�
� f�6�
���dZdZgd�ZdZddlmZmZddlmZddl Z ed d
d
d
ddd� ��Z
d d
d
d
ddddd d � d
�Z d d
d
d
ddddd d � d�Z edd���Z
d�Zddddddd�d�Zddddddd�d�ZdS)a JSON (JavaScript Object Notation) <https://json.org> is a subset of
JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
interchange format.
:mod:`json` exposes an API familiar to users of the standard library
:mod:`marshal` and :mod:`pickle` modules. It is derived from a
version of the externally maintained simplejson library.
Encoding basic Python object hierarchies::
>>> import json
>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
'["foo", {"bar": ["baz", null, 1.0, 2]}]'
>>> print(json.dumps("\"foo\bar"))
"\"foo\bar"
>>> print(json.dumps('\u1234'))
"\u1234"
>>> print(json.dumps('\\'))
"\\"
>>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))
{"a": 0, "b": 0, "c": 0}
>>> from io import StringIO
>>> io = StringIO()
>>> json.dump(['streaming API'], io)
>>> io.getvalue()
'["streaming API"]'
Compact encoding::
>>> import json
>>> mydict = {'4': 5, '6': 7}
>>> json.dumps([1,2,3,mydict], separators=(',', ':'))
'[1,2,3,{"4":5,"6":7}]'
Pretty printing::
>>> import json
>>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4))
{
"4": 5,
"6": 7
}
Decoding JSON::
>>> import json
>>> obj = ['foo', {'bar': ['baz', None, 1.0, 2]}]
>>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj
True
>>> json.loads('"\\"foo\\bar"') == '"foo\x08ar'
True
>>> from io import StringIO
>>> io = StringIO('["streaming API"]')
>>> json.load(io)[0] == 'streaming API'
True
Specializing JSON object decoding::
>>> import json
>>> def as_complex(dct):
... if '__complex__' in dct:
... return complex(dct['real'], dct['imag'])
... return dct
...
>>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
... object_hook=as_complex)
(1+2j)
>>> from decimal import Decimal
>>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')
True
Specializing JSON object encoding::
>>> import json
>>> def encode_complex(obj):
... if isinstance(obj, complex):
... return [obj.real, obj.imag]
... raise TypeError(f'Object of type {obj.__class__.__name__} '
... f'is not JSON serializable')
...
>>> json.dumps(2 + 1j, default=encode_complex)
'[2.0, 1.0]'
>>> json.JSONEncoder(default=encode_complex).encode(2 + 1j)
'[2.0, 1.0]'
>>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j))
'[2.0, 1.0]'
Using json.tool from the shell to validate and pretty-print::
$ echo '{"json":"obj"}' | python -m json.tool
{
"json": "obj"
}
$ echo '{ 1.2:3.4}' | python -m json.tool
Expecting property name enclosed in double quotes: line 1 column 3 (char 2)
z2.0.9)�dump�dumps�load�loads� JSONDecoder�JSONDecodeError� JSONEncoderz Bob Ippolito <bob@redivi.com>�)rr)r�NFT)�skipkeys� ensure_ascii�check_circular� allow_nan�indent�
separators�default) r r r
r�clsrrr� sort_keysc ���|s-|r+|r)|r'|�%|�#|�!| � |
s | st�|��} n-|�t}|d||||||| |
d�| ���|��} | D]}
|�|
���dS)a�Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
``.write()``-supporting file-like object).
If ``skipkeys`` is true then ``dict`` keys that are not basic types
(``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
instead of raising a ``TypeError``.
If ``ensure_ascii`` is false, then the strings written to ``fp`` can
contain non-ASCII characters if they appear in strings contained in
``obj``. Otherwise, all such characters are escaped in JSON strings.
If ``check_circular`` is false, then the circular reference check
for container types will be skipped and a circular reference will
result in an ``RecursionError`` (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
rrrrr�)�_default_encoder�
iterencoder�write)�obj�fpr r r
rrrrrr�kw�iterable�chunks �4/opt/alt/python311/lib64/python3.11/json/__init__.pyrrxs���Z
� H� � H�� H�$� H� � ���:�+=��� ��"��#�.�.�s�3�3��� �;� �C��3�8��|�)�Y�v�!��y�8�8�57�8�8�9C�
�3��� � ����
����������c ��|s,|r*|r(|r&|�$|�"|� |� | s |
st�|��S|�t}|d|||||||| d�|
���|��S)avSerialize ``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 ``RecursionError`` (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.
Nrr)r�encoder) rr r r
rrrrrrr s r rr�s���X
�,� �,��,�$�,� � ���:�+=��� ��"�� �&�&�s�+�+�+�
�{��� �3� �� �%��6� �w�)� � �
� � ��f�S�k�k� r )� object_hook�object_pairs_hookc��|j}|tjtjf��rdS|tjtjf��rdS|tj��rdSt|��dkr1|ds |drdndS|ds|d s|d
rd nd Sn't|��d kr|dsdS|dsd Sd
S)Nzutf-32zutf-16z utf-8-sig�r
r z utf-16-bez utf-32-be��z utf-16-lez utf-32-lezutf-8)�
startswith�codecs� BOM_UTF32_BE� BOM_UTF32_LE� BOM_UTF16_BE� BOM_UTF16_LE�BOM_UTF8�len)�b� bstartswiths r �detect_encodingr3�s����,�K��{�F�'��)<�=�>�>���x��{�F�'��)<�=�>�>���x��{�6�?�#�#���{�
�1�v�v��{�{���t� 8�#$�A�$�7�;�;�K� 7���t� @�#$�A�$�?�!�A�$�?�;�;�K� ?� @�
�Q���1�����t� � �;���t� � �;� �7r �rr#� parse_float� parse_int�parse_constantr$c
�N�t|���f||||||d�|��S)a�Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
a JSON document) to a Python object.
``object_hook`` is an optional function that will be called with the
result of any object literal decode (a ``dict``). The return value of
``object_hook`` will be used instead of the ``dict``. This feature
can be used to implement custom decoders (e.g. JSON-RPC class hinting).
``object_pairs_hook`` is an optional function that will be called with the
result of any object literal decoded with an ordered list of pairs. The
return value of ``object_pairs_hook`` will be used instead of the ``dict``.
This feature can be used to implement custom decoders. If ``object_hook``
is also defined, the ``object_pairs_hook`` takes priority.
To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
kwarg; otherwise ``JSONDecoder`` is used.
r4)r�read)rrr#r5r6r7r$r s r rrsL��& ������ R� �[� �9�%�9J� R� R�OQ� R� R�Rr c ��t|t��r'|�d��rtd|d���n[t|tt
f��s t
d|jj�����|� t|��d��}|�&|�$|�"|� |� |� |st� |��S|�t}|�||d<|�||d<|�||d <|�||d
<|�||d <|d i|��� |��S)
aRDeserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance
containing a JSON document) to a Python object.
``object_hook`` is an optional function that will be called with the
result of any object literal decode (a ``dict``). The return value of
``object_hook`` will be used instead of the ``dict``. This feature
can be used to implement custom decoders (e.g. JSON-RPC class hinting).
``object_pairs_hook`` is an optional function that will be called with the
result of any object literal decoded with an ordered list of pairs. The
return value of ``object_pairs_hook`` will be used instead of the ``dict``.
This feature can be used to implement custom decoders. If ``object_hook``
is also defined, the ``object_pairs_hook`` takes priority.
``parse_float``, if specified, will be called with the string
of every JSON float to be decoded. By default this is equivalent to
float(num_str). This can be used to use another datatype or parser
for JSON floats (e.g. decimal.Decimal).
``parse_int``, if specified, will be called with the string
of every JSON int to be decoded. By default this is equivalent to
int(num_str). This can be used to use another datatype or parser
for JSON integers (e.g. float).
``parse_constant``, if specified, will be called with one of the
following strings: -Infinity, Infinity, NaN.
This can be used to raise an exception if invalid JSON numbers
are encountered.
To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
kwarg; otherwise ``JSONDecoder`` is used.
uz-Unexpected UTF-8 BOM (decode using utf-8-sig)r
z5the JSON object must be str, bytes or bytearray, not �
surrogatepassNr#r$r5r6r7r)
�
isinstance�strr)r�bytes� bytearray� TypeError� __class__�__name__�decoder3�_default_decoderr)�srr#r5r6r7r$r s r rr+s\��D�!�S���:� �<�<�� !� !� (�!�"Q�"#�Q�(�(�
(� (��!�e�Y� /�0�0� ;�� :�#$�;�#7� :� :�;�;�
;�
�H�H�_�Q�'�'� � 9� 9�� � � �+� � �+�"5� � "�'8�'@��'@� �&�&�q�)�)�)�
�{���� � '��=���$�"3�� � �� � '��=��� �#��;���!� -�� � � �3�9�9��9�9� � �A� � � r )�__doc__� __version__�__all__�
__author__�decoderrr�encoderrr*rrrrDr3rrrr r �<module>rLsy��`�`�B� � � � ��
-�
�1�1�1�1�1�1�1�1� � � � � � �
�
�
�
� �;�
���� �� ����� $�$�t��D��$���<�<�<�<�<�~ !�t�D��D��$���7�7�7�7�7�t �;�4�4�H�H�H�����<�d���t�t�R�R�R�R�R�2�d���t�t�< �< �< �< �< �< �< r |