simplejson 4.1.0__tar.gz → 4.1.2__tar.gz

{simplejson-4.1.0 → simplejson-4.1.2}/CHANGES.txt

@@ -1,3 +1,27 @@
+Version 4.1.2 released 2026-08-26
+
+* Fix control character error position when content precedes the control char
+  https://github.com/simplejson/simplejson/pull/379
+* Report the offending char, not the backslash, for invalid \X escapes
+  https://github.com/simplejson/simplejson/pull/380
+* Handle non-finite Decimals like floats in the encoder
+  https://github.com/simplejson/simplejson/pull/381
+* Parse failures due to trailing commas are now reported consistently
+  across implementations
+  https://github.com/simplejson/simplejson/pull/382
+
+Version 4.1.1 released 2026-04-24
+
+* The ``build_wheels_py27`` CI job now also builds Python 2.7 wheels
+  for Windows AMD64 and Windows x86, joining the existing Py2.7
+  manylinux1 / manylinux2010 x86_64 wheels. This unblocks offline /
+  ``--no-index`` installs on Py2.7-on-Windows (the original
+  reporter's case), which previously had no matching binary wheel on
+  PyPI, fell through to the sdist, and failed on the PEP 517
+  isolated-build step complaining that ``setuptools>=42`` was not in
+  the wheelhouse.
+  https://github.com/simplejson/simplejson/issues/377
+
 Version 4.1.0 released 2026-04-22
 
 * The C extension now accelerates encoding when ``indent=`` is set.

{simplejson-4.1.0/simplejson.egg-info → simplejson-4.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplejson
-Version: 4.1.0
+Version: 4.1.2
 Summary: Simple, fast, extensible JSON encoder/decoder for Python
 Home-page: https://github.com/simplejson/simplejson
 Author: Bob Ippolito

{simplejson-4.1.0 → simplejson-4.1.2}/conf.py

@@ -36,7 +36,7 @@ master_doc = 'index'
 
 # General substitutions.
 project = 'simplejson'
-copyright = '2025, Bob Ippolito'
+copyright = '2026, Bob Ippolito'
 
 # The default replacements for |version| and |release|, also used in various
 # other places throughout the built documents.
@@ -44,7 +44,7 @@ copyright = '2025, Bob Ippolito'
 # The short X.Y version.
 version = '4.1'
 # The full version, including alpha/beta/rc tags.
-release = '4.1.0'
+release = '4.1.2'
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:

{simplejson-4.1.0 → simplejson-4.1.2}/setup.py

@@ -12,7 +12,7 @@ from distutils.errors import CCompilerError, DistutilsExecError, \
 
 IS_PYPY = hasattr(sys, 'pypy_translation_info')
 IS_GRAALPY = getattr(getattr(sys, "implementation", None), "name", None) == "graalpy"
-VERSION = '4.1.0'
+VERSION = '4.1.2'
 DESCRIPTION = "Simple, fast, extensible JSON encoder/decoder for Python"
 
 with open('README.rst', 'r') as f:

{simplejson-4.1.0 → simplejson-4.1.2}/simplejson/__init__.py

@@ -118,7 +118,7 @@ Serializing multiple objects to JSON lines (newline-delimited JSON)::
 
 """
 from __future__ import absolute_import
-__version__ = '4.1.0'
+__version__ = '4.1.2'
 __all__ = [
     'dump', 'dumps', 'load', 'loads',
     'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',

{simplejson-4.1.0 → simplejson-4.1.2}/simplejson/_speedups.c

@@ -429,6 +429,8 @@ static PyObject *
 encoder_long_to_str(PyObject *obj);
 static PyObject *
 encoder_encode_float(PyEncoderObject *s, PyObject *obj);
+static PyObject *
+encoder_encode_decimal(PyEncoderObject *s, PyObject *obj);
 static int
 encoder_accumulate_newline_indent(PyEncoderObject *s, _speedups_state *state,
                                   JSON_Accu *rval, Py_ssize_t indent_level);
@@ -1062,7 +1064,7 @@ encoder_stringify_key(PyEncoderObject *s, PyObject *key)
         return encoder_long_to_str(key);
     }
     else if (s->use_decimal && PyObject_TypeCheck(key, (PyTypeObject *)s->Decimal)) {
-        return PyObject_Str(key);
+        return encoder_encode_decimal(s, key);
     }
     if (s->skipkeys) {
         Py_INCREF(Py_None);
@@ -1365,7 +1367,7 @@ scanstring_str(_speedups_state *state, PyObject *pystr, Py_ssize_t end,
                 default: c = 0;
             }
             if (c == 0) {
-                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 2);
+                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 1);
                 goto bail;
             }
         }
@@ -1564,7 +1566,7 @@ scanstring_unicode(_speedups_state *state, PyObject *pystr, Py_ssize_t end,
                 default: c = 0;
             }
             if (c == 0) {
-                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 2);
+                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 1);
                 goto bail;
             }
         }
@@ -1755,7 +1757,7 @@ scanstring_unicode(_speedups_state *state, PyObject *pystr, Py_ssize_t end,
                 default: c = 0;
             }
             if (c == 0) {
-                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 2);
+                raise_errmsg(state, ERR_STRING_ESC1, pystr, end - 1);
                 goto bail;
             }
         }
@@ -2785,33 +2787,38 @@ _encoded_const(_speedups_state *state, PyObject *obj)
     }
 }
 
+static PyObject *
+encoder_encode_nonfinite(PyEncoderObject *s, int sign)
+{
+    _speedups_state *state = get_speedups_state(s->module_ref);
+
+    if (!s->allow_or_ignore_nan) {
+        PyErr_SetString(PyExc_ValueError, "Out of range float values are not JSON compliant");
+        return NULL;
+    }
+    if (s->allow_or_ignore_nan & JSON_IGNORE_NAN) {
+        return _encoded_const(state, Py_None);
+    }
+    /* JSON_ALLOW_NAN is set */
+    if (sign > 0) {
+        Py_INCREF(state->JSON_Infinity);
+        return state->JSON_Infinity;
+    }
+    if (sign < 0) {
+        Py_INCREF(state->JSON_NegInfinity);
+        return state->JSON_NegInfinity;
+    }
+    Py_INCREF(state->JSON_NaN);
+    return state->JSON_NaN;
+}
+
 static PyObject *
 encoder_encode_float(PyEncoderObject *s, PyObject *obj)
 {
     /* Return the JSON representation of a PyFloat */
-    _speedups_state *state = get_speedups_state(s->module_ref);
     double i = PyFloat_AS_DOUBLE(obj);
     if (!Py_IS_FINITE(i)) {
-        if (!s->allow_or_ignore_nan) {
-            PyErr_SetString(PyExc_ValueError, "Out of range float values are not JSON compliant");
-            return NULL;
-        }
-        if (s->allow_or_ignore_nan & JSON_IGNORE_NAN) {
-            return _encoded_const(state, Py_None);
-        }
-        /* JSON_ALLOW_NAN is set */
-        else if (i > 0) {
-            Py_INCREF(state->JSON_Infinity);
-            return state->JSON_Infinity;
-        }
-        else if (i < 0) {
-            Py_INCREF(state->JSON_NegInfinity);
-            return state->JSON_NegInfinity;
-        }
-        else {
-            Py_INCREF(state->JSON_NaN);
-            return state->JSON_NaN;
-        }
+        return encoder_encode_nonfinite(s, i > 0 ? 1 : (i < 0 ? -1 : 0));
     }
     /* Use a better float format here? */
     if (PyFloat_CheckExact(obj)) {
@@ -2830,6 +2837,61 @@ encoder_encode_float(PyEncoderObject *s, PyObject *obj)
     }
 }
 
+static PyObject *
+encoder_encode_decimal(PyEncoderObject *s, PyObject *obj)
+{
+    /* Return the JSON representation of a Decimal. Finite Decimals are
+       stringified as-is (preserving precision and trailing zeros); non-finite
+       Decimals (NaN, sNaN, Infinity) are routed through the same
+       allow_nan/ignore_nan handling as floats so they never emit invalid
+       JSON. See https://github.com/simplejson/simplejson/issues/149
+
+       str(Decimal) carries a leading '-' sign at most (never '+'); a finite
+       value's first significant character is always a digit while a non-finite
+       value's is a letter ('N'/'s' for [s]NaN, 'I' for Infinity). So a single
+       str() plus a one/two character check distinguishes the two. */
+    PyObject *str = PyObject_Str(obj);
+    Py_ssize_t len;
+    int negative;
+    JSON_UNICHR c;
+#if PY_MAJOR_VERSION >= 3
+    int kind;
+    void *data;
+#else
+    const char *data;
+#endif
+    if (str == NULL)
+        return NULL;
+#if PY_MAJOR_VERSION >= 3
+    if (PyUnicode_READY(str)) {
+        Py_DECREF(str);
+        return NULL;
+    }
+    len = PyUnicode_GET_LENGTH(str);
+    kind = PyUnicode_KIND(str);
+    data = PyUnicode_DATA(str);
+    negative = (len > 0 && PyUnicode_READ(kind, data, 0) == '-');
+    c = (JSON_UNICHR)0;
+    if (len > (negative ? 1 : 0))
+        c = PyUnicode_READ(kind, data, negative ? 1 : 0);
+#else
+    len = PyString_GET_SIZE(str);
+    data = PyString_AS_STRING(str);
+    negative = (len > 0 && data[0] == '-');
+    c = (JSON_UNICHR)0;
+    if (len > (negative ? 1 : 0))
+        c = (unsigned char)data[negative ? 1 : 0];
+#endif
+    if (IS_DIGIT(c)) {
+        /* First significant character is a digit: finite Decimal, emit as-is. */
+        return str;
+    }
+    /* Non-finite Decimal; use the same allow_nan/ignore_nan path as floats
+       without creating a temporary float. */
+    Py_DECREF(str);
+    return encoder_encode_nonfinite(s, c == 'I' ? (negative ? -1 : 1) : 0);
+}
+
 static PyObject *
 encoder_encode_string(PyEncoderObject *s, PyObject *obj)
 {
@@ -3090,7 +3152,7 @@ encoder_listencode_obj(PyEncoderObject *s, JSON_Accu *rval, PyObject *obj, Py_ss
         Py_LeaveRecursiveCall();
     }
     else if (s->use_decimal && PyObject_TypeCheck(obj, (PyTypeObject *)s->Decimal)) {
-        PyObject *encoded = PyObject_Str(obj);
+        PyObject *encoded = encoder_encode_decimal(s, obj);
         if (encoded != NULL)
             rv = _steal_accumulate(state, rval, encoded);
     }

{simplejson-4.1.0 → simplejson-4.1.2}/simplejson/_speedups_scan.h

@@ -204,6 +204,7 @@ JSON_SCAN_FN(_parse_object)(PyScannerObject *s, PyObject *pystr,
     /* only loop if the object is non-empty */
     if (idx <= end_idx && JSON_SCAN_READ(idx) != '}') {
         int trailing_delimiter = 0;
+        Py_ssize_t comma_idx = 0;
         while (idx <= end_idx) {
             trailing_delimiter = 0;
 
@@ -271,6 +272,7 @@ JSON_SCAN_FN(_parse_object)(PyScannerObject *s, PyObject *pystr,
                 raise_errmsg(state, ERR_OBJECT_DELIMITER, pystr, idx);
                 goto bail;
             }
+            comma_idx = idx;
             idx++;
 
             /* skip whitespace after , delimiter */
@@ -279,7 +281,7 @@ JSON_SCAN_FN(_parse_object)(PyScannerObject *s, PyObject *pystr,
 
             /* check for trailing comma before } */
             if (idx <= end_idx && JSON_SCAN_READ(idx) == '}') {
-                raise_errmsg(state, ERR_TRAILING_COMMA_OBJECT, pystr, idx);
+                raise_errmsg(state, ERR_TRAILING_COMMA_OBJECT, pystr, comma_idx);
                 goto bail;
             }
         }
@@ -351,6 +353,7 @@ JSON_SCAN_FN(_parse_array)(PyScannerObject *s, PyObject *pystr,
     /* only loop if the array is non-empty */
     if (idx <= end_idx && JSON_SCAN_READ(idx) != ']') {
         int trailing_delimiter = 0;
+        Py_ssize_t comma_idx = 0;
         while (idx <= end_idx) {
             trailing_delimiter = 0;
             /* read any JSON term and de-tuplefy the (rval, idx) */
@@ -377,6 +380,7 @@ JSON_SCAN_FN(_parse_array)(PyScannerObject *s, PyObject *pystr,
                 raise_errmsg(state, ERR_ARRAY_DELIMITER, pystr, idx);
                 goto bail;
             }
+            comma_idx = idx;
             idx++;
 
             /* skip whitespace after , */
@@ -385,7 +389,7 @@ JSON_SCAN_FN(_parse_array)(PyScannerObject *s, PyObject *pystr,
 
             /* check for trailing comma before ] */
             if (idx <= end_idx && JSON_SCAN_READ(idx) == ']') {
-                raise_errmsg(state, ERR_TRAILING_COMMA_ARRAY, pystr, idx);
+                raise_errmsg(state, ERR_TRAILING_COMMA_ARRAY, pystr, comma_idx);
                 goto bail;
             }
         }

{simplejson-4.1.0 → simplejson-4.1.2}/simplejson/decoder.py

@@ -102,7 +102,7 @@ def py_scanstring(s, end, encoding=None, strict=True,
         elif terminator != '\\':
             if strict:
                 msg = "Invalid control character %r at"
-                raise JSONDecodeError(msg, s, prev_end)
+                raise JSONDecodeError(msg, s, end - 1)
             else:
                 _append(terminator)
                 continue
@@ -213,6 +213,7 @@ def JSONObject(state, encoding, strict, scan_once, object_hook,
             break
         elif nextchar != ',':
             raise JSONDecodeError("Expecting ',' delimiter or '}'", s, end - 1)
+        comma_idx = end - 1
 
         try:
             nextchar = s[end]
@@ -230,7 +231,7 @@ def JSONObject(state, encoding, strict, scan_once, object_hook,
             if nextchar == '}':
                 raise JSONDecodeError(
                     "Illegal trailing comma before end of object",
-                    s, end - 1)
+                    s, comma_idx)
             raise JSONDecodeError(
                 "Expecting property name enclosed in double quotes",
                 s, end - 1)
@@ -271,6 +272,7 @@ def JSONArray(state, scan_once, array_hook=None,
             break
         elif nextchar != ',':
             raise JSONDecodeError("Expecting ',' delimiter or ']'", s, end - 1)
+        comma_idx = end - 1
 
         try:
             if s[end] in _ws:
@@ -283,7 +285,7 @@ def JSONArray(state, scan_once, array_hook=None,
         if s[end:end + 1] == ']':
             raise JSONDecodeError(
                 "Illegal trailing comma before end of array",
-                s, end - 1)
+                s, comma_idx)
 
     if array_hook is not None:
         values = array_hook(values)

{simplejson-4.1.0 → simplejson-4.1.2}/simplejson/encoder.py

@@ -43,6 +43,35 @@ del i
 
 FLOAT_REPR = repr
 
+_NAN = float('nan')
+_INFINITY = float('inf')
+
+
+def _encode_decimal(d, _floatstr):
+    """Return the JSON representation of a ``Decimal``.
+
+    Finite Decimals are stringified as-is, preserving precision and trailing
+    zeros.  Non-finite Decimals (``NaN``, ``sNaN``, ``Infinity``) are routed
+    through the same ``allow_nan``/``ignore_nan`` handling as floats so they
+    never emit invalid JSON (see #149).
+
+    ``str(Decimal)`` yields a leading ``-`` sign at most (never ``+``); a
+    finite value's first significant character is always a digit, while a
+    non-finite value's is a letter (``N``, ``s`` or ``I``).  So a single
+    ``str()`` plus a one/two character check distinguishes the two.
+    """
+    s = str(d)
+    c0 = s[:1]
+    c = s[1:2] if c0 == '-' else c0
+    if '0' <= c <= '9':
+        # First significant character is a digit: finite Decimal.
+        return s
+    # Non-finite Decimal. ``N``/``s`` -> NaN (float(Decimal('sNaN')) raises,
+    # so map both quiet and signaling NaN to a plain NaN); ``I`` -> Infinity.
+    if c == 'I':
+        return _floatstr(-_INFINITY if c0 == '-' else _INFINITY)
+    return _floatstr(_NAN)
+
 # dict-like types that should be encoded as JSON objects.
 # frozendict is a builtin added in CPython 3.15 (PEP 814).
 if sys.version_info >= (3, 15):
@@ -536,7 +565,7 @@ def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
                 elif isinstance(value, float):
                     yield buf + _floatstr(value)
                 elif _use_decimal and isinstance(value, Decimal):
-                    yield buf + str(value)
+                    yield buf + _encode_decimal(value, _floatstr)
                 else:
                     yield buf
                     for_json = _for_json and call_method(value, 'for_json')
@@ -596,7 +625,7 @@ def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
                 key = int(key)
             key = str(key)
         elif _use_decimal and isinstance(key, Decimal):
-            key = str(key)
+            key = _encode_decimal(key, _floatstr)
         elif _skipkeys:
             key = None
         else:
@@ -668,7 +697,7 @@ def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
                 elif isinstance(value, float):
                     yield _floatstr(value)
                 elif _use_decimal and isinstance(value, Decimal):
-                    yield str(value)
+                    yield _encode_decimal(value, _floatstr)
                 else:
                     for_json = _for_json and call_method(value, 'for_json')
                     if for_json:
@@ -744,7 +773,7 @@ def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
                     for chunk in _iterencode_dict(o, _current_indent_level):
                         yield chunk
                 elif _use_decimal and isinstance(o, Decimal):
-                    yield str(o)
+                    yield _encode_decimal(o, _floatstr)
                 else:
                     while _iterable_as_array:
                         # Markers are not checked here because it is valid for

simplejson-4.1.2/simplejson/tests/test_decimal.py

@@ -0,0 +1,133 @@
+import decimal
+from decimal import Decimal
+from unittest import TestCase
+from simplejson.compat import StringIO, reload_module
+
+import simplejson as json
+
+class TestDecimal(TestCase):
+    NUMS = "1.0", "10.00", "1.1", "1234567890.1234567890", "500"
+    def dumps(self, obj, **kw):
+        sio = StringIO()
+        json.dump(obj, sio, **kw)
+        res = json.dumps(obj, **kw)
+        self.assertEqual(res, sio.getvalue())
+        return res
+
+    def loads(self, s, **kw):
+        sio = StringIO(s)
+        res = json.loads(s, **kw)
+        self.assertEqual(res, json.load(sio, **kw))
+        return res
+
+    def test_decimal_encode(self):
+        for d in map(Decimal, self.NUMS):
+            self.assertEqual(self.dumps(d, use_decimal=True), str(d))
+
+    def test_decimal_decode(self):
+        for s in self.NUMS:
+            self.assertEqual(self.loads(s, parse_float=Decimal), Decimal(s))
+
+    def test_stringify_key(self):
+        for d in map(Decimal, self.NUMS):
+            v = {d: d}
+            self.assertEqual(
+                self.loads(
+                    self.dumps(v, use_decimal=True), parse_float=Decimal),
+                {str(d): d})
+
+    def test_decimal_roundtrip(self):
+        for d in map(Decimal, self.NUMS):
+            # The type might not be the same (int and Decimal) but they
+            # should still compare equal.
+            for v in [d, [d], {'': d}]:
+                self.assertEqual(
+                    self.loads(
+                        self.dumps(v, use_decimal=True), parse_float=Decimal),
+                    v)
+
+    def test_decimal_defaults(self):
+        d = Decimal('1.1')
+        # use_decimal=True is the default
+        self.assertRaises(TypeError, json.dumps, d, use_decimal=False)
+        self.assertEqual('1.1', json.dumps(d))
+        self.assertEqual('1.1', json.dumps(d, use_decimal=True))
+        self.assertRaises(TypeError, json.dump, d, StringIO(),
+                          use_decimal=False)
+        sio = StringIO()
+        json.dump(d, sio)
+        self.assertEqual('1.1', sio.getvalue())
+        sio = StringIO()
+        json.dump(d, sio, use_decimal=True)
+        self.assertEqual('1.1', sio.getvalue())
+
+    def test_decimal_reload(self):
+        # Simulate a subinterpreter that reloads the Python modules but not
+        # the C code https://github.com/simplejson/simplejson/issues/34
+        global Decimal
+        Decimal = reload_module(decimal).Decimal
+        import simplejson.encoder
+        simplejson.encoder.Decimal = Decimal
+        self.test_decimal_roundtrip()
+
+    def test_decimal_nan_allow(self):
+        # Non-finite Decimals should be treated the same as the matching
+        # float, i.e. emit the JavaScript literals when allow_nan is true.
+        # https://github.com/simplejson/simplejson/issues/149
+        self.assertEqual(json.dumps(Decimal('NaN'), allow_nan=True), 'NaN')
+        self.assertEqual(
+            json.dumps(Decimal('Infinity'), allow_nan=True), 'Infinity')
+        self.assertEqual(
+            json.dumps(Decimal('-Infinity'), allow_nan=True), '-Infinity')
+        # sNaN is also not finite and must not leak through as a literal.
+        self.assertEqual(json.dumps(Decimal('sNaN'), allow_nan=True), 'NaN')
+
+    def test_decimal_nan_ignore(self):
+        # ignore_nan should emit null for non-finite Decimals, matching float.
+        # https://github.com/simplejson/simplejson/issues/149
+        for d in (Decimal('NaN'), Decimal('sNaN'),
+                  Decimal('Infinity'), Decimal('-Infinity')):
+            self.assertEqual(json.dumps(d, ignore_nan=True), 'null')
+        self.assertEqual(
+            json.dumps([Decimal('0.33'), Decimal('NaN'), Decimal('0.20')],
+                       ignore_nan=True),
+            '[0.33, null, 0.20]')
+
+    def test_decimal_nan_deny(self):
+        # allow_nan=False must raise for non-finite Decimals rather than
+        # silently emit invalid JSON.
+        # https://github.com/simplejson/simplejson/issues/149
+        for d in (Decimal('NaN'), Decimal('sNaN'),
+                  Decimal('Infinity'), Decimal('-Infinity')):
+            self.assertRaises(ValueError, json.dumps, d, allow_nan=False)
+        # allow_nan defaults to False, so a plain dumps must raise too.
+        self.assertRaises(ValueError, json.dumps, Decimal('NaN'))
+
+    def test_decimal_nan_as_value(self):
+        # Non-finite Decimals nested inside containers must be handled too.
+        self.assertEqual(
+            json.dumps({'a': Decimal('NaN')}, allow_nan=True), '{"a": NaN}')
+        self.assertEqual(
+            json.dumps({'a': Decimal('Infinity')}, ignore_nan=True),
+            '{"a": null}')
+        self.assertRaises(
+            ValueError, json.dumps, [Decimal('NaN')], allow_nan=False)
+
+    def test_decimal_nan_as_key(self):
+        # A non-finite Decimal used as a dict key follows the same rules.
+        self.assertEqual(
+            json.dumps({Decimal('NaN'): 1}, allow_nan=True), '{"NaN": 1}')
+        self.assertEqual(
+            json.dumps({Decimal('Infinity'): 1}, ignore_nan=True),
+            '{"null": 1}')
+        self.assertRaises(
+            ValueError, json.dumps, {Decimal('NaN'): 1}, allow_nan=False)
+
+    def test_decimal_finite_unaffected(self):
+        # The fix must not perturb finite Decimals, including zero and
+        # values that would lose trailing zeros if routed through float().
+        for s in ('0', '0.00', '-0', '1.50', '1E-30', '1234567890.1234567890'):
+            d = Decimal(s)
+            self.assertEqual(json.dumps(d), str(d))
+            self.assertEqual(json.dumps(d, ignore_nan=True), str(d))
+            self.assertEqual(json.dumps(d, allow_nan=True), str(d))

{simplejson-4.1.0 → simplejson-4.1.2}/simplejson/tests/test_decode.py

@@ -165,6 +165,33 @@ class TestDecode(TestCase):
                 self.assertIn(expected_msg, str(e),
                     "Wrong error for %r: %s" % (doc, e))
 
+    def test_trailing_comma_position(self):
+        # The reported position is the comma itself, not the closing
+        # bracket and not whatever whitespace happens to precede it.
+        # Same positions as the stdlib json module. Runs on both the C
+        # and the pure-Python scanner.
+        test_cases = [
+            ('[42,]', 3),
+            ('[42, ]', 3),
+            ('[42,\n]', 3),
+            ('[123  , ]', 6),
+            ('{"spam":42,}', 10),
+            ('{"spam":42 , }', 11),
+            ('{"spam":42,\n}', 10),
+            ('[[1, 2],]', 7),
+            ('{"a": {"b": 1,},}', 13),
+        ]
+        for doc, expected_pos in test_cases:
+            try:
+                json.loads(doc)
+                self.fail("Expected JSONDecodeError for %r" % (doc,))
+            except json.JSONDecodeError as e:
+                self.assertEqual(doc[e.pos], ',',
+                    "Position %d of %r is %r, not the comma"
+                    % (e.pos, doc, doc[e.pos]))
+                self.assertEqual(e.pos, expected_pos,
+                    "Wrong position for %r: %d" % (doc, e.pos))
+
     def test_nonascii_digits_rejected(self):
         # Non-ASCII digits (e.g. fullwidth digits) must not be accepted
         # as JSON numbers. Matches CPython gh-125687.

{simplejson-4.1.0 → simplejson-4.1.2}/simplejson/tests/test_fail.py

@@ -158,6 +158,8 @@ class TestFail(TestCase):
             ('[,', "Expecting value", 1),
             ('--', 'Expecting value', 0),
             ('"\x18d', "Invalid control character %r", 1),
+            # control char after content: pos must point to the control char, not start of content
+            ('"d\x18"', "Invalid control character %r", 2),
         ]
         for data, msg, idx in test_cases:
             try:

{simplejson-4.1.0 → simplejson-4.1.2}/simplejson/tests/test_scanstring.py

@@ -290,3 +290,49 @@ class TestScanString(TestCase):
             self.assertEqual(
                 scanstring(u'\\ud834\\udd1e"', 0, None, True),
                 (u'\U0001d11e', 13))
+
+    def test_single_char_escape_error_parity(self):
+        # Regression: for an invalid single-character escape (``\X``), the C
+        # scanstring reported the position of the backslash, while
+        # py_scanstring reports the position of the offending escape
+        # character itself. Because the "Invalid \\X escape sequence %r"
+        # message renders %r as the character at that position, the C path
+        # produced the nonsensical "Invalid \\X escape sequence '\\'" (naming
+        # the backslash, which is always a valid escape introducer) instead
+        # of naming the actual bad character. This asserts exact parity
+        # (position and rendered message) between the two backends, matching
+        # the \\uXXXX parity already covered by test_escape_error_parity.
+        if simplejson.decoder.c_scanstring is None:
+            return
+
+        def get_exc(scanstring, s):
+            try:
+                scanstring(s, 0, None, True)
+            except json.JSONDecodeError as e:
+                return (e.pos, str(e).split(': line ')[0])
+            return None
+
+        # Each case: (input, escape_char_index). The rendered message must
+        # name the character at escape_char_index, never the backslash.
+        cases = [
+            (u'\\x41"', 1),
+            (u'a\\q"', 2),
+            (u'\\ "', 1),
+            (u'prefix\\z"', 7),
+            (u'\\!"', 1),
+        ]
+        for s, esc_idx in cases:
+            expected = (
+                esc_idx,
+                "Invalid \\X escape sequence %r" % (s[esc_idx],))
+            py = get_exc(simplejson.decoder.py_scanstring, s)
+            c = get_exc(simplejson.decoder.c_scanstring, s)
+            self.assertEqual(py, expected,
+                             'py_scanstring(%r) expected %r, got %r' %
+                             (s, expected, py))
+            self.assertEqual(c, expected,
+                             'c_scanstring(%r) expected %r, got %r' %
+                             (s, expected, c))
+            # The reported position must land on the bad char, not the '\\'.
+            self.assertNotEqual(s[c[0]], u'\\',
+                                'c_scanstring(%r) pointed at the backslash' % (s,))

{simplejson-4.1.0 → simplejson-4.1.2/simplejson.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplejson
-Version: 4.1.0
+Version: 4.1.2
 Summary: Simple, fast, extensible JSON encoder/decoder for Python
 Home-page: https://github.com/simplejson/simplejson
 Author: Bob Ippolito

simplejson-4.1.0/simplejson/tests/test_decimal.py

@@ -1,71 +0,0 @@
-import decimal
-from decimal import Decimal
-from unittest import TestCase
-from simplejson.compat import StringIO, reload_module
-
-import simplejson as json
-
-class TestDecimal(TestCase):
-    NUMS = "1.0", "10.00", "1.1", "1234567890.1234567890", "500"
-    def dumps(self, obj, **kw):
-        sio = StringIO()
-        json.dump(obj, sio, **kw)
-        res = json.dumps(obj, **kw)
-        self.assertEqual(res, sio.getvalue())
-        return res
-
-    def loads(self, s, **kw):
-        sio = StringIO(s)
-        res = json.loads(s, **kw)
-        self.assertEqual(res, json.load(sio, **kw))
-        return res
-
-    def test_decimal_encode(self):
-        for d in map(Decimal, self.NUMS):
-            self.assertEqual(self.dumps(d, use_decimal=True), str(d))
-
-    def test_decimal_decode(self):
-        for s in self.NUMS:
-            self.assertEqual(self.loads(s, parse_float=Decimal), Decimal(s))
-
-    def test_stringify_key(self):
-        for d in map(Decimal, self.NUMS):
-            v = {d: d}
-            self.assertEqual(
-                self.loads(
-                    self.dumps(v, use_decimal=True), parse_float=Decimal),
-                {str(d): d})
-
-    def test_decimal_roundtrip(self):
-        for d in map(Decimal, self.NUMS):
-            # The type might not be the same (int and Decimal) but they
-            # should still compare equal.
-            for v in [d, [d], {'': d}]:
-                self.assertEqual(
-                    self.loads(
-                        self.dumps(v, use_decimal=True), parse_float=Decimal),
-                    v)
-
-    def test_decimal_defaults(self):
-        d = Decimal('1.1')
-        # use_decimal=True is the default
-        self.assertRaises(TypeError, json.dumps, d, use_decimal=False)
-        self.assertEqual('1.1', json.dumps(d))
-        self.assertEqual('1.1', json.dumps(d, use_decimal=True))
-        self.assertRaises(TypeError, json.dump, d, StringIO(),
-                          use_decimal=False)
-        sio = StringIO()
-        json.dump(d, sio)
-        self.assertEqual('1.1', sio.getvalue())
-        sio = StringIO()
-        json.dump(d, sio, use_decimal=True)
-        self.assertEqual('1.1', sio.getvalue())
-
-    def test_decimal_reload(self):
-        # Simulate a subinterpreter that reloads the Python modules but not
-        # the C code https://github.com/simplejson/simplejson/issues/34
-        global Decimal
-        Decimal = reload_module(decimal).Decimal
-        import simplejson.encoder
-        simplejson.encoder.Decimal = Decimal
-        self.test_decimal_roundtrip()