Support (recursively unwrap/call) any type of callable as an annotation function class' __call__ attribute

Author: dr-carlos

Lib/annotationlib.py

@@ -897,10 +897,15 @@ def _get_annotate_attr(annotate, attr, default):
     if isinstance(annotate, types.MethodType):
         return _get_annotate_attr(annotate.__func__, attr, default)
 
-    # Class instances themselves aren't methods, their __call__ functions are.
-    if isinstance(annotate.__call__, types.MethodType):
-        if call_func := getattr(annotate.__call__, "__func__", None):
-            return getattr(call_func, attr, default)
+    # If annotate is a class instance, its __call__ is the relevant function.
+    # However, __call__ Could be a method, a function descriptor, or any other callable.
+    # Normal functions have a __call__ property which is a useless method wrapper,
+    # ignore these.
+    if (
+        (call := getattr(annotate, "__call__", None)) and
+        not isinstance(call, types.MethodWrapperType)
+    ):
+        return _get_annotate_attr(annotate.__call__, attr, default)
 
     # Classes and generics are callable, usually the __init__ method sets attributes,
     # so let's access this method for fake globals and the like.
@@ -932,12 +937,15 @@ def _direct_call_annotate(func, annotate, *args):
         # argument.
         return _direct_call_annotate(func, annotate.__func__, self, *args)
 
-    # If annotate is a class instance, its __call__ function is the method.
+    # If annotate is a class instance, its __call__ is the function.
+    # __call__ Could be a method, a function descriptor, or any other callable.
+    # Normal functions have a __call__ property which is a useless method wrapper,
+    # ignore these.
     if (
-        hasattr(annotate.__call__, "__func__") and
-        (self := getattr(annotate.__call__, "__self__", None))
+        (call := getattr(annotate, "__call__", None)) and
+        not isinstance(call, types.MethodWrapperType)
     ):
-        return func(self, *args)
+        return _direct_call_annotate(func, annotate.__call__, *args)
 
     # If annotate is a class, `func` is the __init__ method, so we still need to call
     # __new__() to create the instance

Lib/test/test_annotationlib.py

@@ -1717,6 +1717,28 @@ def __init__(self, format, /, __Format=Format,
 
         self.assertEqual(annotations, {"x": int})
 
+    def test_callable_object_custom_call_annotate_forwardref_value_fallback(self):
+        # If Format.STRING and Format.VALUE_WITH_FAKE_GLOBALS are not
+        # supported fall back to Format.VALUE and convert to strings
+        class AnnotateClass(dict):
+            def __init__(self, format, /, __Format=Format,
+                         __NotImplementedError=NotImplementedError):
+                if format == __Format.VALUE:
+                    super().__init__({"x": int})
+                else:
+                    raise __NotImplementedError(format)
+
+        class Annotate:
+            __call__ = AnnotateClass
+
+        annotations = annotationlib.call_annotate_function(
+            Annotate(),
+            Format.FORWARDREF,
+        )
+
+        self.assertEqual(annotations, {"x": int})
+
+
     def test_callable_generic_class_annotate_forwardref_value_fallback(self):
         # Generics that inherit from builtins become types.GenericAlias objects.
         # This is special-case in annotationlib to ensure the constructor is handled