trailing placeholder restriction removed

Author: dg-pb

Lib/functools.py

@@ -334,16 +334,6 @@ class partial:
     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:
-            # Trim trailing placeholders
-            j = len(args) - 1
-            if not j:
-                args = ()
-            else:
-                while (j := j - 1) >= 0:
-                    if args[j] is not Placeholder:
-                        break
-                args = args[:j + 1]
         if isinstance(func, partial):
             pto_phcount = func._phcount
             tot_args = func.args
@@ -411,8 +401,8 @@ def __setstate__(self, state):
            (namespace is not None and not isinstance(namespace, dict))):
             raise TypeError("invalid partial state")
 
-        if args and args[-1] is Placeholder:
-            raise TypeError("unexpected trailing Placeholders")
+        # if args and args[-1] is Placeholder:
+        #     raise TypeError("unexpected trailing Placeholders")
         phcount, merger = _partial_prepare_merger(args)
 
         args = tuple(args) # just in case it's a subclass
@@ -435,6 +425,7 @@ def __setstate__(self, state):
 except ImportError:
     pass
 
+
 # Descriptor version
 class partialmethod:
     """Method descriptor with partial application of the given arguments
@@ -446,50 +437,49 @@ class partialmethod:
 
     __slots__ = ("func", "args", "keywords", "wrapper",
                  "__isabstractmethod__", "__dict__", "__weakref__")
+
     __repr__ = _partial_repr
+    __class_getitem__ = classmethod(GenericAlias)
 
     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)
+            isabstract = func.__isabstractmethod__
             func = func.func
             args = temp.args
             keywords = temp.keywords
+        else:
+            isabstract = getattr(func, '__isabstractmethod__', False)
         self.func = func
         self.args = args
         self.keywords = keywords
-        self.__isabstractmethod__ = getattr(func, "__isabstractmethod__", False)
+        self.__isabstractmethod__ = isabstract
 
         # 5 cases
-        rewrap = None
         if isinstance(func, staticmethod):
-            self.wrapper = partial(func.__wrapped__, *args, **keywords)
-            rewrap = staticmethod
+            wrapper = partial(func.__wrapped__, *args, **keywords)
+            self.wrapper = _rewrap_func(wrapper, isabstract, staticmethod)
         elif isinstance(func, classmethod):
-            self.wrapper = partial(func.__wrapped__, Placeholder, *args, **keywords)
-            rewrap = classmethod
+            wrapper = _partial_unbound(func.__wrapped__, args, keywords)
+            self.wrapper = _rewrap_func(wrapper, isabstract, classmethod)
         elif isinstance(func, (FunctionType, partial)):
             # instance method
-            self.wrapper = partial(func, Placeholder, *args, **keywords)
+            wrapper = _partial_unbound(func, args, keywords)
+            self.wrapper = _rewrap_func(wrapper, isabstract)
         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")
             # callable object without __get__
             # treat this like an instance method
-            self.wrapper = partial(func, Placeholder, *args, **keywords)
+            if not callable(func):
+                raise TypeError(f'the first argument {func!r} must be a callable '
+                                'or a descriptor')
+            wrapper = _partial_unbound(func, args, keywords)
+            self.wrapper = _rewrap_func(wrapper, isabstract)
         else:
             # Unknown descriptor
             self.wrapper = None
 
-        # Adjust for abstract and rewrap if needed
-        if self.wrapper is not None:
-            if self.__isabstractmethod__:
-                self.wrapper = abstractmethod(self.wrapper)
-            if rewrap is not None:
-                self.wrapper = rewrap(self.wrapper)
-
     def __get__(self, obj, cls=None):
         if self.wrapper is not None:
             return self.wrapper.__get__(obj, cls)
@@ -503,25 +493,32 @@ def __get__(self, obj, cls=None):
                 pass
             return result
 
-    __class_getitem__ = classmethod(GenericAlias)
-
 
 # Helper functions
 
+def _partial_unbound(func, args, keywords):
+    if not args:
+        return partial(func, **keywords)
+    return partial(func, Placeholder, *args, **keywords)
+
+def _rewrap_func(func, isabstract, decorator=None):
+    if isabstract:
+        func = abstractmethod(func)
+    if decorator is not None:
+        func = decorator(func)
+    return func
+
 def _unwrap_partial(func):
     while isinstance(func, partial):
         func = func.func
     return func
 
 def _unwrap_partialmethod(func):
-    prev = None
-    while func is not prev:
-        prev = func
-        while isinstance(func, partialmethod):
-            func = getattr(func, 'func')
-        func = _unwrap_partial(func)
+    while isinstance(func, (partial, partialmethod)):
+        func = func.func
     return func
 
+
 ################################################################################
 ### LRU Cache function decorator
 ################################################################################

Lib/test/test_functools.py

@@ -211,16 +211,16 @@ def foo(bar):
         p2.new_attr = 'spam'
         self.assertEqual(p2.new_attr, 'spam')
 
-    def test_placeholders_trailing_trim(self):
-        PH = self.module.Placeholder
-        for args, call_args, expected_args in [
-                    [(PH,), (), ()],
-                    [(0, PH), (), (0,)],
-                    [(0, PH, 1, PH, PH, PH), (2,), (0, 2, 1)]
-                ]:
-            actual_args, actual_kwds = self.partial(capture, *args)(*call_args)
-            self.assertEqual(actual_args, expected_args)
-            self.assertEqual(actual_kwds, {})
+    # def test_placeholders_trailing_trim(self):
+    #     PH = self.module.Placeholder
+    #     for args, call_args, expected_args in [
+    #                 [(PH,), (), ()],
+    #                 [(0, PH), (), (0,)],
+    #                 [(0, PH, 1, PH, PH, PH), (2,), (0, 2, 1)]
+    #             ]:
+    #         actual_args, actual_kwds = self.partial(capture, *args)(*call_args)
+    #         self.assertEqual(actual_args, expected_args)
+    #         self.assertEqual(actual_kwds, {})
 
     def test_placeholders(self):
         PH = self.module.Placeholder
@@ -373,11 +373,11 @@ def test_setstate(self):
             f()
         self.assertEqual(f(2), ((2, 1), dict(a=10)))
 
-        # Trailing Placeholder error
-        f = self.partial(signature)
-        msg_regex = re.escape("unexpected trailing Placeholders")
-        with self.assertRaisesRegex(TypeError, f'^{msg_regex}$') as cm:
-            f.__setstate__((capture, (1, PH), dict(a=10), dict(attr=[])))
+        # # Trailing Placeholder error
+        # f = self.partial(signature)
+        # msg_regex = re.escape("unexpected trailing Placeholders")
+        # with self.assertRaisesRegex(TypeError, f'^{msg_regex}$') as cm:
+        #     f.__setstate__((capture, (1, PH), dict(a=10), dict(attr=[])))
 
     def test_setstate_errors(self):
         f = self.partial(signature)

Lib/test/test_inspect/test_inspect.py

@@ -3671,7 +3671,7 @@ def test():
         self.assertEqual(self.signature(Spam.ham, eval_str=False),
                          ((), Ellipsis))
         with self.assertRaisesRegex(ValueError, "invalid method signature"):
-             inspect.signature(Spam().ham)
+            inspect.signature(Spam().ham)
 
         class Spam:
             def test(it, a, b, *, c) -> 'spam':

Modules/_functoolsmodule.c

@@ -213,13 +213,7 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
     pto->fn = Py_NewRef(func);
     pto->placeholder = phold;
 
-    /* Get new_args with trailing Placeholders trimmed */
-    while (new_nargs > 0 && PyTuple_GET_ITEM(args, new_nargs) == phold) {
-        new_nargs--;
-    }
-
     /* process args */
-    Py_ssize_t phcount = 0;
     if (new_nargs == 0) {
         if (pto_args == NULL) {
             pto->args = PyTuple_New(0);
@@ -234,7 +228,8 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
     }
     else {
         /* Count placeholders */
-        for (Py_ssize_t i = 0; i < new_nargs - 1; i++) {
+        Py_ssize_t phcount = 0;
+        for (Py_ssize_t i = 0; i < new_nargs; i++) {
             if (PyTuple_GET_ITEM(args, i + 1) == phold) {
                 phcount++;
             }
@@ -414,6 +409,12 @@ partial_vectorcall(partialobject *pto, PyObject *const *args,
                                           pto_args, pto_nargs, NULL);
     }
 
+    /* Fast path if all Placeholders */
+    if (pto_nargs == pto_phcount) {
+        return _PyObject_VectorcallTstate(tstate, pto->fn,
+                                          args, nargs, kwnames);
+    }
+
     /* Fast path using PY_VECTORCALL_ARGUMENTS_OFFSET to prepend a single
      * positional argument */
     if (pto_nargs == 1 && (nargsf & PY_VECTORCALL_ARGUMENTS_OFFSET)) {
@@ -701,11 +702,6 @@ partial_setstate(partialobject *pto, PyObject *state)
         return NULL;
     }
 
-    Py_ssize_t nargs = PyTuple_GET_SIZE(fnargs);
-    if (nargs && PyTuple_GET_ITEM(fnargs, nargs - 1) == pto->placeholder) {
-        PyErr_SetString(PyExc_TypeError, "unexpected trailing Placeholders");
-        return NULL;
-    }
     /* Count placeholders */
     Py_ssize_t phcount = 0;
     for (Py_ssize_t i = 0; i < nargs - 1; i++) {