Recursion detection (#31)

Author: crusaderky

doc/conf.py

@@ -37,8 +37,8 @@
 ]
 
 extlinks = {
-    "issue": ("https://github.com/crusaderky/recursive_diff/issues/%s", "#"),
-    "pull": ("https://github.com/crusaderky/recursive_diff/pull/%s", "#"),
+    "issue": ("https://github.com/crusaderky/recursive_diff/issues/%s", "#%s"),
+    "pull": ("https://github.com/crusaderky/recursive_diff/pull/%s", "#%s"),
 }
 
 autosummary_generate = True

doc/whats-new.rst

@@ -8,7 +8,8 @@ v1.3.0 (unreleased)
 -------------------
 - Test against Python 3.13 and 3.14
 - Test against recent Pandas versions (tested up to 3.0 beta)
-- Fixed warnings in recent Pandas versions
+- Detect and handle recursion in data structures (:issue:`24`)
+- Fixed warnings in recent Pandas versions (:issue:`27`)
 - Bumped up minimum versions for all dependencies:
 
   ========== ====== ========

recursive_diff/recursive_diff.py

@@ -9,6 +9,7 @@
 import math
 import re
 from collections.abc import Collection, Hashable, Iterator
+from contextlib import suppress
 from typing import Any, Literal
 
 import numpy as np
@@ -105,6 +106,8 @@ def recursive_diff(
         abs_tol=abs_tol,
         brief_dims=brief_dims,
         path=[],
+        seen_lhs=[],
+        seen_rhs=[],
         suppress_type_diffs=False,
         join="inner",
     )
@@ -118,13 +121,19 @@ def _recursive_diff(
     abs_tol: float,
     brief_dims: Collection[Hashable] | str,
     path: list[object],
+    seen_lhs: list[int],
+    seen_rhs: list[int],
     suppress_type_diffs: bool,
     join: Literal["inner", "outer"],
 ) -> Iterator[str]:
     """Recursive implementation of :func:`recursive_diff`
 
     :param list path:
         list of nodes traversed so far, to be prepended to all error messages
+    param list[int] seen_lhs:
+        list of id() of all lhs objects traversed so far, to detect cycles
+    param list[int] seen_rhs:
+        list of id() of all rhs objects traversed so far, to detect cycles
     :param bool suppress_type_diffs:
         if True, don't print out messages about differences in type
     :param str join:
@@ -144,6 +153,34 @@ def diff(msg: str, print_path: list[object] = path) -> str:
             path_prefix += ": "
         return path_prefix + msg
 
+    # Detect recursion
+    recursive_lhs = -1
+    recursive_rhs = -1
+    with suppress(ValueError):
+        recursive_lhs = seen_lhs.index(id(lhs))
+    with suppress(ValueError):
+        recursive_rhs = seen_rhs.index(id(rhs))
+
+    if recursive_lhs >= 0 or recursive_rhs >= 0:
+        if recursive_lhs != recursive_rhs:
+            if recursive_lhs == -1:
+                msg_lhs = "is not recursive"
+            else:
+                msg_lhs = f"recurses to {path[: recursive_lhs + 1]}"
+            if recursive_rhs == -1:
+                msg_rhs = "is not recursive"
+            else:
+                msg_rhs = f"recurses to {path[: recursive_rhs + 1]}"
+            yield diff(f"LHS {msg_lhs}; RHS {msg_rhs}")
+        return
+
+    # Don't add internalized objects
+    if not isinstance(lhs, (bool, int, float, type(None), str, bytes)):
+        seen_lhs = [*seen_lhs, id(lhs)]
+    if not isinstance(rhs, (bool, int, float, type(None), str, bytes)):
+        seen_rhs = [*seen_rhs, id(rhs)]
+    # End of recursion detection
+
     # Build string representation of the two variables *before* casting
     lhs_repr = _str_trunc(lhs)
     rhs_repr = _str_trunc(rhs)
@@ -215,6 +252,8 @@ def diff(msg: str, print_path: list[object] = path) -> str:
                 abs_tol=abs_tol,
                 brief_dims=brief_dims,
                 path=[*path, i],
+                seen_lhs=seen_lhs,
+                seen_rhs=seen_rhs,
                 suppress_type_diffs=suppress_type_diffs,
                 join=join,
             )
@@ -271,6 +310,8 @@ def diff(msg: str, print_path: list[object] = path) -> str:
                 abs_tol=abs_tol,
                 brief_dims=brief_dims,
                 path=[*path, key],
+                seen_lhs=seen_lhs,
+                seen_rhs=seen_rhs,
                 suppress_type_diffs=suppress_type_diffs,
                 join=join,
             )
@@ -426,6 +467,8 @@ def diff(msg: str, print_path: list[object] = path) -> str:
                     abs_tol=abs_tol,
                     brief_dims=brief_dims,
                     path=path,
+                    seen_lhs=seen_lhs,
+                    seen_rhs=seen_rhs,
                     suppress_type_diffs=True,
                     join=join,
                 )
@@ -441,6 +484,8 @@ def diff(msg: str, print_path: list[object] = path) -> str:
                 abs_tol=abs_tol,
                 brief_dims=brief_dims,
                 path=path,
+                seen_lhs=seen_lhs,
+                seen_rhs=seen_rhs,
                 suppress_type_diffs=True,
                 join=join,
             )

recursive_diff/tests/test_recursive_diff.py

@@ -857,3 +857,48 @@ def test_dask(chunk_lhs, chunk_rhs):
         rhs = rhs.chunk(chunk_rhs)
 
     check(lhs, rhs, "[data][x=2]: c != d")
+
+
+def test_recursion():
+    lhs = []
+    lhs.append(lhs)
+    rhs = [1]
+    check(lhs, rhs, "[0]: LHS recurses to [0]; RHS is not recursive")
+    check(rhs, lhs, "[0]: LHS is not recursive; RHS recurses to [0]")
+
+    rhs = []
+    rhs.append(rhs)
+    check(lhs, rhs)
+
+
+def test_recursion_different_target_different():
+    lhs = [[1, 2], [3, 4]]
+    lhs.append(lhs[0])
+    rhs = [[1, 2], [3, 4]]
+    rhs.append(rhs[1])
+
+    check(
+        lhs,
+        rhs,
+        "[2][0]: 1 != 3 (abs: 2.0e+00, rel: 2.0e+00)",
+        "[2][1]: 2 != 4 (abs: 2.0e+00, rel: 1.0e+00)",
+    )
+
+
+def test_recursion_different_target_identical():
+    lhs = [[1, 2], [1, 2]]
+    lhs.append(lhs[0])
+    rhs = [[1, 2], [1, 2]]
+    rhs.append(rhs[1])
+    check(lhs, rhs)
+
+
+def test_repetition_is_not_recursion():
+    class C:
+        def __eq__(self, other):
+            return isinstance(other, C)
+
+    c1 = C()
+    lhs = [c1, c1]
+    rhs = [c1, C()]
+    check(lhs, rhs)