fix review idea

Signed-off-by: Manjusaka <me@manjusaka.me>

Author: Zheaoli

Lib/annotationlib.py

@@ -1062,141 +1062,11 @@ def annotations_to_string(annotations):
     }
 
 
-def _get_annotations_for_partialmethod(partialmethod_obj, format):
-    """Get annotations for a functools.partialmethod object.
-
-    Returns annotations for the wrapped function, but only for parameters
-    that haven't been bound by the partial application. The first parameter
-    (usually 'self' or 'cls') is kept since partialmethod is unbound.
-    """
-    import inspect
-
-    # Get the wrapped function
-    func = partialmethod_obj.func
-
-    # Get annotations from the wrapped function
-    func_annotations = get_annotations(func, format=format)
-
-    if not func_annotations:
-        return {}
-
-    # For partialmethod, we need to simulate the signature calculation
-    # The first parameter (self/cls) should remain, but bound args should be removed
-    try:
-        # Get the function signature
-        func_sig = inspect.signature(func)
-        func_params = list(func_sig.parameters.keys())
-
-        if not func_params:
-            return func_annotations
-
-        # Calculate which parameters are bound by the partialmethod
-        partial_args = partialmethod_obj.args or ()
-        partial_keywords = partialmethod_obj.keywords or {}
-
-        # Build new annotations dict in proper order
-        # (parameters first, then return)
-        new_annotations = {}
-
-        # The first parameter (self/cls) is always kept for unbound partialmethod
-        first_param = func_params[0]
-        if first_param in func_annotations:
-            new_annotations[first_param] = func_annotations[first_param]
-
-        # For partialmethod, positional args bind to parameters AFTER the first one
-        # So if func is (self, a, b, c) and partialmethod.args=(1,)
-        # Then 'self' stays, 'a' is bound, 'b' and 'c' remain
-
-        remaining_params = func_params[1:]
-        num_positional_bound = len(partial_args)
-
-        for i, param_name in enumerate(remaining_params):
-            # Skip if this param is bound positionally
-            if i < num_positional_bound:
-                continue
-
-            # For keyword binding: keep the annotation (keyword sets default, doesn't remove param)
-            if param_name in partial_keywords:
-                if param_name in func_annotations:
-                    new_annotations[param_name] = func_annotations[param_name]
-                continue
-
-            # This parameter is not bound, keep its annotation
-            if param_name in func_annotations:
-                new_annotations[param_name] = func_annotations[param_name]
-
-        # Add return annotation at the end
-        if 'return' in func_annotations:
-            new_annotations['return'] = func_annotations['return']
-
-        return new_annotations
-
-    except (ValueError, TypeError):
-        # If we can't process, return the original annotations
-        return func_annotations
-
-
-def _get_annotations_for_partial(partial_obj, format):
-    """Get annotations for a functools.partial object.
-
-    Returns annotations for the wrapped function, but only for parameters
-    that haven't been bound by the partial application.
-    """
-    import inspect
-
-    # Get the wrapped function
-    func = partial_obj.func
-
-    # Get annotations from the wrapped function
-    func_annotations = get_annotations(func, format=format)
-
-    if not func_annotations:
-        return {}
-
-    # Get the signature to determine which parameters are bound
-    try:
-        sig = inspect.signature(partial_obj)
-    except (ValueError, TypeError):
-        # If we can't get signature, return empty dict
-        return {}
-
-    # Build new annotations dict with only unbound parameters
-    # (parameters first, then return)
-    new_annotations = {}
-
-    # Only include annotations for parameters that still exist in partial's signature
-    for param_name in sig.parameters:
-        if param_name in func_annotations:
-            new_annotations[param_name] = func_annotations[param_name]
-
-    # Add return annotation at the end
-    if 'return' in func_annotations:
-        new_annotations['return'] = func_annotations['return']
-
-    return new_annotations
-
-
 def _get_and_call_annotate(obj, format):
     """Get the __annotate__ function and call it.
 
     May not return a fresh dictionary.
     """
-    import functools
-
-    # Handle functools.partialmethod objects (unbound)
-    # Check for __partialmethod__ attribute first
-    try:
-        partialmethod = obj.__partialmethod__
-    except AttributeError:
-        pass
-    else:
-        if isinstance(partialmethod, functools.partialmethod):
-            return _get_annotations_for_partialmethod(partialmethod, format)
-
-    # Handle functools.partial objects
-    if isinstance(obj, functools.partial):
-        return _get_annotations_for_partial(obj, format)
-
     annotate = getattr(obj, "__annotate__", None)
     if annotate is not None:
         ann = call_annotate_function(annotate, format, owner=obj)
@@ -1214,21 +1084,6 @@ def _get_dunder_annotations(obj):
 
     Does not return a fresh dictionary.
     """
-    # Check for functools.partialmethod - skip __annotations__ and use __annotate__ path
-    import functools
-    try:
-        partialmethod = obj.__partialmethod__
-        if isinstance(partialmethod, functools.partialmethod):
-            # Return None to trigger _get_and_call_annotate
-            return None
-    except AttributeError:
-        pass
-
-    # Check for functools.partial - skip __annotations__ and use __annotate__ path
-    if isinstance(obj, functools.partial):
-        # Return None to trigger _get_and_call_annotate
-        return None
-
     # This special case is needed to support types defined under
     # from __future__ import annotations, where accessing the __annotations__
     # attribute directly might return annotations for the wrong class.

Lib/functools.py

@@ -467,6 +467,8 @@ def _method(cls_or_self, /, *args, **keywords):
             return self.func(cls_or_self, *pto_args, *args, **keywords)
         _method.__isabstractmethod__ = self.__isabstractmethod__
         _method.__partialmethod__ = self
+        # Set __annotate__ to delegate to the partialmethod's __annotate__
+        _method.__annotate__ = self.__annotate__
         return _method
 
     def __get__(self, obj, cls=None):
@@ -492,6 +494,10 @@ def __get__(self, obj, cls=None):
     def __isabstractmethod__(self):
         return getattr(self.func, "__isabstractmethod__", False)
 
+    def __annotate__(self, format):
+        """Return annotations for the partial method."""
+        return _partialmethod_annotate(self, format)
+
     __class_getitem__ = classmethod(GenericAlias)
 
 
@@ -513,6 +519,123 @@ def _unwrap_partialmethod(func):
         func = _unwrap_partial(func)
     return func
 
+def _partial_annotate(partial_obj, format):
+    """Helper function to compute annotations for a partial object.
+
+    This is called by the __annotate__ descriptor defined in C.
+    Returns annotations for the wrapped function, but only for parameters
+    that haven't been bound by the partial application.
+    """
+    import inspect
+    from annotationlib import get_annotations
+
+    # Get the wrapped function
+    func = partial_obj.func
+
+    # Get annotations from the wrapped function
+    func_annotations = get_annotations(func, format=format)
+
+    if not func_annotations:
+        return {}
+
+    # Get the signature to determine which parameters are bound
+    try:
+        sig = inspect.signature(partial_obj)
+    except (ValueError, TypeError):
+        # If we can't get signature, return empty dict
+        return {}
+
+    # Build new annotations dict with only unbound parameters
+    # (parameters first, then return)
+    new_annotations = {}
+
+    # Only include annotations for parameters that still exist in partial's signature
+    for param_name in sig.parameters:
+        if param_name in func_annotations:
+            new_annotations[param_name] = func_annotations[param_name]
+
+    # Add return annotation at the end
+    if 'return' in func_annotations:
+        new_annotations['return'] = func_annotations['return']
+
+    return new_annotations
+
+def _partialmethod_annotate(partialmethod_obj, format):
+    """Helper function to compute annotations for a partialmethod object.
+
+    This is called when accessing annotations on an unbound partialmethod
+    (via the __partialmethod__ attribute).
+    Returns annotations for the wrapped function, but only for parameters
+    that haven't been bound by the partial application. The first parameter
+    (usually 'self' or 'cls') is kept since partialmethod is unbound.
+    """
+    import inspect
+    from annotationlib import get_annotations
+
+    # Get the wrapped function
+    func = partialmethod_obj.func
+
+    # Get annotations from the wrapped function
+    func_annotations = get_annotations(func, format=format)
+
+    if not func_annotations:
+        return {}
+
+    # For partialmethod, we need to simulate the signature calculation
+    # The first parameter (self/cls) should remain, but bound args should be removed
+    try:
+        # Get the function signature
+        func_sig = inspect.signature(func)
+        func_params = list(func_sig.parameters.keys())
+
+        if not func_params:
+            return func_annotations
+
+        # Calculate which parameters are bound by the partialmethod
+        partial_args = partialmethod_obj.args or ()
+        partial_keywords = partialmethod_obj.keywords or {}
+
+        # Build new annotations dict in proper order
+        # (parameters first, then return)
+        new_annotations = {}
+
+        # The first parameter (self/cls) is always kept for unbound partialmethod
+        first_param = func_params[0]
+        if first_param in func_annotations:
+            new_annotations[first_param] = func_annotations[first_param]
+
+        # For partialmethod, positional args bind to parameters AFTER the first one
+        # So if func is (self, a, b, c) and partialmethod.args=(1,)
+        # Then 'self' stays, 'a' is bound, 'b' and 'c' remain
+
+        remaining_params = func_params[1:]
+        num_positional_bound = len(partial_args)
+
+        for i, param_name in enumerate(remaining_params):
+            # Skip if this param is bound positionally
+            if i < num_positional_bound:
+                continue
+
+            # For keyword binding: keep the annotation (keyword sets default, doesn't remove param)
+            if param_name in partial_keywords:
+                if param_name in func_annotations:
+                    new_annotations[param_name] = func_annotations[param_name]
+                continue
+
+            # This parameter is not bound, keep its annotation
+            if param_name in func_annotations:
+                new_annotations[param_name] = func_annotations[param_name]
+
+        # Add return annotation at the end
+        if 'return' in func_annotations:
+            new_annotations['return'] = func_annotations['return']
+
+        return new_annotations
+
+    except (ValueError, TypeError):
+        # If we can't process, return the original annotations
+        return func_annotations
+
 ################################################################################
 ### LRU Cache function decorator
 ################################################################################

Modules/_functoolsmodule.c

@@ -360,6 +360,32 @@ partial_descr_get(PyObject *self, PyObject *obj, PyObject *type)
     return PyMethod_New(self, obj);
 }
 
+static PyObject *
+partial_annotate(PyObject *self, PyObject *format_obj)
+{
+    /* Delegate to Python functools._partial_annotate helper */
+    PyObject *functools = NULL, *helper = NULL, *result = NULL;
+
+    /* Import functools module */
+    functools = PyImport_ImportModule("functools");
+    if (functools == NULL) {
+        return NULL;
+    }
+
+    /* Get the _partial_annotate function */
+    helper = PyObject_GetAttrString(functools, "_partial_annotate");
+    Py_DECREF(functools);
+    if (helper == NULL) {
+        return NULL;
+    }
+
+    /* Call _partial_annotate(self, format) */
+    result = PyObject_CallFunctionObjArgs(helper, self, format_obj, NULL);
+    Py_DECREF(helper);
+
+    return result;
+}
+
 static PyObject *
 partial_vectorcall(PyObject *self, PyObject *const *args,
                    size_t nargsf, PyObject *kwnames)
@@ -832,6 +858,7 @@ partial_setstate(PyObject *self, PyObject *state)
 static PyMethodDef partial_methods[] = {
     {"__reduce__", partial_reduce, METH_NOARGS},
     {"__setstate__", partial_setstate, METH_O},
+    {"__annotate__", partial_annotate, METH_O},
     {"__class_getitem__",    Py_GenericAlias,
     METH_O|METH_CLASS,       PyDoc_STR("See PEP 585")},
     {NULL,              NULL}           /* sentinel */