patchdiff 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

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/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/diff.py

@@ -1,4 +1,5 @@
-from functools import partial, reduce
+from __future__ import annotations
+
 from typing import Dict, List, Set, Tuple
 
 from .pointer import Pointer
@@ -6,126 +7,178 @@ from .types import Diffable
 
 
 def diff_lists(input: List, output: List, ptr: Pointer) -> Tuple[List, List]:
-    memory = {(0, 0): {"ops": [], "rops": [], "cost": 0}}
+    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)]
 
-    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)
+    # 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:
-                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
+                # 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(target) + padding else "-"
-            full_op = {
-                "op": "add",
-                "path": ptr.append(idx_token),
-                "value": op["value"],
-            }
-            return [[*ops, full_op], padding + 1]
+            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":
-            full_op = {
-                "op": "remove",
-                "path": ptr.append(op["idx"] + padding),
-            }
-            return [[*ops, full_op], padding - 1]
-        else:
+            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)
-            return [ops + replace_ops, padding]
+            padded_ops.extend(replace_ops)
 
-    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])
+    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
+    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 = [], []
-    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)})
+    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) -> Tuple[List, List]:
+def diff(
+    input: Diffable, output: Diffable, ptr: Pointer | None = None
+) -> Tuple[List, List]:
     if input == output:
         return [], []
     if ptr is None:

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.dist-info → patchdiff-0.3.7.dist-info}/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,9 @@
+patchdiff/__init__.py,sha256=tXjBK8Oei1NjMt-U4gRhshdJ9yYoRq5Y-xf0m3nHLq8,163
+patchdiff/apply.py,sha256=zxjJ4sCivcy4WOZulQGfv2iduVeY0xnjlvZJkHIZhtY,1405
+patchdiff/diff.py,sha256=-Aj-8NGE1HRoLxVYNK1dFofACaY3fCCsIJo6ypkrl5U,6827
+patchdiff/pointer.py,sha256=MBakmqcm__2vrorFtMeJekeA8bWS-5mh384UG0u4E0w,1790
+patchdiff/serialize.py,sha256=N0S9e0P49TBMb7ghM--h13MsF59ybiscjZ_auAErTq8,295
+patchdiff/types.py,sha256=BVKXOl3tnQOOml3VI_epTrLn79agi6sD5vNr2acC-yE,77
+patchdiff-0.3.7.dist-info/METADATA,sha256=d35C8963EBLsfTkqYNNriTO1aXYFKnJNEPh3tVYF0Es,1634
+patchdiff-0.3.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+patchdiff-0.3.7.dist-info/RECORD,,

patchdiff-0.3.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-patchdiff/__init__.py,sha256=uQAwiWM9rTop0zZC6Spn0y_v74cfAzuhCxcEFOrAaXY,110
-patchdiff/apply.py,sha256=25TfOTZTYFIjy70mBus5yCzmbJRawbguDffv_4yHjqE,1366
-patchdiff/diff.py,sha256=AQuIhGDnZda-9IykepEHXcfrDJSEJPXuGe8SdLQoquU,5424
-patchdiff/pointer.py,sha256=ZZqJtGYM2uK6P2saOBn0LWxpIb_qgdTFlcE4EQncnRU,1804
-patchdiff/serialize.py,sha256=N0S9e0P49TBMb7ghM--h13MsF59ybiscjZ_auAErTq8,295
-patchdiff/types.py,sha256=BVKXOl3tnQOOml3VI_epTrLn79agi6sD5vNr2acC-yE,77
-patchdiff-0.3.5.dist-info/METADATA,sha256=pea0_lmfx8Y5g5RMNpQGfSJWfQiDQQHFv_yybEQUMkg,1634
-patchdiff-0.3.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-patchdiff-0.3.5.dist-info/RECORD,,