���ѧۧݧ�ӧ�� �ާ֧ߧ֧էا֧� - ���֧էѧܧ�ڧ��ӧѧ�� - /home/ukubnwwtacc0unt/chapelbellstudios.com/uploads/cover/json.tar
���ѧ٧ѧ�
encoder.py 0000644 00000037224 15204104504 0006540 0 ustar 00 """Implementation of JSONEncoder """ import re try: from _json import encode_basestring_ascii as c_encode_basestring_ascii except ImportError: c_encode_basestring_ascii = None try: from _json import encode_basestring as c_encode_basestring except ImportError: c_encode_basestring = None try: from _json import make_encoder as c_make_encoder except ImportError: c_make_encoder = None ESCAPE = re.compile(r'[\x00-\x1f\\"\b\f\n\r\t]') ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])') HAS_UTF8 = re.compile(b'[\x80-\xff]') ESCAPE_DCT = { '\\': '\\\\', '"': '\\"', '\b': '\\b', '\f': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t', } for i in range(0x20): ESCAPE_DCT.setdefault(chr(i), '\\u{0:04x}'.format(i)) #ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,)) INFINITY = float('inf') def py_encode_basestring(s): """Return a JSON representation of a Python string """ def replace(match): return ESCAPE_DCT[match.group(0)] return '"' + ESCAPE.sub(replace, s) + '"' encode_basestring = (c_encode_basestring or py_encode_basestring) def py_encode_basestring_ascii(s): """Return an ASCII-only JSON representation of a Python string """ def replace(match): s = match.group(0) try: return ESCAPE_DCT[s] except KeyError: n = ord(s) if n < 0x10000: return '\\u{0:04x}'.format(n) #return '\\u%04x' % (n,) else: # surrogate pair n -= 0x10000 s1 = 0xd800 | ((n >> 10) & 0x3ff) s2 = 0xdc00 | (n & 0x3ff) return '\\u{0:04x}\\u{1:04x}'.format(s1, s2) return '"' + ESCAPE_ASCII.sub(replace, s) + '"' encode_basestring_ascii = ( c_encode_basestring_ascii or py_encode_basestring_ascii) class JSONEncoder(object): """Extensible JSON <http://json.org> encoder for Python data structures. Supports the following objects and types by default: +-------------------+---------------+ | Python | JSON | +===================+===============+ | dict | object | +-------------------+---------------+ | list, tuple | array | +-------------------+---------------+ | str | string | +-------------------+---------------+ | int, float | number | +-------------------+---------------+ | True | true | +-------------------+---------------+ | False | false | +-------------------+---------------+ | None | null | +-------------------+---------------+ To extend this to recognize other objects, subclass and implement a ``.default()`` method with another method that returns a serializable object for ``o`` if possible, otherwise it should call the superclass implementation (to raise ``TypeError``). """ item_separator = ', ' key_separator = ': ' def __init__(self, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None): """Constructor for JSONEncoder, with sensible defaults. If skipkeys is false, then it is a TypeError to attempt encoding of keys that are not str, int, float or None. If skipkeys is True, such items are simply skipped. If ensure_ascii is true, the output is guaranteed to be str objects with all incoming non-ASCII characters escaped. If ensure_ascii is false, the output can contain non-ASCII characters. If check_circular is true, then lists, dicts, and custom encoded objects will be checked for circular references during encoding to prevent an infinite recursion (which would cause an OverflowError). Otherwise, no such check takes place. If allow_nan is true, then NaN, Infinity, and -Infinity will be encoded as such. This behavior is not JSON specification compliant, but is consistent with most JavaScript based encoders and decoders. Otherwise, it will be a ValueError to encode such floats. If sort_keys is true, then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis. If indent is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. None is the most compact representation. If specified, separators should be an (item_separator, key_separator) tuple. The default is (', ', ': ') if *indent* is ``None`` and (',', ': ') otherwise. To get the most compact JSON representation, you should specify (',', ':') to eliminate whitespace. If specified, default is a function that gets called for objects that can't otherwise be serialized. It should return a JSON encodable version of the object or raise a ``TypeError``. """ self.skipkeys = skipkeys self.ensure_ascii = ensure_ascii self.check_circular = check_circular self.allow_nan = allow_nan self.sort_keys = sort_keys self.indent = indent if separators is not None: self.item_separator, self.key_separator = separators elif indent is not None: self.item_separator = ',' if default is not None: self.default = default def default(self, o): """Implement this method in a subclass such that it returns a serializable object for ``o``, or calls the base implementation (to raise a ``TypeError``). For example, to support arbitrary iterators, you could implement default like this:: def default(self, o): try: iterable = iter(o) except TypeError: pass else: return list(iterable) # Let the base class default method raise the TypeError return JSONEncoder.default(self, o) """ raise TypeError("Object of type '%s' is not JSON serializable" % o.__class__.__name__) def encode(self, o): """Return a JSON string representation of a Python data structure. >>> from json.encoder import JSONEncoder >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo": ["bar", "baz"]}' """ # This is for extremely simple cases and benchmarks. if isinstance(o, str): if self.ensure_ascii: return encode_basestring_ascii(o) else: return encode_basestring(o) # This doesn't pass the iterator directly to ''.join() because the # exceptions aren't as detailed. The list call should be roughly # equivalent to the PySequence_Fast that ''.join() would do. chunks = self.iterencode(o, _one_shot=True) if not isinstance(chunks, (list, tuple)): chunks = list(chunks) return ''.join(chunks) def iterencode(self, o, _one_shot=False): """Encode the given object and yield each string representation as available. For example:: for chunk in JSONEncoder().iterencode(bigobject): mysocket.write(chunk) """ if self.check_circular: markers = {} else: markers = None if self.ensure_ascii: _encoder = encode_basestring_ascii else: _encoder = encode_basestring def floatstr(o, allow_nan=self.allow_nan, _repr=float.__repr__, _inf=INFINITY, _neginf=-INFINITY): # Check for specials. Note that this type of test is processor # and/or platform-specific, so do tests which don't depend on the # internals. if o != o: text = 'NaN' elif o == _inf: text = 'Infinity' elif o == _neginf: text = '-Infinity' else: return _repr(o) if not allow_nan: raise ValueError( "Out of range float values are not JSON compliant: " + repr(o)) return text if (_one_shot and c_make_encoder is not None and self.indent is None): _iterencode = c_make_encoder( markers, self.default, _encoder, self.indent, self.key_separator, self.item_separator, self.sort_keys, self.skipkeys, self.allow_nan) else: _iterencode = _make_iterencode( markers, self.default, _encoder, self.indent, floatstr, self.key_separator, self.item_separator, self.sort_keys, self.skipkeys, _one_shot) return _iterencode(o, 0) def _make_iterencode(markers, _default, _encoder, _indent, _floatstr, _key_separator, _item_separator, _sort_keys, _skipkeys, _one_shot, ## HACK: hand-optimized bytecode; turn globals into locals ValueError=ValueError, dict=dict, float=float, id=id, int=int, isinstance=isinstance, list=list, str=str, tuple=tuple, _intstr=int.__str__, ): if _indent is not None and not isinstance(_indent, str): _indent = ' ' * _indent def _iterencode_list(lst, _current_indent_level): if not lst: yield '[]' return if markers is not None: markerid = id(lst) if markerid in markers: raise ValueError("Circular reference detected") markers[markerid] = lst buf = '[' if _indent is not None: _current_indent_level += 1 newline_indent = '\n' + _indent * _current_indent_level separator = _item_separator + newline_indent buf += newline_indent else: newline_indent = None separator = _item_separator first = True for value in lst: if first: first = False else: buf = separator if isinstance(value, str): yield buf + _encoder(value) elif value is None: yield buf + 'null' elif value is True: yield buf + 'true' elif value is False: yield buf + 'false' elif isinstance(value, int): # Subclasses of int/float may override __str__, but we still # want to encode them as integers/floats in JSON. One example # within the standard library is IntEnum. yield buf + _intstr(value) elif isinstance(value, float): # see comment above for int yield buf + _floatstr(value) else: yield buf if isinstance(value, (list, tuple)): chunks = _iterencode_list(value, _current_indent_level) elif isinstance(value, dict): chunks = _iterencode_dict(value, _current_indent_level) else: chunks = _iterencode(value, _current_indent_level) yield from chunks if newline_indent is not None: _current_indent_level -= 1 yield '\n' + _indent * _current_indent_level yield ']' if markers is not None: del markers[markerid] def _iterencode_dict(dct, _current_indent_level): if not dct: yield '{}' return if markers is not None: markerid = id(dct) if markerid in markers: raise ValueError("Circular reference detected") markers[markerid] = dct yield '{' if _indent is not None: _current_indent_level += 1 newline_indent = '\n' + _indent * _current_indent_level item_separator = _item_separator + newline_indent yield newline_indent else: newline_indent = None item_separator = _item_separator first = True if _sort_keys: items = sorted(dct.items(), key=lambda kv: kv[0]) else: items = dct.items() for key, value in items: if isinstance(key, str): pass # JavaScript is weakly typed for these, so it makes sense to # also allow them. Many encoders seem to do something like this. elif isinstance(key, float): # see comment for int/float in _make_iterencode key = _floatstr(key) elif key is True: key = 'true' elif key is False: key = 'false' elif key is None: key = 'null' elif isinstance(key, int): # see comment for int/float in _make_iterencode key = _intstr(key) elif _skipkeys: continue else: raise TypeError("key " + repr(key) + " is not a string") if first: first = False else: yield item_separator yield _encoder(key) yield _key_separator if isinstance(value, str): yield _encoder(value) elif value is None: yield 'null' elif value is True: yield 'true' elif value is False: yield 'false' elif isinstance(value, int): # see comment for int/float in _make_iterencode yield _intstr(value) elif isinstance(value, float): # see comment for int/float in _make_iterencode yield _floatstr(value) else: if isinstance(value, (list, tuple)): chunks = _iterencode_list(value, _current_indent_level) elif isinstance(value, dict): chunks = _iterencode_dict(value, _current_indent_level) else: chunks = _iterencode(value, _current_indent_level) yield from chunks if newline_indent is not None: _current_indent_level -= 1 yield '\n' + _indent * _current_indent_level yield '}' if markers is not None: del markers[markerid] def _iterencode(o, _current_indent_level): if isinstance(o, str): yield _encoder(o) elif o is None: yield 'null' elif o is True: yield 'true' elif o is False: yield 'false' elif isinstance(o, int): # see comment for int/float in _make_iterencode yield _intstr(o) elif isinstance(o, float): # see comment for int/float in _make_iterencode yield _floatstr(o) elif isinstance(o, (list, tuple)): yield from _iterencode_list(o, _current_indent_level) elif isinstance(o, dict): yield from _iterencode_dict(o, _current_indent_level) else: if markers is not None: markerid = id(o) if markerid in markers: raise ValueError("Circular reference detected") markers[markerid] = o o = _default(o) yield from _iterencode(o, _current_indent_level) if markers is not None: del markers[markerid] return _iterencode __init__.py 0000644 00000034074 15204104505 0006661 0 ustar 00 r"""JSON (JavaScript Object Notation) <http://json.org> is a subset of JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data interchange format. :mod:`json` exposes an API familiar to users of the standard library :mod:`marshal` and :mod:`pickle` modules. It is derived from a version of the externally maintained simplejson library. Encoding basic Python object hierarchies:: >>> import json >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}]) '["foo", {"bar": ["baz", null, 1.0, 2]}]' >>> print(json.dumps("\"foo\bar")) "\"foo\bar" >>> print(json.dumps('\u1234')) "\u1234" >>> print(json.dumps('\\')) "\\" >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)) {"a": 0, "b": 0, "c": 0} >>> from io import StringIO >>> io = StringIO() >>> json.dump(['streaming API'], io) >>> io.getvalue() '["streaming API"]' Compact encoding:: >>> import json >>> from collections import OrderedDict >>> mydict = OrderedDict([('4', 5), ('6', 7)]) >>> json.dumps([1,2,3,mydict], separators=(',', ':')) '[1,2,3,{"4":5,"6":7}]' Pretty printing:: >>> import json >>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4)) { "4": 5, "6": 7 } Decoding JSON:: >>> import json >>> obj = ['foo', {'bar': ['baz', None, 1.0, 2]}] >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj True >>> json.loads('"\\"foo\\bar"') == '"foo\x08ar' True >>> from io import StringIO >>> io = StringIO('["streaming API"]') >>> json.load(io)[0] == 'streaming API' True Specializing JSON object decoding:: >>> import json >>> def as_complex(dct): ... if '__complex__' in dct: ... return complex(dct['real'], dct['imag']) ... return dct ... >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}', ... object_hook=as_complex) (1+2j) >>> from decimal import Decimal >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1') True Specializing JSON object encoding:: >>> import json >>> def encode_complex(obj): ... if isinstance(obj, complex): ... return [obj.real, obj.imag] ... raise TypeError(repr(obj) + " is not JSON serializable") ... >>> json.dumps(2 + 1j, default=encode_complex) '[2.0, 1.0]' >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j) '[2.0, 1.0]' >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j)) '[2.0, 1.0]' Using json.tool from the shell to validate and pretty-print:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) """ __version__ = '2.0.9' __all__ = [ 'dump', 'dumps', 'load', 'loads', 'JSONDecoder', 'JSONDecodeError', 'JSONEncoder', ] __author__ = 'Bob Ippolito <bob@redivi.com>' from .decoder import JSONDecoder, JSONDecodeError from .encoder import JSONEncoder import codecs _default_encoder = JSONEncoder( skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, indent=None, separators=None, default=None, ) def dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw): """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a ``.write()``-supporting file-like object). If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, then the strings written to ``fp`` can contain non-ASCII characters if they appear in strings contained in ``obj``. Otherwise, all such characters are escaped in JSON strings. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. """ # cached encoder if (not skipkeys and ensure_ascii and check_circular and allow_nan and cls is None and indent is None and separators is None and default is None and not sort_keys and not kw): iterable = _default_encoder.iterencode(obj) else: if cls is None: cls = JSONEncoder iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii, check_circular=check_circular, allow_nan=allow_nan, indent=indent, separators=separators, default=default, sort_keys=sort_keys, **kw).iterencode(obj) # could accelerate with writelines in some versions of Python, at # a debuggability cost for chunk in iterable: fp.write(chunk) def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw): """Serialize ``obj`` to a JSON formatted ``str``. If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, then the return value can contain non-ASCII characters if they appear in strings contained in ``obj``. Otherwise, all such characters are escaped in JSON strings. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. """ # cached encoder if (not skipkeys and ensure_ascii and check_circular and allow_nan and cls is None and indent is None and separators is None and default is None and not sort_keys and not kw): return _default_encoder.encode(obj) if cls is None: cls = JSONEncoder return cls( skipkeys=skipkeys, ensure_ascii=ensure_ascii, check_circular=check_circular, allow_nan=allow_nan, indent=indent, separators=separators, default=default, sort_keys=sort_keys, **kw).encode(obj) _default_decoder = JSONDecoder(object_hook=None, object_pairs_hook=None) def detect_encoding(b): bstartswith = b.startswith if bstartswith((codecs.BOM_UTF32_BE, codecs.BOM_UTF32_LE)): return 'utf-32' if bstartswith((codecs.BOM_UTF16_BE, codecs.BOM_UTF16_LE)): return 'utf-16' if bstartswith(codecs.BOM_UTF8): return 'utf-8-sig' if len(b) >= 4: if not b[0]: # 00 00 -- -- - utf-32-be # 00 XX -- -- - utf-16-be return 'utf-16-be' if b[1] else 'utf-32-be' if not b[1]: # XX 00 00 00 - utf-32-le # XX 00 00 XX - utf-16-le # XX 00 XX -- - utf-16-le return 'utf-16-le' if b[2] or b[3] else 'utf-32-le' elif len(b) == 2: if not b[0]: # 00 XX - utf-16-be return 'utf-16-be' if not b[1]: # XX 00 - utf-16-le return 'utf-16-le' # default return 'utf-8' def load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw): """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. """ return loads(fp.read(), cls=cls, object_hook=object_hook, parse_float=parse_float, parse_int=parse_int, parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw) def loads(s, *, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw): """Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance containing a JSON document) to a Python object. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. The ``encoding`` argument is ignored and deprecated. """ if isinstance(s, str): if s.startswith('\ufeff'): raise JSONDecodeError("Unexpected UTF-8 BOM (decode using utf-8-sig)", s, 0) else: if not isinstance(s, (bytes, bytearray)): raise TypeError('the JSON object must be str, bytes or bytearray, ' 'not {!r}'.format(s.__class__.__name__)) s = s.decode(detect_encoding(s), 'surrogatepass') if (cls is None and object_hook is None and parse_int is None and parse_float is None and parse_constant is None and object_pairs_hook is None and not kw): return _default_decoder.decode(s) if cls is None: cls = JSONDecoder if object_hook is not None: kw['object_hook'] = object_hook if object_pairs_hook is not None: kw['object_pairs_hook'] = object_pairs_hook if parse_float is not None: kw['parse_float'] = parse_float if parse_int is not None: kw['parse_int'] = parse_int if parse_constant is not None: kw['parse_constant'] = parse_constant return cls(**kw).decode(s) tool.py 0000644 00000003155 15204104505 0006073 0 ustar 00 r"""Command-line tool to validate and pretty-print JSON Usage:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) """ import argparse import collections import json import sys def main(): prog = 'python -m json.tool' description = ('A simple command line interface for json module ' 'to validate and pretty-print JSON objects.') parser = argparse.ArgumentParser(prog=prog, description=description) parser.add_argument('infile', nargs='?', type=argparse.FileType(), help='a JSON file to be validated or pretty-printed') parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'), help='write the output of infile to outfile') parser.add_argument('--sort-keys', action='store_true', default=False, help='sort the output of dictionaries alphabetically by key') options = parser.parse_args() infile = options.infile or sys.stdin outfile = options.outfile or sys.stdout sort_keys = options.sort_keys with infile: try: if sort_keys: obj = json.load(infile) else: obj = json.load(infile, object_pairs_hook=collections.OrderedDict) except ValueError as e: raise SystemExit(e) with outfile: json.dump(obj, outfile, sort_keys=sort_keys, indent=4) outfile.write('\n') if __name__ == '__main__': main() __pycache__/scanner.cpython-38.opt-1.pyc 0000644 00000003641 15204104505 0013774 0 ustar 00 U e5dy � @ sj d Z ddlZzddlmZ W n ek r4 dZY nX dgZe�dejej B ej B �Z dd� Z epde ZdS )zJSON token scanner � N)� make_scannerr z)(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c sv | j � | j�| j� tj�| j� | j�| j�| j�| j �| j �| j �� ��������� � � f dd�� � �fdd�}|S )Nc s� z | | }W n t k r* t|�d �Y nX |dkrD� | |d � �S |dkrf� | |d f� � ����S |dkr��| |d f� �S |dkr�| ||d � dkr�d |d fS |dkr�| ||d � d kr�d |d fS |d k� r�| ||d � d k� r�d|d fS �| |�}|d k �r\|�� \}}}|�s*|�rH�||�p6d |�p@d �}n�|�}||�� fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r�d�|d fS t|��d S )N�"� �{�[�n� Znull�t�trueT�f� ZfalseF� �N� ZNaN�I� ZInfinity�-� z -Infinity)� IndexError� StopIteration�groups�end)�string�idxZnextchar�mZintegerZfracZexp�res� � _scan_onceZ match_number�memo� object_hook�object_pairs_hook� parse_array�parse_constant� parse_float� parse_int� parse_object� parse_string�strict� �$/usr/lib64/python3.8/json/scanner.pyr sF � z#py_make_scanner.<locals>._scan_oncec s z� | |�W �S �� � X d S )N)�clear)r r )r r r( r) � scan_onceA s z"py_make_scanner.<locals>.scan_once) r% r! r& � NUMBER_RE�matchr' r# r$ r" r r r )�contextr+ r( r r) �py_make_scanner s "%r/ ) �__doc__�reZ_jsonr Zc_make_scanner� ImportError�__all__�compile�VERBOSE� MULTILINE�DOTALLr, r/ r( r( r( r) �<module> s �: __pycache__/tool.cpython-38.pyc 0000644 00000003552 15204104506 0012363 0 ustar 00 U e5d� � @ sj d Z ddlZddlZddlZdd� Zedkrfz e� W n. ek rd Z ze�ej � W 5 dZ[X Y nX dS )a Command-line tool to validate and pretty-print JSON Usage:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) � Nc C s4 d} d}t j| |d�}|jddt jdd�dtjd � |jd dt jd dd�d tjd � |jd dddd� |jddddd� |�� }|j}|j }|j }|j }|�� |�~ zJ|r�dd� |D �}n t � |�f}|D ] } t j| ||dd� |�d� q�W n, tk �r } z t| ��W 5 d } ~ X Y nX W 5 Q R X W 5 Q R X d S )Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)�prog� description�infile�?zutf-8)�encodingz-a JSON file to be validated or pretty-printed)�nargs�type�help�default�outfile�wz%write the output of infile to outfilez --sort-keys� store_trueFz5sort the output of dictionaries alphabetically by key)�actionr r z --json-linesz&parse input using the jsonlines formatc s s | ]}t �|�V qd S )N)�json�loads)�.0�line� r �!/usr/lib64/python3.8/json/tool.py� <genexpr>, s zmain.<locals>.<genexpr>� )� sort_keys�indent� )�argparse�ArgumentParser� add_argumentZFileType�sys�stdin�stdout� parse_argsr r r � json_linesr �load�dump�write� ValueError� SystemExit) r r �parserZoptionsr r r r! Zobjs�obj�er r r �main sD � � � � r* �__main__) �__doc__r r r r* �__name__�BrokenPipeError�exc�exit�errnor r r r �<module> s $ __pycache__/scanner.cpython-38.opt-2.pyc 0000644 00000003575 15204104506 0014004 0 ustar 00 U e5dy � @ sf d dl Z zd dlmZ W n ek r0 dZY nX dgZe �de je jB e j B �Z dd� Z ep`e ZdS )� N)� make_scannerr z)(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c sv | j � | j�| j� tj�| j� | j�| j�| j�| j �| j �| j �� ��������� � � f dd�� � �fdd�}|S )Nc s� z | | }W n t k r* t|�d �Y nX |dkrD� | |d � �S |dkrf� | |d f� � ����S |dkr��| |d f� �S |dkr�| ||d � dkr�d |d fS |dkr�| ||d � d kr�d |d fS |d k� r�| ||d � d k� r�d|d fS �| |�}|d k �r\|�� \}}}|�s*|�rH�||�p6d |�p@d �}n�|�}||�� fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r�d�|d fS t|��d S )N�"� �{�[�n� Znull�t�trueT�f� ZfalseF� �N� ZNaN�I� ZInfinity�-� z -Infinity)� IndexError� StopIteration�groups�end)�string�idxZnextchar�mZintegerZfracZexp�res� � _scan_onceZ match_number�memo� object_hook�object_pairs_hook� parse_array�parse_constant� parse_float� parse_int� parse_object� parse_string�strict� �$/usr/lib64/python3.8/json/scanner.pyr sF � z#py_make_scanner.<locals>._scan_oncec s z� | |�W �S �� � X d S )N)�clear)r r )r r r( r) � scan_onceA s z"py_make_scanner.<locals>.scan_once) r% r! r& � NUMBER_RE�matchr' r# r$ r" r r r )�contextr+ r( r r) �py_make_scanner s "%r/ ) �reZ_jsonr Zc_make_scanner� ImportError�__all__�compile�VERBOSE� MULTILINE�DOTALLr, r/ r( r( r( r) �<module> s �: __pycache__/__init__.cpython-38.opt-1.pyc 0000644 00000030502 15204104506 0014077 0 ustar 00 U e5d 8 � @ s� d Z dZdddddddgZd Zd d lmZmZ d d lmZ d dl Z edddddddd�Z dddddddddd� dd�Z dddddddddd� dd�Z eddd�Z dd� Zddddddd�dd�Zddddddd�dd�ZdS )a JSON (JavaScript Object Notation) <http://json.org> is a subset of JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data interchange format. :mod:`json` exposes an API familiar to users of the standard library :mod:`marshal` and :mod:`pickle` modules. It is derived from a version of the externally maintained simplejson library. Encoding basic Python object hierarchies:: >>> import json >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}]) '["foo", {"bar": ["baz", null, 1.0, 2]}]' >>> print(json.dumps("\"foo\bar")) "\"foo\bar" >>> print(json.dumps('\u1234')) "\u1234" >>> print(json.dumps('\\')) "\\" >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)) {"a": 0, "b": 0, "c": 0} >>> from io import StringIO >>> io = StringIO() >>> json.dump(['streaming API'], io) >>> io.getvalue() '["streaming API"]' Compact encoding:: >>> import json >>> mydict = {'4': 5, '6': 7} >>> json.dumps([1,2,3,mydict], separators=(',', ':')) '[1,2,3,{"4":5,"6":7}]' Pretty printing:: >>> import json >>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4)) { "4": 5, "6": 7 } Decoding JSON:: >>> import json >>> obj = ['foo', {'bar': ['baz', None, 1.0, 2]}] >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj True >>> json.loads('"\\"foo\\bar"') == '"foo\x08ar' True >>> from io import StringIO >>> io = StringIO('["streaming API"]') >>> json.load(io)[0] == 'streaming API' True Specializing JSON object decoding:: >>> import json >>> def as_complex(dct): ... if '__complex__' in dct: ... return complex(dct['real'], dct['imag']) ... return dct ... >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}', ... object_hook=as_complex) (1+2j) >>> from decimal import Decimal >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1') True Specializing JSON object encoding:: >>> import json >>> def encode_complex(obj): ... if isinstance(obj, complex): ... return [obj.real, obj.imag] ... raise TypeError(f'Object of type {obj.__class__.__name__} ' ... f'is not JSON serializable') ... >>> json.dumps(2 + 1j, default=encode_complex) '[2.0, 1.0]' >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j) '[2.0, 1.0]' >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j)) '[2.0, 1.0]' Using json.tool from the shell to validate and pretty-print:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) z2.0.9�dump�dumps�load�loads� JSONDecoder�JSONDecodeError� JSONEncoderz Bob Ippolito <bob@redivi.com>� )r r )r � NFT)�skipkeys� ensure_ascii�check_circular� allow_nan�indent� separators�default) r r r r �clsr r r � sort_keysc K s� |sD|rD|rD|rD|dkrD|dkrD|dkrD| dkrD| sD| sDt �| �} n2|dkrPt}|f ||||||| | d�| ���| �} | D ]} |�| � qzdS )a� Serialize ``obj`` as a JSON formatted stream to ``fp`` (a ``.write()``-supporting file-like object). If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, then the strings written to ``fp`` can contain non-ASCII characters if they appear in strings contained in ``obj``. Otherwise, all such characters are escaped in JSON strings. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. N�r r r r r r r r )�_default_encoder� iterencoder �write)�obj�fpr r r r r r r r r �kw�iterable�chunk� r �%/usr/lib64/python3.8/json/__init__.pyr x sD -�������� ���c K st |sB|rB|rB|rB|dkrB|dkrB|dkrB|dkrB| sB| sBt �| �S |dkrNt}|f |||||||| d�| ���| �S )au Serialize ``obj`` to a JSON formatted ``str``. If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, then the return value can contain non-ASCII characters if they appear in strings contained in ``obj``. Otherwise, all such characters are escaped in JSON strings. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. Nr )r �encoder ) r r r r r r r r r r r r r r r � sD ,�������� ���)� object_hook�object_pairs_hookc C s� | j }|tjtjf�rdS |tjtjf�r.dS |tj�r<dS t| �dkr�| d s`| d r\dS dS | d s�| d sx| d r|d S d S n$t| �d kr�| d s�dS | d s�d S d S )Nzutf-32zutf-16z utf-8-sig� r r z utf-16-bez utf-32-be� � z utf-16-lez utf-32-lezutf-8)� startswith�codecs� BOM_UTF32_BE� BOM_UTF32_LE� BOM_UTF16_BE� BOM_UTF16_LE�BOM_UTF8�len)�bZ bstartswithr r r �detect_encoding� s$ r- �r r � parse_float� parse_int�parse_constantr c K s" t | �� f||||||d�|��S )a� Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders. If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. r. )r �read)r r r r/ r0 r1 r r r r r r s ��c K s& t | t�r"| �d�rRtd| d��n0t | ttf�sBtd| jj� ���| � t | �d�} d|krxddl }|j dt d d � |d= |dkr�|dkr�|dkr�|dkr�|dkr�|dkr�|s�t� | �S |dkr�t}|dk r�||d < |dk r�||d < |dk r�||d < |dk �r||d< |dk �r||d< |f |�� | �S )a� Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance containing a JSON document) to a Python object. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders. If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. The ``encoding`` argument is ignored and deprecated since Python 3.1. u z-Unexpected UTF-8 BOM (decode using utf-8-sig)r z5the JSON object must be str, bytes or bytearray, not � surrogatepass�encodingNzF'encoding' is ignored and deprecated. It will be removed in Python 3.9r" )� stacklevelr r r/ r0 r1 )� isinstance�strr$ r �bytes� bytearray� TypeError� __class__�__name__�decoder- �warnings�warn�DeprecationWarning�_default_decoderr ) �sr r r/ r0 r1 r r r> r r r r + sT $ ������� )�__doc__� __version__�__all__� __author__�decoderr r �encoderr r% r r r rA r- r r r r r r �<module> sd a � � � ? � : � � __pycache__/tool.cpython-38.opt-2.pyc 0000644 00000003105 15204104506 0013315 0 ustar 00 U e5d� � @ sf d dl Z d dlZd dlZdd� Zedkrbz e� W n. ek r` Z ze�ej� W 5 dZ[X Y nX dS )� Nc C s4 d} d}t j| |d�}|jddt jdd�dtjd � |jd dt jd dd�d tjd � |jd dddd� |jddddd� |�� }|j}|j }|j }|j }|�� |�~ zJ|r�dd� |D �}n t � |�f}|D ] } t j| ||dd� |�d� q�W n, tk �r } z t| ��W 5 d } ~ X Y nX W 5 Q R X W 5 Q R X d S )Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)�prog� description�infile�?zutf-8)�encodingz-a JSON file to be validated or pretty-printed)�nargs�type�help�default�outfile�wz%write the output of infile to outfilez --sort-keys� store_trueFz5sort the output of dictionaries alphabetically by key)�actionr r z --json-linesz&parse input using the jsonlines formatc s s | ]}t �|�V qd S )N)�json�loads)�.0�line� r �!/usr/lib64/python3.8/json/tool.py� <genexpr>, s zmain.<locals>.<genexpr>� )� sort_keys�indent� )�argparse�ArgumentParser� add_argumentZFileType�sys�stdin�stdout� parse_argsr r r � json_linesr �load�dump�write� ValueError� SystemExit) r r �parserZoptionsr r r r! Zobjs�obj�er r r �main sD � � � � r* �__main__) r r r r* �__name__�BrokenPipeError�exc�exit�errnor r r r �<module> s $ __pycache__/__init__.cpython-38.opt-2.pyc 0000644 00000006241 15204104506 0014103 0 ustar 00 U e5d 8 � @ s� d Z dddddddgZdZd d lmZmZ d d lmZ d d lZeddddd d d d�Z ddddd d d d dd� dd�Z ddddd d d d dd� dd�Z ed d d�Z dd� Z d d d d d d d�dd�Zd d d d d d d�dd�Zd S )z2.0.9�dump�dumps�load�loads� JSONDecoder�JSONDecodeError� JSONEncoderz Bob Ippolito <bob@redivi.com>� )r r )r � NFT)�skipkeys� ensure_ascii�check_circular� allow_nan�indent� separators�default) r r r r �clsr r r � sort_keysc K s� |sD|rD|rD|rD|d krD|d krD|d krD| d krD| sD| sDt �| �} n2|d krPt}|f ||||||| | d�| ���| �} | D ]} |�| � qzd S �N)r r r r r r r r )�_default_encoder� iterencoder �write)�obj�fpr r r r r r r r r �kw�iterable�chunk� r �%/usr/lib64/python3.8/json/__init__.pyr x sD -�������� ���c K st |sB|rB|rB|rB|d krB|d krB|d krB|d krB| sB| sBt �| �S |d krNt}|f |||||||| d�| ���| �S r )r �encoder ) r r r r r r r r r r r r r r r � sD ,�������� ���)� object_hook�object_pairs_hookc C s� | j }|tjtjf�rdS |tjtjf�r.dS |tj�r<dS t| �dkr�| d s`| d r\dS dS | d s�| d sx| d r|d S d S n$t| �d kr�| d s�dS | d s�d S d S )Nzutf-32zutf-16z utf-8-sig� r r z utf-16-bez utf-32-be� � z utf-16-lez utf-32-lezutf-8)� startswith�codecs� BOM_UTF32_BE� BOM_UTF32_LE� BOM_UTF16_BE� BOM_UTF16_LE�BOM_UTF8�len)�bZ bstartswithr r r �detect_encoding� s$ r- �r r � parse_float� parse_int�parse_constantr c K s" t | �� f||||||d�|��S )Nr. )r �read)r r r r/ r0 r1 r r r r r r s ��c K s& t | t�r"| �d�rRtd| d��n0t | ttf�sBtd| jj� ���| � t | �d�} d|krxdd l }|j dt dd � |d= |d kr�|d kr�|d kr�|d kr�|d kr�|d kr�|s�t� | �S |d kr�t}|d k r�||d < |d k r�||d < |d k r�||d < |d k �r||d < |d k �r||d< |f |�� | �S )Nu z-Unexpected UTF-8 BOM (decode using utf-8-sig)r z5the JSON object must be str, bytes or bytearray, not � surrogatepass�encodingzF'encoding' is ignored and deprecated. It will be removed in Python 3.9r" )� stacklevelr r r/ r0 r1 )� isinstance�strr$ r �bytes� bytearray� TypeError� __class__�__name__�decoder- �warnings�warn�DeprecationWarning�_default_decoderr ) �sr r r/ r0 r1 r r r> r r r r + sT $ ������� )� __version__�__all__� __author__�decoderr r �encoderr r% r r r rA r- r r r r r r �<module>b sb � � � ? � : � � __pycache__/decoder.cpython-38.opt-1.pyc 0000644 00000023166 15204104506 0013755 0 ustar 00 U e5d�0 � @ s d Z ddlZddlmZ zddlmZ W n ek r@ dZY nX ddgZej ej B ej B Z e d�Ze d�Ze d �ZG d d� de�Zeeed �Ze�d e �Zd dddddddd�Zdd� Zdeejfdd�Zep�eZe�de �Zd Zdejefd d �Z ejefd d �Z G d!d� de �Z dS )"z Implementation of JSONDecoder � N)�scanner)� scanstring� JSONDecoder�JSONDecodeError�nan�infz-infc @ s e Zd ZdZdd� Zdd� ZdS )r a Subclass of ValueError with the following additional properties: msg: The unformatted error message doc: The JSON document being parsed pos: The start index of doc where parsing failed lineno: The line corresponding to pos colno: The column corresponding to pos c C sb |� dd|�d }||�dd|� }d||||f }t�| |� || _|| _|| _|| _|| _d S )N� r � z %s: line %d column %d (char %d)) �count�rfind� ValueError�__init__�msg�doc�pos�lineno�colno)�selfr r r r r �errmsg� r �$/usr/lib64/python3.8/json/decoder.pyr s zJSONDecodeError.__init__c C s | j | j| j| jffS )N)� __class__r r r )r r r r � __reduce__* s zJSONDecodeError.__reduce__N)�__name__� __module__� __qualname__�__doc__r r r r r r r s )z -InfinityZInfinity�NaNz(.*?)(["\\\x00-\x1f])�"�\�/�� r � � )r r r �b�f�n�r�tc C sb | |d |d � }t |�dkrN|d dkrNz t|d�W S tk rL Y nX d}t|| |��d S )Nr � � ZxX� zInvalid \uXXXX escape)�len�intr r )�sr �escr r r r � _decode_uXXXX; s r1 Tc C s� g }|j }|d }|| |�}|dkr0td| |��|�� }|�� \} } | rP|| � | dkr^�q�n.| dkr�|r�d�| �} t| | |��n || � qz | | } W n" tk r� td| |�d�Y nX | dk�rz || } W n* tk r� d�| �} t| | |��Y nX |d7 }n�t| |�}|d 7 }d | k�r2d k�r�n n`| ||d � d k�r�t| |d �}d| k�rrdk�r�n n d|d d> |d B }|d7 }t|�} || � qd� |�|fS )a� Scan the string s for a JSON string. End is the index of the character in s after the quote that started the JSON string. Unescapes all valid JSON string escape sequences and raises ValueError on attempt to decode an invalid string. If strict is False then literal control characters are allowed in the string. Returns a tuple of the decoded string and the index of the character in s after the end quote.r Nz Unterminated string starting atr r z"Invalid control character {0!r} at�uzInvalid \escape: {0!r}r* i � i�� � z\ui � i�� i � � � ) �appendr �end�groups�format� IndexError�KeyErrorr1 �chr�join)r/ r8 �strictZ_b�_mZchunks�_appendZbegin�chunkZcontent� terminatorr r0 �charZuniZuni2r r r � py_scanstringE sX �� 2 rE z [ \t\n\r]*z c C s� | \}} g } | j } |d kr i }|j} || | d � } | dkr�| |krb||| ��� } || | d � } | dkr�|d k r�|| �}|| d fS i } |d k r�|| �} | | d fS | dkr�td|| ��| d7 } t|| |�\}} | ||�}|| | d � dk�r"||| ��� } || | d � dk�r"td|| ��| d7 } z:|| |k�rb| d7 } || |k�rb||| d ��� } W n tk �rz Y nX z||| �\}} W n4 tk �r� } ztd||j�d �W 5 d }~X Y nX | ||f� z0|| } | |k�r�||| d ��� } || } W n tk �r d} Y nX | d7 } | dk�r4�q�n| d k�rNtd || d ��||| ��� } || | d � } | d7 } | dkr�td|| d ��q�|d k �r�|| �}|| fS t| �} |d k �r�|| �} | | fS ) Nr r �}z1Expecting property name enclosed in double quotes�:zExpecting ':' delimiter�Expecting valuer6 �,�Expecting ',' delimiter) r7 � setdefaultr8 r r r; � StopIteration�value�dict)� s_and_endr? � scan_once� object_hook�object_pairs_hook�memo�_w�_wsr/ r8 ZpairsZ pairs_appendZmemo_get�nextchar�result�keyrM �errr r r � JSONObject� s� � " � rZ c C st | \}}g }|||d � }||krF|||d �� � }|||d � }|dkrZ||d fS |j}z|||�\} }W n2 tk r� } ztd|| j�d �W 5 d } ~ X Y nX || � |||d � }||kr�|||d �� � }|||d � }|d7 }|dkr��qln|dk�rtd||d ��z:|| |k�rP|d7 }|| |k�rP|||d �� � }W q` tk �rh Y q`X q`||fS )Nr �]rH rI rJ )r8 r7 rL r rM r; ) rO rP rT rU r/ r8 �valuesrV rA rM rY r r r � JSONArray� s> " r] c @ s@ e Zd ZdZddddddd�dd�Zejfdd�Zd d d �ZdS ) r a Simple JSON <http://json.org> decoder Performs the following translations in decoding by default: +---------------+-------------------+ | JSON | Python | +===============+===================+ | object | dict | +---------------+-------------------+ | array | list | +---------------+-------------------+ | string | str | +---------------+-------------------+ | number (int) | int | +---------------+-------------------+ | number (real) | float | +---------------+-------------------+ | true | True | +---------------+-------------------+ | false | False | +---------------+-------------------+ | null | None | +---------------+-------------------+ It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as their corresponding ``float`` values, which is outside the JSON spec. NT)rQ � parse_float� parse_int�parse_constantr? rR c C sZ || _ |p t| _|pt| _|p"tj| _|| _|| _ t | _ t | _ t| _i | _t�| �| _dS )a� ``object_hook``, if specified, will be called with the result of every JSON object decoded and its return value will be used in place of the given ``dict``. This can be used to provide custom deserializations (e.g. to support JSON-RPC class hinting). ``object_pairs_hook``, if specified will be called with the result of every JSON object decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders. If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. If ``strict`` is false (true is the default), then control characters will be allowed inside strings. Control characters in this context are those with character codes in the 0-31 range, including ``'\t'`` (tab), ``'\n'``, ``'\r'`` and ``'\0'``. N)rQ �floatr^ r. r_ � _CONSTANTS� __getitem__r` r? rR rZ Z parse_objectr] Z parse_arrayr Z parse_stringrS r Z make_scannerrP )r rQ r^ r_ r` r? rR r r r r s # zJSONDecoder.__init__c C sF | j |||d��� d�\}}|||��� }|t|�krBtd||��|S )zlReturn the Python representation of ``s`` (a ``str`` instance containing a JSON document). r )�idxz Extra data)� raw_decoder8 r- r )r r/ rT �objr8 r r r �decodeL s zJSONDecoder.decoder c C sP z| � ||�\}}W n2 tk rF } ztd||j�d�W 5 d}~X Y nX ||fS )a= Decode a JSON document from ``s`` (a ``str`` beginning with a JSON document) and return a 2-tuple of the Python representation and the index in ``s`` where the document ended. This can be used to decode a JSON document from a string that may have extraneous data at the end. rH N)rP rL r rM )r r/ rd rf r8 rY r r r re W s "zJSONDecoder.raw_decode)r ) r r r r r � WHITESPACE�matchrg re r r r r r � s � 0 ) r �reZjsonr Z_jsonr Z c_scanstring� ImportError�__all__�VERBOSE� MULTILINE�DOTALL�FLAGSra r ZPosInfZNegInfr r rb �compileZ STRINGCHUNKZ BACKSLASHr1 ri rE rh ZWHITESPACE_STRrZ r] �objectr r r r r �<module> sP � � � = � Q% __pycache__/encoder.cpython-38.opt-1.pyc 0000644 00000025645 15204104507 0013774 0 ustar 00 U e5d�> � @ s> d Z ddlZzddlmZ W n ek r4 dZY nX zddlmZ W n ek r^ dZY nX zddlmZ W n ek r� dZ Y nX e� d�Z e� d�Z e� d�Z d d d d d ddd�Zed�D ]Ze�ee�d�e�� q�ed�Zdd� Zep�eZdd� Ze�peZG dd� de�Zeeee e e e e e!e j"f dd�Z#dS ) z Implementation of JSONEncoder � N)�encode_basestring_ascii)�encode_basestring)� make_encoderz[\x00-\x1f\\"\b\f\n\r\t]z([\\"]|[^\ -~])s [�-�]z\\z\"z\bz\fz\nz\rz\t)�\�"�� � � � � � \u{0:04x}�infc C s dd� }dt �|| � d S )z5Return a JSON representation of a Python string c S s t | �d� S )Nr )� ESCAPE_DCT�group)�match� r �$/usr/lib64/python3.8/json/encoder.py�replace( s z%py_encode_basestring.<locals>.replacer )�ESCAPE�sub��sr r r r �py_encode_basestring$ s r c C s dd� }dt �|| � d S )zAReturn an ASCII-only JSON representation of a Python string c S s� | � d�}z t| W S tk rz t|�}|dk rBd�|� Y S |d8 }d|d? d@ B }d|d@ B }d�||� Y S Y nX d S ) Nr i r i � � i� i � z\u{0:04x}\u{1:04x})r r �KeyError�ord�format)r r �n�s1�s2r r r r 4 s z+py_encode_basestring_ascii.<locals>.replacer )� ESCAPE_ASCIIr r r r r �py_encode_basestring_ascii0 s r" c @ sN e Zd ZdZdZdZddddddddd�dd �Zd d � Zd d � Zddd�Z dS )� JSONEncoderaZ Extensible JSON <http://json.org> encoder for Python data structures. Supports the following objects and types by default: +-------------------+---------------+ | Python | JSON | +===================+===============+ | dict | object | +-------------------+---------------+ | list, tuple | array | +-------------------+---------------+ | str | string | +-------------------+---------------+ | int, float | number | +-------------------+---------------+ | True | true | +-------------------+---------------+ | False | false | +-------------------+---------------+ | None | null | +-------------------+---------------+ To extend this to recognize other objects, subclass and implement a ``.default()`` method with another method that returns a serializable object for ``o`` if possible, otherwise it should call the superclass implementation (to raise ``TypeError``). z, z: FTN)�skipkeys� ensure_ascii�check_circular� allow_nan� sort_keys�indent� separators�defaultc C sZ || _ || _|| _|| _|| _|| _|dk r:|\| _| _n|dk rHd| _|dk rV|| _dS )a� Constructor for JSONEncoder, with sensible defaults. If skipkeys is false, then it is a TypeError to attempt encoding of keys that are not str, int, float or None. If skipkeys is True, such items are simply skipped. If ensure_ascii is true, the output is guaranteed to be str objects with all incoming non-ASCII characters escaped. If ensure_ascii is false, the output can contain non-ASCII characters. If check_circular is true, then lists, dicts, and custom encoded objects will be checked for circular references during encoding to prevent an infinite recursion (which would cause an OverflowError). Otherwise, no such check takes place. If allow_nan is true, then NaN, Infinity, and -Infinity will be encoded as such. This behavior is not JSON specification compliant, but is consistent with most JavaScript based encoders and decoders. Otherwise, it will be a ValueError to encode such floats. If sort_keys is true, then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis. If indent is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. None is the most compact representation. If specified, separators should be an (item_separator, key_separator) tuple. The default is (', ', ': ') if *indent* is ``None`` and (',', ': ') otherwise. To get the most compact JSON representation, you should specify (',', ':') to eliminate whitespace. If specified, default is a function that gets called for objects that can't otherwise be serialized. It should return a JSON encodable version of the object or raise a ``TypeError``. N�,) r$ r% r& r' r( r) �item_separator� key_separatorr+ ) �selfr$ r% r& r' r( r) r* r+ r r r �__init__h s +zJSONEncoder.__init__c C s t d|jj� d���dS )al Implement this method in a subclass such that it returns a serializable object for ``o``, or calls the base implementation (to raise a ``TypeError``). For example, to support arbitrary iterators, you could implement default like this:: def default(self, o): try: iterable = iter(o) except TypeError: pass else: return list(iterable) # Let the base class default method raise the TypeError return JSONEncoder.default(self, o) zObject of type z is not JSON serializableN)� TypeError� __class__�__name__)r/ �or r r r+ � s zJSONEncoder.defaultc C sN t |t�r | jrt|�S t|�S | j|dd�}t |ttf�sDt|�}d�|�S )z�Return a JSON string representation of a Python data structure. >>> from json.encoder import JSONEncoder >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo": ["bar", "baz"]}' T)� _one_shot� ) � isinstance�strr% r r � iterencode�list�tuple�join)r/ r4 �chunksr r r �encode� s zJSONEncoder.encodec C s� | j r i }nd}| jr t}nt}| jtjtt fdd�}|rvtdk rv| j dkrvt|| j || j | j | j | j | j| j� }n&t|| j || j || j | j | j | j|� }||d�S )z�Encode the given object and yield each string representation as available. For example:: for chunk in JSONEncoder().iterencode(bigobject): mysocket.write(chunk) Nc S sJ | | krd}n$| |kr d}n| |kr*d}n|| �S |sFt dt| � ��|S )NZNaNZInfinityz -Infinityz2Out of range float values are not JSON compliant: )� ValueError�repr)r4 r' Z_reprZ_infZ_neginf�textr r r �floatstr� s ��z(JSONEncoder.iterencode.<locals>.floatstrr )r& r% r r r' �float�__repr__�INFINITY�c_make_encoderr) r+ r. r- r( r$ �_make_iterencode)r/ r4 r5 �markers�_encoderrB � _iterencoder r r r9 � sL � � � �zJSONEncoder.iterencode)F) r3 � __module__� __qualname__�__doc__r- r. r0 r+ r> r9 r r r r r# I s � 8r# c s� �d k r����sd� �� �������� � ��������fdd�� � �������� � � � � ��������fdd��� ������� � ��������fdd���S )N� c 3 s� | sdV d S �d k r6� | �}|�kr.� d��| �|< d}�d k rh|d7 }d�| }�| }||7 }nd }�}d}| D ]�}|r�d}n|}� |��r�|�|� V qx|d kr�|d V qx|dkr�|d V qx|dkr�|d V qx� |� �r�|�|� V qx� |� ��r|�|� V qx|V � |��f��r8�||�}n"� |� ��rP�||�}n �||�}|E d H qx|d k �r�|d8 }d�| V d V �d k �r��|= d S ) Nz[]�Circular reference detected�[� r TF�null�true�false�]r ) Zlst�_current_indent_level�markeridZbuf�newline_indentZ separator�first�valuer= )r? rI � _floatstr�_indent�_intstr�_item_separatorrJ �_iterencode_dict�_iterencode_list�dictrC �id�intr7 r: rH r8 r; r r r` s\ z*_make_iterencode.<locals>._iterencode_listc 3 s: | sdV d S �d k r6�| �}|�kr.� d��| �|< dV �d k rh|d7 }d�| }�| }|V nd }�}d}� r�t | �� �}n| �� }|D �]j\}}�|��r�nn�|� �r��|�}nZ|dkr�d}nL|dkr�d }n>|d kr�d }n0�|��r��|�}n � �rq�ntd |jj� ���|�r"d}n|V �|�V � V �|���rP�|�V q�|d k�rbd V q�|dk�rtdV q�|dk�r�d V q��|���r��|�V q��|� ��r��|�V q��|��f��r҈||�} n"�|� ��r�||�} n �||�} | E d H q�|d k �r |d8 }d�| V d V �d k �r6�|= d S ) Nz{}rO �{rQ r TrS FrT rR z0keys must be str, int, float, bool or None, not �})�sorted�itemsr1 r2 r3 ) ZdctrV rW rX r- rY rg �keyrZ r= )r? rI r[ r\ r] r^ rJ r_ r` �_key_separator� _skipkeys� _sort_keysra rC rb rc r7 r: rH r8 r; r r r_ M s� z*_make_iterencode.<locals>._iterencode_dictc 3 s � | ��r�| �V n�| d kr&dV n�| dkr6dV n�| dkrFdV n�� | � �r\�| �V n�� | � �rr�| �V n�� | � �f�r��| |�E d H nj� | ��r��| |�E d H nN�d k rֈ | �}|�krΈ d��| �|< �| �} �| |�E d H �d k r��|= d S )NrR TrS FrT rO r )r4 rV rW )r? �_defaultrI r[ r] rJ r_ r` ra rC rb rc r7 r: rH r8 r; r r rJ � s2 z%_make_iterencode.<locals>._iterencoder )rH rl rI r\ r[ ri r^ rk rj r5 r? ra rC rb rc r7 r: r8 r; r] r )r? rl rI r[ r\ r] r^ rJ r_ r` ri rj rk ra rC rb rc r7 r: rH r8 r; r rG s .84P, rG )$rM �reZ_jsonr Zc_encode_basestring_ascii� ImportErrorr Zc_encode_basestringr rF �compiler r! ZHAS_UTF8r �range�i� setdefault�chrr rC rE r r" �objectr# r? ra rb rc r7 r: r8 r; rD rG r r r r �<module> sZ � � >� __pycache__/decoder.cpython-38.opt-2.pyc 0000644 00000013341 15204104507 0013751 0 ustar 00 U e5d�0 � @ s d dl Z d dlmZ zd dlmZ W n ek r< dZY nX ddgZe je j B e j B Z e d�Z e d�Ze d�ZG d d� de�Zeee d �Ze �d e �Zd d ddddddd�Zdd� Zdeejfdd�Zep�eZe �de �ZdZdejefd d �Zejefd d �Z G d d� de �Z dS )!� N)�scanner)� scanstring� JSONDecoder�JSONDecodeError�nan�infz-infc @ s e Zd Zdd� Zdd� ZdS )r c C sb |� dd|�d }||�dd|� }d||||f }t�| |� || _|| _|| _|| _|| _d S )N� r � z %s: line %d column %d (char %d)) �count�rfind� ValueError�__init__�msg�doc�pos�lineno�colno)�selfr r r r r �errmsg� r �$/usr/lib64/python3.8/json/decoder.pyr s zJSONDecodeError.__init__c C s | j | j| j| jffS �N)� __class__r r r )r r r r � __reduce__* s zJSONDecodeError.__reduce__N)�__name__� __module__� __qualname__r r r r r r r s )z -InfinityZInfinity�NaNz(.*?)(["\\\x00-\x1f])�"�\�/�� r � � )r r r �b�f�n�r�tc C sb | |d |d � }t |�dkrN|d dkrNz t|d�W S tk rL Y nX d}t|| |��d S )Nr � � ZxX� zInvalid \uXXXX escape)�len�intr r )�sr �escr r r r � _decode_uXXXX; s r1 Tc C s� g }|j }|d }|| |�}|d kr0td| |��|�� }|�� \} } | rP|| � | dkr^�q�n.| dkr�|r�d�| �} t| | |��n || � qz | | } W n" tk r� td| |�d �Y nX | dk�rz || } W n* tk r� d�| �} t| | |��Y nX |d7 }n�t| |�}|d7 }d | k�r2d k�r�n n`| ||d � d k�r�t| |d �}d | k�rrdk�r�n n d|d d> |d B }|d7 }t|�} || � qd� |�|fS )Nr z Unterminated string starting atr r z"Invalid control character {0!r} at�uzInvalid \escape: {0!r}r* i � i�� � z\ui � i�� i � � � ) �appendr �end�groups�format� IndexError�KeyErrorr1 �chr�join)r/ r8 �strictZ_b�_mZchunks�_appendZbegin�chunkZcontent� terminatorr r0 �charZuniZuni2r r r � py_scanstringE sX �� 2 rE z [ \t\n\r]*z c C s� | \}} g } | j } |d kr i }|j} || | d � } | dkr�| |krb||| ��� } || | d � } | dkr�|d k r�|| �}|| d fS i } |d k r�|| �} | | d fS | dkr�td|| ��| d7 } t|| |�\}} | ||�}|| | d � dk�r"||| ��� } || | d � dk�r"td|| ��| d7 } z:|| |k�rb| d7 } || |k�rb||| d ��� } W n tk �rz Y nX z||| �\}} W n4 tk �r� } ztd||j�d �W 5 d }~X Y nX | ||f� z0|| } | |k�r�||| d ��� } || } W n tk �r d} Y nX | d7 } | dk�r4�q�n| d k�rNtd || d ��||| ��� } || | d � } | d7 } | dkr�td|| d ��q�|d k �r�|| �}|| fS t| �} |d k �r�|| �} | | fS ) Nr r �}z1Expecting property name enclosed in double quotes�:zExpecting ':' delimiter�Expecting valuer6 �,�Expecting ',' delimiter) r7 � setdefaultr8 r r r; � StopIteration�value�dict)� s_and_endr? � scan_once� object_hook�object_pairs_hook�memo�_w�_wsr/ r8 ZpairsZ pairs_appendZmemo_get�nextchar�result�keyrM �errr r r � JSONObject� s� � " � rZ c C st | \}}g }|||d � }||krF|||d �� � }|||d � }|dkrZ||d fS |j}z|||�\} }W n2 tk r� } ztd|| j�d �W 5 d } ~ X Y nX || � |||d � }||kr�|||d �� � }|||d � }|d7 }|dkr��qln|dk�rtd||d ��z:|| |k�rP|d7 }|| |k�rP|||d �� � }W q` tk �rh Y q`X q`||fS )Nr �]rH rI rJ )r8 r7 rL r rM r; ) rO rP rT rU r/ r8 �valuesrV rA rM rY r r r � JSONArray� s> " r] c @ s< e Zd Zddddddd�dd�Zejfdd�Zd d d �ZdS ) r NT)rQ � parse_float� parse_int�parse_constantr? rR c C sZ || _ |p t| _|pt| _|p"tj| _|| _|| _ t | _ t | _ t| _i | _t�| �| _d S r )rQ �floatr^ r. r_ � _CONSTANTS� __getitem__r` r? rR rZ Z parse_objectr] Z parse_arrayr Z parse_stringrS r Z make_scannerrP )r rQ r^ r_ r` r? rR r r r r s # zJSONDecoder.__init__c C sF | j |||d��� d�\}}|||��� }|t|�krBtd||��|S )Nr )�idxz Extra data)� raw_decoder8 r- r )r r/ rT �objr8 r r r �decodeL s zJSONDecoder.decoder c C sP z| � ||�\}}W n2 tk rF } ztd||j�d �W 5 d }~X Y nX ||fS )NrH )rP rL r rM )r r/ rd rf r8 rY r r r re W s "zJSONDecoder.raw_decode)r )r r r r � WHITESPACE�matchrg re r r r r r � s � 0 ) �reZjsonr Z_jsonr Z c_scanstring� ImportError�__all__�VERBOSE� MULTILINE�DOTALL�FLAGSra r ZPosInfZNegInfr r rb �compileZ STRINGCHUNKZ BACKSLASHr1 ri rE rh ZWHITESPACE_STRrZ r] �objectr r r r r �<module> sN � � � = � Q% __pycache__/tool.cpython-38.opt-1.pyc 0000644 00000003552 15204104507 0013323 0 ustar 00 U e5d� � @ sj d Z ddlZddlZddlZdd� Zedkrfz e� W n. ek rd Z ze�ej � W 5 dZ[X Y nX dS )a Command-line tool to validate and pretty-print JSON Usage:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) � Nc C s4 d} d}t j| |d�}|jddt jdd�dtjd � |jd dt jd dd�d tjd � |jd dddd� |jddddd� |�� }|j}|j }|j }|j }|�� |�~ zJ|r�dd� |D �}n t � |�f}|D ] } t j| ||dd� |�d� q�W n, tk �r } z t| ��W 5 d } ~ X Y nX W 5 Q R X W 5 Q R X d S )Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)�prog� description�infile�?zutf-8)�encodingz-a JSON file to be validated or pretty-printed)�nargs�type�help�default�outfile�wz%write the output of infile to outfilez --sort-keys� store_trueFz5sort the output of dictionaries alphabetically by key)�actionr r z --json-linesz&parse input using the jsonlines formatc s s | ]}t �|�V qd S )N)�json�loads)�.0�line� r �!/usr/lib64/python3.8/json/tool.py� <genexpr>, s zmain.<locals>.<genexpr>� )� sort_keys�indent� )�argparse�ArgumentParser� add_argumentZFileType�sys�stdin�stdout� parse_argsr r r � json_linesr �load�dump�write� ValueError� SystemExit) r r �parserZoptionsr r r r! Zobjs�obj�er r r �main sD � � � � r* �__main__) �__doc__r r r r* �__name__�BrokenPipeError�exc�exit�errnor r r r �<module> s $ __pycache__/encoder.cpython-38.pyc 0000644 00000025645 15204104507 0013035 0 ustar 00 U e5d�> � @ s> d Z ddlZzddlmZ W n ek r4 dZY nX zddlmZ W n ek r^ dZY nX zddlmZ W n ek r� dZ Y nX e� d�Z e� d�Z e� d�Z d d d d d ddd�Zed�D ]Ze�ee�d�e�� q�ed�Zdd� Zep�eZdd� Ze�peZG dd� de�Zeeee e e e e e!e j"f dd�Z#dS ) z Implementation of JSONEncoder � N)�encode_basestring_ascii)�encode_basestring)� make_encoderz[\x00-\x1f\\"\b\f\n\r\t]z([\\"]|[^\ -~])s [�-�]z\\z\"z\bz\fz\nz\rz\t)�\�"�� � � � � � \u{0:04x}�infc C s dd� }dt �|| � d S )z5Return a JSON representation of a Python string c S s t | �d� S )Nr )� ESCAPE_DCT�group)�match� r �$/usr/lib64/python3.8/json/encoder.py�replace( s z%py_encode_basestring.<locals>.replacer )�ESCAPE�sub��sr r r r �py_encode_basestring$ s r c C s dd� }dt �|| � d S )zAReturn an ASCII-only JSON representation of a Python string c S s� | � d�}z t| W S tk rz t|�}|dk rBd�|� Y S |d8 }d|d? d@ B }d|d@ B }d�||� Y S Y nX d S ) Nr i r i � � i� i � z\u{0:04x}\u{1:04x})r r �KeyError�ord�format)r r �n�s1�s2r r r r 4 s z+py_encode_basestring_ascii.<locals>.replacer )� ESCAPE_ASCIIr r r r r �py_encode_basestring_ascii0 s r" c @ sN e Zd ZdZdZdZddddddddd�dd �Zd d � Zd d � Zddd�Z dS )� JSONEncoderaZ Extensible JSON <http://json.org> encoder for Python data structures. Supports the following objects and types by default: +-------------------+---------------+ | Python | JSON | +===================+===============+ | dict | object | +-------------------+---------------+ | list, tuple | array | +-------------------+---------------+ | str | string | +-------------------+---------------+ | int, float | number | +-------------------+---------------+ | True | true | +-------------------+---------------+ | False | false | +-------------------+---------------+ | None | null | +-------------------+---------------+ To extend this to recognize other objects, subclass and implement a ``.default()`` method with another method that returns a serializable object for ``o`` if possible, otherwise it should call the superclass implementation (to raise ``TypeError``). z, z: FTN)�skipkeys� ensure_ascii�check_circular� allow_nan� sort_keys�indent� separators�defaultc C sZ || _ || _|| _|| _|| _|| _|dk r:|\| _| _n|dk rHd| _|dk rV|| _dS )a� Constructor for JSONEncoder, with sensible defaults. If skipkeys is false, then it is a TypeError to attempt encoding of keys that are not str, int, float or None. If skipkeys is True, such items are simply skipped. If ensure_ascii is true, the output is guaranteed to be str objects with all incoming non-ASCII characters escaped. If ensure_ascii is false, the output can contain non-ASCII characters. If check_circular is true, then lists, dicts, and custom encoded objects will be checked for circular references during encoding to prevent an infinite recursion (which would cause an OverflowError). Otherwise, no such check takes place. If allow_nan is true, then NaN, Infinity, and -Infinity will be encoded as such. This behavior is not JSON specification compliant, but is consistent with most JavaScript based encoders and decoders. Otherwise, it will be a ValueError to encode such floats. If sort_keys is true, then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis. If indent is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. None is the most compact representation. If specified, separators should be an (item_separator, key_separator) tuple. The default is (', ', ': ') if *indent* is ``None`` and (',', ': ') otherwise. To get the most compact JSON representation, you should specify (',', ':') to eliminate whitespace. If specified, default is a function that gets called for objects that can't otherwise be serialized. It should return a JSON encodable version of the object or raise a ``TypeError``. N�,) r$ r% r& r' r( r) �item_separator� key_separatorr+ ) �selfr$ r% r& r' r( r) r* r+ r r r �__init__h s +zJSONEncoder.__init__c C s t d|jj� d���dS )al Implement this method in a subclass such that it returns a serializable object for ``o``, or calls the base implementation (to raise a ``TypeError``). For example, to support arbitrary iterators, you could implement default like this:: def default(self, o): try: iterable = iter(o) except TypeError: pass else: return list(iterable) # Let the base class default method raise the TypeError return JSONEncoder.default(self, o) zObject of type z is not JSON serializableN)� TypeError� __class__�__name__)r/ �or r r r+ � s zJSONEncoder.defaultc C sN t |t�r | jrt|�S t|�S | j|dd�}t |ttf�sDt|�}d�|�S )z�Return a JSON string representation of a Python data structure. >>> from json.encoder import JSONEncoder >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo": ["bar", "baz"]}' T)� _one_shot� ) � isinstance�strr% r r � iterencode�list�tuple�join)r/ r4 �chunksr r r �encode� s zJSONEncoder.encodec C s� | j r i }nd}| jr t}nt}| jtjtt fdd�}|rvtdk rv| j dkrvt|| j || j | j | j | j | j| j� }n&t|| j || j || j | j | j | j|� }||d�S )z�Encode the given object and yield each string representation as available. For example:: for chunk in JSONEncoder().iterencode(bigobject): mysocket.write(chunk) Nc S sJ | | krd}n$| |kr d}n| |kr*d}n|| �S |sFt dt| � ��|S )NZNaNZInfinityz -Infinityz2Out of range float values are not JSON compliant: )� ValueError�repr)r4 r' Z_reprZ_infZ_neginf�textr r r �floatstr� s ��z(JSONEncoder.iterencode.<locals>.floatstrr )r& r% r r r' �float�__repr__�INFINITY�c_make_encoderr) r+ r. r- r( r$ �_make_iterencode)r/ r4 r5 �markers�_encoderrB � _iterencoder r r r9 � sL � � � �zJSONEncoder.iterencode)F) r3 � __module__� __qualname__�__doc__r- r. r0 r+ r> r9 r r r r r# I s � 8r# c s� �d k r����sd� �� �������� � ��������fdd�� � �������� � � � � ��������fdd��� ������� � ��������fdd���S )N� c 3 s� | sdV d S �d k r6� | �}|�kr.� d��| �|< d}�d k rh|d7 }d�| }�| }||7 }nd }�}d}| D ]�}|r�d}n|}� |��r�|�|� V qx|d kr�|d V qx|dkr�|d V qx|dkr�|d V qx� |� �r�|�|� V qx� |� ��r|�|� V qx|V � |��f��r8�||�}n"� |� ��rP�||�}n �||�}|E d H qx|d k �r�|d8 }d�| V d V �d k �r��|= d S ) Nz[]�Circular reference detected�[� r TF�null�true�false�]r ) Zlst�_current_indent_level�markeridZbuf�newline_indentZ separator�first�valuer= )r? rI � _floatstr�_indent�_intstr�_item_separatorrJ �_iterencode_dict�_iterencode_list�dictrC �id�intr7 r: rH r8 r; r r r` s\ z*_make_iterencode.<locals>._iterencode_listc 3 s: | sdV d S �d k r6�| �}|�kr.� d��| �|< dV �d k rh|d7 }d�| }�| }|V nd }�}d}� r�t | �� �}n| �� }|D �]j\}}�|��r�nn�|� �r��|�}nZ|dkr�d}nL|dkr�d }n>|d kr�d }n0�|��r��|�}n � �rq�ntd |jj� ���|�r"d}n|V �|�V � V �|���rP�|�V q�|d k�rbd V q�|dk�rtdV q�|dk�r�d V q��|���r��|�V q��|� ��r��|�V q��|��f��r҈||�} n"�|� ��r�||�} n �||�} | E d H q�|d k �r |d8 }d�| V d V �d k �r6�|= d S ) Nz{}rO �{rQ r TrS FrT rR z0keys must be str, int, float, bool or None, not �})�sorted�itemsr1 r2 r3 ) ZdctrV rW rX r- rY rg �keyrZ r= )r? rI r[ r\ r] r^ rJ r_ r` �_key_separator� _skipkeys� _sort_keysra rC rb rc r7 r: rH r8 r; r r r_ M s� z*_make_iterencode.<locals>._iterencode_dictc 3 s � | ��r�| �V n�| d kr&dV n�| dkr6dV n�| dkrFdV n�� | � �r\�| �V n�� | � �rr�| �V n�� | � �f�r��| |�E d H nj� | ��r��| |�E d H nN�d k rֈ | �}|�krΈ d��| �|< �| �} �| |�E d H �d k r��|= d S )NrR TrS FrT rO r )r4 rV rW )r? �_defaultrI r[ r] rJ r_ r` ra rC rb rc r7 r: rH r8 r; r r rJ � s2 z%_make_iterencode.<locals>._iterencoder )rH rl rI r\ r[ ri r^ rk rj r5 r? ra rC rb rc r7 r: r8 r; r] r )r? rl rI r[ r\ r] r^ rJ r_ r` ri rj rk ra rC rb rc r7 r: rH r8 r; r rG s .84P, rG )$rM �reZ_jsonr Zc_encode_basestring_ascii� ImportErrorr Zc_encode_basestringr rF �compiler r! ZHAS_UTF8r �range�i� setdefault�chrr rC rE r r" �objectr# r? ra rb rc r7 r: r8 r; rD rG r r r r �<module> sZ � � >� __pycache__/encoder.cpython-38.opt-2.pyc 0000644 00000015246 15204104507 0013771 0 ustar 00 U e5d�> � @ s: d dl Z zd dlmZ W n ek r0 dZY nX zd dlmZ W n ek rZ dZY nX zd dlmZ W n ek r� dZY nX e � d�Z e � d�Z e � d�Z dd d d d d dd�Z ed�D ]Ze �ee�d�e�� q�ed�Zdd� Zep�eZdd� Ze�peZG dd� de�Zeeeee e e e e e j!f dd�Z"dS )� N)�encode_basestring_ascii)�encode_basestring)� make_encoderz[\x00-\x1f\\"\b\f\n\r\t]z([\\"]|[^\ -~])s [�-�]z\\z\"z\bz\fz\nz\rz\t)�\�"�� � � � � � \u{0:04x}�infc C s dd� }dt �|| � d S )Nc S s t | �d� S )Nr )� ESCAPE_DCT�group)�match� r �$/usr/lib64/python3.8/json/encoder.py�replace( s z%py_encode_basestring.<locals>.replacer )�ESCAPE�sub��sr r r r �py_encode_basestring$ s r c C s dd� }dt �|| � d S )Nc S s� | � d�}z t| W S tk rz t|�}|dk rBd�|� Y S |d8 }d|d? d@ B }d|d@ B }d�||� Y S Y nX d S ) Nr i r i � � i� i � z\u{0:04x}\u{1:04x})r r �KeyError�ord�format)r r �n�s1�s2r r r r 4 s z+py_encode_basestring_ascii.<locals>.replacer )� ESCAPE_ASCIIr r r r r �py_encode_basestring_ascii0 s r" c @ sJ e Zd ZdZdZddddddddd�dd�Zd d � Zd d � Zdd d�ZdS )� JSONEncoderz, z: FTN)�skipkeys� ensure_ascii�check_circular� allow_nan� sort_keys�indent� separators�defaultc C sZ || _ || _|| _|| _|| _|| _|d k r:|\| _| _n|d k rHd| _|d k rV|| _d S )N�,) r$ r% r& r' r( r) �item_separator� key_separatorr+ ) �selfr$ r% r& r' r( r) r* r+ r r r �__init__h s +zJSONEncoder.__init__c C s t d|jj� d���d S )NzObject of type z is not JSON serializable)� TypeError� __class__�__name__)r/ �or r r r+ � s zJSONEncoder.defaultc C sN t |t�r | jrt|�S t|�S | j|dd�}t |ttf�sDt|�}d�|�S )NT)� _one_shot� ) � isinstance�strr% r r � iterencode�list�tuple�join)r/ r4 �chunksr r r �encode� s zJSONEncoder.encodec C s� | j r i }nd }| jr t}nt}| jtjtt fdd�}|rvtd k rv| j d krvt|| j || j | j | j | j | j| j� }n&t|| j || j || j | j | j | j|� }||d�S )Nc S sJ | | krd}n$| |kr d}n| |kr*d}n|| �S |sFt dt| � ��|S )NZNaNZInfinityz -Infinityz2Out of range float values are not JSON compliant: )� ValueError�repr)r4 r' Z_reprZ_infZ_neginf�textr r r �floatstr� s ��z(JSONEncoder.iterencode.<locals>.floatstrr )r& r% r r r' �float�__repr__�INFINITY�c_make_encoderr) r+ r. r- r( r$ �_make_iterencode)r/ r4 r5 �markers�_encoderrB � _iterencoder r r r9 � sL � � � �zJSONEncoder.iterencode)F) r3 � __module__� __qualname__r- r. r0 r+ r> r9 r r r r r# I s � 8r# c s� �d k r����sd� �� �������� � ��������fdd�� � �������� � � � � ��������fdd��� ������� � ��������fdd���S )N� c 3 s� | sdV d S �d k r6� | �}|�kr.� d��| �|< d}�d k rh|d7 }d�| }�| }||7 }nd }�}d}| D ]�}|r�d}n|}� |��r�|�|� V qx|d kr�|d V qx|dkr�|d V qx|dkr�|d V qx� |� �r�|�|� V qx� |� ��r|�|� V qx|V � |��f��r8�||�}n"� |� ��rP�||�}n �||�}|E d H qx|d k �r�|d8 }d�| V d V �d k �r��|= d S ) Nz[]�Circular reference detected�[� r TF�null�true�false�]r ) Zlst�_current_indent_level�markeridZbuf�newline_indentZ separator�first�valuer= )r? rI � _floatstr�_indent�_intstr�_item_separatorrJ �_iterencode_dict�_iterencode_list�dictrC �id�intr7 r: rH r8 r; r r r_ s\ z*_make_iterencode.<locals>._iterencode_listc 3 s: | sdV d S �d k r6�| �}|�kr.� d��| �|< dV �d k rh|d7 }d�| }�| }|V nd }�}d}� r�t | �� �}n| �� }|D �]j\}}�|��r�nn�|� �r��|�}nZ|dkr�d}nL|dkr�d }n>|d kr�d }n0�|��r��|�}n � �rq�ntd |jj� ���|�r"d}n|V �|�V � V �|���rP�|�V q�|d k�rbd V q�|dk�rtdV q�|dk�r�d V q��|���r��|�V q��|� ��r��|�V q��|��f��r҈||�} n"�|� ��r�||�} n �||�} | E d H q�|d k �r |d8 }d�| V d V �d k �r6�|= d S ) Nz{}rN �{rP r TrR FrS rQ z0keys must be str, int, float, bool or None, not �})�sorted�itemsr1 r2 r3 ) ZdctrU rV rW r- rX rf �keyrY r= )r? rI rZ r[ r\ r] rJ r^ r_ �_key_separator� _skipkeys� _sort_keysr` rC ra rb r7 r: rH r8 r; r r r^ M s� z*_make_iterencode.<locals>._iterencode_dictc 3 s � | ��r�| �V n�| d kr&dV n�| dkr6dV n�| dkrFdV n�� | � �r\�| �V n�� | � �rr�| �V n�� | � �f�r��| |�E d H nj� | ��r��| |�E d H nN�d k rֈ | �}|�krΈ d��| �|< �| �} �| |�E d H �d k r��|= d S )NrQ TrR FrS rN r )r4 rU rV )r? �_defaultrI rZ r\ rJ r^ r_ r` rC ra rb r7 r: rH r8 r; r r rJ � s2 z%_make_iterencode.<locals>._iterencoder )rH rk rI r[ rZ rh r] rj ri r5 r? r` rC ra rb r7 r: r8 r; r\ r )r? rk rI rZ r[ r\ r] rJ r^ r_ rh ri rj r` rC ra rb r7 r: rH r8 r; r rG s .84P, rG )#�reZ_jsonr Zc_encode_basestring_ascii� ImportErrorr Zc_encode_basestringr rF �compiler r! ZHAS_UTF8r �range�i� setdefault�chrr rC rE r r" �objectr# r? r` ra rb r7 r: r8 r; rD rG r r r r �<module> sX � � >� __pycache__/decoder.cpython-38.pyc 0000644 00000023166 15204104507 0013017 0 ustar 00 U e5d�0 � @ s d Z ddlZddlmZ zddlmZ W n ek r@ dZY nX ddgZej ej B ej B Z e d�Ze d�Ze d �ZG d d� de�Zeeed �Ze�d e �Zd dddddddd�Zdd� Zdeejfdd�Zep�eZe�de �Zd Zdejefd d �Z ejefd d �Z G d!d� de �Z dS )"z Implementation of JSONDecoder � N)�scanner)� scanstring� JSONDecoder�JSONDecodeError�nan�infz-infc @ s e Zd ZdZdd� Zdd� ZdS )r a Subclass of ValueError with the following additional properties: msg: The unformatted error message doc: The JSON document being parsed pos: The start index of doc where parsing failed lineno: The line corresponding to pos colno: The column corresponding to pos c C sb |� dd|�d }||�dd|� }d||||f }t�| |� || _|| _|| _|| _|| _d S )N� r � z %s: line %d column %d (char %d)) �count�rfind� ValueError�__init__�msg�doc�pos�lineno�colno)�selfr r r r r �errmsg� r �$/usr/lib64/python3.8/json/decoder.pyr s zJSONDecodeError.__init__c C s | j | j| j| jffS )N)� __class__r r r )r r r r � __reduce__* s zJSONDecodeError.__reduce__N)�__name__� __module__� __qualname__�__doc__r r r r r r r s )z -InfinityZInfinity�NaNz(.*?)(["\\\x00-\x1f])�"�\�/�� r � � )r r r �b�f�n�r�tc C sb | |d |d � }t |�dkrN|d dkrNz t|d�W S tk rL Y nX d}t|| |��d S )Nr � � ZxX� zInvalid \uXXXX escape)�len�intr r )�sr �escr r r r � _decode_uXXXX; s r1 Tc C s� g }|j }|d }|| |�}|dkr0td| |��|�� }|�� \} } | rP|| � | dkr^�q�n.| dkr�|r�d�| �} t| | |��n || � qz | | } W n" tk r� td| |�d�Y nX | dk�rz || } W n* tk r� d�| �} t| | |��Y nX |d7 }n�t| |�}|d 7 }d | k�r2d k�r�n n`| ||d � d k�r�t| |d �}d| k�rrdk�r�n n d|d d> |d B }|d7 }t|�} || � qd� |�|fS )a� Scan the string s for a JSON string. End is the index of the character in s after the quote that started the JSON string. Unescapes all valid JSON string escape sequences and raises ValueError on attempt to decode an invalid string. If strict is False then literal control characters are allowed in the string. Returns a tuple of the decoded string and the index of the character in s after the end quote.r Nz Unterminated string starting atr r z"Invalid control character {0!r} at�uzInvalid \escape: {0!r}r* i � i�� � z\ui � i�� i � � � ) �appendr �end�groups�format� IndexError�KeyErrorr1 �chr�join)r/ r8 �strictZ_b�_mZchunks�_appendZbegin�chunkZcontent� terminatorr r0 �charZuniZuni2r r r � py_scanstringE sX �� 2 rE z [ \t\n\r]*z c C s� | \}} g } | j } |d kr i }|j} || | d � } | dkr�| |krb||| ��� } || | d � } | dkr�|d k r�|| �}|| d fS i } |d k r�|| �} | | d fS | dkr�td|| ��| d7 } t|| |�\}} | ||�}|| | d � dk�r"||| ��� } || | d � dk�r"td|| ��| d7 } z:|| |k�rb| d7 } || |k�rb||| d ��� } W n tk �rz Y nX z||| �\}} W n4 tk �r� } ztd||j�d �W 5 d }~X Y nX | ||f� z0|| } | |k�r�||| d ��� } || } W n tk �r d} Y nX | d7 } | dk�r4�q�n| d k�rNtd || d ��||| ��� } || | d � } | d7 } | dkr�td|| d ��q�|d k �r�|| �}|| fS t| �} |d k �r�|| �} | | fS ) Nr r �}z1Expecting property name enclosed in double quotes�:zExpecting ':' delimiter�Expecting valuer6 �,�Expecting ',' delimiter) r7 � setdefaultr8 r r r; � StopIteration�value�dict)� s_and_endr? � scan_once� object_hook�object_pairs_hook�memo�_w�_wsr/ r8 ZpairsZ pairs_appendZmemo_get�nextchar�result�keyrM �errr r r � JSONObject� s� � " � rZ c C st | \}}g }|||d � }||krF|||d �� � }|||d � }|dkrZ||d fS |j}z|||�\} }W n2 tk r� } ztd|| j�d �W 5 d } ~ X Y nX || � |||d � }||kr�|||d �� � }|||d � }|d7 }|dkr��qln|dk�rtd||d ��z:|| |k�rP|d7 }|| |k�rP|||d �� � }W q` tk �rh Y q`X q`||fS )Nr �]rH rI rJ )r8 r7 rL r rM r; ) rO rP rT rU r/ r8 �valuesrV rA rM rY r r r � JSONArray� s> " r] c @ s@ e Zd ZdZddddddd�dd�Zejfdd�Zd d d �ZdS ) r a Simple JSON <http://json.org> decoder Performs the following translations in decoding by default: +---------------+-------------------+ | JSON | Python | +===============+===================+ | object | dict | +---------------+-------------------+ | array | list | +---------------+-------------------+ | string | str | +---------------+-------------------+ | number (int) | int | +---------------+-------------------+ | number (real) | float | +---------------+-------------------+ | true | True | +---------------+-------------------+ | false | False | +---------------+-------------------+ | null | None | +---------------+-------------------+ It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as their corresponding ``float`` values, which is outside the JSON spec. NT)rQ � parse_float� parse_int�parse_constantr? rR c C sZ || _ |p t| _|pt| _|p"tj| _|| _|| _ t | _ t | _ t| _i | _t�| �| _dS )a� ``object_hook``, if specified, will be called with the result of every JSON object decoded and its return value will be used in place of the given ``dict``. This can be used to provide custom deserializations (e.g. to support JSON-RPC class hinting). ``object_pairs_hook``, if specified will be called with the result of every JSON object decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders. If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. If ``strict`` is false (true is the default), then control characters will be allowed inside strings. Control characters in this context are those with character codes in the 0-31 range, including ``'\t'`` (tab), ``'\n'``, ``'\r'`` and ``'\0'``. N)rQ �floatr^ r. r_ � _CONSTANTS� __getitem__r` r? rR rZ Z parse_objectr] Z parse_arrayr Z parse_stringrS r Z make_scannerrP )r rQ r^ r_ r` r? rR r r r r s # zJSONDecoder.__init__c C sF | j |||d��� d�\}}|||��� }|t|�krBtd||��|S )zlReturn the Python representation of ``s`` (a ``str`` instance containing a JSON document). r )�idxz Extra data)� raw_decoder8 r- r )r r/ rT �objr8 r r r �decodeL s zJSONDecoder.decoder c C sP z| � ||�\}}W n2 tk rF } ztd||j�d�W 5 d}~X Y nX ||fS )a= Decode a JSON document from ``s`` (a ``str`` beginning with a JSON document) and return a 2-tuple of the Python representation and the index in ``s`` where the document ended. This can be used to decode a JSON document from a string that may have extraneous data at the end. rH N)rP rL r rM )r r/ rd rf r8 rY r r r re W s "zJSONDecoder.raw_decode)r ) r r r r r � WHITESPACE�matchrg re r r r r r � s � 0 ) r �reZjsonr Z_jsonr Z c_scanstring� ImportError�__all__�VERBOSE� MULTILINE�DOTALL�FLAGSra r ZPosInfZNegInfr r rb �compileZ STRINGCHUNKZ BACKSLASHr1 ri rE rh ZWHITESPACE_STRrZ r] �objectr r r r r �<module> sP � � � = � Q% __pycache__/scanner.cpython-38.pyc 0000644 00000003641 15204104507 0013037 0 ustar 00 U e5dy � @ sj d Z ddlZzddlmZ W n ek r4 dZY nX dgZe�dejej B ej B �Z dd� Z epde ZdS )zJSON token scanner � N)� make_scannerr z)(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c sv | j � | j�| j� tj�| j� | j�| j�| j�| j �| j �| j �� ��������� � � f dd�� � �fdd�}|S )Nc s� z | | }W n t k r* t|�d �Y nX |dkrD� | |d � �S |dkrf� | |d f� � ����S |dkr��| |d f� �S |dkr�| ||d � dkr�d |d fS |dkr�| ||d � d kr�d |d fS |d k� r�| ||d � d k� r�d|d fS �| |�}|d k �r\|�� \}}}|�s*|�rH�||�p6d |�p@d �}n�|�}||�� fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r�d�|d fS t|��d S )N�"� �{�[�n� Znull�t�trueT�f� ZfalseF� �N� ZNaN�I� ZInfinity�-� z -Infinity)� IndexError� StopIteration�groups�end)�string�idxZnextchar�mZintegerZfracZexp�res� � _scan_onceZ match_number�memo� object_hook�object_pairs_hook� parse_array�parse_constant� parse_float� parse_int� parse_object� parse_string�strict� �$/usr/lib64/python3.8/json/scanner.pyr sF � z#py_make_scanner.<locals>._scan_oncec s z� | |�W �S �� � X d S )N)�clear)r r )r r r( r) � scan_onceA s z"py_make_scanner.<locals>.scan_once) r% r! r& � NUMBER_RE�matchr' r# r$ r" r r r )�contextr+ r( r r) �py_make_scanner s "%r/ ) �__doc__�reZ_jsonr Zc_make_scanner� ImportError�__all__�compile�VERBOSE� MULTILINE�DOTALLr, r/ r( r( r( r) �<module> s �: __pycache__/__init__.cpython-38.pyc 0000644 00000030502 15204104507 0013141 0 ustar 00 U e5d 8 � @ s� d Z dZdddddddgZd Zd d lmZmZ d d lmZ d dl Z edddddddd�Z dddddddddd� dd�Z dddddddddd� dd�Z eddd�Z dd� Zddddddd�dd�Zddddddd�dd�ZdS )a JSON (JavaScript Object Notation) <http://json.org> is a subset of JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data interchange format. :mod:`json` exposes an API familiar to users of the standard library :mod:`marshal` and :mod:`pickle` modules. It is derived from a version of the externally maintained simplejson library. Encoding basic Python object hierarchies:: >>> import json >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}]) '["foo", {"bar": ["baz", null, 1.0, 2]}]' >>> print(json.dumps("\"foo\bar")) "\"foo\bar" >>> print(json.dumps('\u1234')) "\u1234" >>> print(json.dumps('\\')) "\\" >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)) {"a": 0, "b": 0, "c": 0} >>> from io import StringIO >>> io = StringIO() >>> json.dump(['streaming API'], io) >>> io.getvalue() '["streaming API"]' Compact encoding:: >>> import json >>> mydict = {'4': 5, '6': 7} >>> json.dumps([1,2,3,mydict], separators=(',', ':')) '[1,2,3,{"4":5,"6":7}]' Pretty printing:: >>> import json >>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4)) { "4": 5, "6": 7 } Decoding JSON:: >>> import json >>> obj = ['foo', {'bar': ['baz', None, 1.0, 2]}] >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj True >>> json.loads('"\\"foo\\bar"') == '"foo\x08ar' True >>> from io import StringIO >>> io = StringIO('["streaming API"]') >>> json.load(io)[0] == 'streaming API' True Specializing JSON object decoding:: >>> import json >>> def as_complex(dct): ... if '__complex__' in dct: ... return complex(dct['real'], dct['imag']) ... return dct ... >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}', ... object_hook=as_complex) (1+2j) >>> from decimal import Decimal >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1') True Specializing JSON object encoding:: >>> import json >>> def encode_complex(obj): ... if isinstance(obj, complex): ... return [obj.real, obj.imag] ... raise TypeError(f'Object of type {obj.__class__.__name__} ' ... f'is not JSON serializable') ... >>> json.dumps(2 + 1j, default=encode_complex) '[2.0, 1.0]' >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j) '[2.0, 1.0]' >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j)) '[2.0, 1.0]' Using json.tool from the shell to validate and pretty-print:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) z2.0.9�dump�dumps�load�loads� JSONDecoder�JSONDecodeError� JSONEncoderz Bob Ippolito <bob@redivi.com>� )r r )r � NFT)�skipkeys� ensure_ascii�check_circular� allow_nan�indent� separators�default) r r r r �clsr r r � sort_keysc K s� |sD|rD|rD|rD|dkrD|dkrD|dkrD| dkrD| sD| sDt �| �} n2|dkrPt}|f ||||||| | d�| ���| �} | D ]} |�| � qzdS )a� Serialize ``obj`` as a JSON formatted stream to ``fp`` (a ``.write()``-supporting file-like object). If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, then the strings written to ``fp`` can contain non-ASCII characters if they appear in strings contained in ``obj``. Otherwise, all such characters are escaped in JSON strings. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. N�r r r r r r r r )�_default_encoder� iterencoder �write)�obj�fpr r r r r r r r r �kw�iterable�chunk� r �%/usr/lib64/python3.8/json/__init__.pyr x sD -�������� ���c K st |sB|rB|rB|rB|dkrB|dkrB|dkrB|dkrB| sB| sBt �| �S |dkrNt}|f |||||||| d�| ���| �S )au Serialize ``obj`` to a JSON formatted ``str``. If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, then the return value can contain non-ASCII characters if they appear in strings contained in ``obj``. Otherwise, all such characters are escaped in JSON strings. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. Nr )r �encoder ) r r r r r r r r r r r r r r r � sD ,�������� ���)� object_hook�object_pairs_hookc C s� | j }|tjtjf�rdS |tjtjf�r.dS |tj�r<dS t| �dkr�| d s`| d r\dS dS | d s�| d sx| d r|d S d S n$t| �d kr�| d s�dS | d s�d S d S )Nzutf-32zutf-16z utf-8-sig� r r z utf-16-bez utf-32-be� � z utf-16-lez utf-32-lezutf-8)� startswith�codecs� BOM_UTF32_BE� BOM_UTF32_LE� BOM_UTF16_BE� BOM_UTF16_LE�BOM_UTF8�len)�bZ bstartswithr r r �detect_encoding� s$ r- �r r � parse_float� parse_int�parse_constantr c K s" t | �� f||||||d�|��S )a� Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders. If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. r. )r �read)r r r r/ r0 r1 r r r r r r s ��c K s& t | t�r"| �d�rRtd| d��n0t | ttf�sBtd| jj� ���| � t | �d�} d|krxddl }|j dt d d � |d= |dkr�|dkr�|dkr�|dkr�|dkr�|dkr�|s�t� | �S |dkr�t}|dk r�||d < |dk r�||d < |dk r�||d < |dk �r||d< |dk �r||d< |f |�� | �S )a� Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance containing a JSON document) to a Python object. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders. If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. The ``encoding`` argument is ignored and deprecated since Python 3.1. u z-Unexpected UTF-8 BOM (decode using utf-8-sig)r z5the JSON object must be str, bytes or bytearray, not � surrogatepass�encodingNzF'encoding' is ignored and deprecated. It will be removed in Python 3.9r" )� stacklevelr r r/ r0 r1 )� isinstance�strr$ r �bytes� bytearray� TypeError� __class__�__name__�decoder- �warnings�warn�DeprecationWarning�_default_decoderr ) �sr r r/ r0 r1 r r r> r r r r + sT $ ������� )�__doc__� __version__�__all__� __author__�decoderr r �encoderr r% r r r rA r- r r r r r r �<module> sd a � � � ? � : � � decoder.py 0000644 00000030451 15204104507 0006524 0 ustar 00 """Implementation of JSONDecoder """ import re from json import scanner try: from _json import scanstring as c_scanstring except ImportError: c_scanstring = None __all__ = ['JSONDecoder', 'JSONDecodeError'] FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL NaN = float('nan') PosInf = float('inf') NegInf = float('-inf') class JSONDecodeError(ValueError): """Subclass of ValueError with the following additional properties: msg: The unformatted error message doc: The JSON document being parsed pos: The start index of doc where parsing failed lineno: The line corresponding to pos colno: The column corresponding to pos """ # Note that this exception is used from _json def __init__(self, msg, doc, pos): lineno = doc.count('\n', 0, pos) + 1 colno = pos - doc.rfind('\n', 0, pos) errmsg = '%s: line %d column %d (char %d)' % (msg, lineno, colno, pos) ValueError.__init__(self, errmsg) self.msg = msg self.doc = doc self.pos = pos self.lineno = lineno self.colno = colno def __reduce__(self): return self.__class__, (self.msg, self.doc, self.pos) _CONSTANTS = { '-Infinity': NegInf, 'Infinity': PosInf, 'NaN': NaN, } STRINGCHUNK = re.compile(r'(.*?)(["\\\x00-\x1f])', FLAGS) BACKSLASH = { '"': '"', '\\': '\\', '/': '/', 'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t', } def _decode_uXXXX(s, pos): esc = s[pos + 1:pos + 5] if len(esc) == 4 and esc[1] not in 'xX': try: return int(esc, 16) except ValueError: pass msg = "Invalid \\uXXXX escape" raise JSONDecodeError(msg, s, pos) def py_scanstring(s, end, strict=True, _b=BACKSLASH, _m=STRINGCHUNK.match): """Scan the string s for a JSON string. End is the index of the character in s after the quote that started the JSON string. Unescapes all valid JSON string escape sequences and raises ValueError on attempt to decode an invalid string. If strict is False then literal control characters are allowed in the string. Returns a tuple of the decoded string and the index of the character in s after the end quote.""" chunks = [] _append = chunks.append begin = end - 1 while 1: chunk = _m(s, end) if chunk is None: raise JSONDecodeError("Unterminated string starting at", s, begin) end = chunk.end() content, terminator = chunk.groups() # Content is contains zero or more unescaped string characters if content: _append(content) # Terminator is the end of string, a literal control character, # or a backslash denoting that an escape sequence follows if terminator == '"': break elif terminator != '\\': if strict: #msg = "Invalid control character %r at" % (terminator,) msg = "Invalid control character {0!r} at".format(terminator) raise JSONDecodeError(msg, s, end) else: _append(terminator) continue try: esc = s[end] except IndexError: raise JSONDecodeError("Unterminated string starting at", s, begin) # If not a unicode escape sequence, must be in the lookup table if esc != 'u': try: char = _b[esc] except KeyError: msg = "Invalid \\escape: {0!r}".format(esc) raise JSONDecodeError(msg, s, end) end += 1 else: uni = _decode_uXXXX(s, end) end += 5 if 0xd800 <= uni <= 0xdbff and s[end:end + 2] == '\\u': uni2 = _decode_uXXXX(s, end + 1) if 0xdc00 <= uni2 <= 0xdfff: uni = 0x10000 + (((uni - 0xd800) << 10) | (uni2 - 0xdc00)) end += 6 char = chr(uni) _append(char) return ''.join(chunks), end # Use speedup if available scanstring = c_scanstring or py_scanstring WHITESPACE = re.compile(r'[ \t\n\r]*', FLAGS) WHITESPACE_STR = ' \t\n\r' def JSONObject(s_and_end, strict, scan_once, object_hook, object_pairs_hook, memo=None, _w=WHITESPACE.match, _ws=WHITESPACE_STR): s, end = s_and_end pairs = [] pairs_append = pairs.append # Backwards compatibility if memo is None: memo = {} memo_get = memo.setdefault # Use a slice to prevent IndexError from being raised, the following # check will raise a more specific ValueError if the string is empty nextchar = s[end:end + 1] # Normally we expect nextchar == '"' if nextchar != '"': if nextchar in _ws: end = _w(s, end).end() nextchar = s[end:end + 1] # Trivial empty object if nextchar == '}': if object_pairs_hook is not None: result = object_pairs_hook(pairs) return result, end + 1 pairs = {} if object_hook is not None: pairs = object_hook(pairs) return pairs, end + 1 elif nextchar != '"': raise JSONDecodeError( "Expecting property name enclosed in double quotes", s, end) end += 1 while True: key, end = scanstring(s, end, strict) key = memo_get(key, key) # To skip some function call overhead we optimize the fast paths where # the JSON key separator is ": " or just ":". if s[end:end + 1] != ':': end = _w(s, end).end() if s[end:end + 1] != ':': raise JSONDecodeError("Expecting ':' delimiter", s, end) end += 1 try: if s[end] in _ws: end += 1 if s[end] in _ws: end = _w(s, end + 1).end() except IndexError: pass try: value, end = scan_once(s, end) except StopIteration as err: raise JSONDecodeError("Expecting value", s, err.value) from None pairs_append((key, value)) try: nextchar = s[end] if nextchar in _ws: end = _w(s, end + 1).end() nextchar = s[end] except IndexError: nextchar = '' end += 1 if nextchar == '}': break elif nextchar != ',': raise JSONDecodeError("Expecting ',' delimiter", s, end - 1) end = _w(s, end).end() nextchar = s[end:end + 1] end += 1 if nextchar != '"': raise JSONDecodeError( "Expecting property name enclosed in double quotes", s, end - 1) if object_pairs_hook is not None: result = object_pairs_hook(pairs) return result, end pairs = dict(pairs) if object_hook is not None: pairs = object_hook(pairs) return pairs, end def JSONArray(s_and_end, scan_once, _w=WHITESPACE.match, _ws=WHITESPACE_STR): s, end = s_and_end values = [] nextchar = s[end:end + 1] if nextchar in _ws: end = _w(s, end + 1).end() nextchar = s[end:end + 1] # Look-ahead for trivial empty array if nextchar == ']': return values, end + 1 _append = values.append while True: try: value, end = scan_once(s, end) except StopIteration as err: raise JSONDecodeError("Expecting value", s, err.value) from None _append(value) nextchar = s[end:end + 1] if nextchar in _ws: end = _w(s, end + 1).end() nextchar = s[end:end + 1] end += 1 if nextchar == ']': break elif nextchar != ',': raise JSONDecodeError("Expecting ',' delimiter", s, end - 1) try: if s[end] in _ws: end += 1 if s[end] in _ws: end = _w(s, end + 1).end() except IndexError: pass return values, end class JSONDecoder(object): """Simple JSON <http://json.org> decoder Performs the following translations in decoding by default: +---------------+-------------------+ | JSON | Python | +===============+===================+ | object | dict | +---------------+-------------------+ | array | list | +---------------+-------------------+ | string | str | +---------------+-------------------+ | number (int) | int | +---------------+-------------------+ | number (real) | float | +---------------+-------------------+ | true | True | +---------------+-------------------+ | false | False | +---------------+-------------------+ | null | None | +---------------+-------------------+ It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as their corresponding ``float`` values, which is outside the JSON spec. """ def __init__(self, *, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None): """``object_hook``, if specified, will be called with the result of every JSON object decoded and its return value will be used in place of the given ``dict``. This can be used to provide custom deserializations (e.g. to support JSON-RPC class hinting). ``object_pairs_hook``, if specified will be called with the result of every JSON object decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. If ``strict`` is false (true is the default), then control characters will be allowed inside strings. Control characters in this context are those with character codes in the 0-31 range, including ``'\\t'`` (tab), ``'\\n'``, ``'\\r'`` and ``'\\0'``. """ self.object_hook = object_hook self.parse_float = parse_float or float self.parse_int = parse_int or int self.parse_constant = parse_constant or _CONSTANTS.__getitem__ self.strict = strict self.object_pairs_hook = object_pairs_hook self.parse_object = JSONObject self.parse_array = JSONArray self.parse_string = scanstring self.memo = {} self.scan_once = scanner.make_scanner(self) def decode(self, s, _w=WHITESPACE.match): """Return the Python representation of ``s`` (a ``str`` instance containing a JSON document). """ obj, end = self.raw_decode(s, idx=_w(s, 0).end()) end = _w(s, end).end() if end != len(s): raise JSONDecodeError("Extra data", s, end) return obj def raw_decode(self, s, idx=0): """Decode a JSON document from ``s`` (a ``str`` beginning with a JSON document) and return a 2-tuple of the Python representation and the index in ``s`` where the document ended. This can be used to decode a JSON document from a string that may have extraneous data at the end. """ try: obj, end = self.scan_once(s, idx) except StopIteration as err: raise JSONDecodeError("Expecting value", s, err.value) from None return obj, end scanner.py 0000644 00000004557 15204104507 0006560 0 ustar 00 """JSON token scanner """ import re try: from _json import make_scanner as c_make_scanner except ImportError: c_make_scanner = None __all__ = ['make_scanner'] NUMBER_RE = re.compile( r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?', (re.VERBOSE | re.MULTILINE | re.DOTALL)) def py_make_scanner(context): parse_object = context.parse_object parse_array = context.parse_array parse_string = context.parse_string match_number = NUMBER_RE.match strict = context.strict parse_float = context.parse_float parse_int = context.parse_int parse_constant = context.parse_constant object_hook = context.object_hook object_pairs_hook = context.object_pairs_hook memo = context.memo def _scan_once(string, idx): try: nextchar = string[idx] except IndexError: raise StopIteration(idx) if nextchar == '"': return parse_string(string, idx + 1, strict) elif nextchar == '{': return parse_object((string, idx + 1), strict, _scan_once, object_hook, object_pairs_hook, memo) elif nextchar == '[': return parse_array((string, idx + 1), _scan_once) elif nextchar == 'n' and string[idx:idx + 4] == 'null': return None, idx + 4 elif nextchar == 't' and string[idx:idx + 4] == 'true': return True, idx + 4 elif nextchar == 'f' and string[idx:idx + 5] == 'false': return False, idx + 5 m = match_number(string, idx) if m is not None: integer, frac, exp = m.groups() if frac or exp: res = parse_float(integer + (frac or '') + (exp or '')) else: res = parse_int(integer) return res, m.end() elif nextchar == 'N' and string[idx:idx + 3] == 'NaN': return parse_constant('NaN'), idx + 3 elif nextchar == 'I' and string[idx:idx + 8] == 'Infinity': return parse_constant('Infinity'), idx + 8 elif nextchar == '-' and string[idx:idx + 9] == '-Infinity': return parse_constant('-Infinity'), idx + 9 else: raise StopIteration(idx) def scan_once(string, idx): try: return _scan_once(string, idx) finally: memo.clear() return scan_once make_scanner = c_make_scanner or py_make_scanner scanner.pyc 0000644 00000004265 15204113707 0006721 0 ustar 00 � { fc @ s� d Z d d l Z y d d l m Z Wn e k r? d Z n Xd g Z e j d e j e j Be j B� Z d � Z e p~ e Z d S( s JSON token scanner i����N( t make_scannerR s) (-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c s� | j � | j � | j � t j � | j � | j � | j � | j � | j � | j � | j � � � � � � � � � � � � � f d � � � S( Nc sZ y | | } Wn t k r' t � n X| d k rK � | | d � � � S| d k rz � | | d f � � � � � � S| d k r� � | | d f � � S| d k r� | | | d !d k r� d | d f S| d k r� | | | d !d k r� t | d f S| d k r0| | | d !d k r0t | d f S� | | � } | d k r�| j � \ } } } | sl| r�� | | p{d | p�d � } n � | � } | | j � f S| d k r�| | | d !d k r�� d � | d f S| d k r| | | d !d k r� d � | d f S| d k rP| | | d !d k rP� d � | d f St � d S( Nt "i t {t [t ni t nullt tt truet fi t falset t Ni t NaNt Ii t Infinityt -i s -Infinity( t IndexErrort StopIterationt Nonet Truet Falset groupst end( t stringt idxt nextchart mt integert fract expt res( t _scan_oncet encodingt match_numbert object_hookt object_pairs_hookt parse_arrayt parse_constantt parse_floatt parse_intt parse_objectt parse_stringt strict( s$ /usr/lib64/python2.7/json/scanner.pyR s> ### # ###( R( R$ R) t NUMBER_REt matchR R* R& R' R% R" R# ( t context( ( R R R! R" R# R$ R% R& R' R( R) R* s$ /usr/lib64/python2.7/json/scanner.pyt py_make_scanner s 0%( t __doc__t ret _jsonR t c_make_scannert ImportErrorR t __all__t compilet VERBOSEt MULTILINEt DOTALLR+ R. ( ( ( s$ /usr/lib64/python2.7/json/scanner.pyt <module> s 4 encoder.pyc 0000644 00000032631 15204113707 0006705 0 ustar 00 � { fc @ s d Z d d l Z y d d l m Z Wn e k r? d Z n Xy d d l m Z Wn e k rm d Z n Xe j d � Z e j d � Z e j d � Z i d d 6d d 6d d 6d d 6d d 6d d 6d d 6Z x3 e d � D]% Z e j e e � d j e � � q� We d � Z e j Z d � Z d � Z e p8e Z d e f d � � YZ e e e e e e e e! e" e# e$ d � Z% d S( s Implementation of JSONEncoder i����N( t encode_basestring_ascii( t make_encoders [\x00-\x1f\\"\b\f\n\r\t]s ([\\"]|[^\ -~])s [\x80-\xff]s \\s \s \"t "s \bs s \fs s \ns s \rs s \ts i s \u{0:04x}t infc C s! d � } d t j | | � d S( s5 Return a JSON representation of a Python string c S s t | j d � S( Ni ( t ESCAPE_DCTt group( t match( ( s$ /usr/lib64/python2.7/json/encoder.pyt replace% s R ( t ESCAPEt sub( t sR ( ( s$ /usr/lib64/python2.7/json/encoder.pyt encode_basestring! s c C s] t | t � r6 t j | � d k r6 | j d � } n d � } d t t j | | � � d S( sA Return an ASCII-only JSON representation of a Python string s utf-8c S s� | j d � } y t | SWnp t k r� t | � } | d k rP d j | � S| d 8} d | d ?d @B} d | d @B} d j | | � Sn Xd S( Ni i s \u{0:04x}i � i i� i � s \u{0:04x}\u{1:04x}( R R t KeyErrort ordt format( R R t nt s1t s2( ( s$ /usr/lib64/python2.7/json/encoder.pyR 0 s R N( t isinstancet strt HAS_UTF8t searcht Nonet decodet ESCAPE_ASCIIR ( R R ( ( s$ /usr/lib64/python2.7/json/encoder.pyt py_encode_basestring_ascii* s $ t JSONEncoderc B s\ e Z d Z d Z d Z e e e e e d d d d d � Z d � Z d � Z e d � Z RS( sZ Extensible JSON <http://json.org> encoder for Python data structures. Supports the following objects and types by default: +-------------------+---------------+ | Python | JSON | +===================+===============+ | dict | object | +-------------------+---------------+ | list, tuple | array | +-------------------+---------------+ | str, unicode | string | +-------------------+---------------+ | int, long, float | number | +-------------------+---------------+ | True | true | +-------------------+---------------+ | False | false | +-------------------+---------------+ | None | null | +-------------------+---------------+ To extend this to recognize other objects, subclass and implement a ``.default()`` method with another method that returns a serializable object for ``o`` if possible, otherwise it should call the superclass implementation (to raise ``TypeError``). s , s : s utf-8c C s| | | _ | | _ | | _ | | _ | | _ | | _ | d k rW | \ | _ | _ n | d k ro | | _ n | | _ d S( s� Constructor for JSONEncoder, with sensible defaults. If skipkeys is false, then it is a TypeError to attempt encoding of keys that are not str, int, long, float or None. If skipkeys is True, such items are simply skipped. If *ensure_ascii* is true (the default), all non-ASCII characters in the output are escaped with \uXXXX sequences, and the results are str instances consisting of ASCII characters only. If ensure_ascii is False, a result may be a unicode instance. This usually happens if the input contains unicode strings or the *encoding* parameter is used. If check_circular is true, then lists, dicts, and custom encoded objects will be checked for circular references during encoding to prevent an infinite recursion (which would cause an OverflowError). Otherwise, no such check takes place. If allow_nan is true, then NaN, Infinity, and -Infinity will be encoded as such. This behavior is not JSON specification compliant, but is consistent with most JavaScript based encoders and decoders. Otherwise, it will be a ValueError to encode such floats. If sort_keys is true, then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis. If indent is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. None is the most compact representation. Since the default item separator is ', ', the output might include trailing whitespace when indent is specified. You can use separators=(',', ': ') to avoid this. If specified, separators should be a (item_separator, key_separator) tuple. The default is (', ', ': '). To get the most compact JSON representation you should specify (',', ':') to eliminate whitespace. If specified, default is a function that gets called for objects that can't otherwise be serialized. It should return a JSON encodable version of the object or raise a ``TypeError``. If encoding is not None, then all input strings will be transformed into unicode using that encoding prior to JSON-encoding. The default is UTF-8. N( t skipkeyst ensure_asciit check_circulart allow_nant sort_keyst indentR t item_separatort key_separatort defaultt encoding( t selfR R R R R R t separatorsR$ R# ( ( s$ /usr/lib64/python2.7/json/encoder.pyt __init__e s 4 c C s t t | � d � � d S( sl Implement this method in a subclass such that it returns a serializable object for ``o``, or calls the base implementation (to raise a ``TypeError``). For example, to support arbitrary iterators, you could implement default like this:: def default(self, o): try: iterable = iter(o) except TypeError: pass else: return list(iterable) # Let the base class default method raise the TypeError return JSONEncoder.default(self, o) s is not JSON serializableN( t TypeErrort repr( R% t o( ( s$ /usr/lib64/python2.7/json/encoder.pyR# � s c C s� t | t � ru t | t � rU | j } | d k rU | d k rU | j | � } qU n | j rh t | � St | � Sn | j | d t �} t | t t f � s� t | � } n d j | � S( s� Return a JSON string representation of a Python data structure. >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo": ["bar", "baz"]}' s utf-8t _one_shott N( R t basestringR R$ R R R R R t iterencodet Truet listt tuplet join( R% R* t _encodingt chunks( ( s$ /usr/lib64/python2.7/json/encoder.pyt encode� s c C s | j r i } n d } | j r* t } n t } | j d k rT | | j d � } n | j t t t d � } | r� t d k r� | j d k r� | j r� t | | j | | j | j | j | j | j | j � } n9 t | | j | | j | | j | j | j | j | � } | | d � S( s� Encode the given object and yield each string representation as available. For example:: for chunk in JSONEncoder().iterencode(bigobject): mysocket.write(chunk) s utf-8c S s+ t | t � r! | j | � } n | | � S( N( R R R ( R* t _orig_encoderR3 ( ( s$ /usr/lib64/python2.7/json/encoder.pyt _encoder� s c S sl | | k r d } n4 | | k r* d } n | | k r? d } n | | � S| sh t d t | � � � n | S( Nt NaNt Infinitys -Infinitys2 Out of range float values are not JSON compliant: ( t ValueErrorR) ( R* R t _reprt _inft _neginft text( ( s$ /usr/lib64/python2.7/json/encoder.pyt floatstr� s i N( R R R R R R$ R t FLOAT_REPRt INFINITYt c_make_encoderR R R# R" R! R t _make_iterencode( R% R* R+ t markersR7 R? t _iterencode( ( s$ /usr/lib64/python2.7/json/encoder.pyR. � s* N( t __name__t __module__t __doc__R! R" t FalseR/ R R' R# R5 R. ( ( ( s$ /usr/lib64/python2.7/json/encoder.pyR F s > c s� � � � � � � � � � � � � � � � � � � � f d � � � � � � � � � � � � � � � � � � � � � � � � f d � � � � � � � � � � � � � � � � � � � � f d � � � S( Nc 3 s8 | s d Vd S� d k rO � | � } | � k rB � d � � n | � | <n d } � d k r� | d 7} d d � | } � | } | | 7} n d } � } t } xF| D]>} | r� t } n | } � | � � r� | � | � Vq� | d k r| d Vq� | t k r| d Vq� | t k r1| d Vq� � | � � f � rX| � | � Vq� � | � � ry| � | � Vq� | V� | � � f � r�� | | � } n0 � | � � r�� | | � } n � | | � } x | D] } | Vq�Wq� W| d k r| d 8} d d � | Vn d V� d k r4� | =n d S( Ns []s Circular reference detectedt [i s t t nullt truet falset ]( R R/ RI ( t lstt _current_indent_levelt markeridt buft newline_indentt separatort firstt valueR4 t chunk( R: R7 t _floatstrt _indentt _item_separatorRE t _iterencode_dictt _iterencode_listR- t dictt floatt idt intR R0 t longRD R R1 ( s$ /usr/lib64/python2.7/json/encoder.pyR] s^ c 3 s | s d Vd S� d k rO � | � } | � k rB � d � � n | � | <n d V� d k r� | d 7} d d � | } � | } | Vn d } � } t } � r� t | j � d d � �} n | j � } x�| D]�\ } } � | � � r� n� � | � � r� | � } n� | t k r(d } nt | t k r=d } n_ | d k rRd } nJ � | � � f � rv� | � } n& � r�q� n t d t | � d � � | r�t } n | V� | � V� V� | � � r�� | � Vq� | d k r�d Vq� | t k rd Vq� | t k rd Vq� � | � � f � r<� | � Vq� � | � � rY� | � Vq� � | � � f � r�� | | � } n0 � | � � r�� | | � } n � | | � } x | D] } | Vq�Wq� W| d k r�| d 8} d d � | Vn d V� d k r� | =n d S( Ns {}s Circular reference detectedt {i s RK t keyc S s | d S( Ni ( ( t kv( ( s$ /usr/lib64/python2.7/json/encoder.pyt <lambda>i R, RM RN RL s key s is not a stringt }( R R/ t sortedt itemst iteritemsRI R( R) ( t dctRQ RR RT R! RV Ri Rd RW R4 RX ( R: R7 RY RZ R[ RE R\ R] t _key_separatort _skipkeyst _sort_keysR- R^ R_ R` Ra R R0 Rb RD R R1 ( s$ /usr/lib64/python2.7/json/encoder.pyR\ U s� c 3 s� � | � � r � | � Vne| d k r1 d VnQ| t k rE d Vn=| t k rY d Vn)� | � � f � r| � | � Vn� | � � r� � | � Vn� � | � � f � r� x� � | | � D] } | Vq� Wn� � | � � rx� � | | � D] } | Vq� Wn� � d k rA� | � } | � k r4� d � � n | � | <n � | � } x � | | � D] } | Vq]W� d k r�� | =n d S( NRL RM RN s Circular reference detected( R R/ RI ( R* RQ RX RR ( R: t _defaultR7 RY RE R\ R] R- R^ R_ R` Ra R R0 Rb RD R R1 ( s$ /usr/lib64/python2.7/json/encoder.pyRE � s8 ( ( RD Ro R7 RZ RY Rl R[ Rn Rm R+ R: R- R^ R_ R` Ra R R0 Rb R R1 ( ( R: Ro R7 RY RZ R[ RE R\ R] Rl Rm Rn R- R^ R_ R` Ra R R0 Rb RD R R1 s$ /usr/lib64/python2.7/json/encoder.pyRC s E5NLB (& RH t ret _jsonR t c_encode_basestring_asciit ImportErrorR R RB t compileR R R R t ranget it setdefaultt chrR R_ RA t __repr__R@ R R t objectR R: R- R^ R` Ra R R0 Rb R R1 RC ( ( ( s$ /usr/lib64/python2.7/json/encoder.pyt <module> sN # � __init__.pyo 0000644 00000033146 15204113707 0007043 0 ustar 00 � { fc @ s, d Z d Z d d d d d d g Z d Z d d l m Z d d l m Z e d e d e d e d e d d d d d d d d � Z e e e e d d d d d e d � Z e e e e d d d d d e d � Z e d d d d d d � Z d d d d d d d d � Z d d d d d d d d � Z d S( s� JSON (JavaScript Object Notation) <http://json.org> is a subset of JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data interchange format. :mod:`json` exposes an API familiar to users of the standard library :mod:`marshal` and :mod:`pickle` modules. It is the externally maintained version of the :mod:`json` library contained in Python 2.6, but maintains compatibility with Python 2.4 and Python 2.5 and (currently) has significant performance advantages, even without using the optional C extension for speedups. Encoding basic Python object hierarchies:: >>> import json >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}]) '["foo", {"bar": ["baz", null, 1.0, 2]}]' >>> print json.dumps("\"foo\bar") "\"foo\bar" >>> print json.dumps(u'\u1234') "\u1234" >>> print json.dumps('\\') "\\" >>> print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True) {"a": 0, "b": 0, "c": 0} >>> from StringIO import StringIO >>> io = StringIO() >>> json.dump(['streaming API'], io) >>> io.getvalue() '["streaming API"]' Compact encoding:: >>> import json >>> json.dumps([1,2,3,{'4': 5, '6': 7}], sort_keys=True, separators=(',',':')) '[1,2,3,{"4":5,"6":7}]' Pretty printing:: >>> import json >>> print json.dumps({'4': 5, '6': 7}, sort_keys=True, ... indent=4, separators=(',', ': ')) { "4": 5, "6": 7 } Decoding JSON:: >>> import json >>> obj = [u'foo', {u'bar': [u'baz', None, 1.0, 2]}] >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj True >>> json.loads('"\\"foo\\bar"') == u'"foo\x08ar' True >>> from StringIO import StringIO >>> io = StringIO('["streaming API"]') >>> json.load(io)[0] == 'streaming API' True Specializing JSON object decoding:: >>> import json >>> def as_complex(dct): ... if '__complex__' in dct: ... return complex(dct['real'], dct['imag']) ... return dct ... >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}', ... object_hook=as_complex) (1+2j) >>> from decimal import Decimal >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1') True Specializing JSON object encoding:: >>> import json >>> def encode_complex(obj): ... if isinstance(obj, complex): ... return [obj.real, obj.imag] ... raise TypeError(repr(obj) + " is not JSON serializable") ... >>> json.dumps(2 + 1j, default=encode_complex) '[2.0, 1.0]' >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j) '[2.0, 1.0]' >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j)) '[2.0, 1.0]' Using json.tool from the shell to validate and pretty-print:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) s 2.0.9t dumpt dumpst loadt loadst JSONDecodert JSONEncoders Bob Ippolito <bob@redivi.com>i ( R ( R t skipkeyst ensure_asciit check_circulart allow_nant indentt separatorst encodings utf-8t defaultc K s� | ru | ru | ru | ru | d k ru | d k ru | d k ru | d k ru | d k ru | ru | ru t j | � } n` | d k r� t } n | d | d | d | d | d | d | d | d | d | | � j | � } x | D] } | j | � q� Wd S( s� Serialize ``obj`` as a JSON formatted stream to ``fp`` (a ``.write()``-supporting file-like object). If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is true (the default), all non-ASCII characters in the output are escaped with ``\uXXXX`` sequences, and the result is a ``str`` instance consisting of ASCII characters only. If ``ensure_ascii`` is false, some chunks written to ``fp`` may be ``unicode`` instances. This usually happens because the input contains unicode strings or the ``encoding`` parameter is used. Unless ``fp.write()`` explicitly understands ``unicode`` (as in ``codecs.getwriter``) this is likely to cause an error. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. Since the default item separator is ``', '``, the output might include trailing whitespace when ``indent`` is specified. You can use ``separators=(',', ': ')`` to avoid this. If ``separators`` is an ``(item_separator, dict_separator)`` tuple then it will be used instead of the default ``(', ', ': ')`` separators. ``(',', ':')`` is the most compact JSON representation. ``encoding`` is the character encoding for str instances, default is UTF-8. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. s utf-8R R R R R R R R t sort_keysN( t Nonet _default_encodert iterencodeR t write( t objt fpR R R R t clsR R R R R t kwt iterablet chunk( ( s% /usr/lib64/python2.7/json/__init__.pyR z s 5 $& c K s� | rp | rp | rp | rp | d k rp | d k rp | d k rp | d k rp | d k rp | rp | rp t j | � S| d k r� t } n | d | d | d | d | d | d | d | d | d | | � j | � S( s Serialize ``obj`` to a JSON formatted ``str``. If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, all non-ASCII characters are not escaped, and the return value may be a ``unicode`` instance. See ``dump`` for details. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. Since the default item separator is ``', '``, the output might include trailing whitespace when ``indent`` is specified. You can use ``separators=(',', ': ')`` to avoid this. If ``separators`` is an ``(item_separator, dict_separator)`` tuple then it will be used instead of the default ``(', ', ': ')`` separators. ``(',', ':')`` is the most compact JSON representation. ``encoding`` is the character encoding for str instances, default is UTF-8. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. s utf-8R R R R R R R R R N( R R t encodeR ( R R R R R R R R R R R R ( ( s% /usr/lib64/python2.7/json/__init__.pyR � s / $& t object_hookt object_pairs_hookc K s= t | j � d | d | d | d | d | d | d | | �S( s� Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. If the contents of ``fp`` is encoded with an ASCII based encoding other than utf-8 (e.g. latin-1), then an appropriate ``encoding`` name must be specified. Encodings that are not ASCII based (such as UCS-2) are not allowed, and should be wrapped with ``codecs.getreader(fp)(encoding)``, or simply decoded to a ``unicode`` object and passed to ``loads()`` ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. R R R t parse_floatt parse_intt parse_constantR ( R t read( R R R R R R R R R ( ( s% /usr/lib64/python2.7/json/__init__.pyR s c K s | d k rh | d k rh | d k rh | d k rh | d k rh | d k rh | d k rh | rh t j | � S| d k r} t } n | d k r� | | d <n | d k r� | | d <n | d k r� | | d <n | d k r� | | d <n | d k r� | | d <n | d | | � j | � S( s� Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON document) to a Python object. If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name must be specified. Encodings that are not ASCII based (such as UCS-2) are not allowed and should be decoded to ``unicode`` first. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. R R R R R R N( R t _default_decodert decodeR ( t sR R R R R R R R ( ( s% /usr/lib64/python2.7/json/__init__.pyR & s" *$ N( t __doc__t __version__t __all__t __author__t decoderR t encoderR t Falset TrueR R R R R R R ( ( ( s% /usr/lib64/python2.7/json/__init__.pyt <module>c s6 E ; # tool.pyc 0000644 00000002416 15204113707 0006241 0 ustar 00 � { fc @ sA d Z d d l Z d d l Z d � Z e d k r= e � n d S( s Command-line tool to validate and pretty-print JSON Usage:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) i����Nc C s> t t j � d k r* t j } t j } n� t t j � d k ra t t j d d � } t j } n[ t t j � d k r� t t j d d � } t t j d d � } n t t j d d � � | �: y t j | � } Wn t k r� } t | � � n XWd QX| �4 t j | | d t d d d d �| j d � Wd QXd S( Ni i t rbi t wbi s [infile [outfile]]t sort_keyst indenti t separatorst ,s : s ( R s : ( t lent syst argvt stdint stdoutt opent SystemExitt jsont loadt ValueErrort dumpt Truet write( t infilet outfilet objt e( ( s! /usr/lib64/python2.7/json/tool.pyt main s& t __main__( t __doc__R R R t __name__( ( ( s! /usr/lib64/python2.7/json/tool.pyt <module> s encoder.pyo 0000644 00000032631 15204113707 0006721 0 ustar 00 � { fc @ s d Z d d l Z y d d l m Z Wn e k r? d Z n Xy d d l m Z Wn e k rm d Z n Xe j d � Z e j d � Z e j d � Z i d d 6d d 6d d 6d d 6d d 6d d 6d d 6Z x3 e d � D]% Z e j e e � d j e � � q� We d � Z e j Z d � Z d � Z e p8e Z d e f d � � YZ e e e e e e e e! e" e# e$ d � Z% d S( s Implementation of JSONEncoder i����N( t encode_basestring_ascii( t make_encoders [\x00-\x1f\\"\b\f\n\r\t]s ([\\"]|[^\ -~])s [\x80-\xff]s \\s \s \"t "s \bs s \fs s \ns s \rs s \ts i s \u{0:04x}t infc C s! d � } d t j | | � d S( s5 Return a JSON representation of a Python string c S s t | j d � S( Ni ( t ESCAPE_DCTt group( t match( ( s$ /usr/lib64/python2.7/json/encoder.pyt replace% s R ( t ESCAPEt sub( t sR ( ( s$ /usr/lib64/python2.7/json/encoder.pyt encode_basestring! s c C s] t | t � r6 t j | � d k r6 | j d � } n d � } d t t j | | � � d S( sA Return an ASCII-only JSON representation of a Python string s utf-8c S s� | j d � } y t | SWnp t k r� t | � } | d k rP d j | � S| d 8} d | d ?d @B} d | d @B} d j | | � Sn Xd S( Ni i s \u{0:04x}i � i i� i � s \u{0:04x}\u{1:04x}( R R t KeyErrort ordt format( R R t nt s1t s2( ( s$ /usr/lib64/python2.7/json/encoder.pyR 0 s R N( t isinstancet strt HAS_UTF8t searcht Nonet decodet ESCAPE_ASCIIR ( R R ( ( s$ /usr/lib64/python2.7/json/encoder.pyt py_encode_basestring_ascii* s $ t JSONEncoderc B s\ e Z d Z d Z d Z e e e e e d d d d d � Z d � Z d � Z e d � Z RS( sZ Extensible JSON <http://json.org> encoder for Python data structures. Supports the following objects and types by default: +-------------------+---------------+ | Python | JSON | +===================+===============+ | dict | object | +-------------------+---------------+ | list, tuple | array | +-------------------+---------------+ | str, unicode | string | +-------------------+---------------+ | int, long, float | number | +-------------------+---------------+ | True | true | +-------------------+---------------+ | False | false | +-------------------+---------------+ | None | null | +-------------------+---------------+ To extend this to recognize other objects, subclass and implement a ``.default()`` method with another method that returns a serializable object for ``o`` if possible, otherwise it should call the superclass implementation (to raise ``TypeError``). s , s : s utf-8c C s| | | _ | | _ | | _ | | _ | | _ | | _ | d k rW | \ | _ | _ n | d k ro | | _ n | | _ d S( s� Constructor for JSONEncoder, with sensible defaults. If skipkeys is false, then it is a TypeError to attempt encoding of keys that are not str, int, long, float or None. If skipkeys is True, such items are simply skipped. If *ensure_ascii* is true (the default), all non-ASCII characters in the output are escaped with \uXXXX sequences, and the results are str instances consisting of ASCII characters only. If ensure_ascii is False, a result may be a unicode instance. This usually happens if the input contains unicode strings or the *encoding* parameter is used. If check_circular is true, then lists, dicts, and custom encoded objects will be checked for circular references during encoding to prevent an infinite recursion (which would cause an OverflowError). Otherwise, no such check takes place. If allow_nan is true, then NaN, Infinity, and -Infinity will be encoded as such. This behavior is not JSON specification compliant, but is consistent with most JavaScript based encoders and decoders. Otherwise, it will be a ValueError to encode such floats. If sort_keys is true, then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis. If indent is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. None is the most compact representation. Since the default item separator is ', ', the output might include trailing whitespace when indent is specified. You can use separators=(',', ': ') to avoid this. If specified, separators should be a (item_separator, key_separator) tuple. The default is (', ', ': '). To get the most compact JSON representation you should specify (',', ':') to eliminate whitespace. If specified, default is a function that gets called for objects that can't otherwise be serialized. It should return a JSON encodable version of the object or raise a ``TypeError``. If encoding is not None, then all input strings will be transformed into unicode using that encoding prior to JSON-encoding. The default is UTF-8. N( t skipkeyst ensure_asciit check_circulart allow_nant sort_keyst indentR t item_separatort key_separatort defaultt encoding( t selfR R R R R R t separatorsR$ R# ( ( s$ /usr/lib64/python2.7/json/encoder.pyt __init__e s 4 c C s t t | � d � � d S( sl Implement this method in a subclass such that it returns a serializable object for ``o``, or calls the base implementation (to raise a ``TypeError``). For example, to support arbitrary iterators, you could implement default like this:: def default(self, o): try: iterable = iter(o) except TypeError: pass else: return list(iterable) # Let the base class default method raise the TypeError return JSONEncoder.default(self, o) s is not JSON serializableN( t TypeErrort repr( R% t o( ( s$ /usr/lib64/python2.7/json/encoder.pyR# � s c C s� t | t � ru t | t � rU | j } | d k rU | d k rU | j | � } qU n | j rh t | � St | � Sn | j | d t �} t | t t f � s� t | � } n d j | � S( s� Return a JSON string representation of a Python data structure. >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo": ["bar", "baz"]}' s utf-8t _one_shott N( R t basestringR R$ R R R R R t iterencodet Truet listt tuplet join( R% R* t _encodingt chunks( ( s$ /usr/lib64/python2.7/json/encoder.pyt encode� s c C s | j r i } n d } | j r* t } n t } | j d k rT | | j d � } n | j t t t d � } | r� t d k r� | j d k r� | j r� t | | j | | j | j | j | j | j | j � } n9 t | | j | | j | | j | j | j | j | � } | | d � S( s� Encode the given object and yield each string representation as available. For example:: for chunk in JSONEncoder().iterencode(bigobject): mysocket.write(chunk) s utf-8c S s+ t | t � r! | j | � } n | | � S( N( R R R ( R* t _orig_encoderR3 ( ( s$ /usr/lib64/python2.7/json/encoder.pyt _encoder� s c S sl | | k r d } n4 | | k r* d } n | | k r? d } n | | � S| sh t d t | � � � n | S( Nt NaNt Infinitys -Infinitys2 Out of range float values are not JSON compliant: ( t ValueErrorR) ( R* R t _reprt _inft _neginft text( ( s$ /usr/lib64/python2.7/json/encoder.pyt floatstr� s i N( R R R R R R$ R t FLOAT_REPRt INFINITYt c_make_encoderR R R# R" R! R t _make_iterencode( R% R* R+ t markersR7 R? t _iterencode( ( s$ /usr/lib64/python2.7/json/encoder.pyR. � s* N( t __name__t __module__t __doc__R! R" t FalseR/ R R' R# R5 R. ( ( ( s$ /usr/lib64/python2.7/json/encoder.pyR F s > c s� � � � � � � � � � � � � � � � � � � � f d � � � � � � � � � � � � � � � � � � � � � � � � f d � � � � � � � � � � � � � � � � � � � � f d � � � S( Nc 3 s8 | s d Vd S� d k rO � | � } | � k rB � d � � n | � | <n d } � d k r� | d 7} d d � | } � | } | | 7} n d } � } t } xF| D]>} | r� t } n | } � | � � r� | � | � Vq� | d k r| d Vq� | t k r| d Vq� | t k r1| d Vq� � | � � f � rX| � | � Vq� � | � � ry| � | � Vq� | V� | � � f � r�� | | � } n0 � | � � r�� | | � } n � | | � } x | D] } | Vq�Wq� W| d k r| d 8} d d � | Vn d V� d k r4� | =n d S( Ns []s Circular reference detectedt [i s t t nullt truet falset ]( R R/ RI ( t lstt _current_indent_levelt markeridt buft newline_indentt separatort firstt valueR4 t chunk( R: R7 t _floatstrt _indentt _item_separatorRE t _iterencode_dictt _iterencode_listR- t dictt floatt idt intR R0 t longRD R R1 ( s$ /usr/lib64/python2.7/json/encoder.pyR] s^ c 3 s | s d Vd S� d k rO � | � } | � k rB � d � � n | � | <n d V� d k r� | d 7} d d � | } � | } | Vn d } � } t } � r� t | j � d d � �} n | j � } x�| D]�\ } } � | � � r� n� � | � � r� | � } n� | t k r(d } nt | t k r=d } n_ | d k rRd } nJ � | � � f � rv� | � } n& � r�q� n t d t | � d � � | r�t } n | V� | � V� V� | � � r�� | � Vq� | d k r�d Vq� | t k rd Vq� | t k rd Vq� � | � � f � r<� | � Vq� � | � � rY� | � Vq� � | � � f � r�� | | � } n0 � | � � r�� | | � } n � | | � } x | D] } | Vq�Wq� W| d k r�| d 8} d d � | Vn d V� d k r� | =n d S( Ns {}s Circular reference detectedt {i s RK t keyc S s | d S( Ni ( ( t kv( ( s$ /usr/lib64/python2.7/json/encoder.pyt <lambda>i R, RM RN RL s key s is not a stringt }( R R/ t sortedt itemst iteritemsRI R( R) ( t dctRQ RR RT R! RV Ri Rd RW R4 RX ( R: R7 RY RZ R[ RE R\ R] t _key_separatort _skipkeyst _sort_keysR- R^ R_ R` Ra R R0 Rb RD R R1 ( s$ /usr/lib64/python2.7/json/encoder.pyR\ U s� c 3 s� � | � � r � | � Vne| d k r1 d VnQ| t k rE d Vn=| t k rY d Vn)� | � � f � r| � | � Vn� | � � r� � | � Vn� � | � � f � r� x� � | | � D] } | Vq� Wn� � | � � rx� � | | � D] } | Vq� Wn� � d k rA� | � } | � k r4� d � � n | � | <n � | � } x � | | � D] } | Vq]W� d k r�� | =n d S( NRL RM RN s Circular reference detected( R R/ RI ( R* RQ RX RR ( R: t _defaultR7 RY RE R\ R] R- R^ R_ R` Ra R R0 Rb RD R R1 ( s$ /usr/lib64/python2.7/json/encoder.pyRE � s8 ( ( RD Ro R7 RZ RY Rl R[ Rn Rm R+ R: R- R^ R_ R` Ra R R0 Rb R R1 ( ( R: Ro R7 RY RZ R[ RE R\ R] Rl Rm Rn R- R^ R_ R` Ra R R0 Rb RD R R1 s$ /usr/lib64/python2.7/json/encoder.pyRC s E5NLB (& RH t ret _jsonR t c_encode_basestring_asciit ImportErrorR R RB t compileR R R R t ranget it setdefaultt chrR R_ RA t __repr__R@ R R t objectR R: R- R^ R` Ra R R0 Rb R R1 RC ( ( ( s$ /usr/lib64/python2.7/json/encoder.pyt <module> sN # � scanner.pyo 0000644 00000004265 15204113707 0006735 0 ustar 00 � { fc @ s� d Z d d l Z y d d l m Z Wn e k r? d Z n Xd g Z e j d e j e j Be j B� Z d � Z e p~ e Z d S( s JSON token scanner i����N( t make_scannerR s) (-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c s� | j � | j � | j � t j � | j � | j � | j � | j � | j � | j � | j � � � � � � � � � � � � � f d � � � S( Nc sZ y | | } Wn t k r' t � n X| d k rK � | | d � � � S| d k rz � | | d f � � � � � � S| d k r� � | | d f � � S| d k r� | | | d !d k r� d | d f S| d k r� | | | d !d k r� t | d f S| d k r0| | | d !d k r0t | d f S� | | � } | d k r�| j � \ } } } | sl| r�� | | p{d | p�d � } n � | � } | | j � f S| d k r�| | | d !d k r�� d � | d f S| d k r| | | d !d k r� d � | d f S| d k rP| | | d !d k rP� d � | d f St � d S( Nt "i t {t [t ni t nullt tt truet fi t falset t Ni t NaNt Ii t Infinityt -i s -Infinity( t IndexErrort StopIterationt Nonet Truet Falset groupst end( t stringt idxt nextchart mt integert fract expt res( t _scan_oncet encodingt match_numbert object_hookt object_pairs_hookt parse_arrayt parse_constantt parse_floatt parse_intt parse_objectt parse_stringt strict( s$ /usr/lib64/python2.7/json/scanner.pyR s> ### # ###( R( R$ R) t NUMBER_REt matchR R* R& R' R% R" R# ( t context( ( R R R! R" R# R$ R% R& R' R( R) R* s$ /usr/lib64/python2.7/json/scanner.pyt py_make_scanner s 0%( t __doc__t ret _jsonR t c_make_scannert ImportErrorR t __all__t compilet VERBOSEt MULTILINEt DOTALLR+ R. ( ( ( s$ /usr/lib64/python2.7/json/scanner.pyt <module> s 4 decoder.pyc 0000644 00000027270 15204113707 0006676 0 ustar 00 � { fc @ s� d Z d d l Z d d l Z d d l Z d d l m Z y d d l m Z Wn e k rg d Z n Xd g Z e j e j Be j BZ d � Z e � \ Z Z Z d � Z d d � Z i e d 6e d 6e d 6Z e j d e � Z i d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6Z d Z d � Z d e e e j d � Z e pSe Z e j d e � Z d! Z e j e d" � Z! e j e d# � Z" d e# f d$ � � YZ$ d S(% s Implementation of JSONDecoder i����N( t scanner( t scanstringt JSONDecoderc C s8 t j d d � \ } t j d d � \ } | | | f S( Ns >ds � s � ( t structt unpack( t nant inf( ( s$ /usr/lib64/python2.7/json/decoder.pyt _floatconstants s c C sU | j d d | � d } | d k r2 | d } n | | j d d | � } | | f S( Ns i i ( t countt rindex( t doct post linenot colno( ( s$ /usr/lib64/python2.7/json/decoder.pyt linecol s c C sw t | | � \ } } | d k r= d } | j | | | | � St | | � \ } } d } | j | | | | | | | � S( Ns# {0}: line {1} column {2} (char {3})s? {0}: line {1} column {2} - line {3} column {4} (char {5} - {6})( R t Nonet format( t msgR R t endR R t fmtt endlinenot endcolno( ( s$ /usr/lib64/python2.7/json/decoder.pyt errmsg" s s -Infinityt Infinityt NaNs (.*?)(["\\\x00-\x1f])u "t "u \s \u /t /u t bu t fu t nu t ru t ts utf-8c C s� | | d | d !} t | � d k r_ | d d k r_ y t | d � SWq_ t k r[ q_ Xn d } t t | | | � � � d S( Ni i i t xXi s Invalid \uXXXX escape( t lent intt ValueErrorR ( t sR t escR ( ( s$ /usr/lib64/python2.7/json/decoder.pyt _decode_uXXXX? s " c C s� | d k r t } n g } | j } | d } xO| | | � } | d k rg t t d | | � � � n | j � } | j � \ } } | r� t | t � s� t | | � } n | | � n | d k r� PnL | d k r| rd j | � } t t | | | � � � q| | � q1 n y | | } Wn) t k rNt t d | | � � � n X| d k r�y | | } Wn9 t k r�d t | � } t t | | | � � � n X| d 7} n� t | | � } | d 7} t j d k rfd | k o�d k n rf| | | d !d k rft | | d � } d | k o7d k n rfd | d d >| d B} | d 7} qfn t | � } | | � q1 Wd j | � | f S( s� Scan the string s for a JSON string. End is the index of the character in s after the quote that started the JSON string. Unescapes all valid JSON string escape sequences and raises ValueError on attempt to decode an invalid string. If strict is False then literal control characters are allowed in the string. Returns a tuple of the decoded string and the index of the character in s after the end quote.i s Unterminated string starting atR s \s" Invalid control character {0!r} att us Invalid \escape: i i�� i � i�� i s \ui � i�� i i i u N( R t DEFAULT_ENCODINGt appendR# R R t groupst isinstancet unicodeR t IndexErrort KeyErrort reprR& t syst maxunicodet unichrt join( R$ R t encodingt strictt _bt _mt chunkst _appendt begint chunkt contentt terminatorR R% t chart unit uni2( ( s$ /usr/lib64/python2.7/json/decoder.pyt py_scanstringI s^ 3 s [ \t\n\r]*s c C s� | \ } } g } | j } | | | d !} | d k r� | | k rm | | | � j � } | | | d !} n | d k r� | d k r� | | � } | | d f Si } | d k r� | | � } n | | d f S| d k r� t t d | | � � � q� n | d 7} x�t r�t | | | | � \ } } | | | d !d k r�| | | � j � } | | | d !d k r�t t d | | � � � q�n | d 7} yM | | | k r�| d 7} | | | k r�| | | d � j � } q�n Wn t k r�n Xy | | | � \ } } Wn) t k r6t t d | | � � � n X| | | f � y@ | | } | | k r�| | | d � j � } | | } n Wn t k r�d } n X| d 7} | d k r�Pn+ | d k r�t t d | | d � � � n yc | | } | | k rH| d 7} | | } | | k rH| | | d � j � } | | } qHn Wn t k rbd } n X| d 7} | d k rt t d | | d � � � qqW| d k r�| | � } | | f St | � } | d k r�| | � } n | | f S( Ni R t }s1 Expecting property name enclosed in double quotest :s Expecting ':' delimiters Expecting objectt t ,s Expecting ',' delimiter( R) R R R# R t TrueR R- t StopIterationt dict( t s_and_endR4 R5 t scan_oncet object_hookt object_pairs_hookt _wt _wsR$ R t pairst pairs_appendt nextchart resultt keyt value( ( s$ /usr/lib64/python2.7/json/decoder.pyt JSONObject� s� # c C s� | \ } } g } | | | d !} | | k r\ | | | d � j � } | | | d !} n | d k rv | | d f S| j } xEt r�y | | | � \ } } Wn) t k r� t t d | | � � � n X| | � | | | d !} | | k r!| | | d � j � } | | | d !} n | d 7} | d k r;Pn' | d k rbt t d | | � � � n yM | | | k r�| d 7} | | | k r�| | | d � j � } q�n Wq� t k r�q� Xq� W| | f S( Ni t ]s Expecting objectRE s Expecting ',' delimiter( R R) RF RG R# R R- ( RI RJ RM RN R$ R t valuesRQ R9 RT ( ( s$ /usr/lib64/python2.7/json/decoder.pyt JSONArray� s@ # c B sG e Z d Z d d d d d e d d � Z e j d � Z d d � Z RS( s Simple JSON <http://json.org> decoder Performs the following translations in decoding by default: +---------------+-------------------+ | JSON | Python | +===============+===================+ | object | dict | +---------------+-------------------+ | array | list | +---------------+-------------------+ | string | unicode | +---------------+-------------------+ | number (int) | int, long | +---------------+-------------------+ | number (real) | float | +---------------+-------------------+ | true | True | +---------------+-------------------+ | false | False | +---------------+-------------------+ | null | None | +---------------+-------------------+ It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as their corresponding ``float`` values, which is outside the JSON spec. c C s� | | _ | | _ | | _ | p$ t | _ | p3 t | _ | pE t j | _ | | _ t | _ t | _ t | _ t j | � | _ d S( s� ``encoding`` determines the encoding used to interpret any ``str`` objects decoded by this instance (utf-8 by default). It has no effect when decoding ``unicode`` objects. Note that currently only encodings that are a superset of ASCII work, strings of other encodings should be passed in as ``unicode``. ``object_hook``, if specified, will be called with the result of every JSON object decoded and its return value will be used in place of the given ``dict``. This can be used to provide custom deserializations (e.g. to support JSON-RPC class hinting). ``object_pairs_hook``, if specified will be called with the result of every JSON object decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. If ``strict`` is false (true is the default), then control characters will be allowed inside strings. Control characters in this context are those with character codes in the 0-31 range, including ``'\t'`` (tab), ``'\n'``, ``'\r'`` and ``'\0'``. N( R4 RK RL t floatt parse_floatR" t parse_intt _CONSTANTSt __getitem__t parse_constantR5 RU t parse_objectRX t parse_arrayR t parse_stringR t make_scannerRJ ( t selfR4 RK RZ R[ R^ R5 RL ( ( s$ /usr/lib64/python2.7/json/decoder.pyt __init__. s - c C sy | j | d | | d � j � �\ } } | | | � j � } | t | � k ru t t d | | t | � � � � n | S( sz Return the Python representation of ``s`` (a ``str`` or ``unicode`` instance containing a JSON document) t idxi s Extra data( t raw_decodeR R! R# R ( Rc R$ RM t objR ( ( s$ /usr/lib64/python2.7/json/decoder.pyt decodeg s *$i c C sF y | j | | � \ } } Wn t k r; t d � � n X| | f S( sL Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning with a JSON document) and return a 2-tuple of the Python representation and the index in ``s`` where the document ended. This can be used to decode a JSON document from a string that may have extraneous data at the end. s No JSON object could be decoded( RJ RG R# ( Rc R$ Re Rg R ( ( s$ /usr/lib64/python2.7/json/decoder.pyRf r s N( t __name__t __module__t __doc__R RF Rd t WHITESPACEt matchRh Rf ( ( ( s$ /usr/lib64/python2.7/json/decoder.pyR s 7 (% Rk t reR0 R t jsonR t _jsonR t c_scanstringt ImportErrorR t __all__t VERBOSEt MULTILINEt DOTALLt FLAGSR R t PosInft NegInfR R R\ t compilet STRINGCHUNKt BACKSLASHR( R& RF Rm RA Rl t WHITESPACE_STRRU RX t objectR ( ( ( s$ /usr/lib64/python2.7/json/decoder.pyt <module> s@ & E W$ tool.pyo 0000644 00000002416 15204113707 0006255 0 ustar 00 � { fc @ sA d Z d d l Z d d l Z d � Z e d k r= e � n d S( s Command-line tool to validate and pretty-print JSON Usage:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) i����Nc C s> t t j � d k r* t j } t j } n� t t j � d k ra t t j d d � } t j } n[ t t j � d k r� t t j d d � } t t j d d � } n t t j d d � � | �: y t j | � } Wn t k r� } t | � � n XWd QX| �4 t j | | d t d d d d �| j d � Wd QXd S( Ni i t rbi t wbi s [infile [outfile]]t sort_keyst indenti t separatorst ,s : s ( R s : ( t lent syst argvt stdint stdoutt opent SystemExitt jsont loadt ValueErrort dumpt Truet write( t infilet outfilet objt e( ( s! /usr/lib64/python2.7/json/tool.pyt main s& t __main__( t __doc__R R R t __name__( ( ( s! /usr/lib64/python2.7/json/tool.pyt <module> s decoder.pyo 0000644 00000027270 15204113710 0006704 0 ustar 00 � { fc @ s� d Z d d l Z d d l Z d d l Z d d l m Z y d d l m Z Wn e k rg d Z n Xd g Z e j e j Be j BZ d � Z e � \ Z Z Z d � Z d d � Z i e d 6e d 6e d 6Z e j d e � Z i d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6Z d Z d � Z d e e e j d � Z e pSe Z e j d e � Z d! Z e j e d" � Z! e j e d# � Z" d e# f d$ � � YZ$ d S(% s Implementation of JSONDecoder i����N( t scanner( t scanstringt JSONDecoderc C s8 t j d d � \ } t j d d � \ } | | | f S( Ns >ds � s � ( t structt unpack( t nant inf( ( s$ /usr/lib64/python2.7/json/decoder.pyt _floatconstants s c C sU | j d d | � d } | d k r2 | d } n | | j d d | � } | | f S( Ns i i ( t countt rindex( t doct post linenot colno( ( s$ /usr/lib64/python2.7/json/decoder.pyt linecol s c C sw t | | � \ } } | d k r= d } | j | | | | � St | | � \ } } d } | j | | | | | | | � S( Ns# {0}: line {1} column {2} (char {3})s? {0}: line {1} column {2} - line {3} column {4} (char {5} - {6})( R t Nonet format( t msgR R t endR R t fmtt endlinenot endcolno( ( s$ /usr/lib64/python2.7/json/decoder.pyt errmsg" s s -Infinityt Infinityt NaNs (.*?)(["\\\x00-\x1f])u "t "u \s \u /t /u t bu t fu t nu t ru t ts utf-8c C s� | | d | d !} t | � d k r_ | d d k r_ y t | d � SWq_ t k r[ q_ Xn d } t t | | | � � � d S( Ni i i t xXi s Invalid \uXXXX escape( t lent intt ValueErrorR ( t sR t escR ( ( s$ /usr/lib64/python2.7/json/decoder.pyt _decode_uXXXX? s " c C s� | d k r t } n g } | j } | d } xO| | | � } | d k rg t t d | | � � � n | j � } | j � \ } } | r� t | t � s� t | | � } n | | � n | d k r� PnL | d k r| rd j | � } t t | | | � � � q| | � q1 n y | | } Wn) t k rNt t d | | � � � n X| d k r�y | | } Wn9 t k r�d t | � } t t | | | � � � n X| d 7} n� t | | � } | d 7} t j d k rfd | k o�d k n rf| | | d !d k rft | | d � } d | k o7d k n rfd | d d >| d B} | d 7} qfn t | � } | | � q1 Wd j | � | f S( s� Scan the string s for a JSON string. End is the index of the character in s after the quote that started the JSON string. Unescapes all valid JSON string escape sequences and raises ValueError on attempt to decode an invalid string. If strict is False then literal control characters are allowed in the string. Returns a tuple of the decoded string and the index of the character in s after the end quote.i s Unterminated string starting atR s \s" Invalid control character {0!r} att us Invalid \escape: i i�� i � i�� i s \ui � i�� i i i u N( R t DEFAULT_ENCODINGt appendR# R R t groupst isinstancet unicodeR t IndexErrort KeyErrort reprR& t syst maxunicodet unichrt join( R$ R t encodingt strictt _bt _mt chunkst _appendt begint chunkt contentt terminatorR R% t chart unit uni2( ( s$ /usr/lib64/python2.7/json/decoder.pyt py_scanstringI s^ 3 s [ \t\n\r]*s c C s� | \ } } g } | j } | | | d !} | d k r� | | k rm | | | � j � } | | | d !} n | d k r� | d k r� | | � } | | d f Si } | d k r� | | � } n | | d f S| d k r� t t d | | � � � q� n | d 7} x�t r�t | | | | � \ } } | | | d !d k r�| | | � j � } | | | d !d k r�t t d | | � � � q�n | d 7} yM | | | k r�| d 7} | | | k r�| | | d � j � } q�n Wn t k r�n Xy | | | � \ } } Wn) t k r6t t d | | � � � n X| | | f � y@ | | } | | k r�| | | d � j � } | | } n Wn t k r�d } n X| d 7} | d k r�Pn+ | d k r�t t d | | d � � � n yc | | } | | k rH| d 7} | | } | | k rH| | | d � j � } | | } qHn Wn t k rbd } n X| d 7} | d k rt t d | | d � � � qqW| d k r�| | � } | | f St | � } | d k r�| | � } n | | f S( Ni R t }s1 Expecting property name enclosed in double quotest :s Expecting ':' delimiters Expecting objectt t ,s Expecting ',' delimiter( R) R R R# R t TrueR R- t StopIterationt dict( t s_and_endR4 R5 t scan_oncet object_hookt object_pairs_hookt _wt _wsR$ R t pairst pairs_appendt nextchart resultt keyt value( ( s$ /usr/lib64/python2.7/json/decoder.pyt JSONObject� s� # c C s� | \ } } g } | | | d !} | | k r\ | | | d � j � } | | | d !} n | d k rv | | d f S| j } xEt r�y | | | � \ } } Wn) t k r� t t d | | � � � n X| | � | | | d !} | | k r!| | | d � j � } | | | d !} n | d 7} | d k r;Pn' | d k rbt t d | | � � � n yM | | | k r�| d 7} | | | k r�| | | d � j � } q�n Wq� t k r�q� Xq� W| | f S( Ni t ]s Expecting objectRE s Expecting ',' delimiter( R R) RF RG R# R R- ( RI RJ RM RN R$ R t valuesRQ R9 RT ( ( s$ /usr/lib64/python2.7/json/decoder.pyt JSONArray� s@ # c B sG e Z d Z d d d d d e d d � Z e j d � Z d d � Z RS( s Simple JSON <http://json.org> decoder Performs the following translations in decoding by default: +---------------+-------------------+ | JSON | Python | +===============+===================+ | object | dict | +---------------+-------------------+ | array | list | +---------------+-------------------+ | string | unicode | +---------------+-------------------+ | number (int) | int, long | +---------------+-------------------+ | number (real) | float | +---------------+-------------------+ | true | True | +---------------+-------------------+ | false | False | +---------------+-------------------+ | null | None | +---------------+-------------------+ It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as their corresponding ``float`` values, which is outside the JSON spec. c C s� | | _ | | _ | | _ | p$ t | _ | p3 t | _ | pE t j | _ | | _ t | _ t | _ t | _ t j | � | _ d S( s� ``encoding`` determines the encoding used to interpret any ``str`` objects decoded by this instance (utf-8 by default). It has no effect when decoding ``unicode`` objects. Note that currently only encodings that are a superset of ASCII work, strings of other encodings should be passed in as ``unicode``. ``object_hook``, if specified, will be called with the result of every JSON object decoded and its return value will be used in place of the given ``dict``. This can be used to provide custom deserializations (e.g. to support JSON-RPC class hinting). ``object_pairs_hook``, if specified will be called with the result of every JSON object decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. If ``strict`` is false (true is the default), then control characters will be allowed inside strings. Control characters in this context are those with character codes in the 0-31 range, including ``'\t'`` (tab), ``'\n'``, ``'\r'`` and ``'\0'``. N( R4 RK RL t floatt parse_floatR" t parse_intt _CONSTANTSt __getitem__t parse_constantR5 RU t parse_objectRX t parse_arrayR t parse_stringR t make_scannerRJ ( t selfR4 RK RZ R[ R^ R5 RL ( ( s$ /usr/lib64/python2.7/json/decoder.pyt __init__. s - c C sy | j | d | | d � j � �\ } } | | | � j � } | t | � k ru t t d | | t | � � � � n | S( sz Return the Python representation of ``s`` (a ``str`` or ``unicode`` instance containing a JSON document) t idxi s Extra data( t raw_decodeR R! R# R ( Rc R$ RM t objR ( ( s$ /usr/lib64/python2.7/json/decoder.pyt decodeg s *$i c C sF y | j | | � \ } } Wn t k r; t d � � n X| | f S( sL Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning with a JSON document) and return a 2-tuple of the Python representation and the index in ``s`` where the document ended. This can be used to decode a JSON document from a string that may have extraneous data at the end. s No JSON object could be decoded( RJ RG R# ( Rc R$ Re Rg R ( ( s$ /usr/lib64/python2.7/json/decoder.pyRf r s N( t __name__t __module__t __doc__R RF Rd t WHITESPACEt matchRh Rf ( ( ( s$ /usr/lib64/python2.7/json/decoder.pyR s 7 (% Rk t reR0 R t jsonR t _jsonR t c_scanstringt ImportErrorR t __all__t VERBOSEt MULTILINEt DOTALLt FLAGSR R t PosInft NegInfR R R\ t compilet STRINGCHUNKt BACKSLASHR( R& RF Rm RA Rl t WHITESPACE_STRRU RX t objectR ( ( ( s$ /usr/lib64/python2.7/json/decoder.pyt <module> s@ & E W$ __init__.pyc 0000644 00000033146 15204113710 0007021 0 ustar 00 � { fc @ s, d Z d Z d d d d d d g Z d Z d d l m Z d d l m Z e d e d e d e d e d d d d d d d d � Z e e e e d d d d d e d � Z e e e e d d d d d e d � Z e d d d d d d � Z d d d d d d d d � Z d d d d d d d d � Z d S( s� JSON (JavaScript Object Notation) <http://json.org> is a subset of JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data interchange format. :mod:`json` exposes an API familiar to users of the standard library :mod:`marshal` and :mod:`pickle` modules. It is the externally maintained version of the :mod:`json` library contained in Python 2.6, but maintains compatibility with Python 2.4 and Python 2.5 and (currently) has significant performance advantages, even without using the optional C extension for speedups. Encoding basic Python object hierarchies:: >>> import json >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}]) '["foo", {"bar": ["baz", null, 1.0, 2]}]' >>> print json.dumps("\"foo\bar") "\"foo\bar" >>> print json.dumps(u'\u1234') "\u1234" >>> print json.dumps('\\') "\\" >>> print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True) {"a": 0, "b": 0, "c": 0} >>> from StringIO import StringIO >>> io = StringIO() >>> json.dump(['streaming API'], io) >>> io.getvalue() '["streaming API"]' Compact encoding:: >>> import json >>> json.dumps([1,2,3,{'4': 5, '6': 7}], sort_keys=True, separators=(',',':')) '[1,2,3,{"4":5,"6":7}]' Pretty printing:: >>> import json >>> print json.dumps({'4': 5, '6': 7}, sort_keys=True, ... indent=4, separators=(',', ': ')) { "4": 5, "6": 7 } Decoding JSON:: >>> import json >>> obj = [u'foo', {u'bar': [u'baz', None, 1.0, 2]}] >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj True >>> json.loads('"\\"foo\\bar"') == u'"foo\x08ar' True >>> from StringIO import StringIO >>> io = StringIO('["streaming API"]') >>> json.load(io)[0] == 'streaming API' True Specializing JSON object decoding:: >>> import json >>> def as_complex(dct): ... if '__complex__' in dct: ... return complex(dct['real'], dct['imag']) ... return dct ... >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}', ... object_hook=as_complex) (1+2j) >>> from decimal import Decimal >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1') True Specializing JSON object encoding:: >>> import json >>> def encode_complex(obj): ... if isinstance(obj, complex): ... return [obj.real, obj.imag] ... raise TypeError(repr(obj) + " is not JSON serializable") ... >>> json.dumps(2 + 1j, default=encode_complex) '[2.0, 1.0]' >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j) '[2.0, 1.0]' >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j)) '[2.0, 1.0]' Using json.tool from the shell to validate and pretty-print:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) s 2.0.9t dumpt dumpst loadt loadst JSONDecodert JSONEncoders Bob Ippolito <bob@redivi.com>i ( R ( R t skipkeyst ensure_asciit check_circulart allow_nant indentt separatorst encodings utf-8t defaultc K s� | ru | ru | ru | ru | d k ru | d k ru | d k ru | d k ru | d k ru | ru | ru t j | � } n` | d k r� t } n | d | d | d | d | d | d | d | d | d | | � j | � } x | D] } | j | � q� Wd S( s� Serialize ``obj`` as a JSON formatted stream to ``fp`` (a ``.write()``-supporting file-like object). If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is true (the default), all non-ASCII characters in the output are escaped with ``\uXXXX`` sequences, and the result is a ``str`` instance consisting of ASCII characters only. If ``ensure_ascii`` is false, some chunks written to ``fp`` may be ``unicode`` instances. This usually happens because the input contains unicode strings or the ``encoding`` parameter is used. Unless ``fp.write()`` explicitly understands ``unicode`` (as in ``codecs.getwriter``) this is likely to cause an error. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. Since the default item separator is ``', '``, the output might include trailing whitespace when ``indent`` is specified. You can use ``separators=(',', ': ')`` to avoid this. If ``separators`` is an ``(item_separator, dict_separator)`` tuple then it will be used instead of the default ``(', ', ': ')`` separators. ``(',', ':')`` is the most compact JSON representation. ``encoding`` is the character encoding for str instances, default is UTF-8. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. s utf-8R R R R R R R R t sort_keysN( t Nonet _default_encodert iterencodeR t write( t objt fpR R R R t clsR R R R R t kwt iterablet chunk( ( s% /usr/lib64/python2.7/json/__init__.pyR z s 5 $& c K s� | rp | rp | rp | rp | d k rp | d k rp | d k rp | d k rp | d k rp | rp | rp t j | � S| d k r� t } n | d | d | d | d | d | d | d | d | d | | � j | � S( s Serialize ``obj`` to a JSON formatted ``str``. If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, all non-ASCII characters are not escaped, and the return value may be a ``unicode`` instance. See ``dump`` for details. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. Since the default item separator is ``', '``, the output might include trailing whitespace when ``indent`` is specified. You can use ``separators=(',', ': ')`` to avoid this. If ``separators`` is an ``(item_separator, dict_separator)`` tuple then it will be used instead of the default ``(', ', ': ')`` separators. ``(',', ':')`` is the most compact JSON representation. ``encoding`` is the character encoding for str instances, default is UTF-8. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. s utf-8R R R R R R R R R N( R R t encodeR ( R R R R R R R R R R R R ( ( s% /usr/lib64/python2.7/json/__init__.pyR � s / $& t object_hookt object_pairs_hookc K s= t | j � d | d | d | d | d | d | d | | �S( s� Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. If the contents of ``fp`` is encoded with an ASCII based encoding other than utf-8 (e.g. latin-1), then an appropriate ``encoding`` name must be specified. Encodings that are not ASCII based (such as UCS-2) are not allowed, and should be wrapped with ``codecs.getreader(fp)(encoding)``, or simply decoded to a ``unicode`` object and passed to ``loads()`` ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. R R R t parse_floatt parse_intt parse_constantR ( R t read( R R R R R R R R R ( ( s% /usr/lib64/python2.7/json/__init__.pyR s c K s | d k rh | d k rh | d k rh | d k rh | d k rh | d k rh | d k rh | rh t j | � S| d k r} t } n | d k r� | | d <n | d k r� | | d <n | d k r� | | d <n | d k r� | | d <n | d k r� | | d <n | d | | � j | � S( s� Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON document) to a Python object. If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name must be specified. Encodings that are not ASCII based (such as UCS-2) are not allowed and should be decoded to ``unicode`` first. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. R R R R R R N( R t _default_decodert decodeR ( t sR R R R R R R R ( ( s% /usr/lib64/python2.7/json/__init__.pyR & s" *$ N( t __doc__t __version__t __all__t __author__t decoderR t encoderR t Falset TrueR R R R R R R ( ( ( s% /usr/lib64/python2.7/json/__init__.pyt <module>c s6 E ; # __pycache__/__init__.cpython-36.opt-2.pyc 0000644 00000005655 15204140032 0014103 0 ustar 00 3 \<8 � @ s� d Z dddddddgZdZd d lmZmZ d d lmZ d d lZeddddd d d d�Z ddddd d d d dd� dd�Z ddddd d d d dd� dd�Z ed d d�Z dd� Z d d d d d d d�dd�Zd d d d d d d d�dd�Zd S )z2.0.9�dump�dumps�load�loads� JSONDecoder�JSONDecodeError� JSONEncoderz Bob Ippolito <bob@redivi.com>� )r r )r � NFT)�skipkeys� ensure_ascii�check_circular� allow_nan�indent� separators�default) r r r r �clsr r r � sort_keysc K s� | rJ|rJ|rJ|rJ|d krJ|d krJ|d krJ| d krJ| rJ| rJt j| �} n2|d krVt}|f ||||||| | d�| ��j| �} x| D ]} |j| � q�W d S )N)r r r r r r r r )�_default_encoder� iterencoder �write)�obj�fpr r r r r r r r r �kw�iterable�chunk� r �%/usr/lib64/python3.6/json/__init__.pyr x s - c K sz | rH|rH|rH|rH|d krH|d krH|d krH|d krH| rH| rHt j| �S |d krTt}|f |||||||| d�| ��j| �S )N)r r r r r r r r )r �encoder ) r r r r r r r r r r r r r r r � s , )� object_hook�object_pairs_hookc C s� | j }|tjtjf�rdS |tjtjf�r.dS |tj�r<dS t| �dkr�| d s`| d r\dS dS | d s�| d sx| d r|d S d S n$t| �d kr�| d s�dS | d s�d S d S )Nzutf-32zutf-16z utf-8-sig� r r z utf-16-bez utf-32-be� � z utf-16-lez utf-32-lezutf-8)� startswith�codecs� BOM_UTF32_BE� BOM_UTF32_LE� BOM_UTF16_BE� BOM_UTF16_LE�BOM_UTF8�len)�bZ bstartswithr r r �detect_encoding� s$ r, )r r � parse_float� parse_int�parse_constantr c K s" t | j� f||||||d�|��S )N)r r r- r. r/ r )r �read)r r r r- r. r/ r r r r r r s )�encodingr r r- r. r/ r c K s� t | t�r"| jd�rRtd| d��n0t | ttf�sBtdj| jj ���| j t | �d�} |d kr�|d kr�|d kr�|d kr�|d kr�|d kr�| r�t j | �S |d kr�t }|d k r�||d< |d k r�||d< |d k r�||d< |d k r�||d < |d k r�||d < |f |�j | �S ) Nu z-Unexpected UTF-8 BOM (decode using utf-8-sig)r z9the JSON object must be str, bytes or bytearray, not {!r}� surrogatepassr r r- r. r/ )� isinstance�strr# r �bytes� bytearray� TypeError�format� __class__�__name__�decoder, �_default_decoderr ) �sr1 r r r- r. r/ r r r r r r . s2 ' )� __version__�__all__� __author__�decoderr r �encoderr r$ r r r r< r, r r r r r r �<module>b s4 =8 __pycache__/scanner.cpython-36.opt-2.pyc 0000644 00000003620 15204140032 0013763 0 ustar 00 3 \o � @ sf d dl Z yd dlmZ W n ek r0 dZY nX dgZe jde je jB e j B �Z dd� Z ep`e ZdS )� N)� make_scannerr z)(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c sv | j � | j�| j� tj�| j� | j�| j�| j�| j �| j �| j �� ��������� � � f dd�� � �fdd�}|S )Nc s� y | | }W n t k r( t|��Y nX |dkrB� | |d � �S |dkrd� | |d f� � ����S |dkr~�| |d f� �S |dkr�| ||d � dkr�d |d fS |dkr�| ||d � d kr�d |d fS |d ko�| ||d � d k� r�d|d fS �| |�}|d k �rX|j� \}}}|�s&|�rD�||�p2d |�p<d �}n�|�}||j� fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r�d�|d fS t|��d S )N�"� �{�[�n� Znull�t�trueT�f� ZfalseF� �N� ZNaN�I� ZInfinity�-� z -Infinity)� IndexError� StopIteration�groups�end)�string�idxZnextchar�mZintegerZfracZexp�res) � _scan_once� match_number�memo� object_hook�object_pairs_hook� parse_array�parse_constant� parse_float� parse_int� parse_object� parse_string�strict� �$/usr/lib64/python3.6/json/scanner.pyr s> z#py_make_scanner.<locals>._scan_oncec s z � | |�S �j � X d S )N)�clear)r r )r r r( r) � scan_onceA s z"py_make_scanner.<locals>.scan_once) r% r! r& � NUMBER_RE�matchr' r# r$ r" r r r )�contextr+ r( ) r r r r r r! r" r# r$ r% r& r' r) �py_make_scanner s "%r/ ) �reZ_jsonr Zc_make_scanner� ImportError�__all__�compile�VERBOSE� MULTILINE�DOTALLr, r/ r( r( r( r) �<module> s : __pycache__/encoder.cpython-36.opt-1.pyc 0000644 00000025773 15204140032 0013765 0 ustar 00 3 \�> � " @ sB d Z ddlZyddlmZ W n ek r4 dZY nX yddlmZ W n ek r^ dZY nX yddlmZ W n ek r� dZ Y nX ej d�Z ej d�Z ej d�Z d d d d d ddd�Zx&ed�D ]Zejee�dje�� q�W ed�Zdd� Zep�eZdd� Ze�p eZG dd� de�Zeeee e e e e e!e j"f dd�Z#dS ) z Implementation of JSONEncoder � N)�encode_basestring_ascii)�encode_basestring)� make_encoderz[\x00-\x1f\\"\b\f\n\r\t]z([\\"]|[^\ -~])s [�-�]z\\z\"z\bz\fz\nz\rz\t)�\�"�� � � � � z \u{0:04x}�infc C s dd� }dt j|| � d S )z5Return a JSON representation of a Python string c S s t | jd� S )Nr )� ESCAPE_DCT�group)�match� r �$/usr/lib64/python3.6/json/encoder.py�replace( s z%py_encode_basestring.<locals>.replacer )�ESCAPE�sub)�sr r r r �py_encode_basestring$ s r c C s dd� }dt j|| � d S )zAReturn an ASCII-only JSON representation of a Python string c S sv | j d�}yt| S tk rp t|�}|dk r<dj|�S |d8 }d|d? d@ B }d|d@ B }dj||�S Y nX d S ) Nr i z \u{0:04x}i � � i� i � z\u{0:04x}\u{1:04x})r r �KeyError�ord�format)r r �n�s1�s2r r r r 4 s z+py_encode_basestring_ascii.<locals>.replacer )� ESCAPE_ASCIIr )r r r r r �py_encode_basestring_ascii0 s r c @ sN e Zd ZdZdZdZddddddddd�dd �Zd d � Zd d � Zddd�Z dS )� JSONEncoderaZ Extensible JSON <http://json.org> encoder for Python data structures. Supports the following objects and types by default: +-------------------+---------------+ | Python | JSON | +===================+===============+ | dict | object | +-------------------+---------------+ | list, tuple | array | +-------------------+---------------+ | str | string | +-------------------+---------------+ | int, float | number | +-------------------+---------------+ | True | true | +-------------------+---------------+ | False | false | +-------------------+---------------+ | None | null | +-------------------+---------------+ To extend this to recognize other objects, subclass and implement a ``.default()`` method with another method that returns a serializable object for ``o`` if possible, otherwise it should call the superclass implementation (to raise ``TypeError``). z, z: FTN)�skipkeys� ensure_ascii�check_circular� allow_nan� sort_keys�indent� separators�defaultc C sZ || _ || _|| _|| _|| _|| _|dk r:|\| _| _n|dk rHd| _|dk rV|| _dS )a� Constructor for JSONEncoder, with sensible defaults. If skipkeys is false, then it is a TypeError to attempt encoding of keys that are not str, int, float or None. If skipkeys is True, such items are simply skipped. If ensure_ascii is true, the output is guaranteed to be str objects with all incoming non-ASCII characters escaped. If ensure_ascii is false, the output can contain non-ASCII characters. If check_circular is true, then lists, dicts, and custom encoded objects will be checked for circular references during encoding to prevent an infinite recursion (which would cause an OverflowError). Otherwise, no such check takes place. If allow_nan is true, then NaN, Infinity, and -Infinity will be encoded as such. This behavior is not JSON specification compliant, but is consistent with most JavaScript based encoders and decoders. Otherwise, it will be a ValueError to encode such floats. If sort_keys is true, then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis. If indent is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. None is the most compact representation. If specified, separators should be an (item_separator, key_separator) tuple. The default is (', ', ': ') if *indent* is ``None`` and (',', ': ') otherwise. To get the most compact JSON representation, you should specify (',', ':') to eliminate whitespace. If specified, default is a function that gets called for objects that can't otherwise be serialized. It should return a JSON encodable version of the object or raise a ``TypeError``. N�,) r" r# r$ r% r& r' �item_separator� key_separatorr) ) �selfr" r# r$ r% r& r' r( r) r r r �__init__h s +zJSONEncoder.__init__c C s t d|jj ��dS )al Implement this method in a subclass such that it returns a serializable object for ``o``, or calls the base implementation (to raise a ``TypeError``). For example, to support arbitrary iterators, you could implement default like this:: def default(self, o): try: iterable = iter(o) except TypeError: pass else: return list(iterable) # Let the base class default method raise the TypeError return JSONEncoder.default(self, o) z,Object of type '%s' is not JSON serializableN)� TypeError� __class__�__name__)r- �or r r r) � s zJSONEncoder.defaultc C sN t |t�r | jrt|�S t|�S | j|dd�}t |ttf�sDt|�}dj|�S )z�Return a JSON string representation of a Python data structure. >>> from json.encoder import JSONEncoder >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo": ["bar", "baz"]}' T)� _one_shot� ) � isinstance�strr# r r � iterencode�list�tuple�join)r- r2 �chunksr r r �encode� s zJSONEncoder.encodec C s� | j r i }nd}| jr t}nt}| jtjtt fdd�}|rvtdk rv| j dkrvt|| j || j | j | j | j | j| j� }n&t|| j || j || j | j | j | j|� }||d�S )z�Encode the given object and yield each string representation as available. For example:: for chunk in JSONEncoder().iterencode(bigobject): mysocket.write(chunk) Nc S sJ | | krd}n$| |kr d}n| |kr*d}n|| �S |sFt dt| � ��|S )NZNaNZInfinityz -Infinityz2Out of range float values are not JSON compliant: )� ValueError�repr)r2 r% Z_reprZ_infZ_neginf�textr r r �floatstr� s z(JSONEncoder.iterencode.<locals>.floatstrr )r$ r# r r r% �float�__repr__�INFINITY�c_make_encoderr' r) r, r+ r& r" �_make_iterencode)r- r2 r3 �markers�_encoderr@ � _iterencoder r r r7 � s& zJSONEncoder.iterencode)F) r1 � __module__� __qualname__�__doc__r+ r, r. r) r< r7 r r r r r! I s 6r! c s� �d k r ���� r d� �� �������� � ��������fdd�� � �������� � � � � ��������fdd��� ������� � ��������fdd���S )N� c 3 s� | sdV d S �d k r6� | �}|�kr.� d��| �|< d}�d k rh|d7 }d�| }�| }||7 }nd }�}d}x�| D ]�}|r�d}n|}� |��r�|�|� V qz|d kr�|d V qz|dkr�|d V qz|dkr�|d V qz� |� �r�|�|� V qz� |� ��r|�|� V qz|V � |��f��r:�||�}n"� |� ��rR�||�}n �||�}|E d H qzW |d k �r�|d8 }d�| V d V �d k �r��|= d S ) Nz[]zCircular reference detected�[� r TF�null�true�false�]r ) Zlst�_current_indent_level�markeridZbuf�newline_indentZ separator�first�valuer; )r= rG � _floatstr�_indent�_intstr�_item_separatorrH �_iterencode_dict�_iterencode_list�dictrA �id�intr5 r8 rF r6 r9 r r r] s\ z*_make_iterencode.<locals>._iterencode_listc 3 sL | sdV d S �d k r6�| �}|�kr.� d��| �|< dV �d k rh|d7 }d�| }�| }|V nd }�}d}� r�t | j� dd� d �}n| j� }�xx|D �]n\}}�|��r�nr�|� �rȈ|�}n^|dkr�d }nP|d kr�d }nB|d kr�d }n4�|���r�|�}n � �rq�ntdt|� d ��|�r2d }n|V �|�V � V �|���r`�|�V q�|d k�rrd V q�|dk�r�d V q�|d k�r�d V q��|���r��|�V q��|� ��rƈ|�V q��|��f��r�||�} n"�|� ��r��||�} n �||�} | E d H q�W |d k �r2|d8 }d�| V dV �d k �rH�|= d S )Nz{}zCircular reference detected�{rN r Tc S s | d S )Nr r )Zkvr r r �<lambda>a s z<_make_iterencode.<locals>._iterencode_dict.<locals>.<lambda>)�keyrP FrQ rO zkey z is not a string�})�sorted�itemsr/ r> ) ZdctrS rT rU r+ rV rf rc rW r; )r= rG rX rY rZ r[ rH r\ r] �_key_separator� _skipkeys� _sort_keysr^ rA r_ r` r5 r8 rF r6 r9 r r r\ M s� z*_make_iterencode.<locals>._iterencode_dictc 3 s � | ��r�| �V n�| d kr&dV n�| dkr6dV n�| dkrFdV n�� | � �r\�| �V n�� | � �rr�| �V n�� | � �f�r��| |�E d H nj� | ��r��| |�E d H nN�d k rֈ | �}|�krΈ d��| �|< �| �} �| |�E d H �d k r��|= d S )NrO TrP FrQ zCircular reference detectedr )r2 rS rT )r= �_defaultrG rX rZ rH r\ r] r^ rA r_ r` r5 r8 rF r6 r9 r r rH � s2 z%_make_iterencode.<locals>._iterencoder )rF rj rG rY rX rg r[ ri rh r3 r= r^ rA r_ r` r5 r8 r6 r9 rZ r )r= rj rG rX rY rZ r[ rH r\ r] rg rh ri r^ rA r_ r` r5 r8 rF r6 r9 r rE s .84O, rE )$rK �reZ_jsonr Zc_encode_basestring_ascii� ImportErrorr Zc_encode_basestringr rD �compiler r ZHAS_UTF8r �range�i� setdefault�chrr rA rC r r �objectr! r= r^ r_ r` r5 r8 r6 r9 �__str__rE r r r r �<module> sT > __pycache__/tool.cpython-36.opt-1.pyc 0000644 00000003013 15204140032 0013302 0 ustar 00 3 \m � @ s> d Z ddlZddlZddlZddlZdd� Zedkr:e� dS )a Command-line tool to validate and pretty-print JSON Usage:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) � Nc " C s d} d}t j| |d�}|jddt j� dd� |jddt jd �d d� |jd d d dd� |j� }|jphtj}|jpttj }|j }|�V y$|r�t j |�}nt j |t jd�}W n* tk r� } zt|��W Y d d }~X nX W d Q R X |�" t j|||dd� |jd� W d Q R X d S )Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)�prog� description�infile�?z-a JSON file to be validated or pretty-printed)�nargs�type�help�outfile�wz%write the output of infile to outfilez --sort-keys� store_trueFz5sort the output of dictionaries alphabetically by key)�action�defaultr )Zobject_pairs_hook� )� sort_keys�indent� )�argparse�ArgumentParser� add_argumentZFileType� parse_argsr �sys�stdinr �stdoutr �json�load� collections� OrderedDict� ValueError� SystemExit�dump�write) r r �parserZoptionsr r r �obj�e� r$ �!/usr/lib64/python3.6/json/tool.py�main s0 $r& �__main__)�__doc__r r r r r& �__name__r$ r$ r$ r% �<module> s __pycache__/encoder.cpython-36.pyc 0000644 00000025773 15204140032 0013026 0 ustar 00 3 \�> � " @ sB d Z ddlZyddlmZ W n ek r4 dZY nX yddlmZ W n ek r^ dZY nX yddlmZ W n ek r� dZ Y nX ej d�Z ej d�Z ej d�Z d d d d d ddd�Zx&ed�D ]Zejee�dje�� q�W ed�Zdd� Zep�eZdd� Ze�p eZG dd� de�Zeeee e e e e e!e j"f dd�Z#dS ) z Implementation of JSONEncoder � N)�encode_basestring_ascii)�encode_basestring)� make_encoderz[\x00-\x1f\\"\b\f\n\r\t]z([\\"]|[^\ -~])s [�-�]z\\z\"z\bz\fz\nz\rz\t)�\�"�� � � � � z \u{0:04x}�infc C s dd� }dt j|| � d S )z5Return a JSON representation of a Python string c S s t | jd� S )Nr )� ESCAPE_DCT�group)�match� r �$/usr/lib64/python3.6/json/encoder.py�replace( s z%py_encode_basestring.<locals>.replacer )�ESCAPE�sub)�sr r r r �py_encode_basestring$ s r c C s dd� }dt j|| � d S )zAReturn an ASCII-only JSON representation of a Python string c S sv | j d�}yt| S tk rp t|�}|dk r<dj|�S |d8 }d|d? d@ B }d|d@ B }dj||�S Y nX d S ) Nr i z \u{0:04x}i � � i� i � z\u{0:04x}\u{1:04x})r r �KeyError�ord�format)r r �n�s1�s2r r r r 4 s z+py_encode_basestring_ascii.<locals>.replacer )� ESCAPE_ASCIIr )r r r r r �py_encode_basestring_ascii0 s r c @ sN e Zd ZdZdZdZddddddddd�dd �Zd d � Zd d � Zddd�Z dS )� JSONEncoderaZ Extensible JSON <http://json.org> encoder for Python data structures. Supports the following objects and types by default: +-------------------+---------------+ | Python | JSON | +===================+===============+ | dict | object | +-------------------+---------------+ | list, tuple | array | +-------------------+---------------+ | str | string | +-------------------+---------------+ | int, float | number | +-------------------+---------------+ | True | true | +-------------------+---------------+ | False | false | +-------------------+---------------+ | None | null | +-------------------+---------------+ To extend this to recognize other objects, subclass and implement a ``.default()`` method with another method that returns a serializable object for ``o`` if possible, otherwise it should call the superclass implementation (to raise ``TypeError``). z, z: FTN)�skipkeys� ensure_ascii�check_circular� allow_nan� sort_keys�indent� separators�defaultc C sZ || _ || _|| _|| _|| _|| _|dk r:|\| _| _n|dk rHd| _|dk rV|| _dS )a� Constructor for JSONEncoder, with sensible defaults. If skipkeys is false, then it is a TypeError to attempt encoding of keys that are not str, int, float or None. If skipkeys is True, such items are simply skipped. If ensure_ascii is true, the output is guaranteed to be str objects with all incoming non-ASCII characters escaped. If ensure_ascii is false, the output can contain non-ASCII characters. If check_circular is true, then lists, dicts, and custom encoded objects will be checked for circular references during encoding to prevent an infinite recursion (which would cause an OverflowError). Otherwise, no such check takes place. If allow_nan is true, then NaN, Infinity, and -Infinity will be encoded as such. This behavior is not JSON specification compliant, but is consistent with most JavaScript based encoders and decoders. Otherwise, it will be a ValueError to encode such floats. If sort_keys is true, then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis. If indent is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. None is the most compact representation. If specified, separators should be an (item_separator, key_separator) tuple. The default is (', ', ': ') if *indent* is ``None`` and (',', ': ') otherwise. To get the most compact JSON representation, you should specify (',', ':') to eliminate whitespace. If specified, default is a function that gets called for objects that can't otherwise be serialized. It should return a JSON encodable version of the object or raise a ``TypeError``. N�,) r" r# r$ r% r& r' �item_separator� key_separatorr) ) �selfr" r# r$ r% r& r' r( r) r r r �__init__h s +zJSONEncoder.__init__c C s t d|jj ��dS )al Implement this method in a subclass such that it returns a serializable object for ``o``, or calls the base implementation (to raise a ``TypeError``). For example, to support arbitrary iterators, you could implement default like this:: def default(self, o): try: iterable = iter(o) except TypeError: pass else: return list(iterable) # Let the base class default method raise the TypeError return JSONEncoder.default(self, o) z,Object of type '%s' is not JSON serializableN)� TypeError� __class__�__name__)r- �or r r r) � s zJSONEncoder.defaultc C sN t |t�r | jrt|�S t|�S | j|dd�}t |ttf�sDt|�}dj|�S )z�Return a JSON string representation of a Python data structure. >>> from json.encoder import JSONEncoder >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo": ["bar", "baz"]}' T)� _one_shot� ) � isinstance�strr# r r � iterencode�list�tuple�join)r- r2 �chunksr r r �encode� s zJSONEncoder.encodec C s� | j r i }nd}| jr t}nt}| jtjtt fdd�}|rvtdk rv| j dkrvt|| j || j | j | j | j | j| j� }n&t|| j || j || j | j | j | j|� }||d�S )z�Encode the given object and yield each string representation as available. For example:: for chunk in JSONEncoder().iterencode(bigobject): mysocket.write(chunk) Nc S sJ | | krd}n$| |kr d}n| |kr*d}n|| �S |sFt dt| � ��|S )NZNaNZInfinityz -Infinityz2Out of range float values are not JSON compliant: )� ValueError�repr)r2 r% Z_reprZ_infZ_neginf�textr r r �floatstr� s z(JSONEncoder.iterencode.<locals>.floatstrr )r$ r# r r r% �float�__repr__�INFINITY�c_make_encoderr' r) r, r+ r& r" �_make_iterencode)r- r2 r3 �markers�_encoderr@ � _iterencoder r r r7 � s& zJSONEncoder.iterencode)F) r1 � __module__� __qualname__�__doc__r+ r, r. r) r< r7 r r r r r! I s 6r! c s� �d k r ���� r d� �� �������� � ��������fdd�� � �������� � � � � ��������fdd��� ������� � ��������fdd���S )N� c 3 s� | sdV d S �d k r6� | �}|�kr.� d��| �|< d}�d k rh|d7 }d�| }�| }||7 }nd }�}d}x�| D ]�}|r�d}n|}� |��r�|�|� V qz|d kr�|d V qz|dkr�|d V qz|dkr�|d V qz� |� �r�|�|� V qz� |� ��r|�|� V qz|V � |��f��r:�||�}n"� |� ��rR�||�}n �||�}|E d H qzW |d k �r�|d8 }d�| V d V �d k �r��|= d S ) Nz[]zCircular reference detected�[� r TF�null�true�false�]r ) Zlst�_current_indent_level�markeridZbuf�newline_indentZ separator�first�valuer; )r= rG � _floatstr�_indent�_intstr�_item_separatorrH �_iterencode_dict�_iterencode_list�dictrA �id�intr5 r8 rF r6 r9 r r r] s\ z*_make_iterencode.<locals>._iterencode_listc 3 sL | sdV d S �d k r6�| �}|�kr.� d��| �|< dV �d k rh|d7 }d�| }�| }|V nd }�}d}� r�t | j� dd� d �}n| j� }�xx|D �]n\}}�|��r�nr�|� �rȈ|�}n^|dkr�d }nP|d kr�d }nB|d kr�d }n4�|���r�|�}n � �rq�ntdt|� d ��|�r2d }n|V �|�V � V �|���r`�|�V q�|d k�rrd V q�|dk�r�d V q�|d k�r�d V q��|���r��|�V q��|� ��rƈ|�V q��|��f��r�||�} n"�|� ��r��||�} n �||�} | E d H q�W |d k �r2|d8 }d�| V dV �d k �rH�|= d S )Nz{}zCircular reference detected�{rN r Tc S s | d S )Nr r )Zkvr r r �<lambda>a s z<_make_iterencode.<locals>._iterencode_dict.<locals>.<lambda>)�keyrP FrQ rO zkey z is not a string�})�sorted�itemsr/ r> ) ZdctrS rT rU r+ rV rf rc rW r; )r= rG rX rY rZ r[ rH r\ r] �_key_separator� _skipkeys� _sort_keysr^ rA r_ r` r5 r8 rF r6 r9 r r r\ M s� z*_make_iterencode.<locals>._iterencode_dictc 3 s � | ��r�| �V n�| d kr&dV n�| dkr6dV n�| dkrFdV n�� | � �r\�| �V n�� | � �rr�| �V n�� | � �f�r��| |�E d H nj� | ��r��| |�E d H nN�d k rֈ | �}|�krΈ d��| �|< �| �} �| |�E d H �d k r��|= d S )NrO TrP FrQ zCircular reference detectedr )r2 rS rT )r= �_defaultrG rX rZ rH r\ r] r^ rA r_ r` r5 r8 rF r6 r9 r r rH � s2 z%_make_iterencode.<locals>._iterencoder )rF rj rG rY rX rg r[ ri rh r3 r= r^ rA r_ r` r5 r8 r6 r9 rZ r )r= rj rG rX rY rZ r[ rH r\ r] rg rh ri r^ rA r_ r` r5 r8 rF r6 r9 r rE s .84O, rE )$rK �reZ_jsonr Zc_encode_basestring_ascii� ImportErrorr Zc_encode_basestringr rD �compiler r ZHAS_UTF8r �range�i� setdefault�chrr rA rC r r �objectr! r= r^ r_ r` r5 r8 r6 r9 �__str__rE r r r r �<module> sT > __pycache__/scanner.cpython-36.opt-1.pyc 0000644 00000003664 15204140032 0013772 0 ustar 00 3 \o � @ sj d Z ddlZyddlmZ W n ek r4 dZY nX dgZejdejej B ej B �Z dd� Z epde ZdS )zJSON token scanner � N)� make_scannerr z)(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c sv | j � | j�| j� tj�| j� | j�| j�| j�| j �| j �| j �� ��������� � � f dd�� � �fdd�}|S )Nc s� y | | }W n t k r( t|��Y nX |dkrB� | |d � �S |dkrd� | |d f� � ����S |dkr~�| |d f� �S |dkr�| ||d � dkr�d |d fS |dkr�| ||d � d kr�d |d fS |d ko�| ||d � d k� r�d|d fS �| |�}|d k �rX|j� \}}}|�s&|�rD�||�p2d |�p<d �}n�|�}||j� fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r�d�|d fS t|��d S )N�"� �{�[�n� Znull�t�trueT�f� ZfalseF� �N� ZNaN�I� ZInfinity�-� z -Infinity)� IndexError� StopIteration�groups�end)�string�idxZnextchar�mZintegerZfracZexp�res) � _scan_once� match_number�memo� object_hook�object_pairs_hook� parse_array�parse_constant� parse_float� parse_int� parse_object� parse_string�strict� �$/usr/lib64/python3.6/json/scanner.pyr s> z#py_make_scanner.<locals>._scan_oncec s z � | |�S �j � X d S )N)�clear)r r )r r r( r) � scan_onceA s z"py_make_scanner.<locals>.scan_once) r% r! r& � NUMBER_RE�matchr' r# r$ r" r r r )�contextr+ r( ) r r r r r r! r" r# r$ r% r& r' r) �py_make_scanner s "%r/ ) �__doc__�reZ_jsonr Zc_make_scanner� ImportError�__all__�compile�VERBOSE� MULTILINE�DOTALLr, r/ r( r( r( r) �<module> s : __pycache__/decoder.cpython-36.opt-2.pyc 0000644 00000013261 15204140032 0013741 0 ustar 00 3 \)1 � @ s d dl Z d dlmZ yd dlmZ W n ek r< dZY nX ddgZe je j B e j B Z e d�Z e d�Ze d�ZG d d� de�Zeee d �Ze jd e �Zd d ddddddd�Zdd� Zdeejfdd�Zep�eZe jde �ZdZdejefd d �Zejefd d �Z G d d� de �Z dS )!� N)�scanner)� scanstring� JSONDecoder�JSONDecodeError�nan�infz-infc @ s e Zd Zdd� Zdd� ZdS )r c C sb |j dd|�d }||jdd|� }d||||f }tj| |� || _|| _|| _|| _|| _d S )N� r � z %s: line %d column %d (char %d)) �count�rfind� ValueError�__init__�msg�doc�pos�lineno�colno)�selfr r r r r �errmsg� r �$/usr/lib64/python3.6/json/decoder.pyr s zJSONDecodeError.__init__c C s | j | j| j| jffS )N)� __class__r r r )r r r r � __reduce__* s zJSONDecodeError.__reduce__N)�__name__� __module__� __qualname__r r r r r r r s )z -InfinityZInfinity�NaNz(.*?)(["\\\x00-\x1f])�"�\�/�� r � � )r r r �b�f�n�r�tc C s` | |d |d � }t |�dkrL|d dkrLy t|d�S tk rJ Y nX d}t|| |��d S )Nr � � ZxX� zInvalid \uXXXX escape)�len�intr r )�sr �escr r r r � _decode_uXXXX; s r0 Tc C s� g }|j }|d }�x�|| |�}|d kr4td| |��|j� }|j� \} } | rT|| � | dkr`P n.| dkr�|r�dj| �} t| | |��n || � qy | | } W n tk r� td| |��Y nX | dk�ry || } W n* tk r� dj| �} t| | |��Y nX |d7 }n�t| |�}|d7 }d | k�o.d kn �r�| ||d � d k�r�t| |d �}d | k�ondkn �r�d|d d> |d B }|d7 }t|�} || � qW dj |�|fS )Nr z Unterminated string starting atr r z"Invalid control character {0!r} at�uzInvalid \escape: {0!r}r) i � i�� � z\ui � i�� i � � � ) �appendr �end�groups�format� IndexError�KeyErrorr0 �chr�join)r. r7 �strictZ_bZ_mZchunks�_appendZbegin�chunkZcontent� terminatorr r/ �charZuniZuni2r r r � py_scanstringE sP 2 rC z [ \t\n\r]*z c # C s� | \}} g } | j } |d kr i }|j} || | d � } | dkr�| |krb||| �j� } || | d � } | dkr�|d k r�|| �}|| d fS i } |d k r�|| �} | | d fS | dkr�td|| ��| d7 } �x�t|| |�\}} | ||�}|| | d � dk�r&||| �j� } || | d � dk�r&td|| ��| d7 } y:|| |k�rf| d7 } || |k�rf||| d �j� } W n tk �r~ Y nX y||| �\}} W n4 tk �r� } ztd||j�d �W Y d d }~X nX | ||f� y0|| } | |k�r||| d �j� } || } W n tk �r d} Y nX | d7 } | dk�r6P n| d k�rPtd || d ��||| �j� } || | d � } | d7 } | dkr�td|| d ��q�W |d k �r�|| �}|| fS t| �} |d k �r�|| �} | | fS ) Nr r �}z1Expecting property name enclosed in double quotes�:zExpecting ':' delimiterzExpecting valuer5 �,zExpecting ',' delimiter) r6 � setdefaultr7 r r r: � StopIteration�value�dict)� s_and_endr> � scan_once� object_hook�object_pairs_hook�memo�_w�_wsr. r7 ZpairsZ pairs_appendZmemo_get�nextchar�result�keyrI �errr r r � JSONObject� s� " rV c C sz | \}}g }|||d � }||krF|||d �j � }|||d � }|dkrZ||d fS |j}�xy|||�\} }W n2 tk r� } ztd|| j�d �W Y d d } ~ X nX || � |||d � }||kr�|||d �j � }|||d � }|d7 }|dk�rP n|dk�r td||d ��y:|| |k�rT|d7 }|| |k�rT|||d �j � }W qd tk �rl Y qdX qdW ||fS )Nr �]zExpecting valuerF zExpecting ',' delimiter)r7 r6 rH r rI r: ) rK rL rP rQ r. r7 �valuesrR r? rI rU r r r � JSONArray� s@ " rY c @ s< e Zd Zddddddd�dd�Zejfdd�Zd d d �ZdS ) r NT)rM � parse_float� parse_int�parse_constantr> rN c C sZ || _ |p t| _|pt| _|p"tj| _|| _|| _ t | _ t | _ t| _i | _tj| �| _d S )N)rM �floatrZ r- r[ � _CONSTANTS� __getitem__r\ r> rN rV Z parse_objectrY Z parse_arrayr Z parse_stringrO r Z make_scannerrL )r rM rZ r[ r\ r> rN r r r r s & zJSONDecoder.__init__c C sF | j |||d�j� d�\}}|||�j� }|t|�krBtd||��|S )Nr )�idxz Extra data)� raw_decoder7 r, r )r r. rP �objr7 r r r �decodeN s zJSONDecoder.decoder c C sP y| j ||�\}}W n2 tk rF } ztd||j�d �W Y d d }~X nX ||fS )NzExpecting value)rL rH r rI )r r. r` rb r7 rU r r r ra Y s "zJSONDecoder.raw_decode)r )r r r r � WHITESPACE�matchrc ra r r r r r � s 1 ) �reZjsonr Z_jsonr Z c_scanstring� ImportError�__all__�VERBOSE� MULTILINE�DOTALL�FLAGSr] r ZPosInfZNegInfr r r^ �compileZ STRINGCHUNKZ BACKSLASHr0 re rC rd ZWHITESPACE_STRrV rY �objectr r r r r �<module> s4 ; P% __pycache__/tool.cpython-36.opt-2.pyc 0000644 00000002346 15204140032 0013313 0 ustar 00 3 \m � @ s: d dl Z d dlZd dlZd dlZdd� Zedkr6e� dS )� Nc " C s d} d}t j| |d�}|jddt j� dd� |jddt jd �d d� |jd d d dd� |j� }|jphtj}|jpttj }|j }|�V y$|r�t j |�}nt j |t jd�}W n* tk r� } zt|��W Y d d }~X nX W d Q R X |�" t j|||dd� |jd� W d Q R X d S )Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)�prog� description�infile�?z-a JSON file to be validated or pretty-printed)�nargs�type�help�outfile�wz%write the output of infile to outfilez --sort-keys� store_trueFz5sort the output of dictionaries alphabetically by key)�action�defaultr )Zobject_pairs_hook� )� sort_keys�indent� )�argparse�ArgumentParser� add_argumentZFileType� parse_argsr �sys�stdinr �stdoutr �json�load� collections� OrderedDict� ValueError� SystemExit�dump�write) r r �parserZoptionsr r r �obj�e� r$ �!/usr/lib64/python3.6/json/tool.py�main s0 $r& �__main__)r r r r r& �__name__r$ r$ r$ r% �<module> s __pycache__/encoder.cpython-36.opt-2.pyc 0000644 00000015374 15204140032 0013762 0 ustar 00 3 \�> � " @ s> d dl Z yd dlmZ W n ek r0 dZY nX yd dlmZ W n ek rZ dZY nX yd dlmZ W n ek r� dZY nX e j d�Z e j d�Z e j d�Z dd d d d d dd�Z x&ed�D ]Ze jee�dje�� q�W ed�Zdd� Zep�eZdd� Ze�peZG dd� de�Zeeeee e e e e e j!f dd�Z"dS )� N)�encode_basestring_ascii)�encode_basestring)� make_encoderz[\x00-\x1f\\"\b\f\n\r\t]z([\\"]|[^\ -~])s [�-�]z\\z\"z\bz\fz\nz\rz\t)�\�"�� � � � � z \u{0:04x}�infc C s dd� }dt j|| � d S )Nc S s t | jd� S )Nr )� ESCAPE_DCT�group)�match� r �$/usr/lib64/python3.6/json/encoder.py�replace( s z%py_encode_basestring.<locals>.replacer )�ESCAPE�sub)�sr r r r �py_encode_basestring$ s r c C s dd� }dt j|| � d S )Nc S sv | j d�}yt| S tk rp t|�}|dk r<dj|�S |d8 }d|d? d@ B }d|d@ B }dj||�S Y nX d S ) Nr i z \u{0:04x}i � � i� i � z\u{0:04x}\u{1:04x})r r �KeyError�ord�format)r r �n�s1�s2r r r r 4 s z+py_encode_basestring_ascii.<locals>.replacer )� ESCAPE_ASCIIr )r r r r r �py_encode_basestring_ascii0 s r c @ sJ e Zd ZdZdZddddddddd�dd�Zd d � Zd d � Zdd d�ZdS )� JSONEncoderz, z: FTN)�skipkeys� ensure_ascii�check_circular� allow_nan� sort_keys�indent� separators�defaultc C sZ || _ || _|| _|| _|| _|| _|d k r:|\| _| _n|d k rHd| _|d k rV|| _d S )N�,) r" r# r$ r% r& r' �item_separator� key_separatorr) ) �selfr" r# r$ r% r& r' r( r) r r r �__init__h s +zJSONEncoder.__init__c C s t d|jj ��d S )Nz,Object of type '%s' is not JSON serializable)� TypeError� __class__�__name__)r- �or r r r) � s zJSONEncoder.defaultc C sN t |t�r | jrt|�S t|�S | j|dd�}t |ttf�sDt|�}dj|�S )NT)� _one_shot� ) � isinstance�strr# r r � iterencode�list�tuple�join)r- r2 �chunksr r r �encode� s zJSONEncoder.encodec C s� | j r i }nd }| jr t}nt}| jtjtt fdd�}|rvtd k rv| j d krvt|| j || j | j | j | j | j| j� }n&t|| j || j || j | j | j | j|� }||d�S )Nc S sJ | | krd}n$| |kr d}n| |kr*d}n|| �S |sFt dt| � ��|S )NZNaNZInfinityz -Infinityz2Out of range float values are not JSON compliant: )� ValueError�repr)r2 r% Z_reprZ_infZ_neginf�textr r r �floatstr� s z(JSONEncoder.iterencode.<locals>.floatstrr )r$ r# r r r% �float�__repr__�INFINITY�c_make_encoderr' r) r, r+ r& r" �_make_iterencode)r- r2 r3 �markers�_encoderr@ � _iterencoder r r r7 � s& zJSONEncoder.iterencode)F) r1 � __module__� __qualname__r+ r, r. r) r< r7 r r r r r! I s 6r! c s� �d k r ���� r d� �� �������� � ��������fdd�� � �������� � � � � ��������fdd��� ������� � ��������fdd���S )N� c 3 s� | sdV d S �d k r6� | �}|�kr.� d��| �|< d}�d k rh|d7 }d�| }�| }||7 }nd }�}d}x�| D ]�}|r�d}n|}� |��r�|�|� V qz|d kr�|d V qz|dkr�|d V qz|dkr�|d V qz� |� �r�|�|� V qz� |� ��r|�|� V qz|V � |��f��r:�||�}n"� |� ��rR�||�}n �||�}|E d H qzW |d k �r�|d8 }d�| V d V �d k �r��|= d S ) Nz[]zCircular reference detected�[� r TF�null�true�false�]r ) Zlst�_current_indent_level�markeridZbuf�newline_indentZ separator�first�valuer; )r= rG � _floatstr�_indent�_intstr�_item_separatorrH �_iterencode_dict�_iterencode_list�dictrA �id�intr5 r8 rF r6 r9 r r r\ s\ z*_make_iterencode.<locals>._iterencode_listc 3 sL | sdV d S �d k r6�| �}|�kr.� d��| �|< dV �d k rh|d7 }d�| }�| }|V nd }�}d}� r�t | j� dd� d �}n| j� }�xx|D �]n\}}�|��r�nr�|� �rȈ|�}n^|dkr�d }nP|d kr�d }nB|d kr�d }n4�|���r�|�}n � �rq�ntdt|� d ��|�r2d }n|V �|�V � V �|���r`�|�V q�|d k�rrd V q�|dk�r�d V q�|d k�r�d V q��|���r��|�V q��|� ��rƈ|�V q��|��f��r�||�} n"�|� ��r��||�} n �||�} | E d H q�W |d k �r2|d8 }d�| V dV �d k �rH�|= d S )Nz{}zCircular reference detected�{rM r Tc S s | d S )Nr r )Zkvr r r �<lambda>a s z<_make_iterencode.<locals>._iterencode_dict.<locals>.<lambda>)�keyrO FrP rN zkey z is not a string�})�sorted�itemsr/ r> ) ZdctrR rS rT r+ rU re rb rV r; )r= rG rW rX rY rZ rH r[ r\ �_key_separator� _skipkeys� _sort_keysr] rA r^ r_ r5 r8 rF r6 r9 r r r[ M s� z*_make_iterencode.<locals>._iterencode_dictc 3 s � | ��r�| �V n�| d kr&dV n�| dkr6dV n�| dkrFdV n�� | � �r\�| �V n�� | � �rr�| �V n�� | � �f�r��| |�E d H nj� | ��r��| |�E d H nN�d k rֈ | �}|�krΈ d��| �|< �| �} �| |�E d H �d k r��|= d S )NrN TrO FrP zCircular reference detectedr )r2 rR rS )r= �_defaultrG rW rY rH r[ r\ r] rA r^ r_ r5 r8 rF r6 r9 r r rH � s2 z%_make_iterencode.<locals>._iterencoder )rF ri rG rX rW rf rZ rh rg r3 r= r] rA r^ r_ r5 r8 r6 r9 rY r )r= ri rG rW rX rY rZ rH r[ r\ rf rg rh r] rA r^ r_ r5 r8 rF r6 r9 r rE s .84O, rE )#�reZ_jsonr Zc_encode_basestring_ascii� ImportErrorr Zc_encode_basestringr rD �compiler r ZHAS_UTF8r �range�i� setdefault�chrr rA rC r r �objectr! r= r] r^ r_ r5 r8 r6 r9 �__str__rE r r r r �<module> sR > __pycache__/tool.cpython-36.pyc 0000644 00000003013 15204140032 0012343 0 ustar 00 3 \m � @ s> d Z ddlZddlZddlZddlZdd� Zedkr:e� dS )a Command-line tool to validate and pretty-print JSON Usage:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) � Nc " C s d} d}t j| |d�}|jddt j� dd� |jddt jd �d d� |jd d d dd� |j� }|jphtj}|jpttj }|j }|�V y$|r�t j |�}nt j |t jd�}W n* tk r� } zt|��W Y d d }~X nX W d Q R X |�" t j|||dd� |jd� W d Q R X d S )Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)�prog� description�infile�?z-a JSON file to be validated or pretty-printed)�nargs�type�help�outfile�wz%write the output of infile to outfilez --sort-keys� store_trueFz5sort the output of dictionaries alphabetically by key)�action�defaultr )Zobject_pairs_hook� )� sort_keys�indent� )�argparse�ArgumentParser� add_argumentZFileType� parse_argsr �sys�stdinr �stdoutr �json�load� collections� OrderedDict� ValueError� SystemExit�dump�write) r r �parserZoptionsr r r �obj�e� r$ �!/usr/lib64/python3.6/json/tool.py�main s0 $r& �__main__)�__doc__r r r r r& �__name__r$ r$ r$ r% �<module> s __pycache__/decoder.cpython-36.pyc 0000644 00000023345 15204140032 0013005 0 ustar 00 3 \)1 � @ s d Z ddlZddlmZ yddlmZ W n ek r@ dZY nX ddgZej ej B ej B Z e d�Ze d�Ze d �ZG d d� de�Zeeed �Zejd e �Zd dddddddd�Zdd� Zdeejfdd�Zep�eZejde �Zd Zdejefd d �Z ejefd d �Z G d!d� de �Z dS )"z Implementation of JSONDecoder � N)�scanner)� scanstring� JSONDecoder�JSONDecodeError�nan�infz-infc @ s e Zd ZdZdd� Zdd� ZdS )r a Subclass of ValueError with the following additional properties: msg: The unformatted error message doc: The JSON document being parsed pos: The start index of doc where parsing failed lineno: The line corresponding to pos colno: The column corresponding to pos c C sb |j dd|�d }||jdd|� }d||||f }tj| |� || _|| _|| _|| _|| _d S )N� r � z %s: line %d column %d (char %d)) �count�rfind� ValueError�__init__�msg�doc�pos�lineno�colno)�selfr r r r r �errmsg� r �$/usr/lib64/python3.6/json/decoder.pyr s zJSONDecodeError.__init__c C s | j | j| j| jffS )N)� __class__r r r )r r r r � __reduce__* s zJSONDecodeError.__reduce__N)�__name__� __module__� __qualname__�__doc__r r r r r r r s )z -InfinityZInfinity�NaNz(.*?)(["\\\x00-\x1f])�"�\�/�� r � � )r r r �b�f�n�r�tc C s` | |d |d � }t |�dkrL|d dkrLy t|d�S tk rJ Y nX d}t|| |��d S )Nr � � ZxX� zInvalid \uXXXX escape)�len�intr r )�sr �escr r r r � _decode_uXXXX; s r1 Tc C s� g }|j }|d }�x�|| |�}|dkr4td| |��|j� }|j� \} } | rT|| � | dkr`P n.| dkr�|r�dj| �} t| | |��n || � qy | | } W n tk r� td| |��Y nX | dk�ry || } W n* tk r� dj| �} t| | |��Y nX |d7 }n�t| |�}|d 7 }d | k�o.d kn �r�| ||d � d k�r�t| |d �}d| k�ondkn �r�d|d d> |d B }|d7 }t|�} || � qW dj |�|fS )a� Scan the string s for a JSON string. End is the index of the character in s after the quote that started the JSON string. Unescapes all valid JSON string escape sequences and raises ValueError on attempt to decode an invalid string. If strict is False then literal control characters are allowed in the string. Returns a tuple of the decoded string and the index of the character in s after the end quote.r Nz Unterminated string starting atr r z"Invalid control character {0!r} at�uzInvalid \escape: {0!r}r* i � i�� � z\ui � i�� i � � � ) �appendr �end�groups�format� IndexError�KeyErrorr1 �chr�join)r/ r8 �strictZ_bZ_mZchunks�_appendZbegin�chunkZcontent� terminatorr r0 �charZuniZuni2r r r � py_scanstringE sP 2 rD z [ \t\n\r]*z c # C s� | \}} g } | j } |d kr i }|j} || | d � } | dkr�| |krb||| �j� } || | d � } | dkr�|d k r�|| �}|| d fS i } |d k r�|| �} | | d fS | dkr�td|| ��| d7 } �x�t|| |�\}} | ||�}|| | d � dk�r&||| �j� } || | d � dk�r&td|| ��| d7 } y:|| |k�rf| d7 } || |k�rf||| d �j� } W n tk �r~ Y nX y||| �\}} W n4 tk �r� } ztd||j�d �W Y d d }~X nX | ||f� y0|| } | |k�r||| d �j� } || } W n tk �r d} Y nX | d7 } | dk�r6P n| d k�rPtd || d ��||| �j� } || | d � } | d7 } | dkr�td|| d ��q�W |d k �r�|| �}|| fS t| �} |d k �r�|| �} | | fS ) Nr r �}z1Expecting property name enclosed in double quotes�:zExpecting ':' delimiterzExpecting valuer6 �,zExpecting ',' delimiter) r7 � setdefaultr8 r r r; � StopIteration�value�dict)� s_and_endr? � scan_once� object_hook�object_pairs_hook�memo�_w�_wsr/ r8 ZpairsZ pairs_appendZmemo_get�nextchar�result�keyrJ �errr r r � JSONObject� s� " rW c C sz | \}}g }|||d � }||krF|||d �j � }|||d � }|dkrZ||d fS |j}�xy|||�\} }W n2 tk r� } ztd|| j�d �W Y d d } ~ X nX || � |||d � }||kr�|||d �j � }|||d � }|d7 }|dk�rP n|dk�r td||d ��y:|| |k�rT|d7 }|| |k�rT|||d �j � }W qd tk �rl Y qdX qdW ||fS )Nr �]zExpecting valuerG zExpecting ',' delimiter)r8 r7 rI r rJ r; ) rL rM rQ rR r/ r8 �valuesrS r@ rJ rV r r r � JSONArray� s@ " rZ c @ s@ e Zd ZdZddddddd�dd�Zejfdd�Zd d d �ZdS ) r a Simple JSON <http://json.org> decoder Performs the following translations in decoding by default: +---------------+-------------------+ | JSON | Python | +===============+===================+ | object | dict | +---------------+-------------------+ | array | list | +---------------+-------------------+ | string | str | +---------------+-------------------+ | number (int) | int | +---------------+-------------------+ | number (real) | float | +---------------+-------------------+ | true | True | +---------------+-------------------+ | false | False | +---------------+-------------------+ | null | None | +---------------+-------------------+ It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as their corresponding ``float`` values, which is outside the JSON spec. NT)rN � parse_float� parse_int�parse_constantr? rO c C sZ || _ |p t| _|pt| _|p"tj| _|| _|| _ t | _ t | _ t| _i | _tj| �| _dS )aD ``object_hook``, if specified, will be called with the result of every JSON object decoded and its return value will be used in place of the given ``dict``. This can be used to provide custom deserializations (e.g. to support JSON-RPC class hinting). ``object_pairs_hook``, if specified will be called with the result of every JSON object decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. If ``strict`` is false (true is the default), then control characters will be allowed inside strings. Control characters in this context are those with character codes in the 0-31 range, including ``'\t'`` (tab), ``'\n'``, ``'\r'`` and ``'\0'``. N)rN �floatr[ r. r\ � _CONSTANTS� __getitem__r] r? rO rW Z parse_objectrZ Z parse_arrayr Z parse_stringrP r Z make_scannerrM )r rN r[ r\ r] r? rO r r r r s & zJSONDecoder.__init__c C sF | j |||d�j� d�\}}|||�j� }|t|�krBtd||��|S )zlReturn the Python representation of ``s`` (a ``str`` instance containing a JSON document). r )�idxz Extra data)� raw_decoder8 r- r )r r/ rQ �objr8 r r r �decodeN s zJSONDecoder.decoder c C sP y| j ||�\}}W n2 tk rF } ztd||j�d�W Y dd}~X nX ||fS )a= Decode a JSON document from ``s`` (a ``str`` beginning with a JSON document) and return a 2-tuple of the Python representation and the index in ``s`` where the document ended. This can be used to decode a JSON document from a string that may have extraneous data at the end. zExpecting valueN)rM rI r rJ )r r/ ra rc r8 rV r r r rb Y s "zJSONDecoder.raw_decode)r ) r r r r r � WHITESPACE�matchrd rb r r r r r � s 1 ) r �reZjsonr Z_jsonr Z c_scanstring� ImportError�__all__�VERBOSE� MULTILINE�DOTALL�FLAGSr^ r ZPosInfZNegInfr r r_ �compileZ STRINGCHUNKZ BACKSLASHr1 rf rD re ZWHITESPACE_STRrW rZ �objectr r r r r �<module> s6 ; P% __pycache__/__init__.cpython-36.pyc 0000644 00000030543 15204140032 0013135 0 ustar 00 3 \<8 � @ s� d Z dZdddddddgZd Zd d lmZmZ d d lmZ d dl Z edddddddd�Z dddddddddd� dd�Z dddddddddd� dd�Z eddd�Z dd� Zddddddd�dd�Zdddddddd�dd�ZdS ) a JSON (JavaScript Object Notation) <http://json.org> is a subset of JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data interchange format. :mod:`json` exposes an API familiar to users of the standard library :mod:`marshal` and :mod:`pickle` modules. It is derived from a version of the externally maintained simplejson library. Encoding basic Python object hierarchies:: >>> import json >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}]) '["foo", {"bar": ["baz", null, 1.0, 2]}]' >>> print(json.dumps("\"foo\bar")) "\"foo\bar" >>> print(json.dumps('\u1234')) "\u1234" >>> print(json.dumps('\\')) "\\" >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)) {"a": 0, "b": 0, "c": 0} >>> from io import StringIO >>> io = StringIO() >>> json.dump(['streaming API'], io) >>> io.getvalue() '["streaming API"]' Compact encoding:: >>> import json >>> from collections import OrderedDict >>> mydict = OrderedDict([('4', 5), ('6', 7)]) >>> json.dumps([1,2,3,mydict], separators=(',', ':')) '[1,2,3,{"4":5,"6":7}]' Pretty printing:: >>> import json >>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4)) { "4": 5, "6": 7 } Decoding JSON:: >>> import json >>> obj = ['foo', {'bar': ['baz', None, 1.0, 2]}] >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj True >>> json.loads('"\\"foo\\bar"') == '"foo\x08ar' True >>> from io import StringIO >>> io = StringIO('["streaming API"]') >>> json.load(io)[0] == 'streaming API' True Specializing JSON object decoding:: >>> import json >>> def as_complex(dct): ... if '__complex__' in dct: ... return complex(dct['real'], dct['imag']) ... return dct ... >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}', ... object_hook=as_complex) (1+2j) >>> from decimal import Decimal >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1') True Specializing JSON object encoding:: >>> import json >>> def encode_complex(obj): ... if isinstance(obj, complex): ... return [obj.real, obj.imag] ... raise TypeError(repr(obj) + " is not JSON serializable") ... >>> json.dumps(2 + 1j, default=encode_complex) '[2.0, 1.0]' >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j) '[2.0, 1.0]' >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j)) '[2.0, 1.0]' Using json.tool from the shell to validate and pretty-print:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) z2.0.9�dump�dumps�load�loads� JSONDecoder�JSONDecodeError� JSONEncoderz Bob Ippolito <bob@redivi.com>� )r r )r � NFT)�skipkeys� ensure_ascii�check_circular� allow_nan�indent� separators�default) r r r r �clsr r r � sort_keysc K s� | rJ|rJ|rJ|rJ|dkrJ|dkrJ|dkrJ| dkrJ| rJ| rJt j| �} n2|dkrVt}|f ||||||| | d�| ��j| �} x| D ]} |j| � q�W dS )a� Serialize ``obj`` as a JSON formatted stream to ``fp`` (a ``.write()``-supporting file-like object). If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, then the strings written to ``fp`` can contain non-ASCII characters if they appear in strings contained in ``obj``. Otherwise, all such characters are escaped in JSON strings. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. N)r r r r r r r r )�_default_encoder� iterencoder �write)�obj�fpr r r r r r r r r �kw�iterable�chunk� r �%/usr/lib64/python3.6/json/__init__.pyr x s - c K sz | rH|rH|rH|rH|dkrH|dkrH|dkrH|dkrH| rH| rHt j| �S |dkrTt}|f |||||||| d�| ��j| �S )au Serialize ``obj`` to a JSON formatted ``str``. If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, then the return value can contain non-ASCII characters if they appear in strings contained in ``obj``. Otherwise, all such characters are escaped in JSON strings. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. N)r r r r r r r r )r �encoder ) r r r r r r r r r r r r r r r � s , )� object_hook�object_pairs_hookc C s� | j }|tjtjf�rdS |tjtjf�r.dS |tj�r<dS t| �dkr�| d s`| d r\dS dS | d s�| d sx| d r|d S d S n$t| �d kr�| d s�dS | d s�d S d S )Nzutf-32zutf-16z utf-8-sig� r r z utf-16-bez utf-32-be� � z utf-16-lez utf-32-lezutf-8)� startswith�codecs� BOM_UTF32_BE� BOM_UTF32_LE� BOM_UTF16_BE� BOM_UTF16_LE�BOM_UTF8�len)�bZ bstartswithr r r �detect_encoding� s$ r, )r r � parse_float� parse_int�parse_constantr c K s" t | j� f||||||d�|��S )a% Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. )r r r- r. r/ r )r �read)r r r r- r. r/ r r r r r r s )�encodingr r r- r. r/ r c K s� t | t�r"| jd�rRtd| d��n0t | ttf�sBtdj| jj ���| j t | �d�} |dkr�|dkr�|dkr�|dkr�|dkr�|dkr�| r�t j | �S |dkr�t }|dk r�||d< |dk r�||d< |dk r�||d < |dk r�||d < |dk r�||d < |f |�j | �S ) a Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance containing a JSON document) to a Python object. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. The ``encoding`` argument is ignored and deprecated. u z-Unexpected UTF-8 BOM (decode using utf-8-sig)r z9the JSON object must be str, bytes or bytearray, not {!r}� surrogatepassNr r r- r. r/ )� isinstance�strr# r �bytes� bytearray� TypeError�format� __class__�__name__�decoder, �_default_decoderr ) �sr1 r r r- r. r/ r r r r r r . s2 ' )�__doc__� __version__�__all__� __author__�decoderr r �encoderr r$ r r r r< r, r r r r r r �<module>a s6 =8 __pycache__/__init__.cpython-36.opt-1.pyc 0000644 00000030543 15204140032 0014074 0 ustar 00 3 \<8 � @ s� d Z dZdddddddgZd Zd d lmZmZ d d lmZ d dl Z edddddddd�Z dddddddddd� dd�Z dddddddddd� dd�Z eddd�Z dd� Zddddddd�dd�Zdddddddd�dd�ZdS ) a JSON (JavaScript Object Notation) <http://json.org> is a subset of JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data interchange format. :mod:`json` exposes an API familiar to users of the standard library :mod:`marshal` and :mod:`pickle` modules. It is derived from a version of the externally maintained simplejson library. Encoding basic Python object hierarchies:: >>> import json >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}]) '["foo", {"bar": ["baz", null, 1.0, 2]}]' >>> print(json.dumps("\"foo\bar")) "\"foo\bar" >>> print(json.dumps('\u1234')) "\u1234" >>> print(json.dumps('\\')) "\\" >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)) {"a": 0, "b": 0, "c": 0} >>> from io import StringIO >>> io = StringIO() >>> json.dump(['streaming API'], io) >>> io.getvalue() '["streaming API"]' Compact encoding:: >>> import json >>> from collections import OrderedDict >>> mydict = OrderedDict([('4', 5), ('6', 7)]) >>> json.dumps([1,2,3,mydict], separators=(',', ':')) '[1,2,3,{"4":5,"6":7}]' Pretty printing:: >>> import json >>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4)) { "4": 5, "6": 7 } Decoding JSON:: >>> import json >>> obj = ['foo', {'bar': ['baz', None, 1.0, 2]}] >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj True >>> json.loads('"\\"foo\\bar"') == '"foo\x08ar' True >>> from io import StringIO >>> io = StringIO('["streaming API"]') >>> json.load(io)[0] == 'streaming API' True Specializing JSON object decoding:: >>> import json >>> def as_complex(dct): ... if '__complex__' in dct: ... return complex(dct['real'], dct['imag']) ... return dct ... >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}', ... object_hook=as_complex) (1+2j) >>> from decimal import Decimal >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1') True Specializing JSON object encoding:: >>> import json >>> def encode_complex(obj): ... if isinstance(obj, complex): ... return [obj.real, obj.imag] ... raise TypeError(repr(obj) + " is not JSON serializable") ... >>> json.dumps(2 + 1j, default=encode_complex) '[2.0, 1.0]' >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j) '[2.0, 1.0]' >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j)) '[2.0, 1.0]' Using json.tool from the shell to validate and pretty-print:: $ echo '{"json":"obj"}' | python -m json.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m json.tool Expecting property name enclosed in double quotes: line 1 column 3 (char 2) z2.0.9�dump�dumps�load�loads� JSONDecoder�JSONDecodeError� JSONEncoderz Bob Ippolito <bob@redivi.com>� )r r )r � NFT)�skipkeys� ensure_ascii�check_circular� allow_nan�indent� separators�default) r r r r �clsr r r � sort_keysc K s� | rJ|rJ|rJ|rJ|dkrJ|dkrJ|dkrJ| dkrJ| rJ| rJt j| �} n2|dkrVt}|f ||||||| | d�| ��j| �} x| D ]} |j| � q�W dS )a� Serialize ``obj`` as a JSON formatted stream to ``fp`` (a ``.write()``-supporting file-like object). If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, then the strings written to ``fp`` can contain non-ASCII characters if they appear in strings contained in ``obj``. Otherwise, all such characters are escaped in JSON strings. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. N)r r r r r r r r )�_default_encoder� iterencoder �write)�obj�fpr r r r r r r r r �kw�iterable�chunk� r �%/usr/lib64/python3.6/json/__init__.pyr x s - c K sz | rH|rH|rH|rH|dkrH|dkrH|dkrH|dkrH| rH| rHt j| �S |dkrTt}|f |||||||| d�| ��j| �S )au Serialize ``obj`` to a JSON formatted ``str``. If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If ``ensure_ascii`` is false, then the return value can contain non-ASCII characters if they appear in strings contained in ``obj``. Otherwise, all such characters are escaped in JSON strings. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. ``None`` is the most compact representation. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *sort_keys* is true (default: ``False``), then the output of dictionaries will be sorted by key. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg; otherwise ``JSONEncoder`` is used. N)r r r r r r r r )r �encoder ) r r r r r r r r r r r r r r r � s , )� object_hook�object_pairs_hookc C s� | j }|tjtjf�rdS |tjtjf�r.dS |tj�r<dS t| �dkr�| d s`| d r\dS dS | d s�| d sx| d r|d S d S n$t| �d kr�| d s�dS | d s�d S d S )Nzutf-32zutf-16z utf-8-sig� r r z utf-16-bez utf-32-be� � z utf-16-lez utf-32-lezutf-8)� startswith�codecs� BOM_UTF32_BE� BOM_UTF32_LE� BOM_UTF16_BE� BOM_UTF16_LE�BOM_UTF8�len)�bZ bstartswithr r r �detect_encoding� s$ r, )r r � parse_float� parse_int�parse_constantr c K s" t | j� f||||||d�|��S )a% Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. )r r r- r. r/ r )r �read)r r r r- r. r/ r r r r r r s )�encodingr r r- r. r/ r c K s� t | t�r"| jd�rRtd| d��n0t | ttf�sBtdj| jj ���| j t | �d�} |dkr�|dkr�|dkr�|dkr�|dkr�|dkr�| r�t j | �S |dkr�t }|dk r�||d< |dk r�||d< |dk r�||d < |dk r�||d < |dk r�||d < |f |�j | �S ) a Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance containing a JSON document) to a Python object. ``object_hook`` is an optional function that will be called with the result of any object literal decode (a ``dict``). The return value of ``object_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting). ``object_pairs_hook`` is an optional function that will be called with the result of any object literal decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg; otherwise ``JSONDecoder`` is used. The ``encoding`` argument is ignored and deprecated. u z-Unexpected UTF-8 BOM (decode using utf-8-sig)r z9the JSON object must be str, bytes or bytearray, not {!r}� surrogatepassNr r r- r. r/ )� isinstance�strr# r �bytes� bytearray� TypeError�format� __class__�__name__�decoder, �_default_decoderr ) �sr1 r r r- r. r/ r r r r r r . s2 ' )�__doc__� __version__�__all__� __author__�decoderr r �encoderr r$ r r r r< r, r r r r r r �<module>a s6 =8 __pycache__/decoder.cpython-36.opt-1.pyc 0000644 00000023345 15204140032 0013744 0 ustar 00 3 \)1 � @ s d Z ddlZddlmZ yddlmZ W n ek r@ dZY nX ddgZej ej B ej B Z e d�Ze d�Ze d �ZG d d� de�Zeeed �Zejd e �Zd dddddddd�Zdd� Zdeejfdd�Zep�eZejde �Zd Zdejefd d �Z ejefd d �Z G d!d� de �Z dS )"z Implementation of JSONDecoder � N)�scanner)� scanstring� JSONDecoder�JSONDecodeError�nan�infz-infc @ s e Zd ZdZdd� Zdd� ZdS )r a Subclass of ValueError with the following additional properties: msg: The unformatted error message doc: The JSON document being parsed pos: The start index of doc where parsing failed lineno: The line corresponding to pos colno: The column corresponding to pos c C sb |j dd|�d }||jdd|� }d||||f }tj| |� || _|| _|| _|| _|| _d S )N� r � z %s: line %d column %d (char %d)) �count�rfind� ValueError�__init__�msg�doc�pos�lineno�colno)�selfr r r r r �errmsg� r �$/usr/lib64/python3.6/json/decoder.pyr s zJSONDecodeError.__init__c C s | j | j| j| jffS )N)� __class__r r r )r r r r � __reduce__* s zJSONDecodeError.__reduce__N)�__name__� __module__� __qualname__�__doc__r r r r r r r s )z -InfinityZInfinity�NaNz(.*?)(["\\\x00-\x1f])�"�\�/�� r � � )r r r �b�f�n�r�tc C s` | |d |d � }t |�dkrL|d dkrLy t|d�S tk rJ Y nX d}t|| |��d S )Nr � � ZxX� zInvalid \uXXXX escape)�len�intr r )�sr �escr r r r � _decode_uXXXX; s r1 Tc C s� g }|j }|d }�x�|| |�}|dkr4td| |��|j� }|j� \} } | rT|| � | dkr`P n.| dkr�|r�dj| �} t| | |��n || � qy | | } W n tk r� td| |��Y nX | dk�ry || } W n* tk r� dj| �} t| | |��Y nX |d7 }n�t| |�}|d 7 }d | k�o.d kn �r�| ||d � d k�r�t| |d �}d| k�ondkn �r�d|d d> |d B }|d7 }t|�} || � qW dj |�|fS )a� Scan the string s for a JSON string. End is the index of the character in s after the quote that started the JSON string. Unescapes all valid JSON string escape sequences and raises ValueError on attempt to decode an invalid string. If strict is False then literal control characters are allowed in the string. Returns a tuple of the decoded string and the index of the character in s after the end quote.r Nz Unterminated string starting atr r z"Invalid control character {0!r} at�uzInvalid \escape: {0!r}r* i � i�� � z\ui � i�� i � � � ) �appendr �end�groups�format� IndexError�KeyErrorr1 �chr�join)r/ r8 �strictZ_bZ_mZchunks�_appendZbegin�chunkZcontent� terminatorr r0 �charZuniZuni2r r r � py_scanstringE sP 2 rD z [ \t\n\r]*z c # C s� | \}} g } | j } |d kr i }|j} || | d � } | dkr�| |krb||| �j� } || | d � } | dkr�|d k r�|| �}|| d fS i } |d k r�|| �} | | d fS | dkr�td|| ��| d7 } �x�t|| |�\}} | ||�}|| | d � dk�r&||| �j� } || | d � dk�r&td|| ��| d7 } y:|| |k�rf| d7 } || |k�rf||| d �j� } W n tk �r~ Y nX y||| �\}} W n4 tk �r� } ztd||j�d �W Y d d }~X nX | ||f� y0|| } | |k�r||| d �j� } || } W n tk �r d} Y nX | d7 } | dk�r6P n| d k�rPtd || d ��||| �j� } || | d � } | d7 } | dkr�td|| d ��q�W |d k �r�|| �}|| fS t| �} |d k �r�|| �} | | fS ) Nr r �}z1Expecting property name enclosed in double quotes�:zExpecting ':' delimiterzExpecting valuer6 �,zExpecting ',' delimiter) r7 � setdefaultr8 r r r; � StopIteration�value�dict)� s_and_endr? � scan_once� object_hook�object_pairs_hook�memo�_w�_wsr/ r8 ZpairsZ pairs_appendZmemo_get�nextchar�result�keyrJ �errr r r � JSONObject� s� " rW c C sz | \}}g }|||d � }||krF|||d �j � }|||d � }|dkrZ||d fS |j}�xy|||�\} }W n2 tk r� } ztd|| j�d �W Y d d } ~ X nX || � |||d � }||kr�|||d �j � }|||d � }|d7 }|dk�rP n|dk�r td||d ��y:|| |k�rT|d7 }|| |k�rT|||d �j � }W qd tk �rl Y qdX qdW ||fS )Nr �]zExpecting valuerG zExpecting ',' delimiter)r8 r7 rI r rJ r; ) rL rM rQ rR r/ r8 �valuesrS r@ rJ rV r r r � JSONArray� s@ " rZ c @ s@ e Zd ZdZddddddd�dd�Zejfdd�Zd d d �ZdS ) r a Simple JSON <http://json.org> decoder Performs the following translations in decoding by default: +---------------+-------------------+ | JSON | Python | +===============+===================+ | object | dict | +---------------+-------------------+ | array | list | +---------------+-------------------+ | string | str | +---------------+-------------------+ | number (int) | int | +---------------+-------------------+ | number (real) | float | +---------------+-------------------+ | true | True | +---------------+-------------------+ | false | False | +---------------+-------------------+ | null | None | +---------------+-------------------+ It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as their corresponding ``float`` values, which is outside the JSON spec. NT)rN � parse_float� parse_int�parse_constantr? rO c C sZ || _ |p t| _|pt| _|p"tj| _|| _|| _ t | _ t | _ t| _i | _tj| �| _dS )aD ``object_hook``, if specified, will be called with the result of every JSON object decoded and its return value will be used in place of the given ``dict``. This can be used to provide custom deserializations (e.g. to support JSON-RPC class hinting). ``object_pairs_hook``, if specified will be called with the result of every JSON object decoded with an ordered list of pairs. The return value of ``object_pairs_hook`` will be used instead of the ``dict``. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, collections.OrderedDict will remember the order of insertion). If ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority. ``parse_float``, if specified, will be called with the string of every JSON float to be decoded. By default this is equivalent to float(num_str). This can be used to use another datatype or parser for JSON floats (e.g. decimal.Decimal). ``parse_int``, if specified, will be called with the string of every JSON int to be decoded. By default this is equivalent to int(num_str). This can be used to use another datatype or parser for JSON integers (e.g. float). ``parse_constant``, if specified, will be called with one of the following strings: -Infinity, Infinity, NaN. This can be used to raise an exception if invalid JSON numbers are encountered. If ``strict`` is false (true is the default), then control characters will be allowed inside strings. Control characters in this context are those with character codes in the 0-31 range, including ``'\t'`` (tab), ``'\n'``, ``'\r'`` and ``'\0'``. N)rN �floatr[ r. r\ � _CONSTANTS� __getitem__r] r? rO rW Z parse_objectrZ Z parse_arrayr Z parse_stringrP r Z make_scannerrM )r rN r[ r\ r] r? rO r r r r s & zJSONDecoder.__init__c C sF | j |||d�j� d�\}}|||�j� }|t|�krBtd||��|S )zlReturn the Python representation of ``s`` (a ``str`` instance containing a JSON document). r )�idxz Extra data)� raw_decoder8 r- r )r r/ rQ �objr8 r r r �decodeN s zJSONDecoder.decoder c C sP y| j ||�\}}W n2 tk rF } ztd||j�d�W Y dd}~X nX ||fS )a= Decode a JSON document from ``s`` (a ``str`` beginning with a JSON document) and return a 2-tuple of the Python representation and the index in ``s`` where the document ended. This can be used to decode a JSON document from a string that may have extraneous data at the end. zExpecting valueN)rM rI r rJ )r r/ ra rc r8 rV r r r rb Y s "zJSONDecoder.raw_decode)r ) r r r r r � WHITESPACE�matchrd rb r r r r r � s 1 ) r �reZjsonr Z_jsonr Z c_scanstring� ImportError�__all__�VERBOSE� MULTILINE�DOTALL�FLAGSr^ r ZPosInfZNegInfr r r_ �compileZ STRINGCHUNKZ BACKSLASHr1 rf rD re ZWHITESPACE_STRrW rZ �objectr r r r r �<module> s6 ; P% __pycache__/scanner.cpython-36.pyc 0000644 00000003664 15204140032 0013033 0 ustar 00 3 \o � @ sj d Z ddlZyddlmZ W n ek r4 dZY nX dgZejdejej B ej B �Z dd� Z epde ZdS )zJSON token scanner � N)� make_scannerr z)(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c sv | j � | j�| j� tj�| j� | j�| j�| j�| j �| j �| j �� ��������� � � f dd�� � �fdd�}|S )Nc s� y | | }W n t k r( t|��Y nX |dkrB� | |d � �S |dkrd� | |d f� � ����S |dkr~�| |d f� �S |dkr�| ||d � dkr�d |d fS |dkr�| ||d � d kr�d |d fS |d ko�| ||d � d k� r�d|d fS �| |�}|d k �rX|j� \}}}|�s&|�rD�||�p2d |�p<d �}n�|�}||j� fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r��d�|d fS |dk�r�| ||d � dk�r�d�|d fS t|��d S )N�"� �{�[�n� Znull�t�trueT�f� ZfalseF� �N� ZNaN�I� ZInfinity�-� z -Infinity)� IndexError� StopIteration�groups�end)�string�idxZnextchar�mZintegerZfracZexp�res) � _scan_once� match_number�memo� object_hook�object_pairs_hook� parse_array�parse_constant� parse_float� parse_int� parse_object� parse_string�strict� �$/usr/lib64/python3.6/json/scanner.pyr s> z#py_make_scanner.<locals>._scan_oncec s z � | |�S �j � X d S )N)�clear)r r )r r r( r) � scan_onceA s z"py_make_scanner.<locals>.scan_once) r% r! r& � NUMBER_RE�matchr' r# r$ r" r r r )�contextr+ r( ) r r r r r r! r" r# r$ r% r& r' r) �py_make_scanner s "%r/ ) �__doc__�reZ_jsonr Zc_make_scanner� ImportError�__all__�compile�VERBOSE� MULTILINE�DOTALLr, r/ r( r( r( r) �<module> s : ext/parser.so 0000755 00000067220 15204140075 0007213 0 ustar 00 ELF > @ �g @ 8 @ pT pT �[ �[ �[ X � \ \ \ � � 8 8 8 $ $ PT PT PT S�td PT PT PT P�td Q Q Q � � Q�td R�td �[ �[ �[ X p GNU �L��&��=CL*�S�B�9 ; �@ � ; > BE���|ŷ|!�qX $ � l � � � � , � � � � � U \ w q I [ � � � � � N � q � ; 5 � X � � i � � � C ` � � , � F " 2 v � | � ` � �a � �> � � ` __gmon_start__ _ITM_deregisterTMCloneTable _ITM_registerTMCloneTable __cxa_finalize ruby_xfree rb_gc_mark_maybe rb_str_buf_new rb_str_resize rb_ary_new_capa rb_ary_push rb_hash_foreach rb_ary_entry rb_funcallv rb_str_cat rb_str_intern rb_utf8_encoding rb_enc_associate __stack_chk_fail rb_enc_raise ruby_xrealloc2 ruby_xmalloc2 rb_check_typeddata rb_string_value rb_enc_get rb_ascii8bit_encoding rb_str_conv_enc rb_str_dup rb_check_hash_type rb_extract_keywords rb_id2sym rb_hash_aref rb_error_arity rb_eArgError rb_raise rb_check_type rb_fix2int rb_eTypeError rb_data_typed_object_zalloc ruby_xmalloc rb_class_new_instance rb_ary_new rb_hash_new rb_cstr2inum rb_str_new_cstr memcpy rb_hash_aset rb_cstr_to_dbl rb_float_new Init_parser rb_require rb_define_module rb_define_module_under rb_cObject rb_define_class_under rb_path2class rb_define_alloc_func rb_define_method rb_const_get rb_intern2 libruby.so.2.5 libc.so.6 _edata __bss_start _end GLIBC_2.2.5 GLIBC_2.14 GLIBC_2.4 � ui � ��� � ii � �[ � �[ p �[ �[ �[ �F �[ � �[ @ �[ �_ �_ �_ �_ �_ 2 �_ 3 �_ 4 ^ ^ ^ (^ 0^ 8^ @^ H^ P^ X^ `^ h^ p^ x^ �^ �^ �^ �^ �^ �^ �^ �^ �^ �^ �^ �^ �^ �^ �^ ! �^ " _ # _ $ _ % _ & _ ' (_ ( 0_ ) 8_ * @_ + H_ , P_ - X_ . `_ / h_ 0 p_ 1 x_ 4 �_ 5 �_ 6 �_ 7 �_ 8 �_ 9 �_ : � �H��H�qL H��t��H��� �5�J �%�J � �h ������ �h ������� �h ������ �h ������ �h ������ �h ������ �h ������ �h ��q����� �h ��a����� �h ��Q����� �h ��A����� �h ��1����� �h ��!����� �h ������� �h ������� �h ����� �h ������ �h ������� �h ������ �h ������ �h ������ �h ������ �h ������ �h ��q����� �h ��a����� �h ��Q����� �h ��A����� �h ��1����� �h ��!����� �h ������� �h ������� �h ����� �h ������ �h! ������� �h" ������ �h# ������ �h$ ������ �h% ������ �h& ������ �h' ��q����� �h( ��a����� �h) ��Q����� �h* ��A����� �h+ ��1����� �h, ��!����� �h- ������� �h. ������� �h/ ����� �h0 ������ �h1 ������� �h2 ������ �h3 ������ ��%EG D � ��%=G D � ��%5G D � ��%-G D � ��%%G D � ��% G D � ��%G D � ��% G D � ��%G D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%�F D � ��%}F D � ��%uF D � ��%mF D � ��%eF D � ��%]F D � ��%UF D � ��%MF D � ��%EF D � ��%=F D � ��%5F D � ��%-F D � ��%%F D � ��% F D � ��%F D � ��% F D � ��%F D � ��%�E D � ��%�E D � ��%�E D � ��%�E D � ��%�E D � ��%�E D � ��%�E D � ��%�E D � ��%�E D � ��%�E D � ��%�E D H�=�E H��E H9�tH��E H��t �� � � � H�=�E H�5�E H)�H��H��H��?H�H�tH�uE H��t��f D � � � ��=�E u+UH�=ZE H��t H�=A ����d����]E ]� � � � ��w��� � �H� V5 H���x=�WH���x0H��H ��WH���x H��H ��WH���xH��H �ø�� �f. � � �H�G`H�@H��h�ff. � @ � �USH��H��H�o`H�}H��t�A���H���9���H��H��[]�+���ff. � � �SH��H�?����H�{ ����H�{8���H�{@���H�{H���H�{X[���f�AWI��AVAUI��ATUSH��1�H��8H�$dH�%( H�D$(1����H�$I�E L�{I9�� A�?"�� 1�KP��ufI�} �S4��t �C0���� H�7�� �� H�w�8�����I�O� HD�H�\$(dH3 %( �� H��8[]A\A]A^A_� D L�cXI�����t�� �i���I�u I��H�����H�5 L��L������� L���;���H������I���I�U H�5\D H��H�L$H�T$� � ���H��I�E � ����H���� �7��� @ H��M��M�fL9��� A�F<"t4<\uM�fL9��� A�F<u�& < �� M���f � I�OI��L9�r� � M9��O L�ɀ9\L�Iu�L9��� �A<f�� � <r� �J <t�r <u�� I�F�I9��w H�yH� $���H� $I��% � H= � � L�II�F�I9��i �y\� H�5�' �� �yu�� H�yH� $���H� $L��I�� %� H��E��L�I ��H��H��I �I �L�к H�t$$H�����D$$L��H�� ��?�Ȁ�D$%L��A��?H��A�ʀ��?D�T$'�Ȁ�D$&�d @ <\�� <b�� <"t|M��M9������L��L)�L��H�����I�m H���� M�� ���� @ � H�5�% <nu�H��L� $�t���L� $M�yM���L��� @ � H�5�% ��f�� H�5�% ��f�� H�5�% �f�H��L��H��L�L$L)�H� $����H� $L�L$�A<f����� H�5Q% �p���� H�5<% �_��� � � H�5 % �G��� � ���I�E �j���f��K���I�} M�� H���'�������f�L�II��w&D�T$$� H�t$$��f�� ���f D I��� �� I���� �f I���� � ����D$$?� H�t$$��� D I�NH9��� A�F<@�� ��0< �� I�NH9��| A�F<@�� ��0< �� I�NH9��d A�F<@�� ��0< wxM�fL9��P A�F<@�� ��0< �R���M��1�� ���f D L��A��?� H��A�ʀH�t$$��D�T$%�D$$����f D <F�M�����a<�B���I����� D <F�R�����a<�G����� <F�[�����a<�P����� <F�������a<������X��� � L�к H�t$$H�� ���D$$L��A��?H��A�ʀ��?D�T$&�Ȁ�D$%�%��� D I� ����1�����I� ����I� ���I� ���I� ����I� ������H� ? ����M���� H�+$ H��H��1����H� �> ���M���� H�C$ H��H��1��v���f D ATI��UH��SH� tWH�OI�T$H��H)�H9�v:H�� � H�H��H)�H9�r�H9�v I�|$� H���;�I�\$I�D$[]A\� @ H�?� ���I� $I�D$I�L$�ff. � � �AVI��H�5�8 AUI��ATA��H��USH�� dH�%( H�D$1��x�H�8 �� H�D$ H��A���� �3 I�H�$H�C(d H�5�= 1�1��CP H�=�= �U�H�C8 H�C H�C@ H�CH I��L�����H��H�����I�����I9��� �-�H��I�����H��L��H����H��L��H�,$��H�$H��� uiH���� H�SH�PH�L��H�SH�L$dH3 %( � H�� []A\A]A^� � Ic�I�|�H��ubA��A��������( � H�PH�SH�P�f�@��u H������� H����H���]�H��H���B��<��� D ��H�D$H���� H�|$��H�|$ H���� A��H���� H�D$A���� I�H�$H���S���H�=�; L�d$���L�� H��H�5�; I��H�D$��H������" �C(d H�=�; ��L�� H��H�5M; I��H�D$�`�H������� �C, H�=F; �q�L�� H��H�5; I��H�D$�"�H������^ �C4 H�= ; �3�L�� H��H�5�: I��H�D$���H������� �CP H�=�: ��L�� H��H�5�: I��H�D$��H������z L��H�����H�C H�=|: ��L�� H��H�5M: I��H�D$�`�H������L H�C8 H�=5: �p�L�� H��H�5: I��H�D$�!�H������� H�C@ H�=�9 �1�L�� H��H�5�9 I��H�D$���H������� H�CH H�=�9 ���L�� H��H�5�9 I��H�D$��H������O H�CX �Q���f. � H�E �� ���!������#�������H��� HD�H�l$� � D��� � D H�D$ A��u���� @ H�599 H�=z9 1�1�� �H�C �u���L��H���E�1�H���SP�S4��� ���H������H��7 H�5� H�81��}� D L��H����H����������C4���f � L��H�����H����������C,�$����L��H����I��H�����u~�C( ����f D L��H����� H�����HD�H�CX��� D L��H���e�H�C@��� @ L��H���M�H�C8��� @ L��H���5�H�CH����H�Ǿ � �L����C(�4���H�X6 H�5� H�81��g����f�� �H��H�5A2 �\�H�8H��t H���K�H�6 H�5h H�81��#� � �AUATUS� H��dH�%( H�D$1�H��4t&I��H�5]7 H��I��1�1�L����H�����u#1�H�L$dH3 %( ��uIH��[]A\A]� @ 1�L�����H�� H��H�5�6 H�$���H�����t�L��L����������� �UH�T1 �h SH���%�� H�h H�����f�@H�@ H� H�E`H��H��[]�ff. � @ AWAVAUATUSH��XdH�%( H�D$H1�H9�tMH��I��H��I��H�j � �A�<n� ��Hc�H�>�� � H�� D H��H9�u� � E1�H�|$HdH3<%( L���� H��X[]A\A]A^A_Ã�0�� w� � H�CH9��{ � H�5� H����� ���] A�O,���� H��5 L�c I�널H�CH9��s����{n�i���H�CH9��\����{f�R���H�CH9��E����{i�;���H�CH9��.����{n�$���H�CH9������{i� ���H�CH9�� ����{t�����H�CH9�����{y����A�W,��� H��4 L�cI�����H�CH9�������{a�����H�CH9�������{N�����A�G,���� H��4 L�cI��v��� A�@I�W@�lj$A�G(���� 9��� ��H�=v4 H�51 1���� � H�CH9��#���E1�{a����H�CH9�� ����{l����H�CH9�������{s���H�CH9������{e����I� L�c�����H�CH9������E1�{r�����H�CH9�������{u�����H�CH9������� ��{e�w���I� L�c�g��� @ A�G(E�`I�W8H�D$ A9��B ���: H�=c3 D��H�5 1����f�L��H��H��L����I��H��LD�����H�CH9����K��*tR��/t����8 �����H��H9�u�����f � H��H�XH9�������@<*t�</�����H�� D H��H9�������8*u��� @ H�CH9��s���E1�{u�i���H�CH9��\����{l�R���H�CH9��E����{l�;���I� L�c�+��� � �� �@����������� ���f � H���� 1�1���I�H9�tE�;{H��u=L�BL9�t4�B<"� �� < t< �� L��L�BL9�u�f. � I����� � H���& 1�1��=�I�H9��b �;[�Y H��H� J L�bL9��� �r�F�<n�� ��Hc�H�>���0@�� �� � H�D$(H�D$H�D$0H�D$D�$H�L$H��L��H�D$( L���|���I��H���N I�@H�t$(I�>�5 H�t$0H�L$� H�5G0 ��I�E�H�PH9�t%�H��,tAr�� t �� �l H��H�PH9�u�I���� � �� �G ���� L��L�bL9��� �J�A�<nw�H�5� ��Hc�H�>�� � ��/� ��]�� H��I��LD�� ���f D </�� <}�( A�wP���� I�8I�w L�$I�>�� H�t$0H�L$0� H�5P/ ��L�$H��tyH�5Z/ H�=�/ L�d$0� L��L�$H�D$0�`�H�5�/ 1�1�H��H���J�L�$H�����t.I�H�5\/ L��H�� H�D$0� �L�$I� � I��M��LD��#����� �������I���z @ H�PH9��{����@<*tC</t�� D �: �S���H��H9�u��Q����H��H9��C����<*t�</�(��� @ H��H9��#����:*u��� @ ������f D I��L9��� A�<$*u�I��L9��� A�$<*t�</u�f. � L�����L���*���L�bL9��� �B<*t�</�� I��L9��� A�<$ u��L�bL9�to�B<*tA</uc D I��L9�tUA�<$ u��}��� I��L9�t=A�$<*t�</�`���f D I��L9�t A�<$*u���@�� �g���@���B���H� �- ��M� H�� H��H��1��J�f. � ������f D � ��Y���f D I�_H9�������<-�� <0�� ��1I��<w6I��L9��� A�$<E�� <e�� <.�� ��0< v� D I�_�<-�j <0�y ��1I��<v���f. � A�$��0< w I��L9�u�I�o`M��H�E I)��E � H�����H�EH�U� � I�G`H�EH�x�s�I���I�LD��F��� L�BL9�������B<*tK</t���f�A�8 �`���I��L9�u��h��� � I��L9��S���A� <*t�</�-��� I��L9��3���A�8*u��� �� <�������� � H�D$ L�- H�$H�D$(H�D$H�D$0H�D$H� $H��L��L��A�G0 ��A�G0 H�������H�H�H�AH9�������Q�� � � ��/�l ��:�K H�pH9��~����H�Q�n�d ��IcT� L�>���0�� �T��� @ H�L$E��H��L��H�D$( �d�H���+���I�8H�t$ H�D$H�T$(I�>� H�t$0H�L$H�5=* H�T$8� �n�L�D$I�@�L�@L9������P��,t?�Q �� t �� �U L��L�@L9�u����f. � < t �� <������L��I��L9�������B< t�~�<"�����</u�L�BL9��]����B<*t6</t �L���A�8 t�I��L9�u��8���I��L9��+���A� <*t�</t�I��L9�����A�8*u��Ҁ� ������������H���e���H�pH9�����@<*t4</t �����> t�H��H9�u����H��H9�������<*t�</t�H��H9�������>*u��� �� �G H������ � ��/� ��}������ ��������U�����,� ���I��M�o`L��H)�I�E H�$�x L�� �0�I�EI�U� I�G`I�EI�HH�x�0 �'�I�HH�L$0H�5( � H�D$0�X��I�� �I��������L��I�_H9��{������f�I�D$H9�t�A�T$��+t��-uI�D$H9�t�A�T$��0�� �:���H��H9��� ���E�!�����e������.�������0�� v����f��� ��������/��� � H�AH9������Q��*tJ��/t���� � �8 �p���H��H9�u����H��H9��������*t�/�D��� H��H9�������8*u��� @ H��L�`L9�������@��0< �������� @ H��L�`L9�������@<E�����<e�����<.�����I�D$H9������A�T$��0�� ������ �L�`L9�����@<E�o���<e�g���<.�� ��0< �����L��L�`L9�u���� L�cL9�� ����C<0�� ��1<�V������L�cL9�����C<0�� ��1<�������H��L����H�}L��H}H���`��LmI�o`����>��L�$�V���L�@L9��X��@<*tH</t�G� � A�8 �{���I��L9�u��(�I��L9���A� <*t�</�P��� I��L9����A�8*u������L�D$���L���/���L���O���I������ �B���M��I����H��L����H�$I�}H��I}�v��H�$IEM�o`�X����0����0�� ���}���I���u���H�-8% ���I�ع� H��H�� H��1����H�-% ����I�ع� ��H�-�$ ���L�C��� �<,��������� D � �UH�5$ SH��dH�%( H�D$1�H�$ �"��H�8 � H�XH�hH� y H�H9��� �3�V�n�� ��Hc�H�>���0@�� wp � E1�H��H��H��H����H���� H��� D �� t�� ��w3H��H�XH9��� �P�� t�/u�H�XH9�t�@<*tL</taH��H� �# ���I�� H�� H��H��1��m�� D H��H9�t��<*t�</t� @ H��H9�t��;*u��; �l���H��H9�u�� @ � �H9������H�t$dH34%( H�$�� H��[]�H��f � H��H9�������I���f D H�SH9��6����s@��*tI@��/tH������ �: t�H��H9�u�����H��H�ZH9�������R��*t�/t�H�� @ H��H9������:*u��� @ @�� �E���@���\�������r��H�� H�5/ H�81�����f. � � �H��H�=d ����H�=d �`��H�5] H��H�W" �Z��H�� H�5U H��H��q��H�=2 H�#" �^��H�=1 H�" �K��H�=" H�5��H��! ����H�=�! �����H���H�5 �2��H�=�! 1�H���H�5� ���H�=�! 1�H�5� H������H�5� H��� H�=�! ���H�5� H�X! H���� H�=h! ����H�5� H�-! H���L H�=E! ����H� ! H�R H��� H�� H�3 H���� H�� H� H���� H�� H�� H���d H�=� H�� �/ H�� H���� H�` H�� H���� H�A H�� H���� H�" H�c H���Z H� H�D H���# H�� H�% H���� H�� H� H���� H�� H�� H���~ H�w H�� H���G H�x H�� H��� H�Y H�� H���� H�* H�k H���� H� H�L H��toH�� H�1 H��t4H�� H��� � � H�=� ���H��H�� ����� H�=d ���H�� H�� H��� @ � H�=9 �w��H�� �t��� � H�= �W��H�� �A��� � H�=� �7��H�� � ��� � H�=� ���H�x ���� � H�=� ���H�` ��� � H�=q ����H�H �e��� � H�=K ���H�0 �.��� � H�= ���H� ��� � H�=� �w��H� ��� � H�=� �W��H�� ��� � H�=� �7��H�� �R��� � H�=j ���H�� ���� � H�=> ���H�� ��� � H�= ����H�� ��� � H�=� ���H�p ���� � H�=� ���H�X �H��� � H�=� �w��H�@ ���� � H�=c �W��H�( ���� � H�=5 �7��H��H� ��� � � H�=� ���H��H�� �I���� �H��H��� " \ already initialized instance uninitialized instance nesting of %d is too deep %u: unexpected token at '%s' -Infinity json/common JSON Ext JSON::ParserError JSON::NestingError initialize parse source NaN MinusInfinity json_creatable? json_create create_id create_additions chr max_nesting allow_nan symbolize_names object_class array_class decimal_class match match_string key? deep_const_get []= [] << new JSON/Parser %u: incomplete unicode character escape sequence at '%s' %u: incomplete surrogate pair at '%s' options :symbolize_names and :create_additions cannot be used in conjunction �����������������������������������������������������������������������������������������������������������������������P����������������������������������`�������������������������������������P������������������������p���n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n���n���n�n�n�n�n�n�n�n�n�n���n���n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n�n���n�n�n�n���n�n�n�n�n�n�n�n�n�n�n�n���n���n�n�n�n�n�n�n�n���n�n�n�n�n�n�n���n�n�n�n�n���n�n�n�n�n�n���������������������������������������������L���������������������L���N���������������������������������������������������L���������L�������������������������L���������������������L���������������L�����������L�������������L������������������������������������������������������������������� �����������������������������������������������������������������������������������������������������������������������������������������������������������`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`���`��`�`�`�`�`�`�`�`�`�`��`���`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`�`��`�`�`�`��`�`�`�`�`�`�`�`�`�`�`�`��`�`�`�`�`�`�`�`�`�`��`�`�`�`�`�`�`��`�`�`�`�`��`�`�`�`�`�`�� ������������������������������������������������ ������� �������������������������� ���������������������������������������������������������������������������������������������������������������������������������������������������������;� P��� ���� ���� ��� �� `��0 ���L ���� ��� P�� ���( @��d ���� p�� �� zR x � $ ����P FJ w� ?:*3$" D ���@ \ ���V p �� $ � ��5 E�A�G ^DA � (��> E�t H � L��� B�E�B �E(�A0�A8�Ip� 8A0A(B BBBF , ���� B�D�D �V ABE @ D @��> F�L�E �G(�A0�DP 0A(A BBBH � <��= HX E 8 � `��� F�B�A �A(�I@R (A ABBE $ � ���Q E�M�D uDA H ��� B�B�B �B(�A0�A8�D�� 8A0A(B BBBA ( T ��V E�H�D0p AAA � ��� H� I C E GNU � � p �[ �F � @ � � H �D �[ �[ ���o ` � � � �] � h P ���o ���o � ���o �o T ���o \ � � � � � � � � 0 @ P ` p � � � � � � � � 0 @ P ` p � � � � � � � � 0 @ P ` p � � � � GA$3a1 H �D GA$3p1113 � �D GA* GA$annobin gcc 8.5.0 20210514 GA$plugin name: gcc-annobin GA$running gcc 8.5.0 20210514 GA* GA* GA! GA*FORTIFY GA+GLIBCXX_ASSERTIONS GA*GOW *� GA*cf_protection GA+omit_frame_pointer GA+stack_clash GA!stack_realign GA*FORTIFY � GA+GLIBCXX_ASSERTIONS parser.so-2.5.9-114.module_el8.10.0+3991+5e651d4e.x86_64.debug Y҈�7zXZ �ִF ! t/����] ?�E�h=��ڊ�2N�s�Ah6o���[��>��o[���5;��>�PG @/�k5�i�XpkcX?T�r3[J��F���J�Y�s?�?>M�f���~�)�$��/���+S�k�Rx`l�z3�Â����'�/���9>4���U���;���Y���� ������ �r"K!������K�(u�vc�;�?�'��Π���4�f�\\I�)�Q� ��L��v�}�0�)!�H��=�x !�&����� pu��R�.ڌ M� Bl�-��Md��dE��fGu��������K��,�:�)�A����u� 0�䯕�/�r�D8�|�X`�K�I�eL̴�@�]<�=Z �D|ړ�)�r�o۽M<AЄ �4�dv-N��)�[��E+����Xw��^�\Pf[^0�\�+���3Zv��� ��:�q�=(�/Z�Z�csߜ2�i�/��� �ї=>h8�� s�"��)� �ޥo�5ɸ+�������s � "i'.��<D`�&�G�V]dE��\d�&H����(�EqxJ�#�e4 ����~�=��:w c7�-�$�x�(�>���-����B)�I�{SɅ������l�<_ �+�<�P���o��P7������4d���P�%7�h�{��D�P��� �R��)*$��@88�>�ָ��%�M���" ��΄���l��$�ǂ�����&�x]6+��>�w���\3h!�Nժkh}�^7��-��]M�s#��Od�A�R���O0a��O��,�C�^���,3C�=q�_�o�y�O��� ���x֚6#Sٱ^ءM��iGĸە�yp����C�|�b���W�Q:�C�F7��S�� � ���j�-��υ�H�k�n�S��yƔ����7�:���S�C�ۭ]���C�s�)I0$����3Ig��G�v� �HE�3�>h �� >���g� YZ .shstrtab .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt.sec .text .fini .rodata .eh_frame_hdr .eh_frame .note.gnu.property .init_array .fini_array .data.rel.ro .dynamic .got .bss .gnu.build.attributes .gnu_debuglink .gnu_debugdata 8 8 $ ���o ` ` 4 ( � � � 0 � � � 8 ���o T T ~ E ���o � � @ T P ^ B h h � h H H c p p P n � � @ w �* } �D �D � �D �D @ � Q Q � � �Q �Q � � PT PT � �[ �[ � �[ �[ � �[ �[ h � \ \ � � �] �] � � ` �_ � � �a` �_ H 0b D tb � hf " ext/generator.so 0000755 00000110320 15204140075 0007673 0 ustar 00 ELF > � @ Љ @ 8 @ �n �n P{ P{ P{ � � �{ �{ �{ � � 8 8 8 $ $ `n `n `n S�td `n `n `n P�td 8a 8a 8a Q�td R�td P{ P{ P{ � � GNU <��t�Z��.�DzH5��p C �@$� C E F BE���|�qX �t�) � � e e b � / � � � � � � � a � Z � r � U � � B � � � C 4 � W � � � � � O � � ' { � � � : � K , � n � F " ' m � s � � � � � � � �N � __gmon_start__ _ITM_deregisterTMCloneTable _ITM_registerTMCloneTable __cxa_finalize rb_funcallv __stack_chk_fail rb_check_typeddata ruby_xfree ruby_xmalloc ruby_xrealloc2 ruby_xmalloc2 memcpy rb_str_new rb_utf8_encoding rb_enc_associate rb_check_type rb_str_new_static rb_hash_aref rb_hash_new rb_obj_class rb_class_name rb_hash_aset rb_str_dup rb_str_cat rb_str_concat rb_str_intern rb_sym2id rb_ivar_set rb_ivar_get rb_ary_entry rb_string_value_cstr rb_iv_get rb_str_substr rb_id2sym rb_intern2 rb_check_convert_type rb_convert_type rb_error_arity rb_data_typed_object_zalloc rb_string_value_ptr rb_path2class rb_raise rb_eArgError rb_float_value rb_cHash rb_cArray rb_cString rb_cFalseClass rb_cInteger rb_cNilClass rb_cFloat rb_respond_to rb_cTrueClass rb_cSymbol rb_obj_is_kind_of rb_const_get Init_generator rb_require rb_define_module rb_define_module_under rb_cObject rb_define_class_under rb_define_alloc_func rb_define_singleton_method rb_define_method rb_define_alias rb_cRegexp libruby.so.2.5 libc.so.6 _edata __bss_start _end GLIBC_2.2.5 GLIBC_2.14 GLIBC_2.4 � ui ��� ii ' P{ ` X{ `{ `{ �{ �^ �{ � �{ P h p x � � � � � $ � & � - � . � 7 � 8 � 9 � ; � B �} �} �} �} �} �} ~ ~ ~ ~ ~ (~ 0~ 8~ @~ H~ P~ X~ `~ h~ p~ x~ �~ �~ �~ �~ ! �~ " �~ # �~ % �~ ' �~ ( �~ ) �~ * �~ + �~ , �~ / �~ 0 �~ 1 2 3 4 5 6 ( : 0 ; 8 < @ = H > P ? X @ ` A � �H��H�qj H��t��H��� �5zh �%{h � �h ������ �h ������� �h ������ �h ������ �h ������ �h ������ �h ������ �h ��q����� �h ��a����� �h ��Q����� �h ��A����� �h ��1����� �h ��!����� �h ������� �h ������� �h ����� �h ������ �h ������� �h ������ �h ������ �h ������ �h ������ �h ������ �h ��q����� �h ��a����� �h ��Q����� �h ��A����� �h ��1����� �h ��!����� �h ������� �h ������� �h ����� �h ������ �h! ������� �h" ������ �h# ������ �h$ ������ �h% ������ �h& ������ �h' ��q����� �h( ��a����� �h) ��Q����� �h* ��A����� �h+ ��1����� �h, ��!����� �h- ������� �h. ������� �h/ ����� �h0 ������ �h1 ������� �h2 ������ ��%Ee D � ��%=e D � ��%5e D � ��%-e D � ��%%e D � ��% e D � ��%e D � ��% e D � ��%e D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%�d D � ��%}d D � ��%ud D � ��%md D � ��%ed D � ��%]d D � ��%Ud D � ��%Md D � ��%Ed D � ��%=d D � ��%5d D � ��%-d D � ��%%d D � ��% d D � ��%d D � ��% d D � ��%d D � ��%�c D � ��%�c D � ��%�c D � ��%�c D � ��%�c D � ��%�c D � ��%�c D � ��%�c D � ��%�c D � ��%�c D H�=Id H�Bd H9�tH��c H��t �� � � � H�=d H�5d H)�H��H��H��?H�H�tH��c H��t��f D � � � ��=�c u+UH�=�c H��t H�= _ ����d�����c ]� � � � ��w��� � H�7H��thv$H��tNH��u8�R�1����?v2�f � H��u��B�<A������� Ѓ�� 1�� D H�W @ �B��H�1���?w�H���J�1����w�����tKv���t$���u/���v��f � ���u���w�� D ���w��f. � 1����o����W��������`����f D � �H�? �� t H�GH� H� t H�WH�DH� t H�W(H�DH�0 t H�W8H�DH�@ t H�WHH�DH�WPH��tHBH�WXH��tHBH�W`H��tHB�ff. � @ � �H��H��H�5>c � dH�%( H�D$1�H��c H��H�$�v���H�T$dH3%( uH������ff. � �� �H��H�51] � ���H��� H��H�D �ff. � � �H��H�5] ���H�@xH��H�D �ff. � � �H��H�5�\ ����xqH�H��H�Ѓ��f. � � �H��H�5�\ ����xpH�H��H�Ѓ��f. � � �H��H�5q\ �\���H�xhH�H��H�Ѓ��f � � �H��H�5A\ �,���H�@hH��H�D �ff. � SH��H�H��t���H��[��� D � �SH��H�?H��t����H�{H��t���H�{ H��t���H�{0H��t���H�{@H��t���H�{PH��t���H�{XH��t�w���H�{`H��t�i���H��[�`���SH��H��� HDؿ ���f�@H�@ H�[ÐATI��UH��SH� tWH�OI�T$H��H)�H9�v:H�� � H�H��H)�H9�r�H9�v I�|$� H���{���I�\$I�D$[]A\� @ H�?� �{���I� $I�D$I�L$�ff. � H��t3UH��SH�� H��H���B���H��H��H������H��[]� D 1�H���f�USH��H��H�wH����H��H���?����z���H��H�����H��H��[]� D � �USH��H�50Z H������H�߾ H�H���t���H��~H��� H��� []�ff. � �� �USH��H�5�Y H������H�߾ H�H���$���H�]xH��� []� @ � �USH��H�5�Y H�����H�߾ H�����H��H�H�EhH��[]�f D � �ATUH��H�5_Y S�I���� H��I�����H�u H��% u;H��I�|$@H��� H��u5H��t���I�D$@ [� ]A\�f. � H�]I�|$@H��t�H��t����H�E % H�}H��tH�}H��� ���I�\$HI�D$@� []A\�f D � �ATUH��H�5�X S���� H��I�����H�u H��% u;H��I�|$0H��� H��u5H��t�=���I�D$0 [� ]A\�f. � H�]I�|$0H��t�H��t����H�E % H�}H��tH�}H���J���I�\$8I�D$0� []A\�f D � �ATUH��H�5�W S����� H��I���)���H�u H��% u;H��I�|$ H��� H��u5H��t�}���I�D$ I�D$( [� ]A\ÐH�]I�|$ H��t�H��t�H���H�E % H�}H��tH�}H�����I�\$(I�D$ � []A\�f D � �ATUH��H�5 W S� ���� H��I���i���H�u H��% u;H��I�|$H��� H��u5H��t��I�D$ I�D$ [� ]A\ÐH�]I�|$H��t�H��t��H�E % H�}H��tH�}H������I�\$I�D$� []A\�f D � �ATUH��H�5_V S�I� H��I����H�u H��% u;H��I�<$H��� H��u5H��t��I�$ I�D$ [� ]A\� H�]I�<$H��t�H��t���H�E % H�}H��tH�}H��� ���I�\$I�$� []A\� � � �SH�� H��H��dH�%( H�D$1���� H�=�7 ��H��H���� H�=_5 H����� H��H��H�5 [ H�$�L�H�T$dH3%( uH��[���� �ATUH��SH��dH�%( H�D$1�� ���H��H���!�H���y�H�5�Z 1�1�H�=G[ I�����L��H��H���� H�=�4 �@�H�� H��H�5^Z H�$�� H�=�6 H����H��H��H����H�T$dH3%( u H��H��[]A\����f�� �AV1�I��1�AUATUSH��H��H�� H�5LZ dH�%( H�D$1�I���$�H��H���� H�56 H�����L�� H��H�5{Y I��H�$���H�����u_� H�=�3 �N�H��H�����H����H����L��H��H���� H�L$dH3 %( u2H�� []A\A]A^� L�� H��L�,$H�5�X L�t$�`�����f � � �AT1�1�USH��H��H��H�5CY dH�%( H�D$1�I����L�� H��H�5�X H��H�$��H�����t5L�� H��H�,$H�5oX ���H�T$dH3%( uCH��[]A\Ð� H�=�2 �/�H��H����H����H�����H��H���y����f�� �AWAVAUI��ATUSH��(dH�%( H�D$1��f�H�5?R L��H���$�H�5�V H��H���� 1�1�L��E1��"�I��H�D$H�$� �H����I9��� L�= X L��L���>�1�1�L��H�����H�H�D$�� �& H���� H�<$H�T$I����L��H����H�T$H�|$� I��H���?�H���w�L��H��H����I�$�� �\���I�D$I9��^���H�sH�;���H�=CW I����L��H��H���e�H�sH�{��H�=W I���Y�L��H��H���;�H�s(H�{ �~�H�=�V I���/�L��H��H����H�s8H�{0�T�H�=�V I����L��H��H�����H�sHH�{@�*�H�={V I�����L��H��H�����{pH�=JV M���I��H��A��H��L�����{qH�=V M���I��H��A��H��L���m�L�chH�=V �m�O�d$H��L��H���J�L�cxH�=�U �J�O�d$H��L��H���'�H��� H�=YU �$�H�\H��H��H����H��H�L$dH3 %( uFH��([]A\A]A^A_� � H�P���� � � H�=�/ �g�H��H��S �G����� � �AVAUI��ATI��H�5IO USH��dH�%( H�D$1�� �H� ?/ � L��H�8/ H����H��H���� H�=U �G�H��H����I��H������� H�=�T �!�H��H���v�I��H������7 H�=�T ��H��H���P�I��H������� H�=rT ���H��H���*�I��H������k H�=TT ��H��H����I��H������ H�= T I����L�� H��H�Ehd H�5�S I��H�$� �H������� H�=�S �H�L�� H��H�Ex H�5�S I��H�$���H������& H�=?S � �L�� H��H�5PS I��H�$��H������� H�=aS ���H��H���)�H�=BS H������Ep��H��H����H�����L���EqH�T$dH3%( �� H��[]A\A]A^�f. � � H���s�M�4$A�� �b M�t$I�|$I�v�/�L�uH�E ����f�L��H����I��H������6���� H��I���M��� ���L��� �����L��H���E�I��H������& H�Ex ���f � L��H����I��H������� H�Eh �E���f � � H����M�4$A�� �b M�t$I�|$I�v�O�L�u8H�E0���f�� H���S�M�4$A�� � M�t$I�|$I�v��L�uHH�E@�W���f�� H����M�4$A�� �� M�t$I�|$I�v���L�u(H�E ��f�� H�����M�4$A�� tNM�t$I�|$I�v��L�uH�E���f D H� ^+ H�R+ � L���e�H������ D I��I�|$A�� I�v� D I��I�|$A�� I�v�V���f. � I��I�|$A�� I�v���f. � I��I�|$A�� I�v���f. � I��I�|$A�� I�v���f. � � H��I����L�uh�c��� � � H��I���L�ux������f�� �ATI��H�50J U��H��SH����H�@hd Hǀ� ��w uI�4$H��tH�����H��[]A\ú 1������ff. � @ � �H��I �� ��ff. � ATI��H��UH��SH���K�H�{H��H{L����Hk[]A\�ff. � @ ATH�5gI US�P�H��� H�����H�kXI��H���) H�E H�� ���H�EH�U�,H�EH�k`H��� H�E H�s H��t H�S(H���� � H����H�EH�U�:H�sH�EH��t H�SH��uhH�kPH��tqH�E � H���R�H�EH�U�,H�s@H�EH��t H�SHH��uL��[]A\� � H�{P���L��[]A\� � H�{`���H�kPH��u�� ��H��H�CP� H���x���H�k`�/��� � � ��H��H�CX����f�� �v�H��H�C`���f. � ��H�( f�� ��� �N��f����� �N�у�f����� �� �N�F��� D I���������SH� �+ H�� dH�%( H�D$1�H��I��H��?L��I��I1�I)��f�L��L��L�II��H��H��H�I)�B�I��A�A�H��u�H��yH�AA�-L��I��L��L9�v#f � ��0H��H��@�q�P�H9�w�M)�uH�D$dH3%( uH�� [� L��L��� ������V�f D UH��SH��(H�t$H�\$H��dH�%( H�D$1���H�L$H��� u0H��H�\$�� H�L$H��u-H�D$dH3%( u*H��([]� H�QH�\$H�L$H��t�H��H���z�������� UH��SH��H��H�>��H�H��u H��[]� D H�u H��H�D$�7���H�D$H��[]�ff. � 1�H�=& �R�f�� �H��H�5�E ��H�x@H��tH�pHH���&�f D H���f. � � �H��H�5qE �\�H�x0H��tH�p8H�����f D H���w��� � � �H��H�51E � �H�x H��tH�p(H����f D H���7��� � � �H��H�5�D ���H�xH��tH�pH���f�f D H����� � � �H��H�5�D ��H�8H��tH�pH���'� � H����� � AWAVAUATI��UH��� SH��H��HdH�%( H�D$81���H�CH�SL��H�5�J H�L$(�"H��J � H�CH�D$(�)��} �� H�(H�D$�� �� L�xH�h�\u L��D$4 f�t$2L9��� A�H� j( I��f���A��L�H9�� L�5�' L�d$2L�-�' D D��L��A�pHc��u����� A���� E��Kc�L�>�� D H�(�� �� L�`H�h�\u E1�L�-d# E1��D$4 f�L$2H���� �K�<<�< � �P����5 H�5' ��Hc�H�>��A� L�5!# L��L)��� L��L��H������M�OM��L9�w�L��L)�tK�4 H��H���� � H���C�H�CH�S�"H�CH�D$8dH3%( �� H��H[]A\A]A^A_� � L��A� L�5�" L)��k��� � K�4 H��L�D$�w���L�D$�I��� D A� L�5F" �&���f D A� L�54" ����f D A� L�5"" ���f D �00 A� L�t$2f�T$4f�Ѓ�f��A�D ��A�T �D$7�T$6��� @ H��L�`�� �7���1�A�I��H�H��H��A�I��H�H��A�I��H�H��H��A�I��H�H��A�I��H�Ic�H� �% H+�H���� �� H�� (��H=� �3 H�B�H��_�� H��"�� H��\�a � H�5 ! H��� ��� D L9��o A�H� T% I��f���A��L�H9�����H�=� �>��H�5�# H��1���� D 1������1�� ���f � 1�����f � 1�� ���f � A��I��H����� � H��L�x�� �%��� � <"tt<\tX��H� �$ f�4����I�I9��M������������f. � H�= �t��H�5M# H��1����� A� L�5� ���f D A� L�5� ���f D � H��H�T$� �H�CH�sH�T$�H�CL9������H�D$H�D$ H�D$��� @ � H�5y H���t����W��� � H�B�H���� IcD� L�>�� � � H�5* H���4������� � � H�5 H��������� � � H�5� H��������� � � H�5� H�������� � � H�5� H������� � H���� wJH�� ��L��H��H��H�D$H�� f�� (���I���H�D$��f��f�� $��L��H���*����=���H�=N ���H�5�! H��1�������1����ff. � �� �ATI��USH9��$ H��H�5�= ���H��H�5�= H�����H��H���� �o E �oHM�oP U �oX0]0�o`@e@�ohPmP�op`u`�oxp}pH��� H��� H�sH�;�n�H�sH�{H�E �]�H�s(H�{ H�E�L�H�s8H�{0H�E �;�H�{@H�sHH�E0�*�H�{PH�E@H��tH�wH�����H�EPH�{XH��tH�wH�����H�EXH�{`H��tH�wH���|���H�E`L��[]A\�H��@ H�5� H�81���� � ATI��UH��H��SH��H�����E�$$1�1�H�5gB H���D$�I��E��u"�D$f(�fT �! f. �! wf.�zBH��H��H��[]A\�O���H��H�D$����H�D$H�=&B �^ H�5W H��1�� ��H��H�D$���H�D$H�=�A �a H�5( H��1������SH��H��H�5�A 1�1����H��[H�����ff. � f�AUI��ATI��UH��SH��H��dH�%( H�D$1����� ��� �����: H���` �� �g H�CH�? H9�� H�,? H9�� H��> H9�v H���� H���� H���� ���� H���� H������� ��� �� �� H��L������E @ H������d���H��tuH���U���H��> H� �J��� D H��H��L��L���G H�D$dH3%( �� H��[]A\A]� � H�a> H� ����H��L��H��r��H� > H� �����H��= H9�@ H�5�? H�������t=H�� H��L�,$H�5�? ����� H��H�����H��L������K���f�H�5�? H��1�1����� H��H������H�uqH��L���������f � H��H��L��L��� ��f. � � H�5� L���l����� � � H�5� L���L���� � H��< H� ������ H�5y L��� ���� � H��< H� ����H� = H� ����H�upH��L���!����E����'�� � AWAVAUI��H��ATUH��SH��XH�B@L�zH�T$H�D$8H�BHH�t$ H�D$@H�H�RhH�D$H�APH�xH�@H�|$HH�yxH�D$H�wH�|$0H�t$(H�qxH��t H9��� � H�����H�EH�U�[H�EH�|$8 t H�|$@ �} �D$01�D�`�Q D H����H9�}RH�|$ t��� H�|$ �� H��L��H������H�T$H�t$ H��H������I�E �� u�I�EH9�|�H�D$H�T$0H�|$8 H�PxtOH�|$@ �� L�l$M��t9H�D$0H��~/A��1�� D ��A9�tM��t�L��L��H����R�A9�u�H�� ���H�EH�U�]H�EH��X[]A\A]A^A_�H�|$( �,���E1�� � A��E9�����M��t�H�t$L��H������� @ H�T$H�t$HH���������H�T$@H�t$8H����L�l$M���#����W���H�T$@H�t$8H�����l���H�����H�D$H�=a< H�5� H�PxH�T$H��H�Px1��:��f. � AWAVI��AUATUH��SH��hH�B0M�nxH�L$8H�ZH�D$ H�B8H�t$H�D$@H�H�RhH�$I�FXH�HH�@H�D$0I�F`H�L$XH�HH�@H�D$(I�EH�L$PH�D$HI�FxH��t H9��q � H��E1�A�����H�UH�E1�H�5�: H�|$8�{1�H�E�L��L�t$I���� � H����I9��� H�|$0 t E���� H�|$ t H�|$@ �� H�<$ �0 L��L���=��H�5�: 1�1�H��I������� H��H�D$���H�D$H�T$H��H�t$H���+���H�|$( � H�|$8L��I���.��H�T$H�t$H��H�����I��� �5���I�GI9��8���L�t$H�|$ M�nxM�e�M�fxtLH�|$@ � L�4$M��t7M��~2A��E1�� @ A��E9�t H��t�H��L��H��A���@�E9�u�H�� ���H�EH�U�}H�EH��h[]A\A]A^A_�f D H�|$H ����E1�� � A��E9������H��t�H�4$H��H������� D H�T$(H�t$PH���������H�T$@H�t$ H�����V���f � H�T$0H�t$XH���~��"���H�T$@H�t$ H���g�L�4$M�������������I�FxH�=-9 H�5� H�P�1�I�Vx���ff. � @ ATI��USH���Q�H��H�5�2 H�����H��L��H��H���.���[H��]A\���f�� �USH��H�����H��H�5t2 H���\��H��H��[]�f�� �UH��SH��H��H��H��dH�%( H�D$1��5��H��t H�T$dH3%( H���� H��[]�f�H�6 H��H�0���H��u)H�="8 H��t<H�5]7 1�1�����H��� � H�� H��H� $H�5�7 ����H���H�=8 H�5�7 ���H��H��7 ��,��ff. � �� �S��wS� uH�H�=�7 H�����H�5V1 H��H���;��H������ H�5� H��H���|�H��[���� 1��'�� � � �S��wS� uH�H�=U7 H�����H�5�0 H��H������H���c�� H�5f H��H��� �H��[�3��� 1���� � � �S��wS� uH�H�=�6 H��� ���H�5v0 H��H���[��H������ H�5� H��H����H��[����� 1��G�� � � �ATUS��wWI�Ը uH�H�=o6 H�����H�5 0 H��H������H��H���z�H�sqL��H��H���X�[H��]A\�L��� 1������ �ATUS��wWI�Ը uH�H�=�5 H���7���H�5�/ H��H���u��H��H��� �H�spL��H��H����[H��]A\����� 1��`��� �USH����w}H�Ӹ uH�H�=�5 H������H�5 / H��H�����H����H���u#H��H���X�H��H��[]�j��f. � H�H��H���B�H��H��[]�D��� 1����� � � �AUATUSH����w_I�ո uH�H�=�4 H���!���H�5z. H��H���_��H��I�����L��L��H��H��H������H��H��[]A\A]���� 1��B��f�� �AUATUSH����w_I�ո uH�H�=i4 H�����H�5�- H��H������H��I���t�L��L��H��H��H������H��H��[]A\A]�>��� 1�����f�� �ATI��U��H��S�{��� H��H������H��L��[��]A\�J���f. � � �ATI��H�5�3 1�U��H��1�S�`����w9H�ý uI�,$H�߾ ���H�=�3 H�����H��[]H��A\�B���� 1������ @ � �SH�=� H��dH�%( H�D$1��+��H�=i �O��H�5� H��H�.3 �Y��H�5� H���J��H�=� H�3 �G��H�=o H��2 �4��H�=�2 H�5� H��2 H�X0 H��@��H�5��H��H��2 ���H�=�2 � H����H�5" � ��H�=�2 �����H���H�5 ����H�=e2 � H�)�H�5� ���H�=F2 1�H� �H�5� ���H�=*2 � H�N��H�5� ���H�= 2 1�H���H�5� �f��H�=�1 � H�S��H�5� �G��H�=�1 1�H�'�H�5� �+��H�=�1 � H�X��H�5� � ��H�=�1 1�H���H�5t ����H�=y1 � H�]��H�5_ ����H�=Z1 1�H�1�H�5N ���H�=>1 � H�b��H�58 ���H�= 1 1�H�f��H�5& �z��H�=1 � H����H�5 �[��H�=�0 1�H����H�5 �?��H�=�0 1�H����H�5� �#��H�=�0 1�H�c��H�5� ���H�=�0 1�H���H�5� ����H�=t0 � H���H�5� ����H�=U0 1�H����H�5� ���H�=90 � H����H�5� ���H�=0 � H�N��H�5� �r��H�=�/ H�� H�5� �H��H�=�/ 1�H���H�5� �<��H�=�/ H�� H�5o ���H�=�/ � H����H�59 ���H�=�/ � H����H�5 ����H�=m/ � H�q���H�5 ����H�=V/ H�5� ���H�5� H��H�)/ �l�������H�P���H�5� H�����H�=/ H�5� �>�������H�b���H�5� H���S��H�=�. H�5� ��������H�����H�5� H���%��H�=�. H�5~ ���������H���H�5X H�����H�=x. H�5X ��������H�H���H�5* H������H�=J. H�50 ���� H�:��H�5 H��H�. ���H�= . �����H�����H�5� �u��H�=�- �����H���H�5� �V��H�=�- 1�H�V��H�5� �:��H�=�- H�5� ���� H����H�5� H��H��- ���H�=�- H�5� ���������H�v���H�58 H������H�=X- H�5� ��������H����H�5 H�����H�=*- H�5g �f��H�5� �����H�3���H���{��H�5, H���� H��* H�8���H��+ H���< H��, H��+ H��� H�v, H��+ H���� H�W, H��+ H���� H�8, H�q+ H���` H�, H�R+ H���) H��+ H�3+ H���� H��+ H�+ H���� H��+ H��* H���� H��+ H��* H���M H�~+ H��* H��� H�_+ H��* H���� H� + H�y* H���� H��* H�Z* H���q H�+ H�;* H���: H��* H� * H��� H��* H��) H���� H��* H��) H���� H�=�) H��* �` H��) H���0 H�i* H��) H���� H�=q) H�B* �� H�U) H���� H� * H�6) H���] � H�= H��) ���H� ) H�$H��� H�=c ���H�� H��H���B��H�=�( H��* �� H��( H���� H�~* H��( H��tZH�* H�* H�D$dH3%( �� H��[�f D � H�=a ���H��H� ) � ��� � � H�=� ���H�( �f D � H�=� �_��H� ( �V��� � H�=v �?��H��' �&��� � H�=H � ��H��H��' ����� H�= ���H��' ��� � H�=� ����H��' �O��� � H�=� ���H��' � ��� � H�=� ���H�p' ��� � H�=~ ���H�X' ��� � H�=u �_��H�@' ��� � H�=9 �?��H�(' �N��� � H�= � ��H�' ���� � H�=� ���H��& ��� � H�=� ����H��& ��� � H�=� ���H��& �r��� � H�=x ���H��& �;��� � H�=K ����H��& ���� � H�=6 �_���H��& ���� � H�= �?���H�h& ��� � H�=� � ���H�P& �_��� � H�=x ���H�8& �(��� � H�=C ����H� & �� � H�= ���H�& ��� � H�=� ���H��% ��� � H�=� ����H��% �L��� � H�=( �_���H��% ���� � H�=} �?���H��% ���� � H�=� � ���H��% ���辽�� � �H��H��� C* @ instance_variables to_hash Hash to_h 0123456789abcdef \n \r \t \f \b \\ \" JSON::GeneratorError unallocated JSON::State %u: %li not allowed in JSON null false true nesting of %ld is too deep json/common Ext Generator JSON::NestingError from_state initialize initialize_copy indent indent= space space= space_before space_before= object_nl object_nl= array_nl array_nl= max_nesting max_nesting= check_circular? allow_nan? ascii_only? depth depth= buffer_initial_length buffer_initial_length= configure merge [] []= generate GeneratorMethods Object to_json Array Integer Float String included to_json_raw to_json_raw_object Extend json_create TrueClass FalseClass NilClass MULTILINE to_s new allow_nan ascii_only unpack create_id extend key? __send__ respond_to? match keys dup utf-8 find Encoding encoding encode SAFE_STATE_PROTOTYPE JSON/Generator/State partial character in source, but hit end source sequence is illegal/malformed utf-8 source sequence is illegal/malformed utf8 ������������������ ����������������X��8�������������0123456789 �0 � � � � � � � ������� �������; B ���8 H���` 8���x ���� ����� ���� 8���� h���� ���� Ƚ�� ����4 (���L H���h Ⱦ��� ����� ����� ȿ��� ���$ X���L ����t ���� ����� X�� ��D ���| ���� (��� ��� ��P ���� ���� �� x��@ ���T ���� h��� ���� ���� (�� x��T ���h ���� ��� H��� ���� ��� x��X ���� ���� ���� �� H�d x�� ��� �� ��4 8�T ��t �� ��� ��� ��, �h ��� ��� H�� zR x � $ ȱ��@ FJ w� ?:*3$" D ��0 \ ����� p ����� � ���T H F A � D���% HW � \���" HT � t���& HW � ����& HW ����' HX ����" HT 0 Ժ�� A�U L غ��� E�v h <���/ A�m , � P���� B�D�D �V ABE ( � ����> F�D�O WAAF�� $ � Ļ��; A�A�G lDA $ ܻ��D E�A�N hFA $ 0 ���< E�A�N `FA $ X ���: E�A�N cAA 4 � 4���� F�A�K �K FBK FAB 4 � ����� F�A�K �K FBK FAB 4 � D���� F�A�K �T FBB FAB 4 ( ̽��� F�A�K �T FBB FAB 4 ` T���� F�A�K �R FBD DAB � ܾ��� E�O t AA 0 � H���� F�A�D �D0� DABA @ � �� F�I�B �A(�A0�JP� 0A(A BBBD 0 4 ����� F�E�A �J0t AABB H h L��� F�B�B �E(�A0�A8�D`� 8A0A(B BBBH @ � �� F�B�E �K(�A0�D@ 0A(A BBBK ( � ���a F�K�F �x ABA $ 0�� ( 8 <��1 B�G�D �`AB 8 d P��� B�H�A �� ABH M ABH � ���K � ���� K�K0� AD ( � ���� A�D�D@Y AAD 0 ��E A�D�G0T AAF ZAA 8 �� L ��6 H] K D l 8��9 H] K D � X��9 H] K D � x��9 H] K D � ���9 H\ L D L � ���� B�B�B �B(�D0�I8�G�� 8A0A(B BBBH , < ��X F�D�A �1 ABA 0 l H��� B�D�G �G0N GABE � ���# A�Z 8 � ���� B�E�D �D(�G@+ (A ABBI L � ���v B�B�B �H(�A0�D8�D�� 8A0A(B BBBA L H ���! B�B�E �B(�A0�D8�D�# 8A0A(B BBBG ( � ���> B�D�A �lDB $ � ���. E�A�G [DA ( � ���� E�D�M0u AAC ���i E�S E 8 ���i E�S E X ,��i E�S E , x |��p F�A�A �Q DBE , � ���p F�A�A �Q DBE 4 � ���� E�A�D R DAO R DAE 8 d��~ F�B�A �A(�D0V (D ABBE 8 L ���~ F�B�A �A(�D0V (D ABBE ( � ���6 F�D�F �\CB ( � �l F�M�H �x AEE � D�� E�K AG GNU � ` `{ �^ � P � � d[ P{ X{ ���o ` @ � 1 �} � P @ ���o ���o ���o �o r ���o �{ P ` p � � � � � � � � 0 @ P ` p � � � � � � � � 0 @ P ` p � � � � � � � � 0 @ P ` p GA$3a1 q[ GA$3p1113 p b[ GA* GA$annobin gcc 8.5.0 20210514 GA$plugin name: gcc-annobin GA$running gcc 8.5.0 20210514 GA* GA* GA! GA*FORTIFY GA+GLIBCXX_ASSERTIONS GA*GOW *� GA*cf_protection GA+omit_frame_pointer GA+stack_clash GA!stack_realign GA*FORTIFY p J GA+GLIBCXX_ASSERTIONS generator.so-2.5.9-114.module_el8.10.0+3991+5e651d4e.x86_64.debug ��Hr�7zXZ �ִF ! t/����] ?�E�h=��ڊ�2N���% ���T C��� (;���'5+� ^��#\�zÑ5��C�t�LD�W��K���oh:� np�� _�[��7�'eԦ���#� ����;i�"\�"ϕ\��3(x��W��c[���m�!�pQ�h��̍��z$:W]�Vr�˫��k�2�D�S����5f��DZ�hԛ���E7'��(�Nr�G�n��H�r��m��a�m��-�Rr .c �n_�:�������v���)㘜�$����p���z {j��ٽv���T`�|�gN��Gu���c�o�.�y,�G�(���.i����&������!(���T(��Z��e�K\#���-�K���:����NQ��R�F�\5#�ѿ� �v�3��S������`��u��a�77kH@�KuƁx�t��BY���DJѥC��?Rb���N#�Xmk|�s8��7e�GZ�R+x)� MsW,kc*#g\��A��g[8��X� ��f=΄?&�jN��N61���:~R� \[�=,҂j��+�vX��� �N�2�V��u��FB|#�q2 J!�v^�'��}��I4gJ%��@�^�h�y�%̷�z��h�<�9��/C�� (!GFH$��M��Pv/��[����a�Un`ɩ���cd �� |�;���07ok�LI�#eμb�� �Jͽq����\s�jg���Y�ПVL��^|>n<� �����U'�Q�"��1��uA�_>?< ��@c[/.z��q�坽�Q������!0pk�a �S_-$ �T5�䡝� G?/��l_�/��K�`�ڮq@�CAs�լ�����'(���\l�� ���� �@��l� a뷌g�¨#?F��{�hI`�*�V�l<���Z��ћҀ�j��/㉡܃�����G�5�I�1�OX���� w���IT� 7��E_#�AM�4 �S2�B$��WM�)�(hJ�=��R~ʵi�LO�#����E� �� �F�c�X�Qa�Y�qV�'e�����4��c4����L� �9,���+����A\w�;��� FO]To�{�k8*_��br�Ӆ��yc\��� ���H9ra�ug<�c�� C�?zd�M��l] �F��ʚ�-�?'R� �K�x�<f�k�V���魙��߀i�=��� y+����Qq�8��W�Ӷ�-��g��a��~ՌFdJ��ׄ�˺N��_��T�:Ģ^�X�cU����s��ȏ`m�j�em 8��v��w�����3�=j��kl!��E�L�cld5"3���8ǖmh/��?��s�`}���S1�א��2Yɧ��)���F�5ò �p>X��+�ݲ5|�n���,� ڬ�|! ���x�l��� q���Y�K�;�ކ� �qJ�4��1�#Io�� '�J���Oq{l��<&-m�f�/�☥��B�WhF5F]$P| �ip�b�4 � �1 ��dD��g� YZ .shstrtab .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt.sec .text .fini .rodata .eh_frame_hdr .eh_frame .note.gnu.property .init_array .fini_array .data.rel.ro .dynamic .got .bss .gnu.build.attributes .gnu_debuglink .gnu_debugdata 8 8 $ ���o ` ` 4 ( � � � 0 @ @ 1 8 ���o r r � E ���o @ T @ @ ^ B P P � h c @ @ @ n � � 0 w � � �? } d[ d[ � �[ �[ � � 8a 8a � Xc Xc � `n `n � P{ P{ � X{ X{ � `{ `{ h � �{ �{ � � �} �} 0 � � � � �` � H 0� H x� 4 �� "
| ver. 1.4 |
Github
|
.
| PHP 8.1.34 | ���֧ߧ֧�ѧ�ڧ� ����ѧߧڧ��: 0.4 |
proxy
|
phpinfo
|
���ѧ����ۧܧ�