patchdiff 0.3.5__tar.gz → 0.3.7__tar.gz

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

@@ -0,0 +1,56 @@
+name: Benchmarks
+
+on:
+  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
+
+      # On PRs: run benchmarks twice (PR code vs master code) and compare
+      - name: Run benchmarks
+        run: |
+          # Checkout master version of patchdiff directory
+          git fetch origin master
+          git checkout origin/master -- patchdiff/
+
+          # Run benchmarks with master code as baseline
+          uv run --no-sync pytest benchmarks/benchmark.py \
+              --benchmark-only \
+              --benchmark-save=master \
+              --benchmark-sort=mean || true
+
+          # Restore PR code
+          git checkout HEAD -- patchdiff/
+
+          # Run benchmarks on PR code and compare
+          uv run --no-sync pytest benchmarks/benchmark.py \
+              --benchmark-only \
+              --benchmark-compare \
+              --benchmark-compare-fail=mean:5% \
+              --benchmark-save=branch \
+              --benchmark-sort=mean
+
+      - name: Upload benchmarks
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: Benchmarks
+          path: .benchmarks/
+          include-hidden-files: true

{patchdiff-0.3.5 → patchdiff-0.3.7}/.gitignore

@@ -4,3 +4,5 @@ __pycache__
 .coverage
 dist
 uv.lock
+.benchmarks/
+.venv

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchdiff
-Version: 0.3.5
+Version: 0.3.7
 Summary: MIT
 Project-URL: Homepage, https://github.com/fork-tongue/patchdiff
 Author-email: Korijn van Golen <korijn@gmail.com>, Berend Klein Haneveld <berendkleinhaneveld@gmail.com>

patchdiff-0.3.7/benchmarks/benchmark.py

@@ -0,0 +1,232 @@
+"""
+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
+from patchdiff.pointer import Pointer
+
+# 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)
+
+
+# ========================================
+# Set Diff Benchmarks
+# ========================================
+
+
+@pytest.mark.benchmark(group="set-diff")
+def test_set_diff_1000_elements(benchmark):
+    """Benchmark: Sets with 1000 elements, 10% difference."""
+    a = set(generate_random_list(1000, 2000))
+    b = a.copy()
+    # Remove 5%
+    a_list = list(a)
+    for i in range(50):
+        a.remove(a_list[i])
+    # Add 5%
+    for i in range(50):
+        b.add(2000 + i)
+
+    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)
+
+
+# ========================================
+# Pointer Evaluate Benchmarks
+# ========================================
+
+
+@pytest.mark.benchmark(group="pointer-evaluate")
+def test_pointer_evaluate_deep_dict(benchmark):
+    """Benchmark: Evaluate pointer on deeply nested structure."""
+    depth = 100
+    obj = 42
+    for i in range(depth - 1, -1, -1):
+        obj = {f"key_{i}": obj}
+    ptr = Pointer([f"key_{i}" for i in range(depth)])
+
+    benchmark(ptr.evaluate, obj)
+
+
+@pytest.mark.benchmark(group="pointer-evaluate")
+def test_pointer_evaluate_deep_list(benchmark):
+    """Benchmark: Evaluate pointer on deep lists."""
+    # Build nested lists 100 levels deep; innermost value is 42.
+    depth = 100
+    nested = 42
+    for _ in range(depth):
+        nested = [nested]
+    obj = nested
+    ptr = Pointer([0] * depth)
+
+    benchmark(ptr.evaluate, obj)
+
+
+# ========================================
+# Pointer Append Benchmarks
+# ========================================
+
+
+@pytest.mark.benchmark(group="pointer-append")
+def test_pointer_append(benchmark):
+    """Benchmark: Append token to pointer."""
+    ptr = Pointer.from_str("/a/b/c/d/e/f/g/h/i/j")
+
+    benchmark(ptr.append, "k")

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

@@ -1,5 +1,7 @@
+from importlib.metadata import version
+
+__version__ = version("patchdiff")
+
 from .apply import apply, iapply
 from .diff import diff
 from .serialize import to_json
-
-__version__ = "0.3.4"

{patchdiff-0.3.5 → patchdiff-0.3.7}/patchdiff/apply.py

@@ -6,6 +6,8 @@ from .types import Diffable
 
 def iapply(obj: Diffable, patches: List[Dict]) -> Diffable:
     """Apply a set of patches to an object, in-place"""
+    if not patches:
+        return obj
     for patch in patches:
         ptr = patch["path"]
         op = patch["op"]

patchdiff-0.3.7/patchdiff/diff.py

@@ -0,0 +1,194 @@
+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()) if input else set()
+    output_keys = set(output.keys()) if output else set()
+    if input_only := input_keys - output_keys:
+        for key in input_only:
+            key_ptr = ptr.append(key)
+            ops.append({"op": "remove", "path": key_ptr})
+            rops.insert(0, {"op": "add", "path": key_ptr, "value": input[key]})
+    if output_only := output_keys - input_keys:
+        for key in output_only:
+            key_ptr = ptr.append(key)
+            ops.append(
+                {
+                    "op": "add",
+                    "path": key_ptr,
+                    "value": output[key],
+                }
+            )
+            rops.insert(0, {"op": "remove", "path": key_ptr})
+    if common := input_keys & output_keys:
+        for key in common:
+            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 = [], []
+    if input_only := input - output:
+        for value in input_only:
+            ops.append({"op": "remove", "path": ptr.append(value)})
+            rops.insert(0, {"op": "add", "path": ptr.append("-"), "value": value})
+    if output_only := output - input:
+        for value in output_only:
+            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.5 → patchdiff-0.3.7}/patchdiff/pointer.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Hashable, List, Tuple
+from typing import Any, Hashable, Iterable, Tuple
 
 from .types import Diffable
 
@@ -20,7 +20,9 @@ def escape(token: str) -> str:
 
 
 class Pointer:
-    def __init__(self, tokens: List[Hashable] | None = None) -> None:
+    __slots__ = ("tokens",)
+
+    def __init__(self, tokens: Iterable[Hashable] | None = None) -> None:
         if tokens is None:
             tokens = []
         self.tokens = tuple(tokens)
@@ -40,7 +42,7 @@ class Pointer:
         return hash(self.tokens)
 
     def __eq__(self, other: "Pointer") -> bool:
-        if not isinstance(other, self.__class__):
+        if other.__class__ != self.__class__:
             return False
         return self.tokens == other.tokens
 
@@ -48,17 +50,14 @@ class Pointer:
         key = ""
         parent = None
         cursor = obj
-        for key in self.tokens:
-            parent = cursor
-            if hasattr(parent, "add"):  # set
-                break
-            if hasattr(parent, "append"):  # list
-                if key == "-":
-                    break
+        if tokens := self.tokens:
             try:
-                cursor = parent[key]
-            except KeyError:
-                break
+                for key in tokens:
+                    parent = cursor
+                    cursor = parent[key]
+            except (KeyError, TypeError):
+                # KeyError for dicts, TypeError for sets and lists
+                pass
         return parent, key, cursor
 
     def append(self, token: Hashable) -> "Pointer":

{patchdiff-0.3.5 → patchdiff-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "patchdiff"
-version = "0.3.5"
+version = "0.3.7"
 description = "MIT"
 authors = [
     { name = "Korijn van Golen", email = "korijn@gmail.com" },
@@ -18,6 +18,7 @@ dev = [
     "pytest",
     "pytest-cov",
     "pytest-watch",
+    "pytest-benchmark",
 ]
 
 [tool.ruff.lint]

patchdiff-0.3.5/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}
-    ]