AppPkg/Applications/Python/Python-2.7.2/Lib/json/encoder.py

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