h%SSKrSSKrSSKrSSKJrJrJrJrJrJ r J r J r J r J r SSKrSSKJr Sq\ \R$\S'"SS\R(5rSSSSSSSSSSSS. S \S \ \S \S \ \\\\4/\4S \ \\/\4S\ \\/\4S\ \\/\4S\S\ \\\ \\4/\4S\S\S\ \S\4SjjrSSSSSSSSSSSS. S\S \ \S \S \ \\\\4/\4S \ \\/\4S\ \\/\4S\ \\/\4S\S\ \\\ \\4/\4S\S\S\ \4SjjrSSSSSSSSSSSS. S\S \ \S \S \ \\\\4/\4S \ \\/\4S\ \\/\4S\ \\/\4S\S\ \\\ \\4/\4S\S\S\ \4SjjrSrS\\\ \\4/\44SjrSSSSSSSSSSSS\R<S. S\S \S \S!\S"\S#\S \ \ S$S%\ \ \\4S&\ \ \\4S'\ \\/\4S(\S)\S*\S\S+\4S,jjrSSSSSSSSSSSS\R<S. S\S \S!\S"\S#\S \ \ S$S%\ \ \\4S&\ \ \\4S'\ \\/\4S(\S)\S*\S\S+\4S-jjr "S.S$5r!S\4S/jr"g)0N) AnyCallableIOIterableMappingOptionalSetTupleTypeUnion)Parser_reserved_word_rec(\rSrSrSrSrSrSrSrSr g) QuoteStyle'a*Controls 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____firstlineno____doc__ ALWAYS_DOUBLE ALWAYS_SINGLE PREFER_DOUBLE PREFER_SINGLE__static_attributes__r\C:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\json5/lib.pyrr's6$M#M#M#Mr!rT encodingcls object_hook parse_float parse_intparse_constantstrictobject_pairs_hookallow_duplicate_keysconsume_trailingstartfpr$r%r&r'r(r)r*r+r,r-r.returnc xUR5n [U UUUUUUUUU U U S9 upnU(a [U5eU $)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 r"loadr9IsVl  A  %+1) KCa o Jr!r5c X[UUUUUUUUUU U U S9 upnU (a [U 5eU $)aDeserialize ``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. ) r5r$r%r&r'r(r)r*r+r,r-r.)r3r4)r5r$r%r&r'r(r)r*r+r,r-r.r6r7r8s r"loadsr;sKV  %+1) KCa o Jr!c zUbS5e[U[5(aU=(d SnURU5nU(d [S5eU =(d Sn [ USU S9n U R XzS.S 9upnU(aSX4$[ U UUUUUU S 9nUSU4$![anS[U5U4sSnA$SnAff=f) 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,) isinstancebytesdecoder4r r3_convertstr)r5r$r%r&r'r(r)r*r+r,r-r.parserastr7r=valuees r"r3r3sV ;;;;;!U&w HHX  <== JQE Azu -FLL &N!MCc S~ ! ##)/!5 dC !SVS  !sB B:" B5/B:5B:c^^^SnUUU4SjnU=(d [nU=(d [nU=(d Un[XX#U5$)NcX[URSS5RSS55$)NInfinityinfNaNnan)floatreplace)r5s r"_fp_constant_parser%_convert.._fp_constant_parserDs%QYYz5199%GHHr!c>T(d:[5nUH*up#X!;a[SUS35eURU5 M, T(aT"U5$T(aT"[U55$[U5$)NzDuplicate key "z" found in object)setr4adddict)pairskeyskeyr8r,r&r+s r"_dictify_convert.._dictifyGsj#5D;$se;L%MNN  $U+ + tE{+ +E{r!)rPint _walk_ast) rGr&r'r(r)r+r,rRr[s ` `` r"rDrD;s>I &K SI#:':N SKN KKr!dictifyc US:XagUS:XagUS:XagUupVUS:XaiURS5(dURS5(aU"US S 9$S U;d S U;dS U;aU"U5$SU;dSU;aU"U5$U"U5$US:XaU$US:Xa4/nUH$up[XX#U5n URX45 M& U"U5$US:XaUVs/sHn[XX#U5PM sn$[SU-5es snf)NNoneTrueTFalseFnumber0x0X)base.rIErLrNstringobjectarrayz unknown el: ) startswithr^appendr4) elr_r'r(r)tyvrXrZval_exprr6s r"r^r^\s3 V| V| W} EB X~ <<  d!3!3QR( ( !8sax3!8q> ! ?eqj!!$ $| X~ X~MC;>C LL# $  u~ W}  b;> J   ^b( ))  sC=F) skipkeys ensure_asciicheck_circular allow_nanr%indent separatorsdefault sort_keys quote_keystrailing_commasr, quote_styleobjrtrurvrw JSON5Encoderrxryrzr{r|r}r~c  VUR[SUUUUUUUUU U U U U US.UD65 g)aLSerialize ``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).`` )rrtrurvrwr%rxryrzr{r|r}r,r~Nr)writedumps)rr/rtrurvrwr%rxryrzr{r|r}r,r~kws r"dumprsQ:HH  %)!!+!5#  r!c  ~U=(d [nU"SUUUUUUUU U U U U S. UD6nURU[5SSS9$)aJ 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).`` rtrurvrwrxryrzr{r|r}r,r~rF)seenlevelas_keyr)rencoderU)rrtrurvrwr%rxryrzr{r|r}r,r~rencs r"rrsgx  C  !%'1   C ::cQu: ==r!c\rSrSrSSSSSSSSSSS\R S. S\S\S\S \S \\\ \ 4S \\ \ \ 4S \\ \ /\ 4S \S\S\S\S\4SjjrS\ S\ 4SjrS\ S\S\ S\S\ 4 SjrS\ S\S\\ 4SjrS\ S\S\ 4SjrS\S\S\ 4SjrS\ S\S\ 4SjrS\ S\S\ 4SjrS\ S\ 4S jrS\S\ S\ 4S!jrS\ S\S\ S\ 4S"jrS\ S\S\ S\ 4S#jrS\ S\ \ \ 44S$jrS%\ S\4S&jrS\ S\4S'jrS\ S\4S(jr S%\ S\4S)jr!S*r"g)+ri%FTNrrtrurvrwrxryrzr{r|r}r,r~c  A XlX lX0lX@lXPlX`lUcUcSOSnUuUlUlU=(d [Ul Xl Xl Xl Xl Xlg)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)rtrurvrwrxryitem_separator kv_separator_raise_type_error default_fnr{r|r}r,r~)selfrtrurvrwrxryrzr{r|r}r,r~rs r"__init__JSON5Encoder.__init__&sq,  (," $  )/[J1;.T.!6%6"$.$8!&r!rr0c$URU5$)a7Provides 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)rrs r"rzJSON5Encoder.defaultNss##r!rrrcU=(d [5nURXS9nUbU$U(a[SU35eURXU5$)aSReturns 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. rz Invalid key f)rU_encode_basic_type TypeError_encode_non_basic_type)rrrrrr5s r"rJSON5Encoder.encodeWsU@}su  # #C # 7 =H mC512 2**3e<U[S5:XaURnSnO_U[S5:XaURnSnOA[R"U5(aURnSnOSn[R U5nU(d [ S5eU(aSUS3$U$) NrMrLz-infz -InfinityrNTzIllegal JSON5 value: f{obj}r)rPrwmathisnanrr4)rrrallowedr5s r"rJSON5Encoder._encode_floats %, nnGA E&M !nnGA ZZ__nnGAGs#A:; ;!1#Qx(q(r!cU(a?URU5(a)UR(dURU5(dU$URXR5$)N) is_identifierr|is_reserved_word_encode_quoted_strr~rs r"rJSON5Encoder._encode_strsJ ""3''OO))#..J&&s,<,<==r!c/nSnSnSnSnUGH nX:Xa>US- nU[R[R4;aURU5n OUn OX:Xa>US- nU[R[R 4;aURU5n OrUn OoUS:XaURU5n OW[ U5n U S:aURU5n O4U S:aUn O+UR(d US;aUn OURU5n URU 5 GM XE:a4U[R:Xa URU[R5$XT:a4U[R :Xa URU[R5$U[R[R4;aSS RU5-S-$SS RU5-S-$) z@Returns a quoted string with a minimal number of escaped quotes.r'r\ )u
u
) rrr _escape_chrrordrurorjoin) rrr~retdouble_quotes_seensingle_quotes_seensqdqch encoded_chos r"rJSON5Encoder._encode_quoted_strs  Bx#a'",,,,#"&!4J!#J"a'",,,,#"&!4J!#Jt!__R0 Gr6!%!4JW!#J**r9M/M!#J!%!4J JJz "CJ  3z777**3 0H0HI I  3z777**3 0H0HI I :33Z5M5MN N%+ +RWWS\!C''r!rcUS:XagUS:XagUS:XagUS:XagUS :Xag US :Xag US :XagUS:XagUS:XagUS:Xag[U5nUS:aSUS3$US- nSUS- -nSUS--nSUSSUS3$)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)rrrr6highlows r"rJSON5Encoder._escape_chs : 9 9 : : : : : : : G u93= 'k#e $T#JbS **r!cUR(a,[U5nXB;a [S5eURU5 [ US5(a'[ US5(aUR XUS-5nO`[ US5(a'[ US5(aUR XUS-5nO(URURU5X#S-SS9nUceUR(aURW5 U$)NzCircular reference detected.rY __getitem__r__iter__Fr) rvidr4rVhasattr _encode_dict _encode_arrayrrzremove)rrrrir5s r"r#JSON5Encoder._encode_non_basic_types   3Ay !?@@ HHQK 3  GC$?$?!!#UQY7A S- ( (WS*-E-E""3eai8A DLL-tQYu MA= =    KKNr!cfU(dgURU5upEURU-nURnUR(a[ UR 55nOUR 5nSU-n Sn [ 5n UH~n URXUSS9n UR(d-X;a[S[U 535eU RU 5 U (aSn OX- n URXX#SS9nXU-U-- n M XS-- n U $![a UR(aMef=f)Nz{}{Trzduplicate key F})_spacersrrr{sortedrYrUrrrtr,r4reprrV)rrrr indent_strend_stritem_sepkv_seprYr5 first_keynew_keysrZkey_strval_strs r"rJSON5Encoder._encode_dict-s*"mmE2 &&3"" >>#((*%D88:D *  5C ++ct+D ,,&$~d3i[%ABB W%!  kk#(DkFG 6!G+ +A'* s]' == s DD0.D0c^^^U(dgTRT5upETRU-nSU-URUUU4SjU55-U-S-$)Nz[][c3H># UHnTRUTTSS9v M g7f)FrN)r).0rprrrs r" -JSON5Encoder._encode_array.._s%EHr BeE :Ss"])rrr)rrrrrrrs` `` r"rJSON5Encoder._encode_arrayVsl"mmE2 &&3  mmEH        r!cURbSnUR(aSn[UR[5(aLURS:a1SSUR-U--nUSSUR-US- --- nO5SnUS- nX24$SURU--nUSURUS- --- nX24$SnSnX24$)Nrrrr r)rxr}rAr])rrrrs r"rJSON5Encoder._spacersfs ;; "G##$++s++;;?!%dkk(9E(A!AJtcDKK&7519&EEEG!%JtOG"" "DKK%$77 4$++";;;""JG""r!rZcU(a"URUS5(d USS;agUSSH#nURU5(aMUS;dM# g g)a"Returns 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)$r8FrNT) _is_id_start_is_id_continue)rrZrs r"rJSON5Encoder.is_identifierzs[$$SV,,Aj(ab'B''++*0Dr!c4[R"U5S;$)N)LuLlLiLtLmLoNl unicodedatacategoryrrs r"rJSON5Encoder._is_id_starts##B',   r!c4[R"U5S;$)N) rrrrrrrNdMnMcPcrr s r"rJSON5Encoder._is_id_continues##B' ,  r!c[c-[R"SSR/SQ5-S-5q[R U5SL$)zReturns 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(|)-breakcasecatchclassconstcontinuedebuggerrzdeletedoelseenumexportextendsrfinallyforfunctionif implementsimportin instanceof interfaceletnewrpackageprivate protectedpublicr0staticsuperswitchthisthrowrtrytypeofvarvoidwhilewithyieldz)$)rrecompilermatch)rrZs r"rJSON5Encoder.is_reserved_wordsY  $ !# ((.01de24! j!&&s+477r!)r,rwrvrrurxrrr|r~ryrtr{r})#rrrrrrboolrr r]rEr rrrrzr rrrrPrrrrrrUrrrrrrrr rr!r"rr%s!#,00426 $%)",":":&'&' &'  &'  &'sCx)&'U38_-&'(C5#:./&'&'&'&'#&' &'P$3$3$'= '='= '=  '= '=Rcdx}0)s)t))))4)C)$ >s >t > >8(c8( 8(s8(t+S+S+@CC4''3's's'R  C   #c#eCHo#(&  s  t    #  $  B8CB8DB8r!c0[[U5S35e)Nz is not JSON5 serializable)rr)rs r"rrs tCyk!;< ==r!)#r rr>typingrrrrrrr r r r r  json5.parserr rPattern__annotations__EnumrrErBr]r9r;r3rDr^rrrrrrr!r"rIs    +/8BJJ'.$$J#@D260459 !%!G GsmG G (GCH$5#6#;<= G (C5#:./ G#,-GXseSj12G G (5c?+,c12GGG C=G  !GZ#@D260459 !%!; ;sm; ; (GCH$5#6#;<= ; (C5#:./ ;#,-;XseSj12; ; (5c?+,c12;;; C=;B#@D260459 !%!g! g!smg! g! (GCH$5#6#;<= g! (C5#:./ g!#,-g!XseSj12g! g! (5c?+,c12g!g!g! C=g!TLB%* xc3h0136 7%*X*.(,,0.2 !%(66!/ / / /  /  // $~& '/ U38_ %/sCx)/hucz* +///// !/j*.(,,0.2 !%(66l> l>l> l>  l>  l> $~& 'l> U38_ %l>sCx)l>hucz* +l>l>l>l>l>l>^D8D8N>c>r!