Cython 3.1.6__tar.gz → 3.1.8__tar.gz

cython-3.1.8/.gitrev

@@ -0,0 +1 @@
+94ea88b3cd5f831ca0976e4450ae43a8144cdf00

{cython-3.1.6 → cython-3.1.8}/CHANGES.rst

@@ -2,6 +2,46 @@
 Cython Changelog
 ================
 
+3.1.8 (2026-01-03)
+==================
+
+Bugs fixed
+----------
+
+* Assignment expressions used in comprehensions could look at the wrong scope,
+  thus using different variables and different data.
+  (Github issue :issue:`6547`)
+
+* Some internal C symbols were not declared as ``static``, preventing static linking
+  of multiple modules.
+  Patch by Yury Popov.  (Github issue :issue:`7310`)
+
+* Accidentally using ``except +`` in C mode did not raise a compile error but generated
+  invalid C code leading to obscure error messages.
+  Patch by user202729.  (Github issue :issue:`6560`)
+
+
+3.1.7 (2025-11-12)
+==================
+
+Bugs fixed
+----------
+
+* Unicode characters formatted from C integers with padding, as in ``f"{value:XXc}"``,
+  could result in invalid Python string objects since Cython 3.1.0.
+  Also, lone surrogates failed to format in this way.
+  (Github issue :issue:`7298`)
+
+* Assigning nested structs from a list of structs (item by item) could crash Cython.
+  (Github issue :issue:`7308`)
+
+* Cython incorrectly called ``PyList_GetItemRef()`` in PyPy and GraalPython before Py3.13.
+  (Github issue :issue:`7269`)
+
+* Trying to instantiate internal types used by Cython is now prohibited.
+  (Github issue :issue:`7263`)
+
+
 3.1.6 (2025-10-23)
 ==================
 

{cython-3.1.6 → cython-3.1.8}/Cython/Compiler/ExprNodes.py

@@ -9049,9 +9049,12 @@ class ListNode(SequenceNode):
             else:
                 if len(self.args) < len(dst_type.scope.var_entries):
                     warning(self.pos, "Too few members for '%s'" % dst_type, 1)
-                for i, (arg, member) in enumerate(zip(self.original_args, dst_type.scope.var_entries)):
+                for i, (arg, coerced_arg, member) in enumerate(zip(self.original_args, self.args, dst_type.scope.var_entries)):
                     if isinstance(arg, CoerceToPyTypeNode):
                         arg = arg.arg
+                    elif member.type.is_struct_or_union and coerced_arg.is_dict_literal:
+                        # For struct assignments, use the coerced dict directly, not a struct type call etc.
+                        arg = coerced_arg
                     self.args[i] = arg.coerce_to(member.type, env)
             self.type = dst_type
         elif dst_type.is_ctuple:

{cython-3.1.6 → cython-3.1.8}/Cython/Compiler/FlowControl.py

@@ -337,7 +337,8 @@ class NameAssignment:
         self.is_arg = False
         self.is_deletion = False
         self.inferred_type = None
-        # For generator expression targets, the rhs can have a different scope than the lhs.
+        # For generator expression targets in comprehensions (and possibly other things),
+        # the rhs can have a different scope than the lhs.
         self.rhs_scope = rhs_scope
 
     def __repr__(self):
@@ -804,7 +805,7 @@ class ControlFlowAnalysis(CythonTransform):
                 entry = self.env.lookup(lhs.name)
             if entry is None:  # TODO: This shouldn't happen...
                 return
-            self.flow.mark_assignment(lhs, rhs, entry, rhs_scope=rhs_scope)
+            self.flow.mark_assignment(lhs, rhs, entry, rhs_scope=(rhs_scope or self.env))
         elif lhs.is_sequence_constructor:
             for i, arg in enumerate(lhs.args):
                 if arg.is_starred:

{cython-3.1.6 → cython-3.1.8}/Cython/Compiler/Nodes.py

@@ -744,6 +744,7 @@ class CFuncDeclaratorNode(CDeclaratorNode):
                     level=2)
 
         if self.exception_check == '+':
+            self.cpp_check(env)
             env.add_include_file('ios')         # for std::ios_base::failure
             env.add_include_file('new')         # for std::bad_alloc
             env.add_include_file('stdexcept')

{cython-3.1.6 → cython-3.1.8}/Cython/Shadow.py

@@ -1,7 +1,7 @@
 # cython.* namespace for pure mode.
 
 # Possible version formats: "3.1.0", "3.1.0a1", "3.1.0a1.dev0"
-__version__ = "3.1.6"
+__version__ = "3.1.8"
 
 
 # BEGIN shameless copy from Cython/minivect/minitypes.py

{cython-3.1.6 → cython-3.1.8}/Cython/Utility/AsyncGen.c

@@ -395,10 +395,8 @@ static PyType_Spec __pyx_AsyncGenType_spec = {
     __PYX_TYPE_MODULE_PREFIX "async_generator",
     sizeof(__pyx_PyAsyncGenObject),
     0,
-#if PY_VERSION_HEX >= 0x030A0000
-    Py_TPFLAGS_IMMUTABLETYPE |
-#endif
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
     __pyx_AsyncGenType_slots
 };
 
@@ -600,9 +598,7 @@ static PyType_Spec __pyx__PyAsyncGenASendType_spec = {
     __PYX_TYPE_MODULE_PREFIX "async_generator_asend",
     sizeof(__pyx_PyAsyncGenASend),
     0,
-#if PY_VERSION_HEX >= 0x030A0000
-    Py_TPFLAGS_IMMUTABLETYPE |
-#endif
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
     __pyx__PyAsyncGenASendType_slots
 };
@@ -682,9 +678,7 @@ static PyType_Spec __pyx__PyAsyncGenWrappedValueType_spec = {
     __PYX_TYPE_MODULE_PREFIX "async_generator_wrapped_value",
     sizeof(__pyx__PyAsyncGenWrappedValue),
     0,
-#if PY_VERSION_HEX >= 0x030A0000
-    Py_TPFLAGS_IMMUTABLETYPE |
-#endif
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
     __pyx__PyAsyncGenWrappedValueType_slots
 };
@@ -954,9 +948,7 @@ static PyType_Spec __pyx__PyAsyncGenAThrowType_spec = {
     __PYX_TYPE_MODULE_PREFIX "async_generator_athrow",
     sizeof(__pyx_PyAsyncGenAThrow),
     0,
-#if PY_VERSION_HEX >= 0x030A0000
-    Py_TPFLAGS_IMMUTABLETYPE |
-#endif
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
     __pyx__PyAsyncGenAThrowType_slots
 };

{cython-3.1.6 → cython-3.1.8}/Cython/Utility/Builtins.c

@@ -305,7 +305,7 @@ static PyObject *__Pyx_PyLong_AbsNeg(PyObject *n) {
 
 //////////////////// divmod_int.proto //////////////////
 
-const {{RETURN_TYPE}} __Pyx_divmod_ERROR_VALUE_{{CFUNC_SUFFIX}} = {-1, -1};
+static const {{RETURN_TYPE}} __Pyx_divmod_ERROR_VALUE_{{CFUNC_SUFFIX}} = {-1, -1};
 
 static CYTHON_INLINE {{RETURN_TYPE}} __Pyx_divmod_{{CFUNC_SUFFIX}}({{TYPE}} a, {{TYPE}} b); /*proto*/
 
@@ -345,7 +345,7 @@ static CYTHON_INLINE {{RETURN_TYPE}} __Pyx_divmod_{{CFUNC_SUFFIX}}({{TYPE}} a, {
 
 //////////////////// divmod_float.proto //////////////////
 
-const {{RETURN_TYPE}} __Pyx_divmod_ERROR_VALUE_{{CFUNC_SUFFIX}} = {-1.0, -1.0};
+static const {{RETURN_TYPE}} __Pyx_divmod_ERROR_VALUE_{{CFUNC_SUFFIX}} = {-1.0, -1.0};
 
 static CYTHON_INLINE {{RETURN_TYPE}} __Pyx_divmod_{{CFUNC_SUFFIX}}({{TYPE}} a, {{TYPE}} b); /*proto*/
 

{cython-3.1.6 → cython-3.1.8}/Cython/Utility/CommonStructures.c

@@ -165,6 +165,18 @@ static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *s
     return PyUnicode_FromString(__PYX_ABI_MODULE_NAME);
 }
 
+#if __PYX_LIMITED_VERSION_HEX < 0x030A0000
+static PyObject* __pyx_CommonTypesMetaclass_call(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwds) {
+    PyErr_SetString(PyExc_TypeError, "Cannot instantiate Cython internal types");
+    return NULL;
+}
+
+static int __pyx_CommonTypesMetaclass_setattr(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *attr, CYTHON_UNUSED PyObject *value) {
+    PyErr_SetString(PyExc_TypeError, "Cython internal types are immutable");
+    return -1;
+}
+#endif
+
 static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = {
     {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL},
     {0, 0, 0, 0, 0}
@@ -172,6 +184,11 @@ static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = {
 
 static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = {
     {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset},
+    #if __PYX_LIMITED_VERSION_HEX < 0x030A0000
+    {Py_tp_call, (void*)__pyx_CommonTypesMetaclass_call},
+    {Py_tp_new, (void*)__pyx_CommonTypesMetaclass_call},
+    {Py_tp_setattro, (void*)__pyx_CommonTypesMetaclass_setattr},
+    #endif
     {0, 0}
 };
 
@@ -179,10 +196,8 @@ static PyType_Spec __pyx_CommonTypesMetaclass_spec = {
     __PYX_TYPE_MODULE_PREFIX "_common_types_metatype",
     0,
     0,
-#if PY_VERSION_HEX >= 0x030A0000
     Py_TPFLAGS_IMMUTABLETYPE |
     Py_TPFLAGS_DISALLOW_INSTANTIATION |
-#endif
     Py_TPFLAGS_DEFAULT, /*tp_flags*/
     __pyx_CommonTypesMetaclass_slots
 };

{cython-3.1.6 → cython-3.1.8}/Cython/Utility/Coroutine.c

@@ -1821,9 +1821,7 @@ static PyType_Spec __pyx_CoroutineAwaitType_spec = {
     __PYX_TYPE_MODULE_PREFIX "coroutine_wrapper",
     sizeof(__pyx_CoroutineAwaitObject),
     0,
-#if PY_VERSION_HEX >= 0x030A0000
-    Py_TPFLAGS_IMMUTABLETYPE |
-#endif
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/
     __pyx_CoroutineAwaitType_slots
 };
@@ -1902,10 +1900,8 @@ static PyType_Spec __pyx_CoroutineType_spec = {
     __PYX_TYPE_MODULE_PREFIX "coroutine",
     sizeof(__pyx_CoroutineObject),
     0,
-#if PY_VERSION_HEX >= 0x030A0000
-    Py_TPFLAGS_IMMUTABLETYPE |
-#endif
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/
     __pyx_CoroutineType_slots
 };
 
@@ -1984,10 +1980,8 @@ static PyType_Spec __pyx_IterableCoroutineType_spec = {
     __PYX_TYPE_MODULE_PREFIX "iterable_coroutine",
     sizeof(__pyx_CoroutineObject),
     0,
-#if PY_VERSION_HEX >= 0x030A0000
-    Py_TPFLAGS_IMMUTABLETYPE |
-#endif
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/
     __pyx_IterableCoroutineType_slots
 };
 
@@ -2063,10 +2057,8 @@ static PyType_Spec __pyx_GeneratorType_spec = {
     __PYX_TYPE_MODULE_PREFIX "generator",
     sizeof(__pyx_CoroutineObject),
     0,
-#if PY_VERSION_HEX >= 0x030A0000
-    Py_TPFLAGS_IMMUTABLETYPE |
-#endif
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/
     __pyx_GeneratorType_slots
 };
 

{cython-3.1.6 → cython-3.1.8}/Cython/Utility/CythonFunction.c

@@ -1230,9 +1230,7 @@ static PyType_Spec __pyx_CyFunctionType_spec = {
     _Py_TPFLAGS_HAVE_VECTORCALL |
 #endif
 #endif // CYTHON_METH_FASTCALL
-#if PY_VERSION_HEX >= 0x030A0000
-    Py_TPFLAGS_IMMUTABLETYPE |
-#endif
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, /*tp_flags*/
     __pyx_CyFunctionType_slots
 };
@@ -1702,10 +1700,8 @@ static PyType_Spec __pyx_FusedFunctionType_spec = {
     __PYX_TYPE_MODULE_PREFIX "fused_cython_function",
     sizeof(__pyx_FusedFunctionObject),
     0,
-#if PY_VERSION_HEX >= 0x030A0000
-    Py_TPFLAGS_IMMUTABLETYPE |
-#endif
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC , /*tp_flags*/
     __pyx_FusedFunctionType_slots
 };
 

{cython-3.1.6 → cython-3.1.8}/Cython/Utility/ModuleSetupCode.c

@@ -765,6 +765,12 @@ static int __Pyx_init_co_variables(void); /* proto */
 #ifndef Py_TPFLAGS_MAPPING
   #define Py_TPFLAGS_MAPPING 0
 #endif
+#ifndef Py_TPFLAGS_IMMUTABLETYPE
+  #define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8)
+#endif
+#ifndef Py_TPFLAGS_DISALLOW_INSTANTIATION
+  #define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7)
+#endif
 
 #ifndef METH_STACKLESS
   // already defined for Stackless Python (all versions) and C-Python >= 3.7

{cython-3.1.6 → cython-3.1.8}/Cython/Utility/ObjectHandling.c

@@ -2255,7 +2255,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObj
 }
 
 /////////////// PyObjectFastCallMethod.proto ///////////////
-//@requires PyObjectFastCall
+//@requires: PyObjectFastCall
 
 #if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000
 #define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL)

{cython-3.1.6 → cython-3.1.8}/Cython/Utility/Optimize.c

@@ -477,17 +477,8 @@ static CYTHON_INLINE int __Pyx_dict_iter_next(
         #endif
         if (unlikely(pos >= list_size)) return 0;
         *ppos = pos + 1;
-        #if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
-        next_item = PyList_GetItemRef(iter_obj, pos);
+        next_item = __Pyx_PyList_GetItemRef(iter_obj, pos);
         if (unlikely(!next_item)) return -1;
-        #elif CYTHON_ASSUME_SAFE_MACROS
-        next_item = PyList_GET_ITEM(iter_obj, pos);
-        Py_INCREF(next_item);
-        #else
-        next_item = PyList_GetItem(iter_obj, pos);
-        if (unlikely(!next_item)) return -1;
-        Py_INCREF(next_item);
-        #endif
     } else
 #endif
     {

{cython-3.1.6 → cython-3.1.8}/Cython/Utility/TypeConversion.c

@@ -817,13 +817,14 @@ static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) {
 }
 
 static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) {
-    if (likely(ulength <= 250)) {
+    Py_ssize_t padding_length = ulength - 1;
+    if (likely((padding_length <= 250) && (value < 0xD800 || value > 0xDFFF))) {
         // Encode to UTF-8 / Latin1 buffer, then decode.
         char chars[256];
 
         if (value <= 255) {
             // Simple Latin1 result, fast to decode.
-            memset(chars, padding_char, (size_t) (ulength - 1));
+            memset(chars, padding_char, (size_t) padding_length);
             chars[ulength-1] = (char) value;
             return PyUnicode_DecodeLatin1(chars, ulength, NULL);
         }
@@ -848,8 +849,8 @@ static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulengt
             value >>= 6;
             *--cpos = (char) (0xf0 | (value & 0x07));
         }
-        cpos -= ulength;
-        memset(cpos, padding_char, (size_t) (ulength - 1));
+        cpos -= padding_length;
+        memset(cpos, padding_char, (size_t) padding_length);
         return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL);
     }
 
@@ -863,7 +864,7 @@ static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulengt
 
         padding_uchar = PyUnicode_FromOrdinal(padding_char);
         if (unlikely(!padding_uchar)) return NULL;
-        padding = PySequence_Repeat(padding_uchar, ulength - 1);
+        padding = PySequence_Repeat(padding_uchar, padding_length);
         Py_DECREF(padding_uchar);
         if (unlikely(!padding)) return NULL;
 
@@ -915,7 +916,13 @@ static const char DIGITS_HEX[2*16+1] = {
 
 /////////////// CIntToPyUnicode.proto ///////////////
 
-static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t width, char padding_char, char format_char);
+#define {{TO_PY_FUNCTION}}(value, width, padding_char, format_char) ( \
+    ((format_char) == ('c')) ? \
+        __Pyx_uchar_{{TO_PY_FUNCTION}}(value, width, padding_char) : \
+        __Pyx__{{TO_PY_FUNCTION}}(value, width, padding_char, format_char) \
+    )
+static CYTHON_INLINE PyObject* __Pyx_uchar_{{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t width, char padding_char);
+static CYTHON_INLINE PyObject* __Pyx__{{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t width, char padding_char, char format_char);
 
 /////////////// CIntToPyUnicode ///////////////
 //@requires: StringTools.c::IncludeStringH
@@ -927,7 +934,32 @@ static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t wid
 
 // NOTE: inlining because most arguments are constant, which collapses lots of code below
 
-static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t width, char padding_char, char format_char) {
+static CYTHON_INLINE PyObject* __Pyx_uchar_{{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t width, char padding_char) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const {{TYPE}} neg_one = ({{TYPE}}) -1, const_zero = ({{TYPE}}) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+
+    // This check is just an awful variation on "(0 <= value <= 1114111)",
+    // but without C compiler complaints about compile time constant conditions depending on the signed/unsigned TYPE.
+    if (unlikely(!(is_unsigned || value == 0 || value > 0) ||
+                    !(sizeof(value) <= 2 || value & ~ ({{TYPE}}) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) {
+        // PyUnicode_FromOrdinal() and chr() raise ValueError, f-strings raise OverflowError. :-/
+        PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)");
+        return NULL;
+    }
+    if (width <= 1) {
+        return PyUnicode_FromOrdinal((int) value);
+    }
+    return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char);
+}
+
+static CYTHON_INLINE PyObject* __Pyx__{{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t width, char padding_char, char format_char) {
     // simple and conservative C string allocation on the stack: each byte gives at most 3 digits, plus sign
     char digits[sizeof({{TYPE}})*3+2];
     // 'dpos' points to end of digits array + 1 initially to allow for pre-decrement looping
@@ -946,22 +978,6 @@ static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t wid
 #endif
     const int is_unsigned = neg_one > const_zero;
 
-    // Format 'c' (unicode character) is really a different thing but included for practical reasons.
-    if (format_char == 'c') {
-        // This check is just an awful variation on "(0 <= value <= 1114111)",
-        // but without C compiler complaints about compile time constant conditions depending on the signed/unsigned TYPE.
-        if (unlikely(!(is_unsigned || value == 0 || value > 0) ||
-                     !(sizeof(value) <= 2 || value & ~ ({{TYPE}}) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) {
-            // PyUnicode_FromOrdinal() and chr() raise ValueError, f-strings raise OverflowError. :-/
-            PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)");
-            return NULL;
-        }
-        if (width <= 1) {
-            return PyUnicode_FromOrdinal((int) value);
-        }
-        return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char);
-    }
-
     if (format_char == 'X') {
         hex_digits += 16;
         format_char = 'x';

{cython-3.1.6 → cython-3.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Cython
-Version: 3.1.6
+Version: 3.1.8
 Summary: The Cython compiler for writing C extensions in the Python language.
 Home-page: https://cython.org/
 Author: Robert Bradshaw, Stefan Behnel, David Woods, Greg Ewing, et al.
@@ -65,17 +65,20 @@ to install an uncompiled (slower) version of Cython with::
 
 .. _Pyrex: https://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/
 
-3.1.6 (2025-10-23)
+3.1.8 (2026-01-03)
 ==================
 
 Bugs fixed
 ----------
 
-* Unicode characters formatted from C integers with ``f"{value:c}"`` could result in
-  invalid Python string objects since Cython 3.1.0.
-  (Github issue https://github.com/cython/cython/issues/7240)
+* Assignment expressions used in comprehensions could look at the wrong scope,
+  thus using different variables and different data.
+  (Github issue https://github.com/cython/cython/issues/6547)
 
-* ``cythonize`` (program and function) now uses ``concurrent.futures.ProcessPoolExecutor``
-  instead of ``multiprocessing.Pool`` to fix a hang on build failures in parallel builds.
-  A possible work-around is to disable parallel builds.
-  Patch by Sviatoslav Sydorenko.  (Github issue https://github.com/cython/cython/issues/7183)
+* Some internal C symbols were not declared as ``static``, preventing static linking
+  of multiple modules.
+  Patch by Yury Popov.  (Github issue https://github.com/cython/cython/issues/7310)
+
+* Accidentally using ``except +`` in C mode did not raise a compile error but generated
+  invalid C code leading to obscure error messages.
+  Patch by user202729.  (Github issue https://github.com/cython/cython/issues/6560)

{cython-3.1.6 → cython-3.1.8}/tests/errors/cppexc_non_extern.pyx

@@ -1,5 +1,5 @@
 # mode: error
-# tag: warnings
+# tag: cpp, warnings
 
 cdef inline void handle_exception():
     pass

{cython-3.1.6 → cython-3.1.8}/tests/errors/e_cpp_only_features.pyx

@@ -18,6 +18,8 @@ def use_del():
     cdef A *p = &a
     del p
 
+cdef extern from *:
+    int use_exception() except+
 
 _ERRORS = """
 4:4: Using 'cppclass' while Cython is not in c++ mode
@@ -26,4 +28,5 @@ _ERRORS = """
 10:0: Using 'cppclass' while Cython is not in c++ mode
 14:16: Operation only allowed in c++
 19:4: Operation only allowed in c++
+22:21: Operation only allowed in c++
 """

{cython-3.1.6 → cython-3.1.8}/tests/run/cstruct.pyx

@@ -105,3 +105,53 @@ def reserved_names():
     s2.new = s1.new
     s2.case, s2.do = s1.case, s1.do
     return (s2.new, s2.case, s2.do)
+
+
+cdef struct Point:
+    double x,y
+    int colour
+
+cdef union int_or_float:
+    int i
+    float f
+
+cdef struct NestedStruct:
+    Point p
+    int_or_float x
+
+
+def struct_union_assignments():
+    """
+    >>> struct_union_assignments()
+    """
+    cdef NestedStruct ns
+
+    ns = [Point(1.0, 2.0, 42), int_or_float(i=1)]
+    assert ns.p.colour == 42, ns.p.colour
+    assert ns.p.x == 1.0, ns.p.x
+    assert ns.p.y == 2.0, ns.p.y
+    assert ns.x.i == 1, ns.x.i
+
+    ns = NestedStruct(Point(x=2.0, y=3.0, colour=43), int_or_float(i=2))
+    assert ns.p.colour == 43, ns.p.colour
+    assert ns.p.x == 2.0, ns.p.x
+    assert ns.p.y == 3.0, ns.p.y
+    assert ns.x.i == 2, ns.x.i
+
+    ns = NestedStruct(x=int_or_float(i=3), p=Point(colour=44, y=4.0, x=3.0))
+    assert ns.p.colour == 44, ns.p.colour
+    assert ns.p.x == 3.0, ns.p.x
+    assert ns.p.y == 4.0, ns.p.y
+    assert ns.x.i == 3, ns.x.i
+
+    ns = NestedStruct([4.0, 5.0, 45], x=int_or_float(i=4))
+    assert ns.p.colour == 45, ns.p.colour
+    assert ns.p.x == 4.0, ns.p.x
+    assert ns.p.y == 5.0, ns.p.y
+    assert ns.x.i == 4, ns.x.i
+
+    ns = [[4.0, 5.0, 46], int_or_float(i=5)]
+    assert ns.p.colour == 46, ns.p.colour
+    assert ns.p.x == 4.0, ns.p.x
+    assert ns.p.y == 5.0, ns.p.y
+    assert ns.x.i == 5, ns.x.i

{cython-3.1.6 → cython-3.1.8}/tests/run/extra_walrus.py

@@ -335,3 +335,21 @@ def memoryview_walrus(x: cython.uchar[:]):
     """
     (y := x)
     return chr(y[0])
+
+def comprehension_scope():
+    """
+    >>> comprehension_scope()
+    [1, 2, 3, 4]
+    """
+    i = 0
+    # i needs to refer to the loop variable, not the function one
+    return [ x for i in range(5) if (x := i) ]
+
+def genexp_scope():
+    """
+    >>> genexp_scope()
+    (1, 2, 3, 4)
+    """
+    i = 0
+    # i needs to refer to the loop variable, not the function one
+    return tuple(x for i in range(5) if (x := i))

{cython-3.1.6 → cython-3.1.8}/tests/run/fstring.pyx

@@ -530,15 +530,29 @@ def format_decoded_bytes(bytes value):
 )
 def format_uchar(int x):
     """
-    >>> format_uchar(0)
-    ('\\x00', '           \\x00', '       \\x00')
-    >>> format_uchar(13)
-    ('\\r', '           \\r', '       \\r')
+    >>> char, right8, right12, _ = format_uchar(0)
+    >>> (char, right8, right12)
+    ('\\x00', '       \\x00', '           \\x00')
+    >>> char, right8, right12, _ = format_uchar(13)
+    >>> (char, right8, right12)
+    ('\\r', '       \\r', '           \\r')
+
+    >>> for c in range(1114111 + 1):
+    ...     char, right8, right12, right252 = format_uchar(c)
+    ...     assert right8[:-1] == ' ' * 7, (c, right8)
+    ...     assert char == right8[-1], (char, right8)
+    ...     assert right12[:-1] == ' ' * 11, (c, right12)
+    ...     assert char == right12[-1], (char, right12)
+    ...     assert right252[:-1] == ' ' * 251, (c, right252)
+    ...     assert char == right252[-1], (char, right252)
+    ...     assert ord(char) == c, (c, char)
+
     >>> format_uchar(1114111 + 1)
     Traceback (most recent call last):
     OverflowError: %c arg not in range(0x110000)
     """
-    return f"{x:c}", f"{x:12c}", f"{x:>8c}"
+    # 252 is just outside the fast path size (padding > 250 characters).
+    return f"{x:c}", f"{x:>8c}", f"{x:12c}", f"{x:>252c}"
 
 
 @cython.test_fail_if_path_exists(

cython-3.1.6/.gitrev

@@ -1 +0,0 @@
-b40c676a7396e3b8ca25974bd5ca4b5cef7f9908