patchdiff 0.3.3__tar.gz → 0.3.5__tar.gz

patchdiff-0.3.5/.github/workflows/ci.yml

@@ -0,0 +1,103 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  test:
+    name: Lint and test on ${{ matrix.name }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Linux py38
+            pyversion: '3.8'
+          - name: Linux py39
+            pyversion: '3.9'
+          - name: Linux py310
+            pyversion: '3.10'
+          - name: Linux py311
+            pyversion: '3.11'
+          - name: Linux py312
+            pyversion: '3.12'
+          - name: Linux py313
+            pyversion: '3.13'
+          - name: Linux py314
+            pyversion: '3.14'
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+      - name: Set up Python ${{ matrix.pyversion }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.pyversion }}
+      - name: Install dependencies
+        run: uv sync
+      - name: Lint
+        run: uv run ruff check
+      - name: Format
+        run: uv run ruff format --check
+      - name: Test
+        run: uv run pytest -v --cov=patchdiff --cov-report=term-missing
+
+  build:
+    name: Build and test wheel
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v5
+    - name: Install uv
+      uses: astral-sh/setup-uv@v6
+    - name: Set up Python 3.9
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.9'
+    - name: Install dependencies
+      run: uv sync
+    - name: Build wheel
+      run: uv build
+    - name: Twine check
+      run: uvx twine check dist/*
+    - name: Upload wheel artifact
+      uses: actions/upload-artifact@v4
+      with:
+        path: dist
+        name: dist
+
+  publish:
+    name: Publish to Github and Pypi
+    runs-on: ubuntu-latest
+    needs: [test, build]
+    if: success() && startsWith(github.ref, 'refs/tags/v')
+    environment:
+      name: pypi
+      url: https://pypi.org/p/patchdiff
+    permissions:
+      id-token: write
+      contents: write
+    steps:
+    - uses: actions/checkout@v5
+    - name: Download wheel artifact
+      uses: actions/download-artifact@v4
+      with:
+        name: dist
+        path: dist
+    - name: Release
+      uses: softprops/action-gh-release@v2
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        files: |
+          dist/*.tar.gz
+          dist/*.whl
+        draft: true
+        prerelease: false
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

patchdiff-0.3.5/.gitignore

@@ -0,0 +1,6 @@
+*.egg-info/
+__pycache__
+.vscode
+.coverage
+dist
+uv.lock

{patchdiff-0.3.3 → patchdiff-0.3.5}/PKG-INFO

@@ -1,20 +1,14 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: patchdiff
-Version: 0.3.3
+Version: 0.3.5
 Summary: MIT
-Home-page: https://github.com/Korijn/patchdiff
-Author: Korijn van Golen
-Author-email: korijn@gmail.com
-Requires-Python: >=3.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
+Project-URL: Homepage, https://github.com/fork-tongue/patchdiff
+Author-email: Korijn van Golen <korijn@gmail.com>, Berend Klein Haneveld <berendkleinhaneveld@gmail.com>
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 
 [![PyPI version](https://badge.fury.io/py/patchdiff.svg)](https://badge.fury.io/py/patchdiff)
-[![CI status](https://github.com/Korijn/patchdiff/workflows/CI/badge.svg)](https://github.com/Korijn/patchdiff/actions)
+[![CI status](https://github.com/fork-tongue/patchdiff/workflows/CI/badge.svg)](https://github.com/fork-tongue/patchdiff/actions)
 
 # Patchdiff 🔍
 
@@ -58,4 +52,3 @@ print(to_json(ops, indent=4))
 #     }
 # ]
 ```
-

{patchdiff-0.3.3 → patchdiff-0.3.5}/README.md

@@ -1,5 +1,5 @@
 [![PyPI version](https://badge.fury.io/py/patchdiff.svg)](https://badge.fury.io/py/patchdiff)
-[![CI status](https://github.com/Korijn/patchdiff/workflows/CI/badge.svg)](https://github.com/Korijn/patchdiff/actions)
+[![CI status](https://github.com/fork-tongue/patchdiff/workflows/CI/badge.svg)](https://github.com/fork-tongue/patchdiff/actions)
 
 # Patchdiff 🔍
 

{patchdiff-0.3.3 → patchdiff-0.3.5}/patchdiff/__init__.py

@@ -2,4 +2,4 @@ from .apply import apply, iapply
 from .diff import diff
 from .serialize import to_json
 
-__version__ = "0.3.3"
+__version__ = "0.3.4"

{patchdiff-0.3.3 → patchdiff-0.3.5}/patchdiff/diff.py

@@ -71,13 +71,13 @@ def diff_lists(input: List, output: List, ptr: Pointer) -> Tuple[List, List]:
                 "path": ptr.append(idx_token),
                 "value": op["value"],
             }
-            return [ops + [full_op], padding + 1]
+            return [[*ops, full_op], padding + 1]
         elif op["op"] == "remove":
             full_op = {
                 "op": "remove",
                 "path": ptr.append(op["idx"] + padding),
             }
-            return [ops + [full_op], padding - 1]
+            return [[*ops, full_op], padding - 1]
         else:
             replace_ptr = ptr.append(op["idx"] + padding)
             replace_ops, _ = diff(op["original"], op["value"], replace_ptr)
@@ -96,7 +96,7 @@ def diff_dicts(input: Dict, output: Dict, ptr: Pointer) -> Tuple[List, List]:
     output_keys = set(output.keys())
     for key in input_keys - output_keys:
         ops.append({"op": "remove", "path": ptr.append(key)})
-        rops.insert(0, {"op": "add", "path": ptr.append(key), "value": output[key]})
+        rops.insert(0, {"op": "add", "path": ptr.append(key), "value": input[key]})
     for key in output_keys - input_keys:
         ops.append(
             {

{patchdiff-0.3.3 → patchdiff-0.3.5}/patchdiff/pointer.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 import re
 from typing import Any, Hashable, List, Tuple
 
 from .types import Diffable
 
-
 tilde0_re = re.compile("~0")
 tilde1_re = re.compile("~1")
 tilde_re = re.compile("~")
@@ -19,21 +20,21 @@ def escape(token: str) -> str:
 
 
 class Pointer:
-    def __init__(self, tokens: List[Hashable] = None) -> None:
+    def __init__(self, tokens: List[Hashable] | None = None) -> None:
         if tokens is None:
             tokens = []
-        self.tokens = tokens
+        self.tokens = tuple(tokens)
 
     @staticmethod
     def from_str(path: str) -> "Pointer":
-        tokens = [unescape(t) for t in path.split("/")]
+        tokens = [unescape(t) for t in path.split("/")[1:]]
         return Pointer(tokens)
 
     def __str__(self) -> str:
         return "/" + "/".join(escape(str(t)) for t in self.tokens)
 
     def __repr__(self) -> str:
-        return f"Pointer({repr(self.tokens)})"
+        return f"Pointer({list(self.tokens)!r})"
 
     def __hash__(self) -> int:
         return hash(self.tokens)
@@ -62,4 +63,4 @@ class Pointer:
 
     def append(self, token: Hashable) -> "Pointer":
         """append, creating new Pointer"""
-        return Pointer(self.tokens + [token])
+        return Pointer((*self.tokens, token))

patchdiff-0.3.5/patchdiff/types.py

@@ -0,0 +1,3 @@
+from typing import Dict, List, Set, Union
+
+Diffable = Union[Dict, List, Set]

patchdiff-0.3.5/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "patchdiff"
+version = "0.3.5"
+description = "MIT"
+authors = [
+    { name = "Korijn van Golen", email = "korijn@gmail.com" },
+    { name = "Berend Klein Haneveld", email = "berendkleinhaneveld@gmail.com" },
+]
+requires-python = ">=3.8"
+readme = "README.md"
+
+[project.urls]
+Homepage = "https://github.com/fork-tongue/patchdiff"
+
+[dependency-groups]
+dev = [
+    "ruff",
+    "pytest",
+    "pytest-cov",
+    "pytest-watch",
+]
+
+[tool.ruff.lint]
+extend-select = [
+    "F",    # Pyflakes (default)
+    "I",    # isort imports
+    "N",    # pep8-naming
+    "T10",  # flake8-debugger
+    "T20",  # flake8-print
+    "RUF",  # ruff
+]
+
+[tool.ruff.lint.per-file-ignores]
+"patchdiff/__init__.py" = ["F401"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

patchdiff-0.3.5/tests/test_apply.py

@@ -0,0 +1,111 @@
+from patchdiff import apply, diff
+
+
+def test_apply():
+    a = {
+        "a": [5, 7, 9, {"a", "b", "c"}],
+        "b": 6,
+    }
+    b = {
+        "a": [5, 2, 9, {"b", "c"}],
+        "b": 6,
+        "c": 7,
+    }
+
+    ops, rops = diff(a, b)
+
+    c = apply(a, ops)
+    assert c == b
+
+    d = apply(b, rops)
+    assert a == d
+
+
+def test_apply_list():
+    a = [1, 5, 9, "sdfsdf", "fff"]
+    b = ["sdf", 5, 9, "c"]
+
+    ops, rops = diff(a, b)
+
+    c = apply(a, ops)
+    assert c == b
+
+    d = apply(b, rops)
+    assert a == d
+
+
+def test_add_remove_list():
+    a = []
+    b = [1]
+
+    ops, rops = diff(a, b)
+
+    c = apply(a, ops)
+    assert c == b
+
+    d = apply(b, rops)
+    assert a == d
+
+
+def test_add_remove_list_extended():
+    a = []
+    b = [1, 2, 3]
+
+    ops, rops = diff(a, b)
+
+    c = apply(a, ops)
+    assert c == b
+
+    d = apply(b, rops)
+    assert a == d
+
+
+def test_insertion_in_list_front():
+    a = [1, 2]
+    b = [3, 1, 2]
+    ops, rops = diff(a, b)
+
+    c = apply(a, ops)
+    assert c == b
+
+    d = apply(b, rops)
+    assert a == d
+
+
+def test_add_remove_list_extended_inverse():
+    a = [1, 2, 3]
+    b = []
+
+    ops, rops = diff(a, b)
+
+    c = apply(a, ops)
+    assert c == b
+
+    d = apply(b, rops)
+    assert a == d
+
+
+def test_add_remove_list_extended_inverse_leaving_start():
+    a = [1, 2, 3, 4]
+    b = [1]
+
+    ops, rops = diff(a, b)
+
+    c = apply(a, ops)
+    assert c == b
+
+    d = apply(b, rops)
+    assert a == d
+
+
+def test_add_remove_list_extended_inverse_leaving_end():
+    a = [1, 2, 3, 4]
+    b = [4]
+
+    ops, rops = diff(a, b)
+
+    c = apply(a, ops)
+    assert c == b
+
+    d = apply(b, rops)
+    assert a == d

patchdiff-0.3.5/tests/test_diff.py

@@ -0,0 +1,170 @@
+from patchdiff import diff
+from patchdiff.pointer import Pointer
+
+
+def test_basic_list_insertion():
+    a = []
+    b = [1]
+    ops, rops = diff(a, b)
+
+    assert ops == [{"op": "add", "path": Pointer(["-"]), "value": 1}]
+    assert rops == [{"op": "remove", "path": Pointer([0])}]
+
+
+def test_basic_list_deletion():
+    a = [1]
+    b = []
+    ops, rops = diff(a, b)
+
+    assert ops == [{"op": "remove", "path": Pointer([0])}]
+    assert rops == [{"op": "add", "path": Pointer(["-"]), "value": 1}]
+
+
+def test_basic_list_insertion_half_way():
+    a = [1, 3]
+    b = [1, 2, 3]
+    ops, rops = diff(a, b)
+
+    assert ops == [{"op": "add", "path": Pointer([1]), "value": 2}]
+    assert rops == [{"op": "remove", "path": Pointer([1])}]
+
+
+def test_basic_list_deletion_half_way():
+    a = [1, 2, 3]
+    b = [1, 3]
+    ops, rops = diff(a, b)
+
+    assert ops == [{"op": "remove", "path": Pointer([1])}]
+    assert rops == [{"op": "add", "path": Pointer([1]), "value": 2}]
+
+
+def test_basic_list_multiple_insertion():
+    a = []
+    b = [1, 2, 3]
+    ops, rops = diff(a, b)
+
+    assert ops == [
+        {"op": "add", "path": Pointer(["-"]), "value": 1},
+        {"op": "add", "path": Pointer(["-"]), "value": 2},
+        {"op": "add", "path": Pointer(["-"]), "value": 3},
+    ]
+    assert rops == [
+        {"op": "remove", "path": Pointer([0])},
+        {"op": "remove", "path": Pointer([0])},
+        {"op": "remove", "path": Pointer([0])},
+    ]
+
+
+def test_basic_list_multiple_deletion():
+    a = [1, 2, 3]
+    b = []
+    ops, rops = diff(a, b)
+
+    assert ops == [
+        {"op": "remove", "path": Pointer([0])},
+        {"op": "remove", "path": Pointer([0])},
+        {"op": "remove", "path": Pointer([0])},
+    ]
+    assert rops == [
+        {"op": "add", "path": Pointer(["-"]), "value": 1},
+        {"op": "add", "path": Pointer(["-"]), "value": 2},
+        {"op": "add", "path": Pointer(["-"]), "value": 3},
+    ]
+
+
+def test_list():
+    a = [1, 5, 9, "sdfsdf", "fff"]
+    b = ["sdf", 5, 9, "c"]
+    ops, rops = diff(a, b)
+
+    assert ops == [
+        {"op": "replace", "path": Pointer([0]), "value": "sdf"},
+        {"op": "replace", "path": Pointer([3]), "value": "c"},
+        {"op": "remove", "path": Pointer([4])},
+    ]
+    assert rops == [
+        {"op": "replace", "path": Pointer([0]), "value": 1},
+        {"op": "replace", "path": Pointer([3]), "value": "sdfsdf"},
+        {"op": "add", "path": Pointer(["-"]), "value": "fff"},
+    ]
+
+
+def test_list_begin():
+    a = [1, 2]
+    b = [3, 1, 2]
+    ops, rops = diff(a, b)
+
+    assert ops == [{"op": "add", "path": Pointer([0]), "value": 3}]
+    assert rops == [{"op": "remove", "path": Pointer([0])}]
+
+
+def test_list_end():
+    a = [1, 2, 3]
+    b = [1, 2, 3, 4]
+    ops, rops = diff(a, b)
+
+    assert ops == [{"op": "add", "path": Pointer(["-"]), "value": 4}]
+    assert rops == [{"op": "remove", "path": Pointer([3])}]
+
+
+def test_dicts():
+    a = {"a": 5, "b": 6}
+    b = {"a": 3, "b": 6, "c": 7}
+    ops, rops = diff(a, b)
+
+    assert ops == [
+        {"op": "add", "path": Pointer(["c"]), "value": 7},
+        {"op": "replace", "path": Pointer(["a"]), "value": 3},
+    ]
+    assert rops == [
+        {"op": "replace", "path": Pointer(["a"]), "value": 5},
+        {"op": "remove", "path": Pointer(["c"])},
+    ]
+
+
+def test_dicts_remove_item():
+    a = {"a": 3, "b": 6}
+    b = {"a": 3}
+    ops, rops = diff(a, b)
+
+    assert ops == [{"op": "remove", "path": Pointer(["b"])}]
+    assert rops == [{"op": "add", "path": Pointer(["b"]), "value": 6}]
+
+
+def test_sets():
+    a = {"a", "b"}
+    b = {"a", "c"}
+    ops, rops = diff(a, b)
+
+    assert ops == [
+        {"op": "remove", "path": Pointer(["b"])},
+        {"op": "add", "path": Pointer(["-"]), "value": "c"},
+    ]
+    assert rops == [
+        {"op": "remove", "path": Pointer(["c"])},
+        {"op": "add", "path": Pointer(["-"]), "value": "b"},
+    ]
+
+
+def test_mixed():
+    a = {
+        "a": [5, 7, 9, {"a", "b", "c"}],
+        "b": 6,
+    }
+    b = {
+        "a": [5, 2, 9, {"b", "c"}],
+        "b": 6,
+        "c": 7,
+    }
+    ops, rops = diff(a, b)
+
+    assert ops == [
+        {"op": "add", "path": Pointer(["c"]), "value": 7},
+        {"op": "replace", "path": Pointer(["a", 1]), "value": 2},
+        {"op": "remove", "path": Pointer(["a", 3, "a"])},
+    ]
+    assert rops == [
+        {"op": "replace", "path": Pointer(["a", 1]), "value": 7},
+        {"op": "add", "path": Pointer(["a", 3, "-"]), "value": "a"},
+        {"op": "remove", "path": Pointer(["c"])},
+    ]

patchdiff-0.3.5/tests/test_pointer.py

@@ -0,0 +1,46 @@
+from patchdiff.pointer import Pointer
+
+
+def test_pointer_get():
+    obj = [1, 5, {"foo": 1, "bar": [1, 2, 3]}, "sdfsdf", "fff"]
+    assert Pointer([1]).evaluate(obj)[2] == 5
+    assert Pointer([2, "bar", 1]).evaluate(obj)[2] == 2
+
+
+def test_pointer_str():
+    assert str(Pointer([1])) == "/1"
+    assert str(Pointer(["foo", "bar", "-"])) == "/foo/bar/-"
+
+
+def test_pointer_repr():
+    assert repr(Pointer([1])) == "Pointer([1])"
+    assert repr(Pointer(["foo", "bar", "-"])) == "Pointer(['foo', 'bar', '-'])"
+
+
+def test_pointer_from_str():
+    assert Pointer.from_str("/1") == Pointer(["1"])
+    assert Pointer.from_str("/foo/bar/-") == Pointer(["foo", "bar", "-"])
+
+
+def test_pointer_hash():
+    assert hash(Pointer([1])) == hash((1,))
+    assert hash(Pointer(["foo", "bar", "-"])) == hash(("foo", "bar", "-"))
+
+
+def test_pointer_set():
+    # hash supports comparison operators for use as keys and set elements
+    # so we exercise that as well
+    unique_pointers = [Pointer([1]), Pointer(["2", "3"])]
+    duplicated_pointers = unique_pointers + unique_pointers
+    assert len(set(duplicated_pointers)) == len(unique_pointers)
+
+
+def test_pointer_eq():
+    assert Pointer([1]) != [1]
+    assert Pointer([1]) != Pointer(["1"])
+    assert Pointer([1]) != Pointer([0])
+    assert Pointer([1]) == Pointer([1])
+
+
+def test_pointer_append():
+    assert Pointer([1]).append("foo") == Pointer([1, "foo"])

patchdiff-0.3.5/tests/test_proxy.py

@@ -0,0 +1,86 @@
+"""
+Tests that check that patchdiff apply and diff work
+on proxied objects.
+"""
+
+from collections import UserDict, UserList
+from collections.abc import Set
+
+from patchdiff import apply, diff
+
+
+class SetProxy(Set):
+    """
+    Custom proxy class that works like UserDict and UserList by
+    storing the original data under the 'data' attribute.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.data = set(*args, **kwargs)
+
+    def __contains__(self, *args, **kwargs):
+        return self.data.__contains__(*args, **kwargs)
+
+    def __iter__(self, *args, **kwargs):
+        return self.data.__iter__(*args, **kwargs)
+
+    def __len__(self, *args, **kwargs):
+        return self.data.__len__(*args, **kwargs)
+
+    def __getattribute__(self, attr):
+        # Redirect __class__ to super() to make sure
+        # isinstance(obj, set) will fail
+        if attr in {"data", "_from_iterable", "__class__"}:
+            return super().__getattribute__(attr)
+        return self.data.__getattribute__(attr)
+
+
+def test_proxy_dict():
+    data = {"foo": "bar"}
+    obj = UserDict(data)
+    assert not isinstance(obj, dict)
+
+    old = obj.copy()
+    obj["foo"] = "baz"
+
+    assert old["foo"] == "bar"
+    assert obj["foo"] == "baz"
+
+    ops, reverse_ops = diff(old, obj)
+
+    assert apply(old, ops) == obj
+    assert apply(obj, reverse_ops) == old
+
+
+def test_proxy_list():
+    data = [1, 2]
+    obj = UserList(data)
+    assert not isinstance(obj, list)
+
+    old = obj.copy()
+    obj[1] = 3
+
+    assert old[1] == 2
+    assert obj[1] == 3
+
+    ops, reverse_ops = diff(old, obj)
+
+    assert apply(old, ops) == obj
+    assert apply(obj, reverse_ops) == old
+
+
+def test_proxy_set():
+    data = {"a", "b"}
+    obj = SetProxy(data)
+    assert not isinstance(obj, set)
+
+    old = obj.copy()
+    obj.add("c")
+
+    assert "c" not in old
+    assert "c" in obj
+
+    ops, reverse_ops = diff(old, obj)
+
+    assert apply(old, ops) == obj
+    assert apply(obj, reverse_ops) == old

patchdiff-0.3.5/tests/test_serialize.py

@@ -0,0 +1,31 @@
+from patchdiff import diff, to_json
+
+
+def test_to_json():
+    a = {
+        "a": [5, 7, 9, {"a", "b", "c"}],
+        "b": 6,
+    }
+    b = {"a": [5, 2, 9, {"b", "c"}], "b": 6, "c": 7}
+
+    ops, _ = diff(a, b)
+
+    assert (
+        to_json(ops, indent=4)
+        == """[
+    {
+        "op": "add",
+        "path": "/c",
+        "value": 7
+    },
+    {
+        "op": "replace",
+        "path": "/a/1",
+        "value": 2
+    },
+    {
+        "op": "remove",
+        "path": "/a/3/a"
+    }
+]"""
+    )

patchdiff-0.3.3/patchdiff/types.py

@@ -1,3 +0,0 @@
-from typing import Dict, List, Set, Tuple, Union
-
-Diffable = Union[Dict, List, Set, Tuple]

patchdiff-0.3.3/pyproject.toml

@@ -1,23 +0,0 @@
-[tool.poetry]
-name = "patchdiff"
-version = "0.3.3"
-description = "MIT"
-authors = ["Korijn van Golen <korijn@gmail.com>"]
-homepage = "https://github.com/Korijn/patchdiff"
-readme = "README.md"
-
-[tool.poetry.dependencies]
-python = ">=3.7"
-
-[tool.poetry.dev-dependencies]
-flake8 = "*"
-black = "*"
-flake8-black = "*"
-flake8-import-order = "*"
-flake8-print = "*"
-pytest = "*"
-twine = "*"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

patchdiff-0.3.3/setup.py

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['patchdiff']
-
-package_data = \
-{'': ['*']}
-
-setup_kwargs = {
-    'name': 'patchdiff',
-    'version': '0.3.3',
-    'description': 'MIT',
-    'long_description': '[![PyPI version](https://badge.fury.io/py/patchdiff.svg)](https://badge.fury.io/py/patchdiff)\n[![CI status](https://github.com/Korijn/patchdiff/workflows/CI/badge.svg)](https://github.com/Korijn/patchdiff/actions)\n\n# Patchdiff 🔍\n\nBased on [rfc6902](https://github.com/chbrown/rfc6902) this library provides a simple API to generate bi-directional diffs between composite python datastructures composed out of lists, sets, tuples and dicts. The diffs are jsonpatch compliant, and can optionally be serialized to json format. Patchdiff can also be used to apply lists of patches to objects, both in-place or on a deepcopy of the input.\n\n## Install\n\n`pip install patchdiff`\n\n## Quick-start\n\n```python\nfrom patchdiff import apply, diff, iapply, to_json\n\ninput = {"a": [5, 7, 9, {"a", "b", "c"}], "b": 6}\noutput = {"a": [5, 2, 9, {"b", "c"}], "b": 6, "c": 7}\n\nops, reverse_ops = diff(input, output)\n\nassert apply(input, ops) == output\nassert apply(output, reverse_ops) == input\n\niapply(input, ops)  # apply in-place\nassert input == output\n\nprint(to_json(ops, indent=4))\n# [\n#     {\n#         "op": "add",\n#         "path": "/c",\n#         "value": 7\n#     },\n#     {\n#         "op": "replace",\n#         "path": "/a/1",\n#         "value": 2\n#     },\n#     {\n#         "op": "remove",\n#         "path": "/a/3/a"\n#     }\n# ]\n```\n',
-    'author': 'Korijn van Golen',
-    'author_email': 'korijn@gmail.com',
-    'maintainer': None,
-    'maintainer_email': None,
-    'url': 'https://github.com/Korijn/patchdiff',
-    'packages': packages,
-    'package_data': package_data,
-    'python_requires': '>=3.7',
-}
-
-
-setup(**setup_kwargs)