2
A simple, fast, extensible JSON encoder and decoder
4
JSON (JavaScript Object Notation) <http://json.org> is a subset of
5
JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
8
simplejson exposes an API familiar to uses of the standard library
9
marshal and pickle modules.
11
Encoding basic Python object hierarchies::
14
>>> simplejson.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
15
'["foo", {"bar": ["baz", null, 1.0, 2]}]'
16
>>> print simplejson.dumps("\"foo\bar")
18
>>> print simplejson.dumps(u'\u1234')
20
>>> print simplejson.dumps('\\')
22
>>> print simplejson.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
23
{"a": 0, "b": 0, "c": 0}
24
>>> from StringIO import StringIO
26
>>> simplejson.dump(['streaming API'], io)
33
>>> simplejson.dumps([1,2,3,{'4': 5, '6': 7}], separators=(',',':'))
34
'[1,2,3,{"4":5,"6":7}]'
39
>>> print simplejson.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4)
48
>>> simplejson.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
49
[u'foo', {u'bar': [u'baz', None, 1.0, 2]}]
50
>>> simplejson.loads('"\\"foo\\bar"')
52
>>> from StringIO import StringIO
53
>>> io = StringIO('["streaming API"]')
54
>>> simplejson.load(io)
57
Specializing JSON object decoding::
60
>>> def as_complex(dct):
61
... if '__complex__' in dct:
62
... return complex(dct['real'], dct['imag'])
65
>>> simplejson.loads('{"__complex__": true, "real": 1, "imag": 2}',
66
... object_hook=as_complex)
69
>>> simplejson.loads('1.1', parse_float=decimal.Decimal)
72
Extending JSONEncoder::
75
>>> class ComplexEncoder(simplejson.JSONEncoder):
76
... def default(self, obj):
77
... if isinstance(obj, complex):
78
... return [obj.real, obj.imag]
79
... return simplejson.JSONEncoder.default(self, obj)
81
>>> dumps(2 + 1j, cls=ComplexEncoder)
83
>>> ComplexEncoder().encode(2 + 1j)
85
>>> list(ComplexEncoder().iterencode(2 + 1j))
86
['[', '2.0', ', ', '1.0', ']']
89
Using simplejson from the shell to validate and
92
$ echo '{"json":"obj"}' | python -msimplejson
96
$ echo '{ 1.2:3.4}' | python -msimplejson
97
Expecting property name: line 1 column 2 (char 2)
99
Note that the JSON produced by this module's default settings
100
is a subset of YAML, so it may be used as a serializer for that as well.
102
__version__ = '1.8.1'
104
'dump', 'dumps', 'load', 'loads',
105
'JSONDecoder', 'JSONEncoder',
108
if __name__ == '__main__':
109
from simplejson.decoder import JSONDecoder
110
from simplejson.encoder import JSONEncoder
112
from decoder import JSONDecoder
113
from encoder import JSONEncoder
115
_default_encoder = JSONEncoder(
126
def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
127
allow_nan=True, cls=None, indent=None, separators=None,
128
encoding='utf-8', default=None, **kw):
130
Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
131
``.write()``-supporting file-like object).
133
If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types
134
(``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
135
will be skipped instead of raising a ``TypeError``.
137
If ``ensure_ascii`` is ``False``, then the some chunks written to ``fp``
138
may be ``unicode`` instances, subject to normal Python ``str`` to
139
``unicode`` coercion rules. Unless ``fp.write()`` explicitly
140
understands ``unicode`` (as in ``codecs.getwriter()``) this is likely
143
If ``check_circular`` is ``False``, then the circular reference check
144
for container types will be skipped and a circular reference will
145
result in an ``OverflowError`` (or worse).
147
If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to
148
serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
149
in strict compliance of the JSON specification, instead of using the
150
JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
152
If ``indent`` is a non-negative integer, then JSON array elements and object
153
members will be pretty-printed with that indent level. An indent level
154
of 0 will only insert newlines. ``None`` is the most compact representation.
156
If ``separators`` is an ``(item_separator, dict_separator)`` tuple
157
then it will be used instead of the default ``(', ', ': ')`` separators.
158
``(',', ':')`` is the most compact JSON representation.
160
``encoding`` is the character encoding for str instances, default is UTF-8.
162
``default(obj)`` is a function that should return a serializable version
163
of obj or raise TypeError. The default simply raises TypeError.
165
To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
166
``.default()`` method to serialize additional types), specify it with
170
if (skipkeys is False and ensure_ascii is True and
171
check_circular is True and allow_nan is True and
172
cls is None and indent is None and separators is None and
173
encoding == 'utf-8' and default is None and not kw):
174
iterable = _default_encoder.iterencode(obj)
178
iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
179
check_circular=check_circular, allow_nan=allow_nan, indent=indent,
180
separators=separators, encoding=encoding,
181
default=default, **kw).iterencode(obj)
182
# could accelerate with writelines in some versions of Python, at
183
# a debuggability cost
184
for chunk in iterable:
188
def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
189
allow_nan=True, cls=None, indent=None, separators=None,
190
encoding='utf-8', default=None, **kw):
192
Serialize ``obj`` to a JSON formatted ``str``.
194
If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types
195
(``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
196
will be skipped instead of raising a ``TypeError``.
198
If ``ensure_ascii`` is ``False``, then the return value will be a
199
``unicode`` instance subject to normal Python ``str`` to ``unicode``
200
coercion rules instead of being escaped to an ASCII ``str``.
202
If ``check_circular`` is ``False``, then the circular reference check
203
for container types will be skipped and a circular reference will
204
result in an ``OverflowError`` (or worse).
206
If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to
207
serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
208
strict compliance of the JSON specification, instead of using the
209
JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
211
If ``indent`` is a non-negative integer, then JSON array elements and
212
object members will be pretty-printed with that indent level. An indent
213
level of 0 will only insert newlines. ``None`` is the most compact
216
If ``separators`` is an ``(item_separator, dict_separator)`` tuple
217
then it will be used instead of the default ``(', ', ': ')`` separators.
218
``(',', ':')`` is the most compact JSON representation.
220
``encoding`` is the character encoding for str instances, default is UTF-8.
222
``default(obj)`` is a function that should return a serializable version
223
of obj or raise TypeError. The default simply raises TypeError.
225
To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
226
``.default()`` method to serialize additional types), specify it with
230
if (skipkeys is False and ensure_ascii is True and
231
check_circular is True and allow_nan is True and
232
cls is None and indent is None and separators is None and
233
encoding == 'utf-8' and default is None and not kw):
234
return _default_encoder.encode(obj)
238
skipkeys=skipkeys, ensure_ascii=ensure_ascii,
239
check_circular=check_circular, allow_nan=allow_nan, indent=indent,
240
separators=separators, encoding=encoding, default=default,
243
_default_decoder = JSONDecoder(encoding=None, object_hook=None)
245
def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
246
parse_int=None, parse_constant=None, **kw):
248
Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
249
a JSON document) to a Python object.
251
If the contents of ``fp`` is encoded with an ASCII based encoding other
252
than utf-8 (e.g. latin-1), then an appropriate ``encoding`` name must
253
be specified. Encodings that are not ASCII based (such as UCS-2) are
254
not allowed, and should be wrapped with
255
``codecs.getreader(fp)(encoding)``, or simply decoded to a ``unicode``
256
object and passed to ``loads()``
258
``object_hook`` is an optional function that will be called with the
259
result of any object literal decode (a ``dict``). The return value of
260
``object_hook`` will be used instead of the ``dict``. This feature
261
can be used to implement custom decoders (e.g. JSON-RPC class hinting).
263
To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
266
return loads(fp.read(),
267
encoding=encoding, cls=cls, object_hook=object_hook,
268
parse_float=parse_float, parse_int=parse_int,
269
parse_constant=parse_constant, **kw)
271
def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
272
parse_int=None, parse_constant=None, **kw):
274
Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
275
document) to a Python object.
277
If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding
278
other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name
279
must be specified. Encodings that are not ASCII based (such as UCS-2)
280
are not allowed and should be decoded to ``unicode`` first.
282
``object_hook`` is an optional function that will be called with the
283
result of any object literal decode (a ``dict``). The return value of
284
``object_hook`` will be used instead of the ``dict``. This feature
285
can be used to implement custom decoders (e.g. JSON-RPC class hinting).
287
``parse_float``, if specified, will be called with the string
288
of every JSON float to be decoded. By default this is equivalent to
289
float(num_str). This can be used to use another datatype or parser
290
for JSON floats (e.g. decimal.Decimal).
292
``parse_int``, if specified, will be called with the string
293
of every JSON int to be decoded. By default this is equivalent to
294
int(num_str). This can be used to use another datatype or parser
295
for JSON integers (e.g. float).
297
``parse_constant``, if specified, will be called with one of the
298
following strings: -Infinity, Infinity, NaN, null, true, false.
299
This can be used to raise an exception if invalid JSON numbers
302
To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
305
if (cls is None and encoding is None and object_hook is None and
306
parse_int is None and parse_float is None and
307
parse_constant is None and not kw):
308
return _default_decoder.decode(s)
311
if object_hook is not None:
312
kw['object_hook'] = object_hook
313
if parse_float is not None:
314
kw['parse_float'] = parse_float
315
if parse_int is not None:
316
kw['parse_int'] = parse_int
317
if parse_constant is not None:
318
kw['parse_constant'] = parse_constant
319
return cls(encoding=encoding, **kw).decode(s)
322
# Compatibility cruft from other libraries
327
demjson, python-cjson API compatibility hook. Use loads(s) instead.
330
warnings.warn("simplejson.loads(s) should be used instead of decode(s)",
336
demjson, python-cjson compatibility hook. Use dumps(s) instead.
339
warnings.warn("simplejson.dumps(s) should be used instead of encode(s)",
345
jsonlib, JsonUtils, python-json, json-py API compatibility hook.
346
Use loads(s) instead.
349
warnings.warn("simplejson.loads(s) should be used instead of read(s)",
355
jsonlib, JsonUtils, python-json, json-py API compatibility hook.
356
Use dumps(s) instead.
359
warnings.warn("simplejson.dumps(s) should be used instead of write(s)",
365
# curl http://mochikit.com/examples/ajax_tables/domains.json | python -msimplejson
370
if len(sys.argv) == 1:
373
elif len(sys.argv) == 2:
374
infile = open(sys.argv[1], 'rb')
376
elif len(sys.argv) == 3:
377
infile = open(sys.argv[1], 'rb')
378
outfile = open(sys.argv[2], 'wb')
380
raise SystemExit("%s [infile [outfile]]" % (sys.argv[0],))
383
except ValueError, e:
385
dump(obj, outfile, sort_keys=True, indent=4)
388
if __name__ == '__main__':
added
removed
gozerbot/contrib/simplejson/__init__.py
