simplejson 3.20.2__tar.gz → 4.1.0__tar.gz

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

@@ -1,6 +1,174 @@
+Version 4.1.0 released 2026-04-22
+
+* The C extension now accelerates encoding when ``indent=`` is set.
+  Previously the encoder fell back to the pure-Python implementation
+  whenever a non-None ``indent`` was passed; now the C encoder emits
+  the newline-plus-indent prefix, the level-aware item separator, and
+  the closing indent directly.  A representative nested-dict workload
+  benchmarks about 4-5x faster end-to-end, and the ``indent=0`` and
+  empty-container edge cases continue to match the Python output
+  byte-for-byte.
+
+* The C extension now emits PEP 678 ``exc.add_note()`` annotations on
+  serialization failures, matching the pure-Python encoder.  A chained
+  error on ``{'a': [1, object(), 3]}`` produces the same three notes
+  (``when serializing object object``, ``when serializing list item 1``,
+  ``when serializing dict item 'a'``) whether the speedups are loaded
+  or not, so the add_note assertions in ``test_errors.py`` no longer
+  need ``indent=2`` to force the Python path.
+
+Version 4.0.1 released 2026-04-18
+
+* Skip uploading Pyodide/wasm wheels to PyPI, which rejects them with
+  "unsupported platform tag 'pyodide_2024_0_wasm32'". The wheels are
+  still built in CI and preserved as workflow artifacts.
+  https://github.com/simplejson/simplejson/pull/375
+
+Version 4.0.0 released 2026-04-18
+
+* simplejson 4 requires Python 2.7 or Python 3.8+. Older Python
+  versions (2.5, 2.6, 3.0-3.7) are no longer supported. pip will
+  not install simplejson 4 on unsupported versions.
+
+* The C extension now uses heap types and per-module state instead of
+  static types and global state. This is required for free-threading
+  support and sub-interpreter isolation. The Python-level API is
+  unchanged.
+
+* Full support for Python 3.13+ free-threading (PEP 703). The C
+  extension is now safe to use with the GIL disabled (python3.14t):
+  - Converted all static types to heap types with per-module state
+  - Added per-object critical sections to scanner and encoder
+  - Added free-threading-safe dict operations for Python 3.13+
+  - Unified per-module state management and templated parser
+  https://github.com/simplejson/simplejson/pull/363
+  https://github.com/simplejson/simplejson/pull/364
+  https://github.com/simplejson/simplejson/pull/365
+  https://github.com/simplejson/simplejson/pull/367
+  https://github.com/simplejson/simplejson/pull/369
+
+* Numerous C extension memory safety fixes:
+  - Fix use-after-free and leak in encoder ident handling
+  - Fix NULL dereferences on OOM in module init and static string init
+  - Fix reference leaks in dict encoder (skipkeys item, variable shadowing)
+  - Fix member table copy-paste, exception clobbering, missing Py_VISIT
+  - Fix error-as-truthy bugs in maybe_quote_bigint and is_raw_json
+  - Fix iterable_as_array swallowing MemoryError and KeyboardInterrupt
+  - Fix for_json and _asdict swallowing MemoryError, KeyboardInterrupt,
+    and other non-AttributeError exceptions raised by user __getattr__
+  https://github.com/simplejson/simplejson/pull/355
+  https://github.com/simplejson/simplejson/pull/356
+  https://github.com/simplejson/simplejson/pull/357
+  https://github.com/simplejson/simplejson/pull/358
+  https://github.com/simplejson/simplejson/pull/359
+  https://github.com/simplejson/simplejson/pull/360
+  https://github.com/simplejson/simplejson/pull/373
+
+* C/Python parity fixes:
+  - Fix C scanstring off-by-one bounds checks that caused truncated
+    or boundary \uXXXX escapes to raise "Invalid \\uXXXX escape
+    sequence" instead of "Unterminated string", and report error
+    position at the 'u' instead of the leading backslash. The C and
+    Python decoders now agree on exception class, message, and
+    position across all tested edge cases.
+  - Align the Python encoder's dispatch order with the C encoder for
+    objects that define _asdict(). Previously a list/tuple/dict
+    subclass with an _asdict() method encoded as its container type
+    under the Python encoder and as the _asdict() return value under
+    the C encoder; both now check _asdict() before list/tuple/dict.
+    for_json() continues to outrank _asdict() in both.
+  - Fix C scanstring raising a plain ValueError ("end is out of
+    bounds") instead of JSONDecodeError for out-of-range end indices.
+    User code with `except JSONDecodeError:` now catches both the
+    C and pure-Python paths consistently.
+  https://github.com/simplejson/simplejson/pull/372
+
+* C extension performance and correctness improvements:
+  - Add PyDict_Next fast path for unsorted exact-dict encoding,
+    avoiding intermediate items list and N tuple allocations
+  - Add indexed fast path for exact list/tuple encoding, avoiding
+    iterator allocation and per-item PyIter_Next overhead
+  - Use PyUnicodeWriter as JSON_Accu backend on Python 3.14+,
+    eliminating intermediate string objects and ''.join calls
+  - Fix integer overflow in ascii_escape output_size calculation
+    that could cause buffer overwrite on pathologically large strings
+  - Fix list encoder separator counter overflow (int to Py_ssize_t)
+  - Dead code cleanup (unreachable NULL checks, do-while wrappers)
+  https://github.com/simplejson/simplejson/pull/370
+
+* Added Python 3.14 support and updated to cibuildwheel 3.2.1. CI now
+  tests free-threaded (3.14t) and debug builds with -Werror, refcount
+  leak detection, and GIL-disabled mode.
+  https://github.com/simplejson/simplejson/pull/343
+
+* Added a ThreadSanitizer (TSan) stress test CI job. Builds a
+  TSan-instrumented free-threaded CPython (cached between runs) and
+  runs a concurrent stress test script against the C extension to
+  catch data races under free-threading.
+  https://github.com/simplejson/simplejson/pull/373
+
+* Replace deprecated license classifiers with SPDX license expression
+  https://github.com/simplejson/simplejson/pull/347
+
+* Documented RawJSON usage with examples and caveats
+  https://github.com/simplejson/simplejson/pull/346
+
+* Added pyproject.toml for PEP 517 build support. setup.py is retained
+  for Python 2.7 wheel builds and backwards compatibility.
+
+* Migrated build_ext import from distutils to setuptools in setup.py.
+  The distutils.errors imports are kept since setuptools vendors
+  distutils on Python 3.12+ where stdlib distutils was removed.
+
+* CI now tests PEP 517 builds (pyproject.toml) alongside the existing
+  setup.py-based builds.
+
+* Added Pyodide (wasm32) wheel builds with C speedups via cibuildwheel.
+  Previously Pyodide users fell back to the pure-Python wheel; now they
+  get the compiled C extension cross-compiled to WebAssembly. Thread
+  and subprocess tests are skipped on Emscripten where those APIs are
+  unavailable.
+
+* Test suite now fails (instead of skipping) when C speedups are missing
+  during cibuildwheel runs, catching broken extension builds early.
+
+* New ``array_hook`` parameter for ``loads()``, ``load()``, and
+  ``JSONDecoder``. Called with each decoded JSON array (as a list),
+  its return value replaces the list. Analogous to ``object_hook``
+  for dicts. Works with both the Python decoder and C scanner.
+  (Matches CPython 3.15 json module.)
+
+* Trailing comma detection: the decoder now raises ``JSONDecodeError``
+  with "Illegal trailing comma before end of object/array" for inputs
+  like ``[1,]`` and ``{"a": 1,}`` instead of generic error messages.
+  Both the Python decoder and C scanner are updated.
+  (Matches CPython 3.13+ json module.)
+
+* ``frozendict`` encoding support: when ``frozendict`` is available
+  (CPython 3.15+ PEP 814), it is encoded as a JSON object just like
+  ``dict``. No effect on older Python versions.
+
+* Serialization errors now include ``add_note()`` context on Python
+  3.11+ (PEP 678), annotating exceptions with the path to the error,
+  e.g. "when serializing list item 1" / "when serializing dict item
+  'key'". Only applies to the Python encoder.
+
+* New C fast path for ``encode_basestring`` (``ensure_ascii=False``).
+  Previously the non-ASCII string encoder fell back to pure Python;
+  now it has a C implementation matching the existing
+  ``encode_basestring_ascii`` fast path.
+  https://github.com/simplejson/simplejson/issues/207
+
+* The Python decoder now rejects non-ASCII digits (e.g. fullwidth
+  ``\uff10``) in JSON numbers, matching the C scanner behavior.
+  The ``NUMBER_RE`` regex was changed from ``\d`` to ``[0-9]``.
+
+* Removed dead single-phase init code for Python 3.3/3.4 from the
+  C extension (these versions are no longer supported).
+
 Version 3.20.2 released 2025-09-24
 
-* Disable speedups on GraalPy smae as on PyPy
+* Disable speedups on GraalPy same as on PyPy
   https://github.com/simplejson/simplejson/pull/339
 
 Version 3.20.1 released 2025-02-14

{simplejson-3.20.2 → simplejson-4.1.0}/MANIFEST.in

@@ -1,5 +1,7 @@
 include *.py
 include *.txt
 include *.rst
+include *.toml
 include scripts/*.py
 include MANIFEST.in
+include simplejson/*.h

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

@@ -1,37 +1,31 @@
 Metadata-Version: 2.4
 Name: simplejson
-Version: 3.20.2
+Version: 4.1.0
 Summary: Simple, fast, extensible JSON encoder/decoder for Python
 Home-page: https://github.com/simplejson/simplejson
 Author: Bob Ippolito
 Author-email: bob@redivi.com
-License: MIT License
+License: MIT OR AFL-2.1
 Platform: any
 Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: WebAssembly :: Emscripten
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: License :: OSI Approved :: Academic Free License (AFL)
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.5
-Classifier: Programming Language :: Python :: 2.6
 Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 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 :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: GraalPy
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=2.5, !=3.0.*, !=3.1.*, !=3.2.*
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*
 License-File: LICENSE.txt
 Dynamic: author
 Dynamic: author-email
@@ -48,8 +42,8 @@ simplejson
 ----------
 
 simplejson is a simple, fast, complete, correct and extensible
-JSON <http://json.org> encoder and decoder for Python 3.3+
-with legacy support for Python 2.5+.  It is pure Python code
+JSON <http://json.org> encoder and decoder for Python 3.8+
+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.
 
@@ -58,8 +52,9 @@ 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 the latest Python 3.8 and maintains backwards compatibility
-with Python 3.3+ and the legacy Python 2.5 - Python 2.7 releases.
+with Python 3.14 (including free-threaded builds) and maintains
+backwards compatibility with Python 3.8+. A legacy Python 2.7 wheel
+is also published.
 
 The encoder can be specialized to provide serialization in any kind of
 situation, without any special support by the objects to be serialized
@@ -78,3 +73,28 @@ Python 2.2. This is based on a very old version of simplejson,
 is not maintained, and should only be used as a last resort.
 
 .. _python2.2: https://github.com/simplejson/simplejson/tree/python2.2
+
+RawJSON
+~~~~~~~
+
+``RawJSON`` allows embedding pre-encoded JSON strings into output without
+re-encoding them.
+
+This can be useful in advanced cases where JSON content is already
+serialized and re-encoding would be unnecessary.
+
+Example usage::
+
+    from simplejson import dumps, RawJSON
+
+    payload = {
+        "status": "ok",
+        "data": RawJSON('{"a": 1, "b": 2}')
+    }
+
+    print(dumps(payload))
+    # Output: {"status": "ok", "data": {"a": 1, "b": 2}}
+
+**Caveat:** ``RawJSON`` should be used with care. It bypasses normal
+serialization and validation, and is not recommended for general use
+unless the embedded JSON content is fully trusted.

{simplejson-3.20.2 → simplejson-4.1.0}/README.rst

@@ -2,8 +2,8 @@ simplejson
 ----------
 
 simplejson is a simple, fast, complete, correct and extensible
-JSON <http://json.org> encoder and decoder for Python 3.3+
-with legacy support for Python 2.5+.  It is pure Python code
+JSON <http://json.org> encoder and decoder for Python 3.8+
+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.
 
@@ -12,8 +12,9 @@ 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 the latest Python 3.8 and maintains backwards compatibility
-with Python 3.3+ and the legacy Python 2.5 - Python 2.7 releases.
+with Python 3.14 (including free-threaded builds) and maintains
+backwards compatibility with Python 3.8+. A legacy Python 2.7 wheel
+is also published.
 
 The encoder can be specialized to provide serialization in any kind of
 situation, without any special support by the objects to be serialized
@@ -32,3 +33,28 @@ Python 2.2. This is based on a very old version of simplejson,
 is not maintained, and should only be used as a last resort.
 
 .. _python2.2: https://github.com/simplejson/simplejson/tree/python2.2
+
+RawJSON
+~~~~~~~
+
+``RawJSON`` allows embedding pre-encoded JSON strings into output without
+re-encoding them.
+
+This can be useful in advanced cases where JSON content is already
+serialized and re-encoding would be unnecessary.
+
+Example usage::
+
+    from simplejson import dumps, RawJSON
+
+    payload = {
+        "status": "ok",
+        "data": RawJSON('{"a": 1, "b": 2}')
+    }
+
+    print(dumps(payload))
+    # Output: {"status": "ok", "data": {"a": 1, "b": 2}}
+
+**Caveat:** ``RawJSON`` should be used with care. It bypasses normal
+serialization and validation, and is not recommended for general use
+unless the embedded JSON content is fully trusted.

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

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

{simplejson-3.20.2 → simplejson-4.1.0}/index.rst

@@ -21,8 +21,8 @@ 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 the latest Python 3.8+ releases back to Python 3.3
-as well as the legacy Python 2.5 - Python 2.7 releases.
+compatibility with Python 3.8 through 3.14 (including free-threaded
+builds) as well as legacy Python 2.7.
 
 Development of simplejson happens on Github:
 http://github.com/simplejson/simplejson

simplejson-4.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

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

@@ -1,61 +1,47 @@
 #!/usr/bin/env python
-from __future__ import with_statement
-
 import os
 import sys
 try:
     from setuptools import setup, Extension, Command
+    from setuptools.command.build_ext import build_ext
 except ImportError:
     from distutils.core import setup, Extension, Command
-from distutils.command.build_ext import build_ext
+    from distutils.command.build_ext import build_ext
 from distutils.errors import CCompilerError, DistutilsExecError, \
     DistutilsPlatformError
 
 IS_PYPY = hasattr(sys, 'pypy_translation_info')
 IS_GRAALPY = getattr(getattr(sys, "implementation", None), "name", None) == "graalpy"
-VERSION = '3.20.2'
+VERSION = '4.1.0'
 DESCRIPTION = "Simple, fast, extensible JSON encoder/decoder for Python"
 
 with open('README.rst', 'r') as f:
     LONG_DESCRIPTION = f.read()
 
-PYTHON_REQUIRES = '>=2.5, !=3.0.*, !=3.1.*, !=3.2.*'
+PYTHON_REQUIRES = '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*'
 
 CLASSIFIERS = [
     'Development Status :: 5 - Production/Stable',
+    'Environment :: WebAssembly :: Emscripten',
     'Intended Audience :: Developers',
-    'License :: OSI Approved :: MIT License',
-    'License :: OSI Approved :: Academic Free License (AFL)',
     'Programming Language :: Python',
     'Programming Language :: Python :: 2',
-    'Programming Language :: Python :: 2.5',
-    'Programming Language :: Python :: 2.6',
     'Programming Language :: Python :: 2.7',
     'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3.3',
-    'Programming Language :: Python :: 3.4',
-    'Programming Language :: Python :: 3.5',
-    'Programming Language :: Python :: 3.6',
-    'Programming Language :: Python :: 3.7',
     '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 :: Implementation :: CPython',
+    'Programming Language :: Python :: Implementation :: GraalPy',
     'Programming Language :: Python :: Implementation :: PyPy',
     'Topic :: Software Development :: Libraries :: Python Modules',
 ]
 
-if sys.platform == 'win32' and sys.version_info < (2, 7):
-    # 2.6's distutils.msvc9compiler can raise an IOError when failing to
-    # find the compiler
-    # It can also raise ValueError https://bugs.python.org/issue7511
-    ext_errors = (CCompilerError, DistutilsExecError, DistutilsPlatformError,
-                  IOError, ValueError)
-else:
-    ext_errors = (CCompilerError, DistutilsExecError, DistutilsPlatformError)
+ext_errors = (CCompilerError, DistutilsExecError, DistutilsPlatformError)
 
 
 class BuildFailed(Exception):
@@ -102,7 +88,11 @@ def run_setup(with_binary):
     if with_binary:
         kw = dict(
             ext_modules=[
-                Extension("simplejson._speedups", ["simplejson/_speedups.c"]),
+                Extension(
+                    "simplejson._speedups",
+                    sources=["simplejson/_speedups.c"],
+                    depends=["simplejson/_speedups_scan.h"],
+                ),
             ],
             cmdclass=dict(cmdclass, build_ext=ve_build_ext),
         )
@@ -119,7 +109,7 @@ def run_setup(with_binary):
         author="Bob Ippolito",
         author_email="bob@redivi.com",
         url="https://github.com/simplejson/simplejson",
-        license="MIT License",
+        license="MIT OR AFL-2.1",
         packages=['simplejson', 'simplejson.tests'],
         platforms=['any'],
         **kw)

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

@@ -4,9 +4,9 @@ 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, but maintains
-compatibility back to Python 2.5 and (currently) has significant performance
-advantages, even without using the optional C extension for speedups.
+version of the :mod:`json` library contained in Python 2.6+, supporting
+Python 2.7 and Python 3.8+, 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__ = '3.20.2'
+__version__ = '4.1.0'
 __all__ = [
     'dump', 'dumps', 'load', 'loads',
     'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',
@@ -133,6 +133,7 @@ from .errors import JSONDecodeError
 from .raw_json import RawJSON
 from .decoder import JSONDecoder
 from .encoder import JSONEncoder, JSONEncoderForHTML
+
 def _import_OrderedDict():
     import collections
     try:
@@ -400,7 +401,7 @@ _default_decoder = JSONDecoder()
 
 def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
         parse_int=None, parse_constant=None, object_pairs_hook=None,
-        use_decimal=False, allow_nan=False, **kw):
+        use_decimal=False, allow_nan=False, array_hook=None, **kw):
     """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
     a JSON document as `str` or `bytes`) to a Python object.
 
@@ -453,12 +454,13 @@ def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
         encoding=encoding, cls=cls, object_hook=object_hook,
         parse_float=parse_float, parse_int=parse_int,
         parse_constant=parse_constant, object_pairs_hook=object_pairs_hook,
-        use_decimal=use_decimal, allow_nan=allow_nan, **kw)
+        use_decimal=use_decimal, allow_nan=allow_nan,
+        array_hook=array_hook, **kw)
 
 
 def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
         parse_int=None, parse_constant=None, object_pairs_hook=None,
-        use_decimal=False, allow_nan=False, **kw):
+        use_decimal=False, allow_nan=False, array_hook=None, **kw):
     """Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
     document) to a Python object.
 
@@ -510,6 +512,7 @@ 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 object_pairs_hook is None
+            and array_hook is None
             and not use_decimal and not allow_nan and not kw):
         return _default_decoder.decode(s)
     if cls is None:
@@ -518,6 +521,8 @@ def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
         kw['object_hook'] = object_hook
     if object_pairs_hook is not None:
         kw['object_pairs_hook'] = object_pairs_hook
+    if array_hook is not None:
+        kw['array_hook'] = array_hook
     if parse_float is not None:
         kw['parse_float'] = parse_float
     if parse_int is not None:
@@ -543,11 +548,14 @@ def _toggle_speedups(enabled):
         enc.c_make_encoder = c_make_encoder
         enc.encode_basestring_ascii = (enc.c_encode_basestring_ascii or
             enc.py_encode_basestring_ascii)
+        enc.encode_basestring = (enc.c_encode_basestring or
+            enc.py_encode_basestring)
         scan.make_scanner = scan.c_make_scanner or scan.py_make_scanner
     else:
         dec.scanstring = dec.py_scanstring
         enc.c_make_encoder = None
         enc.encode_basestring_ascii = enc.py_encode_basestring_ascii
+        enc.encode_basestring = enc.py_encode_basestring
         scan.make_scanner = scan.py_make_scanner
     dec.make_scanner = scan.make_scanner
     global _default_decoder