MhLUddlZddlZddlZddlmZmZmZmZmZm Z m Z m Z m Z m Z ddlZddlmZdae ejed<GddejZdddddddddddd d ed e ed ed e eeeefgefd e eegefde eegefde eegefdede eee eefgefdedede edefdZdddddddddddd ded e ed ed e eeeefgefd e eegefde eegefde eegefdede eee eefgefdedede efdZdddddddddddd ded e ed ed e eeeefgefd e eegefde eegefde eegefdede eee eefgefdedede efdZdZdeee eefgeffdZddddddddddddejd ded ed ed!ed"ed#ed e e d$d%e e eefd&e e eefd'e eegefd(ed)ed*eded+efd,Zddddddddddddejd ded ed!ed"ed#ed e e d$d%e e eefd&e e eefd'e eegefd(ed)ed*eded+efd-Z Gd.d$Z!defd/Z"dS)0N) AnyCallableIOIterableMappingOptionalSetTupleTypeUnion)Parser_reserved_word_rec"eZdZdZdZdZdZdZdS) QuoteStyleaControls how strings will be quoted during encoding. By default, for compatibility with the `json` module and older versions of `json5`, strings (not being used as keys and that are legal identifiers) will always be double-quoted, and any double quotes in the string will be escaped. This is `QuoteStyle.ALWAYS_DOUBLE`. If you pass `QuoteStyle.ALWAYS_SINGLE`, then strings will always be single-quoted, and any single quotes in the string will be escaped. If you pass `QuoteStyle.PREFER_DOUBLE`, then the behavior is the same as ALWAYS_DOUBLE and strings will be double-quoted *unless* the string contains more double quotes than single quotes, in which case the string will be single-quoted and single quotes will be escaped. If you pass `QuoteStyle.PREFER_SINGLE`, then the behavior is the same as ALWAYS_SINGLE and strings will be single-quoted *unless* the string contains more single quotes than double quotes, in which case the string will be double-quoted and any double quotes will be escaped. *Note:* PREFER_DOUBLE and PREFER_SINGLE can impact performance, since in order to know which encoding to use you have to iterate over the entire string to count the number of single and double quotes. The codes guesses at an encoding while doing so, but if it guess wrong, the entire string has to be re-encoded, which will slow things down. If you are very concerned about performance (a) you probably shouldn't be using this library in the first place, because it just isn't very fast, and (b) you should use ALWAYS_DOUBLE or ALWAYS_SINGLE, which won't have this issue. always_double always_single prefer_double prefer_singleN)__name__ __module__ __qualname____doc__ ALWAYS_DOUBLE ALWAYS_SINGLE PREFER_DOUBLE PREFER_SINGLEI/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/json5/lib.pyrr's.6$M#M#M#MMMrrT encodingcls object_hook parse_float parse_intparse_constantstrictobject_pairs_hookallow_duplicate_keysconsume_trailingstartfpr!r"r#r$r%r&r'r(r)r*r+returnc |} t| ||||||||| | |  \} }}|rt|| S)aDeserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. Supports almost the same arguments as ``json.load()`` except that: - the `cls` keyword is ignored. - an extra `allow_duplicate_keys` parameter supports checking for duplicate keys in a object; by default, this is True for compatibility with ``json.load()``, but if set to False and the object contains duplicate keys, a ValueError will be raised. - an extra `consume_trailing` parameter specifies whether to consume any trailing characters after a valid object has been parsed. By default, this value is True and the only legal trailing characters are whitespace. If this value is set to False, parsing will stop when a valid object has been parsed and any trailing characters in the string will be ignored. - an extra `start` parameter specifies the zero-based offset into the file to start parsing at. If `start` is None, parsing will start at the current position in the file, and line number and column values will be reported as if starting from the beginning of the file; If `start` is not None, `load` will seek to zero and then read (and discard) the appropriate number of characters before beginning parsing; the file must be seekable for this to work correctly. You can use `load(..., consume_trailing=False)` to repeatedly read values from a file. However, in the current implementation `load` does this by reading the entire file into memory before doing anything, so it is not very efficient. Raises - `ValueError` if given an invalid document. This is different from the `json` module, which raises `json.JSONDecodeError`. - `UnicodeDecodeError` if given a byte string that is not a legal UTF-8 document (or the equivalent, if using a different `encoding`). This matches the `json` module. r )readparse ValueError)r,r!r"r#r$r%r&r'r(r)r*r+svalerr_s rloadr6Iskl  A  %+1)   KCa oo Jrr2c ft|||||||||| | |  \} } }| rt| | S)aPDeserialize ``s`` (a string containing a JSON5 document) to a Python object. Supports the same arguments as ``json.load()`` except that: - the `cls` keyword is ignored. - an extra `allow_duplicate_keys` parameter supports checking for duplicate keys in a object; by default, this is True for compatibility with ``json.load()``, but if set to False and the object contains duplicate keys, a ValueError will be raised. - an extra `consume_trailing` parameter specifies whether to consume any trailing characters after a valid object has been parsed. By default, this value is True and the only legal trailing characters are whitespace. If this value is set to False, parsing will stop when a valid object has been parsed and any trailing characters in the string will be ignored. - an extra `start` parameter specifies the zero-based offset into the string to start parsing at. Raises - `ValueError` if given an invalid document. This is different from the `json` module, which raises `json.JSONDecodeError`. - `UnicodeDecodeError` if given a byte string that is not a legal UTF-8 document (or the equivalent, if using a different `encoding`). This matches the `json` module. ) r2r!r"r#r$r%r&r'r(r)r*r+)r0r1)r2r!r"r#r$r%r&r'r(r)r*r+r3r4r5s rloadsr8s^V  %+1)   KCa oo Jrc | Jdt|tr|pd}||}|std| pd} t |d| } | || d \} }}|rd||fS t | |||||| }|d|fS#t$r}dt||fcYd}~Sd}~wwxYw) a Parse ```s``, returning positional information along with a value. This works exactly like `loads()`, except that (a) it returns the position in the string where the parsing stopped (either due to hitting an error or parsing a valid value) and any error as a string, (b) it takes an optional `consume_trailing` parameter that says whether to keep parsing the string after a valid value has been parsed; if True (the default), any trailing characters must be whitespace. If False, parsing stops when a valid value has been reached, (c) it takes an optional `start` parameter that specifies a zero-based offset to start parsing from in the string, and (d) the return value is different, as described below. `parse()` is useful if you have a string that might contain multiple values and you need to extract all of them; you can do so by repeatedly calling `parse`, setting `start` to the value returned in `position` from the previous call. Returns a tuple of (value, error_string, position). If the string was a legal value, `value` will be the deserialized value, `error_string` will be `None`, and `position` will be one past the zero-based offset where the parser stopped reading. If the string was not a legal value, `value` will be `None`, `error_string` will be the string value of the exception that would've been raised, and `position` will be the zero-based farthest offset into the string where the parser hit an error. Raises: - `UnicodeDecodeError` if given a byte string that is not a legal UTF-8 document (or the equivalent, if using a different `encoding`). This matches the `json` module. Note that this does *not* raise a `ValueError`; instead any error is returned as the second value in the tuple. You can use this method to read in a series of values from a string `s` as follows: >>> import json5 >>> s = '1 2 3 4' >>> values = [] >>> start = 0 >>> while True: ... v, err, pos = json5.parse(s, start=start, consume_trailing=False) ... if v: ... values.append(v) ... start = pos ... if start == len(s) or s[start:].isspace(): ... # Reached the end of the string (ignoring trailing ... # whitespace ... break ... continue ... raise ValueError(err) >>> values [1, 2, 3, 4] Nz!Custom decoders are not supportedzutf-8z!Empty strings are not legal JSON5rz)pos)_strict_consume_trailing) global_vars)r#r$r%r&r(r)) isinstancebytesdecoder1r r0_convertstr)r2r!r"r#r$r%r&r'r(r)r*r+parserastr4r:valuees rr0r0s4V ;;;;;;!U&w HHX   ><=== JQE Azu - - -FLL &=MNN!MCc S#~ ! ##)/!5   dC !!!SVVS       !sB"" C,C=CCcnd}fd}|pt}|pt}|p|}t|||||S)Ncpt|ddddS)NInfinityinfNaNnan)floatreplace)r2s r_fp_constant_parserz%_convert.._fp_constant_parserDs.QYYz51199%GGHHHrcsBt}|D]1\}}||vrtd|d||2r |Srt|St|S)NzDuplicate key "z" found in object)setr1adddict)pairskeyskeyr5r)r#r(s r_dictifyz_convert.._dictifyGs# 55D  Q$;;$%Ms%M%M%MNNN  ,$$U++ +  ,;tE{{++ +E{{r)rMint _walk_ast) rDr#r$r%r&r(r)rOrWs ` `` rrArA;sqIII       &K SI#:':N S(KN K KKrdictifyc|dkrdS|dkrdS|dkrdS|\}}|dkrl|ds|dr |d Sd |vsd |vsd |vr |Sd|vsd|vr |S|S|dkr|S|dkr?g}|D]/\}} t| } ||| f0|S|dkrfd|DStd|z)NNoneTrueTFalseFnumber0x0X)base.rFErIrKstringobjectarrayc 6g|]}t|Sr)rY).0elrZr&r$r%s r z_walk_ast..}s9    b'; > J J   rz unknown el: ) startswithrYappendr1) rkrZr$r%r&tyvrTrVval_exprr3s ```` rrYrY\s V||t V||t W}}u EB X~~ <<   )d!3!3 )9QR((( ( !88saxx3!88;q>> ! ??eqjj!>!$$ $y|| X~~ X~~ % %MC'; >C LL#s $ $ $ $wu~~ W}}            ^b( ) ))rF) skipkeys ensure_asciicheck_circular allow_nanr"indent separatorsdefault sort_keys quote_keystrailing_commasr) quote_styleobjrrrsrtru JSON5Encoderrvrwrxryrzr{r|c  b|td||||||||| | | | | |d|dS)a`Serialize ``obj`` to a JSON5-formatted stream to ``fp``, a ``.write()``-supporting file-like object. Supports the same arguments as ``dumps()``, below. Calling ``dump(obj, fp, quote_keys=True, trailing_commas=False, allow_duplicate_keys=True)`` should produce exactly the same output as ``json.dump(obj, fp).`` )r}rrrsrtrur"rvrwrxryrzr{r)r|Nr)writedumps)r}r,rrrsrtrur"rvrwrxryrzr{r)r|kws rdumprso:HH  %)!!+!5#    rc  |pt}|d|||||||| | | | | d |}||tddS)a> Serialize ``obj`` to a JSON5-formatted string. Supports the same arguments as ``json.dumps()``, except that: - The ``encoding`` keyword is ignored; Unicode strings are always written. - By default, object keys that are legal identifiers are not quoted; if you pass ``quote_keys=True``, they will be. - By default, if lists and objects span multiple lines of output (i.e., when ``indent`` >=0), the last item will have a trailing comma after it. If you pass ``trailing_commas=False``, it will not. - If you use a number, a boolean, or ``None`` as a key value in a dict, it will be converted to the corresponding JSON string value, e.g. "1", "true", or "null". By default, ``dump()`` will match the `json` modules behavior and produce malformed JSON if you mix keys of different types that have the same converted value; e.g., ``{1: "foo", "1": "bar"}`` produces '{"1": "foo", "1": "bar"}', an object with duplicated keys. If you pass ``allow_duplicate_keys=False``, an exception will be raised instead. - If `quote_keys` is true, then keys of objects will be enclosed in quotes, as in regular JSON. Otheriwse, keys will not be enclosed in quotes unless they contain whitespace. - If `trailing_commas` is false, then commas will not be inserted after the final elements of objects and arrays, as in regular JSON. Otherwise, such commas will be inserted. - If `allow_duplicate_keys` is false, then only the last entry with a given key will be written. Otherwise, all entries with the same key will be written. - `quote_style` controls how strings are encoded. See the documentation for the `QuoteStyle` class, above, for how this is used. *Note*: Strings that are being used as unquoted keys are not affected by this parameter and remain unquoted. *`quote_style` was added in version 0.10.0*. Other keyword arguments are allowed and will be passed to the encoder so custom encoders can get them, but otherwise they will be ignored in an attempt to provide some amount of forward-compatibility. *Note:* the standard JSON module explicitly calls `int.__repr(obj)__` and `float.__repr(obj)__` to encode ints and floats, thereby bypassing any custom representations you might have for objects that are subclasses of ints and floats, and, for compatibility, JSON5 does the same thing. To override this behavior, create a subclass of JSON5Encoder that overrides `encode()` and handles your custom representation. For example: ``` >>> import json5 >>> from typing import Any, Set >>> >>> class Hex(int): ... def __repr__(self): ... return hex(self) >>> >>> class CustomEncoder(json5.JSON5Encoder): ... def encode( ... self, obj: Any, seen: Set, level: int, *, as_key: bool ... ) -> str: ... if isinstance(obj, Hex): ... return repr(obj) ... return super().encode(obj, seen, level, as_key=as_key) ... >>> json5.dumps([20, Hex(20)], cls=CustomEncoder) '[20, 0x14]' ``` *Note:* calling ``dumps(obj, quote_keys=True, trailing_commas=False, allow_duplicate_keys=True)`` should produce exactly the same output as ``json.dumps(obj).`` rrrsrtrurvrwrxryrzr{r)r|rF)seenlevelas_keyr)r~encoderQ)r}rrrsrtrur"rvrwrxryrzr{r)r|rencs rrrsxx  C # !%'1     C ::cQu: = ==rceZdZdddddddddddejd dedededed eeee fd ee e e fd ee e ge fd ed edededefdZ de de fdZde dededede f dZde dedee fdZdedede fdZdedede fdZde dede fdZde dede fdZde de fdZdedede fd Zde dedede fd!Zde dedede fd"Zdede e e ffd#Zd$e defd%Zde defd&Zde defd'Zd$e defd(Z dS))r~FTNrrrrsrtrurvrwrxryrzr{r)r|c  ~ ||_||_||_||_||_||_||dnd}|\|_|_|pt|_ ||_ | |_ | |_ | |_ | |_dS)zProvides a class that may be overridden to customize the behavior of `dumps()`. The keyword args are the same as for that function. *Added in version 0.10.0N)z, : ),r)rrrsrtrurvrwitem_separator kv_separator_raise_type_error default_fnryrzr{r)r|)selfrrrsrtrurvrwrxryrzr{r)r|rs r__init__zJSON5Encoder.__init__&s,   (," $  )/[J1;.T.!6%6"$.$8!&rr}r-c,||S)aWProvides a last-ditch option to encode a value that the encoder doesn't otherwise recognize, by converting `obj` to a value that *can* (and will) be serialized by the other methods in the class. Note: this must not return a serialized value (i.e., string) directly, as that'll result in a doubly-encoded value.)r)rr}s rrxzJSON5Encoder.defaultNss###rrrrc|p t}|||}||S|rtd|||||S)aReturns an JSON5-encoded version of an arbitrary object. This can be used to provide customized serialization of objects. Overridden methods of this class should handle their custom objects and then fall back to super.encode() if they've been passed a normal object. `seen` is used for duplicate object tracking when `check_circular` is True. `level` represents the current indentation level, which increases by one for each recursive invocation of encode (i.e., whenever we're encoding the values of a dict or a list). May raise `TypeError` if the object is the wrong type to be encoded (i.e., your custom routine can't handle it either), and `ValueError` if there's something wrong with the value, e.g. a float value of NaN when `allow_nan` is false. If `as_key` is true, the return value should be a double-quoted string representation of the object, unless obj is a string that can be an identifier (and quote_keys is false and obj isn't a reserved word). If the object should not be used as a key, `TypeError` should be raised; that allows the base implementation to implement `skipkeys` properly. rNz Invalid key f)rQ_encode_basic_type TypeError_encode_non_basic_type)rr}rrrr2s rrzJSON5Encoder.encodeWsk@}suu  # #C # 7 7 =H  31C1122 2**3e<<rB _encode_strrX _encode_intrM _encode_floatrr}rs rrzJSON5Encoder._encode_basic_types c3   8##C#77 7 $;;%1886 1 %<< &399G 3 ;%1886 1 c3   8##C#77 7 c5 ! ! :%%c&%99 9trcJt|}|rd|dn|S)N")rX__repr__)rr}rr2s rrzJSON5Encoder._encode_ints* LL  !(x1xxxxq(rc |tdkr |j}d}nW|tdkr |j}d}n:tj|r |j}d}nd}t|}|st d|rd|dn|S) NrJrIz-infz -InfinityrKTzIllegal JSON5 value: f{obj}r)rMrumathisnanrr1)rr}rallowedr2s rrzJSON5Encoder._encode_floats %,,  nGAA E&MM ! !nGAA Z__ $nGAAGs##A <:;; ;!(x1xxxxq(rc|r3||r|js||s|S|||jS)N) is_identifierrzis_reserved_word_encode_quoted_strr|rs rrzJSON5Encoder._encode_strsd  ""3'' O ))#..   J&&sD,<===rcg}d}d}d}d}|D]}||kr8|dz }|tjtjfvr||} n|} n||kr8|dz }|tjtjfvr||} nv|} ns|dkr||} nWt |} | dkr||} n,| dkr|} n#|js|dvr|} n||} ||  ||kr0|tjkr | |tjS||kr0|tjkr | |tjS|tjtjfvrdd |zdzSdd |zdzS) z@Returns a quoted string with a minimal number of escaped quotes.r'r\ )u
u
) rrr _escape_chrrordrsrnrjoin) rr}r|retdouble_quotes_seensingle_quotes_seensqdqch encoded_chos rrzJSON5Encoder._encode_quoted_strs  ! #! #BRxx#a'",,#"&!4!4JJ!#JJr"a'",,#"&!4!4JJ!#JJt!__R00 GGr66!%!4!4JJWW!#JJ*5r9M/M/M!#JJ!%!4!4J JJz " " " " !3 3 3z777**3 0HII I !3 3 3z777**3 0HII I :3Z5MN N N%+ +RWWS\\!C''rrc|dkrdS|dkrdS|dkrdS|dkrdS|d krd S|d krd S|d krdS|dkrdS|dkrdS|dkrdSt|}|dkrd|dS|dz }d|dz z}d|dzz}d|dd|dS)z9Returns the backslash-escaped representation of the char.rz\\rz\'rz\" z\n z\r z\tz\b z\f z\vz\0iz\u04xi ii)r)rrrr3highlows rrzJSON5Encoder._escape_chs ::6 995 995 ::5 ::5 ::5 ::5 ::5 ::5 ::5 GG u99 === 'k#e $*T*******rc |jr7t|}||vrtd||t |dr+t |dr||||dz}nnt |dr+t |dr||||dz}n3|||||dzd}|J|jr| ||S)NzCircular reference detected.rU __getitem__r__iter__Fr) rtidr1rRhasattr _encode_dict _encode_arrayrrxremove)rr}rrir2s rrz#JSON5Encoder._encode_non_basic_types   3ADyy !?@@@ HHQKKK 3   !GC$?$? !!!#tUQY77AA S- ( ( !WS*-E-E !""3eai88AA DLL--tUQYu MMA===    KKNNNrcj|sdS||\}}|j|z}|j}|jr"t |}n|}d|z} d} t } |D]} || ||d} n#t$r |j rY0wxYw|j s8| | vrtdt| | | | rd} n| |z } ||| ||d}| | |z|zz } | |dzz } | S)Nz{}{Trzduplicate key F})_spacersrrrysortedrUrQrrrrr)r1reprrR)rr}rr indent_strend_stritem_sepkv_seprUr2 first_keynew_keysrVkey_strval_strs rrzJSON5Encoder._encode_dict-s 4"mmE22 G&3" > #((**%%DD88::D *  55 , ,C ++c4t+DD   =H  , &h&&$%Ad3ii%A%ABBB W%%% ! X kk#c(D%kFFG 6!G+ +AA Ws]sBB42B4c|sdS\}}j|z}d|z|fd|Dz|zdzS)Nz[][c3JK|]}|dVdS)FrN)r)rjrkrrrs r z-JSON5Encoder._encode_array.._sH?A BeE ::r])rrr)rr}rrrrrs` `` rrzJSON5Encoder._encode_arrayVs 4"mmE22 G&3  mmEH        rc |jd}|jrd}t|jtr:|jdkr'dd|jz|zz}|dd|jz|dz zzz }n-d}|dz }n%d|j|zz}|d|j|dz zzz }nd}d}||fS)Nrrrr r)rvr{r>rX)rrrrs rrzJSON5Encoder._spacersfs ; "G# $+s++ <;??!%dk(9E(A!AJtcDK&7519&EEEGG!%JtOGG!DK%$77 4$+";;;JG7""rrVc|r%||ds |ddvrdS|ddD]}||s|dvrdSdS)aJReturns whether the string could be used as a legal EcmaScript/JavaScript identifier. There should normally be no reason to override this, unless the definition of identifiers change in later versions of the JSON5 spec and this implementation hasn't been updated to handle the changes yet.r)$r5FrNT) _is_id_start_is_id_continue)rrVrs rrzJSON5Encoder.is_identifierzs $$SV,, Aj((5abb'  B''++ *0D0Duutrc.tj|dvS)N)LuLlLiLtLmLoNl unicodedatacategoryrrs rrzJSON5Encoder._is_id_starts#B'',   rc.tj|dvS)N) rrrrrrrNdMnMcPcrrs rrzJSON5Encoder._is_id_continues#B'' ,  rct/tjddgdzdzat|duS)aReturns whether the key is a reserved word. There should normally be no need to override this, unless there have been reserved words added in later versions of the JSON5 spec and this implementation has not yet been updated to handle the changes yet.N(|)-breakcasecatchclassconstcontinuedebuggerrxdeletedoelseenumexportextendsrfinallyforfunctionif implementsimportin instanceof interfaceletnewrpackageprivate protectedpublicr-staticsuperswitchthisthrowrtrytypeofvarvoidwhilewithyieldz)$)rrecompilermatch)rrVs rrzJSON5Encoder.is_reserved_wordsn  $ !# ((...001de24!4! j!&&s++477r)!rrrrrboolrr rXrBr rrrrxr rrrrMrrrrrrQrrrrrrrrrrr~r~%s!#,00426 $%)",":&'&'&'&' &'  &'  &'sCx)&'U38_-&'(C5#:./&'&'&'&'#&' &'&'&'&'P$3$3$$$$'= '='= '=  '= '='='='=Rcdx}0)s)t)))))))4)C))))$ >s >t > > > > >8(c8( 8(s8(8(8(8(t+S+S++++@CC4''3's's''''R  C      #c#eCHo####(&  s  t       #  $     B8CB8DB8B8B8B8B8B8rc@tt|d)Nz is not JSON5 serializable)rr)r}s rrrs tCyy<<< = ==r)#r rr*typingrrrrrrr r r r r json5.parserr rPattern__annotations__EnumrrBr-rXr6r8r0rArYrrrr~rrrrr4s                         +/8BJ'...$$$$$$$$J#@D260459 !%!GGG GsmG G (GCH$5#6#;<= G (C5#:./ G#,-GXseSj12G G (5c?+,c12GGG C=G  !GGGGZ#@D260459 !%!;;; ;sm; ; (GCH$5#6#;<= ; (C5#:./ ;#,-;XseSj12; ; (5c?+,c12;;; C=;;;;B#@D260459 !%!g!g!g! g!smg! g! (GCH$5#6#;<= g! (C5#:./ g!#,-g!XseSj12g! g! (5c?+,c12g!g!g! C=g!g!g!g!TLLLB%* xc3h0136 7%*%*%*%*X*.(,,0.2 !%(6!/// / / /  /  // $~& '/ U38_ %/sCx)/hucz* +///// !////j*.(,,0.2 !%(6l>l>l> l>l> l>  l>  l> $~& 'l> U38_ %l>sCx)l>hucz* +l>l>l>l>l>l>l>l>l>^D8D8D8D8D8D8D8D8N>c>>>>>>r