Cython 3.2.3__tar.gz → 3.2.4__tar.gz

cython-3.2.4/.gitrev

@@ -0,0 +1 @@
+21bda420d583bcf464fb9efb932b09c5f3db1efd

{cython-3.2.3 → cython-3.2.4}/CHANGES.rst

@@ -2,6 +2,41 @@
 Cython Changelog
 ================
 
+3.2.4 (2026-01-04)
+==================
+
+Features added
+--------------
+
+* In preparation of Cython 3.3, a new decorator ``@collection_type(tname)`` can be used
+  to advertise an extension type as being a ``'sequence'`` or ``'mapping'``.  This currently
+  only has the effect of setting the ``Py_TPFLAGS_SEQUENCE`` flag on the type or not, but
+  is provided for convenience to allow using the new decorator already in Cython 3.2 code.
+
+* Several C++ exception declarations were added to ``libcpp.exceptions``.
+  (Github issue :issue:`7389`)
+
+Bugs fixed
+----------
+
+* Pseudo-literal default values of function arguments like ``arg=str()`` could generate
+  invalid C code when internally converted into a real literal.
+  (Github issue :issue:`6192`)
+
+* The pickle serialisation of extension types using the ``auto_pickle`` feature was
+  larger than necessary since 3.2.0 for types without Python object attributes.
+  It is now back to the state before 3.2.0 again.
+  (Github issue :issue:`7443`)
+
+* Constants are now only made immortal on freethreading Python if they are not shared.
+  (Github issue :issue:`7439`)
+
+* ``PyDict_SetDefaultRef()`` is now used when available to avoid temporary borrowed references.
+  (Github issue :issue:`7347`)
+
+* Includes all fixes as of Cython 3.1.8.
+
+
 3.2.3 (2025-12-14)
 ==================
 
@@ -591,12 +626,16 @@ Other changes
   (Github issue :issue:`6423`)
 
 
-3.1.8 (2025-??-??)
+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`)

{cython-3.2.3 → cython-3.2.4}/Cython/Compiler/Code.py

@@ -2422,7 +2422,17 @@ class GlobalState:
         writer.putln(f"PyObject **table = {array_cname};")
         writer.putln(f"for (Py_ssize_t i=0; i<{constant_count}; ++i) {{")
         writer.putln("#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING")
+        # We don't want to set the refcount on shared constants (e.g. cached integers)
+        # because setting the refcount isn't thread-safe. The chances are that most of the constants
+        # that this applies to are already immortal though so that isn't a great loss.
+        writer.putln("#if PY_VERSION_HEX < 0x030E0000")
+        writer.putln("if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1)")
+        writer.putln("#else")
+        writer.putln("if (PyUnstable_Object_IsUniquelyReferenced(table[i]))")
+        writer.putln("#endif")
+        writer.putln("{")
         writer.putln("Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL);")
+        writer.putln("}")
         writer.putln("#else")
         writer.putln("Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT);")
         writer.putln("#endif")

{cython-3.2.3 → cython-3.2.4}/Cython/Compiler/ExprNodes.py

@@ -10491,8 +10491,8 @@ class PyCFunctionNode(ExprNode, ModuleNameMixin):
             defaults = '__Pyx_CyFunction_Defaults(struct %s, %s)' % (
                 self.defaults_entry.type.objstruct_cname, self.result())
             for arg, entry in self.defaults:
-                arg.generate_assignment_code(code, target='%s->%s' % (
-                    defaults, entry.cname))
+                if arg.is_dynamic:
+                    arg.generate_assignment_code(code, cyfunc_struct_target=f'{defaults}->{entry.cname}')
 
         if self.defaults_tuple:
             code.putln('__Pyx_CyFunction_SetDefaultsTuple(%s, %s);' % (

{cython-3.2.3 → cython-3.2.4}/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.2.3 → cython-3.2.4}/Cython/Compiler/Nodes.py

@@ -1078,12 +1078,14 @@ class CArgDeclNode(Node):
         if self.default:
             self.default.annotate(code)
 
-    def generate_assignment_code(self, code, target=None, overloaded_assignment=False):
+    def generate_assignment_code(self, code, overloaded_assignment=False,
+                                 cyfunc_struct_target=None):
         default = self.default
-        if default is None or default.is_literal:
+        if default is None or (default.is_literal and cyfunc_struct_target is None):
             return
-        if target is None:
-            target = self.calculate_default_value_code(code)
+        # Note that even if self.is_dynamic, default may be a literal if it's been
+        # optimized into a literal after analyse_expressions
+        target = cyfunc_struct_target or self.calculate_default_value_code(code)
         default.generate_evaluation_code(code)
         default.make_owned_reference(code)
         result = default.result() if overloaded_assignment else default.result_as(self.type)

{cython-3.2.3 → cython-3.2.4}/Cython/Compiler/Options.py

@@ -357,7 +357,7 @@ directive_types = {
     'auto_pickle': bool,
     'locals': dict,
     'final' : bool,  # final cdef classes and methods
-    'collection_type': one_of('sequence'),
+    'collection_type': one_of('sequence', 'mapping'),
     'nogil' : DEFER_ANALYSIS_OF_ARGUMENTS,
     'gil' : DEFER_ANALYSIS_OF_ARGUMENTS,
     'critical_section' : DEFER_ANALYSIS_OF_ARGUMENTS,

{cython-3.2.3 → cython-3.2.4}/Cython/Compiler/ParseTreeTransforms.py

@@ -1397,6 +1397,8 @@ class InterpretCompilerDirectives(CythonTransform):
                 elif isinstance(old_value, list):
                     old_value.extend(value)
                 else:
+                    if name == "collection_type" and value != optdict[name]:
+                        error(node.pos, "Multiple values of collection_type are not supported")
                     optdict[name] = value
             else:
                 optdict[name] = value
@@ -2323,7 +2325,7 @@ if VALUE is not None:
 
             members = ', '.join(f'self.{v}' for v in all_members_names) + (',' if len(all_members_names) == 1 else '')
             # Even better, we could check PyType_IS_GC.
-            any_notnone_members = ' or '.join([f'self.{e.name} is not None' for e in all_members if e.type.is_pyobject] or ['False']),
+            any_notnone_members = ' or '.join([f'self.{e.name} is not None' for e in all_members if e.type.is_pyobject] or ['False'])
 
             pickle_code = f"""
                 def __reduce_cython__(self):

{cython-3.2.3 → cython-3.2.4}/Cython/Compiler/Parsing.py

@@ -550,7 +550,7 @@ def p_trailer(s: PyrexScanner, node1):
 #             star_expr )
 
 @cython.cfunc
-def p_call_parse_args(s: PyrexScanner, allow_genexp: cython.bint = True):
+def p_call_parse_args(s: PyrexScanner, allow_genexp: cython.bint = True) -> tuple:
     # s.sy == '('
     s.next()
     positional_args = []
@@ -699,7 +699,7 @@ def p_subscript_list(s: PyrexScanner) -> tuple:
 #subscript: '.' '.' '.' | test | [test] ':' [test] [':' [test]]
 
 @cython.cfunc
-def p_subscript(s: PyrexScanner):
+def p_subscript(s: PyrexScanner) -> list:
     # Parse a subscript and return a list of
     # 1, 2 or 3 ExprNodes, depending on how
     # many slice elements were encountered.
@@ -731,7 +731,7 @@ def expect_ellipsis(s: PyrexScanner):
 
 
 @cython.cfunc
-def make_slice_nodes(pos, subscripts):
+def make_slice_nodes(pos, subscripts) -> list:
     # Convert a list of subscripts as returned
     # by p_subscript_list into a list of ExprNodes,
     # creating SliceNodes for elements with 2 or
@@ -1041,7 +1041,7 @@ def p_string_literal_shared_read(
     return result
 
 @cython.cfunc
-def _validate_kind_string(pos, systring: str):
+def _validate_kind_string(pos, systring: str) -> str:
     kind_string = systring.rstrip('"\'').lower()
     if len(kind_string) <= 1 or (len(kind_string) == 2 and kind_string in "rbrurfrtr"):
         return kind_string
@@ -1137,7 +1137,7 @@ def p_string_literal(s: PyrexScanner, kind_override=None) -> tuple:
 
 
 @cython.cfunc
-def p_read_ft_string_expression(s: PyrexScanner):
+def p_read_ft_string_expression(s: PyrexScanner) -> str:
     strings = []
     while True:
         s.next()
@@ -1154,7 +1154,7 @@ def p_read_ft_string_expression(s: PyrexScanner):
 @cython.cfunc
 def p_ft_string_replacement_field(s: PyrexScanner,
                                 is_raw: cython.bint, is_single_quoted: cython.bint,
-                                tf_string_kind: cython.Py_UCS4):
+                                tf_string_kind: cython.Py_UCS4) -> list:
     result = []
     conversion_char = format_spec = expr = None
     t_string_expression = None
@@ -1264,7 +1264,7 @@ def p_ft_string_replacement_field(s: PyrexScanner,
 def p_ft_string_middles(s: PyrexScanner,
                         is_raw: cython.bint, is_single_quoted: cython.bint,
                         is_format_string: cython.bint,
-                        tf_string_kind: cython.Py_UCS4):
+                        tf_string_kind: cython.Py_UCS4) -> list:
     middles: list = []
     builder = StringEncoding.UnicodeLiteralBuilder()
     pos = s.position()
@@ -1302,7 +1302,7 @@ def p_ft_string_middles(s: PyrexScanner,
     return middles
 
 @cython.cfunc
-def p_ft_string_literal(s: PyrexScanner):
+def p_ft_string_literal(s: PyrexScanner) -> tuple:
     # s.sy == BEGIN_FT_STRING
     kind_string = _validate_kind_string(s.position(), s.systring)
     tf_string_kind: cython.Py_UCS4 = 't' if 't' in kind_string else 'f'
@@ -1988,7 +1988,7 @@ def p_from_import_statement(s: PyrexScanner, first_statement: cython.bint = 0):
 
 
 @cython.cfunc
-def p_imported_name(s: PyrexScanner):
+def p_imported_name(s: PyrexScanner) -> tuple:
     pos = s.position()
     name = p_ident(s)
     as_name = p_as_name(s)
@@ -2684,7 +2684,7 @@ def p_suite_with_docstring(s: PyrexScanner, ctx, with_doc_only: cython.bint = Fa
 
 
 @cython.cfunc
-def p_positional_and_keyword_args(s: PyrexScanner, end_sy_set, templates = None):
+def p_positional_and_keyword_args(s: PyrexScanner, end_sy_set, templates = None) -> tuple:
     """
     Parses positional and keyword arguments. end_sy_set
     should contain any s.sy that terminate the argument list.
@@ -4713,7 +4713,7 @@ def p_class_pattern(s: PyrexScanner):
 
 
 @cython.cfunc
-def p_keyword_pattern(s: PyrexScanner):
+def p_keyword_pattern(s: PyrexScanner) -> tuple:
     if s.sy != "IDENT":
         s.error("Expected identifier")
     arg = p_name(s, s.systring)

{cython-3.2.3 → cython-3.2.4}/Cython/Compiler/Symtab.py

@@ -1901,12 +1901,6 @@ class ModuleScope(Scope):
         if self.directives.get('final'):
             entry.type.is_final_type = True
         collection_type = self.directives.get('collection_type')
-        if collection_type:
-            from .UtilityCode import NonManglingModuleScope
-            if not isinstance(self, NonManglingModuleScope):
-                # TODO - DW would like to make it public, but I'm making it internal-only
-                # for now to avoid adding new features without consensus
-                error(pos, "'collection_type' is not a public cython directive")
         if collection_type == 'sequence':
             entry.type.has_sequence_flag = True
 

{cython-3.2.3 → cython-3.2.4}/Cython/Includes/libcpp/exception.pxd

@@ -6,7 +6,47 @@ cdef extern from "<exception>" namespace "std" nogil:
 
     exception_ptr make_exception_ptr[E](E e) noexcept
     void rethrow_exception(exception_ptr) except +
-    # current_exception skipped because it'll be almost impossible to use from Cython
+    exception_ptr current_exception() noexcept
+
+    cdef cppclass exception:
+        const char* what() noexcept
+
+cdef extern from "<stdexcept>" namespace "std" nogil:
+    # Omitting the constructors of derived exception classes for now.
+    # They can't be stack-allocated easily in Cython because they don't have
+    # a nullary constructor. They also can't be thrown in Cython.
+    # So they're most useful just as class names when implementing
+    # exception handlers.
+    cdef cppclass logic_error(exception):
+        pass
+    cdef cppclass invalid_argument(logic_error):
+        pass
+    cdef cppclass domain_error(logic_error):
+        pass
+    cdef cppclass length_error(logic_error):
+        pass
+    cdef cppclass out_of_range(logic_error):
+        pass
+
+    cdef cppclass runtime_error(exception):
+        pass
+    cdef cppclass range_error(runtime_error):
+        pass
+    cdef cppclass overflow_error(runtime_error):
+        pass
+
+    cdef cppclass bad_typeid(exception):
+        pass
+
+    cdef cppclass bad_cast(exception):
+        pass
+
+    cdef cppclass bad_alloc(exception):
+        pass
+
+    cdef cppclass bad_exception(exception):
+        pass
+
 
 cdef extern from *:
     """

{cython-3.2.3 → cython-3.2.4}/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.2.3"
+__version__ = "3.2.4"
 
 
 # BEGIN shameless copy from Cython/minivect/minitypes.py
@@ -103,7 +103,7 @@ class _Optimization:
 cclass = ccall = cfunc = _EmptyDecoratorAndManager()
 
 annotation_typing = returns = wraparound = boundscheck = initializedcheck = \
-    nonecheck = embedsignature = cdivision = cdivision_warnings = \
+    nonecheck = embedsignature = cdivision = cdivision_warnings = collection_type = \
     always_allow_keywords = profile = linetrace = infer_types = \
     unraisable_tracebacks = freelist = auto_pickle = cpow = trashcan = \
     auto_cpdef = c_api_binop_methods = \

{cython-3.2.3 → cython-3.2.4}/Cython/Tests/TestShadow.py

@@ -8,9 +8,7 @@ class TestShadow(unittest.TestCase):
         missing_directives = []
         extra_directives = []
         for full_directive in Options.directive_types.keys():
-            # Python 2 doesn't support "directive, *rest = full_directive.split('.')"
-            split_directive = full_directive.split('.')
-            directive, rest = split_directive[0], split_directive[1:]
+            directive, *rest = full_directive.split('.')
 
             scope = Options.directive_scopes.get(full_directive)
             if scope and len(scope) == 1 and scope[0] == "module":
@@ -18,10 +16,6 @@ class TestShadow(unittest.TestCase):
                 if hasattr(Shadow, directive):
                     extra_directives.append(full_directive)
                 continue
-            if full_directive == "collection_type":
-                # collection_type is current restricted to utility code only
-                # so doesn't need to be in Shadow
-                continue
             if full_directive == "staticmethod":
                 # staticmethod is a weird special-case and not really intended to be
                 # used from the cython module

{cython-3.2.3 → cython-3.2.4}/Cython/Utility/Builtins.c

@@ -631,13 +631,13 @@ static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *ke
 
 static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value) {
     PyObject* value;
-#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030C0000
+#if __PYX_LIMITED_VERSION_HEX >= 0x030F0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4)
+    PyDict_SetDefaultRef(d, key, default_value, &value);
+#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030C0000
     PyObject *args[] = {d, key, default_value};
     value = PyObject_VectorcallMethod(PYIDENT("setdefault"), args, 3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
 #elif CYTHON_COMPILING_IN_LIMITED_API
     value = PyObject_CallMethodObjArgs(d, PYIDENT("setdefault"), key, default_value, NULL);
-#elif PY_VERSION_HEX >= 0x030d0000
-    PyDict_SetDefaultRef(d, key, default_value, &value);
 #else
     value = PyDict_SetDefault(d, key, default_value);
     if (unlikely(!value)) return NULL;

{cython-3.2.3 → cython-3.2.4}/Cython/Utility/StringTools.c

@@ -59,7 +59,7 @@ static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int al
 //@requires: TypeConversion.c::GCCDiagnostics
 
 static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo) {
-    PyObject *module, *decompress, *compressed_bytes, *decompressed;
+    PyObject *module = NULL, *decompress, *compressed_bytes, *decompressed;
 
     const char* module_name = algo == 3 ? "compression.zstd" : algo == 2 ? "bz2" : "zlib";
 
@@ -69,7 +69,7 @@ static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int al
     #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000
     if (algo == 3) {
         PyObject *fromlist = Py_BuildValue("[O]", methodname);
-        if (unlikely(!fromlist)) return NULL;
+        if (unlikely(!fromlist)) goto bad;
         module = PyImport_ImportModuleLevel("compression.zstd", NULL, NULL, fromlist, 0);
         Py_DECREF(fromlist);
     } else

cython-3.2.4/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.1
+Name: Cython
+Version: 3.2.4
+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.
+Author-email: cython-devel@python.org
+License: Apache-2.0
+Project-URL: Documentation, https://cython.readthedocs.io/
+Project-URL: Donate, https://cython.readthedocs.io/en/latest/src/donating.html
+Project-URL: Source Code, https://github.com/cython/cython
+Project-URL: Bug Tracker, https://github.com/cython/cython/issues/
+Project-URL: User Group, https://groups.google.com/g/cython-users
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Implementation :: Stackless
+Classifier: Programming Language :: C
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Cython
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+
+The Cython language makes writing C extensions for the Python language as
+easy as Python itself.  Cython is a source code translator based on Pyrex_,
+but supports more cutting edge functionality and optimizations.
+
+The Cython language is a superset of the Python language (almost all Python
+code is also valid Cython code), but Cython additionally supports optional
+static typing to natively call C functions, operate with C++ classes and
+declare fast C types on variables and class attributes.  This allows the
+compiler to generate very efficient C code from Cython code.
+
+This makes Cython the ideal language for writing glue code for external
+C/C++ libraries, and for fast C modules that speed up the execution of
+Python code.
+
+The newest Cython release can always be downloaded from https://cython.org/.
+Unpack the tarball or zip file, enter the directory, and then run::
+
+    pip install .
+
+Note that for one-time builds, e.g. for CI/testing, on platforms that are not
+covered by one of the wheel packages provided on PyPI *and* the pure Python wheel
+that we provide is not used, it is substantially faster than a full source build
+to install an uncompiled (slower) version of Cython with::
+
+    NO_CYTHON_COMPILE=true pip install .
+
+.. _Pyrex: https://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/
+
+3.2.4 (2026-01-04)
+==================
+
+Features added
+--------------
+
+* In preparation of Cython 3.3, a new decorator ``@collection_type(tname)`` can be used
+  to advertise an extension type as being a ``'sequence'`` or ``'mapping'``.  This currently
+  only has the effect of setting the ``Py_TPFLAGS_SEQUENCE`` flag on the type or not, but
+  is provided for convenience to allow using the new decorator already in Cython 3.2 code.
+
+* Several C++ exception declarations were added to ``libcpp.exceptions``.
+  (Github issue https://github.com/cython/cython/issues/7389)
+
+Bugs fixed
+----------
+
+* Pseudo-literal default values of function arguments like ``arg=str()`` could generate
+  invalid C code when internally converted into a real literal.
+  (Github issue https://github.com/cython/cython/issues/6192)
+
+* The pickle serialisation of extension types using the ``auto_pickle`` feature was
+  larger than necessary since 3.2.0 for types without Python object attributes.
+  It is now back to the state before 3.2.0 again.
+  (Github issue https://github.com/cython/cython/issues/7443)
+
+* Constants are now only made immortal on freethreading Python if they are not shared.
+  (Github issue https://github.com/cython/cython/issues/7439)
+
+* ``PyDict_SetDefaultRef()`` is now used when available to avoid temporary borrowed references.
+  (Github issue https://github.com/cython/cython/issues/7347)
+
+* Includes all fixes as of Cython 3.1.8.
+
+3.1.8 (2026-01-03):
+
+* 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)
+
+* 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)
+
+3.1.7 (2025-11-12):
+
+* 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 https://github.com/cython/cython/issues/7298)
+
+* Assigning nested structs from a list of structs (item by item) could crash Cython.
+  (Github issue https://github.com/cython/cython/issues/7308)
+
+* Cython incorrectly called ``PyList_GetItemRef()`` in PyPy and GraalPython before Py3.13.
+  (Github issue https://github.com/cython/cython/issues/7269)
+
+* Trying to instantiate internal types used by Cython is now prohibited.
+  (Github issue https://github.com/cython/cython/issues/7263)
+
+3.1.6 (2025-10-23):
+
+* 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)
+
+* ``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)
+
+3.1.5 (2025-10-20):
+
+* Conversion from C++ strings longer than ``PY_SSIZE_T_MAX`` did not validate the length.
+
+* Some non-Limited API code was incorrectly used in generated header files.
+  (Github issue https://github.com/cython/cython/issues/7157)
+
+* Optimised unpacking of Python integers in expressions uses a slightly safer scheme.
+  (Github issue https://github.com/cython/cython/issues/7134)
+
+* Empty return statements were not always reported when tracing.
+  (Github issue https://github.com/cython/cython/issues/7022)
+
+* Value conversion errors when tracing C return statements no longer fail the trace
+  but fall back to reporting ``None`` returns instead.
+  (Github issue https://github.com/cython/cython/issues/6503)

{cython-3.2.3 → cython-3.2.4}/tests/run/cyfunction_defaults.pyx

@@ -290,6 +290,17 @@ def test_func_default_scope_local():
     print i  # genexprs don't leak
     return func
 
+
+def test_str_call(arg=str()):
+    """
+    The call to str() is optimized into a literal late in the process.
+    This shouldn't break the usage.
+    >>> test_str_call()
+    ''
+    """
+    return arg
+
+
 cdef class C:
     def f1(self, a, b=1, c=[]):
         pass

{cython-3.2.3 → cython-3.2.4}/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.2.3 → cython-3.2.4}/tests/run/reduce_pickle.pyx

@@ -319,3 +319,35 @@ else:
         >>> b == NoPyMembers(i=11, x=1.5) or b
         True
         """
+
+OLD_310_PICKLE = b'''\
+\x80\x04\x95a\x00\x00\x00\x00\x00\x00\x00\x8c\rreduce_pickle\x94\x8c\x1a\
+__pyx_unpickle_NoPyMembers\x94\x93\x94h\x00\x8c\x0bNoPyMembers\
+\x94\x93\x94J\x03\x03\x1f\x08]\x94(K\x0bKyM3\x05eG?\xf8\x00\x00\x00\x00\x00\x00\x86\x94\x87\x94R\x94.\
+'''
+
+# 3.2.0 had a bug that made the pickles larger than necessary.
+# 3.2.4 fixed this and brought it back to the 3.1 pickle putput.
+# https://github.com/cython/cython/issues/7443
+OLD_320_PICKLE = b'''\
+\x80\x04\x95c\x00\x00\x00\x00\x00\x00\x00\x8c\rreduce_pickle\x94\x8c\x1a\
+__pyx_unpickle_NoPyMembers\x94\x93\x94h\x00\x8c\x0bNoPyMembers\
+\x94\x93\x94J\x03\x03\x1f\x08N\x87\x94R\x94]\x94(K\x0bKyM3\x05eG?\xf8\x00\x00\x00\x00\x00\x00\x86\x94b.\
+'''
+
+def unpickle_old_pickles():
+    """
+    >>> import pickle
+
+    # To print the current pickle for later updates:
+    #>>> b = NoPyMembers(i=11, x=1.5)
+    #>>> pickle.dumps(b, protocol=5)  # choose desired pickle protocol version
+
+    >>> b = pickle.loads(OLD_310_PICKLE)
+    >>> b == NoPyMembers(i=11, x=1.5) or b  # OLD_310_PICKLE
+    True
+
+    >>> b = pickle.loads(OLD_320_PICKLE)
+    >>> b == NoPyMembers(i=11, x=1.5) or b  # OLD_320_PICKLE
+    True
+    """

cython-3.2.3/.gitrev

@@ -1 +0,0 @@
-5bb6ce9ec2c3ab6acef5d4fceae8ab54ab815fca