Support recursive unwrapping of annotate functions

Author: dr-carlos

Lib/annotationlib.py

@@ -905,8 +905,11 @@ def _get_annotate_attr(annotate, attr, default):
     if isinstance(annotate, type) or isinstance(annotate, types.GenericAlias):
         return getattr(annotate.__init__, attr, default)
 
-    if (wrapped := getattr(annotate, "__wrapped__", None)) is not None:
-        return getattr(wrapped, attr, default)
+    # Most 'wrapped' functions, including functools.cache and staticmethod, need us
+    # to manually, recursively unwrap. For partial.update_wrapper functions, the
+    # attribute is accessible on the function itself, so we never get this far.
+    if (unwrapped := getattr(annotate, "__wrapped__", None)) is not None:
+        return _get_annotate_attr(unwrapped, attr, default)
 
     if (
         (functools := sys.modules.get("functools", None))

Lib/test/test_annotationlib.py

@@ -1812,9 +1812,39 @@ def format(format, /, __Format=Format,
         self.assertIsInstance(annotations["x"], float)
         self.assertIs(annotations["y"], str)
 
+        # Check annotations again to ensure that cache is working.
         new_anns = annotationlib.call_annotate_function(format, Format.FORWARDREF)
         self.assertEqual(annotations, new_anns)
 
+    def test_callable_double_wrapped_annotate_forwardref_value_fallback(self):
+        # The raw staticmethod object returns a 'wrapped' function, and so is
+        # @functools.cache. Here we test that functions unwrap recursively,
+        # allowing wrapping of wrapped functions.
+        class Annotate:
+            @staticmethod
+            @functools.cache
+            def format(format, /, __Format=Format,
+                       __NotImplementedError=NotImplementedError):
+                if format == __Format.VALUE:
+                    return {"x": random.random(), "y": str}
+                else:
+                    raise __NotImplementedError(format)
+
+        # Access the raw staticmethod object which wraps the cached function.
+        annotations = annotationlib.call_annotate_function(
+            Annotate.__dict__["format"],
+            Format.FORWARDREF,
+        )
+
+        self.assertIsInstance(annotations, dict)
+        self.assertIn("x", annotations)
+        self.assertIsInstance(annotations["x"], float)
+        self.assertIs(annotations["y"], str)
+
+        # Check annotations again to ensure that cache is working.
+        new_anns = annotationlib.call_annotate_function(Annotate.format, Format.FORWARDREF)
+        self.assertEqual(annotations, new_anns)
+
     def test_callable_wrapped_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