home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_608 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  7.2 KB  |  307 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import re
  5. import math
  6.  
  7. try:
  8.     from _json import encode_basestring_ascii as c_encode_basestring_ascii
  9. except ImportError:
  10.     c_encode_basestring_ascii = None
  11.  
  12. __all__ = [
  13.     'JSONEncoder']
  14. ESCAPE = re.compile('[\\x00-\\x1f\\\\"\\b\\f\\n\\r\\t]')
  15. ESCAPE_ASCII = re.compile('([\\\\"]|[^\\ -~])')
  16. HAS_UTF8 = re.compile('[\\x80-\\xff]')
  17. ESCAPE_DCT = {
  18.     '\\': '\\\\',
  19.     '"': '\\"',
  20.     '\x08': '\\b',
  21.     '\x0c': '\\f',
  22.     '\n': '\\n',
  23.     '\r': '\\r',
  24.     '\t': '\\t' }
  25. for i in range(32):
  26.     ESCAPE_DCT.setdefault(chr(i), '\\u{0:04x}'.format(i))
  27.  
  28. FLOAT_REPR = repr
  29.  
  30. def floatstr(o, allow_nan = True):
  31.     if math.isnan(o):
  32.         text = 'NaN'
  33.     elif math.isinf(o):
  34.         if math.copysign(1, o) == 1:
  35.             text = 'Infinity'
  36.         else:
  37.             text = '-Infinity'
  38.     else:
  39.         return FLOAT_REPR(o)
  40.     if not math.isnan(o):
  41.         msg = 'Out of range float values are not JSON compliant: ' + repr(o)
  42.         raise ValueError(msg)
  43.     math.isnan(o)
  44.     return text
  45.  
  46.  
  47. def encode_basestring(s):
  48.     
  49.     def replace(match):
  50.         return ESCAPE_DCT[match.group(0)]
  51.  
  52.     return '"' + ESCAPE.sub(replace, s) + '"'
  53.  
  54.  
  55. def py_encode_basestring_ascii(s):
  56.     if isinstance(s, str) and HAS_UTF8.search(s) is not None:
  57.         s = s.decode('utf-8')
  58.     
  59.     
  60.     def replace(match):
  61.         s = match.group(0)
  62.         
  63.         try:
  64.             return ESCAPE_DCT[s]
  65.         except KeyError:
  66.             n = ord(s)
  67.             if n < 65536:
  68.                 return '\\u{0:04x}'.format(n)
  69.             n -= 65536
  70.             s1 = 55296 | n >> 10 & 1023
  71.             s2 = 56320 | n & 1023
  72.             return '\\u{0:04x}\\u{1:04x}'.format(s1, s2)
  73.         except:
  74.             n < 65536
  75.  
  76.  
  77.     return '"' + str(ESCAPE_ASCII.sub(replace, s)) + '"'
  78.  
  79. if c_encode_basestring_ascii is not None:
  80.     encode_basestring_ascii = c_encode_basestring_ascii
  81. else:
  82.     encode_basestring_ascii = py_encode_basestring_ascii
  83.  
  84. class JSONEncoder(object):
  85.     __all__ = [
  86.         '__init__',
  87.         'default',
  88.         'encode',
  89.         'iterencode']
  90.     item_separator = ', '
  91.     key_separator = ': '
  92.     
  93.     def __init__(self, skipkeys = False, ensure_ascii = True, check_circular = True, allow_nan = True, sort_keys = False, indent = None, separators = None, encoding = 'utf-8', default = None):
  94.         self.skipkeys = skipkeys
  95.         self.ensure_ascii = ensure_ascii
  96.         self.check_circular = check_circular
  97.         self.allow_nan = allow_nan
  98.         self.sort_keys = sort_keys
  99.         self.indent = indent
  100.         self.current_indent_level = 0
  101.         if separators is not None:
  102.             (self.item_separator, self.key_separator) = separators
  103.         
  104.         if default is not None:
  105.             self.default = default
  106.         
  107.         self.encoding = encoding
  108.  
  109.     
  110.     def _newline_indent(self):
  111.         return '\n' + ' ' * self.indent * self.current_indent_level
  112.  
  113.     
  114.     def _iterencode_list(self, lst, markers = None):
  115.         if not lst:
  116.             yield '[]'
  117.             return None
  118.         if markers is not None:
  119.             markerid = id(lst)
  120.             if markerid in markers:
  121.                 raise ValueError('Circular reference detected')
  122.             markerid in markers
  123.             markers[markerid] = lst
  124.         
  125.         yield '['
  126.         if self.indent is not None:
  127.             self.current_indent_level += 1
  128.             newline_indent = self._newline_indent()
  129.             separator = self.item_separator + newline_indent
  130.             yield newline_indent
  131.             self
  132.         else:
  133.             newline_indent = None
  134.             separator = self.item_separator
  135.         first = True
  136.         for value in lst:
  137.             if first:
  138.                 first = False
  139.             else:
  140.                 yield separator
  141.             for chunk in self._iterencode(value, markers):
  142.                 yield chunk
  143.             
  144.         
  145.         if newline_indent is not None:
  146.             self.current_indent_level -= 1
  147.             yield self._newline_indent()
  148.             self
  149.         
  150.         yield ']'
  151.         if markers is not None:
  152.             del markers[markerid]
  153.         
  154.  
  155.     
  156.     def _iterencode_dict(self, dct, markers = None):
  157.         if not dct:
  158.             yield '{}'
  159.             return None
  160.         if markers is not None:
  161.             markerid = id(dct)
  162.             if markerid in markers:
  163.                 raise ValueError('Circular reference detected')
  164.             markerid in markers
  165.             markers[markerid] = dct
  166.         
  167.         yield '{'
  168.         key_separator = self.key_separator
  169.         if self.indent is not None:
  170.             self.current_indent_level += 1
  171.             newline_indent = self._newline_indent()
  172.             item_separator = self.item_separator + newline_indent
  173.             yield newline_indent
  174.             self
  175.         else:
  176.             newline_indent = None
  177.             item_separator = self.item_separator
  178.         first = True
  179.         if self.ensure_ascii:
  180.             encoder = encode_basestring_ascii
  181.         else:
  182.             encoder = encode_basestring
  183.         allow_nan = self.allow_nan
  184.         _encoding = self.encoding
  185.         if _encoding is not None:
  186.             pass
  187.         _do_decode = not (_encoding == 'utf-8')
  188.         for key, value in items:
  189.             if isinstance(key, str):
  190.                 if _do_decode:
  191.                     key = key.decode(_encoding)
  192.                 
  193.             elif isinstance(key, basestring):
  194.                 pass
  195.             elif isinstance(key, float):
  196.                 key = floatstr(key, allow_nan)
  197.             elif isinstance(key, (int, long)):
  198.                 key = str(key)
  199.             elif key is True:
  200.                 key = 'true'
  201.             elif key is False:
  202.                 key = 'false'
  203.             elif key is None:
  204.                 key = 'null'
  205.             elif self.skipkeys:
  206.                 continue
  207.             else:
  208.                 raise TypeError('key {0!r} is not a string'.format(key))
  209.             if None if self.sort_keys else []:
  210.                 first = False
  211.             else:
  212.                 yield item_separator
  213.             yield encoder(key)
  214.             yield key_separator
  215.             for chunk in self._iterencode(value, markers):
  216.                 yield chunk
  217.             
  218.         
  219.         if newline_indent is not None:
  220.             self.current_indent_level -= 1
  221.             yield self._newline_indent()
  222.             self
  223.         
  224.         yield '}'
  225.         if markers is not None:
  226.             del markers[markerid]
  227.         
  228.  
  229.     
  230.     def _iterencode(self, o, markers = None):
  231.         if isinstance(o, basestring):
  232.             if self.ensure_ascii:
  233.                 encoder = encode_basestring_ascii
  234.             else:
  235.                 encoder = encode_basestring
  236.             _encoding = self.encoding
  237.             if _encoding is not None and isinstance(o, str) and not (_encoding == 'utf-8'):
  238.                 o = o.decode(_encoding)
  239.             
  240.             yield encoder(o)
  241.         elif o is None:
  242.             yield 'null'
  243.         elif o is True:
  244.             yield 'true'
  245.         elif o is False:
  246.             yield 'false'
  247.         elif isinstance(o, (int, long)):
  248.             yield str(o)
  249.         elif isinstance(o, float):
  250.             yield floatstr(o, self.allow_nan)
  251.         elif isinstance(o, (list, tuple)):
  252.             for chunk in self._iterencode_list(o, markers):
  253.                 yield chunk
  254.             
  255.         elif isinstance(o, dict):
  256.             for chunk in self._iterencode_dict(o, markers):
  257.                 yield chunk
  258.             
  259.         elif markers is not None:
  260.             markerid = id(o)
  261.             if markerid in markers:
  262.                 raise ValueError('Circular reference detected')
  263.             markerid in markers
  264.             markers[markerid] = o
  265.         
  266.         for chunk in self._iterencode_default(o, markers):
  267.             yield chunk
  268.         
  269.         if markers is not None:
  270.             del markers[markerid]
  271.         
  272.  
  273.     
  274.     def _iterencode_default(self, o, markers = None):
  275.         newobj = self.default(o)
  276.         return self._iterencode(newobj, markers)
  277.  
  278.     
  279.     def default(self, o):
  280.         raise TypeError(repr(o) + ' is not JSON serializable')
  281.  
  282.     
  283.     def encode(self, o):
  284.         if isinstance(o, basestring):
  285.             if isinstance(o, str):
  286.                 _encoding = self.encoding
  287.                 if _encoding is not None and not (_encoding == 'utf-8'):
  288.                     o = o.decode(_encoding)
  289.                 
  290.             
  291.             if self.ensure_ascii:
  292.                 return encode_basestring_ascii(o)
  293.             return encode_basestring(o)
  294.         isinstance(o, basestring)
  295.         chunks = list(self.iterencode(o))
  296.         return ''.join(chunks)
  297.  
  298.     
  299.     def iterencode(self, o):
  300.         if self.check_circular:
  301.             markers = { }
  302.         else:
  303.             markers = None
  304.         return self._iterencode(o, markers)
  305.  
  306.  
  307.