Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

5 files changed, 1255 insertions, 1255 deletions

diff --git a/contrib/tools/python3/src/Lib/json/__init__.py b/contrib/tools/python3/src/Lib/json/__init__.py
index 6f14bdd90e3..e4c21daaf3e 100644
--- a/contrib/tools/python3/src/Lib/json/__init__.py
+++ b/contrib/tools/python3/src/Lib/json/__init__.py
@@ -1,359 +1,359 @@
-r"""JSON (JavaScript Object Notation) <http://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 <[email protected]>' 
- 
-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 
+r"""JSON (JavaScript Object Notation) <http://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 <[email protected]>'
+
+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 
+
+    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) 
- 
- 
+
+    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) 
+        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)
diff --git a/contrib/tools/python3/src/Lib/json/decoder.py b/contrib/tools/python3/src/Lib/json/decoder.py
index de147e58cc3..d7d824454e1 100644
--- a/contrib/tools/python3/src/Lib/json/decoder.py
+++ b/contrib/tools/python3/src/Lib/json/decoder.py
@@ -1,356 +1,356 @@
-"""Implementation of JSONDecoder 
-""" 
-import re 
- 
-from json import scanner 
-try: 
-    from _json import scanstring as c_scanstring 
-except ImportError: 
-    c_scanstring = None 
- 
-__all__ = ['JSONDecoder', 'JSONDecodeError'] 
- 
-FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL 
- 
-NaN = float('nan') 
-PosInf = float('inf') 
-NegInf = float('-inf') 
- 
- 
-class JSONDecodeError(ValueError): 
-    """Subclass of ValueError with the following additional properties: 
- 
-    msg: The unformatted error message 
-    doc: The JSON document being parsed 
-    pos: The start index of doc where parsing failed 
-    lineno: The line corresponding to pos 
-    colno: The column corresponding to pos 
- 
-    """ 
-    # Note that this exception is used from _json 
-    def __init__(self, msg, doc, pos): 
-        lineno = doc.count('\n', 0, pos) + 1 
-        colno = pos - doc.rfind('\n', 0, pos) 
-        errmsg = '%s: line %d column %d (char %d)' % (msg, lineno, colno, pos) 
-        ValueError.__init__(self, errmsg) 
-        self.msg = msg 
-        self.doc = doc 
-        self.pos = pos 
-        self.lineno = lineno 
-        self.colno = colno 
- 
-    def __reduce__(self): 
-        return self.__class__, (self.msg, self.doc, self.pos) 
- 
- 
-_CONSTANTS = { 
-    '-Infinity': NegInf, 
-    'Infinity': PosInf, 
-    'NaN': NaN, 
-} 
- 
- 
-STRINGCHUNK = re.compile(r'(.*?)(["\\\x00-\x1f])', FLAGS) 
-BACKSLASH = { 
-    '"': '"', '\\': '\\', '/': '/', 
-    'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t', 
-} 
- 
-def _decode_uXXXX(s, pos): 
-    esc = s[pos + 1:pos + 5] 
-    if len(esc) == 4 and esc[1] not in 'xX': 
-        try: 
-            return int(esc, 16) 
-        except ValueError: 
-            pass 
-    msg = "Invalid \\uXXXX escape" 
-    raise JSONDecodeError(msg, s, pos) 
- 
-def py_scanstring(s, end, strict=True, 
-        _b=BACKSLASH, _m=STRINGCHUNK.match): 
-    """Scan the string s for a JSON string. End is the index of the 
-    character in s after the quote that started the JSON string. 
-    Unescapes all valid JSON string escape sequences and raises ValueError 
-    on attempt to decode an invalid string. If strict is False then literal 
-    control characters are allowed in the string. 
- 
-    Returns a tuple of the decoded string and the index of the character in s 
-    after the end quote.""" 
-    chunks = [] 
-    _append = chunks.append 
-    begin = end - 1 
-    while 1: 
-        chunk = _m(s, end) 
-        if chunk is None: 
-            raise JSONDecodeError("Unterminated string starting at", s, begin) 
-        end = chunk.end() 
-        content, terminator = chunk.groups() 
-        # Content is contains zero or more unescaped string characters 
-        if content: 
-            _append(content) 
-        # Terminator is the end of string, a literal control character, 
-        # or a backslash denoting that an escape sequence follows 
-        if terminator == '"': 
-            break 
-        elif terminator != '\\': 
-            if strict: 
-                #msg = "Invalid control character %r at" % (terminator,) 
-                msg = "Invalid control character {0!r} at".format(terminator) 
-                raise JSONDecodeError(msg, s, end) 
-            else: 
-                _append(terminator) 
-                continue 
-        try: 
-            esc = s[end] 
-        except IndexError: 
-            raise JSONDecodeError("Unterminated string starting at", 
-                                  s, begin) 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 <http://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 
+"""Implementation of JSONDecoder
+"""
+import re
+
+from json import scanner
+try:
+    from _json import scanstring as c_scanstring
+except ImportError:
+    c_scanstring = None
+
+__all__ = ['JSONDecoder', 'JSONDecodeError']
+
+FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL
+
+NaN = float('nan')
+PosInf = float('inf')
+NegInf = float('-inf')
+
+
+class JSONDecodeError(ValueError):
+    """Subclass of ValueError with the following additional properties:
+
+    msg: The unformatted error message
+    doc: The JSON document being parsed
+    pos: The start index of doc where parsing failed
+    lineno: The line corresponding to pos
+    colno: The column corresponding to pos
+
+    """
+    # Note that this exception is used from _json
+    def __init__(self, msg, doc, pos):
+        lineno = doc.count('\n', 0, pos) + 1
+        colno = pos - doc.rfind('\n', 0, pos)
+        errmsg = '%s: line %d column %d (char %d)' % (msg, lineno, colno, pos)
+        ValueError.__init__(self, errmsg)
+        self.msg = msg
+        self.doc = doc
+        self.pos = pos
+        self.lineno = lineno
+        self.colno = colno
+
+    def __reduce__(self):
+        return self.__class__, (self.msg, self.doc, self.pos)
+
+
+_CONSTANTS = {
+    '-Infinity': NegInf,
+    'Infinity': PosInf,
+    'NaN': NaN,
+}
+
+
+STRINGCHUNK = re.compile(r'(.*?)(["\\\x00-\x1f])', FLAGS)
+BACKSLASH = {
+    '"': '"', '\\': '\\', '/': '/',
+    'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t',
+}
+
+def _decode_uXXXX(s, pos):
+    esc = s[pos + 1:pos + 5]
+    if len(esc) == 4 and esc[1] not in 'xX':
+        try:
+            return int(esc, 16)
+        except ValueError:
+            pass
+    msg = "Invalid \\uXXXX escape"
+    raise JSONDecodeError(msg, s, pos)
+
+def py_scanstring(s, end, strict=True,
+        _b=BACKSLASH, _m=STRINGCHUNK.match):
+    """Scan the string s for a JSON string. End is the index of the
+    character in s after the quote that started the JSON string.
+    Unescapes all valid JSON string escape sequences and raises ValueError
+    on attempt to decode an invalid string. If strict is False then literal
+    control characters are allowed in the string.
+
+    Returns a tuple of the decoded string and the index of the character in s
+    after the end quote."""
+    chunks = []
+    _append = chunks.append
+    begin = end - 1
+    while 1:
+        chunk = _m(s, end)
+        if chunk is None:
+            raise JSONDecodeError("Unterminated string starting at", s, begin)
+        end = chunk.end()
+        content, terminator = chunk.groups()
+        # Content is contains zero or more unescaped string characters
+        if content:
+            _append(content)
+        # Terminator is the end of string, a literal control character,
+        # or a backslash denoting that an escape sequence follows
+        if terminator == '"':
+            break
+        elif terminator != '\\':
+            if strict:
+                #msg = "Invalid control character %r at" % (terminator,)
+                msg = "Invalid control character {0!r} at".format(terminator)
+                raise JSONDecodeError(msg, s, end)
+            else:
+                _append(terminator)
+                continue
+        try:
+            esc = s[end]
+        except IndexError:
+            raise JSONDecodeError("Unterminated string starting at",
+                                  s, begin) 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 <http://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
diff --git a/contrib/tools/python3/src/Lib/json/encoder.py b/contrib/tools/python3/src/Lib/json/encoder.py
index aba0c5704b0..21bff2c1a1f 100644
--- a/contrib/tools/python3/src/Lib/json/encoder.py
+++ b/contrib/tools/python3/src/Lib/json/encoder.py
@@ -1,442 +1,442 @@
-"""Implementation of JSONEncoder 
-""" 
-import re 
- 
-try: 
-    from _json import encode_basestring_ascii as c_encode_basestring_ascii 
-except ImportError: 
-    c_encode_basestring_ascii = None 
-try: 
-    from _json import encode_basestring as c_encode_basestring 
-except ImportError: 
-    c_encode_basestring = None 
-try: 
-    from _json import make_encoder as c_make_encoder 
-except ImportError: 
-    c_make_encoder = None 
- 
-ESCAPE = re.compile(r'[\x00-\x1f\\"\b\f\n\r\t]') 
-ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])') 
-HAS_UTF8 = re.compile(b'[\x80-\xff]') 
-ESCAPE_DCT = { 
-    '\\': '\\\\', 
-    '"': '\\"', 
-    '\b': '\\b', 
-    '\f': '\\f', 
-    '\n': '\\n', 
-    '\r': '\\r', 
-    '\t': '\\t', 
-} 
-for i in range(0x20): 
-    ESCAPE_DCT.setdefault(chr(i), '\\u{0:04x}'.format(i)) 
-    #ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,)) 
- 
-INFINITY = float('inf') 
- 
-def py_encode_basestring(s): 
-    """Return a JSON representation of a Python string 
- 
-    """ 
-    def replace(match): 
-        return ESCAPE_DCT[match.group(0)] 
-    return '"' + ESCAPE.sub(replace, s) + '"' 
- 
- 
-encode_basestring = (c_encode_basestring or py_encode_basestring) 
- 
- 
-def py_encode_basestring_ascii(s): 
-    """Return an ASCII-only JSON representation of a Python string 
- 
-    """ 
-    def replace(match): 
-        s = match.group(0) 
-        try: 
-            return ESCAPE_DCT[s] 
-        except KeyError: 
-            n = ord(s) 
-            if n < 0x10000: 
-                return '\\u{0:04x}'.format(n) 
-                #return '\\u%04x' % (n,) 
-            else: 
-                # surrogate pair 
-                n -= 0x10000 
-                s1 = 0xd800 | ((n >> 10) & 0x3ff) 
-                s2 = 0xdc00 | (n & 0x3ff) 
-                return '\\u{0:04x}\\u{1:04x}'.format(s1, s2) 
-    return '"' + ESCAPE_ASCII.sub(replace, s) + '"' 
- 
- 
-encode_basestring_ascii = ( 
-    c_encode_basestring_ascii or py_encode_basestring_ascii) 
- 
-class JSONEncoder(object): 
-    """Extensible JSON <http://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 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 
+"""Implementation of JSONEncoder
+"""
+import re
+
+try:
+    from _json import encode_basestring_ascii as c_encode_basestring_ascii
+except ImportError:
+    c_encode_basestring_ascii = None
+try:
+    from _json import encode_basestring as c_encode_basestring
+except ImportError:
+    c_encode_basestring = None
+try:
+    from _json import make_encoder as c_make_encoder
+except ImportError:
+    c_make_encoder = None
+
+ESCAPE = re.compile(r'[\x00-\x1f\\"\b\f\n\r\t]')
+ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])')
+HAS_UTF8 = re.compile(b'[\x80-\xff]')
+ESCAPE_DCT = {
+    '\\': '\\\\',
+    '"': '\\"',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+}
+for i in range(0x20):
+    ESCAPE_DCT.setdefault(chr(i), '\\u{0:04x}'.format(i))
+    #ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,))
+
+INFINITY = float('inf')
+
+def py_encode_basestring(s):
+    """Return a JSON representation of a Python string
+
+    """
+    def replace(match):
+        return ESCAPE_DCT[match.group(0)]
+    return '"' + ESCAPE.sub(replace, s) + '"'
+
+
+encode_basestring = (c_encode_basestring or py_encode_basestring)
+
+
+def py_encode_basestring_ascii(s):
+    """Return an ASCII-only JSON representation of a Python string
+
+    """
+    def replace(match):
+        s = match.group(0)
+        try:
+            return ESCAPE_DCT[s]
+        except KeyError:
+            n = ord(s)
+            if n < 0x10000:
+                return '\\u{0:04x}'.format(n)
+                #return '\\u%04x' % (n,)
+            else:
+                # surrogate pair
+                n -= 0x10000
+                s1 = 0xd800 | ((n >> 10) & 0x3ff)
+                s2 = 0xdc00 | (n & 0x3ff)
+                return '\\u{0:04x}\\u{1:04x}'.format(s1, s2)
+    return '"' + ESCAPE_ASCII.sub(replace, s) + '"'
+
+
+encode_basestring_ascii = (
+    c_encode_basestring_ascii or py_encode_basestring_ascii)
+
+class JSONEncoder(object):
+    """Extensible JSON <http://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 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 JSONEncoder.default(self, 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, 
+        Otherwise, no such check takes place.
+
+        If allow_nan is true, then NaN, Infinity, and -Infinity will be
+        encoded as such.  This behavior is not JSON specification compliant,
+        but is consistent with most JavaScript based encoders and decoders.
+        Otherwise, it will be a ValueError to encode such floats.
+
+        If sort_keys is true, then the output of dictionaries will be
+        sorted by key; this is useful for regression tests to ensure
+        that JSON serializations can be compared on a day-to-day basis.
+
+        If indent is a non-negative integer, then JSON array
+        elements and object members will be pretty-printed with that
+        indent level.  An indent level of 0 will only insert newlines.
+        None is the most compact representation.
+
+        If specified, separators should be an (item_separator, key_separator)
+        tuple.  The default is (', ', ': ') if *indent* is ``None`` and
+        (',', ': ') otherwise.  To get the most compact JSON representation,
+        you should specify (',', ':') to eliminate whitespace.
+
+        If specified, default is a function that gets called for objects
+        that can't otherwise be serialized.  It should return a JSON encodable
+        version of the object or raise a ``TypeError``.
+
+        """
+
+        self.skipkeys = skipkeys
+        self.ensure_ascii = ensure_ascii
+        self.check_circular = check_circular
+        self.allow_nan = allow_nan
+        self.sort_keys = sort_keys
+        self.indent = indent
+        if separators is not None:
+            self.item_separator, self.key_separator = separators
+        elif indent is not None:
+            self.item_separator = ','
+        if default is not None:
+            self.default = default
+
+    def default(self, o):
+        """Implement this method in a subclass such that it returns
+        a serializable object for ``o``, or calls the base implementation
+        (to raise a ``TypeError``).
+
+        For example, to support arbitrary iterators, you could
+        implement default like this::
+
+            def default(self, o):
+                try:
+                    iterable = iter(o)
+                except TypeError:
+                    pass
+                else:
+                    return list(iterable)
+                # Let the base class default method raise the TypeError
+                return JSONEncoder.default(self, o)
+
+        """
+        raise TypeError(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): 
+    ):
+
+    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: 
+                # 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 
+        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
diff --git a/contrib/tools/python3/src/Lib/json/scanner.py b/contrib/tools/python3/src/Lib/json/scanner.py
index 6fab25ccfa5..7a61cfc2d24 100644
--- a/contrib/tools/python3/src/Lib/json/scanner.py
+++ b/contrib/tools/python3/src/Lib/json/scanner.py
@@ -1,73 +1,73 @@
-"""JSON token scanner 
-""" 
-import re 
-try: 
-    from _json import make_scanner as c_make_scanner 
-except ImportError: 
-    c_make_scanner = None 
- 
-__all__ = ['make_scanner'] 
- 
-NUMBER_RE = re.compile( 
-    r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?', 
-    (re.VERBOSE | re.MULTILINE | re.DOTALL)) 
- 
-def py_make_scanner(context): 
-    parse_object = context.parse_object 
-    parse_array = context.parse_array 
-    parse_string = context.parse_string 
-    match_number = NUMBER_RE.match 
-    strict = context.strict 
-    parse_float = context.parse_float 
-    parse_int = context.parse_int 
-    parse_constant = context.parse_constant 
-    object_hook = context.object_hook 
-    object_pairs_hook = context.object_pairs_hook 
-    memo = context.memo 
- 
-    def _scan_once(string, idx): 
-        try: 
-            nextchar = string[idx] 
-        except IndexError: 
-            raise StopIteration(idx) 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 
+"""JSON token scanner
+"""
+import re
+try:
+    from _json import make_scanner as c_make_scanner
+except ImportError:
+    c_make_scanner = None
+
+__all__ = ['make_scanner']
+
+NUMBER_RE = re.compile(
+    r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?',
+    (re.VERBOSE | re.MULTILINE | re.DOTALL))
+
+def py_make_scanner(context):
+    parse_object = context.parse_object
+    parse_array = context.parse_array
+    parse_string = context.parse_string
+    match_number = NUMBER_RE.match
+    strict = context.strict
+    parse_float = context.parse_float
+    parse_int = context.parse_int
+    parse_constant = context.parse_constant
+    object_hook = context.object_hook
+    object_pairs_hook = context.object_pairs_hook
+    memo = context.memo
+
+    def _scan_once(string, idx):
+        try:
+            nextchar = string[idx]
+        except IndexError:
+            raise StopIteration(idx) 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
diff --git a/contrib/tools/python3/src/Lib/json/tool.py b/contrib/tools/python3/src/Lib/json/tool.py
index 8174c70e536..0490b8c0be1 100644
--- a/contrib/tools/python3/src/Lib/json/tool.py
+++ b/contrib/tools/python3/src/Lib/json/tool.py
@@ -1,26 +1,26 @@
-r"""Command-line tool to validate and pretty-print JSON 
- 
-Usage:: 
- 
-    $ echo '{"json":"obj"}' | python -m json.tool 
-    { 
-        "json": "obj" 
-    } 
-    $ echo '{ 1.2:3.4}' | python -m json.tool 
-    Expecting property name enclosed in double quotes: line 1 column 3 (char 2) 
- 
-""" 
-import argparse 
-import json 
-import sys 
+r"""Command-line tool to validate and pretty-print JSON
+
+Usage::
+
+    $ echo '{"json":"obj"}' | python -m json.tool
+    {
+        "json": "obj"
+    }
+    $ echo '{ 1.2:3.4}' | python -m json.tool
+    Expecting property name enclosed in double quotes: line 1 column 3 (char 2)
+
+"""
+import argparse
+import 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) 
+
+
+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',
@@ -29,8 +29,8 @@ def main():
                         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('--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,
@@ -48,8 +48,8 @@ def main():
                        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() 
- 
+    options = parser.parse_args()
+
     dump_args = {
         'sort_keys': options.sort_keys,
         'indent': options.indent,
@@ -60,7 +60,7 @@ def main():
         dump_args['separators'] = ',', ':'
 
     with options.infile as infile:
-        try: 
+        try:
             if options.json_lines:
                 objs = (json.loads(line) for line in infile)
             else:
@@ -74,11 +74,11 @@ def main():
                 for obj in objs:
                     json.dump(obj, outfile, **dump_args)
                     outfile.write('\n')
-        except ValueError as e: 
-            raise SystemExit(e) 
- 
- 
-if __name__ == '__main__': 
+        except ValueError as e:
+            raise SystemExit(e)
+
+
+if __name__ == '__main__':
     try:
         main()
     except BrokenPipeError as exc: