MAINT: simplify check that target owns method

Author: steppi

src/array_api_extra/testing.py

@@ -219,7 +219,7 @@ def test_myfunc(xp):
             DeprecationWarning,
             stacklevel=2,
         )
-    tags = {
+    tags: dict[str, bool | int | type] = {
         "allow_dask_compute": allow_dask_compute,
         "jax_jit": jax_jit,
     }
@@ -238,10 +238,6 @@ def test_myfunc(xp):
         raw_attr = getattr_static(cls, method_name)
         method = getattr(cls, method_name)
         cloned_method = _clone_function(method)
-        # Update the ``__qualname__`` because this will be used later to check
-        # whether something is a method defined in the class of interest, or just
-        # a reference to a function that's stored in a class.
-        cloned_method.__qualname__ = f"{cls.__name__}.{method_name}"
 
         method_to_set: Any
         if isinstance(raw_attr, staticmethod):
@@ -253,6 +249,8 @@ def test_myfunc(xp):
 
         setattr(cls, method_name, method_to_set)
         f = getattr(cls, method_name)
+        # Annotate that cls owns this method so we can check that later.
+        tags["owner"] = cls
     else:
         f = func
 
@@ -382,19 +380,17 @@ def iter_tagged() -> Iterator[
                     with contextlib.suppress(KeyError, TypeError):
                         tags = _ufuncs_tags[func]
                 if tags is not None:
-                    if isinstance(target, type):
+                    if isinstance(target, type) and tags.get("owner") is not target:
                         # There's a common pattern to wrap functions in namespace
                         # classes to bypass lazy_xp_function like this:
                         #
                         # class naked:
                         #     myfunc = mymodule.myfunc
                         #
                         # To ensure this still works when checking for tags in
-                        # attributes of classes, use ``__qualname__`` to check whether
-                        # or not ``func`` was originally defined within ``target``.
-                        qn = getattr(func, "__qualname__", "")
-                        if not qn.startswith(f"{target.__name__}."):
-                            continue
+                        # attributes of classes, ensure that target is the actual
+                        # owning class where func was defined.
+                        continue
                     # put attr, and func in the outputs so we can later tell
                     # if this was a staticmethod or classmethod.
                     yield target, name, attr, func, tags