Cython 3.2.1__py3-none-any.whl → 3.2.3__py3-none-any.whl

Cython/Build/Cythonize.py

@@ -12,10 +12,8 @@ from ..Compiler import Options
 
 try:
     import multiprocessing
-    parallel_compiles = int(multiprocessing.cpu_count() * 1.5)
 except ImportError:
     multiprocessing = None
-    parallel_compiles = 0
 
 
 def find_package_base(path):
@@ -85,7 +83,8 @@ def _build(ext_modules, parallel):
     if not modcount:
         return
 
-    serial_execution_mode = modcount == 1 or parallel < 2
+    serial_execution_mode = modcount == 1 or (
+        parallel is not None and parallel < 2)
 
     try:
         pool_cm = (
@@ -248,8 +247,8 @@ Environment variables:
                       help="use CODESTRING as pre-benchmark setup code for --bench")
 
     parser.add_argument('-j', '--parallel', dest='parallel', metavar='N',
-                      type=int, default=parallel_compiles,
-                      help=f'run builds in N parallel jobs (default: {parallel_compiles or 1})')
+                      type=int, default=None,
+                      help='run builds in N parallel jobs (default: CPU count)')
     parser.add_argument('-f', '--force', dest='force', action='store_true', default=None,
                       help='force recompilation')
     parser.add_argument('-q', '--quiet', dest='quiet', action='store_true', default=None,

Cython/Build/Tests/TestCythonizeArgsParser.py

@@ -1,6 +1,5 @@
 from Cython.Build.Cythonize import (
     create_args_parser, parse_args_raw, parse_args,
-    parallel_compiles
 )
 
 from Cython.Compiler import Options
@@ -22,7 +21,9 @@ class TestCythonizeArgsParser(TestCase):
     def are_default(self, options, skip):
         # empty containers
         empty_containers = ['directives', 'compile_time_env', 'options', 'excludes']
-        are_none = ['language_level', 'annotate', 'build', 'build_inplace', 'force', 'quiet', 'lenient', 'keep_going', 'no_docstrings']
+        are_none = [
+            'language_level', 'annotate', 'build', 'build_inplace', 'force', 'quiet', 'lenient', 'keep_going', 'no_docstrings', 'parallel'
+        ]
         for opt_name in empty_containers:
             if len(getattr(options, opt_name))!=0 and (opt_name not in skip):
                 self.assertEqual(opt_name,"", msg="For option "+opt_name)
@@ -31,8 +32,6 @@ class TestCythonizeArgsParser(TestCase):
             if (getattr(options, opt_name) is not None) and (opt_name not in skip):
                 self.assertEqual(opt_name,"", msg="For option "+opt_name)
                 return False
-        if options.parallel!=parallel_compiles and ('parallel' not in skip):
-            return False
         return True
 
     # testing directives:

Cython/Compiler/Builtin.py

@@ -20,9 +20,16 @@ pyexec_globals_utility_code = UtilityCode.load("PyExecGlobals", "Builtins.c")
 globals_utility_code = UtilityCode.load("Globals", "Builtins.c")
 range_utility_code = UtilityCode.load("PyRange_Check", "Builtins.c")
 include_std_lib_h_utility_code = UtilityCode.load("IncludeStdlibH", "ModuleSetupCode.c")
-pysequence_multiply_utility_code = UtilityCode.load("PySequenceMultiply", "ObjectHandling.c")
 slice_accessor_utility_code = UtilityCode.load("PySliceAccessors", "Builtins.c")
 
+def make_sequence_multiply_method(typeobj_cname):
+    pysequence_multiply_utility_code = TempitaUtilityCode.load(
+        "BuiltinSequenceMultiply", "ObjectHandling.c",
+        context={'typeobj': typeobj_cname})
+    return BuiltinMethod("__mul__",  "Tz",   "T", f"__Pyx_{typeobj_cname}_Multiply",
+                         utility_code=pysequence_multiply_utility_code)
+
+
 # mapping from builtins to their C-level equivalents
 
 class _BuiltinOverride:
@@ -378,22 +385,18 @@ builtin_types_table = [
                                     ]),
 
     ("bytearray", "&PyByteArray_Type", [
-                                    BuiltinMethod("__mul__",  "Tz",   "T", "__Pyx_PySequence_Multiply",
-                                                  utility_code=pysequence_multiply_utility_code),
+                                    make_sequence_multiply_method("PyByteArray_Type"),
                                     ]),
     ("bytes",   "&PyBytes_Type",   [BuiltinMethod("join",  "TO",   "T", "__Pyx_PyBytes_Join",
                                                   utility_code=UtilityCode.load("StringJoin", "StringTools.c")),
-                                    BuiltinMethod("__mul__",  "Tz",   "T", "__Pyx_PySequence_Multiply",
-                                                  utility_code=pysequence_multiply_utility_code),
+                                    make_sequence_multiply_method("PyBytes_Type"),
                                     ]),
     ("str",     "&PyUnicode_Type", [BuiltinMethod("__contains__",  "TO",   "b", "PyUnicode_Contains"),
                                     BuiltinMethod("join",  "TO",   "T", "PyUnicode_Join"),
-                                    BuiltinMethod("__mul__",  "Tz",   "T", "__Pyx_PySequence_Multiply",
-                                                  utility_code=pysequence_multiply_utility_code),
+                                    make_sequence_multiply_method("PyUnicode_Type"),
                                     ]),
 
-    ("tuple",  "&PyTuple_Type",    [BuiltinMethod("__mul__", "Tz", "T", "__Pyx_PySequence_Multiply",
-                                                  utility_code=pysequence_multiply_utility_code),
+    ("tuple",  "&PyTuple_Type",    [make_sequence_multiply_method("PyTuple_Type"),
                                     ]),
 
     ("list",   "&PyList_Type",     [BuiltinMethod("insert",  "TzO",  "r", "PyList_Insert"),
@@ -402,8 +405,7 @@ builtin_types_table = [
                                                   utility_code=UtilityCode.load("ListAppend", "Optimize.c")),
                                     BuiltinMethod("extend",  "TO",   "r", "__Pyx_PyList_Extend",
                                                   utility_code=UtilityCode.load("ListExtend", "Optimize.c")),
-                                    BuiltinMethod("__mul__",  "Tz",   "T", "__Pyx_PySequence_Multiply",
-                                                  utility_code=pysequence_multiply_utility_code),
+                                    make_sequence_multiply_method("PyList_Type"),
                                     ]),
 
     ("dict",   "&PyDict_Type",     [BuiltinMethod("__contains__",  "TO",   "b", "PyDict_Contains"),

Cython/Compiler/ExprNodes.py

@@ -1813,7 +1813,7 @@ class BytesNode(ConstNode):
             node.type = dst_type
             return node
         elif dst_type in (PyrexTypes.c_uchar_ptr_type, PyrexTypes.c_const_uchar_ptr_type, PyrexTypes.c_void_ptr_type):
-            node.type = (PyrexTypes.c_const_char_ptr_type if dst_type == PyrexTypes.c_const_uchar_ptr_type
+            node.type = (PyrexTypes.c_const_char_ptr_type if dst_type.base_type.is_const
                          else PyrexTypes.c_char_ptr_type)
             return CastNode(node, dst_type)
         elif dst_type.assignable_from(PyrexTypes.c_char_ptr_type):
@@ -1830,7 +1830,7 @@ class BytesNode(ConstNode):
     def generate_evaluation_code(self, code):
         if self.type.is_pyobject:
             result = code.get_py_string_const(self.value)
-        elif self.type.is_const:
+        elif (self.type.is_ptr or self.type.is_array) and self.type.base_type.is_const:
             result = code.get_string_const(self.value)
         else:
             # not const => use plain C string literal and cast to mutable type
@@ -1900,6 +1900,9 @@ class UnicodeNode(ConstNode):
                     dst_type.is_ptr and dst_type.base_type.is_void):
                 # Allow using '-3' enforced unicode literals in a C char/char*/void* context.
                 if self.bytes_value is not None:
+                    if dst_type.is_array:
+                        # Prevent an invalid assignment from a C string array and use a pointer instead.
+                        dst_type = dst_type.element_ptr_type()
                     return BytesNode(self.pos, value=self.bytes_value).coerce_to(dst_type, env)
                 if env.directives['c_string_encoding']:
                     try:
@@ -9052,11 +9055,14 @@ class TupleNode(SequenceNode):
         return self.result_code
 
     def calculate_constant_result(self):
+        if self.mult_factor:
+            raise ValueError()  # may exceed the compile time memory
         self.constant_result = tuple([
                 arg.constant_result for arg in self.args])
 
     def compile_time_value(self, denv):
         values = self.compile_time_value_list(denv)
+        assert self.mult_factor is None, self.mult_factor  # set only after parsing
         try:
             return tuple(values)
         except Exception as e:

Cython/Compiler/ModuleNode.py

@@ -979,6 +979,17 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
             code.putln("#endif")
             code.putln("")
 
+        code.putln("#ifdef CYTHON_FREETHREADING_COMPATIBLE")
+        code.putln("#if CYTHON_FREETHREADING_COMPATIBLE")
+        code.putln("#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_NOT_USED")
+        code.putln("#else")
+        code.putln("#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED")
+        code.putln("#endif")
+        code.putln("#else")
+        ft_compatible = "Py_MOD_GIL_NOT_USED" if env.directives["freethreading_compatible"] else "Py_MOD_GIL_USED"
+        code.putln(f"#define __Pyx_FREETHREADING_COMPATIBLE {ft_compatible}")
+        code.putln("#endif")
+
         c_string_type = env.directives['c_string_type']
         c_string_encoding = env.directives['c_string_encoding']
         if c_string_type not in ('bytes', 'bytearray') and not c_string_encoding:
@@ -3628,10 +3639,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
         code.putln("{Py_mod_create, (void*)%s}," % Naming.pymodule_create_func_cname)
         code.putln("{Py_mod_exec, (void*)%s}," % exec_func_cname)
         code.putln("#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING")
-        gil_option = ("Py_MOD_GIL_NOT_USED"
-                      if env.directives["freethreading_compatible"]
-                      else "Py_MOD_GIL_USED")
-        code.putln("{Py_mod_gil, %s}," % gil_option)
+        code.putln("{Py_mod_gil, __Pyx_FREETHREADING_COMPATIBLE},")
         code.putln("#endif")
         code.putln("#if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE")
         subinterp_option = {

Cython/Compiler/Nodes.py

@@ -766,6 +766,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')
@@ -2019,6 +2020,10 @@ class FuncDefNode(StatNode, BlockNode):
                                 outer_scope=genv,
                                 parent_scope=env,
                                 scope_name=self.entry.cname)
+            # FIXME: why do GeneratorDefNode and GeneratorBodyDefNode use the same scope?
+            # This should hit the GeneratorBodyDefNode, not the GeneratorDefNode.
+            if self.is_generator_body or self.is_generator:
+                lenv.is_generator_scope = True
         else:
             lenv = LocalScope(name=self.entry.name,
                               outer_scope=genv,
@@ -3250,7 +3255,7 @@ class DefNode(FuncDefNode):
             from .ExprNodes import ConstNode
             exception_value = ConstNode.for_type(
                 self.pos, value=str(cfunc_type.exception_value), type=cfunc_type.return_type,
-                constant_result=cfunc_type.exception_value)
+                constant_result=cfunc_type.exception_value.python_value)
         declarator = CFuncDeclaratorNode(self.pos,
                                          base=CNameDeclaratorNode(self.pos, name=self.name, cname=None),
                                          args=self.args,
@@ -8992,7 +8997,6 @@ class CriticalSectionStatNode(TryFinallyStatNode):
     child_attrs = ["args"] + TryFinallyStatNode.child_attrs
 
     var_type = None
-    state_temp = None
     preserve_exception = False
     is_pymutex_critical_section = False
 
@@ -9002,8 +9006,6 @@ class CriticalSectionStatNode(TryFinallyStatNode):
         else:
             self.var_type = PyrexTypes.c_py_critical_section_type
 
-        self.create_state_temp_if_needed(pos, body)
-
         self.length_tag = str(len(args)) if len(args) > 1 else ""
 
         super().__init__(
@@ -9011,19 +9013,16 @@ class CriticalSectionStatNode(TryFinallyStatNode):
             args=args,
             body=body,
             finally_clause=CriticalSectionExitNode(
-                pos, length_tag=self.length_tag, critical_section=self),
+                pos, length_tag=self.length_tag),
             **kwds,
         )
 
-    def create_state_temp_if_needed(self, pos, body):
+    def check_for_yields(self):
         from .ParseTreeTransforms import YieldNodeCollector
         collector = YieldNodeCollector()
-        collector.visitchildren(body)
-        if not collector.yields:
-            return
-
-        from . import ExprNodes
-        self.state_temp = ExprNodes.TempNode(pos, self.var_type)
+        collector.visitchildren(self.body)
+        if collector.yields:
+            error(self.pos, f"Cannot yield while in a cython.critical_section.")
 
     def analyse_declarations(self, env):
         for arg in self.args:
@@ -9031,6 +9030,7 @@ class CriticalSectionStatNode(TryFinallyStatNode):
         return super().analyse_declarations(env)
 
     def analyse_expressions(self, env):
+        self.check_for_yields()
         cy_pymutex_type = PyrexTypes.get_cy_pymutex_type()
         mutex_count = 0
         for i, arg in enumerate(self.args):
@@ -9074,12 +9074,8 @@ class CriticalSectionStatNode(TryFinallyStatNode):
 
         code.mark_pos(self.pos)
         code.begin_block()
-        if self.state_temp:
-            self.state_temp.allocate(code)
-            variable = self.state_temp.result()
-        else:
-            variable = Naming.critical_section_variable
-            code.putln(f"{self.var_type.declaration_code(variable)};")
+        variable = Naming.critical_section_variable
+        code.putln(f"{self.var_type.declaration_code(variable)};")
 
         for arg in self.args:
             arg.generate_evaluation_code(code)
@@ -9097,16 +9093,13 @@ class CriticalSectionStatNode(TryFinallyStatNode):
             arg.generate_disposal_code(code)
             arg.free_temps(code)
 
-        if self.state_temp:
-            self.state_temp.release(code)
-
         code.end_block()
 
     def nogil_check(self, env):
         error(self.pos, "Critical sections require the GIL")
 
 
-class CriticalSectionExitNode(StatNode, CopyWithUpTreeRefsMixin):
+class CriticalSectionExitNode(StatNode):
     """
     critical_section - the CriticalSectionStatNode that owns this
     """
@@ -9117,13 +9110,8 @@ class CriticalSectionExitNode(StatNode, CopyWithUpTreeRefsMixin):
         return self
 
     def generate_execution_code(self, code):
-        if self.critical_section.state_temp:
-            variable_name = self.critical_section.state_temp.result()
-        else:
-            variable_name =  Naming.critical_section_variable
-
         code.putln(
-            f"__Pyx_PyCriticalSection{self.length_tag}_End(&{variable_name});"
+            f"__Pyx_PyCriticalSection{self.length_tag}_End(&{ Naming.critical_section_variable});"
         )
 
 class CythonLockStatNode(TryFinallyStatNode):
@@ -9162,29 +9150,12 @@ class CythonLockStatNode(TryFinallyStatNode):
         result.finally_except_clause = result.finally_clause
         return result
 
-    def check_for_yields(self):
-        from .ParseTreeTransforms import YieldNodeCollector
-        collector = YieldNodeCollector()
-        collector.visitchildren(self.body)
-        if collector.yields:
-            # DW - I've disallowed this because it seems like a deadlock disaster waiting to happen.
-            # I'm sure it's technically possible, and we can revise it if people have legitimate
-            # uses.
-            typename = self.arg.type.empty_declaration_code(pyrex=True).strip()
-            error(
-                self.pos,
-                f"Cannot use a 'with' statement with a '{typename}' in a generator. "
-                "If you really want to do this (and you are confident that there are no deadlocks) "
-                "then use try-finally."
-            )
-
     def analyse_declarations(self, env):
         self.arg.analyse_declarations(env)
         return super().analyse_declarations(env)
 
     def analyse_expressions(self, env):
         self.arg = self.arg.analyse_expressions(env)
-        self.check_for_yields()
         body = self.body
         if isinstance(body, StatListNode) and len(body.stats) >= 1:
             body = body.stats[0]

Cython/Compiler/Optimize.py

@@ -219,13 +219,14 @@ class IterationTransform(Visitor.EnvTransform):
         return self._optimise_for_loop(node, node.iterator.sequence)
 
     def _optimise_for_loop(self, node, iterable, reversed=False):
+        iter_type = iterable.type
         annotation_type = None
         if (iterable.is_name or iterable.is_attribute) and iterable.entry and iterable.entry.annotation:
             annotation = iterable.entry.annotation.expr
             if annotation.is_subscript:
                 annotation = annotation.base  # container base type
 
-        if Builtin.dict_type in (iterable.type, annotation_type):
+        if Builtin.dict_type in (iter_type, annotation_type):
             # like iterating over dict.keys()
             if reversed:
                 # CPython raises an error here: not a sequence
@@ -233,29 +234,31 @@ class IterationTransform(Visitor.EnvTransform):
             return self._transform_dict_iteration(
                 node, dict_obj=iterable, method=None, keys=True, values=False)
 
-        if (Builtin.set_type in (iterable.type, annotation_type) or
-                Builtin.frozenset_type in (iterable.type, annotation_type)):
+        if (Builtin.set_type in (iter_type, annotation_type) or
+                Builtin.frozenset_type in (iter_type, annotation_type)):
             if reversed:
                 # CPython raises an error here: not a sequence
                 return node
             return self._transform_set_iteration(node, iterable)
 
+        env = self.current_env()
+
         # C array (slice) iteration?
-        if iterable.type.is_ptr or iterable.type.is_array:
+        if iter_type.is_ptr or iter_type.is_array:
             return self._transform_carray_iteration(node, iterable, reversed=reversed)
-        if iterable.is_sequence_constructor:
+        if iterable.is_sequence_constructor and not env.is_generator_scope:
             # Convert iteration over homogeneous sequences of C types into array iteration.
-            env = self.current_env()
+            # FIXME: using ListNode in this way currently generates invalid C code inside of generator loops.
             item_type = ExprNodes.infer_sequence_item_type(
-                env, iterable, seq_type=iterable.type)
+                env, iterable, seq_type=iter_type)
             if item_type and not item_type.is_pyobject and not any(item.is_starred for item in iterable.args):
                 iterable = ExprNodes.ListNode(iterable.pos, args=iterable.args).analyse_types(env).coerce_to(
                     PyrexTypes.c_array_type(item_type, len(iterable.args)), env)
                 return self._transform_carray_iteration(node, iterable, reversed=reversed)
-        if iterable.is_string_literal:
+        if iterable.is_string_literal and not env.is_generator_scope:
             # Iterate over C array of single character values.
-            env = self.current_env()
-            if iterable.type is Builtin.unicode_type:
+            # FIXME: using ListNode in this way currently generates invalid C code inside of generator loops.
+            if iter_type is Builtin.unicode_type:
                 item_type = PyrexTypes.c_py_ucs4_type
                 items = map(ord, iterable.value)
             else:
@@ -266,13 +269,16 @@ class IterationTransform(Visitor.EnvTransform):
             iterable = ExprNodes.ListNode(iterable.pos, args=[as_int_node(ch)for ch in items])
             iterable = iterable.analyse_types(env).coerce_to(PyrexTypes.c_array_type(item_type, len(iterable.args)), env)
             return self._transform_carray_iteration(node, iterable, reversed=reversed)
-        if iterable.type is Builtin.bytes_type:
-            return self._transform_bytes_iteration(node, iterable, reversed=reversed)
-        if iterable.type is Builtin.unicode_type:
+        if iter_type is Builtin.bytes_type:
+            if env.is_generator_scope:
+                return self._transform_indexable_iteration(node, iterable, is_mutable=False, reversed=reversed)
+            else:
+                return self._transform_bytes_iteration(node, iterable, reversed=reversed)
+        if iter_type is Builtin.unicode_type:
             return self._transform_unicode_iteration(node, iterable, reversed=reversed)
         # in principle _transform_indexable_iteration would work on most of the above, and
         # also tuple and list. However, it probably isn't quite as optimized
-        if iterable.type is Builtin.bytearray_type:
+        if iter_type is Builtin.bytearray_type:
             return self._transform_indexable_iteration(node, iterable, is_mutable=True, reversed=reversed)
         if isinstance(iterable, ExprNodes.CoerceToPyTypeNode) and iterable.arg.type.is_memoryviewslice:
             return self._transform_indexable_iteration(node, iterable.arg, is_mutable=False, reversed=reversed)
@@ -601,7 +607,8 @@ class IterationTransform(Visitor.EnvTransform):
         exception_value=-1)
 
     def _transform_unicode_iteration(self, node, slice_node, reversed=False):
-        if slice_node.is_literal:
+        env = self.current_env()
+        if slice_node.is_literal and not env.is_generator_scope:
             # try to reduce to byte iteration for plain Latin-1 strings
             try:
                 bytes_value = bytes_literal(slice_node.value.encode('latin1'), 'iso8859-1')
@@ -614,7 +621,7 @@ class IterationTransform(Visitor.EnvTransform):
                         slice_node.pos, value=bytes_value,
                         constant_result=bytes_value,
                         type=PyrexTypes.c_const_char_ptr_type).coerce_to(
-                            PyrexTypes.c_const_uchar_ptr_type, self.current_env()),
+                            PyrexTypes.c_const_uchar_ptr_type, env),
                     start=None,
                     stop=ExprNodes.IntNode.for_size(slice_node.pos, len(bytes_value)),
                     type=Builtin.unicode_type,  # hint for Python conversion
@@ -646,8 +653,7 @@ class IterationTransform(Visitor.EnvTransform):
             is_temp = False,
             )
         if target_value.type != node.target.type:
-            target_value = target_value.coerce_to(node.target.type,
-                                                  self.current_env())
+            target_value = target_value.coerce_to(node.target.type, env)
         target_assign = Nodes.SingleAssignmentNode(
             pos = node.target.pos,
             lhs = node.target,

Cython/Compiler/Symtab.py

@@ -364,6 +364,7 @@ class Scope:
     # is_c_class_scope  boolean            Is an extension type scope
     # is_local_scope    boolean            Is a local (i.e. function/method/generator) scope
     # is_closure_scope  boolean            Is a closure scope
+    # is_generator_scope  boolean          Is a closure scope of a generator
     # is_generator_expression_scope boolean   A subset of closure scope used for generator expressions
     # is_passthrough    boolean            Outer scope is passed directly
     # is_cpp_class_scope  boolean          Is a C++ class scope
@@ -386,6 +387,7 @@ class Scope:
     is_c_class_scope = 0
     is_closure_scope = 0
     is_local_scope = False
+    is_generator_scope = False
     is_generator_expression_scope = 0
     is_comprehension_scope = 0
     is_passthrough = 0
@@ -2254,6 +2256,7 @@ class ClosureScope(LocalScope):
 
 
 class GeneratorExpressionScope(ClosureScope):
+    is_generator_scope = True
     is_generator_expression_scope = True
 
     def declare_assignment_expression_target(self, name, type, pos):

Cython/Compiler/Visitor.py

@@ -549,7 +549,7 @@ class MethodDispatcherTransform(EnvTransform):
                 if Future.division in self.current_env().context.future_directives:
                     special_method_name = '__truediv__'
             obj_type = operand1.type
-            if obj_type.is_builtin_type:
+            if obj_type.is_builtin_type and not obj_type.is_exception_type:
                 type_name = obj_type.name
             else:
                 type_name = "object"  # safety measure
@@ -564,7 +564,7 @@ class MethodDispatcherTransform(EnvTransform):
         if special_method_name:
             operand = node.operand
             obj_type = operand.type
-            if obj_type.is_builtin_type:
+            if obj_type.is_builtin_type and not obj_type.is_exception_type:
                 type_name = obj_type.name
             else:
                 type_name = "object"  # safety measure
@@ -619,7 +619,8 @@ class MethodDispatcherTransform(EnvTransform):
                     # => see if it's usable instead
                     return self._delegate_to_assigned_value(
                         node, function, arg_list, kwargs)
-                if arg_list and entry.is_cmethod and entry.scope and entry.scope.parent_type.is_builtin_type:
+                if (arg_list and entry.is_cmethod and entry.scope and
+                        entry.scope.parent_type.is_builtin_type and not entry.scope.parent_type.is_exception_type):
                     if entry.scope.parent_type is arg_list[0].type:
                         # Optimised (unbound) method of a builtin type => try to "de-optimise".
                         return self._dispatch_to_method_handler(
@@ -650,7 +651,8 @@ class MethodDispatcherTransform(EnvTransform):
                 return node
             obj_type = self_arg.type
             is_unbound_method = False
-            if obj_type.is_builtin_type:
+            # Exceptions aren't necessarily exact types so could have unknown methods
+            if obj_type.is_builtin_type and not obj_type.is_exception_type:
                 if obj_type is Builtin.type_type and self_arg.is_name and arg_list and arg_list[0].type.is_pyobject:
                     # calling an unbound method like 'list.append(L,x)'
                     # (ignoring 'type.mro()' here ...)

Cython/Includes/cpython/array.pxd

@@ -101,7 +101,7 @@ cdef extern from *:  # Hard-coded utility code hack.
             arraydescr* ob_descr    # struct arraydescr *ob_descr;
 
         @property
-        cdef inline __data_union data(self) nogil:
+        cdef inline __data_union data(self) noexcept nogil:
             return __Pyx_PyArray_Data(self)
 
         def __getbuffer__(self, Py_buffer* info, int flags):
@@ -134,7 +134,7 @@ cdef extern from *:  # Hard-coded utility code hack.
 
     array newarrayobject(PyTypeObject* type, Py_ssize_t size, arraydescr *descr)
 
-    __data_union __Pyx_PyArray_Data(array self) nogil
+    __data_union __Pyx_PyArray_Data(array self) noexcept nogil
     # fast resize/realloc
     # not suitable for small increments; reallocation 'to the point'
     int resize(array self, Py_ssize_t n) except -1

Cython/Includes/cpython/dict.pxd

@@ -3,11 +3,97 @@ from .pyport cimport uint64_t
 
 cdef extern from *:
     # On Python 2, PyDict_GetItemWithError is called _PyDict_GetItemWithError
+    # Also backport PyDict_GetItemStringRef and PyDict_SetDefaultRef
     """
     #if PY_MAJOR_VERSION <= 2
     #define PyDict_GetItemWithError _PyDict_GetItemWithError
     #endif
+
+    #if __PYX_LIMITED_VERSION_HEX < 0x030d0000
+    static CYTHON_INLINE int
+    __Pyx_CAPI_PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result)
+    {
+        int res;
+        PyObject *key_obj = PyUnicode_FromString(key);
+        if (key_obj == NULL) {
+            *result = NULL;
+            return -1;
+        }
+        res = __Pyx_PyDict_GetItemRef(mp, key_obj, result);
+        Py_DECREF(key_obj);
+        return res;
+    }
+    #else
+    #define __Pyx_CAPI_PyDict_GetItemStringRef PyDict_GetItemStringRef
+    #endif
+    #if PY_VERSION_HEX < 0x030d0000 || (CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030F0000)
+    static CYTHON_INLINE int
+    __Pyx_CAPI_PyDict_SetDefaultRef(PyObject *d, PyObject *key, PyObject *default_value,
+                        PyObject **result)
+    {
+        PyObject *value;
+        if (__Pyx_PyDict_GetItemRef(d, key, &value) < 0) {
+            // get error
+            if (result) {
+                *result = NULL;
+            }
+            return -1;
+        }
+        if (value != NULL) {
+            // present
+            if (result) {
+                *result = value;
+            }
+            else {
+                Py_DECREF(value);
+            }
+            return 1;
+        }
+
+        // missing: set the item
+        if (PyDict_SetItem(d, key, default_value) < 0) {
+            // set error
+            if (result) {
+                *result = NULL;
+            }
+            return -1;
+        }
+        if (result) {
+            Py_INCREF(default_value);
+            *result = default_value;
+        }
+        return 0;
+    }
+    #else
+    #define __Pyx_CAPI_PyDict_SetDefaultRef PyDict_SetDefaultRef
+    #endif
     """
+    int PyDict_GetItemRef "__Pyx_PyDict_GetItemRef" (object p, object key, PyObject* *result) except -1
+    # Return a new strong reference to the object from dictionary p
+    # which has a key key:
+    # - If the key is present, set *result to a new strong reference to
+    #   the value and return 1.
+    # - If the key is missing, set *result to NULL and return 0.
+    # - On error, raise an exception and return -1.
+
+    int PyDict_GetItemStringRef "__Pyx_CAPI_PyDict_GetItemStringRef" (object p, const char *key, PyObject* *result) except -1
+    # Similar to PyDict_GetItemRef(), but key is specified as a const char*
+    # UTF-8 encoded bytes string, rather than a PyObject*.
+
+    int PyDict_SetDefaultRef "__Pyx_CAPI_PyDict_SetDefaultRef" (object p, object key, object default_value, PyObject* *result) except -1
+    # Inserts default_value into the dictionary p with a key of key if the
+    # key is not already present in the dictionary. If result is not NULL,
+    # then *result is set to a strong reference to either default_value,
+    # if the key was not present, or the existing value, if key was already
+    # present in the dictionary. Returns 1 if the key was present and
+    # default_value was not inserted, or 0 if the key was not present and
+    # default_value was inserted. On failure, returns -1, sets an exception,
+    # and sets *result to NULL.
+    # For clarity: if you have a strong reference to default_value before
+    # calling this function, then after it returns, you hold a strong
+    # reference to both default_value and *result (if it’s not NULL). These
+    # may refer to the same object: in that case you hold two separate
+    # references to it.
 
 cdef extern from "Python.h":
     ############################################################################

Cython/Includes/cpython/list.pxd

@@ -1,5 +1,38 @@
 from .object cimport PyObject
 
+cdef extern from *:
+    # Backport PyList_GetItemRef, PyList_Extend and PyList_Clear
+    """
+    #if __PYX_LIMITED_VERSION_HEX < 0x030d0000
+    static CYTHON_INLINE PyObject *
+    __Pyx_CAPI_PyList_GetItemRef(PyObject *list, Py_ssize_t index)
+    {
+        PyObject *item = PyList_GetItem(list, index);
+        Py_XINCREF(item);
+        return item;
+    }
+    #else
+    #define __Pyx_CAPI_PyList_GetItemRef PyList_GetItemRef
+    #endif
+
+    #if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030d0000
+    static CYTHON_INLINE int
+    __Pyx_CAPI_PyList_Extend(PyObject *list, PyObject *iterable)
+    {
+        return PyList_SetSlice(list, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, iterable);
+    }
+
+    static CYTHON_INLINE int
+    __Pyx_CAPI_PyList_Clear(PyObject *list)
+    {
+        return PyList_SetSlice(list, 0, PY_SSIZE_T_MAX, NULL);
+    }
+    #else
+    #define __Pyx_CAPI_PyList_Extend PyList_Extend
+    #define __Pyx_CAPI_PyList_Clear PyList_Clear
+    #endif
+    """
+
 cdef extern from "Python.h":
 
     ############################################################################
@@ -29,12 +62,17 @@ cdef extern from "Python.h":
     Py_ssize_t PyList_GET_SIZE(object list)
     # Macro form of PyList_Size() without error checking.
 
+    object PyList_GetItemRef "__Pyx_CAPI_PyList_GetItemRef" (object list, Py_ssize_t index)
+    # Return value: New reference.
+    # Return the object at position index in the list pointed to by list.
+    # The position must be non-negative; indexing from the end of the
+    # list is not supported. If index is out of bounds (<0 or >=len(list)),
+    # return NULL and set an IndexError exception.
+
     PyObject* PyList_GetItem(object list, Py_ssize_t index) except NULL
     # Return value: Borrowed reference.
-    # Return the object at position pos in the list pointed to by
-    # p. The position must be positive, indexing from the end of the
-    # list is not supported. If pos is out of bounds, return NULL and
-    # set an IndexError exception.
+    # Like PyList_GetItemRef(), but returns a borrowed reference instead of
+    # a strong reference.
 
     PyObject* PyList_GET_ITEM(object list, Py_ssize_t i)
     # Return value: Borrowed reference.
@@ -78,6 +116,20 @@ cdef extern from "Python.h":
     # may be NULL, indicating the assignment of an empty list (slice
     # deletion). Return 0 on success, -1 on failure.
 
+    int PyList_Extend "__Pyx_CAPI_PyList_Extend" (object list, object iterable) except -1
+    # Extend list with the contents of iterable. This is the same as
+    # PyList_SetSlice(list, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, iterable)
+    # and analogous to list.extend(iterable) or list += iterable.
+    # Raise an exception and return -1 if list is not a list object.
+    # Return 0 on success.
+
+    int PyList_Clear "__Pyx_CAPI_PyList_Clear" (object list) except -1
+    # Remove all items from list. This is the same as
+    # PyList_SetSlice(list, 0, PY_SSIZE_T_MAX, NULL) and analogous
+    # to list.clear() or del list[:].
+    # Raise an exception and return -1 if list is not a list object.
+    # Return 0 on success.
+
     int PyList_Sort(object list) except -1
     # Sort the items of list in place. Return 0 on success, -1 on
     # failure. This is equivalent to "list.sort()".

Cython/Includes/libc/threads.pxd

@@ -139,7 +139,7 @@ cdef extern from *:
             return 1;
         #elif PY_VERSION_HEX >= 0x030d0000
             return PyThreadState_GetUnchecked() != NULL;
-        #elif PY_VERSION_HEX >= 0x030b0000
+        #elif PY_VERSION_HEX >= 0x030C0000
             return _PyThreadState_UncheckedGet() != NULL;
         #else
             return PyGILState_Check();
@@ -166,7 +166,7 @@ cdef extern from *:
         return lock_result;
     }
 
-    static CYTHON_UNUSED int __pyx_py_safe_mtx_lock(mtx_t* mutex) {
+    CYTHON_UNUSED static int __pyx_py_safe_mtx_lock(mtx_t* mutex) {
         PyGILState_STATE gil_state = __pyx_libc_threads_limited_api_ensure_gil();
         if (!__pyx_libc_threads_has_gil())
             return mtx_lock(mutex); /* No GIL, no problem */
@@ -175,7 +175,7 @@ cdef extern from *:
         return result;
     }
 
-    static CYTHON_UNUSED int __pyx_py_safe_cnd_wait( cnd_t* cond, mtx_t* mutex) {
+    CYTHON_UNUSED static int __pyx_py_safe_cnd_wait( cnd_t* cond, mtx_t* mutex) {
         __Pyx_UnknownThreadState thread_state = __Pyx_SaveUnknownThread();
         int result = cnd_wait(cond, mutex);
         if (__Pyx_UnknownThreadStateMayHaveHadGil(thread_state)) {
@@ -194,7 +194,7 @@ cdef extern from *:
         }
     }
 
-    static CYTHON_UNUSED int __pyx_py_safe_cnd_timedwait(cnd_t* cond, mtx_t* mutex, const struct timespec* time_point) {
+    CYTHON_UNUSED static int __pyx_py_safe_cnd_timedwait(cnd_t* cond, mtx_t* mutex, const struct timespec* time_point) {
         __Pyx_UnknownThreadState thread_state = __Pyx_SaveUnknownThread();
         int result = cnd_timedwait(cond, mutex, time_point);
         if (__Pyx_UnknownThreadStateMayHaveHadGil(thread_state)) {
@@ -213,7 +213,7 @@ cdef extern from *:
         }
     }
 
-    static CYTHON_UNUSED void __pyx_libc_threads_py_safe_call_once(once_flag* flag, void (*func)(void)) {
+    CYTHON_UNUSED static void __pyx_libc_threads_py_safe_call_once(once_flag* flag, void (*func)(void)) {
         __Pyx_UnknownThreadState thread_state = __Pyx_SaveUnknownThread();
         call_once(flag, func);
         __Pyx_RestoreUnknownThread(thread_state);

Cython/Includes/libcpp/mutex.pxd

@@ -194,7 +194,7 @@ cdef extern from *:
             return 1;
         #elif PY_VERSION_HEX >= 0x030d0000
             return PyThreadState_GetUnchecked() != NULL;
-        #elif PY_VERSION_HEX >= 0x030b0000
+        #elif PY_VERSION_HEX >= 0x030C0000
             return _PyThreadState_UncheckedGet() != NULL;
         #else
             return PyGILState_Check();

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.1"
+__version__ = "3.2.3"
 
 
 # BEGIN shameless copy from Cython/minivect/minitypes.py

Cython/Utility/Builtins.c

@@ -303,7 +303,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*/
 
@@ -343,7 +343,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/Utility/CythonFunction.c

@@ -1572,10 +1572,7 @@ __pyx_err:;
 
     if (likely(unbound_result_func)) {
         if (self->self) {
-            __pyx_FusedFunctionObject *unbound = (__pyx_FusedFunctionObject *) unbound_result_func;
-
-            // TODO: move this to InitClassCell
-            __Pyx_CyFunction_SetClassObj(unbound, __Pyx_CyFunction_GetClassObj(self));
+            assert(__Pyx_CyFunction_GetClassObj(unbound_result_func) == __Pyx_CyFunction_GetClassObj(self));
 
             result_func = __pyx_FusedFunction_descr_get(unbound_result_func,
                                                         self->self, self->self);
@@ -1673,7 +1670,7 @@ __pyx_FusedFunction_call(PyObject *func, PyObject *args, PyObject *kw)
         if (unlikely(!new_func))
             goto bad;
 
-        __Pyx_CyFunction_SetClassObj(new_func, __Pyx_CyFunction_GetClassObj(binding_func));
+        assert(__Pyx_CyFunction_GetClassObj(new_func) == __Pyx_CyFunction_GetClassObj(binding_func));
 
         func = (PyObject *) new_func;
     }

Cython/Utility/Embed.c

@@ -89,9 +89,9 @@ int
     }
     else {
         int i, res;
-        wchar_t **argv_copy = (wchar_t **)malloc(sizeof(wchar_t*)*argc);
+        wchar_t **argv_copy = (wchar_t **)malloc(sizeof(wchar_t*) * (size_t) argc);
         /* We need a second copy, as Python might modify the first one. */
-        wchar_t **argv_copy2 = (wchar_t **)malloc(sizeof(wchar_t*)*argc);
+        wchar_t **argv_copy2 = (wchar_t **)malloc(sizeof(wchar_t*) * (size_t) argc);
         char *oldloc = strdup(setlocale(LC_ALL, NULL));
         if (!argv_copy || !argv_copy2 || !oldloc) {
             fprintf(stderr, "out of memory\\n");

Cython/Utility/Exceptions.c

@@ -18,6 +18,11 @@ if (likely(__Pyx_init_assertions_enabled() == 0)); else
   static int __pyx_assertions_enabled_flag;
   #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag)
 
+  #if __clang__ || __GNUC__
+  // "Assertions enabled" may be written multiple times when using subinterpreters.
+  // However, it should always be written to the same value to isn't a "real" race.
+  __attribute__((no_sanitize("thread")))
+  #endif
   static int __Pyx_init_assertions_enabled(void) {
     PyObject *builtins, *debug, *debug_str;
     int flag;

Cython/Utility/ObjectHandling.c

@@ -2968,10 +2968,15 @@ static CYTHON_INLINE PyObject *__Pyx_PyUnicode_ConcatInPlaceImpl(PyObject **p_le
 /////////////// PySequenceMultiply.proto ///////////////
 
 #define __Pyx_PySequence_Multiply_Left(mul, seq)  __Pyx_PySequence_Multiply(seq, mul)
+#if !CYTHON_USE_TYPE_SLOTS
+#define  __Pyx_PySequence_Multiply PySequence_Repeat
+#else
 static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul);
+#endif
 
 /////////////// PySequenceMultiply ///////////////
 
+#if CYTHON_USE_TYPE_SLOTS
 static PyObject* __Pyx_PySequence_Multiply_Generic(PyObject *seq, Py_ssize_t mul) {
     PyObject *result, *pymul = PyLong_FromSsize_t(mul);
     if (unlikely(!pymul))
@@ -2982,17 +2987,32 @@ static PyObject* __Pyx_PySequence_Multiply_Generic(PyObject *seq, Py_ssize_t mul
 }
 
 static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul) {
-#if CYTHON_USE_TYPE_SLOTS
     PyTypeObject *type = Py_TYPE(seq);
     if (likely(type->tp_as_sequence && type->tp_as_sequence->sq_repeat)) {
         return type->tp_as_sequence->sq_repeat(seq, mul);
-    } else
-#endif
-    {
+    } else {
         return __Pyx_PySequence_Multiply_Generic(seq, mul);
     }
 }
+#endif
+
+/////////////// BuiltinSequenceMultiply.proto ///////////////
+
+static CYTHON_INLINE PyObject* __Pyx_{{typeobj}}_Multiply(PyObject *seq, Py_ssize_t mul);
 
+/////////////// BuiltinSequenceMultiply ////////////////
+
+static CYTHON_INLINE PyObject* __Pyx_{{typeobj}}_Multiply(PyObject *seq, Py_ssize_t mul) {
+    // It's important that this function always calls the exact typeobj slot, because it may
+    // be used with a subclass deliberately to access the base class slot.
+    ssizeargfunc slot = __Pyx_PyType_TryGetSubSlot(&{{typeobj}}, tp_as_sequence, sq_repeat, ssizeargfunc);
+    #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
+    if (unlikely(!slot)) {
+        return PyObject_CallMethod((PyObject*)&{{typeobj}}, "__mul__", "On", seq, mul);
+    }
+    #endif
+    return slot(seq, mul);
+}
 
 /////////////// FormatTypeName.proto ///////////////
 

Cython/Utility/Optimize.c

@@ -1191,6 +1191,13 @@ static {{c_ret_type}} __Pyx_Fallback_{{cfunc_name}}(PyObject *op1, PyObject *op2
 }
 
 #if CYTHON_USE_PYLONG_INTERNALS
+{{if op == 'Lshift'}}
+#if __clang__ || __GNUC__
+// left-shift by more than the width of the number is undefined behaviour.
+// We do check it (and test that it gives the right answer though).
+__attribute__((no_sanitize("shift")))
+#endif
+{{endif}}
 static {{c_ret_type}} __Pyx_Unpacked_{{cfunc_name}}(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
     CYTHON_MAYBE_UNUSED_VAR(inplace);
     CYTHON_UNUSED_VAR(zerodivision_check);

Cython/Utility/Synchronization.c

@@ -300,7 +300,7 @@ static void __Pyx__Locks_PyThreadTypeLock_Lock(__Pyx_Locks_PyThreadTypeLock lock
         PyGILState_Release(state);
         return;
     }
-#elif CYTHON_COMPILING_IN_PYPY || PY_VERSION_HEX < 0x030B0000
+#elif CYTHON_COMPILING_IN_PYPY || PY_VERSION_HEX < 0x030C0000
     has_gil = PyGILState_Check();
 #elif PY_VERSION_HEX < 0x030d0000
     has_gil = _PyThreadState_UncheckedGet() != NULL;

Cython/Utility/TString.c

@@ -17,8 +17,10 @@ Py_VISIT((PyObject*)traverse_module_state->__pyx_templatelib_Interpolation);
 
 //////////////////////////// InitializeTemplateLib.module_state_clear ////////////////////////////
 
-Py_CLEAR((PyObject*)traverse_module_state->__pyx_templatelib_Template);
-Py_CLEAR((PyObject*)traverse_module_state->__pyx_templatelib_Interpolation)
+Py_XDECREF((PyObject*)clear_module_state->__pyx_templatelib_Template);
+clear_module_state->__pyx_templatelib_Template = 0;
+Py_XDECREF((PyObject*)clear_module_state->__pyx_templatelib_Interpolation);
+clear_module_state->__pyx_templatelib_Interpolation = 0;
 
 //////////////////////////// InitializeTemplateLib.proto ///////////////////////////
 
@@ -325,7 +327,7 @@ static PyObject* __Pyx_MakeTemplateLibTemplate(PyObject *strings, PyObject *inte
 #endif
     zipped_tuple = PyTuple_New(strings_len + interpolations_len);
     if (!zipped_tuple) goto end;
-    for (Py_ssize_t i=0; (i<interpolations_len && i<strings_len); ++i) {
+    for (Py_ssize_t i=0; (i<interpolations_len || i<strings_len); ++i) {
         if (i < strings_len) {
             PyObject *s = __Pyx_PyTuple_GET_ITEM(strings, i);
 #if !CYTHON_ASSUME_SAFE_MACROS

{cython-3.2.1.dist-info → cython-3.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Cython
-Version: 3.2.1
+Version: 3.2.3
 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,79 +65,32 @@ to install an uncompiled (slower) version of Cython with::
 
 .. _Pyrex: https://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/
 
-3.2.1 (2025-11-12)
+3.2.3 (2025-12-14)
 ==================
 
 Features added
 --------------
 
-* Cython now leaves markers about its utility code dependencies in the generated C code
-  to help debugging "unused function" C compiler warnings.
-  (Github issue https://github.com/cython/cython/issues/7294)
+* The C-API declarations were updated to include the new ``PyList_*()`` functions.
+  (Github issue https://github.com/cython/cython/issues/7291)
+
+* The ``Py_mod_gil`` module setting can now be changed with a C macro, overriding
+  the ``freethreading_compatible`` directive setting.
+  (Github issue https://github.com/cython/cython/issues/7404)
 
 Bugs fixed
 ----------
 
-* Relative imports could fail if the shared utility module is used.
-  This bug was introduces in Cython 3.2.0.
-  (Github issue https://github.com/cython/cython/issues/7290)
-
-* Under lock congestion, acquiring the GIL could crash in Python 3.11.
-  This bug was introduces in Cython 3.2.0.
-  (Github issue https://github.com/cython/cython/issues/7312)
-
-* Using the shared utility module left an unused C function in user modules with memoryviews.
-  To make debugging this kind of issue easier, Cython now leaves "used by …" markers in the
-  generated C files that indicate why a specific piece of utility code was included.
-  This bug was introduces in Cython 3.2.0.
-  (Github issue https://github.com/cython/cython/issues/7293)
-
-* Code using the pre-import scope failed with an undefined name.
-  This bug was introduces in Cython 3.2.0.
-  (Github issue https://github.com/cython/cython/issues/7304)
-
-* Includes all fixes as of Cython 3.1.7.
-
-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)
+* t-strings lost the last element when compiled for the Limited API.
+  (Github issue https://github.com/cython/cython/issues/7381)
 
-* Optimised unpacking of Python integers in expressions uses a slightly safer scheme.
-  (Github issue https://github.com/cython/cython/issues/7134)
+* The ``array.data`` property of the ``cpython.array`` declarations generated a
+  useless exception check that degraded its use in ``nogil`` code.
+  (Github issue https://github.com/cython/cython/issues/7408)
 
-* Empty return statements were not always reported when tracing.
-  (Github issue https://github.com/cython/cython/issues/7022)
+* Parallel builds with the ``cythonize`` command could request more processes
+  than allowed by the platform, thus failing the build.
+  (Github issue https://github.com/cython/cython/issues/7384)
 
-* 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)
+* A minor thread sanitizer issue was resolved.
+  (Github issue https://github.com/cython/cython/issues/7383)

{cython-3.2.1.dist-info → cython-3.2.3.dist-info}/RECORD

@@ -2,7 +2,7 @@ cython.py,sha256=OTJCP0F_fecQWMsGOPJDuFU7brM1ScJAATH6ek98ho4,632
 Cython/CodeWriter.py,sha256=k1SAPvsjXum7dhX9IjZ3wXuDUOzzFKYEbNZSxMKEwos,24276
 Cython/Coverage.py,sha256=WGY5BW1nBcJ86f4Lrs6ZZIuFKCdngsEizs4Kor0iRsc,18783
 Cython/Debugging.py,sha256=vFtJhn7QstMf5gnYru2qHIz5ZjPg1KSlZVGHr-pBCwM,552
-Cython/Shadow.py,sha256=aXVdJeJTNMvFYBfGZisA1em00OeAvXyRyLzSF2SZ16k,19632
+Cython/Shadow.py,sha256=0K9vhws2gEekhrPAMzDGYmZK0Dp6oMu6hDUoY-if268,19632
 Cython/Shadow.pyi,sha256=BaaRtWtFlBVM14LOD9ql-9Uw1UDZV3AOT2AWULk1WUw,18597
 Cython/StringIOTree.py,sha256=8u4R5jhUzqYvSX1w5_RrvxbgUvaMqW8jhQgXcCNKIkE,5570
 Cython/TestUtils.py,sha256=rph07UD41dNbdOjqQx_vNu2c0b3Ib1UeMxNYao_vxJU,15584
@@ -12,7 +12,7 @@ Cython/__init__.pyi,sha256=b6tWj5MgrMJz8EAV9MOqTbaFGvIxCOzH2bBkhrC80GU,185
 Cython/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Cython/Build/BuildExecutable.py,sha256=OhySP6G2ppkA_Tzutv2Mvxt3YyhViy_aU7vAeGCjEbY,4742
 Cython/Build/Cache.py,sha256=kdxcA-x7-hck6K6VuMajP4pYMWQH_4pkzwvk5qOawiE,6855
-Cython/Build/Cythonize.py,sha256=T0FMC7GTT5-4RKsOTeqJ6mJHZ1O7AS3PHPGZQVvl5bQ,13557
+Cython/Build/Cythonize.py,sha256=9dYCW_To76B0wZA5GO3DNWjZn8PllkFvef-X7d-nbRc,13475
 Cython/Build/Dependencies.py,sha256=eY-zCjgd_ENgIErJw-yGVzv4lWveeNhljFaRcFN4wMw,51710
 Cython/Build/Distutils.py,sha256=iO5tPX84Kc-ZWMocfuQbl_PqyC9HGGIRS-NiKI60-ZE,49
 Cython/Build/Inline.py,sha256=hcRhJJ8XWRYZJ7eGW8P-Yh5DhWCQm2Hxr9Im7WP352g,16298
@@ -20,7 +20,7 @@ Cython/Build/IpythonMagic.py,sha256=X11ClQS2psBcjnI4S1Ovyz_3sW8xEjRqXIh-44ycdek,
 Cython/Build/SharedModule.py,sha256=6WL0f3NxG2SwRy_humjasLk-FpsbY-ukK4iopuGsE0s,3666
 Cython/Build/__init__.py,sha256=UCsI8hI_a75i0iWwZQfuaoKTH5LW6z2b5GhN9QaJ0zo,339
 Cython/Build/Tests/TestCyCache.py,sha256=0yu2hshimJNwdjnfbRZdxXWTfy_KkLuqJIugcBf3WeY,6554
-Cython/Build/Tests/TestCythonizeArgsParser.py,sha256=w8mw0sS_OV-8j1sdevv5wE28LZkhNFRmHdLcpddaCgE,20257
+Cython/Build/Tests/TestCythonizeArgsParser.py,sha256=l7dgs39KO-ZPxQzRVccg3wvzQuBLOIi9hqB9jollw5c,20167
 Cython/Build/Tests/TestDependencies.py,sha256=E8yGrYy03JvVPwtYB7JGE-VOCWyYB2ZkQpXKTORpyps,5566
 Cython/Build/Tests/TestInline.py,sha256=pUvDhJOdgiHX0yeuZpKXnk4i3QxLzv9apwiVmdY1FLQ,5695
 Cython/Build/Tests/TestIpythonMagic.py,sha256=9GL8U_Jtyk-sAdEBzCS81RkVjxeM0Jrs2-zAhfFUb54,9004
@@ -31,7 +31,7 @@ Cython/Compiler/AnalysedTreeTransforms.py,sha256=f7YtGIZx2TannOY8QMvqv5-8GGVFvol
 Cython/Compiler/Annotate.py,sha256=yjoXb-y5flOG37Naw_UtkK4HVRKxBIVNC7-x7aa8qnA,13559
 Cython/Compiler/AutoDocTransforms.py,sha256=eIPOjZ8hLiIr--4a4DGHoy6IcqbmUgwaDuG2LVG5YLA,11974
 Cython/Compiler/Buffer.py,sha256=NMqvFYIofuS93840lWrNcvDXlBhuXgKLoEuMs0PffLk,26954
-Cython/Compiler/Builtin.py,sha256=KTq5PwVqPe9FwNNtOXrZI7dxArjbMuIB7vwg7wcQK08,42742
+Cython/Compiler/Builtin.py,sha256=sfW7MGgRm39TG2QoTF0GPhIVVy_8gW-eylGFaLRiy8I,42433
 Cython/Compiler/CmdLine.py,sha256=6u--_tFCXMEjDQaqYXbH4AXed5jXcOhBWGefngFB_Aw,13339
 Cython/Compiler/Code.pxd,sha256=-bYyHehjGEiFoe8bqT-2djaHann3jnU86gVgymoIpL0,3918
 Cython/Compiler/Code.py,sha256=dBNNyklkMCzaIYIGvjp7yPi48xS87JwRDHT7fHyGTbs,144440
@@ -40,7 +40,7 @@ Cython/Compiler/CythonScope.py,sha256=b_RU0YKr4UYzfrhAJE9xNdYAHi1H44hczsbBA9tiq6
 Cython/Compiler/Dataclass.py,sha256=NhP7E63rJzLpE98ZVrYCbNt-W0aYLh9r29e6yT0KnCQ,36595
 Cython/Compiler/DebugFlags.py,sha256=-ht7qWQyoJO6H5o0XJgwVjj5gWayuol-H2HoLqiCXsE,713
 Cython/Compiler/Errors.py,sha256=_qycMnE9-dH-uh--Wv20jFXlXkRl8UGIAsAdlIig9xM,9160
-Cython/Compiler/ExprNodes.py,sha256=0mKQWvz0_6upLxe6dGIwItoZb_nYbbqZe_w1OypGfOk,634967
+Cython/Compiler/ExprNodes.py,sha256=jVQYixwSu_fx5tP7RKiu4RY3WOJzFpkccGvd2VZFT_8,635396
 Cython/Compiler/FlowControl.pxd,sha256=0wDFfkjWddMSOjs76KQSePJBMS1CQk5RjESRHXRkYww,2499
 Cython/Compiler/FlowControl.py,sha256=P4L87MdPre8loo2U2-ruXFz3Pz7jkUJEpg10db76_Vg,50821
 Cython/Compiler/FusedNode.py,sha256=gXGXpM6XPZtVT7fGr5g19Id0flqQf4OrcR5_zn1VP4Y,41407
@@ -51,10 +51,10 @@ Cython/Compiler/LineTable.py,sha256=epP6DoefUR7JCK9OUOyoYcxMWhBEwyTWOr3E7vJRqa4,
 Cython/Compiler/Main.py,sha256=8BCgxfGhYNGvhROKqV7ovifvQJvWn2xOQBB3uBiAZ5g,35011
 Cython/Compiler/MatchCaseNodes.py,sha256=yVGVAsc1yrda1jHTAI7mZ2-SL67tNdcfOn-ugdCRWPs,7792
 Cython/Compiler/MemoryView.py,sha256=pyy1oidHhmYAprfxjhX7fweDXzrxMkEbSICKFm2vd4o,31485
-Cython/Compiler/ModuleNode.py,sha256=7HAhU4H5VEeZxN42HGlq7dYRGA3faauucz3YsQmyULk,194712
+Cython/Compiler/ModuleNode.py,sha256=KfHvXpp8G8S1i_1-xMwqzflqnDWMJRRSuvu0pZhGNWY,195154
 Cython/Compiler/Naming.py,sha256=xneFFCsB68xZhghXAxA2GnRrooWMumxss20B1I0avqk,11159
-Cython/Compiler/Nodes.py,sha256=Ef-QpICjbff3wb-LEzEfNA69fg4rOlAVSBgDLJYYL6E,455923
-Cython/Compiler/Optimize.py,sha256=0pI7dkwJirE2IrlSoLrbbuL9cq1pls5VDoex_5rYTmk,227816
+Cython/Compiler/Nodes.py,sha256=SPMs4eHpOSsUakYl2NtNErXUZ_OwI5DRHcoWz12gRrg,454893
+Cython/Compiler/Optimize.py,sha256=CX-UEAmTqAc4JsMxpRsKPx_7yaaEzwewcxHc7c2Roq0,228209
 Cython/Compiler/Options.py,sha256=DegABgz_JQbPN_hHfOTxDd3zKHXvqoYedB9jgco4fnk,32062
 Cython/Compiler/ParseTreeTransforms.pxd,sha256=mkdSaFvc5we32bs0RNFwbODQMsTHIU0jIlpZuFtHnaU,2268
 Cython/Compiler/ParseTreeTransforms.py,sha256=nL6TdknzbWsFTThUaMJeKcDakIYf7cDFk6vsaWeTFg4,186705
@@ -66,7 +66,7 @@ Cython/Compiler/Pythran.py,sha256=wiRE1buAxQ0NFbxg7DHyyd03I6qgLp-KP_fokAvSii4,78
 Cython/Compiler/Scanning.pxd,sha256=vcNaZoZdifzj5H_cbFa1eACNNCKko9iwWaOHuWQDfWs,1358
 Cython/Compiler/Scanning.py,sha256=kZI5h8k3ZoLA_nqCAx3nY2QZljuFi3QwpjZ9N9d6GGc,25212
 Cython/Compiler/StringEncoding.py,sha256=0o6B-tFxKhUdQ79eJfHZhdLun69qdkVUeznffpBAxtI,8487
-Cython/Compiler/Symtab.py,sha256=T05lDEidL_iB5mpb0UXrRN4qfocRUD3CoD1ckT4iAoY,137637
+Cython/Compiler/Symtab.py,sha256=C18rR7_afF4id7vLEqKI4JNyV4G33d5RYWLlEB1LoCg,137775
 Cython/Compiler/TreeFragment.py,sha256=1AscujwN_mCFeO137PGy1ghCnJ17L9uYoJfqc-7h9VY,9514
 Cython/Compiler/TreePath.py,sha256=Vht_mzZpptXKJw2t_TM-PBYHtZIXXvZFWxjNkhPr9yg,7960
 Cython/Compiler/TypeInference.py,sha256=fmetS6rcT_ELhkCWMOukgOF5QarS-z0EyhvGudwvZuM,22446
@@ -76,7 +76,7 @@ Cython/Compiler/UtilNodes.py,sha256=GzzXI_7mw4IWr_y0aPwEy6af8CYIr17uddaPUGw6-_o,
 Cython/Compiler/UtilityCode.py,sha256=WC2ktplj5knJ9rpLb5v63VIFpV8QQGz2uZ9BGXjTxjs,14332
 Cython/Compiler/Version.py,sha256=24xykpTsCkAQLowr2Y16q5HnlEfiBaCLPD0y4TPy-h0,142
 Cython/Compiler/Visitor.pxd,sha256=Ys_t3ZU9Oy_GqY-P6CvZxg36dcFEAmnDzoI1gTpg6KU,1783
-Cython/Compiler/Visitor.py,sha256=KxPbGeg239Dd5vXabchffLuRMUE-vrUrD-Ag_Dlp56I,31117
+Cython/Compiler/Visitor.py,sha256=UiHHq0QkhHnvtbgs1dc7_31e3vww8TZqmnVcxmNsEWA,31384
 Cython/Compiler/__init__.py,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
 Cython/Compiler/Tests/TestBuffer.py,sha256=conB2NtpIjYP6bqS50rnDOEhSVulkfviCvuUw5_Y9Nc,4144
 Cython/Compiler/Tests/TestBuiltin.py,sha256=WyH4jo-2LCkxD_QPWMywRPaMPsUF2ZJerL4p60Hc3Mg,3453
@@ -113,7 +113,7 @@ Cython/Distutils/extension.py,sha256=hJ8VeNgGyxdz7Lke_Bg7FUkiC6mu9uNz9TosfXsfTaI
 Cython/Distutils/old_build_ext.py,sha256=T-0H1lPbaP1wa_YgV9JkattbYOhHDHqQ9gsWkqYkkd0,13723
 Cython/Includes/openmp.pxd,sha256=3GTRd5JH31CvfTzXErglXnyf_jye1Gvk9O4giTa6pc0,1712
 Cython/Includes/cpython/__init__.pxd,sha256=dUl8RHGxo-181oczdAl7vND_jkcMaHnK4A2ji1hJaos,8100
-Cython/Includes/cpython/array.pxd,sha256=yMNqxS6_3TlHriTDGZ3Gw_CBWMHZeP0W6tV26TJlhdI,6581
+Cython/Includes/cpython/array.pxd,sha256=11nQbNFyD9ILmahlOHJUdUYRMDujOkaRW_8g2UG_RxY,6599
 Cython/Includes/cpython/bool.pxd,sha256=2_ouVZUNuCHLVxpNwzQ4bCExpZTj354KcQ0iRv48LZs,1358
 Cython/Includes/cpython/buffer.pxd,sha256=wm7aHygGUof_H3-JyICOek_xiU6Oks178ark1Nfk-a0,4870
 Cython/Includes/cpython/bytearray.pxd,sha256=00A4Jz669d43AirqCWwswlVxaykwj1f3zNgMSYOYD74,1453
@@ -126,7 +126,7 @@ Cython/Includes/cpython/contextvars.pxd,sha256=5kHKXWueZ7KlnKo5HeHA90YNdZtLy07Fk
 Cython/Includes/cpython/conversion.pxd,sha256=dbbFuZJF0SscmcaNCUf0tlBQDRdKYf5tH8yzhTU_XYI,1696
 Cython/Includes/cpython/datetime.pxd,sha256=_AQIUYFSNeVzO_VtU4O_bdC-lQ8S5eCa-EEZqgWR6PI,14216
 Cython/Includes/cpython/descr.pxd,sha256=RPSPJUxyejKsWruYS3IWU1rg0L1pKFAYidYcXW9YAj0,728
-Cython/Includes/cpython/dict.pxd,sha256=k3JbYRJ_LxF39v_aErVk_Ka2-czw-H6lQCpZNUmzmdU,7959
+Cython/Includes/cpython/dict.pxd,sha256=eAjCr8sWCtjzistMc7xf5RiiRMzzm86enkT26tPW1sg,11417
 Cython/Includes/cpython/exc.pxd,sha256=0pI7VcDnMLqf-S_BClRgoiH2xGyDbhlmFGWOKcn3sGM,13830
 Cython/Includes/cpython/fileobject.pxd,sha256=yQG3M9wfS2jwpgSTo-8oXx8K9xnpGIkL-etQt9YDwTU,2889
 Cython/Includes/cpython/float.pxd,sha256=1wVFFSyGTQA0IWBACQU1BUVMwVRjXDQwNZEYcSXEew0,1670
@@ -136,7 +136,7 @@ Cython/Includes/cpython/getargs.pxd,sha256=268twKzdiAkQMXMsetNiNlNqaqzlKtiBENKbh
 Cython/Includes/cpython/instance.pxd,sha256=qCbxPeHKOJbuszDu3UEaI-KLX9lTopuaNCcpoHJ9ngU,985
 Cython/Includes/cpython/iterator.pxd,sha256=o52mLHbdm14Kqant2hR2zAdYzqK4fkSWZtBcRmpoP-I,1319
 Cython/Includes/cpython/iterobject.pxd,sha256=5UEZZwG5zyzxoCpknoQuh91zPUV11Uxr6F1taJdTv8k,1036
-Cython/Includes/cpython/list.pxd,sha256=HhnwchBGhPIAoObzIXyg33KqvSxBRveWoq34iZM508s,4096
+Cython/Includes/cpython/list.pxd,sha256=jBR_a3d8sSamhIhMnhrgjkBCVJWI1iNc230JXLpCW88,6049
 Cython/Includes/cpython/long.pxd,sha256=1gN-O5AcV4B_r974qxW9YDr7NedDyDrTRjOelClvoyA,7047
 Cython/Includes/cpython/longintrepr.pxd,sha256=zHZAj59YfzjVn-acRB8D6AELEhkO2hsejtBB4gwzQrA,335
 Cython/Includes/cpython/mapping.pxd,sha256=DI5_kOp78IaYx77qIWpetu13iMEgGXZew84mTsCPYtM,2692
@@ -176,7 +176,7 @@ Cython/Includes/libc/stdint.pxd,sha256=qHJXzpWCrbvJWSaHYZL27VJPupQreTZl9VGj0jgLd
 Cython/Includes/libc/stdio.pxd,sha256=qUaxEwNrQl1-4yHLorzzJZ-a-y5_-Rm_m7Z5meaRqH0,2476
 Cython/Includes/libc/stdlib.pxd,sha256=p62xq2XfB24WfNCjRXgD6cOYoRuV47AnYijkjWv4ugE,2444
 Cython/Includes/libc/string.pxd,sha256=tzYGbRrnccedFLes-KGgJqM0FEtwHF_q4f2fqltNvyE,2038
-Cython/Includes/libc/threads.pxd,sha256=HNfAaGiYQ3ntmYmv1xUIVBcr56Grg0Dv2O5quribVBc,9232
+Cython/Includes/libc/threads.pxd,sha256=0Wov5KeF7fux7vnmyHBbJ168aXl3anWmkQY33SkGazI,9232
 Cython/Includes/libc/time.pxd,sha256=BFEwIzV2tL_3EGonlifFlwgfja2giNQC77Qq-nz4IrY,1488
 Cython/Includes/libcpp/__init__.pxd,sha256=PCx8ZRfOeoyMRu41PPlPY9uo2kZmt_7d0KR4Epzfe7c,94
 Cython/Includes/libcpp/algorithm.pxd,sha256=HaatOKA2pIHc-RNHCIWayPXLT2Hd56Q0gKC5kLlCYYc,23704
@@ -200,7 +200,7 @@ Cython/Includes/libcpp/limits.pxd,sha256=BWJzVBB8MZt3l9PUre1o5eScE2fGJa3_Sv6e_KH
 Cython/Includes/libcpp/list.pxd,sha256=iOovgIk_Slkf7yaDEv6-ZUss_AU98OGWkvgNQDF0K0A,4438
 Cython/Includes/libcpp/map.pxd,sha256=C8EaEsvLEc2tmEkyybOzgkx3CoFWYFBpZelHhcKHI1s,10481
 Cython/Includes/libcpp/memory.pxd,sha256=OqNDPX_1ps9bxWCEQDiefbQv-NeZJ7SNUQtdYB86MZs,3593
-Cython/Includes/libcpp/mutex.pxd,sha256=cxuiJwcyXnT33pOfE-tPPZbgPHHK1v-yCBiurzSaEUw,14843
+Cython/Includes/libcpp/mutex.pxd,sha256=WJYD5G7eyI6EVEsMDK7unvs3m4JWAXfEfXh1V3qgTzs,14843
 Cython/Includes/libcpp/numbers.pxd,sha256=SkBhbClhRTtzbSMj_QvR2pz-CjdB08ZXPJbXSwATzvw,395
 Cython/Includes/libcpp/numeric.pxd,sha256=H4k7D-xrJ3mcLrGRUmghwS1-9FPb4BQnSREMuw3PvKQ,6570
 Cython/Includes/libcpp/optional.pxd,sha256=Mf5gnZIvB9IR-L7bi3ntog2EOXB-pp1Xo45CWqyRCiU,990
@@ -269,7 +269,7 @@ Cython/Tests/xmlrunner.py,sha256=1X79TBIYWOcZIzoylOSu9zULxVIR4xvq-RZ7f8Fn600,146
 Cython/Utility/AsyncGen.c,sha256=MG4LN14ozyq3JruA1Ad8I9ZnjlASxO2kwfvHTcAHXuU,33376
 Cython/Utility/Buffer.c,sha256=TcJ4eSxi1NxD51NH2GEK-dXgXdmVFIQcHSq22azfB2U,28258
 Cython/Utility/BufferFormatFromTypeInfo.pxd,sha256=KoGGKw7rW8Utav9xrwVZpsLX-vlpFe3Xv0hmp45PimM,97
-Cython/Utility/Builtins.c,sha256=udHKjWEYYG6CEKTeD6yxY03l2GVwLSa5svM6NKPrGg4,26719
+Cython/Utility/Builtins.c,sha256=76n9lDGzDe37cskDojBYSXozaPTvy9AS_TFdm_Fj56U,26733
 Cython/Utility/CConvert.pyx,sha256=UFlPDRT9anal0RpY03hXsejEcwp-RXJSnLy6LbbnmPQ,4471
 Cython/Utility/CMath.c,sha256=rP6O5u23EybDGimRCHfy8WTpyxhPu5G1F6ksEmrgKnQ,3044
 Cython/Utility/CommonStructures.c,sha256=cXOrFQv0DP8QX2CF4u_2O2lFW41WC3nTNwSKRVt3B7M,7926
@@ -278,10 +278,10 @@ Cython/Utility/Coroutine.c,sha256=mnN1zdID44Jn-0qF5Bw17QA5gloWpO8JTjiF7ggzuF8,85
 Cython/Utility/CpdefEnums.pyx,sha256=TMXyfhDeip3zqatMgNEQTQiss41nnp-PzFGn78tgBAs,3531
 Cython/Utility/CppConvert.pyx,sha256=onbI09dQzC6ZJxvzosS-WuvweIeh3f0rd65Xor7G3AU,7317
 Cython/Utility/CppSupport.cpp,sha256=vR1G8qqdyLWTk4quKz5v6Z1syIMrfPldB9IzbwkYxDo,5464
-Cython/Utility/CythonFunction.c,sha256=BCAiHjYiVBWils4k776a4UvBaDmuE7OSOFkygPXPtZE,63367
+Cython/Utility/CythonFunction.c,sha256=VJMWKfsT4-5-gj8POZFCxaEUO4awTN7zineBjTriNZI,63250
 Cython/Utility/Dataclasses.c,sha256=eCa9JHHg6bj-WSKw1xTDjazghmXAkMd9J5TnELNTVOI,4023
-Cython/Utility/Embed.c,sha256=pMoDW-9EHL_bxqKsaiCbkhyMMdYxdrDzUtlf-d0i-HQ,3417
-Cython/Utility/Exceptions.c,sha256=AE8cCfTP5E9C-c9eaY-xvv2nclXGUL5G4qT6qo8CZpE,35547
+Cython/Utility/Embed.c,sha256=P4JHaSwtj61hRVFgQBKyt3FaNJiBjJe-asLtsFtexGs,3439
+Cython/Utility/Exceptions.c,sha256=EV8TIZaCdQNo7CPGo6LPQYDYE1a06l2IOwEp6PIHLns,35793
 Cython/Utility/ExtensionTypes.c,sha256=l3_3wNWBncR-JcaWmUqe3ME56-PwxNEMo5rTo7Ih2ug,38249
 Cython/Utility/FunctionArguments.c,sha256=HvEfAAdrvBDxbAmiK_HZ4F2IFXs-xWC-u-28gwQ06fA,33705
 Cython/Utility/FusedFunction.pyx,sha256=3reL7n6L2M3gU_OXSYAvoDEVVjJxMWvpiesvGmRAEc8,1494
@@ -291,14 +291,14 @@ Cython/Utility/MemoryView.pyx,sha256=b_H0MFfFOLfBJUxD070EwnJLnZolLjPND96_IIDY-fg
 Cython/Utility/MemoryView_C.c,sha256=yFrTMRyNIE-PCKi-PzqcrzxfieSY6AaE6EsoQvHKcf4,28780
 Cython/Utility/ModuleSetupCode.c,sha256=OR-NnsdtIVlj6_hmIVquSLnOFyAqm2cA5RIF1oZcQj0,118854
 Cython/Utility/NumpyImportArray.c,sha256=Gwo493DF8JxUxhTTjJYIdyHHJ9TEwFKqDmKsdk_uPyw,2033
-Cython/Utility/ObjectHandling.c,sha256=yKBjDrbzSf5t4kunHiWZHqmN2lDnZvlPq96TCD4vIkU,119365
-Cython/Utility/Optimize.c,sha256=ksJP3HuQl63FSOE351WQLPmCpMdp1tdiyL4dOJPjfwA,59685
+Cython/Utility/ObjectHandling.c,sha256=FOu27NOBKND-kNgq3mgCOw1ymElvTmXfUazeajzn218,120275
+Cython/Utility/Optimize.c,sha256=AHaZlr8XCp6E2QOBNlUAEIhRUolKp0UyRJxh6jilqjk,59931
 Cython/Utility/Overflow.c,sha256=9C-WIzd4k4uSD7IrLVIJz8fEMK1jFt9UR4WRjDlarYk,15689
 Cython/Utility/Printing.c,sha256=h3F9eyCXSs284Y8DZRivKtoAOcx5jIYPeNFOSD59foc,2898
 Cython/Utility/Profile.c,sha256=JPglBHCdnTtyGj0JKzPtfN0djAIe6P5FVAqBQt43RZo,41218
 Cython/Utility/StringTools.c,sha256=WQpQTBWSVYpNPUsVj2cXP_RgwcfyQ_NH-T70e65N59U,50848
-Cython/Utility/Synchronization.c,sha256=mLjmEoh00bkL1LGFbecq9xtbE_86y6tdPHmZb4Uzjz8,18675
-Cython/Utility/TString.c,sha256=UM3kg04oc0qq54ciFZd9X6Bk2acO1TqqZo89UtFvaoQ,13893
+Cython/Utility/Synchronization.c,sha256=B3sJpm2UwNGkjWIeMDF8AqCgtttASNIPRXHvA7kXLKE,18675
+Cython/Utility/TString.c,sha256=8cAAcx70pSeYH9Xw98OPmYBUV1LtgwmIFr54Swvuqa0,14001
 Cython/Utility/TestCyUtilityLoader.pyx,sha256=91lWWJub7l_6xNn3ncrvQZZ94RpkQzEx2NtAaFpvrxY,152
 Cython/Utility/TestCythonScope.pyx,sha256=mWowHlHIs22w6xC5KAc8kelf2f2n6bhLapyqgz0JMpc,1999
 Cython/Utility/TestUtilityLoader.c,sha256=dGy6ZWL2kBqtmUY7kF75UEox5kadQZ__BmZKscwg2aY,279
@@ -310,8 +310,8 @@ Cython/Utility/arrayarray.h,sha256=hjXya3s-GoN4mKZTKUlyqPfT3tzf0GiansnSkUcWhk0,4
 pyximport/__init__.py,sha256=9hOyKolFtOerPiVEyktKrT1VtzbGexq9UmORzo52iHI,79
 pyximport/pyxbuild.py,sha256=AsL1tyLxG61Mj7Ah-DxtDBuaXF94W2Tb6KTos7r0w8I,5702
 pyximport/pyximport.py,sha256=BnXVwq1cwo1EYRjPU0J-RUDcwzGjUlzKWZOOMDNcu-s,18510
-cython-3.2.1.dist-info/METADATA,sha256=K3wBpDK7xFhqMMYTjA4K_mDyZ02hYmU2p92PQHl9uwY,6458
-cython-3.2.1.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-cython-3.2.1.dist-info/entry_points.txt,sha256=VU8NX8gnQyFbyqiWMzfh9BHvYMuoQRS3Nbm3kKcKQeY,139
-cython-3.2.1.dist-info/top_level.txt,sha256=jLV8tZV98iCbIfiJR4DVzTX5Ru1Y_pYMZ59wkMCe6SY,24
-cython-3.2.1.dist-info/RECORD,,
+cython-3.2.3.dist-info/METADATA,sha256=8EoMsr6l320ZMH_ZMxMZUUzPLxRYB-B8v1zy8ZyDSiU,4285
+cython-3.2.3.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+cython-3.2.3.dist-info/entry_points.txt,sha256=VU8NX8gnQyFbyqiWMzfh9BHvYMuoQRS3Nbm3kKcKQeY,139
+cython-3.2.3.dist-info/top_level.txt,sha256=jLV8tZV98iCbIfiJR4DVzTX5Ru1Y_pYMZ59wkMCe6SY,24
+cython-3.2.3.dist-info/RECORD,,