Fixed recursion bug

line_profiler/line_profiler.py::LineProfiler.add_class(), .add_module()
    Added object-identity tracking to avoid possible recursion if the
    namespaces profiled reference themselves or one another

tests/test_explicit_profile.py
    test_profiler_add_class_recursion_guard()
        New test for adding self-/mutually-referential classes to be
        profiled

Author: TTsangSC

line_profiler/line_profiler.py

@@ -149,12 +149,20 @@ def _add_namespace(self, namespace, *, wrap=False):
             n (int):
                 Number of members added to the profiler.
         """
+        return self._add_namespace_inner(set(), namespace, wrap=wrap)
+
+    def _add_namespace_inner(self, duplicate_tracker, namespace, *,
+                             wrap=False):
         count = 0
-        add_cls = self.add_class
+        add_cls = self._add_namespace_inner
         add_func = self.add_callable
         for attr, value in vars(namespace).items():
+            if id(value) in duplicate_tracker:
+                continue
+            duplicate_tracker.add(id(value))
             if isinstance(value, type):
-                count += 1 if add_cls(value, wrap=wrap) else 0
+                if add_cls(duplicate_tracker, value, wrap=wrap):
+                    count += 1
                 continue
             try:
                 func_needs_adding = add_func(value)

tests/test_explicit_profile.py

@@ -498,6 +498,57 @@ def func3():
         assert line.split()[1] == ('1' if has_timing else 'pass')
 
 
+def test_profiler_add_class_recursion_guard():
+    """
+    Test that if we were to add a pair of classes which each of them
+    has a reference to the other in its namespace, we don't end up in
+    infinite recursion.
+    """
+    with contextlib.ExitStack() as stack:
+        enter = stack.enter_context
+        enter(ub.ChDir(enter(tempfile.TemporaryDirectory())))
+        curdir = ub.Path.cwd()
+        (curdir / 'script.py').write_text(ub.codeblock("""
+        from line_profiler import LineProfiler
+
+
+        class Class1:
+            def method1(self):
+                pass
+
+            class ChildClass1:
+                def child_method_1(self):
+                    pass
+
+
+        class Class2:
+            def method2(self):
+                pass
+
+            class ChildClass2:
+                def child_method_2(self):
+                    pass
+
+            OtherClass = Class1
+            # A duplicate reference shouldn't affect profiling either
+            YetAnotherClass = Class1
+
+
+        # Add self/mutual references
+        Class1.ThisClass = Class1
+        Class1.OtherClass = Class2
+
+        profile = LineProfiler()
+        profile.add_class(Class1)
+        assert len(profile.functions) == 4
+        assert Class1.method1 in profile.functions
+        assert Class2.method2 in profile.functions
+        assert Class1.ChildClass1.child_method_1 in profile.functions
+        assert Class2.ChildClass2.child_method_2 in profile.functions
+        """))
+        ub.cmd([sys.executable, 'script.py'], verbose=2).check_returncode()
+
+
 if __name__ == '__main__':
     ...
     test_simple_explicit_nonglobal_usage()