Inspect: Detect recursive objects

Replicates graphql/graphql-js@1375776

Author: Cito

graphql/pyutils/inspect.py

@@ -15,8 +15,12 @@
 
 __all__ = ["inspect"]
 
+max_recursive_depth = 2
+max_str_size = 240
+max_list_size = 10
 
-def inspect(value: Any, max_depth: int = 2, depth: int = 0) -> str:
+
+def inspect(value: Any) -> str:
     """Inspect value and a return string representation for error messages.
 
     Used to print values in error messages. We do not use repr() in order to not
@@ -27,46 +31,47 @@ def inspect(value: Any, max_depth: int = 2, depth: int = 0) -> str:
     We also restrict the size of the representation by truncating strings and
     collections and allowing only a maximum recursion depth.
     """
+    return inspect_recursive(value, [])
+
+
+def inspect_recursive(value: Any, seen_values: List) -> str:
     if value is None or value is INVALID or isinstance(value, (bool, float, complex)):
         return repr(value)
     if isinstance(value, (int, str, bytes, bytearray)):
         return trunc_str(repr(value))
-    if depth < max_depth:
-        try:
-            # check if we have a custom inspect method
-            inspect_method = value.__inspect__
-            if callable(inspect_method):
-                s = inspect_method()
-                return (
-                    trunc_str(s)
-                    if isinstance(s, str)
-                    else inspect(s, max_depth, depth + 1)
-                )
-        except AttributeError:
-            pass
+    if len(seen_values) < max_recursive_depth and value not in seen_values:
+        # check if we have a custom inspect method
+        inspect_method = getattr(value, "__inspect__", None)
+        if inspect_method is not None and callable(inspect_method):
+            s = inspect_method()
+            if isinstance(s, str):
+                return trunc_str(s)
+            seen_values = [*seen_values, value]
+            return inspect_recursive(s, seen_values)
+        # recursively inspect collections
         if isinstance(value, (list, tuple, dict, set, frozenset)):
             if not value:
                 return repr(value)
+            seen_values = [*seen_values, value]
             if isinstance(value, list):
                 items = value
             elif isinstance(value, dict):
                 items = list(value.items())
             else:
                 items = list(value)
             items = trunc_list(items)
-            depth += 1
             if isinstance(value, dict):
                 s = ", ".join(
                     "..."
                     if v is ELLIPSIS
-                    else inspect(v[0], max_depth, depth)
+                    else inspect_recursive(v[0], seen_values)
                     + ": "
-                    + inspect(v[1], max_depth, depth)
+                    + inspect_recursive(v[1], seen_values)
                     for v in items
                 )
             else:
                 s = ", ".join(
-                    "..." if v is ELLIPSIS else inspect(v, max_depth, depth)
+                    "..." if v is ELLIPSIS else inspect_recursive(v, seen_values)
                     for v in items
                 )
             if isinstance(value, tuple):
@@ -79,6 +84,7 @@ def inspect(value: Any, max_depth: int = 2, depth: int = 0) -> str:
                 return f"frozenset({{{s}}})"
             return f"[{s}]"
     else:
+        # handle collections that are nested too deep
         if isinstance(value, (list, tuple, dict, set, frozenset)):
             if not value:
                 return repr(value)
@@ -139,19 +145,19 @@ def inspect(value: Any, max_depth: int = 2, depth: int = 0) -> str:
         return f"<{type_} {name}>"
 
 
-def trunc_str(s: str, max_string=240) -> str:
+def trunc_str(s: str) -> str:
     """Truncate strings to maximum length."""
-    if len(s) > max_string:
-        i = max(0, (max_string - 3) // 2)
-        j = max(0, max_string - 3 - i)
+    if len(s) > max_str_size:
+        i = max(0, (max_str_size - 3) // 2)
+        j = max(0, max_str_size - 3 - i)
         s = s[:i] + "..." + s[-j:]
     return s
 
 
-def trunc_list(s: List, max_list=10) -> List:
+def trunc_list(s: List) -> List:
     """Truncate lists to maximum length."""
-    if len(s) > max_list:
-        i = max_list // 2
+    if len(s) > max_list_size:
+        i = max_list_size // 2
         j = i - 1
         s = s[:i] + [ELLIPSIS] + s[-j:]
     return s

tests/pyutils/test_inspect.py

@@ -1,4 +1,6 @@
 from math import nan, inf
+from contextlib import contextmanager
+from importlib import import_module
 
 from pytest import mark
 
@@ -13,6 +15,35 @@
     GraphQLString,
 )
 
+inspect_module = import_module(inspect.__module__)
+
+
+@contextmanager
+def increased_recursive_depth():
+    inspect_module.max_recursive_depth += 1
+    try:
+        yield inspect
+    finally:
+        inspect_module.max_recursive_depth -= 1
+
+
+@contextmanager
+def increased_str_size():
+    inspect_module.max_str_size *= 2
+    try:
+        yield inspect
+    finally:
+        inspect_module.max_str_size //= 2
+
+
+@contextmanager
+def increased_list_size():
+    inspect_module.max_list_size *= 2
+    try:
+        yield inspect
+    finally:
+        inspect_module.max_list_size //= 2
+
 
 def describe_inspect():
     def inspect_invalid():
@@ -33,6 +64,8 @@ def overly_large_string():
         s = "foo" * 100
         r = repr(s)
         assert inspect(s) == r[:118] + "..." + r[-119:]
+        with increased_str_size():
+            assert inspect(s) == r
 
     def inspect_bytes():
         for b in b"", b"abc", b"foo\tbar \x7f\xff\0", b"'", b"'":
@@ -62,6 +95,8 @@ def overly_large_int():
         n = int("123" * 100)
         r = repr(n)
         assert inspect(n) == r[:118] + "..." + r[-119:]
+        with increased_str_size():
+            assert inspect(n) == r
 
     def inspect_function():
         assert inspect(lambda: 0) == "<function>"
@@ -132,18 +167,21 @@ def inspect_lists():
     def inspect_overly_large_list():
         s = list(range(20))
         assert inspect(s) == "[0, 1, 2, 3, 4, ..., 16, 17, 18, 19]"
+        with increased_list_size():
+            assert inspect(s) == repr(s)
 
     def inspect_overly_nested_list():
         s = [[[]]]
         assert inspect(s) == "[[[]]]"
         s = [[[1, 2, 3]]]
         assert inspect(s) == "[[[...]]]"
-        assert inspect(s, max_depth=3) == repr(s)
+        with increased_recursive_depth():
+            assert inspect(s) == repr(s)
 
     def inspect_recursive_list():
         s = [1, 2, 3]
         s[1] = s
-        assert inspect(s) == "[1, [1, [...], 3], 3]"
+        assert inspect(s) == "[1, [...], 3]"
 
     def inspect_tuples():
         assert inspect(()) == "()"
@@ -155,13 +193,16 @@ def inspect_tuples():
     def inspect_overly_large_tuple():
         s = tuple(range(20))
         assert inspect(s) == "(0, 1, 2, 3, 4, ..., 16, 17, 18, 19)"
+        with increased_list_size():
+            assert inspect(s) == repr(s)
 
     def inspect_overly_nested_tuple():
         s = (((),),)
         assert inspect(s) == "(((),),)"
         s = (((1, 2, 3),),)
         assert inspect(s) == "(((...),),)"
-        assert inspect(s, max_depth=3) == repr(s)
+        with increased_recursive_depth():
+            assert inspect(s) == repr(s)
 
     def inspect_recursive_tuple():
         s = [1, 2, 3]
@@ -193,18 +234,21 @@ def inspect_overly_large_dict():
             inspect(s) == "{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4,"
             " ..., 'q': 16, 'r': 17, 's': 18, 't': 19}"
         )
+        with increased_list_size():
+            assert inspect(s) == repr(s)
 
     def inspect_overly_nested_dict():
         s = {"a": {"b": {}}}
         assert inspect(s) == "{'a': {'b': {}}}"
         s = {"a": {"b": {"c": 3}}}
         assert inspect(s) == "{'a': {'b': {...}}}"
-        assert inspect(s, max_depth=3) == repr(s)
+        with increased_recursive_depth():
+            assert inspect(s) == repr(s)
 
     def inspect_recursive_dict():
         s = {}
         s[1] = s
-        assert inspect(s) == "{1: {1: {...}}}"
+        assert inspect(s) == "{1: {...}}"
 
     def inspect_sets():
         assert inspect(set()) == "set()"
@@ -217,13 +261,16 @@ def inspect_overly_large_set():
         assert r.startswith("{") and r.endswith("}")
         assert "..., " in r and "5" not in s  # sets are unordered
         assert len(r) == 36
+        with increased_list_size():
+            assert inspect(s) == repr(s)
 
     def inspect_overly_nested_set():
         s = [[set()]]
         assert inspect(s) == "[[set()]]"
         s = [[set([1, 2, 3])]]
         assert inspect(s) == "[[set(...)]]"
-        assert inspect(s, max_depth=3) == repr(s)
+        with increased_recursive_depth():
+            assert inspect(s) == repr(s)
 
     def inspect_frozensets():
         assert inspect(frozenset()) == "frozenset()"
@@ -239,13 +286,16 @@ def inspect_overly_large_frozenset():
         assert r.startswith("frozenset({") and r.endswith("})")
         assert "..., " in r and "5" not in s  # frozensets are unordered
         assert len(r) == 47
+        with increased_list_size():
+            assert inspect(s) == repr(s)
 
     def inspect_overly_nested_frozenset():
         s = frozenset([frozenset([frozenset()])])
         assert inspect(s) == "frozenset({frozenset({frozenset()})})"
         s = frozenset([frozenset([frozenset([1, 2, 3])])])
         assert inspect(s) == "frozenset({frozenset({frozenset(...)})})"
-        assert inspect(s, max_depth=3) == repr(s)
+        with increased_recursive_depth():
+            assert inspect(s) == repr(s)
 
     def mixed_recursive_dict_and_list():
         s = {1: []}
@@ -312,7 +362,11 @@ class TestClass:
             def __inspect__():
                 return s
 
-        assert inspect(TestClass()) == s[:118] + "..." + s[-119:]
+        value = TestClass()
+
+        assert inspect(value) == s[:118] + "..." + s[-119:]
+        with increased_str_size():
+            assert inspect(value) == s
 
     def custom_inspect_that_is_recursive():
         class TestClass: