fastjsonpatch 0.1.0__tar.gz → 0.1.3__tar.gz

fastjsonpatch-0.1.3/BENCHMARKS.md

@@ -0,0 +1,57 @@
+# fastjsonpatch benchmarks
+
+## Results
+
+Measured on Linux x86_64, Python 3.13 (times are the best of several runs).
+
+Real-world data:
+
+| scenario | size | jsonpatch | fastjsonpatch | speedup |
+|---|---|---|---|---|
+| Kubernetes OpenAPI v1.33 (3.7 MB) → v1.34 (3.8 MB): make_patch | 283 ops | 136.4 ms | 9.6 ms | **14x** |
+| Kubernetes OpenAPI v1.33 → v1.34: apply | 283 ops | 78.0 ms | 11.4 ms | **7x** |
+| 3-op patch on the v1.34 spec | 3.8 MB | 71.1 ms | 10.1 ms | **7x** |
+| 3-op patch on the v1.34 spec, `in_place=True` | 3.8 MB | 21.2 µs | 4.7 µs | **4x** |
+| PyPI metadata snapshots (8k records): make_patch | 2,487 ops | 255.2 ms | 12.1 ms | **21x** |
+| PyPI metadata snapshots: apply | 2,487 ops | 91.7 ms | 14.0 ms | **7x** |
+| REST resource, apply_patch per request | ×1000 | 47.4 ms | 7.5 ms | **6x** |
+| REST resource, make_patch per request | ×1000 | 74.4 ms | 5.6 ms | **13x** |
+
+Synthetic records shaped like `{"id", "name", "score", "tags": [..], "meta": {..}}`:
+
+| workload | ops | make_patch: jsonpatch | fastjsonpatch | speedup | apply: jsonpatch | fastjsonpatch | speedup |
+|---|---|---|---|---|---|---|---|
+| 10k records, 100 field edits | 100 | 292.61 ms | 5.26 ms | **56x** | 89.38 ms | 7.90 ms | **11x** |
+| 10k records, insert 1 at front | 49911 | 669.77 ms | 42.78 ms | **16x** | 535.21 ms | 72.35 ms | **7x** |
+| 10k records, delete 50 | 44900 | 636.53 ms | 40.46 ms | **16x** | 563.20 ms | 63.45 ms | **9x** |
+| 10k records, move 20 | 26305 | 434.93 ms | 24.38 ms | **18x** | 325.64 ms | 41.03 ms | **8x** |
+| 2k ints, insert 1 at front | 1 | 17.04 ms | 1.91 ms | **9x** | 581 µs | 21 µs | **27x** |
+| small config (200 keys), 1 edit | 1 | 1.98 ms | 35 µs | **57x** | 464 µs | 32 µs | **15x** |
+
+Python 3.14 made `copy.deepcopy` about 1.5x faster, so on 3.14 jsonpatch's `apply` on
+a large document is faster too; on the "10k records, 100 field edits" workload the
+`apply` speedup drops from about 11x to about 6x. The `make_patch` speedup stays about
+the same. Run `python bench/compare.py` (from the source distribution) to measure on
+your own machine.
+
+## Where the time goes
+
+**make_patch.** jsonpatch walks both documents in Python and compares every scalar
+with `json.dumps(a) == json.dumps(b)`. Profiling the "10k records" workload with
+cProfile puts about 40% of the time in `json.dumps` and about a third in `isinstance`
+checks against abstract base classes (`MutableMapping`, `MutableSequence`).
+fastjsonpatch walks the documents in Rust over the CPython objects directly (no
+conversion to a Rust data structure), compares values natively with the same rules as the `json.dumps` comparison (`1`, `1.0` and `True`
+are all different, `-0.0 != 0.0`, NaN equals NaN), keeps the current path on a stack,
+and takes a single lockstep pass when two dicts have the same keys in the same order.
+It is a port of jsonpatch's `DiffBuilder`, so it produces the same operations in the
+same order, including detected moves.
+
+**apply.** jsonpatch first runs `copy.deepcopy` on the document (so the original is
+not modified), then builds a `JsonPointer` and an operation object for each operation.
+For a small patch on a large document the copy is nearly all of the time.
+fastjsonpatch copies each dict and list with one C call and only recurses into values
+that are themselves containers; it keeps `deepcopy`'s semantics (shared and cyclic
+references are copied once) but skips the bookkeeping for containers referenced only
+once. It then resolves the paths and runs the operations without creating
+`JsonPointer` or operation objects.

fastjsonpatch-0.1.3/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## 0.1.3 (2026-10-12)
+
+- Fix: `replace` with a path ending in `-` that names a dict key (`{"-": 1}`,
+  path `/-`) was applied; jsonpatch 1.34 raises `InvalidJsonPatch` for it, and
+  fastjsonpatch now does too.
+- Shorter README; full benchmark tables moved to BENCHMARKS.md.
+
+## 0.1.2 (2026-10-11)
+
+Documentation only: the README now states only measured facts (including exactly
+which platforms CI tests), and its link to MAINTAINING.md works on PyPI. No code
+changes. (0.1.1 was tagged but not published.)
+
+## 0.1.0 (2026-10-11)
+
+First release. Behaves like jsonpatch 1.34 with `make_patch`, `apply`/`apply_patch`
+and patch validation in Rust:
+
+- `make_patch` 9-57x faster, `apply` 4-27x faster (see BENCHMARKS.md).
+- Standalone: depends only on `jsonpointer`.
+- Wheels for Linux (glibc and musl, x86_64 and aarch64), macOS (arm64, x86_64) and
+  Windows (x64); one abi3 wheel per platform covers Python 3.12+.

{fastjsonpatch-0.1.0 → fastjsonpatch-0.1.3}/Cargo.lock

@@ -23,7 +23,7 @@ checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
 
 [[package]]
 name = "fastjsonpatch"
-version = "0.1.0"
+version = "0.1.3"
 dependencies = [
  "ahash",
  "pyo3",

{fastjsonpatch-0.1.0 → fastjsonpatch-0.1.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fastjsonpatch"
-version = "0.1.0"
+version = "0.1.3"
 edition = "2024"
 description = "Rust core of the fastjsonpatch Python package"
 license = "BSD-3-Clause"

fastjsonpatch-0.1.3/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: fastjsonpatch
+Version: 0.1.3
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: jsonpointer>=3.0,<4
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: jsonpatch==1.34 ; extra == 'test'
+Provides-Extra: test
+License-File: LICENSE
+License-File: THIRD_PARTY_LICENSES.md
+Summary: Drop-in faster jsonpatch (RFC 6902): make_patch and apply in Rust
+Keywords: json,patch,jsonpatch,rfc6902,diff,rust
+Author-email: bitsbybyun@gmail.com
+License-Expression: BSD-3-Clause
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/amzntiger/fastjsonpatch/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/amzntiger/fastjsonpatch/issues
+Project-URL: Repository, https://github.com/amzntiger/fastjsonpatch
+
+# fastjsonpatch
+
+A drop-in replacement for [jsonpatch](https://github.com/stefankoegl/python-json-patch)
+([RFC 6902](https://www.rfc-editor.org/rfc/rfc6902)) with `make_patch` and `apply`
+written in Rust. It returns the same patches and documents as jsonpatch 1.34 and raises
+exceptions with the same types and messages.
+
+```sh
+pip install fastjsonpatch
+```
+
+```python
+import fastjsonpatch as jsonpatch      # the only line you change
+
+src = {"name": "web", "replicas": 3, "ports": [80, 443]}
+dst = {"name": "web", "replicas": 5, "ports": [80, 443, 8080]}
+
+patch = jsonpatch.make_patch(src, dst)
+patch.patch
+# [{'op': 'replace', 'path': '/replicas', 'value': 5},
+#  {'op': 'add', 'path': '/ports/2', 'value': 8080}]
+
+patch.apply(src) == dst                # True; src is not modified
+jsonpatch.apply_patch(src, [{"op": "remove", "path": "/ports/0"}])
+# {'name': 'web', 'replicas': 3, 'ports': [443]}
+```
+
+Requires CPython 3.12+. Wheels are published for Linux (x86_64, aarch64; glibc and
+musl), macOS (arm64, x86_64) and Windows (x64). The only dependency is `jsonpointer`.
+
+## Performance
+
+Linux x86_64, Python 3.13, best of several runs:
+
+| workload | jsonpatch | fastjsonpatch | speedup |
+|---|---|---|---|
+| `make_patch`, Kubernetes OpenAPI v1.33 → v1.34 (3.7 → 3.8 MB, 283 ops) | 136.4 ms | 9.6 ms | **14x** |
+| `apply`, the same 283 ops | 78.0 ms | 11.4 ms | **7x** |
+| `make_patch`, 10k records with 100 field edits | 292.61 ms | 5.26 ms | **56x** |
+| `apply`, the same 100 ops | 89.38 ms | 7.90 ms | **11x** |
+| `make_patch`, small REST resource ×1000 | 74.4 ms | 5.6 ms | **13x** |
+| `apply_patch`, small REST resource ×1000 | 47.4 ms | 7.5 ms | **6x** |
+
+Across all measured workloads, `make_patch` is 9-57x faster and `apply` 4-27x (4x is a
+3-operation patch applied `in_place` to a 3.8 MB document, where no copy is made). On
+Python 3.14, whose `copy.deepcopy` is faster, the `apply` speedup is smaller (about 6x
+instead of 11x on the 10k-record workload). Full tables and an explanation of where
+the time goes are in
+[BENCHMARKS.md](https://github.com/amzntiger/fastjsonpatch/blob/main/BENCHMARKS.md);
+`python bench/compare.py` (in the source distribution) measures on your machine.
+
+## Compatibility
+
+fastjsonpatch is jsonpatch 1.34's module with `JsonPatch.__init__` (validation),
+`JsonPatch.from_diff` (`make_patch`) and `JsonPatch.apply` (`apply_patch`) routed to
+Rust; every other public name is jsonpatch's own code. Inputs the Rust code does not
+handle exactly fall back to jsonpatch's original code before anything is modified:
+non-JSON values, dict or list subclasses, nesting deeper than 1000, a custom `dumps=`
+or `json_dumper`, a custom `pointer_cls`, `operations` or `_get_operation` (for
+`apply`), and operations that would fail.
+
+Known differences:
+
+- The exception classes are fastjsonpatch's own, so
+  `except fastjsonpatch.JsonPatchConflict` does not catch an exception raised by the `jsonpatch` package, and vice versa.
+- Values in a document that are not dicts, lists or JSON scalars are copied with
+  `copy.deepcopy` one by one, so aliasing between such values is not preserved.
+- `__version__` is fastjsonpatch's version; `__jsonpatch_version__` is `"1.34"`.
+  jsonpatch's `__author__` and `__website__` are not defined.
+
+## Testing
+
+About 1,580 tests: randomized comparisons against jsonpatch 1.34 (patches, documents
+and errors), jsonpatch's own test suite and doctests, and the
+[json-patch-tests](https://github.com/json-patch/json-patch-tests) RFC 6902 suite.
+CI runs them with Python 3.12-3.14 on Linux (x86_64, aarch64; glibc), macOS (arm64,
+x86_64) and Windows (x64); the musl wheels are built but not tested in CI.
+
+## License
+
+BSD-3-Clause. The Python module and the diff algorithm come from jsonpatch
+(Copyright (c) 2011 Stefan Kögl, BSD). Licenses of the Rust crates compiled into the
+wheels are in `THIRD_PARTY_LICENSES.md`. Development and release notes:
+[MAINTAINING.md](https://github.com/amzntiger/fastjsonpatch/blob/main/MAINTAINING.md).
+

fastjsonpatch-0.1.3/README.md

@@ -0,0 +1,84 @@
+# fastjsonpatch
+
+A drop-in replacement for [jsonpatch](https://github.com/stefankoegl/python-json-patch)
+([RFC 6902](https://www.rfc-editor.org/rfc/rfc6902)) with `make_patch` and `apply`
+written in Rust. It returns the same patches and documents as jsonpatch 1.34 and raises
+exceptions with the same types and messages.
+
+```sh
+pip install fastjsonpatch
+```
+
+```python
+import fastjsonpatch as jsonpatch      # the only line you change
+
+src = {"name": "web", "replicas": 3, "ports": [80, 443]}
+dst = {"name": "web", "replicas": 5, "ports": [80, 443, 8080]}
+
+patch = jsonpatch.make_patch(src, dst)
+patch.patch
+# [{'op': 'replace', 'path': '/replicas', 'value': 5},
+#  {'op': 'add', 'path': '/ports/2', 'value': 8080}]
+
+patch.apply(src) == dst                # True; src is not modified
+jsonpatch.apply_patch(src, [{"op": "remove", "path": "/ports/0"}])
+# {'name': 'web', 'replicas': 3, 'ports': [443]}
+```
+
+Requires CPython 3.12+. Wheels are published for Linux (x86_64, aarch64; glibc and
+musl), macOS (arm64, x86_64) and Windows (x64). The only dependency is `jsonpointer`.
+
+## Performance
+
+Linux x86_64, Python 3.13, best of several runs:
+
+| workload | jsonpatch | fastjsonpatch | speedup |
+|---|---|---|---|
+| `make_patch`, Kubernetes OpenAPI v1.33 → v1.34 (3.7 → 3.8 MB, 283 ops) | 136.4 ms | 9.6 ms | **14x** |
+| `apply`, the same 283 ops | 78.0 ms | 11.4 ms | **7x** |
+| `make_patch`, 10k records with 100 field edits | 292.61 ms | 5.26 ms | **56x** |
+| `apply`, the same 100 ops | 89.38 ms | 7.90 ms | **11x** |
+| `make_patch`, small REST resource ×1000 | 74.4 ms | 5.6 ms | **13x** |
+| `apply_patch`, small REST resource ×1000 | 47.4 ms | 7.5 ms | **6x** |
+
+Across all measured workloads, `make_patch` is 9-57x faster and `apply` 4-27x (4x is a
+3-operation patch applied `in_place` to a 3.8 MB document, where no copy is made). On
+Python 3.14, whose `copy.deepcopy` is faster, the `apply` speedup is smaller (about 6x
+instead of 11x on the 10k-record workload). Full tables and an explanation of where
+the time goes are in
+[BENCHMARKS.md](https://github.com/amzntiger/fastjsonpatch/blob/main/BENCHMARKS.md);
+`python bench/compare.py` (in the source distribution) measures on your machine.
+
+## Compatibility
+
+fastjsonpatch is jsonpatch 1.34's module with `JsonPatch.__init__` (validation),
+`JsonPatch.from_diff` (`make_patch`) and `JsonPatch.apply` (`apply_patch`) routed to
+Rust; every other public name is jsonpatch's own code. Inputs the Rust code does not
+handle exactly fall back to jsonpatch's original code before anything is modified:
+non-JSON values, dict or list subclasses, nesting deeper than 1000, a custom `dumps=`
+or `json_dumper`, a custom `pointer_cls`, `operations` or `_get_operation` (for
+`apply`), and operations that would fail.
+
+Known differences:
+
+- The exception classes are fastjsonpatch's own, so
+  `except fastjsonpatch.JsonPatchConflict` does not catch an exception raised by the `jsonpatch` package, and vice versa.
+- Values in a document that are not dicts, lists or JSON scalars are copied with
+  `copy.deepcopy` one by one, so aliasing between such values is not preserved.
+- `__version__` is fastjsonpatch's version; `__jsonpatch_version__` is `"1.34"`.
+  jsonpatch's `__author__` and `__website__` are not defined.
+
+## Testing
+
+About 1,580 tests: randomized comparisons against jsonpatch 1.34 (patches, documents
+and errors), jsonpatch's own test suite and doctests, and the
+[json-patch-tests](https://github.com/json-patch/json-patch-tests) RFC 6902 suite.
+CI runs them with Python 3.12-3.14 on Linux (x86_64, aarch64; glibc), macOS (arm64,
+x86_64) and Windows (x64); the musl wheels are built but not tested in CI.
+
+## License
+
+BSD-3-Clause. The Python module and the diff algorithm come from jsonpatch
+(Copyright (c) 2011 Stefan Kögl, BSD). Licenses of the Rust crates compiled into the
+wheels are in `THIRD_PARTY_LICENSES.md`. Development and release notes:
+[MAINTAINING.md](https://github.com/amzntiger/fastjsonpatch/blob/main/MAINTAINING.md).

{fastjsonpatch-0.1.0 → fastjsonpatch-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "fastjsonpatch"
-version = "0.1.0"
+version = "0.1.3"
 description = "Drop-in faster jsonpatch (RFC 6902): make_patch and apply in Rust"
 readme = "README.md"
 license = "BSD-3-Clause"

{fastjsonpatch-0.1.0 → fastjsonpatch-0.1.3}/src/lib.rs

@@ -835,6 +835,9 @@ impl<'py> Applier<'_, 'py> {
                 if parts.is_empty() {
                     return Ok(Some(deepcopy(&v)?));
                 }
+                if parts.last().is_some_and(|p| p == "-") {
+                    return Ok(None); // jsonpatch rejects "-" here even for a dict key
+                }
                 let Some(s) = slot(obj, parts)? else { return Ok(None) };
                 if slot_value(&s)?.is_none() {
                     return Ok(None);

{fastjsonpatch-0.1.0 → fastjsonpatch-0.1.3}/tests/test_parity.py

@@ -163,6 +163,25 @@ def test_invalid_patches(patch):
     assert outcome(lambda: fastjsonpatch.JsonPatch(patch)) == outcome(lambda: jsonpatch.JsonPatch(patch))
 
 
+@pytest.mark.parametrize("doc, patch", [
+    # jsonpatch rejects a final "-" in replace even when it names a dict key
+    ({"-": 1}, [{"op": "replace", "path": "/-", "value": 2}]),
+    ({"a": {"-": 1}}, [{"op": "replace", "path": "/a/-", "value": 2}]),
+    ([1], [{"op": "replace", "path": "/-", "value": 2}]),
+    ({"-": 1}, [{"op": "remove", "path": "/-"}]),
+    ({"-": 1}, [{"op": "add", "path": "/-", "value": 2}]),
+    ({"-": 1}, [{"op": "test", "path": "/-", "value": 1}]),
+    ({"-": 1}, [{"op": "move", "from": "/-", "path": "/b"}]),
+    ({"-": 1}, [{"op": "copy", "from": "/-", "path": "/b"}]),
+])
+def test_dash_key(doc, patch):
+    for in_place in (False, True):
+        a, b = copy.deepcopy(doc), copy.deepcopy(doc)
+        assert (outcome(lambda: fastjsonpatch.apply_patch(a, patch, in_place=in_place))
+                == outcome(lambda: jsonpatch.apply_patch(b, patch, in_place=in_place)))
+        assert repr(a) == repr(b)
+
+
 def test_exceptions_have_the_same_hierarchy():
     with pytest.raises(fastjsonpatch.JsonPatchConflict):
         fastjsonpatch.apply_patch({}, [{"op": "remove", "path": "/a"}])

fastjsonpatch-0.1.0/CHANGELOG.md

@@ -1,11 +0,0 @@
-# Changelog
-
-## 0.1.0 (2026-10-11)
-
-First release. Behaves like jsonpatch 1.34 with `make_patch`, `apply`/`apply_patch`
-and patch validation in Rust:
-
-- `make_patch` 9-57x faster, `apply` 6-27x faster (see README).
-- Standalone: depends only on `jsonpointer`.
-- Wheels for Linux (glibc and musl, x86_64 and aarch64), macOS (arm64, x86_64) and
-  Windows (x64); one abi3 wheel per platform covers Python 3.12+.

fastjsonpatch-0.1.0/PKG-INFO

@@ -1,200 +0,0 @@
-Metadata-Version: 2.4
-Name: fastjsonpatch
-Version: 0.1.0
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Rust
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Topic :: Software Development :: Libraries
-Requires-Dist: jsonpointer>=3.0,<4
-Requires-Dist: pytest ; extra == 'test'
-Requires-Dist: jsonpatch==1.34 ; extra == 'test'
-Provides-Extra: test
-License-File: LICENSE
-License-File: THIRD_PARTY_LICENSES.md
-Summary: Drop-in faster jsonpatch (RFC 6902): make_patch and apply in Rust
-Keywords: json,patch,jsonpatch,rfc6902,diff,rust
-Author-email: bitsbybyun@gmail.com
-License-Expression: BSD-3-Clause
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Changelog, https://github.com/amzntiger/fastjsonpatch/blob/main/CHANGELOG.md
-Project-URL: Issues, https://github.com/amzntiger/fastjsonpatch/issues
-Project-URL: Repository, https://github.com/amzntiger/fastjsonpatch
-
-# fastjsonpatch
-
-A drop-in, faster [jsonpatch](https://github.com/stefankoegl/python-json-patch)
-([RFC 6902](https://www.rfc-editor.org/rfc/rfc6902) JSON Patch) for Python.
-`make_patch` and `apply` run in Rust and return the **same patches, the same documents
-and the same exceptions** as jsonpatch 1.34: typically 10-50x faster to make a patch
-and 6-15x faster to apply one.
-
-```sh
-pip install fastjsonpatch
-```
-
-```python
-import fastjsonpatch as jsonpatch      # the only line you change
-
-src = {"name": "web", "replicas": 3, "ports": [80, 443]}
-dst = {"name": "web", "replicas": 5, "ports": [80, 443, 8080]}
-
-patch = jsonpatch.make_patch(src, dst)
-patch.patch
-# [{'op': 'replace', 'path': '/replicas', 'value': 5},
-#  {'op': 'add', 'path': '/ports/2', 'value': 8080}]
-
-patch.apply(src) == dst                # True; src is not modified
-jsonpatch.apply_patch(src, [{"op": "remove", "path": "/ports/0"}])
-# {'name': 'web', 'replicas': 3, 'ports': [443]}
-```
-
-Python 3.12+ (CPython). Prebuilt wheels for Linux (x86_64 and aarch64, glibc and
-musl), macOS (Apple Silicon and Intel) and Windows (x64); one wheel per platform covers
-every Python from 3.12 on. The only dependency is `jsonpointer`.
-
-## Why
-
-JSON Patch describes a change to a JSON document as a list of operations (`add`,
-`remove`, `replace`, `move`, `copy`, `test`). It is how HTTP `PATCH` requests,
-Kubernetes and many APIs express partial updates, and how tools store or send the
-difference between two versions of a document.
-
-jsonpatch is the standard Python implementation, and it is written in pure Python.
-That is fine for small documents, but the cost grows quickly:
-
-- `make_patch` on a 10,000-record document takes about 300 ms (on a fast machine),
-  and diffing two Kubernetes OpenAPI specs (3.7 MB) takes about 140 ms.
-- `apply` deep-copies the whole document first, so even a one-operation patch on a
-  large document costs tens of milliseconds.
-- A web service that applies or computes a patch per request spends 40-75 µs on
-  each call, even for small resources.
-
-fastjsonpatch keeps jsonpatch's behaviour exactly and moves these hot paths to Rust,
-so existing code gets faster without changes.
-
-## Speed
-
-Measured on Linux x86_64, Python 3.13 (times are the best of several runs).
-
-Real-world data:
-
-| scenario | size | jsonpatch | fastjsonpatch | speedup |
-|---|---|---|---|---|
-| Kubernetes OpenAPI v1.33 → v1.34: make_patch | 3.7 MB, 283 ops | 136.4 ms | 9.6 ms | **14x** |
-| Kubernetes OpenAPI v1.33 → v1.34: apply | 283 ops | 78.0 ms | 11.4 ms | **7x** |
-| 3-op patch on the 3.8 MB spec | | 71.1 ms | 10.1 ms | **7x** |
-| 3-op patch on the 3.8 MB spec, `in_place=True` | | 21.2 µs | 4.7 µs | **4x** |
-| PyPI metadata snapshots (8k records): make_patch | 2,487 ops | 255.2 ms | 12.1 ms | **21x** |
-| PyPI metadata snapshots: apply | 2,487 ops | 91.7 ms | 14.0 ms | **7x** |
-| REST resource, apply_patch per request | ×1000 | 47.4 ms | 7.5 ms | **6x** |
-| REST resource, make_patch per request | ×1000 | 74.4 ms | 5.6 ms | **13x** |
-
-Synthetic records shaped like `{"id", "name", "score", "tags": [..], "meta": {..}}`:
-
-| workload | ops | make_patch: jsonpatch | fastjsonpatch | speedup | apply: jsonpatch | fastjsonpatch | speedup |
-|---|---|---|---|---|---|---|---|
-| 10k records, 100 field edits | 100 | 292.61 ms | 5.26 ms | **56x** | 89.38 ms | 7.90 ms | **11x** |
-| 10k records, insert 1 at front | 49911 | 669.77 ms | 42.78 ms | **16x** | 535.21 ms | 72.35 ms | **7x** |
-| 10k records, delete 50 | 44900 | 636.53 ms | 40.46 ms | **16x** | 563.20 ms | 63.45 ms | **9x** |
-| 10k records, move 20 | 26305 | 434.93 ms | 24.38 ms | **18x** | 325.64 ms | 41.03 ms | **8x** |
-| 2k ints, insert 1 at front | 1 | 17.04 ms | 1.91 ms | **9x** | 581 µs | 21 µs | **27x** |
-| small config (200 keys), 1 edit | 1 | 1.98 ms | 35 µs | **57x** | 464 µs | 32 µs | **15x** |
-
-Python 3.14 made `copy.deepcopy` about 1.6x faster, so on 3.14 jsonpatch's `apply` on
-a large document is faster too and the gap shrinks to about 6x. `make_patch` is not
-affected. Run `python bench/compare.py` (from the source distribution) to measure on
-your own machine.
-
-## Why it is faster
-
-**make_patch.** jsonpatch walks both documents in Python and compares every scalar
-with `json.dumps(a) == json.dumps(b)`. That serialisation is about half of the
-runtime; the rest is `isinstance` checks against abstract base classes and path
-tuples rebuilt at every level. fastjsonpatch walks the documents in Rust over the
-CPython objects directly (no conversion to a Rust data structure), compares values
-natively with the same rules as the `json.dumps` comparison (`1`, `1.0` and `True`
-are all different, `-0.0 != 0.0`, NaN equals NaN), keeps the current path on a stack,
-and takes a single lockstep pass when two dicts have the same keys in the same order.
-It is a port of jsonpatch's `DiffBuilder`, so it produces the same operations in the
-same order, including detected moves.
-
-**apply.** jsonpatch first runs `copy.deepcopy` on the document (so the original is
-not modified), then builds a `JsonPointer` and an operation object for each operation.
-For a small patch on a large document the copy is nearly all of the time.
-fastjsonpatch copies each dict and list with one C call and only recurses into values
-that are themselves containers; it keeps `deepcopy`'s semantics (shared and cyclic
-references are copied once) but skips the bookkeeping for containers referenced only
-once. It then resolves the paths and runs the operations without creating
-intermediate objects.
-
-## Compatibility
-
-fastjsonpatch is jsonpatch's own module (BSD licensed) with three methods routed to
-Rust: `JsonPatch.__init__` (validation), `JsonPatch.from_diff` (`make_patch`) and
-`JsonPatch.apply` (`apply_patch`). Everything else is jsonpatch's code, so the public
-API is identical: `JsonPatch`, `make_patch`, `apply_patch`, `JsonPatch.from_string`,
-the operation classes, `DiffBuilder`, `multidict`, and the exceptions
-`JsonPatchException`, `InvalidJsonPatch`, `JsonPatchConflict`, `JsonPatchTestFailed`
-(with the same hierarchy, and `JsonPointerException` from jsonpointer).
-
-The Rust code handles the common case and hands anything else back to the original
-Python code, so results never differ:
-
-- **make_patch**: values it cannot reproduce exactly (non-JSON types that need
-  comparing, dict or list subclasses, a custom `dumps=`, nesting deeper than 1000)
-  are diffed by the original `DiffBuilder`.
-- **apply**: works on plain dicts and lists. An operation that would fail, or that
-  touches anything else, is run by the original operation classes before anything is
-  mutated, so errors have the same type and message.
-- Subclasses of `JsonPatch` with custom `operations`, `pointer_cls` or `json_dumper`,
-  and patches that are not lists or tuples, use the original code.
-
-Known differences:
-
-- The exception classes belong to fastjsonpatch. An exception raised by the original
-  `jsonpatch` package (for example inside another library that imports it) is not
-  caught by `except fastjsonpatch.JsonPatchConflict`, and vice versa.
-- A value that is not a dict, list or JSON scalar inside a document being applied to
-  is copied with `copy.deepcopy` on its own, so aliasing between such values is not
-  preserved.
-
-`fastjsonpatch.__jsonpatch_version__` says which jsonpatch release the behaviour
-matches (currently `1.34`).
-
-## How it is tested
-
-About 1,570 tests, run on every supported OS and Python version:
-
-- **Parity:** random documents, mutations and patches (valid and invalid) run through
-  both fastjsonpatch and jsonpatch 1.34, comparing the resulting patches and documents
-  by `repr` and errors by type and message. Also covers aliasing, cycles, non-JSON
-  values, subclasses, deep nesting and every fallback path.
-- **jsonpatch's own test suite** and doctests, run against fastjsonpatch.
-- **RFC 6902 conformance:** the
-  [json-patch-tests](https://github.com/json-patch/json-patch-tests) suite.
-
-The source distribution includes the tests and the benchmark.
-
-## Development
-
-```sh
-pip install maturin
-maturin develop --release
-pip install "jsonpatch==1.34" pytest   # jsonpatch is the reference for the parity tests
-pytest tests
-python bench/compare.py                # speed vs jsonpatch on this machine
-```
-
-See [MAINTAINING.md](MAINTAINING.md) for releases and upkeep.
-
-## License
-
-BSD-3-Clause. The Python module and the diff algorithm come from jsonpatch
-(Copyright (c) 2011 Stefan Kögl, BSD). The licenses of the Rust crates compiled into
-the wheels are in `THIRD_PARTY_LICENSES.md`.
-

fastjsonpatch-0.1.0/README.md

@@ -1,172 +0,0 @@
-# fastjsonpatch
-
-A drop-in, faster [jsonpatch](https://github.com/stefankoegl/python-json-patch)
-([RFC 6902](https://www.rfc-editor.org/rfc/rfc6902) JSON Patch) for Python.
-`make_patch` and `apply` run in Rust and return the **same patches, the same documents
-and the same exceptions** as jsonpatch 1.34: typically 10-50x faster to make a patch
-and 6-15x faster to apply one.
-
-```sh
-pip install fastjsonpatch
-```
-
-```python
-import fastjsonpatch as jsonpatch      # the only line you change
-
-src = {"name": "web", "replicas": 3, "ports": [80, 443]}
-dst = {"name": "web", "replicas": 5, "ports": [80, 443, 8080]}
-
-patch = jsonpatch.make_patch(src, dst)
-patch.patch
-# [{'op': 'replace', 'path': '/replicas', 'value': 5},
-#  {'op': 'add', 'path': '/ports/2', 'value': 8080}]
-
-patch.apply(src) == dst                # True; src is not modified
-jsonpatch.apply_patch(src, [{"op": "remove", "path": "/ports/0"}])
-# {'name': 'web', 'replicas': 3, 'ports': [443]}
-```
-
-Python 3.12+ (CPython). Prebuilt wheels for Linux (x86_64 and aarch64, glibc and
-musl), macOS (Apple Silicon and Intel) and Windows (x64); one wheel per platform covers
-every Python from 3.12 on. The only dependency is `jsonpointer`.
-
-## Why
-
-JSON Patch describes a change to a JSON document as a list of operations (`add`,
-`remove`, `replace`, `move`, `copy`, `test`). It is how HTTP `PATCH` requests,
-Kubernetes and many APIs express partial updates, and how tools store or send the
-difference between two versions of a document.
-
-jsonpatch is the standard Python implementation, and it is written in pure Python.
-That is fine for small documents, but the cost grows quickly:
-
-- `make_patch` on a 10,000-record document takes about 300 ms (on a fast machine),
-  and diffing two Kubernetes OpenAPI specs (3.7 MB) takes about 140 ms.
-- `apply` deep-copies the whole document first, so even a one-operation patch on a
-  large document costs tens of milliseconds.
-- A web service that applies or computes a patch per request spends 40-75 µs on
-  each call, even for small resources.
-
-fastjsonpatch keeps jsonpatch's behaviour exactly and moves these hot paths to Rust,
-so existing code gets faster without changes.
-
-## Speed
-
-Measured on Linux x86_64, Python 3.13 (times are the best of several runs).
-
-Real-world data:
-
-| scenario | size | jsonpatch | fastjsonpatch | speedup |
-|---|---|---|---|---|
-| Kubernetes OpenAPI v1.33 → v1.34: make_patch | 3.7 MB, 283 ops | 136.4 ms | 9.6 ms | **14x** |
-| Kubernetes OpenAPI v1.33 → v1.34: apply | 283 ops | 78.0 ms | 11.4 ms | **7x** |
-| 3-op patch on the 3.8 MB spec | | 71.1 ms | 10.1 ms | **7x** |
-| 3-op patch on the 3.8 MB spec, `in_place=True` | | 21.2 µs | 4.7 µs | **4x** |
-| PyPI metadata snapshots (8k records): make_patch | 2,487 ops | 255.2 ms | 12.1 ms | **21x** |
-| PyPI metadata snapshots: apply | 2,487 ops | 91.7 ms | 14.0 ms | **7x** |
-| REST resource, apply_patch per request | ×1000 | 47.4 ms | 7.5 ms | **6x** |
-| REST resource, make_patch per request | ×1000 | 74.4 ms | 5.6 ms | **13x** |
-
-Synthetic records shaped like `{"id", "name", "score", "tags": [..], "meta": {..}}`:
-
-| workload | ops | make_patch: jsonpatch | fastjsonpatch | speedup | apply: jsonpatch | fastjsonpatch | speedup |
-|---|---|---|---|---|---|---|---|
-| 10k records, 100 field edits | 100 | 292.61 ms | 5.26 ms | **56x** | 89.38 ms | 7.90 ms | **11x** |
-| 10k records, insert 1 at front | 49911 | 669.77 ms | 42.78 ms | **16x** | 535.21 ms | 72.35 ms | **7x** |
-| 10k records, delete 50 | 44900 | 636.53 ms | 40.46 ms | **16x** | 563.20 ms | 63.45 ms | **9x** |
-| 10k records, move 20 | 26305 | 434.93 ms | 24.38 ms | **18x** | 325.64 ms | 41.03 ms | **8x** |
-| 2k ints, insert 1 at front | 1 | 17.04 ms | 1.91 ms | **9x** | 581 µs | 21 µs | **27x** |
-| small config (200 keys), 1 edit | 1 | 1.98 ms | 35 µs | **57x** | 464 µs | 32 µs | **15x** |
-
-Python 3.14 made `copy.deepcopy` about 1.6x faster, so on 3.14 jsonpatch's `apply` on
-a large document is faster too and the gap shrinks to about 6x. `make_patch` is not
-affected. Run `python bench/compare.py` (from the source distribution) to measure on
-your own machine.
-
-## Why it is faster
-
-**make_patch.** jsonpatch walks both documents in Python and compares every scalar
-with `json.dumps(a) == json.dumps(b)`. That serialisation is about half of the
-runtime; the rest is `isinstance` checks against abstract base classes and path
-tuples rebuilt at every level. fastjsonpatch walks the documents in Rust over the
-CPython objects directly (no conversion to a Rust data structure), compares values
-natively with the same rules as the `json.dumps` comparison (`1`, `1.0` and `True`
-are all different, `-0.0 != 0.0`, NaN equals NaN), keeps the current path on a stack,
-and takes a single lockstep pass when two dicts have the same keys in the same order.
-It is a port of jsonpatch's `DiffBuilder`, so it produces the same operations in the
-same order, including detected moves.
-
-**apply.** jsonpatch first runs `copy.deepcopy` on the document (so the original is
-not modified), then builds a `JsonPointer` and an operation object for each operation.
-For a small patch on a large document the copy is nearly all of the time.
-fastjsonpatch copies each dict and list with one C call and only recurses into values
-that are themselves containers; it keeps `deepcopy`'s semantics (shared and cyclic
-references are copied once) but skips the bookkeeping for containers referenced only
-once. It then resolves the paths and runs the operations without creating
-intermediate objects.
-
-## Compatibility
-
-fastjsonpatch is jsonpatch's own module (BSD licensed) with three methods routed to
-Rust: `JsonPatch.__init__` (validation), `JsonPatch.from_diff` (`make_patch`) and
-`JsonPatch.apply` (`apply_patch`). Everything else is jsonpatch's code, so the public
-API is identical: `JsonPatch`, `make_patch`, `apply_patch`, `JsonPatch.from_string`,
-the operation classes, `DiffBuilder`, `multidict`, and the exceptions
-`JsonPatchException`, `InvalidJsonPatch`, `JsonPatchConflict`, `JsonPatchTestFailed`
-(with the same hierarchy, and `JsonPointerException` from jsonpointer).
-
-The Rust code handles the common case and hands anything else back to the original
-Python code, so results never differ:
-
-- **make_patch**: values it cannot reproduce exactly (non-JSON types that need
-  comparing, dict or list subclasses, a custom `dumps=`, nesting deeper than 1000)
-  are diffed by the original `DiffBuilder`.
-- **apply**: works on plain dicts and lists. An operation that would fail, or that
-  touches anything else, is run by the original operation classes before anything is
-  mutated, so errors have the same type and message.
-- Subclasses of `JsonPatch` with custom `operations`, `pointer_cls` or `json_dumper`,
-  and patches that are not lists or tuples, use the original code.
-
-Known differences:
-
-- The exception classes belong to fastjsonpatch. An exception raised by the original
-  `jsonpatch` package (for example inside another library that imports it) is not
-  caught by `except fastjsonpatch.JsonPatchConflict`, and vice versa.
-- A value that is not a dict, list or JSON scalar inside a document being applied to
-  is copied with `copy.deepcopy` on its own, so aliasing between such values is not
-  preserved.
-
-`fastjsonpatch.__jsonpatch_version__` says which jsonpatch release the behaviour
-matches (currently `1.34`).
-
-## How it is tested
-
-About 1,570 tests, run on every supported OS and Python version:
-
-- **Parity:** random documents, mutations and patches (valid and invalid) run through
-  both fastjsonpatch and jsonpatch 1.34, comparing the resulting patches and documents
-  by `repr` and errors by type and message. Also covers aliasing, cycles, non-JSON
-  values, subclasses, deep nesting and every fallback path.
-- **jsonpatch's own test suite** and doctests, run against fastjsonpatch.
-- **RFC 6902 conformance:** the
-  [json-patch-tests](https://github.com/json-patch/json-patch-tests) suite.
-
-The source distribution includes the tests and the benchmark.
-
-## Development
-
-```sh
-pip install maturin
-maturin develop --release
-pip install "jsonpatch==1.34" pytest   # jsonpatch is the reference for the parity tests
-pytest tests
-python bench/compare.py                # speed vs jsonpatch on this machine
-```
-
-See [MAINTAINING.md](MAINTAINING.md) for releases and upkeep.
-
-## License
-
-BSD-3-Clause. The Python module and the diff algorithm come from jsonpatch
-(Copyright (c) 2011 Stefan Kögl, BSD). The licenses of the Rust crates compiled into
-the wheels are in `THIRD_PARTY_LICENSES.md`.