code: 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)
  
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 1 for calling a global function with example usage: dump(obj, fp) without return types