From 0ad98d8509764ee3947c481103e1e735cc048305 Mon Sep 17 00:00:00 2001 From: Raymond Hettinger Date: Tue, 21 Apr 2009 03:09:17 +0000 Subject: [PATCH] Forward port r70471: Add object_pairs_hook. Issue 5381. --- Lib/json/__init__.py | 13 ++++++++----- Lib/json/decoder.py | 14 +++++++++++--- Lib/json/tests/test_decode.py | 19 +++++++++++++++++++ Lib/json/tests/test_unicode.py | 16 ++++++++++++++++ 4 files changed, 54 insertions(+), 8 deletions(-) diff --git a/Lib/json/__init__.py b/Lib/json/__init__.py index c419c780e1..1ccde875ca 100644 --- a/Lib/json/__init__.py +++ b/Lib/json/__init__.py @@ -237,11 +237,12 @@ def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, **kw).encode(obj) -_default_decoder = JSONDecoder(encoding=None, object_hook=None) +_default_decoder = JSONDecoder(encoding=None, object_hook=None, + object_pairs_hook=None) def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None, - parse_int=None, parse_constant=None, **kw): + parse_int=None, parse_constant=None, object_pairs_hook=None, **kw): """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object. @@ -264,11 +265,11 @@ def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None, return loads(fp.read(), encoding=encoding, cls=cls, object_hook=object_hook, parse_float=parse_float, parse_int=parse_int, - parse_constant=parse_constant, **kw) + parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw) def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, - parse_int=None, parse_constant=None, **kw): + parse_int=None, parse_constant=None, object_pairs_hook=None, **kw): """Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON document) to a Python object. @@ -303,12 +304,14 @@ def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, """ if (cls is None and encoding is None and object_hook is None and parse_int is None and parse_float is None and - parse_constant is None and not kw): + parse_constant is None and object_pairs_hook is None and not kw): return _default_decoder.decode(s) if cls is None: cls = JSONDecoder if object_hook is not None: kw['object_hook'] = object_hook + if object_pairs_hook is not None: + kw['object_pairs_hook'] = object_pairs_hook if parse_float is not None: kw['parse_float'] = parse_float if parse_int is not None: diff --git a/Lib/json/decoder.py b/Lib/json/decoder.py index 4e88ba6cc9..b71215b0c1 100644 --- a/Lib/json/decoder.py +++ b/Lib/json/decoder.py @@ -164,7 +164,8 @@ WHITESPACE = re.compile(r'\s*', FLAGS) def JSONObject(match, context, _w=WHITESPACE.match): - pairs = {} + pairs = [] + pairs_append = pairs.append s = match.string end = _w(s, match.end()).end() nextchar = s[end:end + 1] @@ -187,7 +188,7 @@ def JSONObject(match, context, _w=WHITESPACE.match): value, end = next(iterscan(s, idx=end, context=context)) except StopIteration: raise ValueError(errmsg("Expecting object", s, end)) - pairs[key] = value + pairs_append((key, value)) end = _w(s, end).end() nextchar = s[end:end + 1] end += 1 @@ -200,6 +201,11 @@ def JSONObject(match, context, _w=WHITESPACE.match): end += 1 if nextchar != '"': raise ValueError(errmsg("Expecting property name", s, end - 1)) + object_pairs_hook = getattr(context, 'object_pairs_hook', None) + if object_pairs_hook is not None: + result = object_pairs_hook(pairs) + return result, end + pairs = dict(pairs) object_hook = getattr(context, 'object_hook', None) if object_hook is not None: pairs = object_hook(pairs) @@ -278,7 +284,8 @@ class JSONDecoder(object): __all__ = ['__init__', 'decode', 'raw_decode'] def __init__(self, encoding=None, object_hook=None, parse_float=None, - parse_int=None, parse_constant=None, strict=True): + parse_int=None, parse_constant=None, strict=True, + object_pairs_hook=None): """``encoding`` determines the encoding used to interpret any ``str`` objects decoded by this instance (utf-8 by default). It has no effect when decoding ``unicode`` objects. @@ -309,6 +316,7 @@ class JSONDecoder(object): """ self.encoding = encoding self.object_hook = object_hook + self.object_pairs_hook = object_pairs_hook self.parse_float = parse_float self.parse_int = parse_int self.parse_constant = parse_constant diff --git a/Lib/json/tests/test_decode.py b/Lib/json/tests/test_decode.py index 609f62288c..67c4c295dd 100644 --- a/Lib/json/tests/test_decode.py +++ b/Lib/json/tests/test_decode.py @@ -1,7 +1,9 @@ import decimal from unittest import TestCase +from io import StringIO import json +from collections import OrderedDict class TestDecode(TestCase): def test_decimal(self): @@ -13,3 +15,20 @@ class TestDecode(TestCase): rval = json.loads('1', parse_int=float) self.assert_(isinstance(rval, float)) self.assertEquals(rval, 1.0) + + def test_object_pairs_hook(self): + s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}' + p = [("xkd", 1), ("kcw", 2), ("art", 3), ("hxm", 4), + ("qrt", 5), ("pad", 6), ("hoy", 7)] + self.assertEqual(json.loads(s), eval(s)) + self.assertEqual(json.loads(s, object_pairs_hook = lambda x: x), p) + self.assertEqual(json.load(StringIO(s), + object_pairs_hook=lambda x: x), p) + od = json.loads(s, object_pairs_hook = OrderedDict) + self.assertEqual(od, OrderedDict(p)) + self.assertEqual(type(od), OrderedDict) + # the object_pairs_hook takes priority over the object_hook + self.assertEqual(json.loads(s, + object_pairs_hook = OrderedDict, + object_hook = lambda x: None), + OrderedDict(p)) diff --git a/Lib/json/tests/test_unicode.py b/Lib/json/tests/test_unicode.py index 7b9c9562a6..00bf58e5e3 100644 --- a/Lib/json/tests/test_unicode.py +++ b/Lib/json/tests/test_unicode.py @@ -1,6 +1,7 @@ from unittest import TestCase import json +from collections import OrderedDict class TestUnicode(TestCase): def test_encoding1(self): @@ -53,3 +54,18 @@ class TestUnicode(TestCase): u = chr(i) js = '"\\u{0:04x}"'.format(i) self.assertEquals(json.loads(js), u) + + def test_object_pairs_hook_with_unicode(self): + s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}' + p = [("xkd", 1), ("kcw", 2), ("art", 3), ("hxm", 4), + ("qrt", 5), ("pad", 6), ("hoy", 7)] + self.assertEqual(json.loads(s), eval(s)) + self.assertEqual(json.loads(s, object_pairs_hook = lambda x: x), p) + od = json.loads(s, object_pairs_hook = OrderedDict) + self.assertEqual(od, OrderedDict(p)) + self.assertEqual(type(od), OrderedDict) + # the object_pairs_hook takes priority over the object_hook + self.assertEqual(json.loads(s, + object_pairs_hook = OrderedDict, + object_hook = lambda x: None), + OrderedDict(p)) -- 2.40.0