Your IP : 216.73.216.86


Current Path : /home/emeraadmin/public_html/4d695/
Upload File :
Current File : /home/emeraadmin/public_html/4d695/json.tar

stringify.js000064400000000135151701443470007125 0ustar00'use strict';
var parent = require('../../stable/json/stringify');

module.exports = parent;
index.js000064400000000537151701443470006224 0ustar00'use strict';
var parent = require('../../stable/json');
require('../../modules/es.object.create');
require('../../modules/es.object.freeze');
require('../../modules/es.object.keys');
require('../../modules/esnext.json.is-raw-json');
require('../../modules/esnext.json.parse');
require('../../modules/esnext.json.raw-json');

module.exports = parent;
to-string-tag.js000064400000000141151701443470007603 0ustar00'use strict';
var parent = require('../../stable/json/to-string-tag');

module.exports = parent;
raw-json.js000064400000000344151701456230006647 0ustar00'use strict';
require('../../modules/es.object.create');
require('../../modules/es.object.freeze');
require('../../modules/esnext.json.raw-json');
var path = require('../../internals/path');

module.exports = path.JSON.rawJSON;
parse.js000064400000000262151701456230006220 0ustar00'use strict';
require('../../modules/es.object.keys');
require('../../modules/esnext.json.parse');
var path = require('../../internals/path');

module.exports = path.JSON.parse;
is-raw-json.js000064400000000223151701456230007254 0ustar00'use strict';
require('../../modules/esnext.json.is-raw-json');
var path = require('../../internals/path');

module.exports = path.JSON.isRawJSON;
__pycache__/__init__.cpython-312.opt-1.pyc000064400000032461151704111340014160 0ustar00�

T��h�6�
���dZdZgd�ZdZddlmZmZddlmZddl	Z	ed	d
d
d
ddd��Z
d	d
d
d
ddddd	d�	d
�Zd	d
d
d
ddddd	d�	d�Zedd��Z
d�Zddddddd�d�Zddddddd�d�Zy)aJSON (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�JSONEncoderzBob Ippolito <bob@redivi.com>�)rr)r�NFT)�skipkeys�ensure_ascii�check_circular�	allow_nan�indent�
separators�default)	rrr
r�clsrrr�	sort_keysc	���|s(|r&|r$|r"|� |�|�|	�|
s|stj|�}n(|�t}|d|||||||	|
d�|��j|�}|D]}
|j|
��y)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�rrr
rrrrr�)�_default_encoder�
iterencoder�write)�obj�fprrr
rrrrrr�kw�iterable�chunks              �&/usr/lib64/python3.12/json/__init__.pyrrxs���Z
���9�����:�+=���	�"�#�.�.�s�3���;��C��8��|�)�Y�v�!��y�8�57�8�9C�
�3��	���
������c	��|s'|r%|r#|r!|�|�|�|�|	s|
stj|�S|�t}|d||||||||	d�|
��j|�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.

    rr)r�encoder)rrrr
rrrrrrrs           rrr�s{��X
���9�����:�+=���	�"��&�&�s�+�+�
�{�������%��6��w�)��
�	��f�S�k�	r )�object_hook�object_pairs_hookc�z�|j}|tjtjf�ry|tjtj
f�ry|tj�ryt|�dk\r"|ds	|drdSdS|ds|d	s|d
rdSdSy
t|�d	k(r|dsy|dsyy
)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�'�'��)<�)<�=�>���F�'�'��)<�)<�=�>���6�?�?�#��
�1�v��{���t�#$�A�$�;�7�K�7���t�#$�A�$�!�A�$�;�?�K�?��

�Q��1����t����t��r �rr#�parse_float�	parse_int�parse_constantr$c
�D�t|j�f||||||d�|��S)a�Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
    a JSON document) to a Python object.

    ``object_hook`` is an optional function that will be called with the
    result of any object literal decode (a ``dict``). The return value of
    ``object_hook`` will be used instead of the ``dict``. This feature
    can be used to implement custom decoders (e.g. JSON-RPC class hinting).

    ``object_pairs_hook`` is an optional function that will be called with the
    result of any object literal decoded with an ordered list of pairs.  The
    return value of ``object_pairs_hook`` will be used instead of the ``dict``.
    This feature can be used to implement custom decoders.  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$rs        rrrs>��&�����R��[��9�%�9J�R�OQ�R�Rr c���t|t�r|jd�r`td|d��t|tt
f�s"t
d|jj����|jt|�d�}|�!|�|�|�|�|�|stj|�S|�t}|�||d<|�||d<|�||d<|�||d	<|�||d
<|di|��j|�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 �
surrogatepassr#r$r5r6r7r)
�
isinstance�strr)r�bytes�	bytearray�	TypeError�	__class__�__name__�decoder3�_default_decoderr)�srr#r5r6r7r$rs        rrr+s#��D�!�S���<�<��!�!�"Q�"#�Q�(�
(��!�e�Y�/�0��#�#$�;�;�#7�#7�"8�:�;�
;�
�H�H�_�Q�'��9�����+���+�"5��"�'8�'@���&�&�q�)�)�
�{�����'��=���$�"3������'��=����#��;���!�-�����9��9���A��r )�__doc__�__version__�__all__�
__author__�decoderrr�encoderrr*rrrrDr3rrrr r�<module>rLs���`�B����
-�
�1� �
��
���������$�$�t��D��$���<�~!�t�D��D��$���7�t�4�4�H���<�d���t�t�R�2�d���t�t�<r __pycache__/__init__.cpython-312.opt-2.pyc000064400000010365151704111340014160 0ustar00�

T��h�6�
���	dZgd�ZdZddlmZmZddlmZddlZedd	d	d	ddd�
�Z	dd	d	d	dddddd�	d�Z
dd	d	d	dddddd�	d
�Zedd��Zd�Z
ddddddd�d�Zddddddd�d�Zy)z2.0.9)�dump�dumps�load�loads�JSONDecoder�JSONDecodeError�JSONEncoderzBob Ippolito <bob@redivi.com>�)rr)r�NFT)�skipkeys�ensure_ascii�check_circular�	allow_nan�indent�
separators�default)	rrr
r�clsrrr�	sort_keysc	���	|s(|r&|r$|r"|� |�|�|	�|
s|stj|�}n(|�t}|d|||||||	|
d�|��j|�}|D]}
|j|
��y�N)rrr
rrrrr�)�_default_encoder�
iterencoder�write)�obj�fprrr
rrrrrr�kw�iterable�chunks              �&/usr/lib64/python3.12/json/__init__.pyrrxs���(�T
���9�����:�+=���	�"�#�.�.�s�3���;��C��8��|�)�Y�v�!��y�8�57�8�9C�
�3��	���
������c	��	|s'|r%|r#|r!|�|�|�|�|	s|
stj|�S|�t}|d||||||||	d�|
��j|�Sr)r�encoder)rrrr
rrrrrrrs           rrr�s���'�R
���9�����:�+=���	�"��&�&�s�+�+�
�{�������%��6��w�)��
�	��f�S�k�	r )�object_hook�object_pairs_hookc�z�|j}|tjtjf�ry|tjtj
f�ry|tj�ryt|�dk\r"|ds	|drdSdS|ds|d	s|d
rdSdSy
t|�d	k(r|dsy|dsyy
)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�'�'��)<�)<�=�>���F�'�'��)<�)<�=�>���6�?�?�#��
�1�v��{���t�#$�A�$�;�7�K�7���t�#$�A�$�!�A�$�;�?�K�?��

�Q��1����t����t��r �rr#�parse_float�	parse_int�parse_constantr$c
�F�	t|j�f||||||d�|��S)Nr4)r�read)rrr#r5r6r7r$rs        rrrsC���"�����R��[��9�%�9J�R�OQ�R�Rr c���	t|t�r|jd�r`td|d��t|tt
f�s"t
d|jj����|jt|�d�}|�!|�|�|�|�|�|stj|�S|�t}|�||d<|�||d<|�||d<|�||d	<|�||d
<|di|��j|�S)Nuz-Unexpected UTF-8 BOM (decode using utf-8-sig)r
z5the JSON object must be str, bytes or bytearray, not �
surrogatepassr#r$r5r6r7r)
�
isinstance�strr)r�bytes�	bytearray�	TypeError�	__class__�__name__�decoder3�_default_decoderr)�srr#r5r6r7r$rs        rrr+s(���@�!�S���<�<��!�!�"Q�"#�Q�(�
(��!�e�Y�/�0��#�#$�;�;�#7�#7�"8�:�;�
;�
�H�H�_�Q�'��9�����+���+�"5��"�'8�'@���&�&�q�)�)�
�{�����'��=���$�"3������'��=����#��;���!�-�����9��9���A��r )�__version__�__all__�
__author__�decoderrr�encoderrr*rrrrDr3rrrr r�<module>rKs���`�B����
-�
�1� �
��
���������$�$�t��D��$���<�~!�t�D��D��$���7�t�4�4�H���<�d���t�t�R�2�d���t�t�<r __pycache__/__init__.cpython-312.pyc000064400000032461151704111340013221 0ustar00�

T��h�6�
���dZdZgd�ZdZddlmZmZddlmZddl	Z	ed	d
d
d
ddd��Z
d	d
d
d
ddddd	d�	d
�Zd	d
d
d
ddddd	d�	d�Zedd��Z
d�Zddddddd�d�Zddddddd�d�Zy)aJSON (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�JSONEncoderzBob Ippolito <bob@redivi.com>�)rr)r�NFT)�skipkeys�ensure_ascii�check_circular�	allow_nan�indent�
separators�default)	rrr
r�clsrrr�	sort_keysc	���|s(|r&|r$|r"|� |�|�|	�|
s|stj|�}n(|�t}|d|||||||	|
d�|��j|�}|D]}
|j|
��y)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�rrr
rrrrr�)�_default_encoder�
iterencoder�write)�obj�fprrr
rrrrrr�kw�iterable�chunks              �&/usr/lib64/python3.12/json/__init__.pyrrxs���Z
���9�����:�+=���	�"�#�.�.�s�3���;��C��8��|�)�Y�v�!��y�8�57�8�9C�
�3��	���
������c	��|s'|r%|r#|r!|�|�|�|�|	s|
stj|�S|�t}|d||||||||	d�|
��j|�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.

    rr)r�encoder)rrrr
rrrrrrrs           rrr�s{��X
���9�����:�+=���	�"��&�&�s�+�+�
�{�������%��6��w�)��
�	��f�S�k�	r )�object_hook�object_pairs_hookc�z�|j}|tjtjf�ry|tjtj
f�ry|tj�ryt|�dk\r"|ds	|drdSdS|ds|d	s|d
rdSdSy
t|�d	k(r|dsy|dsyy
)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�'�'��)<�)<�=�>���F�'�'��)<�)<�=�>���6�?�?�#��
�1�v��{���t�#$�A�$�;�7�K�7���t�#$�A�$�!�A�$�;�?�K�?��

�Q��1����t����t��r �rr#�parse_float�	parse_int�parse_constantr$c
�D�t|j�f||||||d�|��S)a�Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
    a JSON document) to a Python object.

    ``object_hook`` is an optional function that will be called with the
    result of any object literal decode (a ``dict``). The return value of
    ``object_hook`` will be used instead of the ``dict``. This feature
    can be used to implement custom decoders (e.g. JSON-RPC class hinting).

    ``object_pairs_hook`` is an optional function that will be called with the
    result of any object literal decoded with an ordered list of pairs.  The
    return value of ``object_pairs_hook`` will be used instead of the ``dict``.
    This feature can be used to implement custom decoders.  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$rs        rrrs>��&�����R��[��9�%�9J�R�OQ�R�Rr c���t|t�r|jd�r`td|d��t|tt
f�s"t
d|jj����|jt|�d�}|�!|�|�|�|�|�|stj|�S|�t}|�||d<|�||d<|�||d<|�||d	<|�||d
<|di|��j|�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 �
surrogatepassr#r$r5r6r7r)
�
isinstance�strr)r�bytes�	bytearray�	TypeError�	__class__�__name__�decoder3�_default_decoderr)�srr#r5r6r7r$rs        rrr+s#��D�!�S���<�<��!�!�"Q�"#�Q�(�
(��!�e�Y�/�0��#�#$�;�;�#7�#7�"8�:�;�
;�
�H�H�_�Q�'��9�����+���+�"5��"�'8�'@���&�&�q�)�)�
�{�����'��=���$�"3������'��=����#��;���!�-�����9��9���A��r )�__doc__�__version__�__all__�
__author__�decoderrr�encoderrr*rrrrDr3rrrr r�<module>rLs���`�B����
-�
�1� �
��
���������$�$�t��D��$���<�~!�t�D��D��$���7�t�4�4�H���<�d���t�t�R�2�d���t�t�<r __pycache__/decoder.cpython-312.opt-1.pyc000064400000033133151704111340014023 0ustar00�

T��h�0�	��dZddlZddlmZ	ddlmZddgZejejzejzZe
d�Ze
d�Ze
d	�ZGd
�de�Zeeed�Zej(de�Zej(d
e�Zddddddddd�Zej0fd�Zdeej0fd�ZexseZej(de�ZdZdej0efd�Zej0efd�ZGd�de�Z y#e$rdZY��wxYw)zImplementation of JSONDecoder
�N)�scanner)�
scanstring�JSONDecoder�JSONDecodeError�nan�infz-infc��eZdZdZd�Zd�Zy)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

    c���|jdd|�dz}||jdd|�z
}d||||fz}tj||�||_||_||_||_||_y)N�
r�z%s: line %d column %d (char %d))	�count�rfind�
ValueError�__init__�msg�doc�pos�lineno�colno)�selfrrrrr�errmsgs       �%/usr/lib64/python3.12/json/decoder.pyrzJSONDecodeError.__init__sv�����4��C�(�1�,���c�i�i��a��-�-��2�c�6�5�#�5N�N�����D�&�)���������������
�c�`�|j|j|j|jffS)N)�	__class__rrr)rs r�
__reduce__zJSONDecodeError.__reduce__*s$���~�~����$�(�(�D�H�H�=�=�=rN)�__name__�
__module__�__qualname__�__doc__rr�rrrrs���	�>r)z	-Infinity�Infinity�NaNz[0-9A-Fa-f]{4}z(.*?)(["\\\x00-\x1f])�"�\�/��r�
�	)r$r%r&�b�f�n�r�tc��|||dz�}|�	t|j�d�Sd}t|||��#t$rY�wxYw)Nr�zInvalid \uXXXX escape)�int�grouprr)�sr�_m�escrs     r�
_decode_uXXXXr7<sX��
�Q��a��.�C�
��	��s�y�y�{�B�'�'�#�C�
�#�q�#�
&�&���	��	�s�9�	A�ATc���g}|j}|dz
}	|||�}|�
td||��|j�}|j�\}	}
|	r||	�|
dk(rn�|
dk7r)|rdj	|
�}t|||��||
��z	||}|dk7r	||}
|dz
}nht||�}|d	z
}d
|cxkrdkrAnn>|||dzd
k(r3t||dz�}d|cxkrdkrnnd|d
z
dz|dz
zz}|dz
}t|�}
||
���dj|�|fS#t
$rtd||�d�wxYw#t$rdj	|�}t|||��wxYw)a�Scan the string s for a JSON string. End is the index of the
    character in s after the quote that started the JSON string.
    Unescapes all valid JSON string escape sequences and raises ValueError
    on attempt to decode an invalid string. If strict is False then literal
    control characters are allowed in the string.

    Returns a tuple of the decoded string and the index of the character in s
    after the end quote.rNzUnterminated string starting atr$r%z"Invalid control character {0!r} at�uzInvalid \escape: {0!r}�i�i���z\ui�i��i�
��)
�appendr�end�groups�format�
IndexError�KeyErrorr7�chr�join)r4r@�strict�_br5�chunks�_append�begin�chunk�content�
terminatorrr6�char�uni�uni2s                r�
py_scanstringrRFs����F��m�m�G��!�G�E�
��1�c�
���=�!�"C�Q��N�N��i�i�k��#�l�l�n������G������
�4�
��:�A�A�*�M��%�c�1�c�2�2��
�#��	6��C�&�C�
�#�:�
3��#�w��
�1�H�C���3�'�C��1�H�C���&��&�1�S��q��>�U�+B�$�Q��a��0���T�+�V�+�!�s�V�|��&:�t�f�}�%M�N�C��1�H�C��s�8�D���
�W�X�7�7�6�?�C����+�	6�!�"C�"#�U�,�15�
6�	6���
3�/�6�6�s�;��%�c�1�c�2�2�
3�s�D*�E�*E�(E-z
[ \t\n\r]*z 	

c�L�|\}}	g}
|
j}|�i}|j}||	|	dz}
|
dk7r^|
|vr|||	�j�}	||	|	dz}
|
dk(r$|�||
�}||	dzfSi}
|�||
�}
|
|	dzfS|
dk7r
td||	��|	dz
}		t	||	|�\}}	|||�}||	|	dzdk7r/|||	�j�}	||	|	dzdk7r
td||	��|	dz
}		||	|vr&|	dz
}	||	|vr|||	dz�j�}		|||	�\}}	|||f�	||	}
|
|vr|||	dz�j�}	||	}
|	dz
}	|
dk(rnP|
d	k7rtd
||	dz
��|||	�j�}	||	|	dz}
|	dz
}	|
dk7rtd||	dz
����!|�||
�}||	fSt|
�}
|�||
�}
|
|	fS#t
$rY��wxYw#t$r}td||j�d�d}~wwxYw#t
$rd}
Y��wxYw)Nrr$�}z1Expecting property name enclosed in double quotes�:zExpecting ':' delimiter�Expecting valuer>�,�Expecting ',' delimiter)	r?�
setdefaultr@rrrC�
StopIteration�value�dict)�	s_and_endrG�	scan_once�object_hook�object_pairs_hook�memo�_w�_wsr4r@�pairs�pairs_append�memo_get�nextchar�result�keyr[�errs                  r�
JSONObjectrk�s���
�F�A�s��E��<�<�L��|������H���S�1�W�~�H��3���s�?��Q��*�.�.�"�C���S�1�W�~�H��s�?� �,�*�5�1���s�Q�w��&��E��&�#�E�*���#��'�>�!�
��_�!�C�Q��M�
M��1�H�C�
��a��f�-���S��s�C� ��
�S��q��>�S� ��Q��*�.�.�"�C���S�1�W�~��$�%�&?��C�H�H��q���	���v��}��q����S�6�S�=��Q��a��.�,�,�.�C�	M�"�1�c�*�J�E�3�	�c�5�\�"�	���v�H��3����C�!�G�n�(�(�*���S�6��	�q����s�?��
��_�!�";�Q��a��H�H���C�j�n�n����S��q��>���q����s�?�!�C�Q��a��Q�
Q�S�V�$�"�5�)���s�{����K�E����E�"���#�:���C�	��	��
�	M�!�"3�Q��	�	�B��L��	M���	��H�	�s<�.-G�G,�3(H�	G)�(G)�,	H�5H
�
H�H#�"H#c�:�|\}}g}|||dz}||vr"|||dz�j�}|||dz}|dk(r||dzfS|j}		|||�\}	}||	�|||dz}||vr"|||dz�j�}|||dz}|dz
}|dk(r	||fS|dk7rtd||dz
��	|||vr&|dz
}|||vr|||dz�j�}��#t$r}
td||
j�d�d}
~
wwxYw#t
$rY�5wxYw)Nr�]rVrWrX)r@r?rZrr[rC)r]r^rbrcr4r@�valuesrgrJr[rjs           r�	JSONArrayro�s���
�F�A�s�
�F���S�1�W�~�H��3����C�!�G�n� � �"���S��q��>���3���s�Q�w����m�m�G�
�	M�"�1�c�*�J�E�3�	����S��q��>���s�?��Q��a��.�$�$�&�C���S�1�W�~�H��q����s�?���3�;����_�!�";�Q��a��H�H�	���v��}��q����S�6�S�=��Q��a��.�,�,�.�C�'���	M�!�"3�Q��	�	�B��L��	M��"�	��	�s*�C%�7-D�%	D�.D�D�	D�Dc�L�eZdZdZddddddd�d�Zejfd�Zdd�Zy)	raSimple JSON <https://json.org> decoder

    Performs the following translations in decoding by default:

    +---------------+-------------------+
    | JSON          | Python            |
    +===============+===================+
    | object        | dict              |
    +---------------+-------------------+
    | array         | list              |
    +---------------+-------------------+
    | string        | str               |
    +---------------+-------------------+
    | number (int)  | int               |
    +---------------+-------------------+
    | number (real) | float             |
    +---------------+-------------------+
    | true          | True              |
    +---------------+-------------------+
    | false         | False             |
    +---------------+-------------------+
    | null          | None              |
    +---------------+-------------------+

    It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
    their corresponding ``float`` values, which is outside the JSON spec.

    NT)r_�parse_float�	parse_int�parse_constantrGr`c� �||_|xst|_|xst|_|xst
j|_||_||_	t|_t|_
t|_i|_t#j$|�|_y)a�``object_hook``, if specified, will be called with the result
        of every JSON object decoded and its return value will be used in
        place of the given ``dict``.  This can be used to provide custom
        deserializations (e.g. to support JSON-RPC class hinting).

        ``object_pairs_hook``, if specified will be called with the result of
        every JSON object decoded with an ordered list of pairs.  The return
        value of ``object_pairs_hook`` will be used instead of the ``dict``.
        This feature can be used to implement custom decoders.
        If ``object_hook`` is also defined, the ``object_pairs_hook`` takes
        priority.

        ``parse_float``, if specified, will be called with the string
        of every JSON float to be decoded. By default this is equivalent to
        float(num_str). This can be used to use another datatype or parser
        for JSON floats (e.g. decimal.Decimal).

        ``parse_int``, if specified, will be called with the string
        of every JSON int to be decoded. By default this is equivalent to
        int(num_str). This can be used to use another datatype or parser
        for JSON integers (e.g. float).

        ``parse_constant``, if specified, will be called with one of the
        following strings: -Infinity, Infinity, NaN.
        This can be used to raise an exception if invalid JSON numbers
        are encountered.

        If ``strict`` is false (true is the default), then control
        characters will be allowed inside strings.  Control characters in
        this context are those with character codes in the 0-31 range,
        including ``'\t'`` (tab), ``'\n'``, ``'\r'`` and ``'\0'``.
        N)r_�floatrqr2rr�
_CONSTANTS�__getitem__rsrGr`rk�parse_objectro�parse_arrayr�parse_stringrar�make_scannerr^)rr_rqrrrsrGr`s       rrzJSONDecoder.__init__sy��F'���&�/�%���"�)�c���,�F�
�0F�0F������!2���&���$���&�����	� �-�-�d�3��rc��|j|||d�j���\}}|||�j�}|t|�k7r
td||��|S)zlReturn the Python representation of ``s`` (a ``str`` instance
        containing a JSON document).

        r)�idxz
Extra data)�
raw_decoder@�lenr)rr4rb�objr@s     r�decodezJSONDecoder.decodeMsW��
�?�?�1�"�Q��(�,�,�.�?�9���S���C�j�n�n����#�a�&�=�!�,��3�7�7��
rc��	|j||�\}}||fS#t$r}td||j�d�d}~wwxYw)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.

        rVN)r^rZrr[)rr4r}r�r@rjs      rr~zJSONDecoder.raw_decodeXsQ��	M��~�~�a��-�H�C���C�x����	M�!�"3�Q��	�	�B��L��	M�s��	A�<�A)r)	rrrr r�
WHITESPACE�matchr�r~r!rrrr�s3���:'+���4��"�-4�`&�+�+�	�
r)!r �re�jsonr�_jsonr�c_scanstring�ImportError�__all__�VERBOSE�	MULTILINE�DOTALL�FLAGSrur#�PosInf�NegInfrrrv�compile�	HEXDIGITS�STRINGCHUNK�	BACKSLASHr�r7rRr��WHITESPACE_STRrkro�objectrr!rr�<module>r�sO���	���0��+�
,��
�
�
�R�\�\�!�B�I�I�-���E�l��	�u���	�v���>�j�>�6����
�
�B�J�J�(�%�0�	��b�j�j�1�5�9��	�D�s�	
�D�t�$�T�
�	�
'�_�_�'�"&���*�*�9 �z�
*�]�
�
�R�Z�Z�
�u�
-�
����Z�-�-�>�O�b(2�'7�'7�^�"�Jf�&�f��o���L��s�D�D
�	D
__pycache__/decoder.cpython-312.opt-2.pyc000064400000023355151704111340014031 0ustar00�

T��h�0�	��	ddlZddlmZ	ddlmZddgZejejzejzZed�Z
ed�Zed�ZGd	�de�Zeee
d
�Zej&de�Zej&de�Zd
dddddddd�Zej.fd�Zdeej.fd�ZexseZej&de�ZdZdej.efd�Zej.efd�ZGd�de�Zy#e$rdZY��wxYw)�N)�scanner)�
scanstring�JSONDecoder�JSONDecodeError�nan�infz-infc��eZdZ	d�Zd�Zy)rc���|jdd|�dz}||jdd|�z
}d||||fz}tj||�||_||_||_||_||_y)N�
r�z%s: line %d column %d (char %d))	�count�rfind�
ValueError�__init__�msg�doc�pos�lineno�colno)�selfrrrrr�errmsgs       �%/usr/lib64/python3.12/json/decoder.pyrzJSONDecodeError.__init__sv�����4��C�(�1�,���c�i�i��a��-�-��2�c�6�5�#�5N�N�����D�&�)���������������
�c�`�|j|j|j|jffS�N)�	__class__rrr)rs r�
__reduce__zJSONDecodeError.__reduce__*s$���~�~����$�(�(�D�H�H�=�=�=rN)�__name__�
__module__�__qualname__rr�rrrrs���	�>r)z	-Infinity�Infinity�NaNz[0-9A-Fa-f]{4}z(.*?)(["\\\x00-\x1f])�"�\�/��r�
�	)r$r%r&�b�f�n�r�tc��|||dz�}|�	t|j�d�Sd}t|||��#t$rY�wxYw)Nr�zInvalid \uXXXX escape)�int�grouprr)�sr�_m�escrs     r�
_decode_uXXXXr7<sX��
�Q��a��.�C�
��	��s�y�y�{�B�'�'�#�C�
�#�q�#�
&�&���	��	�s�9�	A�ATc���	g}|j}|dz
}	|||�}|�
td||��|j�}|j�\}	}
|	r||	�|
dk(rn�|
dk7r)|rdj	|
�}t|||��||
��z	||}|dk7r	||}
|dz
}nht||�}|dz
}d	|cxkrd
krAnn>|||dzdk(r3t||dz�}d
|cxkrdkrnnd|d	z
dz|d
z
zz}|dz
}t|�}
||
���dj|�|fS#t
$rtd||�d�wxYw#t$rdj	|�}t|||��wxYw)NrzUnterminated string starting atr$r%z"Invalid control character {0!r} at�uzInvalid \escape: {0!r}�i�i���z\ui�i��i�
��)
�appendr�end�groups�format�
IndexError�KeyErrorr7�chr�join)r4r@�strict�_br5�chunks�_append�begin�chunk�content�
terminatorrr6�char�uni�uni2s                r�
py_scanstringrRFs�����F��m�m�G��!�G�E�
��1�c�
���=�!�"C�Q��N�N��i�i�k��#�l�l�n������G������
�4�
��:�A�A�*�M��%�c�1�c�2�2��
�#��	6��C�&�C�
�#�:�
3��#�w��
�1�H�C���3�'�C��1�H�C���&��&�1�S��q��>�U�+B�$�Q��a��0���T�+�V�+�!�s�V�|��&:�t�f�}�%M�N�C��1�H�C��s�8�D���
�W�X�7�7�6�?�C����+�	6�!�"C�"#�U�,�15�
6�	6���
3�/�6�6�s�;��%�c�1�c�2�2�
3�s�D+�E�+E�(E.z
[ \t\n\r]*z 	

c�L�|\}}	g}
|
j}|�i}|j}||	|	dz}
|
dk7r^|
|vr|||	�j�}	||	|	dz}
|
dk(r$|�||
�}||	dzfSi}
|�||
�}
|
|	dzfS|
dk7r
td||	��|	dz
}		t	||	|�\}}	|||�}||	|	dzdk7r/|||	�j�}	||	|	dzdk7r
td||	��|	dz
}		||	|vr&|	dz
}	||	|vr|||	dz�j�}		|||	�\}}	|||f�	||	}
|
|vr|||	dz�j�}	||	}
|	dz
}	|
dk(rnP|
d	k7rtd
||	dz
��|||	�j�}	||	|	dz}
|	dz
}	|
dk7rtd||	dz
����!|�||
�}||	fSt|
�}
|�||
�}
|
|	fS#t
$rY��wxYw#t$r}td||j�d�d}~wwxYw#t
$rd}
Y��wxYw)Nrr$�}z1Expecting property name enclosed in double quotes�:zExpecting ':' delimiter�Expecting valuer>�,�Expecting ',' delimiter)	r?�
setdefaultr@rrrC�
StopIteration�value�dict)�	s_and_endrG�	scan_once�object_hook�object_pairs_hook�memo�_w�_wsr4r@�pairs�pairs_append�memo_get�nextchar�result�keyr[�errs                  r�
JSONObjectrk�s���
�F�A�s��E��<�<�L��|������H���S�1�W�~�H��3���s�?��Q��*�.�.�"�C���S�1�W�~�H��s�?� �,�*�5�1���s�Q�w��&��E��&�#�E�*���#��'�>�!�
��_�!�C�Q��M�
M��1�H�C�
��a��f�-���S��s�C� ��
�S��q��>�S� ��Q��*�.�.�"�C���S�1�W�~��$�%�&?��C�H�H��q���	���v��}��q����S�6�S�=��Q��a��.�,�,�.�C�	M�"�1�c�*�J�E�3�	�c�5�\�"�	���v�H��3����C�!�G�n�(�(�*���S�6��	�q����s�?��
��_�!�";�Q��a��H�H���C�j�n�n����S��q��>���q����s�?�!�C�Q��a��Q�
Q�S�V�$�"�5�)���s�{����K�E����E�"���#�:���C�	��	��
�	M�!�"3�Q��	�	�B��L��	M���	��H�	�s<�.-G�G,�3(H�	G)�(G)�,	H�5H
�
H�H#�"H#c�:�|\}}g}|||dz}||vr"|||dz�j�}|||dz}|dk(r||dzfS|j}		|||�\}	}||	�|||dz}||vr"|||dz�j�}|||dz}|dz
}|dk(r	||fS|dk7rtd||dz
��	|||vr&|dz
}|||vr|||dz�j�}��#t$r}
td||
j�d�d}
~
wwxYw#t
$rY�5wxYw)Nr�]rVrWrX)r@r?rZrr[rC)r]r^rbrcr4r@�valuesrgrJr[rjs           r�	JSONArrayro�s���
�F�A�s�
�F���S�1�W�~�H��3����C�!�G�n� � �"���S��q��>���3���s�Q�w����m�m�G�
�	M�"�1�c�*�J�E�3�	����S��q��>���s�?��Q��a��.�$�$�&�C���S�1�W�~�H��q����s�?���3�;����_�!�";�Q��a��H�H�	���v��}��q����S�6�S�=��Q��a��.�,�,�.�C�'���	M�!�"3�Q��	�	�B��L��	M��"�	��	�s*�C%�7-D�%	D�.D�D�	D�Dc�J�eZdZ	ddddddd�d�Zej
fd�Zdd�Zy)rNT)r_�parse_float�	parse_int�parse_constantrGr`c�"�	||_|xst|_|xst|_|xst
j|_||_||_	t|_t|_
t|_i|_t#j$|�|_yr)r_�floatrqr2rr�
_CONSTANTS�__getitem__rsrGr`rk�parse_objectro�parse_arrayr�parse_stringrar�make_scannerr^)rr_rqrrrsrGr`s       rrzJSONDecoder.__init__s~��	�@'���&�/�%���"�)�c���,�F�
�0F�0F������!2���&���$���&�����	� �-�-�d�3��rc���	|j|||d�j���\}}|||�j�}|t|�k7r
td||��|S)Nr)�idxz
Extra data)�
raw_decoder@�lenr)rr4rb�objr@s     r�decodezJSONDecoder.decodeMs\��	��?�?�1�"�Q��(�,�,�.�?�9���S���C�j�n�n����#�a�&�=�!�,��3�7�7��
rc��		|j||�\}}||fS#t$r}td||j�d�d}~wwxYw)NrV)r^rZrr[)rr4r}r�r@rjs      rr~zJSONDecoder.raw_decodeXsV��	�	M��~�~�a��-�H�C���C�x����	M�!�"3�Q��	�	�B��L��	M�s��	A�=�A)r)rrr r�
WHITESPACE�matchr�r~r!rrrr�s3���:'+���4��"�-4�`&�+�+�	�
r) �re�jsonr�_jsonr�c_scanstring�ImportError�__all__�VERBOSE�	MULTILINE�DOTALL�FLAGSrur#�PosInf�NegInfrrrv�compile�	HEXDIGITS�STRINGCHUNK�	BACKSLASHr�r7rRr��WHITESPACE_STRrkro�objectrr!rr�<module>r�sO���	���0��+�
,��
�
�
�R�\�\�!�B�I�I�-���E�l��	�u���	�v���>�j�>�6����
�
�B�J�J�(�%�0�	��b�j�j�1�5�9��	�D�s�	
�D�t�$�T�
�	�
'�_�_�'�"&���*�*�9 �z�
*�]�
�
�R�Z�Z�
�u�
-�
����Z�-�-�>�O�b(2�'7�'7�^�"�Jf�&�f��o���L��s�C?�?D	�D	__pycache__/decoder.cpython-312.pyc000064400000033133151704111340013064 0ustar00�

T��h�0�	��dZddlZddlmZ	ddlmZddgZejejzejzZe
d�Ze
d�Ze
d	�ZGd
�de�Zeeed�Zej(de�Zej(d
e�Zddddddddd�Zej0fd�Zdeej0fd�ZexseZej(de�ZdZdej0efd�Zej0efd�ZGd�de�Z y#e$rdZY��wxYw)zImplementation of JSONDecoder
�N)�scanner)�
scanstring�JSONDecoder�JSONDecodeError�nan�infz-infc��eZdZdZd�Zd�Zy)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

    c���|jdd|�dz}||jdd|�z
}d||||fz}tj||�||_||_||_||_||_y)N�
r�z%s: line %d column %d (char %d))	�count�rfind�
ValueError�__init__�msg�doc�pos�lineno�colno)�selfrrrrr�errmsgs       �%/usr/lib64/python3.12/json/decoder.pyrzJSONDecodeError.__init__sv�����4��C�(�1�,���c�i�i��a��-�-��2�c�6�5�#�5N�N�����D�&�)���������������
�c�`�|j|j|j|jffS)N)�	__class__rrr)rs r�
__reduce__zJSONDecodeError.__reduce__*s$���~�~����$�(�(�D�H�H�=�=�=rN)�__name__�
__module__�__qualname__�__doc__rr�rrrrs���	�>r)z	-Infinity�Infinity�NaNz[0-9A-Fa-f]{4}z(.*?)(["\\\x00-\x1f])�"�\�/��r�
�	)r$r%r&�b�f�n�r�tc��|||dz�}|�	t|j�d�Sd}t|||��#t$rY�wxYw)Nr�zInvalid \uXXXX escape)�int�grouprr)�sr�_m�escrs     r�
_decode_uXXXXr7<sX��
�Q��a��.�C�
��	��s�y�y�{�B�'�'�#�C�
�#�q�#�
&�&���	��	�s�9�	A�ATc���g}|j}|dz
}	|||�}|�
td||��|j�}|j�\}	}
|	r||	�|
dk(rn�|
dk7r)|rdj	|
�}t|||��||
��z	||}|dk7r	||}
|dz
}nht||�}|d	z
}d
|cxkrdkrAnn>|||dzd
k(r3t||dz�}d|cxkrdkrnnd|d
z
dz|dz
zz}|dz
}t|�}
||
���dj|�|fS#t
$rtd||�d�wxYw#t$rdj	|�}t|||��wxYw)a�Scan the string s for a JSON string. End is the index of the
    character in s after the quote that started the JSON string.
    Unescapes all valid JSON string escape sequences and raises ValueError
    on attempt to decode an invalid string. If strict is False then literal
    control characters are allowed in the string.

    Returns a tuple of the decoded string and the index of the character in s
    after the end quote.rNzUnterminated string starting atr$r%z"Invalid control character {0!r} at�uzInvalid \escape: {0!r}�i�i���z\ui�i��i�
��)
�appendr�end�groups�format�
IndexError�KeyErrorr7�chr�join)r4r@�strict�_br5�chunks�_append�begin�chunk�content�
terminatorrr6�char�uni�uni2s                r�
py_scanstringrRFs����F��m�m�G��!�G�E�
��1�c�
���=�!�"C�Q��N�N��i�i�k��#�l�l�n������G������
�4�
��:�A�A�*�M��%�c�1�c�2�2��
�#��	6��C�&�C�
�#�:�
3��#�w��
�1�H�C���3�'�C��1�H�C���&��&�1�S��q��>�U�+B�$�Q��a��0���T�+�V�+�!�s�V�|��&:�t�f�}�%M�N�C��1�H�C��s�8�D���
�W�X�7�7�6�?�C����+�	6�!�"C�"#�U�,�15�
6�	6���
3�/�6�6�s�;��%�c�1�c�2�2�
3�s�D*�E�*E�(E-z
[ \t\n\r]*z 	

c�L�|\}}	g}
|
j}|�i}|j}||	|	dz}
|
dk7r^|
|vr|||	�j�}	||	|	dz}
|
dk(r$|�||
�}||	dzfSi}
|�||
�}
|
|	dzfS|
dk7r
td||	��|	dz
}		t	||	|�\}}	|||�}||	|	dzdk7r/|||	�j�}	||	|	dzdk7r
td||	��|	dz
}		||	|vr&|	dz
}	||	|vr|||	dz�j�}		|||	�\}}	|||f�	||	}
|
|vr|||	dz�j�}	||	}
|	dz
}	|
dk(rnP|
d	k7rtd
||	dz
��|||	�j�}	||	|	dz}
|	dz
}	|
dk7rtd||	dz
����!|�||
�}||	fSt|
�}
|�||
�}
|
|	fS#t
$rY��wxYw#t$r}td||j�d�d}~wwxYw#t
$rd}
Y��wxYw)Nrr$�}z1Expecting property name enclosed in double quotes�:zExpecting ':' delimiter�Expecting valuer>�,�Expecting ',' delimiter)	r?�
setdefaultr@rrrC�
StopIteration�value�dict)�	s_and_endrG�	scan_once�object_hook�object_pairs_hook�memo�_w�_wsr4r@�pairs�pairs_append�memo_get�nextchar�result�keyr[�errs                  r�
JSONObjectrk�s���
�F�A�s��E��<�<�L��|������H���S�1�W�~�H��3���s�?��Q��*�.�.�"�C���S�1�W�~�H��s�?� �,�*�5�1���s�Q�w��&��E��&�#�E�*���#��'�>�!�
��_�!�C�Q��M�
M��1�H�C�
��a��f�-���S��s�C� ��
�S��q��>�S� ��Q��*�.�.�"�C���S�1�W�~��$�%�&?��C�H�H��q���	���v��}��q����S�6�S�=��Q��a��.�,�,�.�C�	M�"�1�c�*�J�E�3�	�c�5�\�"�	���v�H��3����C�!�G�n�(�(�*���S�6��	�q����s�?��
��_�!�";�Q��a��H�H���C�j�n�n����S��q��>���q����s�?�!�C�Q��a��Q�
Q�S�V�$�"�5�)���s�{����K�E����E�"���#�:���C�	��	��
�	M�!�"3�Q��	�	�B��L��	M���	��H�	�s<�.-G�G,�3(H�	G)�(G)�,	H�5H
�
H�H#�"H#c�:�|\}}g}|||dz}||vr"|||dz�j�}|||dz}|dk(r||dzfS|j}		|||�\}	}||	�|||dz}||vr"|||dz�j�}|||dz}|dz
}|dk(r	||fS|dk7rtd||dz
��	|||vr&|dz
}|||vr|||dz�j�}��#t$r}
td||
j�d�d}
~
wwxYw#t
$rY�5wxYw)Nr�]rVrWrX)r@r?rZrr[rC)r]r^rbrcr4r@�valuesrgrJr[rjs           r�	JSONArrayro�s���
�F�A�s�
�F���S�1�W�~�H��3����C�!�G�n� � �"���S��q��>���3���s�Q�w����m�m�G�
�	M�"�1�c�*�J�E�3�	����S��q��>���s�?��Q��a��.�$�$�&�C���S�1�W�~�H��q����s�?���3�;����_�!�";�Q��a��H�H�	���v��}��q����S�6�S�=��Q��a��.�,�,�.�C�'���	M�!�"3�Q��	�	�B��L��	M��"�	��	�s*�C%�7-D�%	D�.D�D�	D�Dc�L�eZdZdZddddddd�d�Zejfd�Zdd�Zy)	raSimple JSON <https://json.org> decoder

    Performs the following translations in decoding by default:

    +---------------+-------------------+
    | JSON          | Python            |
    +===============+===================+
    | object        | dict              |
    +---------------+-------------------+
    | array         | list              |
    +---------------+-------------------+
    | string        | str               |
    +---------------+-------------------+
    | number (int)  | int               |
    +---------------+-------------------+
    | number (real) | float             |
    +---------------+-------------------+
    | true          | True              |
    +---------------+-------------------+
    | false         | False             |
    +---------------+-------------------+
    | null          | None              |
    +---------------+-------------------+

    It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
    their corresponding ``float`` values, which is outside the JSON spec.

    NT)r_�parse_float�	parse_int�parse_constantrGr`c� �||_|xst|_|xst|_|xst
j|_||_||_	t|_t|_
t|_i|_t#j$|�|_y)a�``object_hook``, if specified, will be called with the result
        of every JSON object decoded and its return value will be used in
        place of the given ``dict``.  This can be used to provide custom
        deserializations (e.g. to support JSON-RPC class hinting).

        ``object_pairs_hook``, if specified will be called with the result of
        every JSON object decoded with an ordered list of pairs.  The return
        value of ``object_pairs_hook`` will be used instead of the ``dict``.
        This feature can be used to implement custom decoders.
        If ``object_hook`` is also defined, the ``object_pairs_hook`` takes
        priority.

        ``parse_float``, if specified, will be called with the string
        of every JSON float to be decoded. By default this is equivalent to
        float(num_str). This can be used to use another datatype or parser
        for JSON floats (e.g. decimal.Decimal).

        ``parse_int``, if specified, will be called with the string
        of every JSON int to be decoded. By default this is equivalent to
        int(num_str). This can be used to use another datatype or parser
        for JSON integers (e.g. float).

        ``parse_constant``, if specified, will be called with one of the
        following strings: -Infinity, Infinity, NaN.
        This can be used to raise an exception if invalid JSON numbers
        are encountered.

        If ``strict`` is false (true is the default), then control
        characters will be allowed inside strings.  Control characters in
        this context are those with character codes in the 0-31 range,
        including ``'\t'`` (tab), ``'\n'``, ``'\r'`` and ``'\0'``.
        N)r_�floatrqr2rr�
_CONSTANTS�__getitem__rsrGr`rk�parse_objectro�parse_arrayr�parse_stringrar�make_scannerr^)rr_rqrrrsrGr`s       rrzJSONDecoder.__init__sy��F'���&�/�%���"�)�c���,�F�
�0F�0F������!2���&���$���&�����	� �-�-�d�3��rc��|j|||d�j���\}}|||�j�}|t|�k7r
td||��|S)zlReturn the Python representation of ``s`` (a ``str`` instance
        containing a JSON document).

        r)�idxz
Extra data)�
raw_decoder@�lenr)rr4rb�objr@s     r�decodezJSONDecoder.decodeMsW��
�?�?�1�"�Q��(�,�,�.�?�9���S���C�j�n�n����#�a�&�=�!�,��3�7�7��
rc��	|j||�\}}||fS#t$r}td||j�d�d}~wwxYw)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.

        rVN)r^rZrr[)rr4r}r�r@rjs      rr~zJSONDecoder.raw_decodeXsQ��	M��~�~�a��-�H�C���C�x����	M�!�"3�Q��	�	�B��L��	M�s��	A�<�A)r)	rrrr r�
WHITESPACE�matchr�r~r!rrrr�s3���:'+���4��"�-4�`&�+�+�	�
r)!r �re�jsonr�_jsonr�c_scanstring�ImportError�__all__�VERBOSE�	MULTILINE�DOTALL�FLAGSrur#�PosInf�NegInfrrrv�compile�	HEXDIGITS�STRINGCHUNK�	BACKSLASHr�r7rRr��WHITESPACE_STRrkro�objectrr!rr�<module>r�sO���	���0��+�
,��
�
�
�R�\�\�!�B�I�I�-���E�l��	�u���	�v���>�j�>�6����
�
�B�J�J�(�%�0�	��b�j�j�1�5�9��	�D�s�	
�D�t�$�T�
�	�
'�_�_�'�"&���*�*�9 �z�
*�]�
�
�R�Z�Z�
�u�
-�
����Z�-�-�>�O�b(2�'7�'7�^�"�Jf�&�f��o���L��s�D�D
�	D
__pycache__/encoder.cpython-312.opt-1.pyc000064400000035362151704111340014043 0ustar00�

T��h�>�
���dZddlZ	ddlmZ	ddlmZ	ddlmZ	ejd�Zejd�Zejd�Z
d	d
ddd
ddd�Zed�D])Zej#ee�dj'e���+[ed�Zd�ZexseZd�ZexseZGd�de�Zeeeeeeee e!ejDf
d�Z#y#e$rdZY��wxYw#e$rdZY��wxYw#e$rdZ	Y��wxYw)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)�\�"���
�
�	� �	\u{0:04x}�infc�@�d�}dtj||�zdzS)z5Return a JSON representation of a Python string

    c�2�t|jd�S)Nr)�
ESCAPE_DCT�group)�matchs �%/usr/lib64/python3.12/json/encoder.py�replacez%py_encode_basestring.<locals>.replace)s���%�+�+�a�.�)�)�r)�ESCAPE�sub��srs  r�py_encode_basestringr%s"��*�����G�Q�'�'�#�-�-rc�@�d�}dtj||�zdzS)zAReturn an ASCII-only JSON representation of a Python string

    c���|jd�}	t|S#t$rPt|�}|dkrdj	|�cYS|dz}d|dz	dzz}d|dzz}dj	||�cYSwxYw)	Nriri��
i�i�z\u{0:04x}\u{1:04x})rr�KeyError�ord�format)rr�n�s1�s2s     rrz+py_encode_basestring_ascii.<locals>.replace5s����K�K��N��	=��a�=� ���
	=��A��A��7�{�#�*�*�1�-�-��W�����R��5�0�1���q�5�y�)��-�4�4�R��<�<�
	=�s��*A5�*A5�4A5r)�ESCAPE_ASCIIrrs  r�py_encode_basestring_asciir'1s&��=���!�!�'�1�-�-��3�3rc	�F�eZdZdZdZdZddddddddd�d�Zd	�Zd
�Zdd�Z	y)
�JSONEncodera[Extensible JSON <https://json.org> encoder for Python data structures.

    Supports the following objects and types by default:

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

    To extend this to recognize other objects, subclass and implement a
    ``.default()`` method with another method that returns a serializable
    object for ``o`` if possible, otherwise it should call the superclass
    implementation (to raise ``TypeError``).

    z, z: FTN)�skipkeys�ensure_ascii�check_circular�	allow_nan�	sort_keys�indent�
separators�defaultc��||_||_||_||_||_||_|�|\|_|_n	|�d|_|�||_yy)a�Constructor for JSONEncoder, with sensible defaults.

        If skipkeys is false, then it is a TypeError to attempt
        encoding of keys that are not str, int, float, bool 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 RecursionError).
        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_separatorr1)	�selfr*r+r,r-r.r/r0r1s	         r�__init__zJSONEncoder.__init__isg��V!��
�(���,���"���"�������!�6@�3�D���!3�
�
�"%�D����"�D�L�rc�H�td|jj�d���)abImplement 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 super().default(o)

        zObject of type z is not JSON serializable)�	TypeError�	__class__�__name__)r6�os  rr1zJSONEncoder.default�s-��&�/�!�+�+�*>�*>�)?�@3�4�5�	5rc���t|t�r"|jrt|�St	|�S|j|d��}t|ttf�st
|�}dj|�S)z�Return a JSON string representation of a Python data structure.

        >>> from json.encoder import JSONEncoder
        >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
        '{"foo": ["bar", "baz"]}'

        T)�	_one_shot�)	�
isinstance�strr+rr�
iterencode�list�tuple�join)r6r<�chunkss   r�encodezJSONEncoder.encode�sf���a���� � �.�q�1�1�(��+�+�����d��3���&�4��-�0��&�\�F��w�w�v��rc�6�|jri}nd}|jrt}nt}|jt
jttfd�}|rlt�f|j�Zt||j||j|j|j|j|j|j�	}nPt||j||j||j|j|j|j|�
}||d�S)z�Encode the given object and yield each string
        representation as available.

        For example::

            for chunk in JSONEncoder().iterencode(bigobject):
                mysocket.write(chunk)

        Nc�x�||k7rd}n||k(rd}n||k(rd}n||�S|stdt|�z��|S)N�NaN�Infinityz	-Infinityz2Out of range float values are not JSON compliant: )�
ValueError�repr)r<r-�_repr�_inf�_neginf�texts      r�floatstrz(JSONEncoder.iterencode.<locals>.floatstr�sW���A�v����d��!���g��"���Q�x��� �H���G�����Krr)r,r+rrr-�float�__repr__�INFINITY�c_make_encoderr/r1r5r4r.r*�_make_iterencode)r6r<r>�markers�_encoderrR�_iterencodes       rrBzJSONEncoder.iterencode�s�������G��G����.�H�(�H�"&�.�.��n�n�8�h�Y�	�.
�.�4��K�K�'�(�����x�����"�"�D�$7�$7�����
�
�t�~�~�/�K�
+�����x����h��"�"�D�$7�$7�����
�
�y�*�K��1�a� � r)F)
r;�
__module__�__qualname__�__doc__r4r5r7r1rGrB�rrr)r)Js;���8�N��M�#(�t��4�5��D�$�6#�p5�,�,5!rr)c������������
���
����������������sd�z��
�����������
������fd���
��������������
������fd���
����������
������fd���S)N� c3�8�K�|sd��y���|�}|�vr�	d��|�|<d}��|dz
}d�|zz}�|z}||z
}nd}�}d}|D]�}|rd}n|}�|��r|�
|�z���!|�|dz���+|dur|d	z���7|dur|d
z���C�|��r|�
|�z���Z�|��r|�|�z���q|���|��f�r
�||�}n�|��r
�||�}n	�||�}|Ed{�����|�|dz}d�|zz��d�����=yy7�"�w)Nz[]�Circular reference detected�[�r
TF�null�true�false�]r^)�lst�_current_indent_level�markerid�buf�newline_indent�	separator�first�valuerFrLrY�	_floatstr�_indent�_intstr�_item_separatorrZ�_iterencode_dict�_iterencode_list�dictrS�id�intr@rCrXrArDs         ������������������rrvz*_make_iterencode.<locals>._iterencode_lists��������J�����#�w�H��7�"� �!>�?�?� #�G�H������!�Q�&�!�!�G�.C�$C�C�N�'�.�8�I��>�!�C�!�N�'�I����E�������%��%��H�U�O�+�+����F�l�"��$���F�l�"��%���G�m�#��E�3�'��G�E�N�*�*��E�5�)��I�e�,�,�,��	��e�d�E�]�3�-�e�5J�K�F���t�,�-�e�5J�K�F�(��0E�F�F�!�!�!�;�<�%�!�Q�&�!���#8�8�8�8��	�����!��"�s�C2D�5D�6#Dc3�\�K�|sd��y���|�}|�vr�
d��|�|<d���
�|dz
}d�
|zz}�|z}|��nd}�}d}�rt|j��}n|j�}|D�]\}}�|��rn\�|��r	�|�}nJ|durd}nC|durd	}n<|�d
}n7�|��r	�|�}n%�r�Ktd|jj����|rd}n|���|�������|��r�|�����|�d
����|durd����|durd	�����|��r�|������|��r�|������|��f�r
�||�}	n�|��r
�||�}	n	�||�}	|	Ed{�����|�|dz}d�
|zz��d�����=yy7�#�w)
Nz{}rb�{rdr
TrfFrgrez0keys must be str, int, float, bool or None, not �})�sorted�itemsr9r:r;)�dctrjrkrmr4ror~�keyrprFrLrYrqrrrsrtrZrurv�_key_separator�	_skipkeys�
_sort_keysrwrSrxryr@rCrXrArDs          ���������������������rruz*_make_iterencode.<locals>._iterencode_dictNs?�������J�����#�w�H��7�"� �!>�?�?� #�G�H���	���!�Q�&�!�!�G�.C�$C�C�N�,�~�=�N� � �!�N�,�N�����3�9�9�;�'�E��I�I�K�E��J�C���#�s�#���C��'���n�����������������C��%��c�l�����#'�'*�}�}�'=�'=�&>�!@�A�A����$�$��3�-�� � ��%��%��u�o�%������$�����%���
��E�3�'��e�n�$��E�5�)���&�&��e�d�E�]�3�-�e�5J�K�F���t�,�-�e�5J�K�F�(��0E�F�F�!�!�!�c �d�%�!�Q�&�!���#8�8�8�8��	�����!��"�s�FF,�F*�$F,c3��K��|��r�|���y|�d��y|durd��y|durd��y�|��r�|���y�|��r�|���y�|��f�r�
||�Ed{���y�|��r�	||�Ed{���y���
|�}|�vr�d��|�|<�|�}�||�Ed{������=yy7�[7�B7��w)NreTrfFrgrbr^)r<rjrkrL�_defaultrYrqrsrZrurvrwrSrxryr@rCrXrArDs   �����������������rrZz%_make_iterencode.<locals>._iterencode�s	������a����1�+��
�Y��L�
�$�Y��L�
�%�Z��M�
��3�
��!�*��
��5�
!��A�,��
��D�%�=�
)�'��+@�A�A�A�
��4�
 �'��+@�A�A�A��"��a�5���w�&�$�%B�C�C�$%���!����A�"�1�&;�<�<�<��"��H�%�#�
B��A��
=�s6�A-C�0C�1C�C�4C�C�C�C�Cr^)rXr�rYrrrqr�rtr�r�r>rLrwrSrxryr@rCrArDrsrZrurvs````````` ``````````@@@rrWrWs_�������:�g�s�#;���-��6"�6"�6"�pN"�N"�N"�N"�`&�&�&�:�r)$r]�re�_jsonr�c_encode_basestring_ascii�ImportErrorr�c_encode_basestringrrV�compilerr&�HAS_UTF8r�range�i�
setdefault�chrr"rSrUrr'�objectr)rLrwrxryr@rCrArDrTrWr^rr�<module>r�sV���	�%�J��>��4�
����/�	0���r�z�z�,�-���2�:�:�n�%��
�	�
�
�
�
�
��
�
�t��A����#�a�&�,�"5�"5�a�"8�9�
����<��.�)�@�,@��4�.�;�!;��x!�&�x!�z�
��
���
������w��{�%� $��%�����������N��s3�C�C�C)�C�C�C&�%C&�)C3�2C3__pycache__/encoder.cpython-312.opt-2.pyc000064400000025051151704111340014036 0ustar00�

T��h�>�
���	ddlZ	ddlmZ	ddlmZ	ddlmZejd�Z
ejd�Zejd�Zdd	d
ddd
dd�Z
ed�D])Ze
j!ee�dj%e���+[ed�Zd�ZexseZd�ZexseZGd�de�Zeeeeeeeee ejBf
d�Z"y#e$rdZY��wxYw#e$rdZY��wxYw#e$rdZY��wxYw)�N)�encode_basestring_ascii)�encode_basestring)�make_encoderz[\x00-\x1f\\"\b\f\n\r\t]z([\\"]|[^\ -~])s[�-�]z\\z\"z\bz\fz\nz\rz\t)�\�"���
�
�	� �	\u{0:04x}�infc�B�	d�}dtj||�zdzS)Nc�2�t|jd�S)Nr)�
ESCAPE_DCT�group)�matchs �%/usr/lib64/python3.12/json/encoder.py�replacez%py_encode_basestring.<locals>.replace)s���%�+�+�a�.�)�)�r)�ESCAPE�sub��srs  r�py_encode_basestringr%s'���*�����G�Q�'�'�#�-�-rc�B�	d�}dtj||�zdzS)Nc���|jd�}	t|S#t$rPt|�}|dkrdj	|�cYS|dz}d|dz	dzz}d|dzz}dj	||�cYSwxYw)	Nriri��
i�i�z\u{0:04x}\u{1:04x})rr�KeyError�ord�format)rr�n�s1�s2s     rrz+py_encode_basestring_ascii.<locals>.replace5s����K�K��N��	=��a�=� ���
	=��A��A��7�{�#�*�*�1�-�-��W�����R��5�0�1���q�5�y�)��-�4�4�R��<�<�
	=�s��*A5�*A5�4A5r)�ESCAPE_ASCIIrrs  r�py_encode_basestring_asciir'1s+���=���!�!�'�1�-�-��3�3rc	�D�eZdZ	dZdZddddddddd�d�Zd�Zd	�Zdd
�Zy)�JSONEncoderz, z: FTN)�skipkeys�ensure_ascii�check_circular�	allow_nan�	sort_keys�indent�
separators�defaultc��	||_||_||_||_||_||_|�|\|_|_n	|�d|_|�||_yy)N�,)	r*r+r,r-r.r/�item_separator�
key_separatorr1)	�selfr*r+r,r-r.r/r0r1s	         r�__init__zJSONEncoder.__init__isl��&	�P!��
�(���,���"���"�������!�6@�3�D���!3�
�
�"%�D����"�D�L�rc�J�	td|jj�d���)NzObject of type z is not JSON serializable)�	TypeError�	__class__�__name__)r6�os  rr1zJSONEncoder.default�s2��	�$�/�!�+�+�*>�*>�)?�@3�4�5�	5rc���	t|t�r"|jrt|�St	|�S|j|d��}t|ttf�st
|�}dj|�S)NT)�	_one_shot�)	�
isinstance�strr+rr�
iterencode�list�tuple�join)r6r<�chunkss   r�encodezJSONEncoder.encode�sk��	��a���� � �.�q�1�1�(��+�+�����d��3���&�4��-�0��&�\�F��w�w�v��rc�8�	|jri}nd}|jrt}nt}|jt
jttfd�}|rlt�f|j�Zt||j||j|j|j|j|j|j�	}nPt||j||j||j|j|j|j|�
}||d�S)Nc�x�||k7rd}n||k(rd}n||k(rd}n||�S|stdt|�z��|S)N�NaN�Infinityz	-Infinityz2Out of range float values are not JSON compliant: )�
ValueError�repr)r<r-�_repr�_inf�_neginf�texts      r�floatstrz(JSONEncoder.iterencode.<locals>.floatstr�sW���A�v����d��!���g��"���Q�x��� �H���G�����Krr)r,r+rrr-�float�__repr__�INFINITY�c_make_encoderr/r1r5r4r.r*�_make_iterencode)r6r<r>�markers�_encoderrR�_iterencodes       rrBzJSONEncoder.iterencode�s���	�����G��G����.�H�(�H�"&�.�.��n�n�8�h�Y�	�.
�.�4��K�K�'�(�����x�����"�"�D�$7�$7�����
�
�t�~�~�/�K�
+�����x����h��"�"�D�$7�$7�����
�
�y�*�K��1�a� � r)F)	r;�
__module__�__qualname__r4r5r7r1rGrB�rrr)r)Js;���8�N��M�#(�t��4�5��D�$�6#�p5�,�,5!rr)c������������
���
����������������sd�z��
�����������
������fd���
��������������
������fd���
����������
������fd���S)N� c3�8�K�|sd��y���|�}|�vr�	d��|�|<d}��|dz
}d�|zz}�|z}||z
}nd}�}d}|D]�}|rd}n|}�|��r|�
|�z���!|�|dz���+|dur|d	z���7|dur|d
z���C�|��r|�
|�z���Z�|��r|�|�z���q|���|��f�r
�||�}n�|��r
�||�}n	�||�}|Ed{�����|�|dz}d�|zz��d�����=yy7�"�w)Nz[]�Circular reference detected�[�r
TF�null�true�false�]r])�lst�_current_indent_level�markerid�buf�newline_indent�	separator�first�valuerFrLrY�	_floatstr�_indent�_intstr�_item_separatorrZ�_iterencode_dict�_iterencode_list�dictrS�id�intr@rCrXrArDs         ������������������rruz*_make_iterencode.<locals>._iterencode_lists��������J�����#�w�H��7�"� �!>�?�?� #�G�H������!�Q�&�!�!�G�.C�$C�C�N�'�.�8�I��>�!�C�!�N�'�I����E�������%��%��H�U�O�+�+����F�l�"��$���F�l�"��%���G�m�#��E�3�'��G�E�N�*�*��E�5�)��I�e�,�,�,��	��e�d�E�]�3�-�e�5J�K�F���t�,�-�e�5J�K�F�(��0E�F�F�!�!�!�;�<�%�!�Q�&�!���#8�8�8�8��	�����!��"�s�C2D�5D�6#Dc3�\�K�|sd��y���|�}|�vr�
d��|�|<d���
�|dz
}d�
|zz}�|z}|��nd}�}d}�rt|j��}n|j�}|D�]\}}�|��rn\�|��r	�|�}nJ|durd}nC|durd	}n<|�d
}n7�|��r	�|�}n%�r�Ktd|jj����|rd}n|���|�������|��r�|�����|�d
����|durd����|durd	�����|��r�|������|��r�|������|��f�r
�||�}	n�|��r
�||�}	n	�||�}	|	Ed{�����|�|dz}d�
|zz��d�����=yy7�#�w)
Nz{}ra�{rcr
TreFrfrdz0keys must be str, int, float, bool or None, not �})�sorted�itemsr9r:r;)�dctrirjrlr4rnr}�keyrorFrLrYrprqrrrsrZrtru�_key_separator�	_skipkeys�
_sort_keysrvrSrwrxr@rCrXrArDs          ���������������������rrtz*_make_iterencode.<locals>._iterencode_dictNs?�������J�����#�w�H��7�"� �!>�?�?� #�G�H���	���!�Q�&�!�!�G�.C�$C�C�N�,�~�=�N� � �!�N�,�N�����3�9�9�;�'�E��I�I�K�E��J�C���#�s�#���C��'���n�����������������C��%��c�l�����#'�'*�}�}�'=�'=�&>�!@�A�A����$�$��3�-�� � ��%��%��u�o�%������$�����%���
��E�3�'��e�n�$��E�5�)���&�&��e�d�E�]�3�-�e�5J�K�F���t�,�-�e�5J�K�F�(��0E�F�F�!�!�!�c �d�%�!�Q�&�!���#8�8�8�8��	�����!��"�s�FF,�F*�$F,c3��K��|��r�|���y|�d��y|durd��y|durd��y�|��r�|���y�|��r�|���y�|��f�r�
||�Ed{���y�|��r�	||�Ed{���y���
|�}|�vr�d��|�|<�|�}�||�Ed{������=yy7�[7�B7��w)NrdTreFrfrar])r<rirjrL�_defaultrYrprrrZrtrurvrSrwrxr@rCrXrArDs   �����������������rrZz%_make_iterencode.<locals>._iterencode�s	������a����1�+��
�Y��L�
�$�Y��L�
�%�Z��M�
��3�
��!�*��
��5�
!��A�,��
��D�%�=�
)�'��+@�A�A�A�
��4�
 �'��+@�A�A�A��"��a�5���w�&�$�%B�C�C�$%���!����A�"�1�&;�<�<�<��"��H�%�#�
B��A��
=�s6�A-C�0C�1C�C�4C�C�C�C�Cr])rXr�rYrqrpr�rsr�r�r>rLrvrSrwrxr@rCrArDrrrZrtrus````````` ``````````@@@rrWrWs_�������:�g�s�#;���-��6"�6"�6"�pN"�N"�N"�N"�`&�&�&�:�r)#�re�_jsonr�c_encode_basestring_ascii�ImportErrorr�c_encode_basestringrrV�compilerr&�HAS_UTF8r�range�i�
setdefault�chrr"rSrUrr'�objectr)rLrvrwrxr@rCrArDrTrWr]rr�<module>r�sV���	�%�J��>��4�
����/�	0���r�z�z�,�-���2�:�:�n�%��
�	�
�
�
�
�
��
�
�t��A����#�a�&�,�"5�"5�a�"8�9�
����<��.�)�@�,@��4�.�;�!;��x!�&�x!�z�
��
���
������w��{�%� $��%�����������N��s3�C�C�C(�C�C�C%�$C%�(C2�1C2__pycache__/encoder.cpython-312.pyc000064400000035362151704111340013104 0ustar00�

T��h�>�
���dZddlZ	ddlmZ	ddlmZ	ddlmZ	ejd�Zejd�Zejd�Z
d	d
ddd
ddd�Zed�D])Zej#ee�dj'e���+[ed�Zd�ZexseZd�ZexseZGd�de�Zeeeeeeee e!ejDf
d�Z#y#e$rdZY��wxYw#e$rdZY��wxYw#e$rdZ	Y��wxYw)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)�\�"���
�
�	� �	\u{0:04x}�infc�@�d�}dtj||�zdzS)z5Return a JSON representation of a Python string

    c�2�t|jd�S)Nr)�
ESCAPE_DCT�group)�matchs �%/usr/lib64/python3.12/json/encoder.py�replacez%py_encode_basestring.<locals>.replace)s���%�+�+�a�.�)�)�r)�ESCAPE�sub��srs  r�py_encode_basestringr%s"��*�����G�Q�'�'�#�-�-rc�@�d�}dtj||�zdzS)zAReturn an ASCII-only JSON representation of a Python string

    c���|jd�}	t|S#t$rPt|�}|dkrdj	|�cYS|dz}d|dz	dzz}d|dzz}dj	||�cYSwxYw)	Nriri��
i�i�z\u{0:04x}\u{1:04x})rr�KeyError�ord�format)rr�n�s1�s2s     rrz+py_encode_basestring_ascii.<locals>.replace5s����K�K��N��	=��a�=� ���
	=��A��A��7�{�#�*�*�1�-�-��W�����R��5�0�1���q�5�y�)��-�4�4�R��<�<�
	=�s��*A5�*A5�4A5r)�ESCAPE_ASCIIrrs  r�py_encode_basestring_asciir'1s&��=���!�!�'�1�-�-��3�3rc	�F�eZdZdZdZdZddddddddd�d�Zd	�Zd
�Zdd�Z	y)
�JSONEncodera[Extensible JSON <https://json.org> encoder for Python data structures.

    Supports the following objects and types by default:

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

    To extend this to recognize other objects, subclass and implement a
    ``.default()`` method with another method that returns a serializable
    object for ``o`` if possible, otherwise it should call the superclass
    implementation (to raise ``TypeError``).

    z, z: FTN)�skipkeys�ensure_ascii�check_circular�	allow_nan�	sort_keys�indent�
separators�defaultc��||_||_||_||_||_||_|�|\|_|_n	|�d|_|�||_yy)a�Constructor for JSONEncoder, with sensible defaults.

        If skipkeys is false, then it is a TypeError to attempt
        encoding of keys that are not str, int, float, bool 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 RecursionError).
        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_separatorr1)	�selfr*r+r,r-r.r/r0r1s	         r�__init__zJSONEncoder.__init__isg��V!��
�(���,���"���"�������!�6@�3�D���!3�
�
�"%�D����"�D�L�rc�H�td|jj�d���)abImplement 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 super().default(o)

        zObject of type z is not JSON serializable)�	TypeError�	__class__�__name__)r6�os  rr1zJSONEncoder.default�s-��&�/�!�+�+�*>�*>�)?�@3�4�5�	5rc���t|t�r"|jrt|�St	|�S|j|d��}t|ttf�st
|�}dj|�S)z�Return a JSON string representation of a Python data structure.

        >>> from json.encoder import JSONEncoder
        >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
        '{"foo": ["bar", "baz"]}'

        T)�	_one_shot�)	�
isinstance�strr+rr�
iterencode�list�tuple�join)r6r<�chunkss   r�encodezJSONEncoder.encode�sf���a���� � �.�q�1�1�(��+�+�����d��3���&�4��-�0��&�\�F��w�w�v��rc�6�|jri}nd}|jrt}nt}|jt
jttfd�}|rlt�f|j�Zt||j||j|j|j|j|j|j�	}nPt||j||j||j|j|j|j|�
}||d�S)z�Encode the given object and yield each string
        representation as available.

        For example::

            for chunk in JSONEncoder().iterencode(bigobject):
                mysocket.write(chunk)

        Nc�x�||k7rd}n||k(rd}n||k(rd}n||�S|stdt|�z��|S)N�NaN�Infinityz	-Infinityz2Out of range float values are not JSON compliant: )�
ValueError�repr)r<r-�_repr�_inf�_neginf�texts      r�floatstrz(JSONEncoder.iterencode.<locals>.floatstr�sW���A�v����d��!���g��"���Q�x��� �H���G�����Krr)r,r+rrr-�float�__repr__�INFINITY�c_make_encoderr/r1r5r4r.r*�_make_iterencode)r6r<r>�markers�_encoderrR�_iterencodes       rrBzJSONEncoder.iterencode�s�������G��G����.�H�(�H�"&�.�.��n�n�8�h�Y�	�.
�.�4��K�K�'�(�����x�����"�"�D�$7�$7�����
�
�t�~�~�/�K�
+�����x����h��"�"�D�$7�$7�����
�
�y�*�K��1�a� � r)F)
r;�
__module__�__qualname__�__doc__r4r5r7r1rGrB�rrr)r)Js;���8�N��M�#(�t��4�5��D�$�6#�p5�,�,5!rr)c������������
���
����������������sd�z��
�����������
������fd���
��������������
������fd���
����������
������fd���S)N� c3�8�K�|sd��y���|�}|�vr�	d��|�|<d}��|dz
}d�|zz}�|z}||z
}nd}�}d}|D]�}|rd}n|}�|��r|�
|�z���!|�|dz���+|dur|d	z���7|dur|d
z���C�|��r|�
|�z���Z�|��r|�|�z���q|���|��f�r
�||�}n�|��r
�||�}n	�||�}|Ed{�����|�|dz}d�|zz��d�����=yy7�"�w)Nz[]�Circular reference detected�[�r
TF�null�true�false�]r^)�lst�_current_indent_level�markerid�buf�newline_indent�	separator�first�valuerFrLrY�	_floatstr�_indent�_intstr�_item_separatorrZ�_iterencode_dict�_iterencode_list�dictrS�id�intr@rCrXrArDs         ������������������rrvz*_make_iterencode.<locals>._iterencode_lists��������J�����#�w�H��7�"� �!>�?�?� #�G�H������!�Q�&�!�!�G�.C�$C�C�N�'�.�8�I��>�!�C�!�N�'�I����E�������%��%��H�U�O�+�+����F�l�"��$���F�l�"��%���G�m�#��E�3�'��G�E�N�*�*��E�5�)��I�e�,�,�,��	��e�d�E�]�3�-�e�5J�K�F���t�,�-�e�5J�K�F�(��0E�F�F�!�!�!�;�<�%�!�Q�&�!���#8�8�8�8��	�����!��"�s�C2D�5D�6#Dc3�\�K�|sd��y���|�}|�vr�
d��|�|<d���
�|dz
}d�
|zz}�|z}|��nd}�}d}�rt|j��}n|j�}|D�]\}}�|��rn\�|��r	�|�}nJ|durd}nC|durd	}n<|�d
}n7�|��r	�|�}n%�r�Ktd|jj����|rd}n|���|�������|��r�|�����|�d
����|durd����|durd	�����|��r�|������|��r�|������|��f�r
�||�}	n�|��r
�||�}	n	�||�}	|	Ed{�����|�|dz}d�
|zz��d�����=yy7�#�w)
Nz{}rb�{rdr
TrfFrgrez0keys must be str, int, float, bool or None, not �})�sorted�itemsr9r:r;)�dctrjrkrmr4ror~�keyrprFrLrYrqrrrsrtrZrurv�_key_separator�	_skipkeys�
_sort_keysrwrSrxryr@rCrXrArDs          ���������������������rruz*_make_iterencode.<locals>._iterencode_dictNs?�������J�����#�w�H��7�"� �!>�?�?� #�G�H���	���!�Q�&�!�!�G�.C�$C�C�N�,�~�=�N� � �!�N�,�N�����3�9�9�;�'�E��I�I�K�E��J�C���#�s�#���C��'���n�����������������C��%��c�l�����#'�'*�}�}�'=�'=�&>�!@�A�A����$�$��3�-�� � ��%��%��u�o�%������$�����%���
��E�3�'��e�n�$��E�5�)���&�&��e�d�E�]�3�-�e�5J�K�F���t�,�-�e�5J�K�F�(��0E�F�F�!�!�!�c �d�%�!�Q�&�!���#8�8�8�8��	�����!��"�s�FF,�F*�$F,c3��K��|��r�|���y|�d��y|durd��y|durd��y�|��r�|���y�|��r�|���y�|��f�r�
||�Ed{���y�|��r�	||�Ed{���y���
|�}|�vr�d��|�|<�|�}�||�Ed{������=yy7�[7�B7��w)NreTrfFrgrbr^)r<rjrkrL�_defaultrYrqrsrZrurvrwrSrxryr@rCrXrArDs   �����������������rrZz%_make_iterencode.<locals>._iterencode�s	������a����1�+��
�Y��L�
�$�Y��L�
�%�Z��M�
��3�
��!�*��
��5�
!��A�,��
��D�%�=�
)�'��+@�A�A�A�
��4�
 �'��+@�A�A�A��"��a�5���w�&�$�%B�C�C�$%���!����A�"�1�&;�<�<�<��"��H�%�#�
B��A��
=�s6�A-C�0C�1C�C�4C�C�C�C�Cr^)rXr�rYrrrqr�rtr�r�r>rLrwrSrxryr@rCrArDrsrZrurvs````````` ``````````@@@rrWrWs_�������:�g�s�#;���-��6"�6"�6"�pN"�N"�N"�N"�`&�&�&�:�r)$r]�re�_jsonr�c_encode_basestring_ascii�ImportErrorr�c_encode_basestringrrV�compilerr&�HAS_UTF8r�range�i�
setdefault�chrr"rSrUrr'�objectr)rLrwrxryr@rCrArDrTrWr^rr�<module>r�sV���	�%�J��>��4�
����/�	0���r�z�z�,�-���2�:�:�n�%��
�	�
�
�
�
�
��
�
�t��A����#�a�&�,�"5�"5�a�"8�9�
����<��.�)�@�,@��4�.�;�!;��x!�&�x!�z�
��
���
������w��{�%� $��%�����������N��s3�C�C�C)�C�C�C&�%C&�)C3�2C3__pycache__/scanner.cpython-312.opt-1.pyc000064400000006404151704111340014050 0ustar00�

T��h�	���dZddlZ	ddlmZdgZejdejejzejz�Zd�ZexseZy#e$rdZY�MwxYw)zJSON token scanner
�N)�make_scannerrz2(-?(?:0|[1-9][0-9]*))(\.[0-9]+)?([eE][-+]?[0-9]+)?c�Z��������	�
���
�|j�|j�|j�tj�|j
�
|j�	|j�
|j�|j�|j�|j���������	�
���
fd����fd�}|S)Nc���	||}|dk(r
�||dz��S|dk(r�||dzf�����
�S|dk(r�
||dzf��S|dk(r|||dzdk(rd|dzfS|dk(r|||dzd	k(rd
|dzfS|dk(r|||dzd
k(rd|dzfS�	||�}|�I|j�\}}}|s|r�||xsdz|xsdz�}n�|�}||j�fS|dk(r|||dzdk(r
�d�|dzfS|dk(r|||dzdk(r
�d�|dzfS|dk(r|||dzdk(r
�d�|dzfSt|��#t$r
t|�d�wxYw)N�"��{�[�n��null�t�trueT�f��falseF��N��NaN�I��Infinity�-�	z	-Infinity)�
IndexError�
StopIteration�groups�end)�string�idx�nextchar�m�integer�frac�exp�res�
_scan_once�match_number�memo�object_hook�object_pairs_hook�parse_array�parse_constant�parse_float�	parse_int�parse_object�parse_string�stricts        �������������%/usr/lib64/python3.12/json/scanner.pyr'z#py_make_scanner.<locals>._scan_onces����	/��c�{�H��s�?����a���8�8�
��_����q�� 1�6��K�):�D�B�
B�
��_����a��0�*�=�=�
��_���C�!�G�!4��!>���q��=� �
��_���C�!�G�!4��!>���q��=� �
��_���C�!�G�!4��!?��#��'�>�!����%���=�!"�����G�T�3��s�!�'�T�Z�R�"8�C�I�2�"F�G����(�������<��
��_���C�!�G�!4��!=�!�%�(�#��'�1�1�
��_���C�!�G�!4�
�!B�!�*�-�s�Q�w�6�6�
��_���C�!�G�!4��!C�!�+�.��a��7�7���$�$��A�	/���$�$�.�	/�s�D?�?Ec�b��	�||��j�S#�j�wxYw)N)�clear)rr r'r)s  ��r3�	scan_oncez"py_make_scanner.<locals>.scan_onceAs%���	��f�c�*��J�J�L��D�J�J�L�s��.)r0r,r1�	NUMBER_RE�matchr2r.r/r-r*r+r))�contextr6r'r(r)r*r+r,r-r.r/r0r1r2s  @@@@@@@@@@@@r3�py_make_scannerr:s������'�'�L��%�%�K��'�'�L��?�?�L�
�^�^�F��%�%�K��!�!�I��+�+�N��%�%�K��1�1���<�<�D�#%�#%�J���)
�__doc__�re�_jsonr�c_make_scanner�ImportError�__all__�compile�VERBOSE�	MULTILINE�DOTALLr7r:�r;r3�<module>rGst���	��4��
���B�J�J�9��Z�Z�"�,�,�����*�
-�	�8�t�0����G���N��s�A�A�A__pycache__/scanner.cpython-312.opt-2.pyc000064400000006344151704111340014054 0ustar00�

T��h�	���	ddlZ	ddlmZdgZejdejejzejz�Z
d�ZexseZy#e$rdZY�MwxYw)�N)�make_scannerrz2(-?(?:0|[1-9][0-9]*))(\.[0-9]+)?([eE][-+]?[0-9]+)?c�Z��������	�
���
�|j�|j�|j�tj�|j
�
|j�	|j�
|j�|j�|j�|j���������	�
���
fd����fd�}|S)Nc���	||}|dk(r
�||dz��S|dk(r�||dzf�����
�S|dk(r�
||dzf��S|dk(r|||dzdk(rd|dzfS|dk(r|||dzd	k(rd
|dzfS|dk(r|||dzd
k(rd|dzfS�	||�}|�I|j�\}}}|s|r�||xsdz|xsdz�}n�|�}||j�fS|dk(r|||dzdk(r
�d�|dzfS|dk(r|||dzdk(r
�d�|dzfS|dk(r|||dzdk(r
�d�|dzfSt|��#t$r
t|�d�wxYw)N�"��{�[�n��null�t�trueT�f��falseF��N��NaN�I��Infinity�-�	z	-Infinity)�
IndexError�
StopIteration�groups�end)�string�idx�nextchar�m�integer�frac�exp�res�
_scan_once�match_number�memo�object_hook�object_pairs_hook�parse_array�parse_constant�parse_float�	parse_int�parse_object�parse_string�stricts        �������������%/usr/lib64/python3.12/json/scanner.pyr'z#py_make_scanner.<locals>._scan_onces����	/��c�{�H��s�?����a���8�8�
��_����q�� 1�6��K�):�D�B�
B�
��_����a��0�*�=�=�
��_���C�!�G�!4��!>���q��=� �
��_���C�!�G�!4��!>���q��=� �
��_���C�!�G�!4��!?��#��'�>�!����%���=�!"�����G�T�3��s�!�'�T�Z�R�"8�C�I�2�"F�G����(�������<��
��_���C�!�G�!4��!=�!�%�(�#��'�1�1�
��_���C�!�G�!4�
�!B�!�*�-�s�Q�w�6�6�
��_���C�!�G�!4��!C�!�+�.��a��7�7���$�$��A�	/���$�$�.�	/�s�D?�?Ec�b��	�||��j�S#�j�wxYw)N)�clear)rr r'r)s  ��r3�	scan_oncez"py_make_scanner.<locals>.scan_onceAs%���	��f�c�*��J�J�L��D�J�J�L�s��.)r0r,r1�	NUMBER_RE�matchr2r.r/r-r*r+r))�contextr6r'r(r)r*r+r,r-r.r/r0r1r2s  @@@@@@@@@@@@r3�py_make_scannerr:s������'�'�L��%�%�K��'�'�L��?�?�L�
�^�^�F��%�%�K��!�!�I��+�+�N��%�%�K��1�1���<�<�D�#%�#%�J���)�re�_jsonr�c_make_scanner�ImportError�__all__�compile�VERBOSE�	MULTILINE�DOTALLr7r:�r;r3�<module>rFst���	��4��
���B�J�J�9��Z�Z�"�,�,�����*�
-�	�8�t�0����G���N��s�A�A�A__pycache__/scanner.cpython-312.pyc000064400000006404151704111340013111 0ustar00�

T��h�	���dZddlZ	ddlmZdgZejdejejzejz�Zd�ZexseZy#e$rdZY�MwxYw)zJSON token scanner
�N)�make_scannerrz2(-?(?:0|[1-9][0-9]*))(\.[0-9]+)?([eE][-+]?[0-9]+)?c�Z��������	�
���
�|j�|j�|j�tj�|j
�
|j�	|j�
|j�|j�|j�|j���������	�
���
fd����fd�}|S)Nc���	||}|dk(r
�||dz��S|dk(r�||dzf�����
�S|dk(r�
||dzf��S|dk(r|||dzdk(rd|dzfS|dk(r|||dzd	k(rd
|dzfS|dk(r|||dzd
k(rd|dzfS�	||�}|�I|j�\}}}|s|r�||xsdz|xsdz�}n�|�}||j�fS|dk(r|||dzdk(r
�d�|dzfS|dk(r|||dzdk(r
�d�|dzfS|dk(r|||dzdk(r
�d�|dzfSt|��#t$r
t|�d�wxYw)N�"��{�[�n��null�t�trueT�f��falseF��N��NaN�I��Infinity�-�	z	-Infinity)�
IndexError�
StopIteration�groups�end)�string�idx�nextchar�m�integer�frac�exp�res�
_scan_once�match_number�memo�object_hook�object_pairs_hook�parse_array�parse_constant�parse_float�	parse_int�parse_object�parse_string�stricts        �������������%/usr/lib64/python3.12/json/scanner.pyr'z#py_make_scanner.<locals>._scan_onces����	/��c�{�H��s�?����a���8�8�
��_����q�� 1�6��K�):�D�B�
B�
��_����a��0�*�=�=�
��_���C�!�G�!4��!>���q��=� �
��_���C�!�G�!4��!>���q��=� �
��_���C�!�G�!4��!?��#��'�>�!����%���=�!"�����G�T�3��s�!�'�T�Z�R�"8�C�I�2�"F�G����(�������<��
��_���C�!�G�!4��!=�!�%�(�#��'�1�1�
��_���C�!�G�!4�
�!B�!�*�-�s�Q�w�6�6�
��_���C�!�G�!4��!C�!�+�.��a��7�7���$�$��A�	/���$�$�.�	/�s�D?�?Ec�b��	�||��j�S#�j�wxYw)N)�clear)rr r'r)s  ��r3�	scan_oncez"py_make_scanner.<locals>.scan_onceAs%���	��f�c�*��J�J�L��D�J�J�L�s��.)r0r,r1�	NUMBER_RE�matchr2r.r/r-r*r+r))�contextr6r'r(r)r*r+r,r-r.r/r0r1r2s  @@@@@@@@@@@@r3�py_make_scannerr:s������'�'�L��%�%�K��'�'�L��?�?�L�
�^�^�F��%�%�K��!�!�I��+�+�N��%�%�K��1�1���<�<�D�#%�#%�J���)
�__doc__�re�_jsonr�c_make_scanner�ImportError�__all__�compile�VERBOSE�	MULTILINE�DOTALLr7r:�r;r3�<module>rGst���	��4��
���B�J�J�9��Z�Z�"�,�,�����*�
-�	�8�t�0����G���N��s�A�A�A__pycache__/tool.cpython-312.opt-1.pyc000064400000010271151704111340013371 0ustar00�

T��h
���dZddlZddlZddlZddlmZd�Zedk(r		e�yy#e$r&Z	eje	j�YdZ	[	ydZ	[	wwxYw)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)

�N)�Pathc��d}d}tj||��}|jddtjd��dtj
�	�|jd
dtdd�	�|jdd
dd��|jdddd��|jdd
dd��|j�}|jddtd��|jddddd �!�|jd"dddd#�!�|jd$d
d%�&�|j�}|j|j|jd'�}|jr
d|d<d(|d)<|j5}	|jr
d*�|D�}nt!j"|�f}|j$�tj&}n|j$j)d+d��}|5}	|D]*}
t!j*|
|	fi|��|	j-d,��,	ddd�ddd�y#1swY�xYw#t.$r}t1|��d}~wwxYw#1swYyxYw)-Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)�prog�description�infile�?zutf-8)�encodingz-a JSON file to be validated or pretty-printed)�nargs�type�help�default�outfilez%write the output of infile to outfilez--sort-keys�
store_trueFz5sort the output of dictionaries alphabetically by key)�actionr
rz--no-ensure-ascii�ensure_ascii�store_falsez(disable escaping of non-ASCII characters)�destrrz--json-linesznparse input using the JSON Lines format. Use with --no-indent or --compact to produce valid JSON Lines output.z--indent�zJseparate items with newlines and use this number of spaces for indentation)r
rrz--tab�store_const�indent�	z9separate items with newlines and use tabs for indentation)rr�constrz--no-indentz/separate items with spaces rather than newlinesz	--compactz1suppress all whitespace separation (most compact))rr)�	sort_keysrr)�,�:�
separatorsc3�FK�|]}tj|����y�w)N)�json�loads)�.0�lines  �"/usr/lib64/python3.12/json/tool.py�	<genexpr>zmain.<locals>.<genexpr>As����<�V�T��
�
�4�(�V�s�!�w�
)�argparse�ArgumentParser�add_argument�FileType�sys�stdinr�add_mutually_exclusive_group�int�
parse_argsrrr�compactr�
json_linesr�loadr�stdout�open�dump�write�
ValueError�
SystemExit)rr�parser�group�options�	dump_argsr�objs�outr�obj�es            r"�mainr@so�� �D�@�K�
�
$�
$�$�K�
H�F�
�����%�.�.��@�L� #�	�	��+����	��!�D� $��&����
�l�E�T��V�
���+�.��G��I�
����|�U�`��a�
�/�/�1�E�	���z�1�3�3��4�
���w�}�8�!�).��/�
���}�]��!�M��O�
���{�<�O��Q����!�G��&�&��.�.��,�,��I�
���"�	�(��"*�	�,��	���6�	 ��!�!�<�V�<���	�	�&�)�+�����&��j�j���o�o�*�*�3��*�A�����C��I�I�c�7�8�i�8��M�M�$�'� ��
������	 ��Q�-���	 ��
��sC�,I�.A(H$�0H�H$�H!	�H$�$	H=�-H8�8H=�=I�I	�__main__)�__doc__r&rr*�pathlibrr@�__name__�BrokenPipeError�exc�exit�errno��r"�<module>rKs^�����
��; �|�z��������������������s�'�A�A
�
A__pycache__/tool.cpython-312.opt-2.pyc000064400000007630151704111340013377 0ustar00�

T��h
���	ddlZddlZddlZddlmZd�Zedk(r		e�yy#e$r&Zejej�YdZ[ydZ[wwxYw)�N)�Pathc��d}d}tj||��}|jddtjd��dtj
�	�|jd
dtdd�	�|jdd
dd��|jdddd��|jdd
dd��|j�}|jddtd��|jddddd �!�|jd"dddd#�!�|jd$d
d%�&�|j�}|j|j|jd'�}|jr
d|d<d(|d)<|j5}	|jr
d*�|D�}nt!j"|�f}|j$�tj&}n|j$j)d+d��}|5}	|D]*}
t!j*|
|	fi|��|	j-d,��,	ddd�ddd�y#1swY�xYw#t.$r}t1|��d}~wwxYw#1swYyxYw)-Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)�prog�description�infile�?zutf-8)�encodingz-a JSON file to be validated or pretty-printed)�nargs�type�help�default�outfilez%write the output of infile to outfilez--sort-keys�
store_trueFz5sort the output of dictionaries alphabetically by key)�actionr
rz--no-ensure-ascii�ensure_ascii�store_falsez(disable escaping of non-ASCII characters)�destrrz--json-linesznparse input using the JSON Lines format. Use with --no-indent or --compact to produce valid JSON Lines output.z--indent�zJseparate items with newlines and use this number of spaces for indentation)r
rrz--tab�store_const�indent�	z9separate items with newlines and use tabs for indentation)rr�constrz--no-indentz/separate items with spaces rather than newlinesz	--compactz1suppress all whitespace separation (most compact))rr)�	sort_keysrr)�,�:�
separatorsc3�FK�|]}tj|����y�w)N)�json�loads)�.0�lines  �"/usr/lib64/python3.12/json/tool.py�	<genexpr>zmain.<locals>.<genexpr>As����<�V�T��
�
�4�(�V�s�!�w�
)�argparse�ArgumentParser�add_argument�FileType�sys�stdinr�add_mutually_exclusive_group�int�
parse_argsrrr�compactr�
json_linesr�loadr�stdout�open�dump�write�
ValueError�
SystemExit)rr�parser�group�options�	dump_argsr�objs�outr�obj�es            r"�mainr@so�� �D�@�K�
�
$�
$�$�K�
H�F�
�����%�.�.��@�L� #�	�	��+����	��!�D� $��&����
�l�E�T��V�
���+�.��G��I�
����|�U�`��a�
�/�/�1�E�	���z�1�3�3��4�
���w�}�8�!�).��/�
���}�]��!�M��O�
���{�<�O��Q����!�G��&�&��.�.��,�,��I�
���"�	�(��"*�	�,��	���6�	 ��!�!�<�V�<���	�	�&�)�+�����&��j�j���o�o�*�*�3��*�A�����C��I�I�c�7�8�i�8��M�M�$�'� ��
������	 ��Q�-���	 ��
��sC�,I�.A(H$�0H�H$�H!	�H$�$	H=�-H8�8H=�=I�I	�__main__)r&rr*�pathlibrr@�__name__�BrokenPipeError�exc�exit�errno��r"�<module>rJs^�����
��; �|�z��������������������s�&�A�A�A__pycache__/tool.cpython-312.pyc000064400000010271151704111340012432 0ustar00�

T��h
���dZddlZddlZddlZddlmZd�Zedk(r		e�yy#e$r&Z	eje	j�YdZ	[	ydZ	[	wwxYw)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)

�N)�Pathc��d}d}tj||��}|jddtjd��dtj
�	�|jd
dtdd�	�|jdd
dd��|jdddd��|jdd
dd��|j�}|jddtd��|jddddd �!�|jd"dddd#�!�|jd$d
d%�&�|j�}|j|j|jd'�}|jr
d|d<d(|d)<|j5}	|jr
d*�|D�}nt!j"|�f}|j$�tj&}n|j$j)d+d��}|5}	|D]*}
t!j*|
|	fi|��|	j-d,��,	ddd�ddd�y#1swY�xYw#t.$r}t1|��d}~wwxYw#1swYyxYw)-Nzpython -m json.toolzZA simple command line interface for json module to validate and pretty-print JSON objects.)�prog�description�infile�?zutf-8)�encodingz-a JSON file to be validated or pretty-printed)�nargs�type�help�default�outfilez%write the output of infile to outfilez--sort-keys�
store_trueFz5sort the output of dictionaries alphabetically by key)�actionr
rz--no-ensure-ascii�ensure_ascii�store_falsez(disable escaping of non-ASCII characters)�destrrz--json-linesznparse input using the JSON Lines format. Use with --no-indent or --compact to produce valid JSON Lines output.z--indent�zJseparate items with newlines and use this number of spaces for indentation)r
rrz--tab�store_const�indent�	z9separate items with newlines and use tabs for indentation)rr�constrz--no-indentz/separate items with spaces rather than newlinesz	--compactz1suppress all whitespace separation (most compact))rr)�	sort_keysrr)�,�:�
separatorsc3�FK�|]}tj|����y�w)N)�json�loads)�.0�lines  �"/usr/lib64/python3.12/json/tool.py�	<genexpr>zmain.<locals>.<genexpr>As����<�V�T��
�
�4�(�V�s�!�w�
)�argparse�ArgumentParser�add_argument�FileType�sys�stdinr�add_mutually_exclusive_group�int�
parse_argsrrr�compactr�
json_linesr�loadr�stdout�open�dump�write�
ValueError�
SystemExit)rr�parser�group�options�	dump_argsr�objs�outr�obj�es            r"�mainr@so�� �D�@�K�
�
$�
$�$�K�
H�F�
�����%�.�.��@�L� #�	�	��+����	��!�D� $��&����
�l�E�T��V�
���+�.��G��I�
����|�U�`��a�
�/�/�1�E�	���z�1�3�3��4�
���w�}�8�!�).��/�
���}�]��!�M��O�
���{�<�O��Q����!�G��&�&��.�.��,�,��I�
���"�	�(��"*�	�,��	���6�	 ��!�!�<�V�<���	�	�&�)�+�����&��j�j���o�o�*�*�3��*�A�����C��I�I�c�7�8�i�8��M�M�$�'� ��
������	 ��Q�-���	 ��
��sC�,I�.A(H$�0H�H$�H!	�H$�$	H=�-H8�8H=�=I�I	�__main__)�__doc__r&rr*�pathlibrr@�__name__�BrokenPipeError�exc�exit�errno��r"�<module>rKs^�����
��; �|�z��������������������s�'�A�A
�
A__init__.py000064400000033304151704111340006655 0ustar00r"""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)
"""
__version__ = '2.0.9'
__all__ = [
    'dump', 'dumps', 'load', 'loads',
    'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',
]

__author__ = 'Bob Ippolito <bob@redivi.com>'

from .decoder import JSONDecoder, JSONDecodeError
from .encoder import JSONEncoder
import codecs

_default_encoder = JSONEncoder(
    skipkeys=False,
    ensure_ascii=True,
    check_circular=True,
    allow_nan=True,
    indent=None,
    separators=None,
    default=None,
)

def dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        default=None, sort_keys=False, **kw):
    """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
    ``.write()``-supporting file-like object).

    If ``skipkeys`` is true then ``dict`` keys that are not basic types
    (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
    instead of raising a ``TypeError``.

    If ``ensure_ascii`` is false, then the strings written to ``fp`` can
    contain non-ASCII characters if they appear in strings contained in
    ``obj``. Otherwise, all such characters are escaped in JSON strings.

    If ``check_circular`` is false, then the circular reference check
    for container types will be skipped and a circular reference will
    result in an ``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.

    """
    # 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 ``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.

    """
    # 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.  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, *, 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.  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.
    """
    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(f'the JSON object must be str, bytes or bytearray, '
                            f'not {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)
decoder.py000064400000030355151704111340006526 0ustar00"""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,
}


HEXDIGITS = re.compile(r'[0-9A-Fa-f]{4}', FLAGS)
STRINGCHUNK = re.compile(r'(.*?)(["\\\x00-\x1f])', FLAGS)
BACKSLASH = {
    '"': '"', '\\': '\\', '/': '/',
    'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t',
}

def _decode_uXXXX(s, pos, _m=HEXDIGITS.match):
    esc = _m(s, pos + 1)
    if esc is not None:
        try:
            return int(esc.group(), 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) from None
        # 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 <https://json.org> decoder

    Performs the following translations in decoding by default:

    +---------------+-------------------+
    | JSON          | Python            |
    +===============+===================+
    | object        | dict              |
    +---------------+-------------------+
    | array         | list              |
    +---------------+-------------------+
    | string        | str               |
    +---------------+-------------------+
    | number (int)  | int               |
    +---------------+-------------------+
    | number (real) | float             |
    +---------------+-------------------+
    | true          | True              |
    +---------------+-------------------+
    | false         | False             |
    +---------------+-------------------+
    | null          | None              |
    +---------------+-------------------+

    It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
    their corresponding ``float`` values, which is outside the JSON spec.

    """

    def __init__(self, *, object_hook=None, parse_float=None,
            parse_int=None, parse_constant=None, strict=True,
            object_pairs_hook=None):
        """``object_hook``, if specified, will be called with the result
        of every JSON object decoded and its return value will be used in
        place of the given ``dict``.  This can be used to provide custom
        deserializations (e.g. to support JSON-RPC class hinting).

        ``object_pairs_hook``, if specified will be called with the result of
        every JSON object decoded with an ordered list of pairs.  The return
        value of ``object_pairs_hook`` will be used instead of the ``dict``.
        This feature can be used to implement custom decoders.
        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
encoder.py000064400000037313151704111340006541 0ustar00"""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,))
del 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 <https://json.org> encoder for Python data structures.

    Supports the following objects and types by default:

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

    To extend this to recognize other objects, subclass and implement a
    ``.default()`` method with another method that returns a serializable
    object for ``o`` if possible, otherwise it should call the superclass
    implementation (to raise ``TypeError``).

    """
    item_separator = ', '
    key_separator = ': '
    def __init__(self, *, skipkeys=False, ensure_ascii=True,
            check_circular=True, allow_nan=True, sort_keys=False,
            indent=None, separators=None, default=None):
        """Constructor for JSONEncoder, with sensible defaults.

        If skipkeys is false, then it is a TypeError to attempt
        encoding of keys that are not str, int, float, bool 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 RecursionError).
        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 super().default(o)

        """
        raise TypeError(f'Object of type {o.__class__.__name__} '
                        f'is not JSON serializable')

    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.__repr__,
    ):

    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 __repr__, 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())
        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(f'keys must be str, int, float, bool or None, '
                                f'not {key.__class__.__name__}')
            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
scanner.py000064400000004602151704111340006546 0ustar00"""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][0-9]*))(\.[0-9]+)?([eE][-+]?[0-9]+)?',
    (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) from None

        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
tool.py000064400000006413151704111340006074 0ustar00r"""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 json
import sys
from pathlib import Path


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(encoding="utf-8"),
                        help='a JSON file to be validated or pretty-printed',
                        default=sys.stdin)
    parser.add_argument('outfile', nargs='?',
                        type=Path,
                        help='write the output of infile to outfile',
                        default=None)
    parser.add_argument('--sort-keys', action='store_true', default=False,
                        help='sort the output of dictionaries alphabetically by key')
    parser.add_argument('--no-ensure-ascii', dest='ensure_ascii', action='store_false',
                        help='disable escaping of non-ASCII characters')
    parser.add_argument('--json-lines', action='store_true', default=False,
                        help='parse input using the JSON Lines format. '
                        'Use with --no-indent or --compact to produce valid JSON Lines output.')
    group = parser.add_mutually_exclusive_group()
    group.add_argument('--indent', default=4, type=int,
                       help='separate items with newlines and use this number '
                       'of spaces for indentation')
    group.add_argument('--tab', action='store_const', dest='indent',
                       const='\t', help='separate items with newlines and use '
                       'tabs for indentation')
    group.add_argument('--no-indent', action='store_const', dest='indent',
                       const=None,
                       help='separate items with spaces rather than newlines')
    group.add_argument('--compact', action='store_true',
                       help='suppress all whitespace separation (most compact)')
    options = parser.parse_args()

    dump_args = {
        'sort_keys': options.sort_keys,
        'indent': options.indent,
        'ensure_ascii': options.ensure_ascii,
    }
    if options.compact:
        dump_args['indent'] = None
        dump_args['separators'] = ',', ':'

    with options.infile as infile:
        try:
            if options.json_lines:
                objs = (json.loads(line) for line in infile)
            else:
                objs = (json.load(infile),)

            if options.outfile is None:
                out = sys.stdout
            else:
                out = options.outfile.open('w', encoding='utf-8')
            with out as outfile:
                for obj in objs:
                    json.dump(obj, outfile, **dump_args)
                    outfile.write('\n')
        except ValueError as e:
            raise SystemExit(e)


if __name__ == '__main__':
    try:
        main()
    except BrokenPipeError as exc:
        sys.exit(exc.errno)