code: def dump(
      obj,
      fp,
      skipkeys=False,
      ensure_ascii=True,
      check_circular=True,
      allow_nan=True,
      cls=None,
      indent=None,
      separators=None,
      encoding="utf-8",
      default=None,
      use_decimal=True,
      namedtuple_as_object=True,
      tuple_as_array=True,
      bigint_as_string=False,
      sort_keys=False,
      item_sort_key=None,
      for_json=False,
      ignore_nan=False,
      int_as_string_bitcount=None,
      iterable_as_array=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``, ``long``, ``float``, ``bool``, ``None``)
      will be skipped instead of raising a ``TypeError``.
  
      If *ensure_ascii* is false (default: ``True``), then the output may
      contain non-ASCII characters, so long as they do not need to be escaped
      by JSON. When it is true, all non-ASCII characters are escaped.
  
      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 original JSON specification, instead of using
      the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). See
      *ignore_nan* for ECMA-262 compliant behavior.
  
      If *indent* is a string, then JSON array elements and object members
      will be pretty-printed with a newline followed by that string repeated
      for each level of nesting. ``None`` (the default) selects the most compact
      representation without any newlines.
  
      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.
  
      *encoding* is the character encoding for str instances, default is UTF-8.
  
      *default(obj)* is a function that should return a serializable version
      of obj or raise ``TypeError``. The default simply raises ``TypeError``.
  
      If *use_decimal* is true (default: ``True``) then decimal.Decimal
      will be natively serialized to JSON with full precision.
  
      If *namedtuple_as_object* is true (default: ``True``),
      :class:`tuple` subclasses with ``_asdict()`` methods will be encoded
      as JSON objects.
  
      If *tuple_as_array* is true (default: ``True``),
      :class:`tuple` (and subclasses) will be encoded as JSON arrays.
  
      If *iterable_as_array* is true (default: ``False``),
      any object not in the above table that implements ``__iter__()``
      will be encoded as a JSON array.
  
      If *bigint_as_string* is true (default: ``False``), ints 2**53 and higher
      or lower than -2**53 will be encoded as strings. This is to avoid the
      rounding that happens in Javascript otherwise. Note that this is still a
      lossy operation that will not round-trip correctly and should be used
      sparingly.
  
      If *int_as_string_bitcount* is a positive number (n), then int of size
      greater than or equal to 2**n or lower than or equal to -2**n will be
      encoded as strings.
  
      If specified, *item_sort_key* is a callable used to sort the items in
      each dictionary. This is useful if you want to sort items other than
      in alphabetical order by key. This option takes precedence over
      *sort_keys*.
  
      If *sort_keys* is true (default: ``False``), the output of dictionaries
      will be sorted by item.
  
      If *for_json* is true (default: ``False``), objects with a ``for_json()``
      method will use the return value of that method for encoding as JSON
      instead of the object.
  
      If *ignore_nan* is true (default: ``False``), then out of range
      :class:`float` values (``nan``, ``inf``, ``-inf``) will be serialized as
      ``null`` in compliance with the ECMA-262 specification. If true, this will
      override *allow_nan*.
  
      To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
      ``.default()`` method to serialize additional types), specify it with
      the ``cls`` kwarg. NOTE: You should use *default* or *for_json* instead
      of subclassing whenever possible.
  
      """
      # 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 encoding == "utf-8"
          and default is None
          and use_decimal
          and namedtuple_as_object
          and tuple_as_array
          and not iterable_as_array
          and not bigint_as_string
          and not sort_keys
          and not item_sort_key
          and not for_json
          and not ignore_nan
          and int_as_string_bitcount is None
          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,
              encoding=encoding,
              default=default,
              use_decimal=use_decimal,
              namedtuple_as_object=namedtuple_as_object,
              tuple_as_array=tuple_as_array,
              iterable_as_array=iterable_as_array,
              bigint_as_string=bigint_as_string,
              sort_keys=sort_keys,
              item_sort_key=item_sort_key,
              for_json=for_json,
              ignore_nan=ignore_nan,
              int_as_string_bitcount=int_as_string_bitcount,
              **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/python/simplejson/py2/simplejson/__init__.py
imports: from __future__ import absolute_import
  from decimal import Decimal
  from .errors import JSONDecodeError
  from .raw_json import RawJSON
  from .decoder import JSONDecoder
  from .encoder import JSONEncoder, JSONEncoderForHTML
label_desc: Use image node_id 3 for calling a global function with example usage: dump(obj, fp, skipkeys, ensure_ascii, check_circular, allow_nan, cls, indent, separators, encoding, default, use_decimal, namedtuple_as_object, tuple_as_array, bigint_as_string, sort_keys, item_sort_key, for_json, ignore_nan, int_as_string_bitcount, iterable_as_array) without return types