gh-124652: partialmethod simplifications

Lib/functools.py

@@ -315,52 +315,6 @@ def _partial_prepare_merger(args):
     merger = itemgetter(*order) if phcount else None
     return phcount, merger
 
-def _partial_new(cls, func, /, *args, **keywords):
-    if issubclass(cls, partial):
-        base_cls = partial
-        if not callable(func):
-            raise TypeError("the first argument must be callable")
-    else:
-        base_cls = partialmethod
-        # func could be a descriptor like classmethod which isn't callable
-        if not callable(func) and not hasattr(func, "__get__"):
-            raise TypeError(f"the first argument {func!r} must be a callable "
-                            "or a descriptor")
-    if args and args[-1] is Placeholder:
-        raise TypeError("trailing Placeholders are not allowed")
-    for value in keywords.values():
-        if value is Placeholder:
-            raise TypeError("Placeholder cannot be passed as a keyword argument")
-    if isinstance(func, base_cls):
-        pto_phcount = func._phcount
-        tot_args = func.args
-        if args:
-            tot_args += args
-            if pto_phcount:
-                # merge args with args of `func` which is `partial`
-                nargs = len(args)
-                if nargs < pto_phcount:
-                    tot_args += (Placeholder,) * (pto_phcount - nargs)
-                tot_args = func._merger(tot_args)
-                if nargs > pto_phcount:
-                    tot_args += args[pto_phcount:]
-            phcount, merger = _partial_prepare_merger(tot_args)
-        else:   # works for both pto_phcount == 0 and != 0
-            phcount, merger = pto_phcount, func._merger
-        keywords = {**func.keywords, **keywords}
-        func = func.func
-    else:
-        tot_args = args
-        phcount, merger = _partial_prepare_merger(tot_args)
-
-    self = object.__new__(cls)
-    self.func = func
-    self.args = tot_args
-    self.keywords = keywords
-    self._phcount = phcount
-    self._merger = merger
-    return self
-
 def _partial_repr(self):
     cls = type(self)
     module = cls.__module__
@@ -379,7 +333,44 @@ class partial:
     __slots__ = ("func", "args", "keywords", "_phcount", "_merger",
                  "__dict__", "__weakref__")
 
-    __new__ = _partial_new
+    def __new__(cls, func, /, *args, **keywords):
+        if not callable(func):
+            raise TypeError("the first argument must be callable")
+        if args and args[-1] is Placeholder:
+            raise TypeError("trailing Placeholders are not allowed")
+        for value in keywords.values():
+            if value is Placeholder:
+                raise TypeError("Placeholder cannot be passed as a keyword argument")
+        if isinstance(func, partial):
+            pto_phcount = func._phcount
+            tot_args = func.args
+            if args:
+                tot_args += args
+                if pto_phcount:
+                    # merge args with args of `func` which is `partial`
+                    nargs = len(args)
+                    if nargs < pto_phcount:
+                        tot_args += (Placeholder,) * (pto_phcount - nargs)
+                    tot_args = func._merger(tot_args)
+                    if nargs > pto_phcount:
+                        tot_args += args[pto_phcount:]
+                phcount, merger = _partial_prepare_merger(tot_args)
+            else:   # works for both pto_phcount == 0 and != 0
+                phcount, merger = pto_phcount, func._merger
+            keywords = {**func.keywords, **keywords}
+            func = func.func
+        else:
+            tot_args = args
+            phcount, merger = _partial_prepare_merger(tot_args)
+
+        self = object.__new__(cls)
+        self.func = func
+        self.args = tot_args
+        self.keywords = keywords
+        self._phcount = phcount
+        self._merger = merger
+        return self
+
     __repr__ = recursive_repr()(_partial_repr)
 
     def __call__(self, /, *args, **keywords):
@@ -444,6 +435,11 @@ def __setstate__(self, state):
 except ImportError:
     pass
 
+
+_PM_WRAPPED_METHOD_TYPES = (staticmethod, classmethod)
+_PM_FAST_METHOD_TYPES = _PM_WRAPPED_METHOD_TYPES + (FunctionType, partial)
+
+
 # Descriptor version
 class partialmethod:
     """Method descriptor with partial application of the given arguments
@@ -452,46 +448,116 @@ class partialmethod:
     Supports wrapping existing descriptors and handles non-descriptor
     callables as instance methods.
     """
-    __new__ = _partial_new
+    __slots__ = (
+        "_func", "_args", "_keywords", "__dict__", "__weakref__",
+        "_cachedmethod", "_iscacheable"
+    )
+
     __repr__ = _partial_repr
 
-    def _make_unbound_method(self):
-        def _method(cls_or_self, /, *args, **keywords):
-            phcount = self._phcount
-            if phcount:
-                try:
-                    pto_args = self._merger(self.args + args)
-                    args = args[phcount:]
-                except IndexError:
-                    raise TypeError("missing positional arguments "
-                                    "in 'partialmethod' call; expected "
-                                    f"at least {phcount}, got {len(args)}")
-            else:
-                pto_args = self.args
-            keywords = {**self.keywords, **keywords}
-            return self.func(cls_or_self, *pto_args, *args, **keywords)
-        _method.__isabstractmethod__ = self.__isabstractmethod__
-        _method.__partialmethod__ = self
-        return _method
+    def __init__(self, func, /, *args, **keywords):
+        if isinstance(func, partialmethod):
+            # Subclass optimization
+            temp = partial(lambda *_, **__: None, *func._args, **func.keywords)
+            temp = partial(temp, *args, **keywords)
+            func = func._func
+            args = temp.args
+            keywords = temp.keywords
+
+        if args and args[-1] is Placeholder:
+            raise TypeError("trailing Placeholders are not allowed")
+
+        self.func = func    # setting via attribute setter
+        self._args = args
+        self._keywords = keywords
+
+    @property
+    def func(self):
+        return self._func
+
+    @func.setter
+    def func(self, func):
+        if isinstance(func, _PM_FAST_METHOD_TYPES):
+            self._iscacheable = True
+        elif getattr(func, '__get__', None) is None:
+            if not callable(func):
+                raise TypeError(f'the first argument {func!r} must be a callable '
+                                'or a descriptor')
+            self._iscacheable = True
+        else:
+            self._iscacheable = False
+        self._func = func
+        self._cachedmethod = None
+
+    @property
+    def args(self):
+        return self._args
+
+    @args.setter
+    def args(self, args):
+        self._args = args
+        self._cachedmethod = None
+
+    @property
+    def keywords(self):
+        method = self._cachedmethod
+        if method is None:
+            return self._keywords
+        if isinstance(method, _PM_WRAPPED_METHOD_TYPES):
+            method = method.__wrapped__
+        return method.keywords
+
+    @keywords.setter
+    def keywords(self, keywords):
+        self._keywords = keywords
+        self._cachedmethod = None
+
+    def __make_method(self):
+        func = self._func
+        args = self._args
+        keywords = self._keywords
+        if isinstance(func, staticmethod):
+            deco = staticmethod
+            method = partial(func.__wrapped__, *args, **keywords)
+        elif isinstance(func, classmethod):
+            deco = classmethod
+            ph_args = (Placeholder,) if args else ()
+            method = partial(func.__wrapped__, *ph_args, *args, **keywords)
+        else:
+            # instance method. 2 cases:
+            #   a) FunctionType | partial
+            #   b) callable object without __get__
+            deco = None
+            ph_args = (Placeholder,) if args else ()
+            method = partial(func, *ph_args, *args, **keywords)
+
+        method.__partialmethod__ = self
+        if self.__isabstractmethod__:
+            method.__isabstractmethod__ = True
+        if deco is not None:
+            method = deco(method)
+        return method
 
     def __get__(self, obj, cls=None):
-        get = getattr(self.func, "__get__", None)
-        result = None
-        if get is not None:
-            new_func = get(obj, cls)
-            if new_func is not self.func:
-                # Assume __get__ returning something new indicates the
-                # creation of an appropriate callable
-                result = partial(new_func, *self.args, **self.keywords)
-                try:
-                    result.__self__ = new_func.__self__
-                except AttributeError:
-                    pass
-        if result is None:
-            # If the underlying descriptor didn't do anything, treat this
-            # like an instance method
-            result = self._make_unbound_method().__get__(obj, cls)
-        return result
+        method = self._cachedmethod
+        if method is None:
+            if not self._iscacheable:
+                # Unknown descriptor == unknown binding
+                # Need to get callable at runtime and apply partial on top
+                func = self._func
+                new_func = func.__get__(obj, cls)
+                if new_func is not func:
+                    result = partial(new_func, *self._args, **self._keywords)
+                    try:
+                        result.__self__ = new_func.__self__
+                    except AttributeError:
+                        pass
+                    return result
+
+            # Cache method
+            self._cachedmethod = method = self.__make_method()
+
+        return method.__get__(obj, cls)
 
     @property
     def __isabstractmethod__(self):
@@ -511,13 +577,14 @@ def _unwrap_partialmethod(func):
     prev = None
     while func is not prev:
         prev = func
-        while isinstance(getattr(func, "__partialmethod__", None), partialmethod):
-            func = func.__partialmethod__
-        while isinstance(func, partialmethod):
-            func = getattr(func, 'func')
-        func = _unwrap_partial(func)
+        __partialmethod__ = getattr(func, "__partialmethod__", None)
+        if isinstance(__partialmethod__, partialmethod):
+            func = __partialmethod__.func
+        if isinstance(func, (partial, partialmethod)):
+            func = func.func
     return func
 
+
 ################################################################################
 ### LRU Cache function decorator
 ################################################################################

Lib/inspect.py

@@ -2492,39 +2492,6 @@ def _signature_from_callable(obj, *,
                     'attribute'.format(sig))
             return sig
 
-    try:
-        partialmethod = obj.__partialmethod__
-    except AttributeError:
-        pass
-    else:
-        if isinstance(partialmethod, functools.partialmethod):
-            # Unbound partialmethod (see functools.partialmethod)
-            # This means, that we need to calculate the signature
-            # as if it's a regular partial object, but taking into
-            # account that the first positional argument
-            # (usually `self`, or `cls`) will not be passed
-            # automatically (as for boundmethods)
-
-            wrapped_sig = _get_signature_of(partialmethod.func)
-
-            sig = _signature_get_partial(wrapped_sig, partialmethod, (None,))
-            first_wrapped_param = tuple(wrapped_sig.parameters.values())[0]
-            if first_wrapped_param.kind is Parameter.VAR_POSITIONAL:
-                # First argument of the wrapped callable is `*args`, as in
-                # `partialmethod(lambda *args)`.
-                return sig
-            else:
-                sig_params = tuple(sig.parameters.values())
-                assert (not sig_params or
-                        first_wrapped_param is not sig_params[0])
-                # If there were placeholders set,
-                #   first param is transformed to positional only
-                if partialmethod.args.count(functools.Placeholder):
-                    first_wrapped_param = first_wrapped_param.replace(
-                        kind=Parameter.POSITIONAL_ONLY)
-                new_params = (first_wrapped_param,) + sig_params
-                return sig.replace(parameters=new_params)
-
     if isinstance(obj, functools.partial):
         wrapped_sig = _get_signature_of(obj.func)
         return _signature_get_partial(wrapped_sig, obj)

Lib/test/test_inspect/test_inspect.py

@@ -3913,8 +3913,10 @@ def test():
                 pass
             ham = partialmethod(test)
 
-        with self.assertRaisesRegex(ValueError, "has incorrect arguments"):
-            inspect.signature(Spam.ham)
+        self.assertEqual(self.signature(Spam.ham, eval_str=False),
+                         ((), Ellipsis))
+        with self.assertRaisesRegex(ValueError, "invalid method signature"):
+            inspect.signature(Spam().ham)
 
         class Spam:
             def test(it, a, b, *, c) -> 'spam':
@@ -3953,7 +3955,7 @@ def test(self: 'anno', x):
             g = partialmethod(test, 1)
 
         self.assertEqual(self.signature(Spam.g, eval_str=False),
-                         ((('self', ..., 'anno', 'positional_or_keyword'),),
+                         ((('self', ..., 'anno', 'positional_only'),),
                           ...))
 
     def test_signature_on_fake_partialmethod(self):

Misc/NEWS.d/next/Library/2024-10-17-00-50-32.gh-issue-124652.AK3PDp.rst

@@ -0,0 +1 @@
+:func:`functools.partialmethod` is now faster by making use of new :func:`functools.partial` placeholder functionality.