Debian Codegraph @

Lib/json/__init__.py

raw
1 r"""JSON (JavaScript Object Notation) <https://json.org> is a subset of
2 JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
3 interchange format.
4
5 :mod:`json` exposes an API familiar to users of the standard library
6 :mod:`marshal` and :mod:`pickle` modules. It is derived from a
7 version of the externally maintained simplejson library.
8
9 Encoding basic Python object hierarchies::
10
11 >>> import json
12 >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
13 '["foo", {"bar": ["baz", null, 1.0, 2]}]'
14 >>> print(json.dumps("\"foo\bar"))
15 "\"foo\bar"
16 >>> print(json.dumps('\u1234'))
17 "\u1234"
18 >>> print(json.dumps('\\'))
19 "\\"
20 >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))
21 {"a": 0, "b": 0, "c": 0}
22 >>> from io import StringIO
23 >>> io = StringIO()
24 >>> json.dump(['streaming API'], io)
25 >>> io.getvalue()
26 '["streaming API"]'
27
28 Compact encoding::
29
30 >>> import json
31 >>> mydict = {'4': 5, '6': 7}
32 >>> json.dumps([1,2,3,mydict], separators=(',', ':'))
33 '[1,2,3,{"4":5,"6":7}]'
34
35 Pretty printing::
36
37 >>> import json
38 >>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4))
39 {
40 "4": 5,
41 "6": 7
42 }
43
44 Decoding JSON::
45
46 >>> import json
47 >>> obj = ['foo', {'bar': ['baz', None, 1.0, 2]}]
48 >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj
49 True
50 >>> json.loads('"\\"foo\\bar"') == '"foo\x08ar'
51 True
52 >>> from io import StringIO
53 >>> io = StringIO('["streaming API"]')
54 >>> json.load(io)[0] == 'streaming API'
55 True
56
57 Specializing JSON object decoding::
58
59 >>> import json
60 >>> def as_complex(dct):
61 ... if '__complex__' in dct:
62 ... return complex(dct['real'], dct['imag'])
63 ... return dct
64 ...
65 >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
66 ... object_hook=as_complex)
67 (1+2j)
68 >>> from decimal import Decimal
69 >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')
70 True
71
72 Specializing JSON object encoding::
73
74 >>> import json
75 >>> def encode_complex(obj):
76 ... if isinstance(obj, complex):
77 ... return [obj.real, obj.imag]
78 ... raise TypeError(f'Object of type {obj.__class__.__name__} '
79 ... f'is not JSON serializable')
80 ...
81 >>> json.dumps(2 + 1j, default=encode_complex)
82 '[2.0, 1.0]'
83 >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j)
84 '[2.0, 1.0]'
85 >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j))
86 '[2.0, 1.0]'
87
88
89 Using json from the shell to validate and pretty-print::
90
91 $ echo '{"json":"obj"}' | python -m json
92 {
93 "json": "obj"
94 }
95 $ echo '{ 1.2:3.4}' | python -m json
96 Expecting property name enclosed in double quotes: line 1 column 3 (char 2)
97 """
98 __version__ = '2.0.9'
99 __all__ = [
100 'dump', 'dumps', 'load', 'loads',
101 'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',
102 ]
103
104 __author__ = 'Bob Ippolito <[email protected]>'
105
106 from .decoder import JSONDecoder, JSONDecodeError
107 from .encoder import JSONEncoder
108 import codecs
109
110 _default_encoder = JSONEncoder(
111 skipkeys=False,
112 ensure_ascii=True,
113 check_circular=True,
114 allow_nan=True,
115 indent=None,
116 separators=None,
117 default=None,
118 )
119
120 def dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True,
121 allow_nan=True, cls=None, indent=None, separators=None,
122 default=None, sort_keys=False, **kw):
123 """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
124 ``.write()``-supporting file-like object).
125
126 If ``skipkeys`` is true then ``dict`` keys that are not basic types
127 (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
128 instead of raising a ``TypeError``.
129
130 If ``ensure_ascii`` is false, then the strings written to ``fp`` can
131 contain non-ASCII and non-printable characters if they appear in strings
132 contained in ``obj``. Otherwise, all such characters are escaped in JSON
133 strings.
134
135 If ``check_circular`` is false, then the circular reference check
136 for container types will be skipped and a circular reference will
137 result in an ``RecursionError`` (or worse).
138
139 If ``allow_nan`` is false, then it will be a ``ValueError`` to
140 serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
141 in strict compliance of the JSON specification, instead of using the
142 JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
143
144 If ``indent`` is a non-negative integer, then JSON array elements and
145 object members will be pretty-printed with that indent level. An indent
146 level of 0 will only insert newlines. ``None`` is the most compact
147 representation.
148
149 If specified, ``separators`` should be an ``(item_separator,
150 key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is
151 ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON
152 representation, you should specify ``(',', ':')`` to eliminate
153 whitespace.
154
155 ``default(obj)`` is a function that should return a serializable version
156 of obj or raise TypeError. The default simply raises TypeError.
157
158 If *sort_keys* is true (default: ``False``), then the output of
159 dictionaries will be sorted by key.
160
161 To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
162 ``.default()`` method to serialize additional types), specify it with
163 the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.
164
165 """
166 # cached encoder
167 if (not skipkeys and ensure_ascii and
168 check_circular and allow_nan and
169 cls is None and indent is None and separators is None and
170 default is None and not sort_keys and not kw):
171 iterable = _default_encoder.iterencode(obj)
172 else:
173 if cls is None:
174 cls = JSONEncoder
175 iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
176 check_circular=check_circular, allow_nan=allow_nan, indent=indent,
177 separators=separators,
178 default=default, sort_keys=sort_keys, **kw).iterencode(obj)
179 # could accelerate with writelines in some versions of Python, at
180 # a debuggability cost
181 for chunk in iterable:
182 fp.write(chunk)
183
184
185 def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
186 allow_nan=True, cls=None, indent=None, separators=None,
187 default=None, sort_keys=False, **kw):
188 """Serialize ``obj`` to a JSON formatted ``str``.
189
190 If ``skipkeys`` is true then ``dict`` keys that are not basic types
191 (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
192 instead of raising a ``TypeError``.
193
194 If ``ensure_ascii`` is false, then the return value can contain
195 non-ASCII and non-printable characters if they appear in strings
196 contained in ``obj``. Otherwise, all such characters are escaped in
197 JSON strings.
198
199 If ``check_circular`` is false, then the circular reference check
200 for container types will be skipped and a circular reference will
201 result in an ``RecursionError`` (or worse).
202
203 If ``allow_nan`` is false, then it will be a ``ValueError`` to
204 serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
205 strict compliance of the JSON specification, instead of using the
206 JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
207
208 If ``indent`` is a non-negative integer, then JSON array elements and
209 object members will be pretty-printed with that indent level. An indent
210 level of 0 will only insert newlines. ``None`` is the most compact
211 representation.
212
213 If specified, ``separators`` should be an ``(item_separator,
214 key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is
215 ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON
216 representation, you should specify ``(',', ':')`` to eliminate
217 whitespace.
218
219 ``default(obj)`` is a function that should return a serializable version
220 of obj or raise TypeError. The default simply raises TypeError.
221
222 If *sort_keys* is true (default: ``False``), then the output of
223 dictionaries will be sorted by key.
224
225 To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
226 ``.default()`` method to serialize additional types), specify it with
227 the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.
228
229 """
230 # cached encoder
231 if (not skipkeys and ensure_ascii and
232 check_circular and allow_nan and
233 cls is None and indent is None and separators is None and
234 default is None and not sort_keys and not kw):
235 return _default_encoder.encode(obj)
236 if cls is None:
237 cls = JSONEncoder
238 return cls(
239 skipkeys=skipkeys, ensure_ascii=ensure_ascii,
240 check_circular=check_circular, allow_nan=allow_nan, indent=indent,
241 separators=separators, default=default, sort_keys=sort_keys,
242 **kw).encode(obj)
243
244
245 _default_decoder = JSONDecoder(object_hook=None, object_pairs_hook=None)
246
247
248 def detect_encoding(b):
249 bstartswith = b.startswith
250 if bstartswith((codecs.BOM_UTF32_BE, codecs.BOM_UTF32_LE)):
251 return 'utf-32'
252 if bstartswith((codecs.BOM_UTF16_BE, codecs.BOM_UTF16_LE)):
253 return 'utf-16'
254 if bstartswith(codecs.BOM_UTF8):
255 return 'utf-8-sig'
256
257 if len(b) >= 4:
258 if not b[0]:
259 # 00 00 -- -- - utf-32-be
260 # 00 XX -- -- - utf-16-be
261 return 'utf-16-be' if b[1] else 'utf-32-be'
262 if not b[1]:
263 # XX 00 00 00 - utf-32-le
264 # XX 00 00 XX - utf-16-le
265 # XX 00 XX -- - utf-16-le
266 return 'utf-16-le' if b[2] or b[3] else 'utf-32-le'
267 elif len(b) == 2:
268 if not b[0]:
269 # 00 XX - utf-16-be
270 return 'utf-16-be'
271 if not b[1]:
272 # XX 00 - utf-16-le
273 return 'utf-16-le'
274 # default
275 return 'utf-8'
276
277
278 def load(fp, *, cls=None, object_hook=None, parse_float=None,
279 parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
280 """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
281 a JSON document) to a Python object.
282
283 ``object_hook`` is an optional function that will be called with the
284 result of any object literal decode (a ``dict``). The return value of
285 ``object_hook`` will be used instead of the ``dict``. This feature
286 can be used to implement custom decoders (e.g. JSON-RPC class hinting).
287
288 ``object_pairs_hook`` is an optional function that will be called with
289 the result of any object literal decoded with an ordered list of pairs.
290 The return value of ``object_pairs_hook`` will be used instead of the
291 ``dict``. This feature can be used to implement custom decoders. If
292 ``object_hook`` is also defined, the ``object_pairs_hook`` takes
293 priority.
294
295 To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
296 kwarg; otherwise ``JSONDecoder`` is used.
297 """
298 return loads(fp.read(),
299 cls=cls, object_hook=object_hook,
300 parse_float=parse_float, parse_int=parse_int,
301 parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw)
302
303
304 def loads(s, *, cls=None, object_hook=None, parse_float=None,
305 parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
306 """Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance
307 containing a JSON document) to a Python object.
308
309 ``object_hook`` is an optional function that will be called with the
310 result of any object literal decode (a ``dict``). The return value of
311 ``object_hook`` will be used instead of the ``dict``. This feature
312 can be used to implement custom decoders (e.g. JSON-RPC class hinting).
313
314 ``object_pairs_hook`` is an optional function that will be called with
315 the result of any object literal decoded with an ordered list of pairs.
316 The return value of ``object_pairs_hook`` will be used instead of the
317 ``dict``. This feature can be used to implement custom decoders. If
318 ``object_hook`` is also defined, the ``object_pairs_hook`` takes
319 priority.
320
321 ``parse_float``, if specified, will be called with the string
322 of every JSON float to be decoded. By default this is equivalent to
323 float(num_str). This can be used to use another datatype or parser
324 for JSON floats (e.g. decimal.Decimal).
325
326 ``parse_int``, if specified, will be called with the string
327 of every JSON int to be decoded. By default this is equivalent to
328 int(num_str). This can be used to use another datatype or parser
329 for JSON integers (e.g. float).
330
331 ``parse_constant``, if specified, will be called with one of the
332 following strings: -Infinity, Infinity, NaN.
333 This can be used to raise an exception if invalid JSON numbers
334 are encountered.
335
336 To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
337 kwarg; otherwise ``JSONDecoder`` is used.
338 """
339 if isinstance(s, str):
340 if s.startswith('\ufeff'):
341 raise JSONDecodeError("Unexpected UTF-8 BOM (decode using utf-8-sig)",
342 s, 0)
343 else:
344 if not isinstance(s, (bytes, bytearray)):
345 raise TypeError(f'the JSON object must be str, bytes or bytearray, '
346 f'not {s.__class__.__name__}')
347 s = s.decode(detect_encoding(s), 'surrogatepass')
348
349 if (cls is None and object_hook is None and
350 parse_int is None and parse_float is None and
351 parse_constant is None and object_pairs_hook is None and not kw):
352 return _default_decoder.decode(s)
353 if cls is None:
354 cls = JSONDecoder
355 if object_hook is not None:
356 kw['object_hook'] = object_hook
357 if object_pairs_hook is not None:
358 kw['object_pairs_hook'] = object_pairs_hook
359 if parse_float is not None:
360 kw['parse_float'] = parse_float
361 if parse_int is not None:
362 kw['parse_int'] = parse_int
363 if parse_constant is not None:
364 kw['parse_constant'] = parse_constant
365 return cls(**kw).decode(s)