Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 1 | """Implementation of JSONDecoder |
| 2 | """ |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 3 | import binascii |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 4 | import re |
| 5 | import sys |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 6 | import struct |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 7 | |
Ezio Melotti | 6b60fb9 | 2011-05-14 06:47:51 +0300 | [diff] [blame] | 8 | from json import scanner |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 9 | try: |
| 10 | from _json import scanstring as c_scanstring |
| 11 | except ImportError: |
| 12 | c_scanstring = None |
| 13 | |
| 14 | __all__ = ['JSONDecoder'] |
| 15 | |
| 16 | FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL |
| 17 | |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 18 | def _floatconstants(): |
| 19 | _BYTES = binascii.unhexlify(b'7FF80000000000007FF0000000000000') |
| 20 | if sys.byteorder != 'big': |
| 21 | _BYTES = _BYTES[:8][::-1] + _BYTES[8:][::-1] |
| 22 | nan, inf = struct.unpack('dd', _BYTES) |
| 23 | return nan, inf, -inf |
| 24 | |
| 25 | NaN, PosInf, NegInf = _floatconstants() |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 26 | |
| 27 | |
| 28 | def linecol(doc, pos): |
Benjamin Peterson | a13d475 | 2008-10-16 21:17:24 +0000 | [diff] [blame] | 29 | if isinstance(doc, bytes): |
| 30 | newline = b'\n' |
| 31 | else: |
| 32 | newline = '\n' |
| 33 | lineno = doc.count(newline, 0, pos) + 1 |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 34 | if lineno == 1: |
| 35 | colno = pos |
| 36 | else: |
Benjamin Peterson | a13d475 | 2008-10-16 21:17:24 +0000 | [diff] [blame] | 37 | colno = pos - doc.rindex(newline, 0, pos) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 38 | return lineno, colno |
| 39 | |
| 40 | |
| 41 | def errmsg(msg, doc, pos, end=None): |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 42 | # Note that this function is called from _json |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 43 | lineno, colno = linecol(doc, pos) |
| 44 | if end is None: |
| 45 | fmt = '{0}: line {1} column {2} (char {3})' |
| 46 | return fmt.format(msg, lineno, colno, pos) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 47 | #fmt = '%s: line %d column %d (char %d)' |
| 48 | #return fmt % (msg, lineno, colno, pos) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 49 | endlineno, endcolno = linecol(doc, end) |
| 50 | fmt = '{0}: line {1} column {2} - line {3} column {4} (char {5} - {6})' |
| 51 | return fmt.format(msg, lineno, colno, endlineno, endcolno, pos, end) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 52 | #fmt = '%s: line %d column %d - line %d column %d (char %d - %d)' |
| 53 | #return fmt % (msg, lineno, colno, endlineno, endcolno, pos, end) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 54 | |
| 55 | |
| 56 | _CONSTANTS = { |
| 57 | '-Infinity': NegInf, |
| 58 | 'Infinity': PosInf, |
| 59 | 'NaN': NaN, |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 63 | STRINGCHUNK = re.compile(r'(.*?)(["\\\x00-\x1f])', FLAGS) |
| 64 | BACKSLASH = { |
| 65 | '"': '"', '\\': '\\', '/': '/', |
| 66 | 'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t', |
| 67 | } |
| 68 | |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 69 | def py_scanstring(s, end, strict=True, |
| 70 | _b=BACKSLASH, _m=STRINGCHUNK.match): |
| 71 | """Scan the string s for a JSON string. End is the index of the |
| 72 | character in s after the quote that started the JSON string. |
| 73 | Unescapes all valid JSON string escape sequences and raises ValueError |
| 74 | on attempt to decode an invalid string. If strict is False then literal |
| 75 | control characters are allowed in the string. |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 76 | |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 77 | Returns a tuple of the decoded string and the index of the character in s |
| 78 | after the end quote.""" |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 79 | chunks = [] |
| 80 | _append = chunks.append |
| 81 | begin = end - 1 |
| 82 | while 1: |
| 83 | chunk = _m(s, end) |
| 84 | if chunk is None: |
| 85 | raise ValueError( |
| 86 | errmsg("Unterminated string starting at", s, begin)) |
| 87 | end = chunk.end() |
| 88 | content, terminator = chunk.groups() |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 89 | # Content is contains zero or more unescaped string characters |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 90 | if content: |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 91 | _append(content) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 92 | # Terminator is the end of string, a literal control character, |
| 93 | # or a backslash denoting that an escape sequence follows |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 94 | if terminator == '"': |
| 95 | break |
| 96 | elif terminator != '\\': |
| 97 | if strict: |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 98 | #msg = "Invalid control character %r at" % (terminator,) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 99 | msg = "Invalid control character {0!r} at".format(terminator) |
| 100 | raise ValueError(errmsg(msg, s, end)) |
| 101 | else: |
| 102 | _append(terminator) |
| 103 | continue |
| 104 | try: |
| 105 | esc = s[end] |
| 106 | except IndexError: |
| 107 | raise ValueError( |
| 108 | errmsg("Unterminated string starting at", s, begin)) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 109 | # If not a unicode escape sequence, must be in the lookup table |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 110 | if esc != 'u': |
| 111 | try: |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 112 | char = _b[esc] |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 113 | except KeyError: |
| 114 | msg = "Invalid \\escape: {0!r}".format(esc) |
| 115 | raise ValueError(errmsg(msg, s, end)) |
| 116 | end += 1 |
| 117 | else: |
| 118 | esc = s[end + 1:end + 5] |
| 119 | next_end = end + 5 |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 120 | if len(esc) != 4: |
| 121 | msg = "Invalid \\uXXXX escape" |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 122 | raise ValueError(errmsg(msg, s, end)) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 123 | uni = int(esc, 16) |
| 124 | # Check for surrogate pair on UCS-4 systems |
| 125 | if 0xd800 <= uni <= 0xdbff and sys.maxunicode > 65535: |
| 126 | msg = "Invalid \\uXXXX\\uXXXX surrogate pair" |
| 127 | if not s[end + 5:end + 7] == '\\u': |
| 128 | raise ValueError(errmsg(msg, s, end)) |
| 129 | esc2 = s[end + 7:end + 11] |
| 130 | if len(esc2) != 4: |
| 131 | raise ValueError(errmsg(msg, s, end)) |
| 132 | uni2 = int(esc2, 16) |
| 133 | uni = 0x10000 + (((uni - 0xd800) << 10) | (uni2 - 0xdc00)) |
| 134 | next_end += 6 |
| 135 | char = chr(uni) |
| 136 | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 137 | end = next_end |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 138 | _append(char) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 139 | return ''.join(chunks), end |
| 140 | |
| 141 | |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 142 | # Use speedup if available |
| 143 | scanstring = c_scanstring or py_scanstring |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 144 | |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 145 | WHITESPACE = re.compile(r'[ \t\n\r]*', FLAGS) |
| 146 | WHITESPACE_STR = ' \t\n\r' |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 147 | |
| 148 | |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 149 | def JSONObject(s_and_end, strict, scan_once, object_hook, object_pairs_hook, |
Antoine Pitrou | 7d6e076 | 2010-09-04 20:16:53 +0000 | [diff] [blame] | 150 | memo=None, _w=WHITESPACE.match, _ws=WHITESPACE_STR): |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 151 | s, end = s_and_end |
Raymond Hettinger | 0ad98d8 | 2009-04-21 03:09:17 +0000 | [diff] [blame] | 152 | pairs = [] |
| 153 | pairs_append = pairs.append |
Antoine Pitrou | 7d6e076 | 2010-09-04 20:16:53 +0000 | [diff] [blame] | 154 | # Backwards compatibility |
| 155 | if memo is None: |
| 156 | memo = {} |
| 157 | memo_get = memo.setdefault |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 158 | # Use a slice to prevent IndexError from being raised, the following |
| 159 | # check will raise a more specific ValueError if the string is empty |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 160 | nextchar = s[end:end + 1] |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 161 | # Normally we expect nextchar == '"' |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 162 | if nextchar != '"': |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 163 | if nextchar in _ws: |
| 164 | end = _w(s, end).end() |
| 165 | nextchar = s[end:end + 1] |
| 166 | # Trivial empty object |
| 167 | if nextchar == '}': |
Ezio Melotti | d210aa1 | 2011-04-13 07:10:13 +0300 | [diff] [blame] | 168 | if object_pairs_hook is not None: |
| 169 | result = object_pairs_hook(pairs) |
| 170 | return result, end |
| 171 | pairs = {} |
| 172 | if object_hook is not None: |
| 173 | pairs = object_hook(pairs) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 174 | return pairs, end + 1 |
| 175 | elif nextchar != '"': |
| 176 | raise ValueError(errmsg("Expecting property name", s, end)) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 177 | end += 1 |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 178 | while True: |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 179 | key, end = scanstring(s, end, strict) |
Antoine Pitrou | 7d6e076 | 2010-09-04 20:16:53 +0000 | [diff] [blame] | 180 | key = memo_get(key, key) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 181 | # To skip some function call overhead we optimize the fast paths where |
| 182 | # the JSON key separator is ": " or just ":". |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 183 | if s[end:end + 1] != ':': |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 184 | end = _w(s, end).end() |
| 185 | if s[end:end + 1] != ':': |
| 186 | raise ValueError(errmsg("Expecting : delimiter", s, end)) |
| 187 | end += 1 |
| 188 | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 189 | try: |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 190 | if s[end] in _ws: |
| 191 | end += 1 |
| 192 | if s[end] in _ws: |
| 193 | end = _w(s, end + 1).end() |
| 194 | except IndexError: |
| 195 | pass |
| 196 | |
| 197 | try: |
| 198 | value, end = scan_once(s, end) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 199 | except StopIteration: |
| 200 | raise ValueError(errmsg("Expecting object", s, end)) |
Raymond Hettinger | 0ad98d8 | 2009-04-21 03:09:17 +0000 | [diff] [blame] | 201 | pairs_append((key, value)) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 202 | try: |
| 203 | nextchar = s[end] |
| 204 | if nextchar in _ws: |
| 205 | end = _w(s, end + 1).end() |
| 206 | nextchar = s[end] |
| 207 | except IndexError: |
| 208 | nextchar = '' |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 209 | end += 1 |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 210 | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 211 | if nextchar == '}': |
| 212 | break |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 213 | elif nextchar != ',': |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 214 | raise ValueError(errmsg("Expecting , delimiter", s, end - 1)) |
| 215 | end = _w(s, end).end() |
| 216 | nextchar = s[end:end + 1] |
| 217 | end += 1 |
| 218 | if nextchar != '"': |
| 219 | raise ValueError(errmsg("Expecting property name", s, end - 1)) |
Raymond Hettinger | 0ad98d8 | 2009-04-21 03:09:17 +0000 | [diff] [blame] | 220 | if object_pairs_hook is not None: |
| 221 | result = object_pairs_hook(pairs) |
| 222 | return result, end |
| 223 | pairs = dict(pairs) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 224 | if object_hook is not None: |
| 225 | pairs = object_hook(pairs) |
| 226 | return pairs, end |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 227 | |
Antoine Pitrou | 7d6e076 | 2010-09-04 20:16:53 +0000 | [diff] [blame] | 228 | def JSONArray(s_and_end, scan_once, _w=WHITESPACE.match, _ws=WHITESPACE_STR): |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 229 | s, end = s_and_end |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 230 | values = [] |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 231 | nextchar = s[end:end + 1] |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 232 | if nextchar in _ws: |
| 233 | end = _w(s, end + 1).end() |
| 234 | nextchar = s[end:end + 1] |
| 235 | # Look-ahead for trivial empty array |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 236 | if nextchar == ']': |
| 237 | return values, end + 1 |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 238 | _append = values.append |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 239 | while True: |
| 240 | try: |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 241 | value, end = scan_once(s, end) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 242 | except StopIteration: |
| 243 | raise ValueError(errmsg("Expecting object", s, end)) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 244 | _append(value) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 245 | nextchar = s[end:end + 1] |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 246 | if nextchar in _ws: |
| 247 | end = _w(s, end + 1).end() |
| 248 | nextchar = s[end:end + 1] |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 249 | end += 1 |
| 250 | if nextchar == ']': |
| 251 | break |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 252 | elif nextchar != ',': |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 253 | raise ValueError(errmsg("Expecting , delimiter", s, end)) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 254 | try: |
| 255 | if s[end] in _ws: |
| 256 | end += 1 |
| 257 | if s[end] in _ws: |
| 258 | end = _w(s, end + 1).end() |
| 259 | except IndexError: |
| 260 | pass |
| 261 | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 262 | return values, end |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 263 | |
| 264 | |
| 265 | class JSONDecoder(object): |
| 266 | """Simple JSON <http://json.org> decoder |
| 267 | |
| 268 | Performs the following translations in decoding by default: |
| 269 | |
| 270 | +---------------+-------------------+ |
| 271 | | JSON | Python | |
| 272 | +===============+===================+ |
| 273 | | object | dict | |
| 274 | +---------------+-------------------+ |
| 275 | | array | list | |
| 276 | +---------------+-------------------+ |
Georg Brandl | c8284cf | 2010-08-02 20:16:18 +0000 | [diff] [blame] | 277 | | string | str | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 278 | +---------------+-------------------+ |
Georg Brandl | c8284cf | 2010-08-02 20:16:18 +0000 | [diff] [blame] | 279 | | number (int) | int | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 280 | +---------------+-------------------+ |
| 281 | | number (real) | float | |
| 282 | +---------------+-------------------+ |
| 283 | | true | True | |
| 284 | +---------------+-------------------+ |
| 285 | | false | False | |
| 286 | +---------------+-------------------+ |
| 287 | | null | None | |
| 288 | +---------------+-------------------+ |
| 289 | |
| 290 | It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as |
| 291 | their corresponding ``float`` values, which is outside the JSON spec. |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 292 | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 293 | """ |
| 294 | |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 295 | def __init__(self, object_hook=None, parse_float=None, |
Raymond Hettinger | 0ad98d8 | 2009-04-21 03:09:17 +0000 | [diff] [blame] | 296 | parse_int=None, parse_constant=None, strict=True, |
| 297 | object_pairs_hook=None): |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 298 | """``object_hook``, if specified, will be called with the result |
| 299 | of every JSON object decoded and its return value will be used in |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 300 | place of the given ``dict``. This can be used to provide custom |
| 301 | deserializations (e.g. to support JSON-RPC class hinting). |
| 302 | |
Georg Brandl | d4460aa | 2010-10-15 17:03:02 +0000 | [diff] [blame] | 303 | ``object_pairs_hook``, if specified will be called with the result of |
| 304 | every JSON object decoded with an ordered list of pairs. The return |
| 305 | value of ``object_pairs_hook`` will be used instead of the ``dict``. |
| 306 | This feature can be used to implement custom decoders that rely on the |
| 307 | order that the key and value pairs are decoded (for example, |
| 308 | collections.OrderedDict will remember the order of insertion). If |
| 309 | ``object_hook`` is also defined, the ``object_pairs_hook`` takes |
| 310 | priority. |
| 311 | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 312 | ``parse_float``, if specified, will be called with the string |
| 313 | of every JSON float to be decoded. By default this is equivalent to |
| 314 | float(num_str). This can be used to use another datatype or parser |
| 315 | for JSON floats (e.g. decimal.Decimal). |
| 316 | |
| 317 | ``parse_int``, if specified, will be called with the string |
| 318 | of every JSON int to be decoded. By default this is equivalent to |
| 319 | int(num_str). This can be used to use another datatype or parser |
| 320 | for JSON integers (e.g. float). |
| 321 | |
| 322 | ``parse_constant``, if specified, will be called with one of the |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 323 | following strings: -Infinity, Infinity, NaN. |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 324 | This can be used to raise an exception if invalid JSON numbers |
| 325 | are encountered. |
| 326 | |
Georg Brandl | d4460aa | 2010-10-15 17:03:02 +0000 | [diff] [blame] | 327 | If ``strict`` is false (true is the default), then control |
| 328 | characters will be allowed inside strings. Control characters in |
| 329 | this context are those with character codes in the 0-31 range, |
| 330 | including ``'\\t'`` (tab), ``'\\n'``, ``'\\r'`` and ``'\\0'``. |
| 331 | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 332 | """ |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 333 | self.object_hook = object_hook |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 334 | self.parse_float = parse_float or float |
| 335 | self.parse_int = parse_int or int |
| 336 | self.parse_constant = parse_constant or _CONSTANTS.__getitem__ |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 337 | self.strict = strict |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 338 | self.object_pairs_hook = object_pairs_hook |
| 339 | self.parse_object = JSONObject |
| 340 | self.parse_array = JSONArray |
| 341 | self.parse_string = scanstring |
Antoine Pitrou | 7d6e076 | 2010-09-04 20:16:53 +0000 | [diff] [blame] | 342 | self.memo = {} |
Ezio Melotti | 6b60fb9 | 2011-05-14 06:47:51 +0300 | [diff] [blame] | 343 | self.scan_once = scanner.make_scanner(self) |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 344 | |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 345 | |
| 346 | def decode(self, s, _w=WHITESPACE.match): |
Georg Brandl | c8284cf | 2010-08-02 20:16:18 +0000 | [diff] [blame] | 347 | """Return the Python representation of ``s`` (a ``str`` instance |
| 348 | containing a JSON document). |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 349 | |
| 350 | """ |
| 351 | obj, end = self.raw_decode(s, idx=_w(s, 0).end()) |
| 352 | end = _w(s, end).end() |
| 353 | if end != len(s): |
| 354 | raise ValueError(errmsg("Extra data", s, end, len(s))) |
| 355 | return obj |
| 356 | |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 357 | def raw_decode(self, s, idx=0): |
Georg Brandl | c8284cf | 2010-08-02 20:16:18 +0000 | [diff] [blame] | 358 | """Decode a JSON document from ``s`` (a ``str`` beginning with |
| 359 | a JSON document) and return a 2-tuple of the Python |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 360 | representation and the index in ``s`` where the document ended. |
| 361 | |
| 362 | This can be used to decode a JSON document from a string that may |
| 363 | have extraneous data at the end. |
| 364 | |
| 365 | """ |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 366 | try: |
Benjamin Peterson | c6b607d | 2009-05-02 12:36:44 +0000 | [diff] [blame] | 367 | obj, end = self.scan_once(s, idx) |
Christian Heimes | 9054000 | 2008-05-08 14:29:10 +0000 | [diff] [blame] | 368 | except StopIteration: |
| 369 | raise ValueError("No JSON object could be decoded") |
| 370 | return obj, end |