? PNG ?%k25u25%fgd5n!? PNG ?%k25u25%fgd5n!PK\o o scanner.pynu["""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 PK\탭>> encoder.pynu["""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 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 PK\=տ  %__pycache__/tool.cpython-36.opt-1.pycnu[3 \m@s>dZddlZddlZddlZddlZddZedkr:edS)aCommand-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 "Cs d}d}tj||d}|jddtjdd|jddtjd d d|jd d d dd|j}|jphtj}|jpttj }|j }|Vy$|rt j |}nt j |t jd}Wn*tk r}zt|WYdd}~XnXWdQRX|"t j|||dd|jdWdQRXdS)Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)prog descriptioninfile?z-a JSON file to be validated or pretty-printed)nargstypehelpoutfilewz%write the output of infile to outfilez --sort-keys store_trueFz5sort the output of dictionaries alphabetically by key)actiondefaultr)Zobject_pairs_hook) sort_keysindent )argparseArgumentParser add_argumentZFileType parse_argsrsysstdinr stdoutrjsonload collections OrderedDict ValueError SystemExitdumpwrite) rrparserZoptionsrr robjer$!/usr/lib64/python3.6/json/tool.pymains0    $r&__main__)__doc__rrrrr&__name__r$r$r$r% sPK\(__pycache__/scanner.cpython-36.opt-1.pycnu[3 \o @sjdZddlZyddlmZWnek r4dZYnXdgZejdejej Bej BZ ddZ epde ZdS)zJSON token scanner N) make_scannerrz)(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c sv|j |j|j tj|j |j|j|j|j |j |j  f ddfdd}|S)Ncsy ||}Wntk r(t|YnX|dkrB ||d S|dkrd ||df S|dkr~||dfS|dkr|||ddkrd|dfS|dkr|||dd krd |dfS|d ko|||d d krd|d fS||}|dk rX|j\}}}|s&|rD||p2d|p            z#py_make_scanner.._scan_oncec sz ||SjXdS)N)clear)rr)rrr(r) scan_onceAs z"py_make_scanner..scan_once) r%r!r& NUMBER_REmatchr'r#r$r"rr r)contextr+r() rrrrr r!r"r#r$r%r&r'r)py_make_scanners"%r/) __doc__reZ_jsonrZc_make_scanner ImportError__all__compileVERBOSE MULTILINEDOTALLr,r/r(r(r(r)s :PK\(__pycache__/encoder.cpython-36.opt-2.pycnu[3 \>"@s>ddlZyddlmZWnek r0dZYnXyddlmZWnek rZdZYnXyddlmZWnek rdZYnXej dZ ej dZ ej dZ dd d d d d ddZ x&edD]Ze jeedjeqWedZddZepeZddZepeZGdddeZeeeeeeeee ej!f ddZ"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}infcCsdd}dtj||dS)NcSst|jdS)Nr) ESCAPE_DCTgroup)matchr$/usr/lib64/python3.6/json/encoder.pyreplace(sz%py_encode_basestring..replacer)ESCAPEsub)srrrrpy_encode_basestring$srcCsdd}dtj||dS)Nc Ssv|jd}yt|Stk rpt|}|dkr.replacer) ESCAPE_ASCIIr)rrrrrpy_encode_basestring_ascii0sr c @sJeZdZdZdZdddddddddddZd d Zd d Zdd dZdS) JSONEncoderz, z: FTN)skipkeys ensure_asciicheck_circular allow_nan sort_keysindent separatorsdefaultc CsZ||_||_||_||_||_||_|dk r:|\|_|_n|dk rHd|_|dk rV||_dS)N,) r"r#r$r%r&r'item_separator key_separatorr)) selfr"r#r$r%r&r'r(r)rrr__init__hs+zJSONEncoder.__init__cCstd|jjdS)Nz,Object of type '%s' is not JSON serializable) TypeError __class____name__)r-orrrr)szJSONEncoder.defaultcCsNt|tr |jrt|St|S|j|dd}t|ttfsDt|}dj|S)NT) _one_shot) isinstancestrr#rr iterencodelisttuplejoin)r-r2chunksrrrencodes zJSONEncoder.encodec Cs|jr i}nd}|jrt}nt}|jtjtt fdd}|rvtdk rv|j dkrvt||j ||j |j |j |j |j|j }n&t||j ||j ||j |j |j |j| }||dS)NcSsJ||krd}n$||krd}n||kr*d}n||S|sFtdt||S)NZNaNZInfinityz -Infinityz2Out of range float values are not JSON compliant: ) ValueErrorrepr)r2r%Z_reprZ_infZ_neginftextrrrfloatstrs z(JSONEncoder.iterencode..floatstrr)r$r#rrr%float__repr__INFINITYc_make_encoderr'r)r,r+r&r"_make_iterencode)r-r2r3markers_encoderr@ _iterencoderrrr7s&       zJSONEncoder.iterencode)F) r1 __module__ __qualname__r+r,r.r)r<r7rrrrr!Is6r!csdk r rd fdd  fdd fddS)N c 3s|sdVdSdk r6 |}|kr.d||<d}dk rh|d7}d|}|}||7}nd}}d}x|D]}|rd}n|} |r||Vqz|dkr|dVqz|dkr|d Vqz|dkr|d Vqz | r||Vqz | r||Vqz|V |fr:||}n" | rR||}n ||}|EdHqzW|dk r|d8}d|Vd Vdk r|=dS) Nz[]zCircular reference detected[r TFnulltruefalse]r) Zlst_current_indent_levelmarkeridZbufnewline_indentZ separatorfirstvaluer;)r=rG _floatstr_indent_intstr_item_separatorrH_iterencode_dict_iterencode_listdictrAidintr5r8rFr6r9rrr\s\               z*_make_iterencode.._iterencode_listc 3sL|sdVdSdk r6|}|kr.d||<dVdk rh|d7}d|}|}|Vnd}}d} rt|jddd }n|j}xx|D]n\}}|rnr| rȈ|}n^|dkrd }nP|d krd }nB|dkrd }n4|r|}n rqntdt|d|r2d }n|V|V V|r`|Vq|dkrrd Vq|dkrd Vq|d krd Vq|r|Vq| rƈ|Vq|fr||} n"| r||} n ||} | EdHqW|dk r2|d8}d|VdVdk rH|=dS)Nz{}zCircular reference detected{rMr TcSs|dS)Nrr)Zkvrrrasz<_make_iterencode.._iterencode_dict..)keyrOFrPrNzkey z is not a string})sorteditemsr/r>) ZdctrRrSrTr+rUrerbrVr;)r=rGrWrXrYrZrHr[r\_key_separator _skipkeys _sort_keysr]rAr^r_r5r8rFr6r9rrr[Ms                      z*_make_iterencode.._iterencode_dictc3s |r|Vn|dkr&dVn|dkr6dVn|dkrFdVn | r\|Vn | rr|Vn | fr||EdHnj |r||EdHnNdk rֈ |}|krΈd||<|}||EdHdk r|=dS)NrNTrOFrPzCircular reference detectedr)r2rRrS)r=_defaultrGrWrYrHr[r\r]rAr^r_r5r8rFr6r9rrrHs2       z%_make_iterencode.._iterencoder)rFrirGrXrWrfrZrhrgr3r=r]rAr^r_r5r8r6r9rYr)r=rirGrWrXrYrZrHr[r\rfrgrhr]rAr^r_r5r8rFr6r9rrEs .84O,rE)#reZ_jsonrZc_encode_basestring_ascii ImportErrorrZc_encode_basestringrrDcompilerrZHAS_UTF8rrangei setdefaultchrrrArCrr objectr!r=r]r^r_r5r8r6r9__str__rErrrrsR        >PK\.kW&&(__pycache__/decoder.cpython-36.opt-1.pycnu[3 \)1@sdZddlZddlmZyddlmZWnek r@dZYnXddgZej ej Bej BZ e dZe dZe d ZGd ddeZeeed Zejd e Zd ddddddddZddZdeejfddZepeZejde ZdZdejefddZejefdd ZGd!ddeZdS)"zImplementation of JSONDecoder N)scanner) scanstring JSONDecoderJSONDecodeErrornaninfz-infc@s eZdZdZddZddZdS)ra 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 cCsb|jdd|d}||jdd|}d||||f}tj||||_||_||_||_||_dS)N rz%s: line %d column %d (char %d)) countrfind ValueError__init__msgdocposlinenocolno)selfrrrrrerrmsgr$/usr/lib64/python3.6/json/decoder.pyr s zJSONDecodeError.__init__cCs|j|j|j|jffS)N) __class__rrr)rrrr __reduce__*szJSONDecodeError.__reduce__N)__name__ __module__ __qualname____doc__r rrrrrrs  )z -InfinityZInfinityNaNz(.*?)(["\\\x00-\x1f])"\/ r  )rrr bfnrtc Cs`||d|d}t|dkrL|ddkrLy t|dStk rJYnXd}t|||dS)Nr ZxXzInvalid \uXXXX escape)lenintr r)srescrrrr _decode_uXXXX;s r1TcCsg}|j}|d}x|||}|dkr4td|||j}|j\} } | rT|| | dkr`Pn.| dkr|rdj| } t| ||n || qy ||} Wn tk rtd||YnX| dkry || } Wn*tk rdj| } t| ||YnX|d7}nt||}|d 7}d |ko.d knr|||d d krt||d}d|kondknrd|d d>|dB}|d7}t|} || qWdj ||fS)aScan 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 NzUnterminated string starting atrrz"Invalid control character {0!r} atuzInvalid \escape: {0!r}r*iiz\uiii ) appendrendgroupsformat IndexErrorKeyErrorr1chrjoin)r/r8strictZ_bZ_mZchunks_appendZbeginchunkZcontent terminatorrr0charZuniZuni2rrr py_scanstringEsP           2 rDz [ \t\n\r]*z c#Cs|\}} g} | j} |dkri}|j} || | d} | dkr| |krb||| j} || | d} | dkr|dk r|| }|| dfSi} |dk r|| } | | dfS| dkrtd|| | d7} xt|| |\}} | ||}|| | ddkr&||| j} || | ddkr&td|| | d7} y:|| |krf| d7} || |krf||| dj} Wntk r~YnXy||| \}} Wn4tk r}ztd||jdWYdd}~XnX| ||fy0|| } | |kr||| dj} || } Wntk rd} YnX| d7} | dkr6Pn| d krPtd || d||| j} || | d} | d7} | dkrtd|| dqW|dk r|| }|| fSt| } |dk r|| } | | fS) Nr r}z1Expecting property name enclosed in double quotes:zExpecting ':' delimiterzExpecting valuer6,zExpecting ',' delimiter) r7 setdefaultr8rrr; StopIterationvaluedict) s_and_endr? scan_once object_hookobject_pairs_hookmemo_w_wsr/r8ZpairsZ pairs_appendZmemo_getnextcharresultkeyrJerrrrr JSONObjects     "        rWc Csz|\}}g}|||d}||krF|||dj}|||d}|dkrZ||dfS|j}xy|||\} }Wn2tk r} ztd|| jdWYdd} ~ XnX|| |||d}||kr|||dj}|||d}|d7}|dkrPn|dkrtd||dy:|||krT|d7}|||krT|||dj}Wqdtk rlYqdXqdW||fS)Nr ]zExpecting valuerGzExpecting ',' delimiter)r8r7rIrrJr;) rLrMrQrRr/r8valuesrSr@rJrVrrr JSONArrays@ "   rZc@s@eZdZdZdddddddddZejfddZd d d ZdS) raSimple JSON 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_intparse_constantr?rOcCsZ||_|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)rNfloatr[r.r\ _CONSTANTS __getitem__r]r?rOrWZ parse_objectrZZ parse_arrayrZ parse_stringrPrZ make_scannerrM)rrNr[r\r]r?rOrrrr s&   zJSONDecoder.__init__cCsF|j|||djd\}}|||j}|t|krBtd|||S)zlReturn the Python representation of ``s`` (a ``str`` instance containing a JSON document). r)idxz Extra data) raw_decoder8r-r)rr/rQobjr8rrrdecodeNs   zJSONDecoder.decodercCsPy|j||\}}Wn2tk rF}ztd||jdWYdd}~XnX||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)rMrIrrJ)rr/rarcr8rVrrrrbYs "zJSONDecoder.raw_decode)r) rrrrr WHITESPACEmatchrdrbrrrrrs 1 ) rreZjsonrZ_jsonrZ c_scanstring ImportError__all__VERBOSE MULTILINEDOTALLFLAGSr^rZPosInfZNegInfr rr_compileZ STRINGCHUNKZ BACKSLASHr1rfrDreZWHITESPACE_STRrWrZobjectrrrrrs6    ; P%PK\"__pycache__/scanner.cpython-36.pycnu[3 \o @sjdZddlZyddlmZWnek r4dZYnXdgZejdejej Bej BZ ddZ epde ZdS)zJSON token scanner N) make_scannerrz)(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c sv|j |j|j tj|j |j|j|j|j |j |j  f ddfdd}|S)Ncsy ||}Wntk r(t|YnX|dkrB ||d S|dkrd ||df S|dkr~||dfS|dkr|||ddkrd|dfS|dkr|||dd krd |dfS|d ko|||d d krd|d fS||}|dk rX|j\}}}|s&|rD||p2d|p            z#py_make_scanner.._scan_oncec sz ||SjXdS)N)clear)rr)rrr(r) scan_onceAs z"py_make_scanner..scan_once) r%r!r& NUMBER_REmatchr'r#r$r"rr r)contextr+r() rrrrr r!r"r#r$r%r&r'r)py_make_scanners"%r/) __doc__reZ_jsonrZc_make_scanner ImportError__all__compileVERBOSE MULTILINEDOTALLr,r/r(r(r(r)s :PK\f n(__pycache__/decoder.cpython-36.opt-2.pycnu[3 \)1@sddlZddlmZyddlmZWnek r<dZYnXddgZejej Bej BZ e dZ e dZe dZGd ddeZeee d Zejd e Zd d dddddddZddZdeejfddZepeZejde ZdZdejefddZejefddZGd ddeZdS)!N)scanner) scanstring JSONDecoderJSONDecodeErrornaninfz-infc@seZdZddZddZdS)rcCsb|jdd|d}||jdd|}d||||f}tj||||_||_||_||_||_dS)N rz%s: line %d column %d (char %d)) countrfind ValueError__init__msgdocposlinenocolno)selfrrrrrerrmsgr$/usr/lib64/python3.6/json/decoder.pyr s zJSONDecodeError.__init__cCs|j|j|j|jffS)N) __class__rrr)rrrr __reduce__*szJSONDecodeError.__reduce__N)__name__ __module__ __qualname__r rrrrrrs  )z -InfinityZInfinityNaNz(.*?)(["\\\x00-\x1f])"\/ r  )rrrbfnrtc Cs`||d|d}t|dkrL|ddkrLy t|dStk rJYnXd}t|||dS)Nr ZxXzInvalid \uXXXX escape)lenintr r)srescrrrr _decode_uXXXX;s r0TcCsg}|j}|d}x|||}|dkr4td|||j}|j\} } | rT|| | dkr`Pn.| dkr|rdj| } t| ||n || qy ||} Wn tk rtd||YnX| dkry || } Wn*tk rdj| } t| ||YnX|d7}nt||}|d7}d |ko.d knr|||d d krt||d}d |kondknrd|d d>|d B}|d7}t|} || qWdj ||fS)Nr zUnterminated string starting atrrz"Invalid control character {0!r} atuzInvalid \escape: {0!r}r)iiz\uiii ) appendrendgroupsformat IndexErrorKeyErrorr0chrjoin)r.r7strictZ_bZ_mZchunks_appendZbeginchunkZcontent terminatorrr/charZuniZuni2rrr py_scanstringEsP           2 rCz [ \t\n\r]*z c#Cs|\}} g} | j} |dkri}|j} || | d} | dkr| |krb||| j} || | d} | dkr|dk r|| }|| dfSi} |dk r|| } | | dfS| dkrtd|| | d7} xt|| |\}} | ||}|| | ddkr&||| j} || | ddkr&td|| | d7} y:|| |krf| d7} || |krf||| dj} Wntk r~YnXy||| \}} Wn4tk r}ztd||jdWYdd}~XnX| ||fy0|| } | |kr||| dj} || } Wntk rd} YnX| d7} | dkr6Pn| d krPtd || d||| j} || | d} | d7} | dkrtd|| dqW|dk r|| }|| fSt| } |dk r|| } | | fS) Nr r}z1Expecting property name enclosed in double quotes:zExpecting ':' delimiterzExpecting valuer5,zExpecting ',' delimiter) r6 setdefaultr7rrr: StopIterationvaluedict) s_and_endr> scan_once object_hookobject_pairs_hookmemo_w_wsr.r7ZpairsZ pairs_appendZmemo_getnextcharresultkeyrIerrrrr JSONObjects     "        rVc Csz|\}}g}|||d}||krF|||dj}|||d}|dkrZ||dfS|j}xy|||\} }Wn2tk r} ztd|| jdWYdd} ~ XnX|| |||d}||kr|||dj}|||d}|d7}|dkrPn|dkrtd||dy:|||krT|d7}|||krT|||dj}Wqdtk rlYqdXqdW||fS)Nr ]zExpecting valuerFzExpecting ',' delimiter)r7r6rHrrIr:) rKrLrPrQr.r7valuesrRr?rIrUrrr JSONArrays@ "   rYc@s<eZdZdddddddddZejfddZd d d ZdS) rNT)rM parse_float parse_intparse_constantr>rNcCsZ||_|p t|_|pt|_|p"tj|_||_||_ t |_ t |_ t|_i|_tj||_dS)N)rMfloatrZr-r[ _CONSTANTS __getitem__r\r>rNrVZ parse_objectrYZ parse_arrayrZ parse_stringrOrZ make_scannerrL)rrMrZr[r\r>rNrrrr s&   zJSONDecoder.__init__cCsF|j|||djd\}}|||j}|t|krBtd|||S)Nr)idxz Extra data) raw_decoder7r,r)rr.rPobjr7rrrdecodeNs   zJSONDecoder.decodercCsPy|j||\}}Wn2tk rF}ztd||jdWYdd}~XnX||fS)NzExpecting value)rLrHrrI)rr.r`rbr7rUrrrraYs "zJSONDecoder.raw_decode)r)rrrr WHITESPACEmatchrcrarrrrrs 1 )reZjsonrZ_jsonrZ c_scanstring ImportError__all__VERBOSE MULTILINEDOTALLFLAGSr]rZPosInfZNegInfr rr^compileZ STRINGCHUNKZ BACKSLASHr0rerCrdZWHITESPACE_STRrVrYobjectrrrrrs4    ; P%PK\ީi%__pycache__/tool.cpython-36.opt-2.pycnu[3 \m@s:ddlZddlZddlZddlZddZedkr6edS)Nc "Cs d}d}tj||d}|jddtjdd|jddtjd d d|jd d d dd|j}|jphtj}|jpttj }|j }|Vy$|rt j |}nt j |t jd}Wn*tk r}zt|WYdd}~XnXWdQRX|"t j|||dd|jdWdQRXdS)Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)prog descriptioninfile?z-a JSON file to be validated or pretty-printed)nargstypehelpoutfilewz%write the output of infile to outfilez --sort-keys store_trueFz5sort the output of dictionaries alphabetically by key)actiondefaultr)Zobject_pairs_hook) sort_keysindent )argparseArgumentParser add_argumentZFileType parse_argsrsysstdinr stdoutrjsonload collections OrderedDict ValueError SystemExitdumpwrite) rrparserZoptionsrr robjer$!/usr/lib64/python3.6/json/tool.pymains0    $r&__main__)rrrrr&__name__r$r$r$r% s PK\NTM++(__pycache__/encoder.cpython-36.opt-1.pycnu[3 \>"@sBdZddlZyddlmZWnek r4dZYnXyddlmZWnek r^dZYnXyddlmZ Wnek rdZ YnXej dZ ej dZ ej dZ d d d d d dddZx&edD]ZejeedjeqWedZddZepeZddZep eZGdddeZeeeeeeee e!ej"f ddZ#dS)zImplementation 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}infcCsdd}dtj||dS)z5Return a JSON representation of a Python string cSst|jdS)Nr) ESCAPE_DCTgroup)matchr$/usr/lib64/python3.6/json/encoder.pyreplace(sz%py_encode_basestring..replacer)ESCAPEsub)srrrrpy_encode_basestring$srcCsdd}dtj||dS)zAReturn an ASCII-only JSON representation of a Python string c Ssv|jd}yt|Stk rpt|}|dkr.replacer) ESCAPE_ASCIIr)rrrrrpy_encode_basestring_ascii0sr c @sNeZdZdZdZdZddddddddddd Zd d Zd d ZdddZ dS) JSONEncoderaZExtensible JSON 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_asciicheck_circular allow_nan sort_keysindent separatorsdefaultc CsZ||_||_||_||_||_||_|dk r:|\|_|_n|dk rHd|_|dk rV||_dS)aConstructor 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)rrr__init__hs+zJSONEncoder.__init__cCstd|jjdS)alImplement 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-orrrr)szJSONEncoder.defaultcCsNt|tr |jrt|St|S|j|dd}t|ttfsDt|}dj|S)zReturn 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) isinstancestrr#rr iterencodelisttuplejoin)r-r2chunksrrrencodes zJSONEncoder.encodec Cs|jr i}nd}|jrt}nt}|jtjtt fdd}|rvtdk rv|j dkrvt||j ||j |j |j |j |j|j }n&t||j ||j ||j |j |j |j| }||dS)zEncode the given object and yield each string representation as available. For example:: for chunk in JSONEncoder().iterencode(bigobject): mysocket.write(chunk) NcSsJ||krd}n$||krd}n||kr*d}n||S|sFtdt||S)NZNaNZInfinityz -Infinityz2Out of range float values are not JSON compliant: ) ValueErrorrepr)r2r%Z_reprZ_infZ_neginftextrrrfloatstrs z(JSONEncoder.iterencode..floatstrr)r$r#rrr%float__repr__INFINITYc_make_encoderr'r)r,r+r&r"_make_iterencode)r-r2r3markers_encoderr@ _iterencoderrrr7s&       zJSONEncoder.iterencode)F) r1 __module__ __qualname____doc__r+r,r.r)r<r7rrrrr!Is6r!csdk r rd fdd  fdd fddS)N c 3s|sdVdSdk r6 |}|kr.d||<d}dk rh|d7}d|}|}||7}nd}}d}x|D]}|rd}n|} |r||Vqz|dkr|dVqz|dkr|d Vqz|dkr|d Vqz | r||Vqz | r||Vqz|V |fr:||}n" | rR||}n ||}|EdHqzW|dk r|d8}d|Vd Vdk r|=dS) Nz[]zCircular reference detected[r TFnulltruefalse]r) Zlst_current_indent_levelmarkeridZbufnewline_indentZ separatorfirstvaluer;)r=rG _floatstr_indent_intstr_item_separatorrH_iterencode_dict_iterencode_listdictrAidintr5r8rFr6r9rrr]s\               z*_make_iterencode.._iterencode_listc 3sL|sdVdSdk r6|}|kr.d||<dVdk rh|d7}d|}|}|Vnd}}d} rt|jddd }n|j}xx|D]n\}}|rnr| rȈ|}n^|dkrd }nP|d krd }nB|dkrd }n4|r|}n rqntdt|d|r2d }n|V|V V|r`|Vq|dkrrd Vq|dkrd Vq|d krd Vq|r|Vq| rƈ|Vq|fr||} n"| r||} n ||} | EdHqW|dk r2|d8}d|VdVdk rH|=dS)Nz{}zCircular reference detected{rNr TcSs|dS)Nrr)Zkvrrrasz<_make_iterencode.._iterencode_dict..)keyrPFrQrOzkey z is not a string})sorteditemsr/r>) ZdctrSrTrUr+rVrfrcrWr;)r=rGrXrYrZr[rHr\r]_key_separator _skipkeys _sort_keysr^rAr_r`r5r8rFr6r9rrr\Ms                      z*_make_iterencode.._iterencode_dictc3s |r|Vn|dkr&dVn|dkr6dVn|dkrFdVn | r\|Vn | rr|Vn | fr||EdHnj |r||EdHnNdk rֈ |}|krΈd||<|}||EdHdk r|=dS)NrOTrPFrQzCircular reference detectedr)r2rSrT)r=_defaultrGrXrZrHr\r]r^rAr_r`r5r8rFr6r9rrrHs2       z%_make_iterencode.._iterencoder)rFrjrGrYrXrgr[rirhr3r=r^rAr_r`r5r8r6r9rZr)r=rjrGrXrYrZr[rHr\r]rgrhrir^rAr_r`r5r8rFr6r9rrEs .84O,rE)$rKreZ_jsonrZc_encode_basestring_ascii ImportErrorrZc_encode_basestringrrDcompilerrZHAS_UTF8rrangei setdefaultchrrrArCrr objectr!r=r^r_r`r5r8r6r9__str__rErrrrsT        >PK\](__pycache__/scanner.cpython-36.opt-2.pycnu[3 \o @sfddlZyddlmZWnek r0dZYnXdgZejdejejBej BZ ddZ ep`e ZdS)N) make_scannerrz)(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?c sv|j |j|j tj|j |j|j|j|j |j |j  f ddfdd}|S)Ncsy ||}Wntk r(t|YnX|dkrB ||d S|dkrd ||df S|dkr~||dfS|dkr|||ddkrd|dfS|dkr|||dd krd |dfS|d ko|||d d krd|d fS||}|dk rX|j\}}}|s&|rD||p2d|p            z#py_make_scanner.._scan_oncec sz ||SjXdS)N)clear)rr)rrr(r) scan_onceAs z"py_make_scanner..scan_once) r%r!r& NUMBER_REmatchr'r#r$r"rr r)contextr+r() rrrrr r!r"r#r$r%r&r'r)py_make_scanners"%r/) reZ_jsonrZc_make_scanner ImportError__all__compileVERBOSE MULTILINEDOTALLr,r/r(r(r(r)s :PK\~tc1c1)__pycache__/__init__.cpython-36.opt-1.pycnu[3 \<8 @sdZdZdddddddgZd Zd d lmZmZd d lmZd dl Z eddddddddZ dddddddddd ddZ dddddddddd ddZ edddZ ddZdddddddddZddddddddddZdS)a JSON (JavaScript Object Notation) 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.9dumpdumpsloadloads JSONDecoderJSONDecodeError JSONEncoderzBob Ippolito )rr)rNFT)skipkeys ensure_asciicheck_circular allow_nanindent separatorsdefault) r r r r clsrrr sort_keysc  Ks| rJ|rJ|rJ|rJ|dkrJ|dkrJ|dkrJ| dkrJ| rJ| rJtj|} n2|dkrVt}|f||||||| | d| j|} x| D]} |j| qWdS)aSerialize ``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 rrrr)_default_encoder iterencoderwrite)objfpr r r r rrrrrkwiterablechunkr%/usr/lib64/python3.6/json/__init__.pyrxs-   c Ksz| rH|rH|rH|rH|dkrH|dkrH|dkrH|dkrH| rH| rHtj|S|dkrTt}|f|||||||| d| j|S)auSerialize ``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 rrrr)rencoder) rr r r r rrrrrrrrrrs,   ) object_hookobject_pairs_hookcCs|j}|tjtjfrdS|tjtjfr.dS|tjras6  =8 PK\.kW&&"__pycache__/decoder.cpython-36.pycnu[3 \)1@sdZddlZddlmZyddlmZWnek r@dZYnXddgZej ej Bej BZ e dZe dZe d ZGd ddeZeeed Zejd e Zd ddddddddZddZdeejfddZepeZejde ZdZdejefddZejefdd ZGd!ddeZdS)"zImplementation of JSONDecoder N)scanner) scanstring JSONDecoderJSONDecodeErrornaninfz-infc@s eZdZdZddZddZdS)ra 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 cCsb|jdd|d}||jdd|}d||||f}tj||||_||_||_||_||_dS)N rz%s: line %d column %d (char %d)) countrfind ValueError__init__msgdocposlinenocolno)selfrrrrrerrmsgr$/usr/lib64/python3.6/json/decoder.pyr s zJSONDecodeError.__init__cCs|j|j|j|jffS)N) __class__rrr)rrrr __reduce__*szJSONDecodeError.__reduce__N)__name__ __module__ __qualname____doc__r rrrrrrs  )z -InfinityZInfinityNaNz(.*?)(["\\\x00-\x1f])"\/ r  )rrr bfnrtc Cs`||d|d}t|dkrL|ddkrLy t|dStk rJYnXd}t|||dS)Nr ZxXzInvalid \uXXXX escape)lenintr r)srescrrrr _decode_uXXXX;s r1TcCsg}|j}|d}x|||}|dkr4td|||j}|j\} } | rT|| | dkr`Pn.| dkr|rdj| } t| ||n || qy ||} Wn tk rtd||YnX| dkry || } Wn*tk rdj| } t| ||YnX|d7}nt||}|d 7}d |ko.d knr|||d d krt||d}d|kondknrd|d d>|dB}|d7}t|} || qWdj ||fS)aScan 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 NzUnterminated string starting atrrz"Invalid control character {0!r} atuzInvalid \escape: {0!r}r*iiz\uiii ) appendrendgroupsformat IndexErrorKeyErrorr1chrjoin)r/r8strictZ_bZ_mZchunks_appendZbeginchunkZcontent terminatorrr0charZuniZuni2rrr py_scanstringEsP           2 rDz [ \t\n\r]*z c#Cs|\}} g} | j} |dkri}|j} || | d} | dkr| |krb||| j} || | d} | dkr|dk r|| }|| dfSi} |dk r|| } | | dfS| dkrtd|| | d7} xt|| |\}} | ||}|| | ddkr&||| j} || | ddkr&td|| | d7} y:|| |krf| d7} || |krf||| dj} Wntk r~YnXy||| \}} Wn4tk r}ztd||jdWYdd}~XnX| ||fy0|| } | |kr||| dj} || } Wntk rd} YnX| d7} | dkr6Pn| d krPtd || d||| j} || | d} | d7} | dkrtd|| dqW|dk r|| }|| fSt| } |dk r|| } | | fS) Nr r}z1Expecting property name enclosed in double quotes:zExpecting ':' delimiterzExpecting valuer6,zExpecting ',' delimiter) r7 setdefaultr8rrr; StopIterationvaluedict) s_and_endr? scan_once object_hookobject_pairs_hookmemo_w_wsr/r8ZpairsZ pairs_appendZmemo_getnextcharresultkeyrJerrrrr JSONObjects     "        rWc Csz|\}}g}|||d}||krF|||dj}|||d}|dkrZ||dfS|j}xy|||\} }Wn2tk r} ztd|| jdWYdd} ~ XnX|| |||d}||kr|||dj}|||d}|d7}|dkrPn|dkrtd||dy:|||krT|d7}|||krT|||dj}Wqdtk rlYqdXqdW||fS)Nr ]zExpecting valuerGzExpecting ',' delimiter)r8r7rIrrJr;) rLrMrQrRr/r8valuesrSr@rJrVrrr JSONArrays@ "   rZc@s@eZdZdZdddddddddZejfddZd d d ZdS) raSimple JSON 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_intparse_constantr?rOcCsZ||_|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)rNfloatr[r.r\ _CONSTANTS __getitem__r]r?rOrWZ parse_objectrZZ parse_arrayrZ parse_stringrPrZ make_scannerrM)rrNr[r\r]r?rOrrrr s&   zJSONDecoder.__init__cCsF|j|||djd\}}|||j}|t|krBtd|||S)zlReturn the Python representation of ``s`` (a ``str`` instance containing a JSON document). r)idxz Extra data) raw_decoder8r-r)rr/rQobjr8rrrdecodeNs   zJSONDecoder.decodercCsPy|j||\}}Wn2tk rF}ztd||jdWYdd}~XnX||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)rMrIrrJ)rr/rarcr8rVrrrrbYs "zJSONDecoder.raw_decode)r) rrrrr WHITESPACEmatchrdrbrrrrrs 1 ) rreZjsonrZ_jsonrZ c_scanstring ImportError__all__VERBOSE MULTILINEDOTALLFLAGSr^rZPosInfZNegInfr rr_compileZ STRINGCHUNKZ BACKSLASHr1rfrDreZWHITESPACE_STRrWrZobjectrrrrrs6    ; P%PK\NTM++"__pycache__/encoder.cpython-36.pycnu[3 \>"@sBdZddlZyddlmZWnek r4dZYnXyddlmZWnek r^dZYnXyddlmZ Wnek rdZ YnXej dZ ej dZ ej dZ d d d d d dddZx&edD]ZejeedjeqWedZddZepeZddZep eZGdddeZeeeeeeee e!ej"f ddZ#dS)zImplementation 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}infcCsdd}dtj||dS)z5Return a JSON representation of a Python string cSst|jdS)Nr) ESCAPE_DCTgroup)matchr$/usr/lib64/python3.6/json/encoder.pyreplace(sz%py_encode_basestring..replacer)ESCAPEsub)srrrrpy_encode_basestring$srcCsdd}dtj||dS)zAReturn an ASCII-only JSON representation of a Python string c Ssv|jd}yt|Stk rpt|}|dkr.replacer) ESCAPE_ASCIIr)rrrrrpy_encode_basestring_ascii0sr c @sNeZdZdZdZdZddddddddddd Zd d Zd d ZdddZ dS) JSONEncoderaZExtensible JSON 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_asciicheck_circular allow_nan sort_keysindent separatorsdefaultc CsZ||_||_||_||_||_||_|dk r:|\|_|_n|dk rHd|_|dk rV||_dS)aConstructor 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)rrr__init__hs+zJSONEncoder.__init__cCstd|jjdS)alImplement 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-orrrr)szJSONEncoder.defaultcCsNt|tr |jrt|St|S|j|dd}t|ttfsDt|}dj|S)zReturn 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) isinstancestrr#rr iterencodelisttuplejoin)r-r2chunksrrrencodes zJSONEncoder.encodec Cs|jr i}nd}|jrt}nt}|jtjtt fdd}|rvtdk rv|j dkrvt||j ||j |j |j |j |j|j }n&t||j ||j ||j |j |j |j| }||dS)zEncode the given object and yield each string representation as available. For example:: for chunk in JSONEncoder().iterencode(bigobject): mysocket.write(chunk) NcSsJ||krd}n$||krd}n||kr*d}n||S|sFtdt||S)NZNaNZInfinityz -Infinityz2Out of range float values are not JSON compliant: ) ValueErrorrepr)r2r%Z_reprZ_infZ_neginftextrrrfloatstrs z(JSONEncoder.iterencode..floatstrr)r$r#rrr%float__repr__INFINITYc_make_encoderr'r)r,r+r&r"_make_iterencode)r-r2r3markers_encoderr@ _iterencoderrrr7s&       zJSONEncoder.iterencode)F) r1 __module__ __qualname____doc__r+r,r.r)r<r7rrrrr!Is6r!csdk r rd fdd  fdd fddS)N c 3s|sdVdSdk r6 |}|kr.d||<d}dk rh|d7}d|}|}||7}nd}}d}x|D]}|rd}n|} |r||Vqz|dkr|dVqz|dkr|d Vqz|dkr|d Vqz | r||Vqz | r||Vqz|V |fr:||}n" | rR||}n ||}|EdHqzW|dk r|d8}d|Vd Vdk r|=dS) Nz[]zCircular reference detected[r TFnulltruefalse]r) Zlst_current_indent_levelmarkeridZbufnewline_indentZ separatorfirstvaluer;)r=rG _floatstr_indent_intstr_item_separatorrH_iterencode_dict_iterencode_listdictrAidintr5r8rFr6r9rrr]s\               z*_make_iterencode.._iterencode_listc 3sL|sdVdSdk r6|}|kr.d||<dVdk rh|d7}d|}|}|Vnd}}d} rt|jddd }n|j}xx|D]n\}}|rnr| rȈ|}n^|dkrd }nP|d krd }nB|dkrd }n4|r|}n rqntdt|d|r2d }n|V|V V|r`|Vq|dkrrd Vq|dkrd Vq|d krd Vq|r|Vq| rƈ|Vq|fr||} n"| r||} n ||} | EdHqW|dk r2|d8}d|VdVdk rH|=dS)Nz{}zCircular reference detected{rNr TcSs|dS)Nrr)Zkvrrrasz<_make_iterencode.._iterencode_dict..)keyrPFrQrOzkey z is not a string})sorteditemsr/r>) ZdctrSrTrUr+rVrfrcrWr;)r=rGrXrYrZr[rHr\r]_key_separator _skipkeys _sort_keysr^rAr_r`r5r8rFr6r9rrr\Ms                      z*_make_iterencode.._iterencode_dictc3s |r|Vn|dkr&dVn|dkr6dVn|dkrFdVn | r\|Vn | rr|Vn | fr||EdHnj |r||EdHnNdk rֈ |}|krΈd||<|}||EdHdk r|=dS)NrOTrPFrQzCircular reference detectedr)r2rSrT)r=_defaultrGrXrZrHr\r]r^rAr_r`r5r8rFr6r9rrrHs2       z%_make_iterencode.._iterencoder)rFrjrGrYrXrgr[rirhr3r=r^rAr_r`r5r8r6r9rZr)r=rjrGrXrYrZr[rHr\r]rgrhrir^rAr_r`r5r8rFr6r9rrEs .84O,rE)$rKreZ_jsonrZc_encode_basestring_ascii ImportErrorrZc_encode_basestringrrDcompilerrZHAS_UTF8rrangei setdefaultchrrrArCrr objectr!r=r^r_r`r5r8r6r9__str__rErrrrsT        >PK\=տ  __pycache__/tool.cpython-36.pycnu[3 \m@s>dZddlZddlZddlZddlZddZedkr:edS)aCommand-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 "Cs d}d}tj||d}|jddtjdd|jddtjd d d|jd d d dd|j}|jphtj}|jpttj }|j }|Vy$|rt j |}nt j |t jd}Wn*tk r}zt|WYdd}~XnXWdQRX|"t j|||dd|jdWdQRXdS)Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)prog descriptioninfile?z-a JSON file to be validated or pretty-printed)nargstypehelpoutfilewz%write the output of infile to outfilez --sort-keys store_trueFz5sort the output of dictionaries alphabetically by key)actiondefaultr)Zobject_pairs_hook) sort_keysindent )argparseArgumentParser add_argumentZFileType parse_argsrsysstdinr stdoutrjsonload collections OrderedDict ValueError SystemExitdumpwrite) rrparserZoptionsrr robjer$!/usr/lib64/python3.6/json/tool.pymains0    $r&__main__)__doc__rrrrr&__name__r$r$r$r% sPK\~tc1c1#__pycache__/__init__.cpython-36.pycnu[3 \<8 @sdZdZdddddddgZd Zd d lmZmZd d lmZd dl Z eddddddddZ dddddddddd ddZ dddddddddd ddZ edddZ ddZdddddddddZddddddddddZdS)a JSON (JavaScript Object Notation) 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.9dumpdumpsloadloads JSONDecoderJSONDecodeError JSONEncoderzBob Ippolito )rr)rNFT)skipkeys ensure_asciicheck_circular allow_nanindent separatorsdefault) r r r r clsrrr sort_keysc  Ks| rJ|rJ|rJ|rJ|dkrJ|dkrJ|dkrJ| dkrJ| rJ| rJtj|} n2|dkrVt}|f||||||| | d| j|} x| D]} |j| qWdS)aSerialize ``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 rrrr)_default_encoder iterencoderwrite)objfpr r r r rrrrrkwiterablechunkr%/usr/lib64/python3.6/json/__init__.pyrxs-   c Ksz| rH|rH|rH|rH|dkrH|dkrH|dkrH|dkrH| rH| rHtj|S|dkrTt}|f|||||||| d| j|S)auSerialize ``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 rrrr)rencoder) rr r r r rrrrrrrrrrs,   ) object_hookobject_pairs_hookcCs|j}|tjtjfrdS|tjtjfr.dS|tjras6  =8 PK\ ;) )__pycache__/__init__.cpython-36.opt-2.pycnu[3 \<8 @sdZdddddddgZdZd d lmZmZd d lmZd d lZeddddd d d dZ ddddd d d d dd ddZ ddddd d d d dd ddZ ed d dZ ddZ d d d d d d dddZd d d d d d d dddZd S)z2.0.9dumpdumpsloadloads JSONDecoderJSONDecodeError JSONEncoderzBob Ippolito )rr)rNFT)skipkeys ensure_asciicheck_circular allow_nanindent separatorsdefault) r r r r clsrrr sort_keysc  Ks| rJ|rJ|rJ|rJ|dkrJ|dkrJ|dkrJ| dkrJ| rJ| rJtj|} n2|dkrVt}|f||||||| | d| j|} x| D]} |j| qWdS)N)r r r r rrrr)_default_encoder iterencoderwrite)objfpr r r r rrrrrkwiterablechunkr%/usr/lib64/python3.6/json/__init__.pyrxs-   c Ksz| rH|rH|rH|rH|dkrH|dkrH|dkrH|dkrH| rH| rHtj|S|dkrTt}|f|||||||| d| j|S)N)r r r r rrrr)rencoder) rr r r r rrrrrrrrrrs,   ) object_hookobject_pairs_hookcCs|j}|tjtjfrdS|tjtjfr.dS|tjrbs4  =8 PK\m~0)1)1 decoder.pynu["""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 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 PK\<8<8 __init__.pynu[r"""JSON (JavaScript Object Notation) 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 ' 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) PK\mmtool.pynu[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() PK\o o scanner.pynu[PK\탭>>  encoder.pynu[PK\=տ  %wH__pycache__/tool.cpython-36.opt-1.pycnu[PK\(N__pycache__/scanner.cpython-36.opt-1.pycnu[PK\(V__pycache__/encoder.cpython-36.opt-2.pycnu[PK\.kW&&(7r__pycache__/decoder.cpython-36.opt-1.pycnu[PK\"t__pycache__/scanner.cpython-36.pycnu[PK\f n(z__pycache__/decoder.cpython-36.opt-2.pycnu[PK\ީi%__pycache__/tool.cpython-36.opt-2.pycnu[PK\NTM++(__pycache__/encoder.cpython-36.opt-1.pycnu[PK\](__pycache__/scanner.cpython-36.opt-2.pycnu[PK\~tc1c1)__pycache__/__init__.cpython-36.opt-1.pycnu[PK\.kW&&"#__pycache__/decoder.cpython-36.pycnu[PK\NTM++"J__pycache__/encoder.cpython-36.pycnu[PK\=տ  9w__pycache__/tool.cpython-36.pycnu[PK\~tc1c1#}__pycache__/__init__.cpython-36.pycnu[PK\ ;) )I__pycache__/__init__.cpython-36.opt-2.pycnu[PK\m~0)1)1 Odecoder.pynu[PK\<8<8 __init__.pynu[PK\mm)%too