code: def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
          allow_nan=True, cls=None, indent=None, **kw):
      
      if cls is None:
          cls = JSONEncoder
      return cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
          check_circular=check_circular, allow_nan=allow_nan, indent=indent, **kw).encode(obj)
docs: Serialize ``obj`` to a JSON formatted ``str``.
  
      If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types
      (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) 
      will be skipped instead of raising a ``TypeError``.
  
      If ``ensure_ascii`` is ``False``, then the return value will be a
      ``unicode`` instance subject to normal Python ``str`` to ``unicode``
      coercion rules instead of being escaped to an ASCII ``str``.
  
      If ``check_circular`` is ``False``, then the circular reference check
      for container types will be skipped and a circular reference will
      result in an ``OverflowError`` (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.
  
      To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
      ``.default()`` method to serialize additional types), specify it with
      the ``cls`` kwarg.