1 """Implementation of JSONEncoder 2 """ 3 import re 4 5 try: 6 from _json import encode_basestring_ascii as c_encode_basestring_ascii 7 except ImportError: 8 c_encode_basestring_ascii = None 9 try: 10 from _json import make_encoder as c_make_encoder 11 except ImportError: 12 c_make_encoder = None 13 14 ESCAPE = re.compile(r'[\x00-\x1f\\"\b\f\n\r\t]') 15 ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])') 16 HAS_UTF8 = re.compile(r'[\x80-\xff]') 17 ESCAPE_DCT = { 18 '\\': '\\\\', 19 '"': '\\"', 20 '\b': '\\b', 21 '\f': '\\f', 22 '\n': '\\n', 23 '\r': '\\r', 24 '\t': '\\t', 25 } 26 for i in range(0x20): 27 ESCAPE_DCT.setdefault(chr(i), '\\u{0:04x}'.format(i)) 28 #ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,)) 29 30 INFINITY = float('inf') 31 FLOAT_REPR = repr 32 33 def encode_basestring(s): 34 """Return a JSON representation of a Python string 35 36 """ 37 def replace(match): 38 return ESCAPE_DCT[match.group(0)] 39 return '"' + ESCAPE.sub(replace, s) + '"' 40 41 42 def py_encode_basestring_ascii(s): 43 """Return an ASCII-only JSON representation of a Python string 44 45 """ 46 if isinstance(s, str) and HAS_UTF8.search(s) is not None: 47 s = s.decode('utf-8') 48 def replace(match): 49 s = match.group(0) 50 try: 51 return ESCAPE_DCT[s] 52 except KeyError: 53 n = ord(s) 54 if n < 0x10000: 55 return '\\u{0:04x}'.format(n) 56 #return '\\u%04x' % (n,) 57 else: 58 # surrogate pair 59 n -= 0x10000 60 s1 = 0xd800 | ((n >> 10) & 0x3ff) 61 s2 = 0xdc00 | (n & 0x3ff) 62 return '\\u{0:04x}\\u{1:04x}'.format(s1, s2) 63 #return '\\u%04x\\u%04x' % (s1, s2) 64 return '"' + str(ESCAPE_ASCII.sub(replace, s)) + '"' 65 66 67 encode_basestring_ascii = ( 68 c_encode_basestring_ascii or py_encode_basestring_ascii) 69 70 class JSONEncoder(object): 71 """Extensible JSON <http://json.org> encoder for Python data structures. 72 73 Supports the following objects and types by default: 74 75 +-------------------+---------------+ 76 | Python | JSON | 77 +===================+===============+ 78 | dict | object | 79 +-------------------+---------------+ 80 | list, tuple | array | 81 +-------------------+---------------+ 82 | str, unicode | string | 83 +-------------------+---------------+ 84 | int, long, float | number | 85 +-------------------+---------------+ 86 | True | true | 87 +-------------------+---------------+ 88 | False | false | 89 +-------------------+---------------+ 90 | None | null | 91 +-------------------+---------------+ 92 93 To extend this to recognize other objects, subclass and implement a 94 ``.default()`` method with another method that returns a serializable 95 object for ``o`` if possible, otherwise it should call the superclass 96 implementation (to raise ``TypeError``). 97 98 """ 99 item_separator = ', ' 100 key_separator = ': ' 101 def __init__(self, skipkeys=False, ensure_ascii=True, 102 check_circular=True, allow_nan=True, sort_keys=False, 103 indent=None, separators=None, encoding='utf-8', default=None): 104 """Constructor for JSONEncoder, with sensible defaults. 105 106 If skipkeys is false, then it is a TypeError to attempt 107 encoding of keys that are not str, int, long, float or None. If 108 skipkeys is True, such items are simply skipped. 109 110 If *ensure_ascii* is true (the default), all non-ASCII 111 characters in the output are escaped with \uXXXX sequences, 112 and the results are str instances consisting of ASCII 113 characters only. If ensure_ascii is False, a result may be a 114 unicode instance. This usually happens if the input contains 115 unicode strings or the *encoding* parameter is used. 116 117 If check_circular is true, then lists, dicts, and custom encoded 118 objects will be checked for circular references during encoding to 119 prevent an infinite recursion (which would cause an OverflowError). 120 Otherwise, no such check takes place. 121 122 If allow_nan is true, then NaN, Infinity, and -Infinity will be 123 encoded as such. This behavior is not JSON specification compliant, 124 but is consistent with most JavaScript based encoders and decoders. 125 Otherwise, it will be a ValueError to encode such floats. 126 127 If sort_keys is true, then the output of dictionaries will be 128 sorted by key; this is useful for regression tests to ensure 129 that JSON serializations can be compared on a day-to-day basis. 130 131 If indent is a non-negative integer, then JSON array 132 elements and object members will be pretty-printed with that 133 indent level. An indent level of 0 will only insert newlines. 134 None is the most compact representation. Since the default 135 item separator is ', ', the output might include trailing 136 whitespace when indent is specified. You can use 137 separators=(',', ': ') to avoid this. 138 139 If specified, separators should be a (item_separator, key_separator) 140 tuple. The default is (', ', ': '). To get the most compact JSON 141 representation you should specify (',', ':') to eliminate whitespace. 142 143 If specified, default is a function that gets called for objects 144 that can't otherwise be serialized. It should return a JSON encodable 145 version of the object or raise a ``TypeError``. 146 147 If encoding is not None, then all input strings will be 148 transformed into unicode using that encoding prior to JSON-encoding. 149 The default is UTF-8. 150 151 """ 152 153 self.skipkeys = skipkeys 154 self.ensure_ascii = ensure_ascii 155 self.check_circular = check_circular 156 self.allow_nan = allow_nan 157 self.sort_keys = sort_keys 158 self.indent = indent 159 if separators is not None: 160 self.item_separator, self.key_separator = separators 161 if default is not None: 162 self.default = default 163 self.encoding = encoding 164 165 def default(self, o): 166 """Implement this method in a subclass such that it returns 167 a serializable object for ``o``, or calls the base implementation 168 (to raise a ``TypeError``). 169 170 For example, to support arbitrary iterators, you could 171 implement default like this:: 172 173 def default(self, o): 174 try: 175 iterable = iter(o) 176 except TypeError: 177 pass 178 else: 179 return list(iterable) 180 # Let the base class default method raise the TypeError 181 return JSONEncoder.default(self, o) 182 183 """ 184 raise TypeError(repr(o) + " is not JSON serializable") 185 186 def encode(self, o): 187 """Return a JSON string representation of a Python data structure. 188 189 >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) 190 '{"foo": ["bar", "baz"]}' 191 192 """ 193 # This is for extremely simple cases and benchmarks. 194 if isinstance(o, basestring): 195 if isinstance(o, str): 196 _encoding = self.encoding 197 if (_encoding is not None 198 and not (_encoding == 'utf-8')): 199 o = o.decode(_encoding) 200 if self.ensure_ascii: 201 return encode_basestring_ascii(o) 202 else: 203 return encode_basestring(o) 204 # This doesn't pass the iterator directly to ''.join() because the 205 # exceptions aren't as detailed. The list call should be roughly 206 # equivalent to the PySequence_Fast that ''.join() would do. 207 chunks = self.iterencode(o, _one_shot=True) 208 if not isinstance(chunks, (list, tuple)): 209 chunks = list(chunks) 210 return ''.join(chunks) 211 212 def iterencode(self, o, _one_shot=False): 213 """Encode the given object and yield each string 214 representation as available. 215 216 For example:: 217 218 for chunk in JSONEncoder().iterencode(bigobject): 219 mysocket.write(chunk) 220 221 """ 222 if self.check_circular: 223 markers = {} 224 else: 225 markers = None 226 if self.ensure_ascii: 227 _encoder = encode_basestring_ascii 228 else: 229 _encoder = encode_basestring 230 if self.encoding != 'utf-8': 231 def _encoder(o, _orig_encoder=_encoder, _encoding=self.encoding): 232 if isinstance(o, str): 233 o = o.decode(_encoding) 234 return _orig_encoder(o) 235 236 def floatstr(o, allow_nan=self.allow_nan, 237 _repr=FLOAT_REPR, _inf=INFINITY, _neginf=-INFINITY): 238 # Check for specials. Note that this type of test is processor 239 # and/or platform-specific, so do tests which don't depend on the 240 # internals. 241 242 if o != o: 243 text = 'NaN' 244 elif o == _inf: 245 text = 'Infinity' 246 elif o == _neginf: 247 text = '-Infinity' 248 else: 249 return _repr(o) 250 251 if not allow_nan: 252 raise ValueError( 253 "Out of range float values are not JSON compliant: " + 254 repr(o)) 255 256 return text 257 258 259 if (_one_shot and c_make_encoder is not None 260 and self.indent is None and not self.sort_keys): 261 _iterencode = c_make_encoder( 262 markers, self.default, _encoder, self.indent, 263 self.key_separator, self.item_separator, self.sort_keys, 264 self.skipkeys, self.allow_nan) 265 else: 266 _iterencode = _make_iterencode( 267 markers, self.default, _encoder, self.indent, floatstr, 268 self.key_separator, self.item_separator, self.sort_keys, 269 self.skipkeys, _one_shot) 270 return _iterencode(o, 0) 271 272 def _make_iterencode(markers, _default, _encoder, _indent, _floatstr, 273 _key_separator, _item_separator, _sort_keys, _skipkeys, _one_shot, 274 ## HACK: hand-optimized bytecode; turn globals into locals 275 ValueError=ValueError, 276 basestring=basestring, 277 dict=dict, 278 float=float, 279 id=id, 280 int=int, 281 isinstance=isinstance, 282 list=list, 283 long=long, 284 str=str, 285 tuple=tuple, 286 ): 287 288 def _iterencode_list(lst, _current_indent_level): 289 if not lst: 290 yield '[]' 291 return 292 if markers is not None: 293 markerid = id(lst) 294 if markerid in markers: 295 raise ValueError("Circular reference detected") 296 markers[markerid] = lst 297 buf = '[' 298 if _indent is not None: 299 _current_indent_level += 1 300 newline_indent = '\n' + (' ' * (_indent * _current_indent_level)) 301 separator = _item_separator + newline_indent 302 buf += newline_indent 303 else: 304 newline_indent = None 305 separator = _item_separator 306 first = True 307 for value in lst: 308 if first: 309 first = False 310 else: 311 buf = separator 312 if isinstance(value, basestring): 313 yield buf + _encoder(value) 314 elif value is None: 315 yield buf + 'null' 316 elif value is True: 317 yield buf + 'true' 318 elif value is False: 319 yield buf + 'false' 320 elif isinstance(value, (int, long)): 321 yield buf + str(value) 322 elif isinstance(value, float): 323 yield buf + _floatstr(value) 324 else: 325 yield buf 326 if isinstance(value, (list, tuple)): 327 chunks = _iterencode_list(value, _current_indent_level) 328 elif isinstance(value, dict): 329 chunks = _iterencode_dict(value, _current_indent_level) 330 else: 331 chunks = _iterencode(value, _current_indent_level) 332 for chunk in chunks: 333 yield chunk 334 if newline_indent is not None: 335 _current_indent_level -= 1 336 yield '\n' + (' ' * (_indent * _current_indent_level)) 337 yield ']' 338 if markers is not None: 339 del markers[markerid] 340 341 def _iterencode_dict(dct, _current_indent_level): 342 if not dct: 343 yield '{}' 344 return 345 if markers is not None: 346 markerid = id(dct) 347 if markerid in markers: 348 raise ValueError("Circular reference detected") 349 markers[markerid] = dct 350 yield '{' 351 if _indent is not None: 352 _current_indent_level += 1 353 newline_indent = '\n' + (' ' * (_indent * _current_indent_level)) 354 item_separator = _item_separator + newline_indent 355 yield newline_indent 356 else: 357 newline_indent = None 358 item_separator = _item_separator 359 first = True 360 if _sort_keys: 361 items = sorted(dct.items(), key=lambda kv: kv[0]) 362 else: 363 items = dct.iteritems() 364 for key, value in items: 365 if isinstance(key, basestring): 366 pass 367 # JavaScript is weakly typed for these, so it makes sense to 368 # also allow them. Many encoders seem to do something like this. 369 elif isinstance(key, float): 370 key = _floatstr(key) 371 elif key is True: 372 key = 'true' 373 elif key is False: 374 key = 'false' 375 elif key is None: 376 key = 'null' 377 elif isinstance(key, (int, long)): 378 key = str(key) 379 elif _skipkeys: 380 continue 381 else: 382 raise TypeError("key " + repr(key) + " is not a string") 383 if first: 384 first = False 385 else: 386 yield item_separator 387 yield _encoder(key) 388 yield _key_separator 389 if isinstance(value, basestring): 390 yield _encoder(value) 391 elif value is None: 392 yield 'null' 393 elif value is True: 394 yield 'true' 395 elif value is False: 396 yield 'false' 397 elif isinstance(value, (int, long)): 398 yield str(value) 399 elif isinstance(value, float): 400 yield _floatstr(value) 401 else: 402 if isinstance(value, (list, tuple)): 403 chunks = _iterencode_list(value, _current_indent_level) 404 elif isinstance(value, dict): 405 chunks = _iterencode_dict(value, _current_indent_level) 406 else: 407 chunks = _iterencode(value, _current_indent_level) 408 for chunk in chunks: 409 yield chunk 410 if newline_indent is not None: 411 _current_indent_level -= 1 412 yield '\n' + (' ' * (_indent * _current_indent_level)) 413 yield '}' 414 if markers is not None: 415 del markers[markerid] 416 417 def _iterencode(o, _current_indent_level): 418 if isinstance(o, basestring): 419 yield _encoder(o) 420 elif o is None: 421 yield 'null' 422 elif o is True: 423 yield 'true' 424 elif o is False: 425 yield 'false' 426 elif isinstance(o, (int, long)): 427 yield str(o) 428 elif isinstance(o, float): 429 yield _floatstr(o) 430 elif isinstance(o, (list, tuple)): 431 for chunk in _iterencode_list(o, _current_indent_level): 432 yield chunk 433 elif isinstance(o, dict): 434 for chunk in _iterencode_dict(o, _current_indent_level): 435 yield chunk 436 else: 437 if markers is not None: 438 markerid = id(o) 439 if markerid in markers: 440 raise ValueError("Circular reference detected") 441 markers[markerid] = o 442 o = _default(o) 443 for chunk in _iterencode(o, _current_indent_level): 444 yield chunk 445 if markers is not None: 446 del markers[markerid] 447 448 return _iterencode 449
