Expose bound arguments from C PartialCallableObjectProxy.

The pure Python implementation of PartialCallableObjectProxy stores the
positional and keyword arguments supplied at creation as the _self_args
and _self_kwargs attributes, but the C extension implementation kept them
in struct fields with no way to read them from Python. Attribute lookups
were instead forwarded to the wrapped callable and failed.

Add read only _self_args and _self_kwargs getters to the C type so both
implementations expose the same attributes, declare them in the stubs,
and add tests covering both implementations.

Author: GrahamDumpleton

docs/changes.rst

@@ -6,6 +6,13 @@ Version 2.4.1
 
 **Bugs Fixed**
 
+* The C extension implementation of ``PartialCallableObjectProxy`` did not
+  expose the bound positional and keyword arguments supplied when the proxy
+  was created, whereas the pure Python implementation makes them available
+  as the ``_self_args`` and ``_self_kwargs`` attributes. The C extension
+  implementation now provides read only ``_self_args`` and ``_self_kwargs``
+  attributes so that both implementations behave the same.
+
 Version 2.4.0
 -------------
 

src/wrapt-stubs/__init__.pyi

@@ -317,6 +317,8 @@ if sys.version_info >= (3, 10):
     # PartialCallableObjectProxy
 
     class PartialCallableObjectProxy(BaseObjectProxy[Callable[..., Any]]):
+        _self_args: tuple[Any, ...]
+        _self_kwargs: dict[str, Any]
         def __init__(
             self, func: Callable[..., Any], *args: Any, **kwargs: Any
         ) -> None: ...

src/wrapt/_wrappers.c

@@ -3930,11 +3930,50 @@ static PyObject *WraptPartialCallableObjectProxy_call(
 
 /* ------------------------------------------------------------------------- */;
 
+static PyObject *WraptPartialCallableObjectProxy_get_self_args(
+    WraptPartialCallableObjectProxyObject *self, void *closure)
+{
+  PyObject *value = NULL;
+
+  value = wrapt_acquire_field((PyObject *)self, &self->args);
+
+  if (!value)
+    return PyTuple_New(0);
+
+  return value;
+}
+
+/* ------------------------------------------------------------------------- */
+
+static PyObject *WraptPartialCallableObjectProxy_get_self_kwargs(
+    WraptPartialCallableObjectProxyObject *self, void *closure)
+{
+  PyObject *value = NULL;
+
+  value = wrapt_acquire_field((PyObject *)self, &self->kwargs);
+
+  if (!value)
+    return PyDict_New();
+
+  return value;
+}
+
+/* ------------------------------------------------------------------------- */
+
+static PyGetSetDef WraptPartialCallableObjectProxy_getset[] = {
+    {"_self_args", (getter)WraptPartialCallableObjectProxy_get_self_args, NULL,
+     0},
+    {"_self_kwargs", (getter)WraptPartialCallableObjectProxy_get_self_kwargs,
+     NULL, 0},
+    {NULL},
+};
+
 static PyType_Slot WraptPartialCallableObjectProxy_slots[] = {
     {Py_tp_dealloc, WraptPartialCallableObjectProxy_dealloc},
     {Py_tp_call, WraptPartialCallableObjectProxy_call},
     {Py_tp_traverse, WraptPartialCallableObjectProxy_traverse},
     {Py_tp_clear, WraptPartialCallableObjectProxy_clear},
+    {Py_tp_getset, WraptPartialCallableObjectProxy_getset},
     {Py_tp_init, WraptPartialCallableObjectProxy_init},
     {Py_tp_new, WraptPartialCallableObjectProxy_new},
     {0, NULL},

tests/core/test_callable_object_proxy.py

@@ -65,6 +65,58 @@ def func0(*args, **kwargs):
 
         self.assertEqual(partial0(), (args, kwargs))
 
+    def test_bound_arguments_no_arguments(self):
+        def func0(*args, **kwargs):
+            return (args, kwargs)
+
+        partial0 = wrapt.partial(func0)
+
+        self.assertEqual(partial0._self_args, ())
+        self.assertEqual(partial0._self_kwargs, {})
+
+    def test_bound_arguments_positional(self):
+        def func0(*args, **kwargs):
+            return (args, kwargs)
+
+        partial0 = wrapt.partial(func0, 1, 2, 3)
+
+        self.assertEqual(partial0._self_args, (1, 2, 3))
+        self.assertEqual(partial0._self_kwargs, {})
+
+    def test_bound_arguments_keyword(self):
+        def func0(*args, **kwargs):
+            return (args, kwargs)
+
+        partial0 = wrapt.partial(func0, k1=1, k2=2)
+
+        self.assertEqual(partial0._self_args, ())
+        self.assertEqual(partial0._self_kwargs, {"k1": 1, "k2": 2})
+
+    def test_bound_arguments_mixed(self):
+        def func0(*args, **kwargs):
+            return (args, kwargs)
+
+        partial0 = wrapt.PartialCallableObjectProxy(func0, 1, 2, k1=1)
+
+        self.assertEqual(partial0._self_args, (1, 2))
+        self.assertEqual(partial0._self_kwargs, {"k1": 1})
+
+    def test_bound_arguments_not_forwarded_to_wrapped(self):
+        # The attributes must come from the proxy itself and not be
+        # forwarded to a same named attribute on the wrapped callable.
+
+        class Callable:
+            _self_args = ("wrapped",)
+            _self_kwargs = {"wrapped": True}
+
+            def __call__(self, *args, **kwargs):
+                return (args, kwargs)
+
+        partial0 = wrapt.partial(Callable(), 1, k1=1)
+
+        self.assertEqual(partial0._self_args, (1,))
+        self.assertEqual(partial0._self_kwargs, {"k1": 1})
+
 
 if __name__ == "__main__":
     unittest.main()