gh-148464: Add missing __ctype_le/be__ attributes for complex types in the ctype module

Author: skirpichev

Lib/test/test_ctypes/test_byteswap.py

@@ -1,4 +1,5 @@
 import binascii
+import ctypes
 import math
 import struct
 import sys
@@ -165,6 +166,48 @@ def test_endian_double(self):
         self.assertEqual(s.value, math.pi)
         self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s))
 
+    @unittest.skipUnless(hasattr(ctypes, 'c_float_complex'), "No complex types")
+    def test_endian_float_complex(self):
+        c_float_complex = ctypes.c_float_complex
+        if sys.byteorder == "little":
+            self.assertIs(c_float_complex.__ctype_le__, c_float_complex)
+            self.assertIs(c_float_complex.__ctype_be__.__ctype_le__,
+                          c_float_complex)
+        else:
+            self.assertIs(c_float_complex.__ctype_be__, c_float_complex)
+            self.assertIs(c_float_complex.__ctype_le__.__ctype_be__,
+                          c_float_complex)
+        s = c_float_complex(math.pi+1j)
+        self.assertEqual(bin(struct.pack("F", math.pi+1j)), bin(s))
+        self.assertAlmostEqual(s.value, math.pi+1j, places=6)
+        s = c_float_complex.__ctype_le__(math.pi+1j)
+        self.assertAlmostEqual(s.value, math.pi+1j, places=6)
+        self.assertEqual(bin(struct.pack("<F", math.pi+1j)), bin(s))
+        s = c_float_complex.__ctype_be__(math.pi+1j)
+        self.assertAlmostEqual(s.value, math.pi+1j, places=6)
+        self.assertEqual(bin(struct.pack(">F", math.pi+1j)), bin(s))
+
+    @unittest.skipUnless(hasattr(ctypes, 'c_double_complex'), "No complex types")
+    def test_endian_double_complex(self):
+        c_double_complex = ctypes.c_double_complex
+        if sys.byteorder == "little":
+            self.assertIs(c_double_complex.__ctype_le__, c_double_complex)
+            self.assertIs(c_double_complex.__ctype_be__.__ctype_le__,
+                          c_double_complex)
+        else:
+            self.assertIs(c_double_complex.__ctype_be__, c_double_complex)
+            self.assertIs(c_double_complex.__ctype_le__.__ctype_be__,
+                          c_double_complex)
+        s = c_double_complex(math.pi+1j)
+        self.assertEqual(bin(struct.pack("D", math.pi+1j)), bin(s))
+        self.assertAlmostEqual(s.value, math.pi+1j, places=6)
+        s = c_double_complex.__ctype_le__(math.pi+1j)
+        self.assertAlmostEqual(s.value, math.pi+1j, places=6)
+        self.assertEqual(bin(struct.pack("<D", math.pi+1j)), bin(s))
+        s = c_double_complex.__ctype_be__(math.pi+1j)
+        self.assertAlmostEqual(s.value, math.pi+1j, places=6)
+        self.assertEqual(bin(struct.pack(">D", math.pi+1j)), bin(s))
+
     def test_endian_other(self):
         self.assertIs(c_byte.__ctype_le__, c_byte)
         self.assertIs(c_byte.__ctype_be__, c_byte)

Misc/NEWS.d/next/Library/2026-04-13-06-22-27.gh-issue-148464.Bj_NZy.rst

@@ -0,0 +1,3 @@
+Add missing ``__ctype_le/be__`` attributes for
+:class:`~ctypes.c_double_float` and :class:`~ctypes.c_double_complex`. Patch
+by Sergey B Kirpichev.

Modules/_ctypes/_ctypes.c

@@ -2267,7 +2267,17 @@ static PyObject *CreateSwappedType(ctypes_state *st, PyTypeObject *type,
         return NULL;
     }
 
-    stginfo->ffi_type_pointer = *fmt->pffi_type;
+    if (!fmt->pffi_type->elements) {
+        stginfo->ffi_type_pointer = *fmt->pffi_type;
+    }
+    else {
+        stginfo->ffi_type_pointer.size = fmt->pffi_type->size;
+        stginfo->ffi_type_pointer.alignment = fmt->pffi_type->alignment;
+        stginfo->ffi_type_pointer.type = fmt->pffi_type->type;
+        stginfo->ffi_type_pointer.elements = PyMem_Malloc(2 * sizeof(ffi_type));
+        memcpy(stginfo->ffi_type_pointer.elements,
+               fmt->pffi_type->elements, 2 * sizeof(ffi_type));
+    }
     stginfo->align = fmt->pffi_type->alignment;
     stginfo->length = 0;
     stginfo->size = fmt->pffi_type->size;

Modules/_ctypes/cfield.c

@@ -792,6 +792,32 @@ D_get(void *ptr, Py_ssize_t size)
     return PyComplex_FromDoubles(x[0], x[1]);
 }
 
+static PyObject *
+D_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
+{
+    assert(NUM_BITS(size) || (size == 2*sizeof(double)));
+    Py_complex c = PyComplex_AsCComplex(value);
+
+    if (c.real == -1 && PyErr_Occurred()) {
+        return NULL;
+    }
+    if (PyFloat_Pack8(c.real, ptr, PY_BIG_ENDIAN)
+        || PyFloat_Pack8(c.imag, ptr + sizeof(double), PY_BIG_ENDIAN))
+    {
+        return NULL;
+    }
+    _RET(value);
+}
+
+static PyObject *
+D_get_sw(void *ptr, Py_ssize_t size)
+{
+    assert(NUM_BITS(size) || (size == 2*sizeof(double)));
+    return PyComplex_FromDoubles(PyFloat_Unpack8(ptr, PY_BIG_ENDIAN),
+                                 PyFloat_Unpack8(ptr + sizeof(double),
+                                                 PY_BIG_ENDIAN));
+}
+
 /* F: float complex */
 static PyObject *
 F_set(void *ptr, PyObject *value, Py_ssize_t size)
@@ -817,6 +843,32 @@ F_get(void *ptr, Py_ssize_t size)
     return PyComplex_FromDoubles(x[0], x[1]);
 }
 
+static PyObject *
+F_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
+{
+    assert(NUM_BITS(size) || (size == 2*sizeof(float)));
+    Py_complex c = PyComplex_AsCComplex(value);
+
+    if (c.real == -1 && PyErr_Occurred()) {
+        return NULL;
+    }
+    if (PyFloat_Pack4(c.real, ptr, PY_BIG_ENDIAN)
+        || PyFloat_Pack4(c.imag, ptr + sizeof(float), PY_BIG_ENDIAN))
+    {
+        return NULL;
+    }
+    _RET(value);
+}
+
+static PyObject *
+F_get_sw(void *ptr, Py_ssize_t size)
+{
+    assert(NUM_BITS(size) || (size == 2*sizeof(float)));
+    return PyComplex_FromDoubles(PyFloat_Unpack4(ptr, PY_BIG_ENDIAN),
+                                 PyFloat_Unpack4(ptr + sizeof(float),
+                                                 PY_BIG_ENDIAN));
+}
+
 /* G: long double complex */
 static PyObject *
 G_set(void *ptr, PyObject *value, Py_ssize_t size)
@@ -1602,7 +1654,9 @@ for base_code, base_c_type in [
 #if defined(_Py_FFI_SUPPORT_C_COMPLEX)
     if (Py_FFI_COMPLEX_AVAILABLE) {
         TABLE_ENTRY(D, &ffi_type_complex_double);
+        TABLE_ENTRY_SW(D, &ffi_type_complex_double);
         TABLE_ENTRY(F, &ffi_type_complex_float);
+        TABLE_ENTRY_SW(F, &ffi_type_complex_float);
         TABLE_ENTRY(G, &ffi_type_complex_longdouble);
     }
 #endif