CR part 1

Author: dg-pb

Lib/functools.py

@@ -304,7 +304,7 @@ def _partial_prepare_merger(args):
     nargs = len(args)
     if not nargs:
         return 0, None
-    order = list()
+    order = []
     i, j = 0, nargs
     for a in args:
         if a is Placeholder:
@@ -319,20 +319,18 @@ def _partial_prepare_merger(args):
 
 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
         # assert issubclass(cls, partialmethod)
         if not callable(func) and not hasattr(func, "__get__"):
             raise TypeError(f"{func!r} is not callable or a descriptor")
-            # func could be a descriptor like classmethod which isn't callable,
-            # so we can't inherit from partial (it verifies func is callable)
-            # flattening is mandatory in order to place cls/self before all
-            # other arguments
-            # it's also more efficient since only one function will be called
     if args and args[-1] is Placeholder:
         raise TypeError("trailing Placeholders are not allowed")
-    if isinstance(func, cls):
+    if isinstance(func, base_cls):
         pto_phcount = func._phcount
         tot_args = func.args
         if args:
@@ -346,7 +344,7 @@ def _partial_new(cls, func, /, *args, **keywords):
                 if nargs > pto_phcount:
                     tot_args += args[pto_phcount:]
             phcount, merger = _partial_prepare_merger(tot_args)
-        elif pto_phcount:   # not args
+        elif pto_phcount:   # not args and pto_phcount
             phcount, merger = pto_phcount, func._merger
         else:               # not args and not pto_phcount
             phcount, merger = 0, None
@@ -386,7 +384,8 @@ class partial:
     __repr__ = recursive_repr()(_partial_repr)
 
     def __call__(self, /, *args, **keywords):
-        if phcount := self._phcount:
+        phcount = self._phcount
+        if phcount:
             try:
                 pto_args = self._merger(self.args + args)
                 args = args[phcount:]
@@ -456,7 +455,8 @@ class partialmethod:
 
     def _make_unbound_method(self):
         def _method(cls_or_self, /, *args, **keywords):
-            if phcount := self._phcount:
+            phcount = self._phcount
+            if phcount:
                 try:
                     pto_args = self._merger(self.args + args)
                     args = args[phcount:]

Lib/test/test_functools.py

@@ -510,6 +510,19 @@ def __str__(self):
         self.assertIn('astr', r)
         self.assertIn("['sth']", r)
 
+    def test_placeholders_refcount_smoke(self):
+        PH = self.module.Placeholder
+        # sum supports vector call
+        lst1, start = [], []
+        sum_lists = self.partial(sum, PH, start)
+        for i in range(10):
+            sum_lists([lst1, lst1])
+        # collections.ChainMap initializer does not support vectorcall
+        map1, map2 = {}, {}
+        partial_cm = self.partial(collections.ChainMap, PH, map1)
+        for i in range(10):
+            partial_cm(map2, map2)
+
 
 class TestPartialPy(TestPartial, unittest.TestCase):
     module = py_functools
@@ -534,6 +547,13 @@ class TestPartialCSubclass(TestPartialC):
 class TestPartialPySubclass(TestPartialPy):
     partial = PyPartialSubclass
 
+    def test_subclass_optimization(self):
+        p = py_functools.partial(min, 2)
+        p2 = self.partial(p, 1)
+        assert p2.func == min
+        assert p2(0) == 0
+
+
 class TestPartialMethod(unittest.TestCase):
 
     class A(object):
@@ -671,6 +691,14 @@ def f(a, b, /):
         p = functools.partial(f, 1)
         self.assertEqual(p(2), f(1, 2))
 
+    def test_subclass_optimization(self):
+        class PartialMethodSubclass(functools.partialmethod):
+            pass
+        p = functools.partialmethod(min, 2)
+        p2 = PartialMethodSubclass(p, 1)
+        assert p2.func == min
+        assert p2.__get__(0)() == 0
+
 
 class TestUpdateWrapper(unittest.TestCase):
 

Lib/test/test_inspect/test_inspect.py

@@ -3507,6 +3507,34 @@ def foo(a, b, /, c, d, **kwargs):
                            ('kwargs', ..., ..., 'var_keyword')),
                          ...))
 
+        # Positional only With Placeholder
+        p = partial(foo, Placeholder, 1, c=0, d=1)
+        self.assertEqual(self.signature(p),
+                         ((('a', ..., ..., "positional_only"),
+                           ('c', 0, ..., "keyword_only"),
+                           ('d', 1, ..., "keyword_only"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...))
+
+        # Optionals Positional With Placeholder
+        def foo(a=0, b=1, /, c=2, d=3):
+            pass
+
+        # Positional
+        p = partial(foo, Placeholder, 1, c=0, d=1)
+        self.assertEqual(self.signature(p),
+                         ((('a', 0, ..., "positional_only"),
+                           ('c', 0, ..., "keyword_only"),
+                           ('d', 1, ..., "keyword_only")),
+                          ...))
+
+        # Positional or Keyword - transformed to positional
+        p = partial(foo, Placeholder, 1, Placeholder, 1)
+        self.assertEqual(self.signature(p),
+                         ((('a', 0, ..., "positional_only"),
+                           ('c', 2, ..., "positional_only")),
+                          ...))
+
     def test_signature_on_partialmethod(self):
         from functools import partialmethod
 

Modules/_functoolsmodule.c

@@ -194,7 +194,7 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
     pto->fn = Py_NewRef(func);
 
     pto->placeholder = state->placeholder;
-    if (new_nargs && Py_Is(PyTuple_GET_ITEM(args, new_nargs), pto->placeholder)) {
+    if (new_nargs && PyTuple_GET_ITEM(args, new_nargs) == pto->placeholder) {
         PyErr_SetString(PyExc_TypeError,
                         "trailing Placeholders are not allowed");
         return NULL;
@@ -214,7 +214,7 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
         }
     }
     /* merge args with args of `func` which is `partial` */
-    if ((pto_phcount > 0) && (new_nargs > 0)) {
+    if (pto_phcount > 0 && new_nargs > 0) {
         Py_ssize_t npargs = PyTuple_GET_SIZE(pto_args);
         Py_ssize_t tot_nargs = npargs;
         if (new_nargs > pto_phcount) {
@@ -409,7 +409,7 @@ partial_vectorcall(partialobject *pto, PyObject *const *args,
         tot_nargs = pto_nargs + nargs - pto_phcount;
         Py_ssize_t j = 0;       // New args index
         for (Py_ssize_t i = 0; i < pto_nargs; i++) {
-            if (Py_Is(pto_args[i], pto->placeholder)){
+            if (pto_args[i] == pto->placeholder){
                 stack[i] = args[j];
                 j += 1;
             }
@@ -508,19 +508,19 @@ partial_call(partialobject *pto, PyObject *args, PyObject *kwargs)
         Py_ssize_t j = 0;   // New args index
         for (Py_ssize_t i = 0; i < pto_nargs; i++) {
             item = PyTuple_GET_ITEM(pto_args, i);
-            if (Py_Is(item, pto->placeholder)) {
+            if (item == pto->placeholder) {
                 item = PyTuple_GET_ITEM(args, j);
                 j += 1;
             }
+            Py_INCREF(item);
             PyTuple_SET_ITEM(tot_args, i, item);
         }
         assert(j == pto_phcount);
-        if (nargs > pto_phcount) {
-            for (Py_ssize_t i = pto_nargs; i < tot_nargs; i++) {
-                item = PyTuple_GET_ITEM(args, j);
-                PyTuple_SET_ITEM(tot_args, i, item);
-                j += 1;
-            }
+        for (Py_ssize_t i = pto_nargs; i < tot_nargs; i++) {
+            item = PyTuple_GET_ITEM(args, j);
+            Py_INCREF(item);
+            PyTuple_SET_ITEM(tot_args, i, item);
+            j += 1;
         }
     }
     else {
@@ -670,15 +670,15 @@ partial_setstate(partialobject *pto, PyObject *state)
     }
 
     Py_ssize_t nargs = PyTuple_GET_SIZE(fnargs);
-    if (nargs && Py_Is(PyTuple_GET_ITEM(fnargs, nargs - 1), pto->placeholder)) {
+    if (nargs && PyTuple_GET_ITEM(fnargs, nargs - 1) == pto->placeholder) {
         PyErr_SetString(PyExc_TypeError,
                         "trailing Placeholders are not allowed");
         return NULL;
     }
     /* Count placeholders */
     Py_ssize_t phcount = 0;
     for (Py_ssize_t i = 0; i < nargs - 1; i++) {
-        if (Py_Is(PyTuple_GET_ITEM(fnargs, i), pto->placeholder)) {
+        if (PyTuple_GET_ITEM(fnargs, i), pto->placeholder) {
             phcount++;
         }
     }