Namespaces


	decoder

	encoder

	ordered_dict

	scanner

	tests

	tool

Functions
def	dump

def	dumps

def	load

def	loads

Variables
string	__version__ = '2.1.3'

list	__all__

string	__author__ = 'Bob Ippolito <bob@redivi.com>'

tuple	OrderedDict = _import_OrderedDict()

tuple	_default_encoder

tuple	_default_decoder

Function Documentation

def simplejson.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 = `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``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
will be skipped instead of raising a ``TypeError``.

If ``ensure_ascii`` is false, then the some chunks written to ``fp``
may be ``unicode`` instances, subject to normal Python ``str`` to
``unicode`` coercion rules. Unless ``fp.write()`` explicitly
understands ``unicode`` (as in ``codecs.getwriter()``) this is likely
to cause an error.

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 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. For backwards compatibility with
versions of simplejson earlier than 2.1.0, an integer is also accepted
and is converted to a string with that many spaces.

If ``separators`` is an ``(item_separator, dict_separator)`` tuple
then it will be used instead of the default ``(', ', ': ')`` separators.
``(',', ':')`` is the most compact JSON representation.

``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: ``False``) then decimal.Decimal
will be natively serialized to JSON with full precision.

To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
``.default()`` method to serialize additional types), specify it with
the ``cls`` kwarg.

def simplejson.dumps	(	obj,
		skipkeys = `False`,
		ensure_ascii = `True`,
		check_circular = `True`,
		allow_nan = `True`,
		cls = `None`,
		indent = `None`,
		separators = `None`,
		encoding = `'utf-8'`,
		default = `None`,
		use_decimal = `False`,
		kw
	)

Serialize ``obj`` to a JSON formatted ``str``.

If ``skipkeys`` is false 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 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. For backwards compatibility with
versions of simplejson earlier than 2.1.0, an integer is also accepted
and is converted to a string with that many spaces.

If ``separators`` is an ``(item_separator, dict_separator)`` tuple
then it will be used instead of the default ``(', ', ': ')`` separators.
``(',', ':')`` is the most compact JSON representation.

``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: ``False``) then decimal.Decimal
will be natively serialized to JSON with full precision.

To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
``.default()`` method to serialize additional types), specify it with
the ``cls`` kwarg.

def simplejson.load	(	fp,
		encoding = `None`,
		cls = `None`,
		object_hook = `None`,
		parse_float = `None`,
		parse_int = `None`,
		parse_constant = `None`,
		object_pairs_hook = `None`,
		use_decimal = `False`,
		kw
	)

Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
a JSON document) to a Python object.

*encoding* determines the encoding used to interpret any
:class:`str` objects decoded by this instance (``'utf-8'`` by
default).  It has no effect when decoding :class:`unicode` objects.

Note that currently only encodings that are a superset of ASCII work,
strings of other encodings should be passed in as :class:`unicode`.

*object_hook*, if specified, will be called with the result of every
JSON object decoded and its return value will be used in place of the
given :class:`dict`.  This can be used to provide custom
deserializations (e.g. to support JSON-RPC class hinting).

*object_pairs_hook* is an optional function that will be called with
the result of any object literal decode with an ordered list of pairs.
The return value of *object_pairs_hook* will be used instead of the
:class:`dict`.  This feature can be used to implement custom decoders
that rely on the order that the key and value pairs are decoded (for
example, :func:`collections.OrderedDict` will remember the order of
insertion). 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. :class:`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. :class:`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.

If *use_decimal* is true (default: ``False``) then it implies
parse_float=decimal.Decimal for parity with ``dump``.

To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
kwarg.

def simplejson.loads	(	s,
		encoding = `None`,
		cls = `None`,
		object_hook = `None`,
		parse_float = `None`,
		parse_int = `None`,
		parse_constant = `None`,
		object_pairs_hook = `None`,
		use_decimal = `False`,
		kw
	)

Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
document) to a Python object.

*encoding* determines the encoding used to interpret any
:class:`str` objects decoded by this instance (``'utf-8'`` by
default).  It has no effect when decoding :class:`unicode` objects.

Note that currently only encodings that are a superset of ASCII work,
strings of other encodings should be passed in as :class:`unicode`.

*object_hook*, if specified, will be called with the result of every
JSON object decoded and its return value will be used in place of the
given :class:`dict`.  This can be used to provide custom
deserializations (e.g. to support JSON-RPC class hinting).

*object_pairs_hook* is an optional function that will be called with
the result of any object literal decode with an ordered list of pairs.
The return value of *object_pairs_hook* will be used instead of the
:class:`dict`.  This feature can be used to implement custom decoders
that rely on the order that the key and value pairs are decoded (for
example, :func:`collections.OrderedDict` will remember the order of
insertion). 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. :class:`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. :class:`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.

If *use_decimal* is true (default: ``False``) then it implies
parse_float=decimal.Decimal for parity with ``dump``.

To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
kwarg.

Variable Documentation

list simplejson.__all__

Initial value:

 = [
     'dump', 'dumps', 'load', 'loads',
     'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',
     'OrderedDict',
 ]

string simplejson.__author__ = 'Bob Ippolito <bob@redivi.com>'

string simplejson.__version__ = '2.1.3'

tuple simplejson._default_decoder

Initial value:

1 = JSONDecoder(encoding=None, object_hook=None,

2 object_pairs_hook=None)

tuple simplejson._default_encoder

Initial value:

 = JSONEncoder(
     skipkeys=False,
     ensure_ascii=True,
     check_circular=True,
     allow_nan=True,
     indent=None,
     separators=None,
     encoding='utf-8',
     default=None,
     use_decimal=False,
 )

tuple simplejson.OrderedDict = _import_OrderedDict()

Namespaces

Functions

Variables

Function Documentation

Variable Documentation