gh-155733: Validate keyword argument keys in operator.methodcaller and functools.partial

Lib/functools.py

@@ -417,6 +417,9 @@ def __setstate__(self, state):
            (namespace is not None and not isinstance(namespace, dict))):
             raise TypeError("invalid partial state")
 
+        if kwds is not None and any(not isinstance(k, str) for k in kwds):
+            raise TypeError("keywords must be strings")
+
         if args and args[-1] is Placeholder:
             raise TypeError("trailing Placeholders are not allowed")
         phcount, merger = _partial_prepare_merger(args)

Lib/test/test_functools.py

@@ -160,6 +160,17 @@ def test_keyword(self):
             empty, got = p(x=None)
             self.assertTrue(expected == got and empty == ())
 
+    def test_non_string_keywords(self):
+        with self.assertRaisesRegex(TypeError, "keywords must be strings"):
+            self.partial(capture, **{1: 'x'})
+        p = self.partial(capture)
+        p.keywords[1] = 'x'
+        with self.assertRaisesRegex(TypeError, "keywords must be strings"):
+            p()
+        p2 = self.partial(capture)
+        with self.assertRaisesRegex(TypeError, "keywords must be strings"):
+            p2.__setstate__((capture, (), {1: 'x'}, None))
+
     def test_no_side_effects(self):
         # make sure there are no side effects that affect subsequent calls
         p = self.partial(capture, 0, a=1)

Lib/test/test_operator.py

@@ -511,6 +511,11 @@ def return_arguments(self, *args, **kwds):
         f = operator.methodcaller('return_arguments', *many_positional_arguments, **many_kw_arguments)
         self.assertEqual(f(a), (many_positional_arguments, many_kw_arguments))
 
+    def test_non_string_keywords(self):
+        operator = self.module
+        with self.assertRaisesRegex(TypeError, "keywords must be strings"):
+            operator.methodcaller('x', **{1: 'x'})
+
     def test_inplace(self):
         operator = self.module
         class C(object):

Misc/NEWS.d/next/C_API/2026-08-14-10-54-00.gh-issue-155733.b2A34f.rst

@@ -0,0 +1 @@
+Validate keyword arguments to :func:`operator.methodcaller` and :func:`functools.partial` to raise a :exc:`TypeError` instead of crashing with non-string keys.

Modules/_functoolsmodule.c

@@ -190,11 +190,16 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
         return NULL;
     }
 
-    /* keyword Placeholder prohibition */
+    /* keyword Placeholder prohibition and key type validation */
     if (kw != NULL) {
         PyObject *key, *val;
         Py_ssize_t pos = 0;
         while (PyDict_Next(kw, &pos, &key, &val)) {
+            if (!PyUnicode_Check(key)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "keywords must be strings");
+                return NULL;
+            }
             if (val == phold) {
                 PyErr_SetString(PyExc_TypeError,
                                 "Placeholder cannot be passed as a keyword argument");
@@ -500,18 +505,29 @@ partial_vectorcall(PyObject *self, PyObject *const *args,
             PyTuple_SET_ITEM(tot_kwnames, pto_nkwds + i, key);
         }
 
-        /* Copy pto_keywords with overlapping call keywords merged
-         * Note, tail is already coppied. */
+        /* Copy pto_keywords with overlapping call keywords merged.
+         * Note, tail is already copied. */
         Py_ssize_t pos = 0, i = 0;
         PyObject *keyword_dict = n_merges ? pto_kw_merged : partial_keywords;
+        int valid_kwargs = 1;
         Py_BEGIN_CRITICAL_SECTION(keyword_dict);
         while (PyDict_Next(keyword_dict, &pos, &key, &val)) {
+            if (!PyUnicode_Check(key)) {
+                valid_kwargs = 0;
+                break;
+            }
             assert(i < pto_nkwds);
             PyTuple_SET_ITEM(tot_kwnames, i, Py_NewRef(key));
             stack[tot_nargs + i] = val;
             i++;
         }
         Py_END_CRITICAL_SECTION();
+        if (!valid_kwargs) {
+            PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+            Py_XDECREF(pto_kw_merged);
+            Py_DECREF(tot_kwnames);
+            goto clean_stack;
+        }
         assert(i == pto_nkwds);
         Py_XDECREF(pto_kw_merged);
 
@@ -816,6 +832,16 @@ partial_setstate(PyObject *self, PyObject *state)
         PyErr_SetString(PyExc_TypeError, "invalid partial state");
         return NULL;
     }
+    if (kw != Py_None) {
+        Py_ssize_t pos = 0;
+        PyObject *key, *val;
+        while (PyDict_Next(kw, &pos, &key, &val)) {
+            if (!PyUnicode_Check(key)) {
+                PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+                return NULL;
+            }
+        }
+    }
 
     Py_ssize_t nargs = PyTuple_GET_SIZE(fnargs);
     if (nargs && PyTuple_GET_ITEM(fnargs, nargs - 1) == pto->placeholder) {

Modules/_operator.c

@@ -1705,6 +1705,18 @@ methodcaller_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         return NULL;
     }
 
+    if (kwds != NULL && PyDict_Check(kwds)) {
+        PyObject *key, *value;
+        Py_ssize_t pos = 0;
+        while (PyDict_Next(kwds, &pos, &key, &value)) {
+            if (!PyUnicode_Check(key)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "keywords must be strings");
+                return NULL;
+            }
+        }
+    }
+
     _operator_state *state = _PyType_GetModuleState(type);
     /* create methodcallerobject structure */
     mc = PyObject_GC_New(methodcallerobject, (PyTypeObject *)state->methodcaller_type);