TypeError on use of super() in ctypes.c_uint64 subclass

[rmorshea]

Bug report

Bug description:

When subclassing ctypes.c_uint64, if you use super() in any method definitions you get a TypeError upon defining the class similar to the following:

import ctypes
class MyClass(ctypes.c_uint64):
    def f(self):
        super()

TypeError: __class__ set to <class '__main__.MyClass'> defining 'MyClass' as <class '__main__.MyClass'>

This does not raise an error if subclassing other ctypes (e.g. c_uint8):

import ctypes
class MyClass(ctypes.c_uint8):  # ok
    def f(self):
        super()

It's also ok to subclass c_uint64 if you don't use super:

import ctypes
class MyClass(ctypes.c_uint64):  # ok
    def f(self):
        pass

CPython versions tested on:

3.13

Operating systems tested on:

macOS

[rmorshea]

This may be an indication of a broader bug with super() in ctypes subclasses. In a different scenario, super() inside a c_uint8 subclass seems to be missing methods that c_uint8 otherwise has.

import ctypes

class _UInt8(ctypes.c_uint8):
    @classmethod
    def from_param(cls, value: int) -> ctypes.c_uint8:
        if not (0 <= value <= 255):
            raise ValueError(f"The domain of uint8 is [0, 256), got {value!r}")
        return super().from_param(value)

assert hasattr(ctypes.c_uint8, "from_param")
_UInt8.from_param(1)  # AttributeError: 'super' object has no attribute 'from_param'

However, I'm less sure this is a bug because this AttributeError seems to be consistent across other ctypes subclasses.

[inventshah]

On main, subclassing either c_uint8 or c_uint64 with a super() call raises the TypeError. Looks like the error for c_uint8 was introduced in a refactor in 3.14: 78ffba4. Specifically, before getfunc_swapped and setfunc_swapped were null for the single-byte types, but after they received a value.

I tested this patch to remove __classcell__ from the class dict when creating the swapped type.

diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
index ac520ffaad6..62eebf5a14f 100644
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -2142,8 +2142,22 @@ static PyObject *CreateSwappedType(ctypes_state *st, PyTypeObject *type,
     PyTuple_SET_ITEM(swapped_args, 0, newname);
     for (i=1; i<PyTuple_GET_SIZE(args); ++i) {
         PyObject *v = PyTuple_GET_ITEM(args, i);
-        Py_INCREF(v);
-        PyTuple_SET_ITEM(swapped_args, i, v);
+
+        // Remove __classcell__ to prevent interference with swapped type's class creation
+        if (i == PyTuple_GET_SIZE(args) - 1 && PyDict_Check(v)) {
+            PyObject *dict_copy = PyDict_Copy(v);
+            if (!dict_copy) {
+                return NULL;
+            }
+
+            PyDict_DelItemString(dict_copy, "__classcell__");
+            PyErr_Clear();
+
+            PyTuple_SET_ITEM(swapped_args, i, dict_copy);
+        } else {
+            Py_INCREF(v);
+            PyTuple_SET_ITEM(swapped_args, i, v);
+        }
     }
 
     /* create the new instance (which is a class,

Edit: calling user defined functions which contain super() on the generated swapped type still fails

[inventshah]

Ah, there's #73456 which discusses this issue, and explains why deleting __classcell__ is not correct.