Support fake globals in Python generic classes' __init__ methods

Author: dr-carlos

Lib/annotationlib.py

@@ -897,6 +897,17 @@ def _get_annotate_attr(annotate, attr, default):
     if isinstance(annotate, types.MethodType):
         return _get_annotate_attr(annotate.__func__, attr, default)
 
+    # Python generics are callable. Usually, the __init__ method sets attributes.
+    # However, typing._BaseGenericAlias overrides the __init__ method, so we need
+    # to use the original class method for fake globals and the like.
+    # _BaseGenericAlias also override __call__, so let's handle this earlier than
+    # other class construction.
+    if (
+        (typing := sys.modules.get("typing", None))
+        and isinstance(annotate, typing._BaseGenericAlias)
+    ):
+        return getattr(annotate.__origin__.__init__, 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,
@@ -937,6 +948,22 @@ def _direct_call_annotate(func, annotate, *args):
         # argument.
         return _direct_call_annotate(func, annotate.__func__, self, *args)
 
+    # Python generics (typing._BaseGenericAlias) override __call__, so let's handle
+    # them earlier than other class construction.
+    if (
+        (typing := sys.modules.get("typing", None))
+        and isinstance(annotate, typing._BaseGenericAlias)
+    ):
+        inst = annotate.__new__(annotate.__origin__)
+        func(inst, *args)
+        # Try to set the original class on the instance, if possible.
+        # This is the same logic used in typing for custom generics.
+        try:
+            inst.__orig_class__ = annotate
+        except Exception:
+            pass
+        return inst
+
     # 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,
@@ -954,7 +981,8 @@ def _direct_call_annotate(func, annotate, *args):
         func(inst, *args)
         return inst
 
-    # Generic instantiation is slightly different.
+    # Generic instantiation is slightly different. Since we want to give
+    # __call__ priority, the custom logic for builtin generics is here.
     if isinstance(annotate, types.GenericAlias):
         inst = annotate.__new__(annotate.__origin__)
         func(inst, *args)

Lib/test/test_annotationlib.py

@@ -1559,6 +1559,44 @@ def __init__(self, format, /, __Format=Format,
         # We manually set the __orig_class__ for this special-case, check this too.
         self.assertEqual(annotations.__orig_class__, Annotate[str, type])
 
+    def test_callable_typing_generic_class_annotate_forwardref_fakeglobals(self):
+        # Normally, generics are 'typing._GenericAlias' objects. These are implemented
+        # in Python with a __call__ method (in _typing.BaseGenericAlias), but this
+        # needs to be bypassed so we can inject fake globals into the origin class'
+        # __init__ method.
+        class Annotate[T]:
+            def __init__(self, format, /, __Format=Format,
+                         __NotImplementedError=NotImplementedError):
+                if format == __Format.VALUE:
+                    self.data = {'x': str}
+                elif format == __Format.VALUE_WITH_FAKE_GLOBALS:
+                    self.data = {"x": int}
+                else:
+                    raise __NotImplementedError(format)
+            def __getitem__(self, item):
+                return self.data[item]
+            def __iter__(self):
+                return iter(self.data)
+            def __len__(self):
+                return len(self.data)
+            def __getattr__(self, attr):
+                val = getattr(collections.abc.Mapping, attr)
+                if isinstance(val, types.FunctionType):
+                    return types.MethodType(val, self)
+                return val
+            def __eq__(self, other):
+                return dict(self.items()) == dict(other.items())
+
+        annotations = annotationlib.call_annotate_function(
+            Annotate[int],
+            Format.FORWARDREF,
+        )
+
+        self.assertEqual(annotations, {"x": int})
+
+        # We manually set the __orig_class__ for this special-case, check this too.
+        self.assertEqual(annotations.__orig_class__, Annotate[int])
+
     def test_user_annotate_forwardref_value_fallback(self):
         # If Format.FORWARDREF and Format.VALUE_WITH_FAKE_GLOBALS are not supported
         # use Format.VALUE
@@ -1808,39 +1846,6 @@ class Annotate:
 
         self.assertEqual(annotations, {"x": int})
 
-    def test_callable_typing_generic_class_annotate_forwardref_value_fallback(self):
-        # Normally, generics are 'typing._GenericAlias' objects. These are implemented
-        # in Python with a __call__ method (in _typing.BaseGenericAlias), so should work
-        # as with any callable class instance.
-        class Annotate[T]:
-            def __init__(self, format, /, __Format=Format,
-                         __NotImplementedError=NotImplementedError):
-                if format == __Format.VALUE_WITH_FAKE_GLOBALS:
-                    self.data = {"x": int}
-                else:
-                    raise __NotImplementedError(format)
-            def __getitem__(self, item):
-                return self.data[item]
-            def __iter__(self):
-                return iter(self.data)
-            def __len__(self):
-                return len(self.data)
-            def __getattr__(self, attr):
-                val = getattr(collections.abc.Mapping, attr)
-                if isinstance(val, types.FunctionType):
-                    return types.MethodType(val, self)
-                return val
-            def __eq__(self, other):
-                return dict(self.items()) == dict(other.items())
-
-        annotations = annotationlib.call_annotate_function(
-            Annotate[int],
-            Format.FORWARDREF,
-        )
-
-        self.assertEqual(annotations, {"x": int})
-        self.assertEqual(annotations.__orig_class__, Annotate[int])
-
     def test_callable_partial_annotate_forwardref_value_fallback(self):
         # functools.partial is implemented in C. Ensure that the annotate function
         # is extracted and called correctly, particularly with Placeholder args.