Tests and fixes

line_profiler/line_profiler.py::LineProfiler.add_class(), add_module()
    Fixed implementation of internal method used (wrong interpretation
    of the `match_scope` parameter)

tests/test_explicit_profile.py
    test_profiler_add_methods()
    test_profiler_add_class_recursion_guard()
        Simplified implementations
    test_profiler_warn_unwrappable()
        New test for the warning in `LineProfiler.add_*(wrap=True)`
    test_profiler_scope_matching()
        New test for `LineProfiler.add_*(match_scope=...)`

tests/test_line_profiler.py::test_profiler_c_callable_no_op()
    New test for how the profiler leaves C-level callables untouched

Author: TTsangSC

line_profiler/line_profiler.py

@@ -4,6 +4,7 @@
 inspect its output. This depends on the :py:mod:`line_profiler._line_profiler`
 Cython backend.
 """
+import functools
 import pickle
 import inspect
 import linecache
@@ -164,31 +165,37 @@ def print_stats(self, stream=None, output_unit=None, stripzeros=False,
                   details=details, summarize=summarize, sort=sort, rich=rich)
 
     def _add_namespace(self, duplicate_tracker, namespace, *,
-                       filter_scope=None, wrap=False):
+                       match_scope='none', wrap=False):
         count = 0
-        add_cls = self._add_namespace
+        add_cls = functools.partial(self._add_namespace, duplicate_tracker,
+                                    match_scope=match_scope, wrap=wrap)
         add_func = self.add_callable
+        remember = duplicate_tracker.add
+        wrap_func = self.wrap_callable
         wrap_failures = {}
-        if filter_scope is None:
-            def filter_scope(*_):
+        if match_scope == 'none':
+            def check(*_):
                 return True
+        elif isinstance(namespace, type):
+            check = self._add_class_filter(namespace, match_scope)
+        else:
+            check = self._add_module_filter(namespace, match_scope)
 
         for attr, value in vars(namespace).items():
             if id(value) in duplicate_tracker:
                 continue
-            duplicate_tracker.add(id(value))
+            remember(id(value))
             if isinstance(value, type):
-                if filter_scope(namespace, value):
-                    if add_cls(duplicate_tracker, value, wrap=wrap):
-                        count += 1
+                if check(value) and add_cls(value):
+                    count += 1
                 continue
             try:
                 if not add_func(value):
                     continue
             except TypeError:  # Not a callable (wrapper)
                 continue
             if wrap:
-                wrapper = self.wrap_callable(value)
+                wrapper = add_func(value)
                 if wrapper is not value:
                     try:
                         setattr(namespace, attr, wrapper)
@@ -207,6 +214,48 @@ def filter_scope(*_):
             warnings.warn(msg, stacklevel=2)
         return count
 
+    @staticmethod
+    def _add_module_filter(mod, match_scope):
+        def match_prefix(s, prefix, sep='.'):
+            return s == prefix or s.startswith(prefix + sep)
+
+        def class_is_child(other):
+            return other.__module__ == mod.__name__
+
+        def class_is_descendant(other):
+            return match_prefix(other.__module__, mod.__name__)
+
+        def class_is_cousin(other):
+            if class_is_descendant(other):
+                return True
+            return match_prefix(other.__module__, parent)
+
+        parent, _, basename = mod.__name__.rpartition('.')
+        return {'exact': class_is_child,
+                'descendants': class_is_descendant,
+                'siblings': (class_is_cousin  # Only if a pkg
+                             if basename else
+                             class_is_descendant)}[match_scope]
+
+    @staticmethod
+    def _add_class_filter(cls, match_scope):
+        def class_is_child(other):
+            if not modules_are_equal(other):
+                return False
+            return other.__qualname__ == f'{cls.__qualname__}.{other.__name__}'
+
+        def modules_are_equal(other):  # = sibling check
+            return cls.__module__ == other.__module__
+
+        def class_is_descendant(other):
+            if not modules_are_equal(other):
+                return False
+            return other.__qualname__.startswith(cls.__qualname__ + '.')
+
+        return {'exact': class_is_child,
+                'descendants': class_is_descendant,
+                'siblings': modules_are_equal}[match_scope]
+
     def add_class(self, cls, *, match_scope='siblings', wrap=False):
         """
         Add the members (callables (wrappers), methods, classes, ...) in
@@ -237,25 +286,8 @@ def add_class(self, cls, *, match_scope='siblings', wrap=False):
             n (int):
                 Number of members added to the profiler.
         """
-        def class_is_child(cls, other):
-            if not modules_are_equal(cls, other):
-                return False
-            return other.__qualname__ == f'{cls.__qualname__}.{other.__name__}'
-
-        def modules_are_equal(cls, other):  # = sibling check
-            return cls.__module__ == other.__module__
-
-        def class_is_descendant(cls, other):
-            if not modules_are_equal(cls, other):
-                return False
-            return other.__qualname__.startswith(cls.__qualname__ + '.')
-
-        filter_scope = {'exact': class_is_child,
-                        'descendants': class_is_descendant,
-                        'siblings': modules_are_equal,
-                        'none': None}[match_scope]
         return self._add_namespace(set(), cls,
-                                   filter_scope=filter_scope, wrap=wrap)
+                                   match_scope=match_scope, wrap=wrap)
 
     def add_module(self, mod, *, match_scope='siblings', wrap=False):
         """
@@ -287,29 +319,8 @@ def add_module(self, mod, *, match_scope='siblings', wrap=False):
             n (int):
                 Number of members added to the profiler.
         """
-        def match_prefix(s: str, prefix: str, sep: str = '.') -> bool:
-            return s == prefix or s.startswith(prefix + sep)
-
-        def class_is_child(mod, other):
-            return other.__module__ == mod.__name__
-
-        def class_is_descendant(mod, other):
-            return match_prefix(other.__module__, mod.__name__)
-
-        def class_is_cousin(mod, other):
-            if class_is_descendant(mod, other):
-                return True
-            return match_prefix(other.__module__, parent)
-
-        parent, _, basename = mod.__name__.rpartition('.')
-        filter_scope = {'exact': class_is_child,
-                        'descendants': class_is_descendant,
-                        'siblings': (class_is_cousin  # Only if a pkg
-                                     if basename else
-                                     class_is_descendant),
-                        'none': None}[match_scope]
         return self._add_namespace(set(), mod,
-                                   filter_scope=filter_scope, wrap=wrap)
+                                   match_scope=match_scope, wrap=wrap)
 
 
 # This could be in the ipython_extension submodule,

tests/test_explicit_profile.py

@@ -8,6 +8,15 @@
 import ubelt as ub
 
 
+@contextlib.contextmanager
+def enter_tmpdir():
+    with contextlib.ExitStack() as stack:
+        enter = stack.enter_context
+        tmpdir = os.path.abspath(enter(tempfile.TemporaryDirectory()))
+        enter(ub.ChDir(tmpdir))
+        yield ub.Path(tmpdir)
+
+
 def test_simple_explicit_nonglobal_usage():
     """
     python -c "from test_explicit_profile import *; test_simple_explicit_nonglobal_usage()"
@@ -458,10 +467,7 @@ def write(path, code):
         '' if wrap_class is None else f', wrap={wrap_class}',
         reset_enable_count))
 
-    with contextlib.ExitStack() as stack:
-        enter = stack.enter_context
-        enter(ub.ChDir(enter(tempfile.TemporaryDirectory())))
-        curdir = ub.Path.cwd()
+    with enter_tmpdir() as curdir:
         write(curdir / 'script.py', script)
         write(curdir / 'my_module_1.py',
               '''
@@ -507,49 +513,180 @@ def test_profiler_add_class_recursion_guard():
     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
+    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
 
+
+def test_profiler_warn_unwrappable():
+    """
+    Test for warnings when using `LineProfiler.add_*(wrap=True)` with a
+    namespace which doesn't allow attribute assignment.
+    """
+    from line_profiler import LineProfiler
+
+    class ProblamticMeta(type):
+        def __init__(cls, *args, **kwargs):
+            super(ProblamticMeta, cls).__init__(*args, **kwargs)
+            cls._initialized = True
+
+        def __setattr__(cls, attr, value):
+            if not getattr(cls, '_initialized', None):
+                return super(ProblamticMeta, cls).__setattr__(attr, value)
+            raise AttributeError(
+                f'cannot set attribute on {type(cls)} instance')
+
+    class ProblematicClass(metaclass=ProblamticMeta):
+        def method(self):
+            pass
+
+    profile = LineProfiler()
+    vanilla_method = ProblematicClass.method
+
+    with pytest.warns(match=r"cannot wrap 1 attribute\(s\) of "
+                      r"<class '.*\.ProblematicClass'> \(`\{attr: value\}`\): "
+                      r"\{'method': <function .*\.method at 0x.*>\}"):
+        # The method is added to the profiler, but we can't assign its
+        # wrapper back into the class namespace
+        assert profile.add_class(ProblematicClass, wrap=True) == 1
+
+    assert ProblematicClass.method is vanilla_method
+
+
+@pytest.mark.parametrize(
+    ('match_scope', 'add_module_targets', 'add_class_targets'),
+    [('exact',
+      {'class2_method', 'child_class2_method'},
+      {'class3_method', 'child_class3_method'}),
+     ('descendants',
+      {'class2_method', 'child_class2_method',
+       'class3_method', 'child_class3_method'},
+      {'class3_method', 'child_class3_method'}),
+     ('siblings',
+      {'class1_method', 'child_class1_method',
+       'class2_method', 'child_class2_method',
+       'class3_method', 'child_class3_method', 'other_class3_method'},
+      {'class3_method', 'child_class3_method', 'other_class3_method'}),
+     ('none',
+      {'class1_method', 'child_class1_method',
+       'class2_method', 'child_class2_method',
+       'class3_method', 'child_class3_method', 'other_class3_method'},
+      {'child_class1_method',
+       'class3_method', 'child_class3_method', 'other_class3_method'})])
+def test_profiler_scope_matching(monkeypatch,
+                                 match_scope,
+                                 add_module_targets,
+                                 add_class_targets):
+    """
+    Test for the scope-matching strategies of the `LineProfiler.add_*()`
+    methods.
+    """
+    def write(path, code=None):
+        path.parent.mkdir(exist_ok=True, parents=True)
+        if code is None:
+            path.touch()
+        else:
+            path.write_text(ub.codeblock(code))
+
+    with enter_tmpdir() as curdir:
+        pkg_dir = curdir / 'packages' / 'my_pkg'
+        write(pkg_dir / '__init__.py')
+        write(pkg_dir / 'submod1.py',
+              """
         class Class1:
-            def method1(self):
+            def class1_method(self):
                 pass
 
             class ChildClass1:
-                def child_method_1(self):
+                def child_class1_method(self):
                     pass
+              """)
+        write(pkg_dir / 'subpkg2' / '__init__.py',
+              """
+        from ..submod1 import Class1  # Import from a sibling
+        from .submod3 import Class3  # Import from a descendant
 
 
         class Class2:
-            def method2(self):
+            def class2_method(self):
                 pass
 
             class ChildClass2:
-                def child_method_2(self):
+                def child_class2_method(self):
                     pass
 
-            OtherClass = Class1
-            # A duplicate reference shouldn't affect profiling either
-            YetAnotherClass = Class1
+            BorrowedChildClass = Class1.ChildClass1  # Non-sibling class
+              """)
+        write(pkg_dir / 'subpkg2' / 'submod3.py',
+              """
+        from ..submod1 import Class1
 
 
-        # Add self/mutual references
-        Class1.ThisClass = Class1
-        Class1.OtherClass = Class2
+        class Class3:
+            def class3_method(self):
+                pass
 
+            class OtherChildClass3:
+                def child_class3_method(self):
+                    pass
+
+            # Unrelated class
+            BorrowedChildClass1 = Class1.ChildClass1
+
+        class OtherClass3:
+            def other_class3_method(self):
+                pass
+
+        # Sibling class
+        Class3.BorrowedChildClass3 = OtherClass3
+              """)
+        monkeypatch.syspath_prepend(pkg_dir.parent)
+
+        from my_pkg import subpkg2
+        from line_profiler import LineProfiler
+
+        # Add a module
+        profile = LineProfiler()
+        profile.add_module(subpkg2, match_scope=match_scope)
+        assert len(profile.functions) == len(add_module_targets)
+        added = {func.__name__ for func in profile.functions}
+        assert added == set(add_module_targets)
+        # Add a class
         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()
+        profile.add_class(subpkg2.Class3, match_scope=match_scope)
+        assert len(profile.functions) == len(add_class_targets)
+        added = {func.__name__ for func in profile.functions}
+        assert added == set(add_class_targets)
 
 
 if __name__ == '__main__':