#NEWLINE# 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 , **kw ) : #NEWLINE# #INDENT# "Serialize ``obj`` as a JSON formatted stream to ``fp`` (a\n        ``.write()``-supporting file-like object).\n\n        If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types\n        (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)\n        will be skipped instead of raising a ``TypeError``.\n\n        If ``ensure_ascii`` is ``False``, then the some chunks written to ``fp``\n        may be ``unicode`` instances, subject to normal Python ``str`` to\n        ``unicode`` coercion rules. Unless ``fp.write()`` explicitly\n        understands ``unicode`` (as in ``codecs.getwriter()``) this is likely\n        to cause an error.\n\n        If ``check_circular`` is ``False``, then the circular reference check\n        for container types will be skipped and a circular reference will\n        result in an ``OverflowError`` (or worse).\n\n        If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to\n        serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)\n        in strict compliance of the JSON specification, instead of using the\n        JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).\n\n        If ``indent`` is a non-negative integer, then JSON array elements and object\n        members will be pretty-printed with that indent level. An indent level\n        of 0 will only insert newlines. ``None`` is the most compact representation.\n\n        If ``separators`` is an ``(item_separator, dict_separator)`` tuple\n        then it will be used instead of the default ``(', ', ': ')`` separators.\n        ``(',', ':')`` is the most compact JSON representation.\n\n        ``encoding`` is the character encoding for str instances, default is UTF-8.\n\n        ``default(obj)`` is a function that should return a serializable version\n        of obj or raise TypeError. The default simply raises TypeError.\n\n        To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the\n        ``.default()`` method to serialize additional types), specify it with\n        the ``cls`` kwarg.\n\n        " #NEWLINE# if ( ( skipkeys is False ) and ( ensure_ascii is True ) and ( check_circular is True ) and ( allow_nan is True ) and ( cls is None ) and ( indent is None ) and ( separators is None ) and ( encoding == 'utf-8' ) and ( default is None ) and ( not kw ) ) : #NEWLINE# #INDENT# iterable = _default_encoder . iterencode ( obj ) #NEWLINE# #UNINDENT# else : #NEWLINE# #INDENT# if ( cls is None ) : #NEWLINE# #INDENT# cls = JSONEncoder #NEWLINE# #UNINDENT# iterable = cls ( skipkeys = skipkeys , ensure_ascii = ensure_ascii , check_circular = check_circular , allow_nan = allow_nan , indent = indent , separators = separators , encoding = encoding , default = default , ** kw ) . iterencode ( obj ) #NEWLINE# #UNINDENT# for chunk in iterable : #NEWLINE# #INDENT# fp . write ( chunk )