Initial Implementation

python · dg-pb · May 21, 2024 · May 21, 2024 · May 21, 2024 · May 21, 2024
commit ee7333c124cfcf1abb9eccbc4b52969f443fa59d
@@ -273,6 +273,11 @@ def reduce(function, sequence, initial=_initial_missing):
 ### partial() argument application
 ################################################################################
 
+
+class Placeholder:
+    """placeholder for partial arguments"""
+
+
 # Purely functional, no descriptor behaviour
 class partial:
     """New function with partial application of the given arguments
@@ -285,8 +290,33 @@ def __new__(cls, func, /, *args, **keywords):
         if not callable(func):
             raise TypeError("the first argument must be callable")
 
+        np = 0
+        nargs = len(args)
+        if args:
+            while nargs and args[nargs-1] is Placeholder:
+                nargs -= 1
+            args = args[:nargs]
+            np = args.count(Placeholder)
         if isinstance(func, partial):
-            args = func.args + args
+            pargs = func.args
+            pnp = func.np
+            if pnp and args:
+                all_args = list(pargs)
+                nargs = len(args)
+                j, pos = 0, 0
+                end = nargs if nargs < pnp else pnp
+                while j < end:
+                    pos = all_args.index(Placeholder, pos)
+                    all_args[pos] = args[j]
+                    j += 1
+                    pos += 1
+                if pnp < nargs:
+                    all_args.extend(args[pnp:])
+                np += pnp - end
+                args = tuple(all_args)
+            else:
+                np += pnp
+                args = func.args + args
             keywords = {**func.keywords, **keywords}
             func = func.func
 
@@ -295,11 +325,25 @@ def __new__(cls, func, /, *args, **keywords):
         self.func = func
         self.args = args
         self.keywords = keywords
+        self.np = np
         return self
 
     def __call__(self, /, *args, **keywords):
-        keywords = {**self.keywords, **keywords}
-        return self.func(*self.args, *args, **keywords)
+        if np := self.np:
+            if len(args) < np:
+                raise ValueError("unfilled placeholders in 'partial' call")
+            f_args = list(self.args)
+            j, pos = 0, 0
+            while j < np:
+                pos = f_args.index(Placeholder, pos)
+                f_args[pos] = args[j]
+                j += 1
+                pos += 1
+            keywords = {**self.keywords, **keywords}
+            return self.func(*f_args, *args[np:], **keywords)
+        else:
+            keywords = {**self.keywords, **keywords}
+            return self.func(*self.args, *args, **keywords)
 
     @recursive_repr()
     def __repr__(self):
@@ -340,7 +384,7 @@ def __setstate__(self, state):
         self.keywords = kwds
 
 try:
-    from _functools import partial
+    from _functools import partial, Placeholder
 except ImportError:
     pass
 

@@ -41,13 +41,31 @@ get_functools_state(PyObject *module)
 
 /* partial object **********************************************************/
 
+
+typedef struct {
+    PyObject_HEAD
+} placeholderobject;
+
+
+static PyTypeObject placeholder_type = {
+    .ob_base = PyVarObject_HEAD_INIT(NULL, 0)
+    .tp_name = "functools.Placeholder",
+    .tp_doc = PyDoc_STR("placeholder for partial arguments"),
+    .tp_basicsize = sizeof(placeholderobject),
+    .tp_itemsize = 0,
+    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION,
+    .tp_new = PyType_GenericNew,
+};
+
+
 typedef struct {
     PyObject_HEAD
     PyObject *fn;
     PyObject *args;
     PyObject *kw;
     PyObject *dict;        /* __dict__ */
     PyObject *weakreflist; /* List of weak references */
+    Py_ssize_t np;         /* Number of placeholders */
     vectorcallfunc vectorcall;
 } partialobject;
 
@@ -72,6 +90,7 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 {
     PyObject *func, *pargs, *nargs, *pkw;
     partialobject *pto;
+    Py_ssize_t pnp = 0;
 
     if (PyTuple_GET_SIZE(args) < 1) {
         PyErr_SetString(PyExc_TypeError,
@@ -98,6 +117,7 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
             pargs = part->args;
             pkw = part->kw;
             func = part->fn;
+            pnp = part->np;
             assert(PyTuple_Check(pargs));
             assert(PyDict_Check(pkw));
         }
@@ -120,11 +140,57 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
         Py_DECREF(pto);
         return NULL;
     }
-    if (pargs == NULL) {
-        pto->args = nargs;
+    Py_ssize_t nnp = 0;
+    Py_ssize_t nnargs = PyTuple_GET_SIZE(nargs);
+    Py
8000
Object *item;
+    if (nnargs > 0){
+        Py_ssize_t i;
+        for (i=nnargs; i > 0; i--) {
+            item = PyTuple_GET_ITEM(nargs, i);
+            if (!Py_Is(item, (PyObject *) &placeholder_type))
+                break;
+        }
+        if (i != nnargs)
+            nnargs = i;
+
+        if (nnargs > 0){
+            for (Py_ssize_t i=0; i < nnargs; i++){
+                item = PyTuple_GET_ITEM(nargs, i);
+                nnp += Py_Is(item, (PyObject *) &placeholder_type);
+            }
+        }
     }
-    else {
+    if ((pnp > 0) & (nnargs > 0)) {
+        Py_ssize_t pnargs = PyTuple_GET_SIZE(pargs);
+        Py_ssize_t anargs = pnargs;
+        if (nnargs > pnp)
+            anargs += nnargs - pnp;
+        PyObject *aargs = PyTuple_New(anargs);
+        Py_ssize_t j = 0;
+        for (Py_ssize_t i=0; i < anargs; i++) {
+            if (i < pnargs) {
+                item = PyTuple_GET_ITEM(pargs, i);
+                if ((j < nnargs) & Py_Is(item, (PyObject *) &placeholder_type)){
+                    item = PyTuple_GET_ITEM(nargs, j);
+                    j++;
+                    pnp--;
+                }
+            } else {
+                item = PyTuple_GET_ITEM(nargs, j);
+                j++;
+            }
+            Py_INCREF(item);
+            PyTuple_SET_ITEM(aargs, i, item);
+        }
+        pto->args = aargs;
+        pto->np = pnp + nnp;
+        Py_DECREF(nargs);
+    } else if (pargs == NULL) {
+        pto->args = nargs;
+        pto->np = nnp;
+    } else {
         pto->args = PySequence_Concat(pargs, nargs);
+        pto->np = pnp + nnp;
         Py_DECREF(nargs);
         if (pto->args == NULL) {
             Py_DECREF(pto);
@@ -217,13 +283,19 @@ partial_vectorcall(partialobject *pto, PyObject *const *args,
                    size_t nargsf, PyObject *kwnames)
 {
     PyThreadState *tstate = _PyThreadState_GET();
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
 
     /* pto->kw is mutable, so need to check every time */
     if (PyDict_GET_SIZE(pto->kw)) {
         return partial_vectorcall_fallback(tstate, pto, args, nargsf, kwnames);
     }
+    Py_ssize_t np = pto->np;
+    if (nargs < np) {
+        PyErr_SetString(PyExc_TypeError,
+                        "unfilled placeholders in 'partial' call");
+        return NULL;
+    }
 
-    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
     Py_ssize_t nargs_total = nargs;
     if (kwnames != NULL) {
         nargs_total += PyTuple_GET_SIZE(kwnames);
@@ -251,6 +323,7 @@ partial_vectorcall(partialobject *pto, PyObject *const *args,
     }
 
     Py_ssize_t newnargs_total = pto_nargs + nargs_total;
+    newnargs_total = newnargs_total - np;
 
     PyObject *small_stack[_PY_FASTCALL_SMALL_STACK];
     PyObject *ret;
@@ -267,12 +340,28 @@ partial_vectorcall(partialobject *pto, PyObject *const *args,
         }
     }
 
-    /* Copy to new stack, using borrowed references */
-    memcpy(stack, pto_args, pto_nargs * sizeof(PyObject*));
-    memcpy(stack + pto_nargs, args, nargs_total * sizeof(PyObject*));
-
-    ret = _PyObject_VectorcallTstate(tstate, pto->fn,
-                                     stack, pto_nargs + nargs, kwnames);
+    Py_ssize_t nargs_new;
+    if (np) {
+        nargs_new = pto_nargs + nargs - np;
+        Py_ssize_t j = 0;   // Placeholder counter
+        for (Py_ssize_t i=0; i < pto_nargs; i++) {
+            if (Py_Is(pto_args[i], (PyObject *) &placeholder_type)){
+                memcpy(stack + i, args + j, 1 * sizeof(PyObject*));
+                j += 1;
+            } else {
+                memcpy(stack + i, pto_args + i, 1 * sizeof(PyObject*));
+            }
+        }
+        if (nargs_total > np){
+            memcpy(stack + pto_nargs, args + np, (nargs_total - np) * sizeof(PyObject*));
+        }
+    } else {
+        nargs_new = pto_nargs + nargs;
+        /* Copy to new stack, using borrowed references */
+        memcpy(stack, pto_args, pto_nargs * sizeof(PyObject*));
+        memcpy(stack + pto_nargs, args, nargs_total * sizeof(PyObject*));
+    }
+    ret = _PyObject_VectorcallTstate(tstate, pto->fn, stack, nargs_new, kwnames);
     if (stack != small_stack) {
         PyMem_Free(stack);
     }
@@ -304,6 +393,14 @@ partial_call(partialobject *pto, PyObject *args, PyObject *kwargs)
     assert(PyTuple_Check(pto->args));
     assert(PyDict_Check(pto->kw));
 
+    Py_ssize_t nargs = PyTuple_GET_SIZE(args);
+    Py_ssize_t np = pto->np;
+    if (nargs < np) {
+        PyErr_SetString(PyExc_TypeError,
+                        "unfilled placeholders in 'partial' call");
+        return NULL;
+    }
+
     /* Merge keywords */
     PyObject *kwargs2;
     if (PyDict_GET_SIZE(pto->kw) == 0) {
@@ -328,8 +425,33 @@ partial_call(partialobject *pto, PyObject *args, PyObject *kwargs)
     }
 
     /* Merge positional arguments */
-    /* Note: tupleconcat() is optimized for empty tuples */
-    PyObject *args2 = PySequence_Concat(pto->args, args);
+    PyObject *args2;
+    if (np) {
+        Py_ssize_t pto_nargs = PyTuple_GET_SIZE(pto->args);
+        Py_ssize_t nargs_new = pto_nargs + nargs - np;
+        args2 = PyTuple_New(nargs_new);
+        PyObject *pto_args = pto->args;
+        PyObject *item;
+        Py_ssize_t j = 0;   // Placeholder counter
+        for (Py_ssize_t i=0; i < pto_nargs; i++) {
+            item = PyTuple_GET_ITEM(pto_args, i);
+            if (Py_Is(item, (PyObject *) &placeholder_type)){
+                item = PyTuple_GET_ITEM(args, j);
+                j += 1;
+            }
+            PyTuple_SET_ITEM(args2, i, item);
+        }
+        if (nargs > np){
+            for (Py_ssize_t i=pto_nargs; i < nargs_new; i++) {
+                item = PyTuple_GET_ITEM(args, j);
+                PyTuple_SET_ITEM(args2, i, item);
+                j += 1;
+            }
+        }
+    } else {
+        /* Note: tupleconcat() is optimized for empty tuples */
+        args2 = PySequence_Concat(pto->args, args);
+    }
     if (args2 == NULL) {
         Py_XDECREF(kwargs2);
         return NULL;
@@ -354,6 +476,8 @@ static PyMemberDef partial_memberlist[] = {
      "tuple of arguments to future partial calls"},
     {"keywords",        _Py_T_OBJECT,       OFF(kw),        Py_READONLY,
      "dictionary of keyword arguments to future partial calls"},
+    {"np",              Py_T_PYSSIZET,      OFF(np),        Py_READONLY,
+     "number of placeholders"},
     {"__weaklistoffset__", Py_T_PYSSIZET,
      offsetof(partialobject, weakreflist), Py_READONLY},
     {"__dictoffset__", Py_T_PYSSIZET,
@@ -1497,6 +1621,9 @@ _functools_exec(PyObject *module)
     if (PyModule_AddType(module, state->partial_type) < 0) {
         return -1;
     }
+    if (PyModule_AddType(module, &placeholder_type) < 0) {
+        return -1;
+    }
 
     PyObject *lru_cache_type = PyType_FromModuleAndSpec(module,
         &lru_cache_type_spec, NULL);