Use JSONDecodeError exception to raise a nice looking ValueError subclass */

Return a JSON string representation of a Python data structure. >>> from simplejson import JSONEncoder >>> JSONEncoder().encode({"foo

Run `func` in two measurement phases and verify the second phase's refcount delta stays near zero. A real per-call leak (1 ref per ca

Write '\n' followed by indent_level copies of s->indent directly to * the accumulator, without materializing the combined string as an * intermediat

Serialize ``obj`` to a JSON formatted ``str``. If ``skipkeys`` is true then ``dict`` keys that are not basic types (``str``, ``int``, ``long`

Attach a PEP 678 note formatted via PyUnicode_FromFormatV to the in- * flight exception. Mirrors the pure-Python encoder's * `except BaseException a

Run a scenario in a forked child so a SEGV can't kill the parent.

Encode the given object and yield each string representation as available. For example:: for chunk in JSONEncoder().iter

Helper to run code in a fresh subinterpreter.

Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning with a JSON document) and return a 2-tuple of the Python represe

Return the Python representation of ``s`` (a ``str`` or ``unicode`` instance containing a JSON document)

Counterpart to encoder_markers_push. Removes the ident entry from * s->markers and drops the caller's reference. Passing NULL is a no-op * so caller

Push a reference to `obj` into the encoder's circular-reference marker * dict, keyed by the object's address. Allocates a fresh PyLong ident and * s

Only needed by the two-pass ascii_escape_unicode (pre-3.14) and * ascii_escape_str (Python 2). The PyUnicodeWriter path on 3.14+ * computes sizes im

Stringify and encode a dict key to its JSON representation, using the * key_memo cache for string keys. Returns a new reference to the encoded * ke

Stringify an int/long to its JSON decimal form. For int/long subclasses * we first normalize through PyLong_Type so custom __str__ / __repr__ * over

Call list.sort(**item_sort_kw) on `lst`. Returns 0 on success, * -1 on error. Factored out so the fast and slow paths of * encoder_dict_iteritems sh

Helper for the for_json / _asdict paths in encoder_listencode_obj. * Steals the reference to `newobj` (returned by _call_json_method), * handles rec

Only needed by the two-pass escape_unicode_noascii (pre-3.14 and * Python 2). The PyUnicodeWriter path on 3.14+ writes escapes inline. */

Shared initializer for per-module state. Called from module_exec on Python 3 and from init_speedups on Python 2. Assumes the type fields in stat

True iff `key` is a Python string type that can be used verbatim * as a JSON object key (PyUnicode on all versions, PyString also on * Python 2). */

Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON document) to a Python object. *encoding* determines the encoding used

Clear every state field that init_speedups_state may populate. * Called at the start of init_speedups_state so that re-initialization * (e.g. import

Fallback encoder path used when obj is not one of the directly- * supported JSON types (const, string, int, float, list, dict, * Decimal, etc.) and