code: 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)
  
file_path: catboost/contrib/tools/python3/src/Lib/json/__init__.py
imports: from .decoder import JSONDecoder, JSONDecodeError
  from .encoder import JSONEncoder
  import codecs
label_desc: Use image node_id 5 for calling a global function with example usage: loads(s) and returns: cls, _default_decoder