gh-112068: C API: Add support of nullable arguments in PyArg_Parse (prefix)

Lib/test/test_capi/test_getargs.py

@@ -1352,6 +1352,123 @@ def test_nested_tuple(self):
                     "argument 1 must be sequence of length 1, not 0"):
                 parse(((),), {}, '(' + f + ')', ['a'])
 
+    def test_specific_type_errors(self):
+        parse = _testcapi.parse_tuple_and_keywords
+
+        def check(format, arg, expected, got='list'):
+            errmsg = f'must be {expected}, not {got}'
+            with self.assertRaisesRegex(TypeError, errmsg):
+                parse((arg,), {}, format, ['a'])
+
+        check('k', [], 'int')
+        check('?k', [], 'int or None')
+        check('K', [], 'int')
+        check('?K', [], 'int or None')
+        check('c', [], 'a byte string of length 1')
+        check('?c', [], 'a byte string of length 1 or None')
+        check('c', b'abc', 'a byte string of length 1',
+              'a bytes object of length 3')
+        check('?c', b'abc', 'a byte string of length 1 or None',
+              'a bytes object of length 3')
+        check('c', bytearray(b'abc'), 'a byte string of length 1',
+              'a bytearray object of length 3')
+        check('?c', bytearray(b'abc'), 'a byte string of length 1 or None',
+              'a bytearray object of length 3')
+        check('C', [], 'a unicode character')
+        check('?C', [], 'a unicode character or None')
+        check('C', 'abc', 'a unicode character',
+              'a string of length 3')
+        check('?C', 'abc', 'a unicode character or None',
+              'a string of length 3')
+        check('s', [], 'str')
+        check('?s', [], 'str or None')
+        check('z', [], 'str or None')
+        check('?z', [], 'str or None')
+        check('es', [], 'str')
+        check('?es', [], 'str or None')
+        check('es#', [], 'str')
+        check('?es#', [], 'str or None')
+        check('et', [], 'str, bytes or bytearray')
+        check('?et', [], 'str, bytes or bytearray or None')
+        check('et#', [], 'str, bytes or bytearray')
+        check('?et#', [], 'str, bytes or bytearray or None')
+        check('w*', [], 'read-write bytes-like object')
+        check('?w*', [], 'read-write bytes-like object or None')
+        check('S', [], 'bytes')
+        check('?S', [], 'bytes or None')
+        check('U', [], 'str')
+        check('?U', [], 'str or None')
+        check('Y', [], 'bytearray')
+        check('?Y', [], 'bytearray or None')
+        check('(OO)', 42, '2-item sequence', 'int')
+        check('?(OO)', 42, '2-item sequence or None', 'int')
+        check('(OO)', (1, 2, 3), 'sequence of length 2', '3')
+
+    def test_nullable(self):
+        parse = _testcapi.parse_tuple_and_keywords
+
+        def check(format, arg, allows_none=False):
+            # Because some format units (such as y*) require cleanup,
+            # we force the parsing code to perform the cleanup by adding
+            # an argument that always fails.
+            # By checking for an exception, we ensure that the parsing
+            # of the first argument was successful.
+            self.assertRaises(OverflowError, parse,
+                              (arg, 256), {}, '?' + format + 'b', ['a', 'b'])
+            self.assertRaises(OverflowError, parse,
+                              (None, 256), {}, '?' + format + 'b', ['a', 'b'])
+            self.assertRaises(OverflowError, parse,
+                              (arg, 256), {}, format + 'b', ['a', 'b'])
+            self.assertRaises(OverflowError if allows_none else TypeError, parse,
+                              (None, 256), {}, format + 'b', ['a', 'b'])
+
+        check('b', 42)
+        check('B', 42)
+        check('h', 42)
+        check('H', 42)
+        check('i', 42)
+        check('I', 42)
+        check('n', 42)
+        check('l', 42)
+        check('k', 42)
+        check('L', 42)
+        check('K', 42)
+        check('f', 2.5)
+        check('d', 2.5)
+        check('D', 2.5j)
+        check('c', b'a')
+        check('C', 'a')
+        check('p', True, allows_none=True)
+        check('y', b'buffer')
+        check('y*', b'buffer')
+        check('y#', b'buffer')
+        check('s', 'string')
+        check('s*', 'string')
+        check('s#', 'string')
+        check('z', 'string', allows_none=True)
+        check('z*', 'string', allows_none=True)
+        check('z#', 'string', allows_none=True)
+        check('w*', bytearray(b'buffer'))
+        check('U', 'string')
+        check('S', b'bytes')
+        check('Y', bytearray(b'bytearray'))
+        check('O', object, allows_none=True)
+
+        check('(OO)', (1, 2))
+        self.assertEqual(parse((((1, 2), 3),), {}, '(?(OO)O)', ['a']), (1, 2, 3))
+        self.assertEqual(parse(((None, 3),), {}, '(?(OO)O)', ['a']), (NULL, NULL, 3))
+        self.assertEqual(parse((((1, 2), 3),), {}, '((OO)O)', ['a']), (1, 2, 3))
+        self.assertRaises(TypeError, parse, ((None, 3),), {}, '((OO)O)', ['a'])
+
+        parse((None,), {}, '?es', ['a'])
+        parse((None,), {}, '?es#', ['a'])
+        parse((None,), {}, '?et', ['a'])
+        parse((None,), {}, '?et#', ['a'])
+        parse((None,), {}, '?O!', ['a'])
+        parse((None,), {}, '?O&', ['a'])
+
+        # TODO: More tests for es?, es#?, et?, et#?, O!, O&
+
     @unittest.skipIf(_testinternalcapi is None, 'needs _testinternalcapi')
     def test_gh_119213(self):
         rc, out, err = script_helper.assert_python_ok("-c", """if True:

Modules/_ctypes/_ctypes.c

@@ -3635,8 +3635,7 @@ _validate_paramflags(ctypes_state *st, PyTypeObject *type, PyObject *paramflags)
         PyObject *name = Py_None;
         PyObject *defval;
         PyObject *typ;
-        if (!PyArg_ParseTuple(item, "i|OO", &flag, &name, &defval) ||
-            !(name == Py_None || PyUnicode_Check(name)))
+        if (!PyArg_ParseTuple(item, "i|?UO", &flag, &name, &defval))
         {
             PyErr_SetString(PyExc_TypeError,
                    "paramflags must be a sequence of (int [,string [,value]]) tuples");
@@ -3701,10 +3700,8 @@ PyCFuncPtr_FromDll(PyTypeObject *type, PyObject *args, PyObject *kwds)
     void *handle;
     PyObject *paramflags = NULL;
 
-    if (!PyArg_ParseTuple(args, "O|O", &ftuple, &paramflags))
+    if (!PyArg_ParseTuple(args, "O|?O", &ftuple, &paramflags))
         return NULL;
-    if (paramflags == Py_None)
-        paramflags = NULL;
 
     ftuple = PySequence_Tuple(ftuple);
     if (!ftuple)
@@ -3819,10 +3816,8 @@ PyCFuncPtr_FromVtblIndex(PyTypeObject *type, PyObject *args, PyObject *kwds)
     GUID *iid = NULL;
     Py_ssize_t iid_len = 0;
 
-    if (!PyArg_ParseTuple(args, "is|Oz#", &index, &name, &paramflags, &iid, &iid_len))
+    if (!PyArg_ParseTuple(args, "is|?Oz#", &index, &name, &paramflags, &iid, &iid_len))
         return NULL;
-    if (paramflags == Py_None)
-        paramflags = NULL;
 
     ctypes_state *st = get_module_state_by_def(Py_TYPE(type));
     if (!_validate_paramflags(st, type, paramflags)) {

Modules/_json.c

@@ -1208,23 +1208,16 @@ encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"markers", "default", "encoder", "indent", "key_separator", "item_separator", "sort_keys", "skipkeys", "allow_nan", NULL};
 
     PyEncoderObject *s;
-    PyObject *markers, *defaultfn, *encoder, *indent, *key_separator;
+    PyObject *markers = Py_None, *defaultfn, *encoder, *indent, *key_separator;
     PyObject *item_separator;
     int sort_keys, skipkeys, allow_nan;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOOUUppp:make_encoder", kwlist,
-        &markers, &defaultfn, &encoder, &indent,
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "?O!OOOUUppp:make_encoder", kwlist,
+        &PyDict_Type, &markers, &defaultfn, &encoder, &indent,
         &key_separator, &item_separator,
         &sort_keys, &skipkeys, &allow_nan))
         return NULL;
 
-    if (markers != Py_None && !PyDict_Check(markers)) {
-        PyErr_Format(PyExc_TypeError,
-                     "make_encoder() argument 1 must be dict or None, "
-                     "not %.200s", Py_TYPE(markers)->tp_name);
-        return NULL;
-    }
-
     s = (PyEncoderObject *)type->tp_alloc(type, 0);
     if (s == NULL)
         return NULL;

Modules/_threadmodule.c

@@ -1878,10 +1878,10 @@ thread_PyThread_start_joinable_thread(PyObject *module, PyObject *fargs,
     PyObject *func = NULL;
     int daemon = 1;
     thread_module_state *state = get_thread_state(module);
-    PyObject *hobj = NULL;
+    PyObject *hobj = Py_None;
     if (!PyArg_ParseTupleAndKeywords(fargs, fkwargs,
-                                     "O|Op:start_joinable_thread", keywords,
-                                     &func, &hobj, &daemon)) {
+                                     "O|?O!p:start_joinable_thread", keywords,
+                                     &func, state->thread_handle_type, &hobj, &daemon)) {
         return NULL;
     }
 
@@ -1891,14 +1891,6 @@ thread_PyThread_start_joinable_thread(PyObject *module, PyObject *fargs,
         return NULL;
     }
 
-    if (hobj == NULL) {
-        hobj = Py_None;
-    }
-    else if (hobj != Py_None && !Py_IS_TYPE(hobj, state->thread_handle_type)) {
-        PyErr_SetString(PyExc_TypeError, "'handle' must be a _ThreadHandle");
-        return NULL;
-    }
-
     if (PySys_Audit("_thread.start_joinable_thread", "OiO", func, daemon,
                     hobj) < 0) {
         return NULL;

Modules/mmapmodule.c

@@ -23,7 +23,6 @@
 #endif
 
 #include <Python.h>
-#include "pycore_abstract.h"      // _Py_convert_optional_to_ssize_t()
 #include "pycore_bytesobject.h"   // _PyBytes_Find()
 #include "pycore_fileutils.h"     // _Py_stat_struct
 
@@ -512,7 +511,7 @@ mmap_read_method(mmap_object *self,
     Py_ssize_t num_bytes = PY_SSIZE_T_MAX, remaining;
 
     CHECK_VALID(NULL);
-    if (!PyArg_ParseTuple(args, "|O&:read", _Py_convert_optional_to_ssize_t, &num_bytes))
+    if (!PyArg_ParseTuple(args, "|?n:read", &num_bytes))
         return NULL;
     CHECK_VALID(NULL);