Cython 3.2.4__tar.gz → 3.2.5__tar.gz

cython-3.2.5/.gitrev

@@ -0,0 +1 @@
+ec152091ca7c535e04b5da96e5bedfc9b33def22

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

@@ -2,6 +2,87 @@
 Cython Changelog
 ================
 
+3.2.5 (2026-05-23)
+==================
+
+Bugs fixed
+----------
+
+* A compile failure was fixed when using the walrus operator inside of try-except.
+  (Github issue :issue:`7462`)
+
+* Expressions with side-effects as object argument to ``isinstance()`` could get
+  evaluated multiple times, e.g. when they use the walrus operator.
+  (Github issue :issue:`7670`)
+
+* Several problems generating the shared utility module were resolved, including
+  a performance regression with memory views.
+  (Github issues :issue:`7487`, :issue:`7497`, :issue:`7504`, :issue:`7558`)
+
+* Some GC and refcounting issues were resolved for Cython functions in the Limited API.
+  (Github issue :issue:`7594`)
+
+* Refcounting errors and error handling issues were resolved in some rare error handling cases.
+  (Github issues :issue:`7597`, :issue:`7599`, :issue:`7612`, :issue:`7673`)
+
+* Using ``cython.pymutex`` in an extension type with ``cdef`` methods generated
+  invalid C code missing the required ``PyMutex`` declarations.
+  (Github issue :issue:`6995`)
+
+* Calling ``.get_frame()`` on Cython coroutines could crash in freethreading Python.
+  (Github issue :issue:`7632`)
+
+* The vectorcall protocol was not used correctly in ``.throw()`` of Cython coroutines
+  when raising the exception only by type (without value or traceback).
+  (Github issue :issue:`7677`)
+
+* A problem with cpdef enums in the Limited API of Python 3.11+ was resolved.
+  (Github issue :issue:`7503`)
+
+* Unicode predicates like ``.isdigit()`` are now allowed to fail in the Limited API.
+  (Github issue :issue:`7602`)
+
+* Conditional expressions mixing Python float and int object types could accidentally
+  infer float as the common result type, instead of treating both independently.
+
+* Using ``sizeof()`` in the size declarations of ``extern`` arrays failed.
+  (Github issue :issue:`7451`)
+
+* Enabling profiling generated invalid C code for non-Python return tuples.
+  (Github issue :issue:`7580`)
+
+* ``abs()`` on C ``long long`` values could generate invalid C code.
+
+* When the ``CYTHON_AVOID_BORROWED_REFS`` C macro is enabled, e.g. in GraalPython,
+  dict iteration could fail to compile.
+  Patch by Michael Šimáček.  (Github issue :issue:`7631`)
+
+* A C compiler warning about unused functions was resolved.
+  (Github issue :issue:`7560`)
+
+* The ``py_safe_call_once()`` C++ mutex helper function in ``libcpp.mutex``
+  failed to compile.
+  (Github issue :issue:`7585`)
+
+* The ``cpython.array`` declarations were adapted for Python 3.15.  Direct access
+  to the C struct of the ``array.array`` data type might require user code changes.
+  (Github issue :issue:`7659`)
+
+* Spaces in file paths written to the ``depfile`` were not escaped.
+  Patch by Loïc Estève.  (Github issue :issue:`7423`)
+
+* Cython's cache failed to restore multi-file results.
+  (Github issue :issue:`7559`)
+
+* Using Tempita from its command line failed with a name error.
+  (Github issue :issue:`7567`)
+
+Other changes
+-------------
+
+* The known builtin types were updated for Py3.15.
+
+
 3.2.4 (2026-01-04)
 ==================
 

{cython-3.2.4 → cython-3.2.5}/Cython/Build/Cache.py

@@ -152,7 +152,7 @@ class Cache:
             dirname = os.path.dirname(c_file)
             with zipfile.ZipFile(cached) as z:
                 for artifact in z.namelist():
-                    z.extract(artifact, join_path(dirname, artifact))
+                    z.extract(artifact, dirname)
         else:
             raise ValueError(f"Unsupported cache file extension: {ext}")
 

{cython-3.2.4 → cython-3.2.5}/Cython/Build/Tests/TestCyCache.py

@@ -149,6 +149,7 @@ class TestCyCache(CythonTest):
 
         for output in expected:
             self.assertTrue(os.path.exists(output), output)
+            self.assertTrue(os.path.isfile(output), output)
 
     def test_multi_file_output_cythonize(self):
         self._test_multi_file_output(self.fresh_cythonize)

{cython-3.2.4 → cython-3.2.5}/Cython/Build/Tests/TestInline.py

@@ -125,7 +125,7 @@ class TestCymeit(unittest.TestCase):
             self.assertGreaterEqual(max_time, 100_000)
         else:
             self.assertGreaterEqual(max_time, 0.0001)
-        self.assertGreater(number, 10)  # arbitrary lower bound for our very quick benchmarks
+        self.assertGreater(number, 4)  # arbitrary lower bound for our very quick benchmarks
 
         return timings
 

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

@@ -95,7 +95,7 @@ basicsize_builtins_map = {
 }
 
 # Builtins as of Python version ...
-KNOWN_PYTHON_BUILTINS_VERSION = (3, 14, 0, 'beta', 1)
+KNOWN_PYTHON_BUILTINS_VERSION = (3, 15, 0, 'beta', 1)
 KNOWN_PYTHON_BUILTINS = frozenset([
     'ArithmeticError',
     'AssertionError',
@@ -125,6 +125,7 @@ KNOWN_PYTHON_BUILTINS = frozenset([
     'FutureWarning',
     'GeneratorExit',
     'IOError',
+    'ImportCycleError',
     'ImportError',
     'ImportWarning',
     'IndentationError',
@@ -176,6 +177,7 @@ KNOWN_PYTHON_BUILTINS = frozenset([
     '_IncompleteInputError',
     '__build_class__',
     '__debug__',
+    '__lazy_import__',
     '__import__',
     'abs',
     'aiter',
@@ -206,6 +208,7 @@ KNOWN_PYTHON_BUILTINS = frozenset([
     'filter',
     'float',
     'format',
+    'frozendict',
     'frozenset',
     'getattr',
     'globals',
@@ -240,6 +243,7 @@ KNOWN_PYTHON_BUILTINS = frozenset([
     'repr',
     'reversed',
     'round',
+    'sentinel',
     'set',
     'setattr',
     'slice',
@@ -257,6 +261,11 @@ KNOWN_PYTHON_BUILTINS = frozenset([
 uncachable_builtins = [
     # Global/builtin names that cannot be cached because they may or may not
     # be available at import time, for various reasons:
+    ## Python 3.15+
+    'frozendict',
+    'sentinel',
+    'ImportCycleError',
+    '__lazy_import__',
     ## Python 3.13+
     '_IncompleteInputError',
     'PythonFinalizationError',
@@ -267,11 +276,10 @@ uncachable_builtins = [
     'aiter',
     'anext',
     'EncodingWarning',
-    ## - Py3.7+
-    'breakpoint',  # might deserve an implementation in Cython
     ## - platform specific
     'WindowsError',
     ## - others
+    'breakpoint',  # Probably best left alone.
     '_',  # e.g. used by gettext
 ]
 

{cython-3.2.4 → cython-3.2.5}/Cython/Compiler/CythonScope.py

@@ -6,6 +6,7 @@ from .Scanning import StringSourceDescriptor
 from . import MemoryView
 from .StringEncoding import EncodedString
 
+NON_TYPE_NAMES = {'pointer', 'const', 'volatile', 'restrict', 'struct', 'union', 'enum'}
 
 class CythonScope(ModuleScope):
     is_cython_builtin = 1
@@ -42,6 +43,8 @@ class CythonScope(ModuleScope):
 
     def lookup_type(self, name):
         # This function should go away when types are all first-level objects.
+        if name in NON_TYPE_NAMES:
+            return None
         type = parse_basic_type(name)
         if type:
             return type

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

@@ -7551,7 +7551,7 @@ class MergedDictNode(ExprNode):
                 items = ((key.constant_result, value.constant_result)
                          for key, value in item.key_value_pairs)
             else:
-                items = item.constant_result.iteritems()
+                items = item.constant_result.items()
 
             for key, value in items:
                 if reject_duplicates and key in result:
@@ -7569,7 +7569,7 @@ class MergedDictNode(ExprNode):
                 items = [(key.compile_time_value(denv), value.compile_time_value(denv))
                          for key, value in item.key_value_pairs]
             else:
-                items = item.compile_time_value(denv).iteritems()
+                items = item.compile_time_value(denv).items()
 
             try:
                 for key, value in items:

{cython-3.2.4 → cython-3.2.5}/Cython/Compiler/FlowControl.py

@@ -85,6 +85,18 @@ class ControlBlock:
         self.children.add(block)
         block.parents.add(self)
 
+    def print(self, level=0, seen=None):
+        if seen is None:
+            seen = set()
+        print(f"{' '*level}{self} {'*' if self in seen else ''}")
+        if self in seen:
+            return
+        for stat in self.stats:
+            print(f"{' '*(level+1)}-{stat}")
+        seen.add(self)
+        for child in self.children:
+            child.print(level+1, seen)
+
 
 class ExitBlock(ControlBlock):
     """Non-empty exit point block."""
@@ -926,8 +938,9 @@ class ControlFlowAnalysis(CythonTransform):
         parent = self.flow.block
         # If clauses
         for clause in node.if_clauses:
-            parent = self.flow.nextblock(parent)
+            self.flow.nextblock(parent)
             self._visit(clause.condition)
+            parent = self.flow.block
             self.flow.nextblock()
             self._visit(clause.body)
             if self.flow.block:
@@ -974,6 +987,7 @@ class ControlFlowAnalysis(CythonTransform):
         self.flow.loops.append(LoopDescr(next_block, condition_block))
         if node.condition:
             self._visit(node.condition)
+        condition_block_end = self.flow.block
         # Body block
         self.flow.nextblock()
         self._visit(node.body)
@@ -984,12 +998,12 @@ class ControlFlowAnalysis(CythonTransform):
             self.flow.block.add_child(next_block)
         # Else clause
         if node.else_clause:
-            self.flow.nextblock(parent=condition_block)
+            self.flow.nextblock(parent=condition_block_end)
             self._visit(node.else_clause)
             if self.flow.block:
                 self.flow.block.add_child(next_block)
         else:
-            condition_block.add_child(next_block)
+            condition_block_end.add_child(next_block)
 
         if next_block.parents:
             self.flow.block = next_block
@@ -1072,6 +1086,7 @@ class ControlFlowAnalysis(CythonTransform):
         # Condition with iterator
         self.flow.loops.append(LoopDescr(next_block, condition_block))
         self._visit(node.iterator)
+        condition_block_end = self.flow.block
         # Target assignment
         self.flow.nextblock()
 
@@ -1096,12 +1111,12 @@ class ControlFlowAnalysis(CythonTransform):
             self.flow.block.add_child(condition_block)
         # Else clause
         if node.else_clause:
-            self.flow.nextblock(parent=condition_block)
+            self.flow.nextblock(parent=condition_block_end)
             self._visit(node.else_clause)
             if self.flow.block:
                 self.flow.block.add_child(next_block)
         else:
-            condition_block.add_child(next_block)
+            condition_block_end.add_child(next_block)
 
         if next_block.parents:
             self.flow.block = next_block
@@ -1152,6 +1167,7 @@ class ControlFlowAnalysis(CythonTransform):
         self._visit(node.bound2)
         if node.step is not None:
             self._visit(node.step)
+        condition_block_end = self.flow.block
         # Target assignment
         self.flow.nextblock()
         self.mark_assignment(node.target, node.bound1)
@@ -1167,12 +1183,12 @@ class ControlFlowAnalysis(CythonTransform):
             self.flow.block.add_child(condition_block)
         # Else clause
         if node.else_clause:
-            self.flow.nextblock(parent=condition_block)
+            self.flow.nextblock(parent=condition_block_end)
             self._visit(node.else_clause)
             if self.flow.block:
                 self.flow.block.add_child(next_block)
         else:
-            condition_block.add_child(next_block)
+            condition_block_end.add_child(next_block)
 
         if next_block.parents:
             self.flow.block = next_block

{cython-3.2.4 → cython-3.2.5}/Cython/Compiler/MemoryView.py

@@ -301,6 +301,7 @@ class MemoryViewSliceBufferEntry(Buffer.BufferEntry):
                     util_name = "SimpleSlice"
                 else:
                     util_name = "ToughSlice"
+                    code.globalstate.use_utility_code(slice_memviewslice_utility)
                     d['error_goto'] = code.error_goto(index.pos)
 
                 new_ndim += 1
@@ -847,6 +848,7 @@ refcount_utility = load_memview_c_utility("MemviewRefcount")
 slice_init_utility = load_memview_c_utility("MemviewSliceInit")
 memviewslice_declare_code = load_memview_c_utility("MemviewSliceStruct", context=template_context)
 copy_contents_new_utility = load_memview_c_utility("MemviewSliceCopy")
+slice_memviewslice_utility = load_memview_c_utility("SliceMemoryviewSlice")
 
 
 @Utils.cached_function
@@ -863,6 +865,7 @@ def _get_memoryview_utility_code():
                     is_contig_utility,
                     overlapping_utility,
                     copy_contents_new_utility,
+                    slice_memviewslice_utility,
                     ],
     )
 

{cython-3.2.4 → cython-3.2.5}/Cython/Compiler/ModuleNode.py

@@ -1401,6 +1401,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
             for method_entry in scope.cfunc_entries:
                 if not method_entry.is_inherited:
                     code.putln("%s;" % method_entry.type.declaration_code("(*%s)" % method_entry.cname))
+                    code.globalstate.use_entry_utility_code(method_entry)
             code.putln("};")
 
     def generate_exttype_vtabptr_declaration(self, entry, code):

{cython-3.2.4 → cython-3.2.5}/Cython/Compiler/Nodes.py

@@ -646,11 +646,12 @@ class CArrayDeclaratorNode(CDeclaratorNode):
                 error(self.dimension.pos, "Array dimension cannot be const variable")
             size = (self.dimension.constant_result if isinstance(self.dimension.constant_result, int)
                     else self.dimension.get_constant_c_result_code())
-            try:
-                size = int(size)
-            except ValueError:
-                # runtime constant?
-                pass
+            if size is not None:
+                try:
+                    size = int(size)
+                except ValueError:
+                    # runtime constant?
+                    pass
 
         if not base_type.is_complete():
             error(self.pos, "Array element type '%s' is incomplete" % base_type)
@@ -4276,7 +4277,7 @@ class DefNodeWrapper(FuncDefNode):
             f"{'' if accept_kwd_args else 'unlikely'}({Naming.kwds_cname}) ? "
             f"__Pyx_NumKwargs_{self.signature.fastvar}({Naming.kwds_cname}) : 0;"
         )
-        code.putln(f"if (unlikely({Naming.kwds_len_cname}) < 0) {goto_error}")
+        code.putln(f"if (unlikely({Naming.kwds_len_cname} < 0)) {goto_error}")
 
         kw_unpacking_condition = f"{Naming.kwds_len_cname} > 0"
         if self.num_required_kw_args > 0:

{cython-3.2.4 → cython-3.2.5}/Cython/Compiler/Optimize.py

@@ -2882,7 +2882,11 @@ class OptimizeBuiltinCalls(Visitor.NodeRefCleanupMixin,
         # Map the separate type checks to check functions.
 
         if types and (allowed_none_node or len(types) > 1):
-            if arg.is_attribute or not arg.is_simple():
+            # Only literals and simple (non-temp) name lookups are safe to use multiple times
+            # without caching.  Everything else — attributes, calls, walrus operators, temps,
+            # etc. — must be evaluated exactly once and its result cached in a ResultRefNode
+            # to avoid repeated evaluation across the short-circuit OR branches.
+            if not (arg.is_literal or (arg.is_name and not arg.is_temp)):
                 arg = UtilNodes.ResultRefNode(arg)
                 temps.append(arg)
 
@@ -3531,7 +3535,8 @@ class OptimizeBuiltinCalls(Visitor.NodeRefCleanupMixin,
     PyUnicode_uchar_predicate_func_type = PyrexTypes.CFuncType(
         PyrexTypes.c_bint_type, [
             PyrexTypes.CFuncTypeArg("uchar", PyrexTypes.c_py_ucs4_type, None),
-            ])
+            ],
+            exception_value=-1)
 
     def _inject_unicode_predicate(self, node, function, args, is_unbound_method):
         if is_unbound_method or len(args) != 1:

{cython-3.2.4 → cython-3.2.5}/Cython/Compiler/PyrexTypes.py

@@ -4689,6 +4689,8 @@ class CTupleType(CType):
 
     _convert_to_py_code = None
     _convert_from_py_code = None
+    to_py_function = None
+    from_py_function = None
 
     def __init__(self, cname, components):
         from .Builtin import tuple_type
@@ -4696,8 +4698,6 @@ class CTupleType(CType):
         self.components = components
         self.equivalent_type = tuple_type
         self.size = len(components)
-        self.to_py_function = f"{Naming.convert_func_prefix}_to_py_{self.cname}"
-        self.from_py_function = f"{Naming.convert_func_prefix}_from_py_{self.cname}"
 
     def __str__(self):
         return "(%s)" % ", ".join(str(c) for c in self.components)
@@ -4732,6 +4732,7 @@ class CTupleType(CType):
                 return False
 
         if self._convert_to_py_code is None:
+            self.to_py_function = f"{Naming.convert_func_prefix}_to_py_{self.cname}"
             context = dict(
                 struct_type_decl=self.empty_declaration_code(),
                 components=self.components,
@@ -4755,6 +4756,7 @@ class CTupleType(CType):
                 return False
 
         if self._convert_from_py_code is None:
+            self.from_py_function = f"{Naming.convert_func_prefix}_from_py_{self.cname}"
             context = dict(
                 struct_type_decl=self.empty_declaration_code(),
                 components=self.components,
@@ -5545,6 +5547,10 @@ def independent_spanning_type(type1, type2):
             return resolved_type1
         # e.g. PyInt + double => object
         return py_object_type
+    elif resolved_type1.is_builtin_type and resolved_type2.is_builtin_type:
+        # Either numeric or incompatible. Do not try to find a widest Python type
+        # (e.g. int+float => float) as it would change one of the result types.
+        return py_object_type
 
     span_type = _spanning_type(type1, type2)
     if span_type is None:

{cython-3.2.4 → cython-3.2.5}/Cython/Compiler/Tests/TestBuiltin.py

@@ -1,4 +1,6 @@
 import builtins
+import json
+import subprocess
 import sys
 import unittest
 
@@ -41,9 +43,17 @@ class TestBuiltinCompatibility(unittest.TestCase):
         expected_builtins = set(KNOWN_PYTHON_BUILTINS)
         if sys.platform != 'win32':
             expected_builtins.discard("WindowsError")
+
+        # Read builtins from fresh Python process to prevent modifications by test dependencies.
+        output = subprocess.run(
+            [sys.executable, '-c', 'import builtins, json, sys; sys.stdout.write(json.dumps(dir(builtins)))'],
+            capture_output=True,
+            encoding='utf8',
+        )
         runtime_builtins = frozenset(
-            name for name in dir(builtins)
+            name for name in json.loads(output.stdout)
             if name not in ('__doc__', '__loader__', '__name__', '__package__', '__spec__'))
+
         if sys.version_info < KNOWN_PYTHON_BUILTINS_VERSION:
             missing_builtins = expected_builtins - runtime_builtins
             if missing_builtins:

{cython-3.2.4 → cython-3.2.5}/Cython/Compiler/TreeFragment.py

@@ -22,12 +22,12 @@ from . import UtilNodes
 
 
 class StringParseContext(Main.Context):
-    def __init__(self, name, include_directories=None, compiler_directives=None, cpp=False):
+    def __init__(self, name, include_directories=None, compiler_directives=None, cpp=False, options=None):
         if include_directories is None:
             include_directories = []
         if compiler_directives is None:
             compiler_directives = {}
-        Main.Context.__init__(self, include_directories, compiler_directives, cpp=cpp, language_level='3')
+        Main.Context.__init__(self, include_directories, compiler_directives, cpp=cpp, language_level='3', options=options)
         self.module_name = name
 
     def find_module(self, module_name, from_module=None, pos=None, need_pxd=1, absolute_fallback=True, relative_import=False):

{cython-3.2.4 → cython-3.2.5}/Cython/Compiler/UtilityCode.py

@@ -125,7 +125,8 @@ class CythonUtilityCode(Code.UtilityCodeBase):
         from . import Pipeline, ParseTreeTransforms
         context = CythonUtilityCodeContext(
             self.name, compiler_directives=self.compiler_directives,
-            cpp=cython_scope.is_cpp() if cython_scope else False)
+            cpp=cython_scope.is_cpp() if cython_scope else False,
+            options=cython_scope.context.options if cython_scope else None)
         context.prefix = self.prefix
         context.cython_scope = cython_scope
         #context = StringParseContext(self.name)
@@ -327,6 +328,8 @@ class CythonSharedUtilityCode(Code.AbstractUtilityCode):
                 dep.declare_in_scope(scope, cython_scope=cython_scope)
         for e in self._shared_library_scope.c_class_entries:
             dest_scope.add_imported_entry(e.name, e, e.pos)
+        for e in self._shared_library_scope.var_entries:
+            dest_scope.add_imported_entry(e.name, e, e.pos)
         return dest_scope
 
     def get_shared_library_scope(self, cython_scope):

{cython-3.2.4 → cython-3.2.5}/Cython/Includes/cpython/array.pxd

@@ -70,7 +70,9 @@ cdef extern from *:  # Hard-coded utility code hack.
     ctypedef object GETF(array a, Py_ssize_t ix)
     ctypedef object SETF(array a, Py_ssize_t ix, object o)
     ctypedef struct arraydescr:  # [object arraydescr]:
-        char typecode
+        char typecode "typecode_char"  # backwards compatibility only
+        char typecode_char             # Python <= 3.14
+        char typecode_array[3]         # Python 3.15+
         int itemsize
         GETF getitem    # PyObject * (*getitem)(struct arrayobject *, Py_ssize_t);
         SETF setitem    # int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *);
@@ -104,34 +106,6 @@ cdef extern from *:  # Hard-coded utility code hack.
         cdef inline __data_union data(self) noexcept nogil:
             return __Pyx_PyArray_Data(self)
 
-        def __getbuffer__(self, Py_buffer* info, int flags):
-            # This implementation of getbuffer is geared towards Cython
-            # requirements, and does not yet fulfill the PEP.
-            # In particular strided access is always provided regardless
-            # of flags
-            item_count = Py_SIZE(self)
-
-            info.suboffsets = NULL
-            info.buf = self.data.as_chars
-            info.readonly = 0
-            info.ndim = 1
-            info.itemsize = self.ob_descr.itemsize   # e.g. sizeof(float)
-            info.len = info.itemsize * item_count
-
-            info.shape = <Py_ssize_t*> PyObject_Malloc(sizeof(Py_ssize_t) + 2)
-            if not info.shape:
-                raise MemoryError()
-            info.shape[0] = item_count      # constant regardless of resizing
-            info.strides = &info.itemsize
-
-            info.format = <char*> (info.shape + 1)
-            info.format[0] = self.ob_descr.typecode
-            info.format[1] = 0
-            info.obj = self
-
-        def __releasebuffer__(self, Py_buffer* info):
-            PyObject_Free(info.shape)
-
     array newarrayobject(PyTypeObject* type, Py_ssize_t size, arraydescr *descr)
 
     __data_union __Pyx_PyArray_Data(array self) noexcept nogil

{cython-3.2.4 → cython-3.2.5}/Cython/Includes/libcpp/mutex.pxd

@@ -158,7 +158,7 @@ cdef extern from *:
 
     namespace {
 
-    static PyGILState_STATE __pyx_libcpp_mutex_limited_api_ensure_gil() {
+    CYTHON_UNUSED PyGILState_STATE __pyx_libcpp_mutex_limited_api_ensure_gil() {
         #if CYTHON_COMPILING_IN_LIMITED_API
         if ((__PYX_LIMITED_VERSION_HEX < 0x030d0000) && __Pyx_get_runtime_version() < 0x030d0000) {
             return PyGILState_Ensure();
@@ -168,7 +168,7 @@ cdef extern from *:
     }
 
     #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000
-    static void __pyx_libcpp_mutex_limited_api_release_gil(PyGILState_STATE gil_state) {
+    CYTHON_UNUSED void __pyx_libcpp_mutex_limited_api_release_gil(PyGILState_STATE gil_state) {
         if (__Pyx_get_runtime_version() < 0x030d0000)
             PyGILState_Release(gil_state);
     }
@@ -176,7 +176,7 @@ cdef extern from *:
     #define __pyx_libcpp_mutex_limited_api_release_gil(ignore) (void)ignore
     #endif
 
-    static int __pyx_libcpp_mutex_has_gil() {
+    CYTHON_UNUSED int __pyx_libcpp_mutex_has_gil() {
         #if CYTHON_COMPILING_IN_LIMITED_API
             if ((__PYX_LIMITED_VERSION_HEX >= 0x030d0000) || __Pyx_get_runtime_version() >= 0x030d0000) {
                 // In 3.13+ we can temporarily give up the GIL to find out what the thread state was
@@ -232,7 +232,7 @@ cdef extern from *:
     }
 
     template <typename Callable, typename ... Args>
-    void __pyx_cpp_py_safe_call_once(std::once_flag& flag, Callable& callable, Args&&... args) {
+    void __pyx_cpp_py_safe_call_once(std::once_flag& flag, Callable&& callable, Args&&... args) {
         class PyException : public std::exception {
         public:
             using std::exception::exception;
@@ -246,7 +246,7 @@ cdef extern from *:
 
         try {
             std::call_once(flag,
-                [&](Args& ...args) {
+                [&](Args&& ...args) {
                     // Make sure we have the GIL
                     PyGILState_STATE gil_state;
                     int had_gil_on_call = __Pyx_UnknownThreadStateDefinitelyHadGil(thread_state);
@@ -296,7 +296,7 @@ cdef extern from *:
         std::lock(arg0, arg1, args...);
     }
 
-    inline void __pyx_libcpp_mutex_unlock() {} // no-op
+    CYTHON_UNUSED inline void __pyx_libcpp_mutex_unlock() {} // no-op
 
     template <typename Lockable0T, typename ... Lockables>
     void __pyx_libcpp_mutex_unlock(Lockable0T& arg0, Lockables&... locks) {

{cython-3.2.4 → cython-3.2.5}/Cython/Runtime/refnanny.pyx

@@ -139,7 +139,7 @@ cdef PyObject* SetupContext(char* funcname, Py_ssize_t lineno, char* filename) e
     PyErr_Restore(type, value, tb)
     return result
 
-cdef void GOTREF(PyObject* _ctx, PyObject* p_obj, Py_ssize_t lineno):
+cdef void GOTREF(PyObject* _ctx, PyObject* p_obj, Py_ssize_t lineno) noexcept:
     if _ctx == NULL: return
     cdef (PyObject*) type = NULL, value = NULL, tb = NULL
     cdef Context ctx = <Context> _ctx
@@ -158,7 +158,7 @@ cdef void GOTREF(PyObject* _ctx, PyObject* p_obj, Py_ssize_t lineno):
         ctx.release_lock()
         return  # swallow any exceptions
 
-cdef bint GIVEREF_and_report(PyObject* _ctx, PyObject* p_obj, Py_ssize_t lineno):
+cdef bint GIVEREF_and_report(PyObject* _ctx, PyObject* p_obj, Py_ssize_t lineno) noexcept:
     if _ctx == NULL: return 1
     cdef (PyObject*) type = NULL, value = NULL, tb = NULL
     cdef bint decref_ok = False
@@ -178,20 +178,20 @@ cdef bint GIVEREF_and_report(PyObject* _ctx, PyObject* p_obj, Py_ssize_t lineno)
         ctx.release_lock()
         return decref_ok  # swallow any exceptions
 
-cdef void GIVEREF(PyObject* ctx, PyObject* p_obj, Py_ssize_t lineno):
+cdef void GIVEREF(PyObject* ctx, PyObject* p_obj, Py_ssize_t lineno) noexcept:
     GIVEREF_and_report(ctx, p_obj, lineno)
 
-cdef void INCREF(PyObject* ctx, PyObject* obj, Py_ssize_t lineno):
+cdef void INCREF(PyObject* ctx, PyObject* obj, Py_ssize_t lineno) noexcept:
     Py_XINCREF(obj)
     PyThreadState_Get()  # Check that we hold the GIL
     GOTREF(ctx, obj, lineno)
 
-cdef void DECREF(PyObject* ctx, PyObject* obj, Py_ssize_t lineno):
+cdef void DECREF(PyObject* ctx, PyObject* obj, Py_ssize_t lineno) noexcept:
     if GIVEREF_and_report(ctx, obj, lineno):
         Py_XDECREF(obj)
     PyThreadState_Get()  # Check that we hold the GIL
 
-cdef void FinishContext(PyObject** ctx):
+cdef void FinishContext(PyObject** ctx) noexcept:
     if ctx == NULL or ctx[0] == NULL: return
     cdef (PyObject*) type = NULL, value = NULL, tb = NULL
     cdef object errors = None

{cython-3.2.4 → cython-3.2.5}/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.4"
+__version__ = "3.2.5"
 
 
 # BEGIN shameless copy from Cython/minivect/minitypes.py