fastjsonpatch 0.1.2__tar.gz → 0.1.4__tar.gz

{fastjsonpatch-0.1.2 → fastjsonpatch-0.1.4}/.github/workflows/CI.yml

@@ -44,7 +44,10 @@ jobs:
         run: |
           python -m pip install --upgrade pip maturin
           maturin build --release --out dist
-          python -m pip install --only-binary fastjsonpatch --find-links dist "fastjsonpatch[test]"
+          # Install the wheel just built by its path: with --find-links, pip prefers a
+          # PyPI wheel of the same version and platform tag over the local one.
+          wheel=$(ls dist/*.whl)
+          python -m pip install "${wheel}[test]"
       - name: Tests (parity with jsonpatch, upstream suite, RFC 6902 suite)
         shell: bash
         run: |
@@ -127,6 +130,21 @@ jobs:
           name: sdist
           path: dist
 
+  # One check for branch protection to require: fails unless every test, wheel and
+  # sdist job succeeded.
+  ci-ok:
+    name: ci-ok
+    needs: [test, wheels, sdist]
+    if: always()
+    runs-on: ubuntu-latest
+    steps:
+      - name: All required jobs succeeded
+        run: |
+          echo 'test=${{ needs.test.result }} wheels=${{ needs.wheels.result }} sdist=${{ needs.sdist.result }}'
+          test '${{ needs.test.result }}' = success
+          test '${{ needs.wheels.result }}' = success
+          test '${{ needs.sdist.result }}' = success
+
   publish:
     name: publish to ${{ startsWith(github.ref, 'refs/tags/v') && 'PyPI' || 'TestPyPI' }}
     needs: [test, wheels, sdist]

fastjsonpatch-0.1.4/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.4/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+## 0.1.4 (2026-10-12)
+
+- `import fastjsonpatch` takes about 11 ms instead of about 53 ms: `__version__` now
+  comes from the Rust module instead of `importlib.metadata`, which is no longer
+  imported. (jsonpatch 1.34 takes about 11 ms.)
+- CI: the macOS and Windows test jobs installed the wheel from PyPI instead of the
+  one built in the job whenever both had the same version; they now install the
+  built wheel by path. No change to the package.
+
+## 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.2 → fastjsonpatch-0.1.4}/Cargo.lock

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

{fastjsonpatch-0.1.2 → fastjsonpatch-0.1.4}/Cargo.toml

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

{fastjsonpatch-0.1.2 → fastjsonpatch-0.1.4}/MAINTAINING.md

@@ -19,7 +19,7 @@ jsonpatch 1.34. A behaviour difference is a bug, unless it is listed in the READ
 ```sh
 maturin develop --release
 pip install "jsonpatch==1.34" pytest
-pytest tests                 # ~1570 tests, a few seconds
+pytest tests                 # ~1580 tests, a few seconds
 python bench/compare.py      # speed vs jsonpatch
 ```
 
@@ -33,6 +33,19 @@ python bench/compare.py      # speed vs jsonpatch
 CI runs the tests and the speed comparison on Linux x86_64/arm64, macOS arm64/x86_64
 and Windows for Python 3.12, 3.13 and 3.14; the run's summary page has the table.
 
+## Making changes
+
+Every change goes through a pull request; nothing is pushed to `main` directly.
+
+1. Branch from `main` (`fix/...`, `feat/...`, `chore/...`), commit, push the branch.
+2. Open a pull request. CI runs on it; the `ci-ok` check passes only when every
+   test, wheel and sdist job passed.
+3. Review the diff on the pull request page, then merge (squash or merge commit).
+
+`main` has a branch rule that requires a pull request and the `ci-ok` check. It does
+not require an approving review: GitHub does not let the author approve their own
+pull request, and the maintainer pushes with their own account.
+
 ## Versions
 
 [Semantic versioning](https://semver.org): `MAJOR.MINOR.PATCH`.
@@ -46,19 +59,22 @@ and Windows for Python 3.12, 3.13 and 3.14; the run's summary page has the table
 While on 0.x the API may still change between minor versions. Go to 1.0 once the
 package has had real-world use without behaviour bugs.
 
-The version lives only in `pyproject.toml` (`[project] version`);
-`fastjsonpatch.__version__` reads it from the installed package. `Cargo.toml` is not
-published and can stay at 0.1.0.
+The published version comes from `pyproject.toml` (`[project] version`);
+`fastjsonpatch.__version__` reads it from the installed package. Keep `Cargo.toml`
+and `Cargo.lock` at the same version (they ship in the sdist).
 
 ## Releasing
 
-1. Update the version in `pyproject.toml` and `CHANGELOG.md`; merge to `main` with green CI.
+1. In a pull request, update the version in `pyproject.toml`, `Cargo.toml` (and
+   `Cargo.lock`) and `CHANGELOG.md`; merge it with a green `ci-ok`.
 2. Optional dry run: Actions → CI → "Run workflow" with target `testpypi`, then
    `pip install -i https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ fastjsonpatch`.
    A version number can be uploaded to TestPyPI only once as well, so use a dev
    version (e.g. `0.1.1.dev1`) for dry runs.
-3. `git tag v0.1.1 && git push origin v0.1.1`. CI checks that the tag equals the
-   version, builds every wheel and the sdist, and publishes to PyPI.
+3. On the merged `main` commit: `git tag v0.1.1 && git push origin v0.1.1`. CI checks
+   that the tag equals the version and builds every wheel and the sdist; the publish
+   job then waits for approval in the `pypi` environment (Actions → the run →
+   Review deployments) and uploads to PyPI.
 
 A version uploaded to PyPI can be yanked (hidden from new installs) but its number can
 never be reused. Fix mistakes with a new PATCH release.

fastjsonpatch-0.1.4/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: fastjsonpatch
+Version: 0.1.4
+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.4/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.2 → fastjsonpatch-0.1.4}/pyproject.toml

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

{fastjsonpatch-0.1.2 → fastjsonpatch-0.1.4}/python/fastjsonpatch/__init__.py

@@ -50,7 +50,6 @@ Custom pointer classes, custom ``operations`` and subclasses that override
 import collections
 import copy
 import functools
-import importlib.metadata
 import json
 from collections.abc import MutableMapping, MutableSequence, Sequence
 from types import MappingProxyType
@@ -64,7 +63,7 @@ _ST_ADD = 0
 _ST_REMOVE = 1
 
 
-__version__ = importlib.metadata.version('fastjsonpatch')
+__version__ = _core.__version__
 __license__ = 'BSD-3-Clause'
 # Version of jsonpatch whose behaviour this module reproduces.
 __jsonpatch_version__ = '1.34'

{fastjsonpatch-0.1.2 → fastjsonpatch-0.1.4}/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);
@@ -962,5 +965,7 @@ fn _core(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(apply, m)?)?;
     m.add_function(wrap_pyfunction!(validate, m)?)?;
     m.add_function(wrap_pyfunction!(py_deepcopy, m)?)?;
+    // The package version, so `fastjsonpatch.__version__` needs no importlib.metadata.
+    m.add("__version__", env!("CARGO_PKG_VERSION"))?;
     Ok(())
 }

{fastjsonpatch-0.1.2 → fastjsonpatch-0.1.4}/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"}])
@@ -188,6 +207,41 @@ def test_standalone_does_not_import_jsonpatch():
     assert out.stdout.strip() == "False"
 
 
+def test_version_matches_the_installed_package():
+    # __version__ comes from Cargo.toml; the wheel's version from pyproject.toml.
+    import importlib.metadata
+    assert fastjsonpatch.__version__ == importlib.metadata.version("fastjsonpatch")
+
+
+_SPY_IMPORTLIB_METADATA = """
+import sys, traceback
+preloaded = "importlib.metadata" in sys.modules
+for name in [m for m in sys.modules if m == "importlib.metadata" or m.startswith("importlib.metadata.")]:
+    del sys.modules[name]
+importers = []
+
+class Spy:
+    def find_spec(self, name, path=None, target=None):
+        if name == "importlib.metadata":
+            importers.append("".join(traceback.format_stack(limit=15)))
+
+sys.meta_path.insert(0, Spy())
+import fastjsonpatch
+print("preloaded:", preloaded)
+print(importers[0] if importers else "")
+"""
+
+
+def test_import_does_not_load_importlib_metadata():
+    # importlib.metadata alone used to add ~30 ms to `import fastjsonpatch`. Drop it
+    # from sys.modules first, in case the interpreter loaded it at startup, and
+    # record who imports it again.
+    out = subprocess.run([sys.executable, "-I", "-c", _SPY_IMPORTLIB_METADATA],
+                         capture_output=True, text=True, check=True)
+    preloaded, _, importer = out.stdout.partition("\n")
+    assert not importer.strip(), f"{preloaded}; importlib.metadata imported by:\n{importer}"
+
+
 def test_aliasing_preserved_like_deepcopy():
     shared = [1, 2]
     doc = {"a": shared, "b": shared}

fastjsonpatch-0.1.2/CHANGELOG.md

@@ -1,17 +0,0 @@
-# Changelog
-
-## 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` 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.2/PKG-INFO

@@ -1,206 +0,0 @@
-Metadata-Version: 2.4
-Name: fastjsonpatch
-Version: 0.1.2
-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 and the same
-documents, and raise exceptions with the same types and messages,** as jsonpatch 1.34.
-In the benchmarks below, making a patch is 9-57x faster and applying one 6-27x faster.
-
-```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 a media type for HTTP `PATCH`
-requests (`application/json-patch+json`), Kubernetes accepts it
-(`kubectl patch --type=json`), and it can store or send the difference between two
-versions of a document.
-
-jsonpatch is written in pure Python. In the measurements below:
-
-- `make_patch` on a 10,000-record document takes 290 ms, and diffing two Kubernetes
-  OpenAPI specs (3.7 MB and 3.8 MB) takes 136 ms.
-- `apply` deep-copies the whole document first, so a 3-operation patch on the
-  3.8 MB Kubernetes spec takes 71 ms, against 21 µs when applied in place.
-- Applying or computing a patch on a small REST resource takes 47-74 µs per call.
-
-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 (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.
-
-## Why it is faster
-
-**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.
-
-## 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
-names are the same: `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.
-- `apply` and validation use the original code for a custom `pointer_cls`, a
-  subclass with custom `operations` or an overridden `_get_operation`, and patches
-  that are not lists or tuples. `make_patch` uses it for a custom `dumps=` or
-  `json_dumper`.
-
-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.
-- `__version__` is fastjsonpatch's version, and jsonpatch's `__author__` and
-  `__website__` are not defined.
-
-`fastjsonpatch.__jsonpatch_version__` says which jsonpatch release the behaviour
-matches (currently `1.34`).
-
-## How it is tested
-
-About 1,570 tests. CI runs them with Python 3.12, 3.13 and 3.14 on Linux (x86_64 and
-aarch64, glibc), macOS (arm64 and x86_64) and Windows (x64); the musl wheels are built
-but not tested in CI:
-
-- **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](https://github.com/amzntiger/fastjsonpatch/blob/main/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.2/README.md

@@ -1,178 +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 and the same
-documents, and raise exceptions with the same types and messages,** as jsonpatch 1.34.
-In the benchmarks below, making a patch is 9-57x faster and applying one 6-27x faster.
-
-```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 a media type for HTTP `PATCH`
-requests (`application/json-patch+json`), Kubernetes accepts it
-(`kubectl patch --type=json`), and it can store or send the difference between two
-versions of a document.
-
-jsonpatch is written in pure Python. In the measurements below:
-
-- `make_patch` on a 10,000-record document takes 290 ms, and diffing two Kubernetes
-  OpenAPI specs (3.7 MB and 3.8 MB) takes 136 ms.
-- `apply` deep-copies the whole document first, so a 3-operation patch on the
-  3.8 MB Kubernetes spec takes 71 ms, against 21 µs when applied in place.
-- Applying or computing a patch on a small REST resource takes 47-74 µs per call.
-
-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 (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.
-
-## Why it is faster
-
-**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.
-
-## 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
-names are the same: `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.
-- `apply` and validation use the original code for a custom `pointer_cls`, a
-  subclass with custom `operations` or an overridden `_get_operation`, and patches
-  that are not lists or tuples. `make_patch` uses it for a custom `dumps=` or
-  `json_dumper`.
-
-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.
-- `__version__` is fastjsonpatch's version, and jsonpatch's `__author__` and
-  `__website__` are not defined.
-
-`fastjsonpatch.__jsonpatch_version__` says which jsonpatch release the behaviour
-matches (currently `1.34`).
-
-## How it is tested
-
-About 1,570 tests. CI runs them with Python 3.12, 3.13 and 3.14 on Linux (x86_64 and
-aarch64, glibc), macOS (arm64 and x86_64) and Windows (x64); the musl wheels are built
-but not tested in CI:
-
-- **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](https://github.com/amzntiger/fastjsonpatch/blob/main/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`.