jsonmend 0.1.0__tar.gz

jsonmend-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 adam2go
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jsonmend-0.1.0/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: jsonmend
+Version: 0.1.0
+Summary: Mends the JSON your LLM almost wrote - fast single-pass repair with true incremental streaming
+Author: adam2go
+License: MIT
+Project-URL: Homepage, https://github.com/adam2go/jsonmend
+Keywords: json,repair,fix,llm,streaming,incremental,agent,tool-calls
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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 :: PyPy
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing :: Filters
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# jsonmend
+
+**Mends the JSON your LLM almost wrote.**
+
+Truncated tool calls, markdown fences, single quotes, bare keys, Python
+literals, comments, trailing commas, prose around the payload — jsonmend
+turns them into valid JSON. It is a drop-in replacement for
+[json_repair](https://github.com/mangiucugna/json_repair) that is
+**5–10× faster** on batch repair, **~50× faster** on streaming, ships a
+**true incremental streaming API** (O(new bytes) per chunk, not O(buffer)),
+and is the reference implementation of an open, cross-language
+[**conformance corpus**](corpus/) for JSON repair.
+
+Pure Python, zero dependencies, zero binaries. Works on CPython 3.9–3.14,
+PyPy, Pyodide/WASM, AWS Lambda — anywhere `pip install` works.
+
+```bash
+pip install jsonmend
+```
+
+## Scoreboard
+
+JSON repair has no standard: the same broken input is repaired
+*differently* by the Python and JavaScript incumbents, which is a real
+source of production bugs. The [jsonmend conformance corpus](corpus/)
+(460 cases, 19 categories, CC0) defines repair semantics as data —
+including the genuinely ambiguous cases, where every defensible answer
+is accepted.
+
+| | jsonmend 0.1.0 | json_repair 0.60.1 | jsonrepair 3.14.0 (JS) |
+|---|---|---|---|
+| corpus pass rate | **460/460 (100%)** | 320/460 (69.6%) | 354/460 (77.0%) |
+
+Per-category breakdown: [corpus/scoreboard.md](corpus/scoreboard.md).
+Reproduce: `python tools/referee.py --write` (needs `pip install
+json_repair` and `npm install jsonrepair`, dev-only).
+
+## Performance
+
+Median of 7, three independent rounds within ±5%, Python 3.12, M-series
+macOS. All inputs are *broken* JSON (the `json.loads` fast path never
+runs). Verified-then-timed: outputs are checked equal before timing.
+Reproduce: `python tools/bench.py --verify && python tools/bench.py`.
+
+| workload | size | jsonmend | json_repair | speedup |
+|---|---|---|---|---|
+| truncated tool call | 1 KB | 0.027 ms | 0.199 ms | **7.3×** |
+| truncated row payload | 75 KB | 1.48 ms | 12.6 ms | **8.5×** |
+| markdown-fenced output | 49 KB | 0.25 ms | 2.6 ms | **10.6×** |
+| dirty (quotes/keys/literals) | 5 KB | 0.38 ms | 2.6 ms | **7.0×** |
+
+### Streaming is a different complexity class
+
+A streaming UI re-renders the partial value on every chunk. With a batch
+repairer you must re-parse the whole buffer each time — O(n²) total. The
+stateful `Mender` only pays for the new bytes:
+
+| workload | jsonmend `Mender` | json_repair (`stream_stable=True`) | |
+|---|---|---|---|
+| 150 KB in 4 KB chunks | 6.9 ms | 323 ms | **47×** |
+| 10 MB in 4 KB chunks | 1.2 s | est. >20 min (quadratic) | — |
+
+## Usage
+
+### Drop-in for json_repair
+
+```python
+# before
+from json_repair import repair_json, loads
+# after — same call sites
+from jsonmend import repair_json, loads
+
+repair_json("{'name': 'John', age: 31")     # '{"name": "John", "age": 31}'
+loads('```json\n{"ok": true,}\n```')         # {'ok': True}
+```
+
+`repair_json(json_str, return_objects=..., skip_json_loads=...,
+ensure_ascii=..., **json_dumps_args)`, `loads`, `load(fd)`,
+`from_file(path)` match json_repair's signatures. Valid JSON
+short-circuits through C-speed `json.loads`.
+
+### Streaming
+
+```python
+from jsonmend import Mender
+
+m = Mender()
+for chunk in llm_stream:           # feed as the tokens arrive
+    partial = m.feed(chunk)        # best-effort value, O(new bytes)
+    render(partial)                # e.g. {"answer": "The capital of Fr"}
+value = m.close()                  # final mended value
+```
+
+`feed()` returns a live view that grows in place — including the string
+that is currently streaming in. Any chunking gives byte-identical results
+to batch repair (property-tested over the whole corpus).
+
+### Strict mode
+
+```python
+from jsonmend import loads, JSONMendError
+
+loads("complete garbage")                  # "" (json_repair-compatible)
+loads("complete garbage", strict=True)     # raises JSONMendError
+```
+
+## What it fixes
+
+truncated objects/arrays/strings/numbers/literals · markdown fences with
+prose around them · single/smart/backtick quotes · unescaped inner quotes
+· missing quotes · bare keys and values · `True/False/None/undefined/NaN/
+Infinity` · `//`, `#`, `/* */` comments · trailing/missing/extra commas ·
+missing colons · mismatched brackets · concatenated/NDJSON documents ·
+string concatenation (`"a" + "b"`) · JSONP/MongoDB wrappers
+(`ObjectId("…")`) · Python tuples/sets · ellipsis placeholders ·
+non-string keys · BOM and exotic whitespace · escaped-JSON documents
+(`{\"a\": 1}`) · broken `\u` escapes and surrogate pairs · 100k-deep
+nesting (no recursion anywhere)
+
+## Why it's fast
+
+* **One resumable state machine** serves batch and streaming — batch is
+  a single feed that never suspends, so there is no streaming tax.
+* **Strings cost one `str.find` + one slice** when clean; never a
+  per-character Python loop.
+* **Speculative C parsing**: complete sub-trees inside broken documents
+  are recognized and handed to the C `json` scanner, with a salvage step
+  that parses the longest clean prefix of a broken container in one shot.
+  Semantics-affecting inputs (NaN, control chars, surrogate escapes)
+  fall back to the machine, so behavior never changes.
+* **Bounded backtracking**: a string-close decision can revisit one
+  recorded candidate quote, never rescan; adversarial quote storms stay
+  linear (tested).
+
+## Guarantees
+
+* Output is always **valid RFC 8259 JSON** (or `""`/an exception). Unlike
+  json_repair, `NaN`/`Infinity` never leak into the output text — they
+  serialize as `null` (`loads` still gives you the floats).
+* Output is always UTF-8 encodable (lone surrogates are replaced).
+* Never crashes, never recurses: fuzzed and property-tested, 100k-deep
+  inputs are fine.
+* `Mender.close()` ≡ batch result, for every chunking (property-tested).
+
+## Honest differences vs json_repair
+
+* `logging=True` is not supported (it is incompatible with the
+  single-pass design and is one reason json_repair is slow); a no-op
+  shim raises `TypeError` so you notice.
+* Schema-guided repair (`schema=`) is not implemented in v0.1.
+* json_repair's `stream_stable=True` flag changes how *truncated escapes*
+  render mid-stream; jsonmend's `Mender` is always stream-stable.
+* On `ambiguous` corpus cases the libraries may legitimately differ;
+  jsonmend's choices are documented case-by-case in the corpus
+  rationales.
+
+## The corpus is the point
+
+If you maintain a JSON-repair library in any language: please steal
+[corpus/](corpus/). It is CC0, the format is three fields, and 460 cases
+with rationales are more valuable than any of our engines. Cross-language
+agreement on repair semantics helps everyone shipping LLM systems.
+
+## License
+
+MIT. The conformance corpus is CC0.

jsonmend-0.1.0/README.md

@@ -0,0 +1,166 @@
+# jsonmend
+
+**Mends the JSON your LLM almost wrote.**
+
+Truncated tool calls, markdown fences, single quotes, bare keys, Python
+literals, comments, trailing commas, prose around the payload — jsonmend
+turns them into valid JSON. It is a drop-in replacement for
+[json_repair](https://github.com/mangiucugna/json_repair) that is
+**5–10× faster** on batch repair, **~50× faster** on streaming, ships a
+**true incremental streaming API** (O(new bytes) per chunk, not O(buffer)),
+and is the reference implementation of an open, cross-language
+[**conformance corpus**](corpus/) for JSON repair.
+
+Pure Python, zero dependencies, zero binaries. Works on CPython 3.9–3.14,
+PyPy, Pyodide/WASM, AWS Lambda — anywhere `pip install` works.
+
+```bash
+pip install jsonmend
+```
+
+## Scoreboard
+
+JSON repair has no standard: the same broken input is repaired
+*differently* by the Python and JavaScript incumbents, which is a real
+source of production bugs. The [jsonmend conformance corpus](corpus/)
+(460 cases, 19 categories, CC0) defines repair semantics as data —
+including the genuinely ambiguous cases, where every defensible answer
+is accepted.
+
+| | jsonmend 0.1.0 | json_repair 0.60.1 | jsonrepair 3.14.0 (JS) |
+|---|---|---|---|
+| corpus pass rate | **460/460 (100%)** | 320/460 (69.6%) | 354/460 (77.0%) |
+
+Per-category breakdown: [corpus/scoreboard.md](corpus/scoreboard.md).
+Reproduce: `python tools/referee.py --write` (needs `pip install
+json_repair` and `npm install jsonrepair`, dev-only).
+
+## Performance
+
+Median of 7, three independent rounds within ±5%, Python 3.12, M-series
+macOS. All inputs are *broken* JSON (the `json.loads` fast path never
+runs). Verified-then-timed: outputs are checked equal before timing.
+Reproduce: `python tools/bench.py --verify && python tools/bench.py`.
+
+| workload | size | jsonmend | json_repair | speedup |
+|---|---|---|---|---|
+| truncated tool call | 1 KB | 0.027 ms | 0.199 ms | **7.3×** |
+| truncated row payload | 75 KB | 1.48 ms | 12.6 ms | **8.5×** |
+| markdown-fenced output | 49 KB | 0.25 ms | 2.6 ms | **10.6×** |
+| dirty (quotes/keys/literals) | 5 KB | 0.38 ms | 2.6 ms | **7.0×** |
+
+### Streaming is a different complexity class
+
+A streaming UI re-renders the partial value on every chunk. With a batch
+repairer you must re-parse the whole buffer each time — O(n²) total. The
+stateful `Mender` only pays for the new bytes:
+
+| workload | jsonmend `Mender` | json_repair (`stream_stable=True`) | |
+|---|---|---|---|
+| 150 KB in 4 KB chunks | 6.9 ms | 323 ms | **47×** |
+| 10 MB in 4 KB chunks | 1.2 s | est. >20 min (quadratic) | — |
+
+## Usage
+
+### Drop-in for json_repair
+
+```python
+# before
+from json_repair import repair_json, loads
+# after — same call sites
+from jsonmend import repair_json, loads
+
+repair_json("{'name': 'John', age: 31")     # '{"name": "John", "age": 31}'
+loads('```json\n{"ok": true,}\n```')         # {'ok': True}
+```
+
+`repair_json(json_str, return_objects=..., skip_json_loads=...,
+ensure_ascii=..., **json_dumps_args)`, `loads`, `load(fd)`,
+`from_file(path)` match json_repair's signatures. Valid JSON
+short-circuits through C-speed `json.loads`.
+
+### Streaming
+
+```python
+from jsonmend import Mender
+
+m = Mender()
+for chunk in llm_stream:           # feed as the tokens arrive
+    partial = m.feed(chunk)        # best-effort value, O(new bytes)
+    render(partial)                # e.g. {"answer": "The capital of Fr"}
+value = m.close()                  # final mended value
+```
+
+`feed()` returns a live view that grows in place — including the string
+that is currently streaming in. Any chunking gives byte-identical results
+to batch repair (property-tested over the whole corpus).
+
+### Strict mode
+
+```python
+from jsonmend import loads, JSONMendError
+
+loads("complete garbage")                  # "" (json_repair-compatible)
+loads("complete garbage", strict=True)     # raises JSONMendError
+```
+
+## What it fixes
+
+truncated objects/arrays/strings/numbers/literals · markdown fences with
+prose around them · single/smart/backtick quotes · unescaped inner quotes
+· missing quotes · bare keys and values · `True/False/None/undefined/NaN/
+Infinity` · `//`, `#`, `/* */` comments · trailing/missing/extra commas ·
+missing colons · mismatched brackets · concatenated/NDJSON documents ·
+string concatenation (`"a" + "b"`) · JSONP/MongoDB wrappers
+(`ObjectId("…")`) · Python tuples/sets · ellipsis placeholders ·
+non-string keys · BOM and exotic whitespace · escaped-JSON documents
+(`{\"a\": 1}`) · broken `\u` escapes and surrogate pairs · 100k-deep
+nesting (no recursion anywhere)
+
+## Why it's fast
+
+* **One resumable state machine** serves batch and streaming — batch is
+  a single feed that never suspends, so there is no streaming tax.
+* **Strings cost one `str.find` + one slice** when clean; never a
+  per-character Python loop.
+* **Speculative C parsing**: complete sub-trees inside broken documents
+  are recognized and handed to the C `json` scanner, with a salvage step
+  that parses the longest clean prefix of a broken container in one shot.
+  Semantics-affecting inputs (NaN, control chars, surrogate escapes)
+  fall back to the machine, so behavior never changes.
+* **Bounded backtracking**: a string-close decision can revisit one
+  recorded candidate quote, never rescan; adversarial quote storms stay
+  linear (tested).
+
+## Guarantees
+
+* Output is always **valid RFC 8259 JSON** (or `""`/an exception). Unlike
+  json_repair, `NaN`/`Infinity` never leak into the output text — they
+  serialize as `null` (`loads` still gives you the floats).
+* Output is always UTF-8 encodable (lone surrogates are replaced).
+* Never crashes, never recurses: fuzzed and property-tested, 100k-deep
+  inputs are fine.
+* `Mender.close()` ≡ batch result, for every chunking (property-tested).
+
+## Honest differences vs json_repair
+
+* `logging=True` is not supported (it is incompatible with the
+  single-pass design and is one reason json_repair is slow); a no-op
+  shim raises `TypeError` so you notice.
+* Schema-guided repair (`schema=`) is not implemented in v0.1.
+* json_repair's `stream_stable=True` flag changes how *truncated escapes*
+  render mid-stream; jsonmend's `Mender` is always stream-stable.
+* On `ambiguous` corpus cases the libraries may legitimately differ;
+  jsonmend's choices are documented case-by-case in the corpus
+  rationales.
+
+## The corpus is the point
+
+If you maintain a JSON-repair library in any language: please steal
+[corpus/](corpus/). It is CC0, the format is three fields, and 460 cases
+with rationales are more valuable than any of our engines. Cross-language
+agreement on repair semantics helps everyone shipping LLM systems.
+
+## License
+
+MIT. The conformance corpus is CC0.

jsonmend-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jsonmend"
+version = "0.1.0"
+description = "Mends the JSON your LLM almost wrote - fast single-pass repair with true incremental streaming"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "adam2go" }]
+keywords = ["json", "repair", "fix", "llm", "streaming", "incremental", "agent", "tool-calls"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "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 :: PyPy",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Text Processing :: Filters",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/adam2go/jsonmend"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

jsonmend-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jsonmend-0.1.0/src/jsonmend/__init__.py

@@ -0,0 +1,269 @@
+"""jsonmend — mends the JSON your LLM almost wrote.
+
+Batch API (drop-in for json_repair):
+
+    from jsonmend import repair_json, loads, load, from_file
+
+Streaming API (true incremental, O(new bytes) per feed):
+
+    from jsonmend import Mender
+    m = Mender()
+    for chunk in stream:
+        partial = m.feed(chunk)   # best-effort value so far
+    value = m.close()
+"""
+
+from __future__ import annotations
+
+import json as _json
+import math as _math
+
+from ._engine import SKIP, JSONMendError, MendMachine
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "repair_json", "loads", "load", "from_file",
+    "mend", "Mender", "JSONMendError", "__version__",
+]
+
+
+def mend(text, *, strict=False, _doom_hint=None):
+    """Repair ``text`` and return the parsed Python value.
+
+    This always runs the repair machine (no ``json.loads`` fast path).
+    Returns ``""`` for unmendable input, or raises :class:`JSONMendError`
+    when ``strict`` is true.
+    """
+    if not isinstance(text, str):
+        text = _coerce_text(text)
+    if text and text[0] == "":
+        text = text.lstrip("")
+        _doom_hint = None
+    machine = MendMachine()
+    machine.final = True
+    if _doom_hint is not None:
+        machine.doomed_from = _doom_hint
+    machine.feed(text)
+    result = machine.close()
+    if result is SKIP:
+        if strict:
+            raise JSONMendError("no JSON content found in input")
+        return ""
+    return result
+
+
+def loads(json_str, *, skip_json_loads=False, strict=False, **_compat):
+    """Repair and parse, returning Python objects.
+
+    Valid JSON takes a C-speed ``json.loads`` fast path unless
+    ``skip_json_loads`` is true.
+    """
+    if not isinstance(json_str, str):
+        json_str = _coerce_text(json_str)
+    if not skip_json_loads:
+        try:
+            return _json.loads(json_str)
+        except Exception as e:
+            p = getattr(e, "pos", None)
+            if p is not None and p >= len(json_str):
+                # truncated input: the machine need not rescan the root
+                return mend(json_str, strict=strict, _doom_hint=p)
+    return mend(json_str, strict=strict)
+
+
+def repair_json(json_str="", return_objects=False, skip_json_loads=False,
+                ensure_ascii=True, strict=False, **json_dumps_args):
+    """Repair broken JSON.  Returns a JSON string (or objects).
+
+    API-compatible with ``json_repair.repair_json`` for the core
+    parameters.  Unlike json_repair, the output is always *valid* JSON:
+    non-finite numbers (NaN/Infinity) are serialized as ``null``.
+    """
+    if json_dumps_args.pop("logging", False):
+        raise TypeError(
+            "jsonmend does not support json_repair's logging=True "
+            "(incompatible with single-pass repair); remove the flag")
+    json_dumps_args.pop("stream_stable", None)  # Mender is always stable
+    if not isinstance(json_str, str):
+        json_str = _coerce_text(json_str)
+    value = None
+    hint = None
+    if not skip_json_loads:
+        try:
+            value = _json.loads(json_str)
+            parsed = True
+        except Exception as e:
+            parsed = False
+            p = getattr(e, "pos", None)
+            if p is not None and p >= len(json_str):
+                hint = p
+    else:
+        parsed = False
+    if not parsed:
+        value = mend(json_str, strict=strict, _doom_hint=hint)
+    if return_objects:
+        return value
+    return _dumps(value, ensure_ascii=ensure_ascii, **json_dumps_args)
+
+
+def load(fd, **kwargs):
+    """Repair and parse JSON from a file-like object."""
+    return loads(fd.read(), **kwargs)
+
+
+def from_file(filename, **kwargs):
+    """Repair and parse JSON from a file path."""
+    with open(filename, encoding="utf-8-sig", newline="") as fd:
+        return loads(fd.read(), **kwargs)
+
+
+class Mender:
+    """Stateful incremental mender.
+
+    Each :meth:`feed` consumes one chunk and returns the best-effort
+    parsed value so far; the cost of a feed is proportional to the new
+    bytes, not to everything fed so far.  The returned value is a *live
+    view* that later feeds may extend in place; call :meth:`close` to get
+    the final result.
+    """
+
+    def __init__(self):
+        self._machine = MendMachine()
+        self._closed = False
+        self._result = None
+
+    def feed(self, chunk):
+        """Feed one chunk; returns the current best-effort value."""
+        if self._closed:
+            raise ValueError("Mender is closed")
+        if not isinstance(chunk, str):
+            chunk = _coerce_text(chunk)
+        self._machine.feed(chunk)
+        return self._machine.current()
+
+    @property
+    def value(self):
+        """Current best-effort value without feeding."""
+        if self._closed:
+            return self._result
+        return self._machine.current()
+
+    def close(self):
+        """Finish parsing and return the final mended value."""
+        if not self._closed:
+            result = self._machine.close()
+            self._result = "" if result is SKIP else result
+            self._closed = True
+        return self._result
+
+
+# ---------------------------------------------------------------------------
+# serialization helpers
+# ---------------------------------------------------------------------------
+
+
+def _coerce_text(obj):
+    if isinstance(obj, (bytes, bytearray)):
+        return obj.decode("utf-8", errors="replace")
+    return str(obj)
+
+
+def _sanitize_nonfinite(value):
+    """Replace NaN/Infinity floats with None (iterative, no recursion)."""
+    if isinstance(value, float):
+        return value if _math.isfinite(value) else None
+    if not isinstance(value, (dict, list)):
+        return value
+    root = [] if isinstance(value, list) else {}
+    todo = [(value, root)]
+    while todo:
+        src, dst = todo.pop()
+        items = src.items() if isinstance(src, dict) else enumerate(src)
+        for k, v in items:
+            if isinstance(v, float) and not _math.isfinite(v):
+                v = None
+            elif isinstance(v, dict):
+                new = {}
+                todo.append((v, new))
+                v = new
+            elif isinstance(v, list):
+                new = []
+                todo.append((v, new))
+                v = new
+            if isinstance(dst, dict):
+                dst[k] = v
+            else:
+                dst.append(v)
+    return root
+
+
+def _has_nonfinite(value):
+    todo = [value]
+    while todo:
+        v = todo.pop()
+        if isinstance(v, float):
+            if not _math.isfinite(v):
+                return True
+        elif isinstance(v, dict):
+            todo.extend(v.values())
+        elif isinstance(v, list):
+            todo.extend(v)
+    return False
+
+
+def _dumps(value, ensure_ascii=True, **kw):
+    kw.setdefault("separators", (", ", ": "))
+    try:
+        return _json.dumps(value, ensure_ascii=ensure_ascii,
+                           allow_nan=False, **kw)
+    except ValueError:
+        return _json.dumps(_sanitize_nonfinite(value),
+                           ensure_ascii=ensure_ascii, **kw)
+    except RecursionError:
+        return _iter_dumps(value, ensure_ascii=ensure_ascii)
+
+
+def _iter_dumps(value, ensure_ascii=True):
+    """Iterative serializer for absurdly deep structures."""
+    out = []
+    enc = _json.encoder.encode_basestring_ascii if ensure_ascii \
+        else _json.encoder.encode_basestring
+    stack = [("v", value)]
+    while stack:
+        op, v = stack.pop()
+        if op == "t":  # literal text
+            out.append(v)
+            continue
+        if isinstance(v, dict):
+            out.append("{")
+            stack.append(("t", "}"))
+            items = list(v.items())
+            for idx in range(len(items) - 1, -1, -1):
+                k, val = items[idx]
+                stack.append(("v", val))
+                stack.append(("t", enc(k) + ": "))
+                if idx:
+                    stack.append(("t", ", "))
+            continue
+        if isinstance(v, list):
+            out.append("[")
+            stack.append(("t", "]"))
+            for idx in range(len(v) - 1, -1, -1):
+                stack.append(("v", v[idx]))
+                if idx:
+                    stack.append(("t", ", "))
+            continue
+        if v is True:
+            out.append("true")
+        elif v is False:
+            out.append("false")
+        elif v is None:
+            out.append("null")
+        elif isinstance(v, str):
+            out.append(enc(v))
+        elif isinstance(v, float):
+            out.append(repr(v) if _math.isfinite(v) else "null")
+        else:
+            out.append(str(v))
+    return "".join(out)