src/third_party/pylib/simplejson/__init__.py - Issue 10827061: Moving mozrunner and simplejson to a toplevel location.

Unified Diff: src/third_party/pylib/simplejson/init.py

Issue 10827061: Moving mozrunner and simplejson to a toplevel location. (Closed) Base URL: svn://svn.chromium.org/native_client/trunk/

Patch Set: Created 8 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: src/third_party/pylib/simplejson/__init__.py

===================================================================

--- src/third_party/pylib/simplejson/__init__.py (revision 9275)

+++ src/third_party/pylib/simplejson/__init__.py (working copy)

@@ -1,437 +0,0 @@

-r"""JSON (JavaScript Object Notation) <http://json.org> is a subset of

-JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data

-interchange format.

-:mod:`simplejson` exposes an API familiar to users of the standard library

-:mod:`marshal` and :mod:`pickle` modules. It is the externally maintained

-version of the :mod:`json` library contained in Python 2.6, but maintains

-compatibility with Python 2.4 and Python 2.5 and (currently) has

-significant performance advantages, even without using the optional C

-extension for speedups.

-Encoding basic Python object hierarchies::

- >>> import simplejson as json

- >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])

- '["foo", {"bar": ["baz", null, 1.0, 2]}]'

- >>> print json.dumps("\"foo\bar")

- "\"foo\bar"

- >>> print json.dumps(u'\u1234')

- "\u1234"

- >>> print json.dumps('\\')

- "\\"

- >>> print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)

- {"a": 0, "b": 0, "c": 0}

- >>> from StringIO import StringIO

- >>> io = StringIO()

- >>> json.dump(['streaming API'], io)

- >>> io.getvalue()

- '["streaming API"]'

-Compact encoding::

- >>> import simplejson as json

- >>> json.dumps([1,2,3,{'4': 5, '6': 7}], separators=(',',':'))

- '[1,2,3,{"4":5,"6":7}]'

-Pretty printing::

- >>> import simplejson as json

- >>> s = json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=' ')

- >>> print '\n'.join([l.rstrip() for l in s.splitlines()])

- {

- "4": 5,

- "6": 7

- }

-Decoding JSON::

- >>> import simplejson as json

- >>> obj = [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]

- >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj

- True

- >>> json.loads('"\\"foo\\bar"') == u'"foo\x08ar'

- True

- >>> from StringIO import StringIO

- >>> io = StringIO('["streaming API"]')

- >>> json.load(io)[0] == 'streaming API'

- True

-Specializing JSON object decoding::

- >>> import simplejson as json

- >>> def as_complex(dct):

- ... if '__complex__' in dct:

- ... return complex(dct['real'], dct['imag'])

- ... return dct

- ...

- >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',

- ... object_hook=as_complex)

- (1+2j)

- >>> from decimal import Decimal

- >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')

- True

-Specializing JSON object encoding::

- >>> import simplejson as json

- >>> def encode_complex(obj):

- ... if isinstance(obj, complex):

- ... return [obj.real, obj.imag]

- ... raise TypeError(repr(o) + " is not JSON serializable")

- ...

- >>> json.dumps(2 + 1j, default=encode_complex)

- '[2.0, 1.0]'

- >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j)

- '[2.0, 1.0]'

- >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j))

- '[2.0, 1.0]'

-Using simplejson.tool from the shell to validate and pretty-print::

- $ echo '{"json":"obj"}' | python -m simplejson.tool

- {

- "json": "obj"

- }

- $ echo '{ 1.2:3.4}' | python -m simplejson.tool

- Expecting property name: line 1 column 2 (char 2)

-"""

-__version__ = '2.1.2'

-__all__ = [

- 'dump', 'dumps', 'load', 'loads',

- 'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',

- 'OrderedDict',

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

-from decimal import Decimal

-from decoder import JSONDecoder, JSONDecodeError

-from encoder import JSONEncoder

-def _import_OrderedDict():

- import collections

- try:

- return collections.OrderedDict

- except AttributeError:

- import ordered_dict

- return ordered_dict.OrderedDict

-OrderedDict = _import_OrderedDict()

-def _import_c_make_encoder():

- try:

- from simplejson._speedups import make_encoder

- return make_encoder

- except ImportError:

- return None

-_default_encoder = JSONEncoder(

- skipkeys=False,

- ensure_ascii=True,

- check_circular=True,

- allow_nan=True,

- indent=None,

- separators=None,

- encoding='utf-8',

- default=None,

- use_decimal=False,

-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=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.

- """

- # 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 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, **kw).iterencode(obj)

- # could accelerate with writelines in some versions of Python, at

- # a debuggability cost

- for chunk in iterable:

- fp.write(chunk)

-def 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.

- """

- # 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 not use_decimal

- and not kw):

- return _default_encoder.encode(obj)

- if cls is None:

- cls = JSONEncoder

- return 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, **kw).encode(obj)

-_default_decoder = JSONDecoder(encoding=None, object_hook=None,

- object_pairs_hook=None)

-def 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.

- """

- return loads(fp.read(),

- encoding=encoding, cls=cls, object_hook=object_hook,

- parse_float=parse_float, parse_int=parse_int,

- parse_constant=parse_constant, object_pairs_hook=object_pairs_hook,

- use_decimal=use_decimal, **kw)

-def 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.