home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / Bureautique / gImageReader / gimagereader_0.9-1_win32.exe / bin / json / decoder.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2011-03-24  |  12KB  |  381 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. '''Implementation of JSONDecoder
  5. '''
  6. import re
  7. import sys
  8. import struct
  9. from json.scanner import make_scanner
  10.  
  11. try:
  12.     from _json import scanstring as c_scanstring
  13. except ImportError:
  14.     c_scanstring = None
  15.  
  16. __all__ = [
  17.     'JSONDecoder']
  18. FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL
  19.  
  20. def _floatconstants():
  21.     _BYTES = '7FF80000000000007FF0000000000000'.decode('hex')
  22.     if sys.byteorder != 'big':
  23.         _BYTES = _BYTES[:8][::-1] + _BYTES[8:][::-1]
  24.     (nan, inf) = struct.unpack('dd', _BYTES)
  25.     return (nan, inf, -inf)
  26.  
  27. (NaN, PosInf, NegInf) = _floatconstants()
  28.  
  29. def linecol(doc, pos):
  30.     lineno = doc.count('\n', 0, pos) + 1
  31.     if lineno == 1:
  32.         colno = pos
  33.     else:
  34.         colno = pos - doc.rindex('\n', 0, pos)
  35.     return (lineno, colno)
  36.  
  37.  
  38. def errmsg(msg, doc, pos, end = None):
  39.     (lineno, colno) = linecol(doc, pos)
  40.     if end is None:
  41.         fmt = '{0}: line {1} column {2} (char {3})'
  42.         return fmt.format(msg, lineno, colno, pos)
  43.     (endlineno, endcolno) = None(doc, end)
  44.     fmt = '{0}: line {1} column {2} - line {3} column {4} (char {5} - {6})'
  45.     return fmt.format(msg, lineno, colno, endlineno, endcolno, pos, end)
  46.  
  47. _CONSTANTS = {
  48.     '-Infinity': NegInf,
  49.     'Infinity': PosInf,
  50.     'NaN': NaN }
  51. STRINGCHUNK = re.compile('(.*?)(["\\\\\\x00-\\x1f])', FLAGS)
  52. BACKSLASH = {
  53.     '"': u'"',
  54.     '\\': u'\\',
  55.     '/': u'/',
  56.     'b': u'\x08',
  57.     'f': u'\x0c',
  58.     'n': u'\n',
  59.     'r': u'\r',
  60.     't': u'\t' }
  61. DEFAULT_ENCODING = 'utf-8'
  62.  
  63. def py_scanstring(s, end, encoding = None, strict = True, _b = BACKSLASH, _m = STRINGCHUNK.match):
  64.     '''Scan the string s for a JSON string. End is the index of the
  65.     character in s after the quote that started the JSON string.
  66.     Unescapes all valid JSON string escape sequences and raises ValueError
  67.     on attempt to decode an invalid string. If strict is False then literal
  68.     control characters are allowed in the string.
  69.  
  70.     Returns a tuple of the decoded string and the index of the character in s
  71.     after the end quote.'''
  72.     if encoding is None:
  73.         encoding = DEFAULT_ENCODING
  74.     chunks = []
  75.     _append = chunks.append
  76.     begin = end - 1
  77.     while None:
  78.         chunk = _m(s, end)
  79.         if chunk is None:
  80.             raise ValueError(errmsg('Unterminated string starting at', s, begin))
  81.         end = chunk.end()
  82.         (content, terminator) = chunk.groups()
  83.         if content:
  84.             if not isinstance(content, unicode):
  85.                 content = unicode(content, encoding)
  86.             _append(content)
  87.         if terminator == '"':
  88.             break
  89.         elif terminator != '\\':
  90.             if strict:
  91.                 msg = 'Invalid control character {0!r} at'.format(terminator)
  92.                 raise ValueError(errmsg(msg, s, end))
  93.             _append(terminator)
  94.             continue
  95.         
  96.         try:
  97.             esc = s[end]
  98.         except IndexError:
  99.             raise ValueError(errmsg('Unterminated string starting at', s, begin))
  100.  
  101.         if esc != 'u':
  102.             
  103.             try:
  104.                 char = _b[esc]
  105.             except KeyError:
  106.                 msg = 'Invalid \\escape: ' + repr(esc)
  107.                 raise ValueError(errmsg(msg, s, end))
  108.  
  109.             end += 1
  110.         else:
  111.             esc = s[end + 1:end + 5]
  112.             next_end = end + 5
  113.             if len(esc) != 4:
  114.                 msg = 'Invalid \\uXXXX escape'
  115.                 raise ValueError(errmsg(msg, s, end))
  116.             uni = int(esc, 16)
  117.             if uni <= uni:
  118.                 pass
  119.             elif uni <= 56319 and sys.maxunicode > 65535:
  120.                 msg = 'Invalid \\uXXXX\\uXXXX surrogate pair'
  121.                 if not s[end + 5:end + 7] == '\\u':
  122.                     raise ValueError(errmsg(msg, s, end))
  123.                 esc2 = s[end + 7:end + 11]
  124.                 if len(esc2) != 4:
  125.                     raise ValueError(errmsg(msg, s, end))
  126.                 uni2 = int(esc2, 16)
  127.                 uni = 65536 + (uni - 55296 << 10 | uni2 - 56320)
  128.                 next_end += 6
  129.             char = unichr(uni)
  130.             end = next_end
  131.         continue
  132.         return (u''.join(chunks), end)
  133.  
  134. if not c_scanstring:
  135.     pass
  136. scanstring = py_scanstring
  137. WHITESPACE = re.compile('[ \\t\\n\\r]*', FLAGS)
  138. WHITESPACE_STR = ' \t\n\r'
  139.  
  140. def JSONObject(s_and_end, encoding, strict, scan_once, object_hook, object_pairs_hook, _w = WHITESPACE.match, _ws = WHITESPACE_STR):
  141.     (s, end) = s_and_end
  142.     pairs = []
  143.     pairs_append = pairs.append
  144.     nextchar = s[end:end + 1]
  145.     if nextchar != '"':
  146.         if nextchar in _ws:
  147.             end = _w(s, end).end()
  148.             nextchar = s[end:end + 1]
  149.         if nextchar == '}':
  150.             return (pairs, end + 1)
  151.         if None != '"':
  152.             raise ValueError(errmsg('Expecting property name', s, end))
  153.     end += 1
  154.     while True:
  155.         (key, end) = scanstring(s, end, encoding, strict)
  156.         if s[end:end + 1] != ':':
  157.             end = _w(s, end).end()
  158.             if s[end:end + 1] != ':':
  159.                 raise ValueError(errmsg('Expecting : delimiter', s, end))
  160.         end += 1
  161.         
  162.         try:
  163.             if s[end] in _ws:
  164.                 end += 1
  165.                 if s[end] in _ws:
  166.                     end = _w(s, end + 1).end()
  167.                 
  168.         except IndexError:
  169.             pass
  170.  
  171.         
  172.         try:
  173.             (value, end) = scan_once(s, end)
  174.         except StopIteration:
  175.             raise ValueError(errmsg('Expecting object', s, end))
  176.  
  177.         pairs_append((key, value))
  178.         
  179.         try:
  180.             nextchar = s[end]
  181.             if nextchar in _ws:
  182.                 end = _w(s, end + 1).end()
  183.                 nextchar = s[end]
  184.         except IndexError:
  185.             nextchar = ''
  186.  
  187.         end += 1
  188.         if nextchar == '}':
  189.             break
  190.         elif nextchar != ',':
  191.             raise ValueError(errmsg('Expecting , delimiter', s, end - 1))
  192.         
  193.         try:
  194.             nextchar = s[end]
  195.             if nextchar in _ws:
  196.                 end += 1
  197.                 nextchar = s[end]
  198.                 if nextchar in _ws:
  199.                     end = _w(s, end + 1).end()
  200.                     nextchar = s[end]
  201.                 
  202.         except IndexError:
  203.             nextchar = ''
  204.  
  205.         end += 1
  206.         if nextchar != '"':
  207.             raise ValueError(errmsg('Expecting property name', s, end - 1))
  208.     if object_pairs_hook is not None:
  209.         result = object_pairs_hook(pairs)
  210.         return (result, end)
  211.     pairs = None(pairs)
  212.     if object_hook is not None:
  213.         pairs = object_hook(pairs)
  214.     return (pairs, end)
  215.  
  216.  
  217. def JSONArray(s_and_end, scan_once, _w = WHITESPACE.match, _ws = WHITESPACE_STR):
  218.     (s, end) = s_and_end
  219.     values = []
  220.     nextchar = s[end:end + 1]
  221.     if nextchar in _ws:
  222.         end = _w(s, end + 1).end()
  223.         nextchar = s[end:end + 1]
  224.     if nextchar == ']':
  225.         return (values, end + 1)
  226.     _append = None.append
  227.     while True:
  228.         
  229.         try:
  230.             (value, end) = scan_once(s, end)
  231.         except StopIteration:
  232.             raise ValueError(errmsg('Expecting object', s, end))
  233.  
  234.         _append(value)
  235.         nextchar = s[end:end + 1]
  236.         if nextchar in _ws:
  237.             end = _w(s, end + 1).end()
  238.             nextchar = s[end:end + 1]
  239.         end += 1
  240.         if nextchar == ']':
  241.             break
  242.         elif nextchar != ',':
  243.             raise ValueError(errmsg('Expecting , delimiter', s, end))
  244.         
  245.         try:
  246.             if s[end] in _ws:
  247.                 end += 1
  248.                 if s[end] in _ws:
  249.                     end = _w(s, end + 1).end()
  250.                 
  251.         continue
  252.         except IndexError:
  253.             continue
  254.         
  255.  
  256.     return (values, end)
  257.  
  258.  
  259. class JSONDecoder(object):
  260.     '''Simple JSON <http://json.org> decoder
  261.  
  262.     Performs the following translations in decoding by default:
  263.  
  264.     +---------------+-------------------+
  265.     | JSON          | Python            |
  266.     +===============+===================+
  267.     | object        | dict              |
  268.     +---------------+-------------------+
  269.     | array         | list              |
  270.     +---------------+-------------------+
  271.     | string        | unicode           |
  272.     +---------------+-------------------+
  273.     | number (int)  | int, long         |
  274.     +---------------+-------------------+
  275.     | number (real) | float             |
  276.     +---------------+-------------------+
  277.     | true          | True              |
  278.     +---------------+-------------------+
  279.     | false         | False             |
  280.     +---------------+-------------------+
  281.     | null          | None              |
  282.     +---------------+-------------------+
  283.  
  284.     It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
  285.     their corresponding ``float`` values, which is outside the JSON spec.
  286.  
  287.     '''
  288.     
  289.     def __init__(self, encoding = None, object_hook = None, parse_float = None, parse_int = None, parse_constant = None, strict = True, object_pairs_hook = None):
  290.         """``encoding`` determines the encoding used to interpret any ``str``
  291.         objects decoded by this instance (utf-8 by default).  It has no
  292.         effect when decoding ``unicode`` objects.
  293.  
  294.         Note that currently only encodings that are a superset of ASCII work,
  295.         strings of other encodings should be passed in as ``unicode``.
  296.  
  297.         ``object_hook``, if specified, will be called with the result
  298.         of every JSON object decoded and its return value will be used in
  299.         place of the given ``dict``.  This can be used to provide custom
  300.         deserializations (e.g. to support JSON-RPC class hinting).
  301.  
  302.         ``object_pairs_hook``, if specified will be called with the result of
  303.         every JSON object decoded with an ordered list of pairs.  The return
  304.         value of ``object_pairs_hook`` will be used instead of the ``dict``.
  305.         This feature can be used to implement custom decoders that rely on the
  306.         order that the key and value pairs are decoded (for example,
  307.         collections.OrderedDict will remember the order of insertion). If
  308.         ``object_hook`` is also defined, the ``object_pairs_hook`` takes
  309.         priority.
  310.  
  311.         ``parse_float``, if specified, will be called with the string
  312.         of every JSON float to be decoded. By default this is equivalent to
  313.         float(num_str). This can be used to use another datatype or parser
  314.         for JSON floats (e.g. decimal.Decimal).
  315.  
  316.         ``parse_int``, if specified, will be called with the string
  317.         of every JSON int to be decoded. By default this is equivalent to
  318.         int(num_str). This can be used to use another datatype or parser
  319.         for JSON integers (e.g. float).
  320.  
  321.         ``parse_constant``, if specified, will be called with one of the
  322.         following strings: -Infinity, Infinity, NaN.
  323.         This can be used to raise an exception if invalid JSON numbers
  324.         are encountered.
  325.  
  326.         If ``strict`` is false (true is the default), then control
  327.         characters will be allowed inside strings.  Control characters in
  328.         this context are those with character codes in the 0-31 range,
  329.         including ``'\\t'`` (tab), ``'\\n'``, ``'\\r'`` and ``'\\0'``.
  330.  
  331.         """
  332.         self.encoding = encoding
  333.         self.object_hook = object_hook
  334.         self.object_pairs_hook = object_pairs_hook
  335.         if not parse_float:
  336.             pass
  337.         self.parse_float = float
  338.         if not parse_int:
  339.             pass
  340.         self.parse_int = int
  341.         if not parse_constant:
  342.             pass
  343.         self.parse_constant = _CONSTANTS.__getitem__
  344.         self.strict = strict
  345.         self.parse_object = JSONObject
  346.         self.parse_array = JSONArray
  347.         self.parse_string = scanstring
  348.         self.scan_once = make_scanner(self)
  349.  
  350.     
  351.     def decode(self, s, _w = WHITESPACE.match):
  352.         '''Return the Python representation of ``s`` (a ``str`` or ``unicode``
  353.         instance containing a JSON document)
  354.  
  355.         '''
  356.         (obj, end) = self.raw_decode(s, idx = _w(s, 0).end())
  357.         end = _w(s, end).end()
  358.         if end != len(s):
  359.             raise ValueError(errmsg('Extra data', s, end, len(s)))
  360.         return obj
  361.  
  362.     
  363.     def raw_decode(self, s, idx = 0):
  364.         '''Decode a JSON document from ``s`` (a ``str`` or ``unicode``
  365.         beginning with a JSON document) and return a 2-tuple of the Python
  366.         representation and the index in ``s`` where the document ended.
  367.  
  368.         This can be used to decode a JSON document from a string that may
  369.         have extraneous data at the end.
  370.  
  371.         '''
  372.         
  373.         try:
  374.             (obj, end) = self.scan_once(s, idx)
  375.         except StopIteration:
  376.             raise ValueError('No JSON object could be decoded')
  377.  
  378.         return (obj, end)
  379.  
  380.  
  381.