patchdiff 0.3.4__tar.gz → 0.3.6__tar.gz

patchdiff-0.3.6/.github/workflows/benchmark.yml

@@ -0,0 +1,69 @@
+name: Benchmarks
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  benchmark:
+    name: Benchmarks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+
+      - name: Set up Python 3.14
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.14'
+
+      - name: Install dependencies
+        run: uv sync
+
+      # Restore benchmark baseline (read-only for PRs)
+      - name: Restore benchmark baseline
+        uses: actions/cache/restore@v4
+        with:
+          path: .benchmarks
+          key: benchmark-baseline-3.14-${{ runner.os }}
+
+      # On master: save baseline results
+      - name: Run benchmarks and save baseline
+        if: github.ref == 'refs/heads/master'
+        continue-on-error: true
+        run: |
+          uv run --no-sync pytest benchmarks/benchmark.py \
+            --benchmark-only \
+            --benchmark-autosave \
+            --benchmark-sort=name
+
+      # On master: cache the new baseline results
+      - name: Save benchmark baseline
+        if: github.ref == 'refs/heads/master'
+        uses: actions/cache/save@v4
+        with:
+          path: .benchmarks
+          key: benchmark-baseline-3.14-${{ runner.os }}
+
+      # On PRs: compare against baseline and fail if degraded
+      - name: Run benchmarks and compare
+        if: github.event_name == 'pull_request'
+        run: |
+          if [ -z "$(uv run --no-sync pytest-benchmark list)" ]; then
+            echo "No baseline found, not comparing"
+            uv run --no-sync pytest -v benchmarks/benchmark.py
+            exit
+          fi
+
+          uv run --no-sync pytest benchmarks/benchmark.py \
+              --benchmark-only \
+              --benchmark-compare \
+              --benchmark-compare-fail=mean:5% \
+              --benchmark-sort=name
+

patchdiff-0.3.6/.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.6/.gitignore

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

{patchdiff-0.3.4 → patchdiff-0.3.6}/PKG-INFO

@@ -1,16 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: patchdiff
-Version: 0.3.4
+Version: 0.3.6
 Summary: MIT
-Home-page: https://github.com/fork-tongue/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)
@@ -58,4 +52,3 @@ print(to_json(ops, indent=4))
 #     }
 # ]
 ```
-

patchdiff-0.3.6/benchmarks/benchmark.py

@@ -0,0 +1,166 @@
+"""
+Benchmark suite for patchdiff performance testing using pytest-benchmark.
+
+Run benchmarks:
+    uv run pytest benchmarks/benchmark.py --benchmark-only
+
+Save baseline:
+    uv run pytest benchmarks/benchmark.py --benchmark-only --benchmark-autosave
+
+Compare against baseline:
+    uv run pytest benchmarks/benchmark.py --benchmark-only --benchmark-compare=0001
+
+Fail if performance degrades >5%:
+    uv run pytest benchmarks/benchmark.py --benchmark-only --benchmark-compare=0001 --benchmark-compare-fail=mean:5%
+"""
+
+import random
+
+import pytest
+
+from patchdiff import apply, diff
+
+# Set seed for reproducibility
+random.seed(42)
+
+
+def generate_random_list(size: int, value_range: int = 1000) -> list[int]:
+    """Generate a random list of integers."""
+    return [random.randint(0, value_range) for _ in range(size)]
+
+
+def generate_similar_lists(
+    size: int, change_ratio: float = 0.1
+) -> tuple[list[int], list[int]]:
+    """
+    Generate two similar lists with specified change ratio.
+
+    Args:
+        size: Size of the lists
+        change_ratio: Ratio of elements that differ (0.0 to 1.0)
+    """
+    list_a = generate_random_list(size)
+    list_b = list_a.copy()
+
+    num_changes = int(size * change_ratio)
+
+    # Make some replacements
+    for _ in range(num_changes // 3):
+        idx = random.randint(0, size - 1)
+        list_b[idx] = random.randint(0, 1000)
+
+    # Make some insertions
+    for _ in range(num_changes // 3):
+        idx = random.randint(0, len(list_b))
+        list_b.insert(idx, random.randint(0, 1000))
+
+    # Make some deletions
+    for _ in range(num_changes // 3):
+        if list_b:
+            idx = random.randint(0, len(list_b) - 1)
+            del list_b[idx]
+
+    return list_a, list_b
+
+
+def generate_nested_dict(depth: int, breadth: int) -> dict | int:
+    """Generate a nested dictionary structure."""
+    if depth == 0:
+        return random.randint(0, 1000)
+
+    result = {}
+    for i in range(breadth):
+        key = f"key_{i}"
+        if random.random() > 0.3:
+            result[key] = generate_nested_dict(depth - 1, breadth)
+        else:
+            result[key] = random.randint(0, 1000)
+    return result
+
+
+# ========================================
+# List Diff Benchmarks
+# ========================================
+
+
+@pytest.mark.benchmark(group="list-diff")
+def test_list_diff_small_10pct(benchmark):
+    """Benchmark: 50 element list with 10% changes."""
+    a, b = generate_similar_lists(50, 0.1)
+    benchmark(diff, a, b)
+
+
+@pytest.mark.benchmark(group="list-diff")
+@pytest.mark.parametrize("change_ratio", [0.05, 0.1, 0.5])
+def test_list_diff_medium(benchmark, change_ratio):
+    """Benchmark: 1000 element list with varying change ratios."""
+    a, b = generate_similar_lists(1000, change_ratio)
+    benchmark(diff, a, b)
+
+
+@pytest.mark.benchmark(group="list-diff-edge")
+def test_list_diff_completely_different(benchmark):
+    """Benchmark: Two completely different 1000 element lists."""
+    a = generate_random_list(1000)
+    b = generate_random_list(1000)
+    benchmark(diff, a, b)
+
+
+@pytest.mark.benchmark(group="list-diff-edge")
+def test_list_diff_identical(benchmark):
+    """Benchmark: Two identical 10000 element lists."""
+    a = generate_random_list(10000)
+    b = a.copy()
+    benchmark(diff, a, b)
+
+
+# ========================================
+# Dict Diff Benchmarks
+# ========================================
+
+
+@pytest.mark.benchmark(group="dict-diff")
+def test_dict_diff_flat_500_keys(benchmark):
+    """Benchmark: Flat dict with 500 keys, 10% changed."""
+    a = {f"key_{i}": i for i in range(500)}
+    b = a.copy()
+    # Change 10%
+    for i in range(50):
+        b[f"key_{i}"] = i + 500
+
+    benchmark(diff, a, b)
+
+
+@pytest.mark.benchmark(group="dict-diff")
+def test_dict_diff_nested(benchmark):
+    """Benchmark: Nested dict with depth=3, breadth=5."""
+    a = generate_nested_dict(3, 5)
+    b = generate_nested_dict(3, 5)
+    benchmark(diff, a, b)
+
+
+# ========================================
+# Mixed Structure Benchmarks
+# ========================================
+
+
+@pytest.mark.benchmark(group="mixed")
+def test_mixed_dict_with_list_values(benchmark):
+    """Benchmark: Dict with 50 keys, each containing a 100-element list."""
+    a = {f"key_{i}": generate_random_list(100) for i in range(50)}
+    b = {f"key_{i}": generate_random_list(100) for i in range(50)}
+    benchmark(diff, a, b)
+
+
+# ========================================
+# Apply Benchmarks
+# ========================================
+
+
+@pytest.mark.benchmark(group="apply")
+def test_apply_list_1000_elements(benchmark):
+    """Benchmark: Apply patch to 1000 element list with 10% changes."""
+    a, b = generate_similar_lists(1000, 0.1)
+    ops, _ = diff(a, b)
+
+    benchmark(apply, a, ops)

patchdiff-0.3.6/patchdiff/diff.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+from typing import Dict, List, Set, Tuple
+
+from .pointer import Pointer
+from .types import Diffable
+
+
+def diff_lists(input: List, output: List, ptr: Pointer) -> Tuple[List, List]:
+    m, n = len(input), len(output)
+
+    # Build DP table bottom-up (iterative approach)
+    # dp[i][j] = cost of transforming input[0:i] to output[0:j]
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+
+    # Initialize base cases
+    for i in range(1, m + 1):
+        dp[i][0] = i  # Cost of deleting all elements
+    for j in range(1, n + 1):
+        dp[0][j] = j  # Cost of adding all elements
+
+    # Fill DP table
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if input[i - 1] == output[j - 1]:
+                # Elements match, no operation needed
+                dp[i][j] = dp[i - 1][j - 1]
+            else:
+                # Take minimum of three operations
+                dp[i][j] = min(
+                    dp[i - 1][j] + 1,  # Remove from input
+                    dp[i][j - 1] + 1,  # Add from output
+                    dp[i - 1][j - 1] + 1,  # Replace
+                )
+
+    # Traceback to extract operations
+    ops = []
+    rops = []
+    i, j = m, n
+
+    while i > 0 or j > 0:
+        if i > 0 and j > 0 and input[i - 1] == output[j - 1]:
+            # Elements match, no operation
+            i -= 1
+            j -= 1
+        elif i > 0 and (j == 0 or dp[i][j] == dp[i - 1][j] + 1):
+            # Remove from input
+            ops.append({"op": "remove", "idx": i - 1})
+            rops.append({"op": "add", "idx": j - 1, "value": input[i - 1]})
+            i -= 1
+        elif j > 0 and (i == 0 or dp[i][j] == dp[i][j - 1] + 1):
+            # Add from output
+            ops.append({"op": "add", "idx": i - 1, "value": output[j - 1]})
+            rops.append({"op": "remove", "idx": j - 1})
+            j -= 1
+        else:
+            # Replace
+            ops.append(
+                {
+                    "op": "replace",
+                    "idx": i - 1,
+                    "original": input[i - 1],
+                    "value": output[j - 1],
+                }
+            )
+            rops.append(
+                {
+                    "op": "replace",
+                    "idx": j - 1,
+                    "original": output[j - 1],
+                    "value": input[i - 1],
+                }
+            )
+            i -= 1
+            j -= 1
+
+    # Apply padding to operations (using explicit loops instead of reduce)
+    padded_ops = []
+    padding = 0
+    # Iterate in reverse to get correct order (traceback extracts operations backwards)
+    for op in reversed(ops):
+        if op["op"] == "add":
+            padded_idx = op["idx"] + 1 + padding
+            idx_token = padded_idx if padded_idx < len(input) + padding else "-"
+            padded_ops.append(
+                {
+                    "op": "add",
+                    "path": ptr.append(idx_token),
+                    "value": op["value"],
+                }
+            )
+            padding += 1
+        elif op["op"] == "remove":
+            padded_ops.append(
+                {
+                    "op": "remove",
+                    "path": ptr.append(op["idx"] + padding),
+                }
+            )
+            padding -= 1
+        else:  # replace
+            replace_ptr = ptr.append(op["idx"] + padding)
+            replace_ops, _ = diff(op["original"], op["value"], replace_ptr)
+            padded_ops.extend(replace_ops)
+
+    padded_rops = []
+    padding = 0
+    # Iterate in reverse to get correct order (traceback extracts operations backwards)
+    for op in reversed(rops):
+        if op["op"] == "add":
+            padded_idx = op["idx"] + 1 + padding
+            idx_token = padded_idx if padded_idx < len(output) + padding else "-"
+            padded_rops.append(
+                {
+                    "op": "add",
+                    "path": ptr.append(idx_token),
+                    "value": op["value"],
+                }
+            )
+            padding += 1
+        elif op["op"] == "remove":
+            padded_rops.append(
+                {
+                    "op": "remove",
+                    "path": ptr.append(op["idx"] + padding),
+                }
+            )
+            padding -= 1
+        else:  # replace
+            replace_ptr = ptr.append(op["idx"] + padding)
+            replace_ops, _ = diff(op["original"], op["value"], replace_ptr)
+            padded_rops.extend(replace_ops)
+
+    return padded_ops, padded_rops
+
+
+def diff_dicts(input: Dict, output: Dict, ptr: Pointer) -> Tuple[List, List]:
+    ops, rops = [], []
+    input_keys = set(input.keys())
+    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": input[key]})
+    for key in output_keys - input_keys:
+        ops.append(
+            {
+                "op": "add",
+                "path": ptr.append(key),
+                "value": output[key],
+            }
+        )
+        rops.insert(0, {"op": "remove", "path": ptr.append(key)})
+    for key in input_keys & output_keys:
+        key_ops, key_rops = diff(input[key], output[key], ptr.append(key))
+        ops.extend(key_ops)
+        key_rops.extend(rops)
+        rops = key_rops
+    return ops, rops
+
+
+def diff_sets(input: Set, output: Set, ptr: Pointer) -> Tuple[List, List]:
+    ops, rops = [], []
+    for value in input - output:
+        ops.append({"op": "remove", "path": ptr.append(value)})
+        rops.insert(0, {"op": "add", "path": ptr.append("-"), "value": value})
+    for value in output - input:
+        ops.append({"op": "add", "path": ptr.append("-"), "value": value})
+        rops.insert(0, {"op": "remove", "path": ptr.append(value)})
+    return ops, rops
+
+
+def diff(
+    input: Diffable, output: Diffable, ptr: Pointer | None = None
+) -> Tuple[List, List]:
+    if input == output:
+        return [], []
+    if ptr is None:
+        ptr = Pointer()
+    if hasattr(input, "append") and hasattr(output, "append"):  # list
+        return diff_lists(input, output, ptr)
+    if hasattr(input, "keys") and hasattr(output, "keys"):  # dict
+        return diff_dicts(input, output, ptr)
+    if hasattr(input, "add") and hasattr(output, "add"):  # set
+        return diff_sets(input, output, ptr)
+    return [{"op": "replace", "path": ptr, "value": output}], [
+        {"op": "replace", "path": ptr, "value": input}
+    ]

{patchdiff-0.3.4 → patchdiff-0.3.6}/patchdiff/pointer.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 import re
-from typing import Any, Hashable, List, Tuple
+from typing import Any, Hashable, Iterable, Tuple
 
 from .types import Diffable
 
-
 tilde0_re = re.compile("~0")
 tilde1_re = re.compile("~1")
 tilde_re = re.compile("~")
@@ -19,7 +20,7 @@ def escape(token: str) -> str:
 
 
 class Pointer:
-    def __init__(self, tokens: List[Hashable] = None) -> None:
+    def __init__(self, tokens: Iterable[Hashable] | None = None) -> None:
         if tokens is None:
             tokens = []
         self.tokens = tuple(tokens)
@@ -33,7 +34,7 @@ class Pointer:
         return "/" + "/".join(escape(str(t)) for t in self.tokens)
 
     def __repr__(self) -> str:
-        return f"Pointer({repr(list(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.6/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "patchdiff"
+version = "0.3.6"
+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",
+    "pytest-benchmark",
+]
+
+[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.6/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.6/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.6/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.6/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.6/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.4/patchdiff/diff.py

@@ -1,141 +0,0 @@
-from functools import partial, reduce
-from typing import Dict, List, Set, Tuple
-
-from .pointer import Pointer
-from .types import Diffable
-
-
-def diff_lists(input: List, output: List, ptr: Pointer) -> Tuple[List, List]:
-    memory = {(0, 0): {"ops": [], "rops": [], "cost": 0}}
-
-    def dist(i, j):
-        if (i, j) not in memory:
-            if i > 0 and j > 0 and input[i - 1] == output[j - 1]:
-                step = dist(i - 1, j - 1)
-            else:
-                paths = []
-                if i > 0:
-                    base = dist(i - 1, j)
-                    op = {"op": "remove", "idx": i - 1}
-                    rop = {"op": "add", "idx": j - 1, "value": input[i - 1]}
-                    paths.append(
-                        {
-                            "ops": base["ops"] + [op],
-                            "rops": base["rops"] + [rop],
-                            "cost": base["cost"] + 1,
-                        }
-                    )
-                if j > 0:
-                    base = dist(i, j - 1)
-                    op = {"op": "add", "idx": i - 1, "value": output[j - 1]}
-                    rop = {"op": "remove", "idx": j - 1}
-                    paths.append(
-                        {
-                            "ops": base["ops"] + [op],
-                            "rops": base["rops"] + [rop],
-                            "cost": base["cost"] + 1,
-                        }
-                    )
-                if i > 0 and j > 0:
-                    base = dist(i - 1, j - 1)
-                    op = {
-                        "op": "replace",
-                        "idx": i - 1,
-                        "original": input[i - 1],
-                        "value": output[j - 1],
-                    }
-                    rop = {
-                        "op": "replace",
-                        "idx": j - 1,
-                        "original": output[j - 1],
-                        "value": input[i - 1],
-                    }
-                    paths.append(
-                        {
-                            "ops": base["ops"] + [op],
-                            "rops": base["rops"] + [rop],
-                            "cost": base["cost"] + 1,
-                        }
-                    )
-                step = min(paths, key=lambda a: a["cost"])
-            memory[(i, j)] = step
-        return memory[(i, j)]
-
-    def pad(state, op, target=None):
-        ops, padding = state
-        if op["op"] == "add":
-            padded_idx = op["idx"] + 1 + padding
-            idx_token = padded_idx if padded_idx < len(target) + padding else "-"
-            full_op = {
-                "op": "add",
-                "path": ptr.append(idx_token),
-                "value": op["value"],
-            }
-            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]
-        else:
-            replace_ptr = ptr.append(op["idx"] + padding)
-            replace_ops, _ = diff(op["original"], op["value"], replace_ptr)
-            return [ops + replace_ops, padding]
-
-    solution = dist(len(input), len(output))
-    padded_ops, _ = reduce(partial(pad, target=input), solution["ops"], [[], 0])
-    padded_rops, _ = reduce(partial(pad, target=output), solution["rops"], [[], 0])
-
-    return padded_ops, padded_rops
-
-
-def diff_dicts(input: Dict, output: Dict, ptr: Pointer) -> Tuple[List, List]:
-    ops, rops = [], []
-    input_keys = set(input.keys())
-    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": input[key]})
-    for key in output_keys - input_keys:
-        ops.append(
-            {
-                "op": "add",
-                "path": ptr.append(key),
-                "value": output[key],
-            }
-        )
-        rops.insert(0, {"op": "remove", "path": ptr.append(key)})
-    for key in input_keys & output_keys:
-        key_ops, key_rops = diff(input[key], output[key], ptr.append(key))
-        ops.extend(key_ops)
-        key_rops.extend(rops)
-        rops = key_rops
-    return ops, rops
-
-
-def diff_sets(input: Set, output: Set, ptr: Pointer) -> Tuple[List, List]:
-    ops, rops = [], []
-    for value in input - output:
-        ops.append({"op": "remove", "path": ptr.append(value)})
-        rops.insert(0, {"op": "add", "path": ptr.append("-"), "value": value})
-    for value in output - input:
-        ops.append({"op": "add", "path": ptr.append("-"), "value": value})
-        rops.insert(0, {"op": "remove", "path": ptr.append(value)})
-    return ops, rops
-
-
-def diff(input: Diffable, output: Diffable, ptr: Pointer = None) -> Tuple[List, List]:
-    if input == output:
-        return [], []
-    if ptr is None:
-        ptr = Pointer()
-    if hasattr(input, "append") and hasattr(output, "append"):  # list
-        return diff_lists(input, output, ptr)
-    if hasattr(input, "keys") and hasattr(output, "keys"):  # dict
-        return diff_dicts(input, output, ptr)
-    if hasattr(input, "add") and hasattr(output, "add"):  # set
-        return diff_sets(input, output, ptr)
-    return [{"op": "replace", "path": ptr, "value": output}], [
-        {"op": "replace", "path": ptr, "value": input}
-    ]

patchdiff-0.3.4/pyproject.toml

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

patchdiff-0.3.4/setup.py

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['patchdiff']
-
-package_data = \
-{'': ['*']}
-
-setup_kwargs = {
-    'name': 'patchdiff',
-    'version': '0.3.4',
-    '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/fork-tongue/patchdiff/workflows/CI/badge.svg)](https://github.com/fork-tongue/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/fork-tongue/patchdiff',
-    'packages': packages,
-    'package_data': package_data,
-    'python_requires': '>=3.7',
-}
-
-
-setup(**setup_kwargs)