simplejson 4.1.2__tar.gz → 4.2.0__tar.gz

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

@@ -1,3 +1,26 @@
+Version 4.2.0 released 2026-10-02
+
+* Start building wheels for Python 3.15 and drop Python 3.8 support
+  via upgrade to cibuildwheel v4.2.0
+  https://github.com/simplejson/simplejson/pull/385
+* Build and test riscv64 Linux wheels on native RISE runners
+  https://github.com/simplejson/simplejson/pull/389
+* The C scanner now reports the same error message as the pure Python
+  decoder for an invalid first key in an object
+  https://github.com/simplejson/simplejson/pull/388
+* ``int_as_string_bitcount`` now supports thresholds of 64 bits and above
+  (including 128-bit integers) in both the C and pure Python encoders;
+  the C encoder previously rejected them
+  https://github.com/simplejson/simplejson/pull/387
+* Circular references introduced through ``for_json()`` or ``_asdict()``
+  now raise ``ValueError("Circular reference detected")`` instead of
+  recursing without bound
+  https://github.com/simplejson/simplejson/pull/390
+* CI now tests Python 3.15 (including free-threaded 3.15t), PyPy 3.12,
+  CPython 3.14.8 debug builds, and uses current GitHub Actions and
+  cibuildwheel v4.2.1
+  https://github.com/simplejson/simplejson/pull/386
+
 Version 4.1.2 released 2026-08-26
 
 * Fix control character error position when content precedes the control char

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplejson
-Version: 4.1.2
+Version: 4.2.0
 Summary: Simple, fast, extensible JSON encoder/decoder for Python
 Home-page: https://github.com/simplejson/simplejson
 Author: Bob Ippolito
@@ -14,18 +14,18 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: GraalPy
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*, !=3.8.*
 License-File: LICENSE.txt
 Dynamic: author
 Dynamic: author-email
@@ -42,7 +42,7 @@ simplejson
 ----------
 
 simplejson is a simple, fast, complete, correct and extensible
-JSON <http://json.org> encoder and decoder for Python 3.8+
+JSON <http://json.org> encoder and decoder for Python 3.9+
 with legacy support for Python 2.7.  It is pure Python code
 with no dependencies, but includes an optional C extension
 for a serious speed boost.
@@ -53,7 +53,7 @@ https://simplejson.readthedocs.io/
 simplejson is the externally maintained development version of the
 json library included with Python (since 2.6). This version is tested
 with Python 3.14 (including free-threaded builds) and maintains
-backwards compatibility with Python 3.8+. A legacy Python 2.7 wheel
+backwards compatibility with Python 3.9+. A legacy Python 2.7 wheel
 is also published.
 
 The encoder can be specialized to provide serialization in any kind of

{simplejson-4.1.2 → simplejson-4.2.0}/README.rst

@@ -2,7 +2,7 @@ simplejson
 ----------
 
 simplejson is a simple, fast, complete, correct and extensible
-JSON <http://json.org> encoder and decoder for Python 3.8+
+JSON <http://json.org> encoder and decoder for Python 3.9+
 with legacy support for Python 2.7.  It is pure Python code
 with no dependencies, but includes an optional C extension
 for a serious speed boost.
@@ -13,7 +13,7 @@ https://simplejson.readthedocs.io/
 simplejson is the externally maintained development version of the
 json library included with Python (since 2.6). This version is tested
 with Python 3.14 (including free-threaded builds) and maintains
-backwards compatibility with Python 3.8+. A legacy Python 2.7 wheel
+backwards compatibility with Python 3.9+. A legacy Python 2.7 wheel
 is also published.
 
 The encoder can be specialized to provide serialization in any kind of

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

@@ -42,9 +42,9 @@ copyright = '2026, Bob Ippolito'
 # other places throughout the built documents.
 #
 # The short X.Y version.
-version = '4.1'
+version = '4.2'
 # The full version, including alpha/beta/rc tags.
-release = '4.1.2'
+release = '4.2.0'
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:

{simplejson-4.1.2 → simplejson-4.2.0}/index.rst

@@ -21,7 +21,7 @@ for a serious speed boost.
 :mod:`simplejson` exposes an API familiar to users of the standard library
 :mod:`marshal` and :mod:`pickle` modules. It is the externally maintained
 version of the :mod:`json` library, but maintains
-compatibility with Python 3.8 through 3.14 (including free-threaded
+compatibility with Python 3.9 through 3.15 (including free-threaded
 builds) as well as legacy Python 2.7.
 
 Development of simplejson happens on Github:
@@ -310,6 +310,10 @@ Basic Usage
     :class:`int` ``2**n`` and higher or lower than ``-2**n`` will be encoded as strings. This is to
     avoid the rounding that happens in Javascript otherwise. Note that this
     option loses type information, so use with extreme caution.
+    Thresholds of 64 bits and above are supported by both encoders, including
+    128-bit integers. Very large thresholds do not allocate a power-of-two
+    boundary.
+
     See also *bigint_as_string* (which is equivalent to `int_as_string_bitcount=53`).
 
     .. note::

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

@@ -12,13 +12,13 @@ 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.2'
+VERSION = '4.2.0'
 DESCRIPTION = "Simple, fast, extensible JSON encoder/decoder for Python"
 
 with open('README.rst', 'r') as f:
     LONG_DESCRIPTION = f.read()
 
-PYTHON_REQUIRES = '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*'
+PYTHON_REQUIRES = '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*, !=3.8.*'
 
 CLASSIFIERS = [
     'Development Status :: 5 - Production/Stable',
@@ -28,13 +28,13 @@ CLASSIFIERS = [
     'Programming Language :: Python :: 2',
     'Programming Language :: Python :: 2.7',
     'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3.8',
     'Programming Language :: Python :: 3.9',
     'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
     'Programming Language :: Python :: 3.13',
     'Programming Language :: Python :: 3.14',
+    'Programming Language :: Python :: 3.15',
     'Programming Language :: Python :: Implementation :: CPython',
     'Programming Language :: Python :: Implementation :: GraalPy',
     'Programming Language :: Python :: Implementation :: PyPy',

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

@@ -5,7 +5,7 @@ interchange format.
 :mod:`simplejson` exposes an API familiar to users of the standard library
 :mod:`marshal` and :mod:`pickle` modules. It is the externally maintained
 version of the :mod:`json` library contained in Python 2.6+, supporting
-Python 2.7 and Python 3.8+, and has significant performance advantages,
+Python 2.7 and Python 3.9+, and has significant performance advantages,
 even without using the optional C extension for speedups.
 
 Encoding basic Python object hierarchies::
@@ -118,7 +118,7 @@ Serializing multiple objects to JSON lines (newline-delimited JSON)::
 
 """
 from __future__ import absolute_import
-__version__ = '4.1.2'
+__version__ = '4.2.0'
 __all__ = [
     'dump', 'dumps', 'load', 'loads',
     'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',

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

@@ -301,6 +301,7 @@ typedef struct _PyEncoderObject {
     int iterable_as_array;
     PyObject *max_long_size;
     PyObject *min_long_size;
+    PyObject *large_int_bitcount;
     PyObject *item_sort_key;
     PyObject *item_sort_kw;
     int for_json;
@@ -327,6 +328,7 @@ typedef struct _PyEncoderObject {
     X(item_sort_key)                  \
     X(max_long_size)                  \
     X(min_long_size)                  \
+    X(large_int_bitcount)             \
     X(Decimal)
 
 static PyMemberDef encoder_members[] = {
@@ -708,22 +710,46 @@ maybe_quote_bigint(PyEncoderObject* s, PyObject *encoded, PyObject *obj)
     int ge, le;
     PyObject *quoted;
 
-    /* int_as_string_bitcount is not set: fast path, return as-is. */
-    if (s->max_long_size == Py_None || s->min_long_size == Py_None)
-        return encoded;
-
-    ge = PyObject_RichCompareBool(obj, s->max_long_size, Py_GE);
-    if (ge < 0) {
-        Py_DECREF(encoded);
-        return NULL;
+    if (s->large_int_bitcount != NULL) {
+        size_t nbits;
+        PyObject *bits;
+        nbits = _PyLong_NumBits(obj);
+        if (nbits == (size_t)-1 && PyErr_Occurred()) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+        bits = PyLong_FromSize_t(nbits);
+        if (bits == NULL) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+        ge = PyObject_RichCompareBool(bits, s->large_int_bitcount, Py_GT);
+        Py_DECREF(bits);
+        if (ge < 0) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+        if (!ge)
+            return encoded;
     }
-    le = PyObject_RichCompareBool(obj, s->min_long_size, Py_LE);
-    if (le < 0) {
-        Py_DECREF(encoded);
-        return NULL;
+    else {
+        /* int_as_string_bitcount is not set: fast path, return as-is. */
+        if (s->max_long_size == Py_None || s->min_long_size == Py_None)
+            return encoded;
+
+        ge = PyObject_RichCompareBool(obj, s->max_long_size, Py_GE);
+        if (ge < 0) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+        le = PyObject_RichCompareBool(obj, s->min_long_size, Py_LE);
+        if (le < 0) {
+            Py_DECREF(encoded);
+            return NULL;
+        }
+        if (!(ge || le))
+            return encoded;
     }
-    if (!(ge || le))
-        return encoded;
 
 #if PY_MAJOR_VERSION >= 3
     quoted = PyUnicode_FromFormat("\"%U\"", encoded);
@@ -2653,10 +2679,11 @@ encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         goto bail;
     if (PyInt_Check(int_as_string_bitcount) || PyLong_Check(int_as_string_bitcount)) {
         static const unsigned long long_long_bitsize = sizeof(long long) * CHAR_BIT;
-        long int_as_string_bitcount_val = PyLong_AsLong(int_as_string_bitcount);
+        int overflow = 0;
+        long int_as_string_bitcount_val = PyLong_AsLongAndOverflow(int_as_string_bitcount, &overflow);
         if (int_as_string_bitcount_val == -1 && PyErr_Occurred())
             goto bail;
-        if (int_as_string_bitcount_val > 0 && int_as_string_bitcount_val < (long)long_long_bitsize) {
+        if (!overflow && int_as_string_bitcount_val > 0 && int_as_string_bitcount_val < (long)long_long_bitsize) {
             int n = (int)int_as_string_bitcount_val;
             /* Compute 2^n as unsigned (well-defined for n < 64) and
              * -(2^n) as signed without UB. Naive "-1LL << n" is a
@@ -2672,10 +2699,19 @@ encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
                 goto bail;
             }
         }
+        else if (overflow > 0 || int_as_string_bitcount_val > 0) {
+            /* Compare magnitudes without allocating a 2**n boundary. */
+            s->large_int_bitcount = PyNumber_Long(int_as_string_bitcount);
+            if (s->large_int_bitcount == NULL)
+                goto bail;
+            Py_INCREF(Py_None);
+            s->max_long_size = Py_None;
+            Py_INCREF(Py_None);
+            s->min_long_size = Py_None;
+        }
         else {
-            PyErr_Format(PyExc_TypeError,
-                         "int_as_string_bitcount (%ld) must be greater than 0 and less than the number of bits of a `long long` type (%lu bits)",
-                         int_as_string_bitcount_val, long_long_bitsize);
+            PyErr_SetString(PyExc_TypeError,
+                            "int_as_string_bitcount must be a positive integer");
             goto bail;
         }
     }
@@ -2979,7 +3015,8 @@ encoder_markers_pop(PyEncoderObject *s, PyObject *ident)
 
 /* Helper for the for_json / _asdict paths in encoder_listencode_obj.
  * Steals the reference to `newobj` (returned by _call_json_method),
- * handles recursion-depth tracking, and dispatches to the right
+ * tracks the original object's circular-reference marker and recursion
+ * depth, and dispatches to the right
  * sub-encoder:
  *   - if as_dict is 0, encodes newobj as a generic JSON value via
  *     encoder_listencode_obj (for_json contract: return any JSON-
@@ -2990,14 +3027,20 @@ encoder_markers_pop(PyEncoderObject *s, PyObject *ident)
  * Cleans up on every exit path. */
 static int
 encoder_steal_encode(PyEncoderObject *s, JSON_Accu *rval,
-                     PyObject *newobj, Py_ssize_t indent_level,
+                     PyObject *obj, PyObject *newobj, Py_ssize_t indent_level,
                      int as_dict)
 {
     int rv;
+    PyObject *ident = NULL;
     if (newobj == NULL)
         return -1;
+    if (encoder_markers_push(s, obj, &ident)) {
+        Py_DECREF(newobj);
+        return -1;
+    }
     if (Py_EnterRecursiveCall(" while encoding a JSON object")) {
         Py_DECREF(newobj);
+        Py_XDECREF(ident);
         return -1;
     }
     if (as_dict) {
@@ -3014,6 +3057,12 @@ encoder_steal_encode(PyEncoderObject *s, JSON_Accu *rval,
     }
     Py_DECREF(newobj);
     Py_LeaveRecursiveCall();
+    if (rv == 0) {
+        if (encoder_markers_pop(s, ident) < 0)
+            rv = -1;
+    } else {
+        Py_XDECREF(ident);
+    }
     return rv;
 }
 
@@ -3121,12 +3170,39 @@ encoder_listencode_obj(PyEncoderObject *s, JSON_Accu *rval, PyObject *obj, Py_ss
             rv = _steal_accumulate(state, rval, cstr);
     }
     else if (PyInt_Check(obj) || PyLong_Check(obj)) {
-        PyObject *encoded = encoder_long_to_str(obj);
+        PyObject *integer, *encoded;
+        /* Large thresholds inspect the same normalized value we serialize. */
+        if (s->large_int_bitcount != NULL) {
+#if PY_MAJOR_VERSION < 3
+            /* Match int(value) in the Python encoder before widening for
+             * _PyLong_NumBits: long(value) would invoke __long__ instead. */
+            PyObject *normalized = PyNumber_Int(obj);
+            if (normalized == NULL)
+                return -1;
+            /* PyNumber_Int may retain a long subclass. Copy its payload
+             * instead of invoking a second conversion hook. */
+            if (PyInt_Check(normalized))
+                integer = PyLong_FromLong(PyInt_AS_LONG(normalized));
+            else
+                integer = PyLong_Type.tp_as_number->nb_long(normalized);
+            Py_DECREF(normalized);
+#else
+            integer = PyNumber_Long(obj);
+#endif
+        }
+        else {
+            integer = obj;
+            Py_INCREF(integer);
+        }
+        if (integer == NULL)
+            return -1;
+        encoded = encoder_long_to_str(integer);
         if (encoded != NULL) {
-            encoded = maybe_quote_bigint(s, encoded, obj);
+            encoded = maybe_quote_bigint(s, encoded, integer);
             if (encoded != NULL)
                 rv = _steal_accumulate(state, rval, encoded);
         }
+        Py_DECREF(integer);
     }
     else if (PyFloat_Check(obj)) {
         PyObject *encoded = encoder_encode_float(s, obj);
@@ -3134,10 +3210,10 @@ encoder_listencode_obj(PyEncoderObject *s, JSON_Accu *rval, PyObject *obj, Py_ss
             rv = _steal_accumulate(state, rval, encoded);
     }
     else if (s->for_json && _call_json_method(obj, state->JSON_attr_for_json, &newobj)) {
-        rv = encoder_steal_encode(s, rval, newobj, indent_level, /*as_dict=*/0);
+        rv = encoder_steal_encode(s, rval, obj, newobj, indent_level, /*as_dict=*/0);
     }
     else if (s->namedtuple_as_object && _call_json_method(obj, state->JSON_attr_asdict, &newobj)) {
-        rv = encoder_steal_encode(s, rval, newobj, indent_level, /*as_dict=*/1);
+        rv = encoder_steal_encode(s, rval, obj, newobj, indent_level, /*as_dict=*/1);
     }
     else if (PyList_Check(obj) || (s->tuple_as_array && PyTuple_Check(obj))) {
         if (Py_EnterRecursiveCall(" while encoding a JSON object"))

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

@@ -210,7 +210,11 @@ JSON_SCAN_FN(_parse_object)(PyScannerObject *s, PyObject *pystr,
 
             /* read key */
             if (JSON_SCAN_READ(idx) != '"') {
-                raise_errmsg(state, ERR_OBJECT_PROPERTY, pystr, idx);
+                /* '}' is still legal where the first key would go. */
+                raise_errmsg(state,
+                             did_parse ? ERR_OBJECT_PROPERTY
+                                       : ERR_OBJECT_PROPERTY_FIRST,
+                             pystr, idx);
                 goto bail;
             }
             key = JSON_SCAN_SCANSTRING_CALL(idx + 1, &next_idx);

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

@@ -516,13 +516,24 @@ def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
             value = int(value)
         if (
             skip_quoting or
-            (-1 << _int_as_string_bitcount)
-            < value <
-            (1 << _int_as_string_bitcount)
+            value.bit_length() <= _int_as_string_bitcount
         ):
             return str(value)
         return '"' + str(value) + '"'
 
+    def _iterencode_method(obj, result, _current_indent_level, encode):
+        if markers is not None:
+            markerid = id(obj)
+            if markerid in markers:
+                raise ValueError("Circular reference detected")
+            markers[markerid] = obj
+        try:
+            for chunk in encode(result, _current_indent_level):
+                yield chunk
+        finally:
+            if markers is not None:
+                del markers[markerid]
+
     def _iterencode_list(lst, _current_indent_level):
         if not lst:
             yield '[]'
@@ -570,15 +581,16 @@ def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
                     yield buf
                     for_json = _for_json and call_method(value, 'for_json')
                     if for_json:
-                        chunks = _iterencode(for_json[0], _current_indent_level)
+                        chunks = _iterencode_method(value, for_json[0],
+                                                    _current_indent_level, _iterencode)
                     else:
                         _asdict = _namedtuple_as_object and call_method(value, '_asdict')
                         if _asdict:
                             dct = _asdict[0]
                             if not isinstance(dct, dict):
                                 raise TypeError("_asdict() must return a dict, not %s" % (type(dct).__name__,))
-                            chunks = _iterencode_dict(dct,
-                                                      _current_indent_level)
+                            chunks = _iterencode_method(value, dct,
+                                                        _current_indent_level, _iterencode_dict)
                         elif isinstance(value, list):
                             chunks = _iterencode_list(value, _current_indent_level)
                         elif _tuple_as_array and isinstance(value, tuple):
@@ -701,15 +713,16 @@ def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
                 else:
                     for_json = _for_json and call_method(value, 'for_json')
                     if for_json:
-                        chunks = _iterencode(for_json[0], _current_indent_level)
+                        chunks = _iterencode_method(value, for_json[0],
+                                                    _current_indent_level, _iterencode)
                     else:
                         _asdict = _namedtuple_as_object and call_method(value, '_asdict')
                         if _asdict:
                             dct = _asdict[0]
                             if not isinstance(dct, dict):
                                 raise TypeError("_asdict() must return a dict, not %s" % (type(dct).__name__,))
-                            chunks = _iterencode_dict(dct,
-                                                      _current_indent_level)
+                            chunks = _iterencode_method(value, dct,
+                                                        _current_indent_level, _iterencode_dict)
                         elif isinstance(value, list):
                             chunks = _iterencode_list(value, _current_indent_level)
                         elif _tuple_as_array and isinstance(value, tuple):
@@ -753,7 +766,8 @@ def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
         else:
             for_json = _for_json and call_method(o, 'for_json')
             if for_json:
-                for chunk in _iterencode(for_json[0], _current_indent_level):
+                for chunk in _iterencode_method(o, for_json[0],
+                                              _current_indent_level, _iterencode):
                     yield chunk
             else:
                 _asdict = _namedtuple_as_object and call_method(o, '_asdict')
@@ -761,7 +775,8 @@ def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
                     dct = _asdict[0]
                     if not isinstance(dct, dict):
                         raise TypeError("_asdict() must return a dict, not %s" % (type(dct).__name__,))
-                    for chunk in _iterencode_dict(dct, _current_indent_level):
+                    for chunk in _iterencode_method(o, dct,
+                                                  _current_indent_level, _iterencode_dict):
                         yield chunk
                 elif isinstance(o, list):
                     for chunk in _iterencode_list(o, _current_indent_level):

{simplejson-4.1.2 → simplejson-4.2.0}/simplejson/tests/test_bitsize_int_as_string.py

@@ -1,6 +1,7 @@
 from unittest import TestCase
 
 import simplejson as json
+from simplejson.compat import PY3, integer_types, long_type
 
 
 class TestBitSizeIntAsString(TestCase):
@@ -118,3 +119,99 @@ class TestBitSizeIntAsString(TestCase):
                     str(v),
                     json.loads(json.dumps(v, int_as_string_bitcount=n)),
                     "n=%d v=%d should be stringified" % (n, v))
+
+
+    def test_large_bitcounts(self):
+        for n in (64, 65, 127, 128, 256, 1024):
+            boundary = 1 << n
+            values = [0, boundary - 1, boundary, boundary + 1,
+                      -boundary + 1, -boundary, -boundary - 1]
+            expected = [0, boundary - 1, str(boundary), str(boundary + 1),
+                        -boundary + 1, str(-boundary), str(-boundary - 1)]
+            for indent in (None, 2):
+                self.assertEqual(expected, json.loads(json.dumps(
+                    values, int_as_string_bitcount=n, indent=indent)))
+                self.assertEqual({'value': expected}, json.loads(json.dumps(
+                    {'value': values}, int_as_string_bitcount=n, indent=indent)))
+
+    def test_huge_bitcount_does_not_build_boundary(self):
+        # A threshold can exceed native integer sizes without allocating 2**n.
+        for n in (2 ** 32 + 31, 2 ** 100):
+            self.assertEqual('[0, 1, -1]', json.dumps(
+                [0, 1, -1], int_as_string_bitcount=n))
+
+    def test_large_bitcount_normalizes_subclass_once(self):
+        for integer_type in integer_types:
+            class ChangingInt(integer_type):
+                calls = 0
+
+                def __int__(self):
+                    self.calls += 1
+                    return normalized if self.calls == 1 else 0
+
+                def __long__(self):
+                    raise AssertionError('must normalize through __int__')
+
+            for normalized in (1 << 64, -(1 << 64), 1):
+                expected = str(normalized)
+                if abs(normalized) >= 1 << 64:
+                    expected = '"' + expected + '"'
+                for indent in (None, 2):
+                    value = ChangingInt(1)
+                    self.assertEqual(expected, json.dumps(
+                        value, int_as_string_bitcount=64, indent=indent))
+                    self.assertEqual(1, value.calls)
+
+    def test_large_bitcount_normalization_error_propagates(self):
+        for integer_type in integer_types:
+            class BadInt(integer_type):
+                def __int__(self):
+                    raise RuntimeError('normalization bomb')
+
+            for indent in (None, 2):
+                self.assertRaises(
+                    RuntimeError, json.dumps, BadInt(1),
+                    int_as_string_bitcount=64, indent=indent)
+
+    def _assert_returned_long_is_not_converted(self, returned_type):
+        for integer_type in integer_types:
+            class OriginalInt(integer_type):
+                calls = 0
+
+                def __int__(self):
+                    self.calls += 1
+                    return returned
+
+                def __long__(self):
+                    return long_type(7)
+
+            for normalized in (7, 1 << 64, -(1 << 64)):
+                expected = str(normalized)
+                if abs(normalized) >= 1 << 64:
+                    expected = '"' + expected + '"'
+                for indent in (None, 2):
+                    returned = returned_type(normalized)
+                    value = OriginalInt(7)
+                    self.assertEqual(expected, json.dumps(
+                        value, int_as_string_bitcount=64, indent=indent))
+                    self.assertEqual(1, value.calls)
+
+    def test_large_bitcount_returned_long_value_preserved(self):
+        if PY3:
+            self.skipTest('Python 2 int() can return a long subclass')
+
+        class ReturnedLong(long_type):
+            def __long__(self):
+                return 1 << 64
+
+        self._assert_returned_long_is_not_converted(ReturnedLong)
+
+    def test_large_bitcount_returned_long_hook_not_called(self):
+        if PY3:
+            self.skipTest('Python 2 int() can return a long subclass')
+
+        class ReturnedLong(long_type):
+            def __long__(self):
+                raise RuntimeError('unexpected second conversion')
+
+        self._assert_returned_long_is_not_converted(ReturnedLong)

simplejson-4.2.0/simplejson/tests/test_custom_method_cycles.py

@@ -0,0 +1,71 @@
+import sys
+from unittest import TestCase, skipIf
+
+import simplejson as json
+
+
+class ForJson:
+    def __init__(self, value=None):
+        self.value = value
+
+    def for_json(self):
+        return self.value
+
+
+class AsDict:
+    def _asdict(self):
+        return {'self': self}
+
+
+class TestCustomMethodCycles(TestCase):
+    def assert_circular(self, value):
+        with self.assertRaises(ValueError) as exc:
+            json.dumps(value, for_json=True)
+        self.assertEqual(str(exc.exception), 'Circular reference detected')
+
+    def test_direct_for_json_cycle(self):
+        value = ForJson()
+        value.value = value
+        self.assert_circular(value)
+
+    def test_indirect_for_json_cycle(self):
+        first = ForJson()
+        second = ForJson(first)
+        first.value = second
+        self.assert_circular(first)
+
+    def test_for_json_cycle_in_list(self):
+        value = ForJson()
+        value.value = value
+        self.assert_circular([value])
+
+    def test_for_json_cycle_in_dict(self):
+        value = ForJson()
+        value.value = value
+        self.assert_circular({'value': value})
+
+    def test_asdict_cycle(self):
+        self.assert_circular(AsDict())
+
+    def test_asdict_cycle_in_list(self):
+        self.assert_circular([AsDict()])
+
+    def test_asdict_cycle_in_dict(self):
+        self.assert_circular({'value': AsDict()})
+
+    def test_repeated_reference_is_not_a_cycle(self):
+        value = ForJson({'x': 1})
+        self.assertEqual(
+            json.loads(json.dumps([value, value], for_json=True)),
+            [{'x': 1}, {'x': 1}])
+
+    def test_acyclic_chain(self):
+        self.assertEqual(json.loads(json.dumps(ForJson(ForJson(1)), for_json=True)), 1)
+
+    @skipIf(sys.platform == 'emscripten',
+            'Pyodide cannot recover from unbounded recursion')
+    def test_circular_checks_can_be_disabled(self):
+        value = ForJson()
+        value.value = value
+        with self.assertRaises(RuntimeError):
+            json.dumps(value, for_json=True, check_circular=False)

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

@@ -135,6 +135,32 @@ class TestFail(TestCase):
             else:
                 self.fail("Unexpected success parsing '[,]'")
 
+    def test_object_property_error_message(self):
+        # '}' is legal where the first key would go, but not after a comma.
+        first = "Expecting property name enclosed in double quotes or '}'"
+        later = 'Expecting property name enclosed in double quotes'
+        test_cases = [
+            ('{:1}', first, 1),
+            ('{,}', first, 1),
+            ('{unquoted_key: "keys must be quoted"}', first, 1),
+            ('{"spam":42,:1}', later, 11),
+            ('{"spam":42,unquoted_key: 1}', later, 11),
+        ]
+        for data, msg, idx in test_cases:
+            try:
+                json.loads(data)
+            except json.JSONDecodeError:
+                e = sys.exc_info()[1]
+                self.assertEqual(
+                    e.msg, msg, "%r != %r for %r" % (e.msg, msg, data))
+                self.assertEqual(
+                    e.pos, idx, "pos %r != %r for %r" % (e.pos, idx, data))
+            except Exception:
+                e = sys.exc_info()[1]
+                self.fail("Unexpected exception raised %r %s" % (e, e))
+            else:
+                self.fail("Unexpected success parsing %r" % (data,))
+
     def test_truncated_input(self):
         test_cases = [
             ('', 'Expecting value', 0),

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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 import sys
 from unittest import TestCase
 

{simplejson-4.1.2 → simplejson-4.2.0}/simplejson/tests/test_speedups.py

@@ -4,7 +4,7 @@ from unittest import TestCase
 
 import simplejson
 from simplejson import encoder, decoder, scanner
-from simplejson.compat import PY3, long_type, b
+from simplejson.compat import PY3, b
 from simplejson.tests._helpers import has_speedups, skip_if_speedups_missing
 
 
@@ -82,13 +82,6 @@ class TestEncode(TestCase):
         self.assertRaises(ZeroDivisionError, test, 'ignore_nan')
         self.assertRaises(ZeroDivisionError, test, 'iterable_as_array')
 
-    @skip_if_speedups_missing
-    def test_int_as_string_bitcount_overflow(self):
-        long_count = long_type(2)**32+31
-        def test():
-            encoder.JSONEncoder(int_as_string_bitcount=long_count).encode(0)
-        self.assertRaises((TypeError, OverflowError), test)
-
     if PY3:
         @skip_if_speedups_missing
         def test_bad_encoding(self):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplejson
-Version: 4.1.2
+Version: 4.2.0
 Summary: Simple, fast, extensible JSON encoder/decoder for Python
 Home-page: https://github.com/simplejson/simplejson
 Author: Bob Ippolito
@@ -14,18 +14,18 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: GraalPy
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*, !=3.8.*
 License-File: LICENSE.txt
 Dynamic: author
 Dynamic: author-email
@@ -42,7 +42,7 @@ simplejson
 ----------
 
 simplejson is a simple, fast, complete, correct and extensible
-JSON <http://json.org> encoder and decoder for Python 3.8+
+JSON <http://json.org> encoder and decoder for Python 3.9+
 with legacy support for Python 2.7.  It is pure Python code
 with no dependencies, but includes an optional C extension
 for a serious speed boost.
@@ -53,7 +53,7 @@ https://simplejson.readthedocs.io/
 simplejson is the externally maintained development version of the
 json library included with Python (since 2.6). This version is tested
 with Python 3.14 (including free-threaded builds) and maintains
-backwards compatibility with Python 3.8+. A legacy Python 2.7 wheel
+backwards compatibility with Python 3.9+. A legacy Python 2.7 wheel
 is also published.
 
 The encoder can be specialized to provide serialization in any kind of

{simplejson-4.1.2 → simplejson-4.2.0}/simplejson.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ simplejson/tests/_helpers.py
 simplejson/tests/test_bigint_as_string.py
 simplejson/tests/test_bitsize_int_as_string.py
 simplejson/tests/test_check_circular.py
+simplejson/tests/test_custom_method_cycles.py
 simplejson/tests/test_decimal.py
 simplejson/tests/test_decode.py
 simplejson/tests/test_default.py