Cython 3.2.0b2__tar.gz → 3.2.0b3__tar.gz

cython-3.2.0b3/.gitrev

@@ -0,0 +1 @@
+730a05b38a517180be7ec9b627c76d89d160cd55

{cython-3.2.0b2 → cython-3.2.0b3}/CHANGES.rst

@@ -2,6 +2,31 @@
 Cython Changelog
 ================
 
+3.2.0b3 (2025-10-30)
+====================
+
+Bugs fixed
+----------
+
+* Using ``cython.pymutex`` in an extension type declared as ``public`` or ``api``
+  generated invalid C code missing the required ``PyMutex`` declarations.
+  (Github issues :issue:`6992`, :issue:`6995`)
+
+* 3.2.0b2 generated incorrect pointer casts in the ``cimport`` importing code.
+  (Github issue :issue:`7268`)
+
+* Cython's type sharing across modules suffered from race conditions if multiple modules
+  tried to initialise and share their types concurrently.  This is due to an underlying
+  CPython issue and cannot easily be worked around completely.  In the common case that
+  module dicts are plain Python dict objects, however, Cython now uses a ``.setdefault()``
+  equivalent for thread-safe type sharing.
+  See https://github.com/python/cpython/issues/137422
+  (Github issue :issue:`7076`)
+
+* Cython incorrectly called ``PyList_GetItemRef()`` in PyPy and GraalPython before Py3.13.
+  (Github issue :issue:`7269`)
+
+
 3.2.0b2 (2025-10-27)
 ====================
 
@@ -238,6 +263,19 @@ Other changes
   (Github issue :issue:`6423`)
 
 
+3.1.7 (2025-??-??)
+==================
+
+Bugs fixed
+----------
+
+* Cython incorrectly called ``PyList_GetItemRef()`` in PyPy and GraalPython before Py3.13.
+  (Github issue :issue:`7269`)
+
+* Trying to instantiate internal types used by Cython is now prohibited.
+  (Github issue :issue:`7263`)
+
+
 3.1.6 (2025-10-23)
 ==================
 

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Compiler/Code.py

@@ -463,7 +463,7 @@ class UtilityCodeBase(AbstractUtilityCode):
             # section title
             r'^%(C)s{5,30}  \s*  (?P<name> (?:\w|\.)+ )  \s*  %(C)s{5,30} |'
             # section tags and dependencies
-            r'^%(C)s+  @(?P<tag> \w+)  \s*  :  \s*  (?P<value> (?: \w|[.:] )+ )'
+            r'^%(C)s+  @(?P<tag> .+)'
         ) % {'C': re.escape(line_comment_char)}, re.VERBOSE).match
 
     @classmethod
@@ -496,8 +496,8 @@ class UtilityCodeBase(AbstractUtilityCode):
 
         if tags:
             all_tags = utility[2]
-            for name, values in tags.items():
-                all_tags.setdefault(name, set()).update(values)
+            for tag_name, tag_values in tags.items():
+                all_tags.setdefault(tag_name, set()).update(tag_values)
 
     @classmethod
     def load_utilities_from_file(cls, path):
@@ -528,26 +528,38 @@ class UtilityCodeBase(AbstractUtilityCode):
 
         for lineno, line in enumerate(all_lines):
             m = match_special(line)
-            if m:
-                if m.group('name'):
-                    cls._add_utility(utility, name, type, lines, begin_lineno, tags)
-
-                    begin_lineno = lineno + 1
-                    del lines[:]
-                    tags.clear()
-
-                    name = m.group('name')
-                    mtype = match_type(name)
-                    if mtype:
-                        name, type = mtype.groups()
-                    else:
-                        type = 'impl'
-                    utility = utilities[name]
+            if m is None:
+                lines.append(rstrip(strip_comments(line)))
+            elif m.group('name'):
+                cls._add_utility(utility, name, type, lines, begin_lineno, tags)
+
+                begin_lineno = lineno + 1
+                del lines[:]
+                tags.clear()
+
+                name = m.group('name')
+                mtype = match_type(name)
+                if mtype:
+                    name, type = mtype.groups()
                 else:
-                    tags[m.group('tag')].add(m.group('value'))
-                    lines.append('')  # keep line number correct
+                    type = 'impl'
+                utility = utilities[name]
             else:
-                lines.append(rstrip(strip_comments(line)))
+                tag_value = m.group('tag')
+                if ':' not in tag_value:
+                    raise RuntimeError(f"Found invalid tag '{tag_value}' in utility section {name}.{type}")
+
+                tag_name, _, tag_value = tag_value.partition(':')
+                tag_name = tag_name.rstrip()
+                tag_value = tag_value.strip()
+
+                if tag_name not in ('requires', 'substitute', 'proto_block'):
+                    raise RuntimeError(f"Found unknown tag name '{tag_name}' in utility section {name}.{type}")
+                if not re.match(r'\S+$', tag_value):
+                    raise RuntimeError(f"Found invalid tag value '{tag_value}' in utility section {name}.{type}")
+
+                tags[tag_name].add(tag_value)
+                lines.append('')  # keep line number correct
 
         if utility is None:
             raise ValueError("Empty utility code file")
@@ -2479,6 +2491,10 @@ class GlobalState:
             self.use_utility_code(entry.utility_code)
         if entry.utility_code_definition:
             self.use_utility_code(entry.utility_code_definition)
+        from . import PyrexTypes
+        for tp in PyrexTypes.get_all_subtypes(entry.type):
+            if hasattr(tp, "entry") and tp.entry is not entry:
+                self.use_entry_utility_code(tp.entry)
 
 
 def funccontext_property(func):
@@ -2968,7 +2984,7 @@ class CCodeWriter:
         elif entry.type.is_pyobject:
             self.put(" = NULL")
         self.putln(";")
-        self.funcstate.scope.use_entry_utility_code(entry)
+        self.globalstate.use_entry_utility_code(entry)
 
     def put_temp_declarations(self, func_context: FunctionState):
         for name, type, manage_ref, static in func_context.temps_allocated:

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Compiler/CythonScope.py

@@ -25,12 +25,16 @@ class CythonScope(ModuleScope):
                                          cname='<error>')
             entry.in_cinclude = True
 
+        cy_pymutex_type = get_cy_pymutex_type()
         entry = self.declare_type(
             "pymutex", cy_pymutex_type, None,
             cname="__Pyx_Locks_PyMutex")
+        entry.utility_code_definition = cy_pymutex_type.get_decl_utility_code()
+        cy_pythread_type_lock_type = get_cy_pythread_type_lock_type()
         entry = self.declare_type(
             "pythread_type_lock", cy_pythread_type_lock_type, None,
             cname="__Pyx_Locks_PyThreadTypeLock")
+        entry.utility_code_definition = cy_pythread_type_lock_type.get_decl_utility_code()
 
     def is_cpp(self):
         # Allow C++ utility code in C++ contexts.

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Compiler/ExprNodes.py

@@ -76,6 +76,9 @@ class NotConstant:
 not_a_constant = NotConstant()
 constant_value_not_set = object()
 
+def _type_to_itself(tp):
+    return tp, tp
+
 # error messages when coercing from key[0] to key[1]
 coercion_error_dict = {
     # string related errors
@@ -94,9 +97,9 @@ coercion_error_dict = {
     (PyrexTypes.c_uchar_ptr_type, unicode_type): "Cannot convert 'char*' to unicode implicitly, decoding required",
     (PyrexTypes.c_const_uchar_ptr_type, unicode_type): (
         "Cannot convert 'char*' to unicode implicitly, decoding required"),
-    (PyrexTypes.cy_pymutex_type, PyrexTypes.cy_pymutex_type): (
+    _type_to_itself(PyrexTypes.get_cy_pymutex_type()): (
         "cython.pymutex cannot be copied"),
-    (PyrexTypes.cy_pythread_type_lock_type, PyrexTypes.cy_pythread_type_lock_type): (
+    _type_to_itself(PyrexTypes.get_cy_pythread_type_lock_type()): (
         "cython.pythread_type_lock cannot be copied"),
 }
 

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Compiler/ModuleNode.py

@@ -161,7 +161,7 @@ class SharedUtilityExporter:
         shared_utility_qualified_name = EncodedString(self.scope.context.shared_utility_qualified_name)
         import_func = f"__Pyx_ImportFunction_{Naming.cyversion}"
         _generate_import_code(
-            code, self.pos, imports, shared_utility_qualified_name, import_func, "void (*{name})(void)")
+            code, self.pos, imports, shared_utility_qualified_name, import_func, "void (**{name})(void)")
 
     def _generate_exports(self, shared_utility_functions: Sequence[Code.SharedFunctionDecl]):
         if self.has_shared_exports(shared_utility_functions):
@@ -285,7 +285,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
 
         self.body.analyse_declarations(env)
 
-        if env.find_shared_usages_of_type(lambda tp: tp is PyrexTypes.cy_pymutex_type):
+        cy_pymutex_type = PyrexTypes.get_cy_pymutex_type()
+        if env.find_shared_usages_of_type(cy_pymutex_type):
             # Be very suspicious of cython locks that are shared.
             # They have the potential to cause ABI issues.
             self.scope.use_utility_code(
@@ -362,30 +363,33 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
             h_code_start.put_h_guard(h_guard)
             h_code_start.putln("")
             h_code_start.putln('#include "Python.h"')
-            self.generate_type_header_code(h_types, h_code_start)
+            self.generate_type_header_code(h_types, h_code_main)
             if options.capi_reexport_cincludes:
-                self.generate_includes(env, [], h_code_start)
-            h_code_start.putln("")
+                self.generate_includes(env, [], h_code_main)
+            h_code_main.putln("")
             api_guard = self.api_name(Naming.api_guard_prefix, env)
-            h_code_start.putln("#ifndef %s" % api_guard)
-            h_code_start.putln("")
-            self.generate_extern_c_macro_definition(h_code_start, env.is_cpp())
-            h_code_start.putln("")
-            self.generate_dl_import_macro(h_code_start)
+            h_code_main.putln("#ifndef %s" % api_guard)
+            h_code_main.putln("")
+            self.generate_extern_c_macro_definition(h_code_main, env.is_cpp())
+            h_code_main.putln("")
+            self.generate_dl_import_macro(h_code_main)
             if h_extension_types:
                 h_code_main.putln("")
                 for entry in h_extension_types:
                     self.generate_cclass_header_code(entry.type, h_code_main)
                     if i_code:
                         self.generate_cclass_include_code(entry.type, i_code)
+                    globalstate.use_entry_utility_code(entry)
             if h_funcs:
                 h_code_main.putln("")
                 for entry in h_funcs:
                     self.generate_public_declaration(entry, h_code_main, i_code)
+                    globalstate.use_entry_utility_code(entry)
             if h_vars:
                 h_code_main.putln("")
                 for entry in h_vars:
                     self.generate_public_declaration(entry, h_code_main, i_code)
+                    globalstate.use_entry_utility_code(entry)
             h_code_main.putln("")
             h_code_main.putln("#endif /* !%s */" % api_guard)
             h_code_main.putln("")
@@ -452,7 +456,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
 
         h_code = Code.CCodeWriter()
         c_code_config = generate_c_code_config(env, options)
-        Code.GlobalState(h_code, self, c_code_config)
+        globalstate = Code.GlobalState(h_code, self, c_code_config)
+        globalstate.initialize_main_h_code()  # in-case utility code is used in the header
         h_code.put_generated_by()
         api_guard = self.api_name(Naming.api_guard_prefix, env)
         h_code.put_h_guard(api_guard)
@@ -480,6 +485,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                 h_code.putln("static PyTypeObject *%s = 0;" % type.typeptr_cname)
                 h_code.putln("#define %s (*%s)" % (
                     type.typeobj_cname, type.typeptr_cname))
+                h_code.globalstate.use_entry_utility_code(entry)
         if api_funcs:
             h_code.putln("")
             for entry in api_funcs:
@@ -487,6 +493,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                 cname = env.mangle(Naming.func_prefix_api, entry.name)
                 h_code.putln("static %s = 0;" % type.declaration_code(cname))
                 h_code.putln("#define %s %s" % (entry.name, cname))
+                h_code.globalstate.use_entry_utility_code(entry)
         if api_vars:
             h_code.putln("")
             for entry in api_vars:
@@ -494,6 +501,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                 cname = env.mangle(Naming.varptr_prefix_api, entry.name)
                 h_code.putln("static %s = 0;" % type.declaration_code(cname))
                 h_code.putln("#define %s (*%s)" % (entry.name, cname))
+                h_code.globalstate.use_entry_utility_code(entry)
         if api_vars:
             put_utility_code("VoidPtrImport", "ImportExport.c")
         if api_funcs:
@@ -1012,6 +1020,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
 
         env.use_utility_code(UtilityCode.load_cached("FastTypeChecks", "ModuleSetupCode.c"))
         env.use_utility_code(UtilityCode.load("GetRuntimeVersion", "ModuleSetupCode.c"))
+        env.use_utility_code(UtilityCode.load_cached("AddModuleRef", "ModuleSetupCode.c"))
         if has_np_pythran(env):
             env.use_utility_code(UtilityCode.load_cached("PythranConversion", "CppSupport.cpp"))
 
@@ -1109,6 +1118,9 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                     self.generate_cpp_class_definition(entry, code)
                 elif type.is_extension_type:
                     self.generate_objstruct_definition(type, code)
+                if getattr(type, "scope", None):
+                    for var_entry in type.scope.var_entries:
+                        code.globalstate.use_entry_utility_code(var_entry)
 
     def generate_gcc33_hack(self, env, code):
         # Workaround for spurious warning generation in gcc 3.3
@@ -1447,7 +1459,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                 decl = attr_type.cpp_optional_declaration_code(attr.cname)
             else:
                 decl = attr_type.declaration_code(attr.cname)
-            type.scope.use_entry_utility_code(attr)
+            code.globalstate.use_entry_utility_code(attr)
             code.putln("%s;" % decl)
         code.putln(footer)
         if type.objtypedef_cname is not None:
@@ -1526,7 +1538,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
             code.putln(";")
             if entry.cname != cname:
                 code.putln("#define %s (*%s)" % (entry.cname, cname))
-            env.use_entry_utility_code(entry)
+            code.globalstate.use_entry_utility_code(entry)
 
     def generate_cfunction_declarations(self, env, code, definition):
         for entry in env.cfunc_entries:
@@ -4204,6 +4216,7 @@ def generate_cfunction_declaration(entry, env, code, definition):
             storage_class,
             modifiers,
             header))
+        code.globalstate.use_entry_utility_code(entry)
 
 #------------------------------------------------------------------------------------
 #

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Compiler/Nodes.py

@@ -2989,6 +2989,7 @@ class CFuncDefNode(FuncDefNode):
             if preprocessor_guard:
                 code.globalstate.parts['module_declarations'].putln("#endif")
         code.putln("%s%s%s {" % (storage_class, modifiers, header))
+        code.globalstate.use_entry_utility_code(self.entry)
 
     def generate_argument_declarations(self, env, code):
         scope = self.local_scope
@@ -9030,11 +9031,12 @@ class CriticalSectionStatNode(TryFinallyStatNode):
         return super().analyse_declarations(env)
 
     def analyse_expressions(self, env):
+        cy_pymutex_type = PyrexTypes.get_cy_pymutex_type()
         mutex_count = 0
         for i, arg in enumerate(self.args):
             arg = arg.analyse_expressions(env)
-            if (arg.type is PyrexTypes.cy_pymutex_type or (
-                    arg.type.is_ptr and arg.type.base_type is PyrexTypes.cy_pymutex_type)):
+            if (arg.type == cy_pymutex_type or (
+                    arg.type.is_ptr and arg.type.base_type == cy_pymutex_type)):
                 mutex_count += 1
                 self.is_pymutex_critical_section = True
             elif arg.type.is_pyobject:
@@ -9189,7 +9191,7 @@ class CythonLockStatNode(TryFinallyStatNode):
         return super().analyse_expressions(env)
 
     def generate_execution_code(self, code):
-        code.globalstate.use_utility_code(self.arg.type.get_utility_code())
+        code.globalstate.use_utility_code(self.arg.type.get_usage_utility_code())
 
         code.mark_pos(self.pos)
         code.begin_block()

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Compiler/PyrexTypes.py

@@ -4947,9 +4947,10 @@ class CythonLockType(PyrexType):
         # Singleton, cannot be copied.
         return src_type is self._special_assignable_reference_type
 
-    def get_utility_code(self):
-        # It doesn't seem like a good way to associate utility code with a type actually exists
-        # so we just have to do it in as many places as possible.
+    def get_decl_utility_code(self):
+        return UtilityCode.load_cached(f"{self.cname_part}Decl", "Synchronization.c")
+
+    def get_usage_utility_code(self):
         return UtilityCode.load_cached(self.cname_part, "Synchronization.c")
 
     def needs_explicit_construction(self, scope):
@@ -4964,7 +4965,7 @@ class CythonLockType(PyrexType):
 
     def generate_explicit_construction(self, code, entry, extra_access_code=""):
         code.globalstate.use_utility_code(
-            self.get_utility_code()
+            self.get_usage_utility_code()
         )
         code.putln(f"__Pyx_Locks_{self.cname_part}_Init({extra_access_code}{entry.cname});")
 
@@ -4992,7 +4993,7 @@ class CythonLockType(PyrexType):
                     pos=None,
                     defining=1,
                     cname=f"__Pyx_Locks_{self.cname_part}_Lock",
-                    utility_code=self.get_utility_code())
+                    utility_code=self.get_usage_utility_code())
             scope.declare_cfunction(
                     "release",
                     CFuncType(c_void_type, [CFuncTypeArg("self", self_type, None)],
@@ -5000,7 +5001,7 @@ class CythonLockType(PyrexType):
                     pos=None,
                     defining=1,
                     cname=f"__Pyx_Locks_{self.cname_part}_Unlock",
-                    utility_code=self.get_utility_code())
+                    utility_code=self.get_usage_utility_code())
             # Don't define a "locked" function because we can't do this with Py_Mutex
             # (which is the preferred implementation)
 
@@ -5012,6 +5013,14 @@ class CythonLockType(PyrexType):
     def create_from_py_utility_code(self, env):
         return False
 
+    def __eq__(self, other):
+        if type(other) is not type(self):
+            return NotImplemented
+        return other.cname_part == self.cname_part
+
+    def __hash__(self):
+        return hash(self.cname_part)
+
 
 rank_to_type_name = (
     "char",          # 0
@@ -5143,8 +5152,12 @@ cython_memoryview_type = CStructOrUnionType("__pyx_memoryview_obj", "struct",
 memoryviewslice_type = CStructOrUnionType("memoryviewslice", "struct",
                                           None, 1, "__Pyx_memviewslice")
 
-cy_pymutex_type = CythonLockType("PyMutex")
-cy_pythread_type_lock_type = CythonLockType("PyThreadTypeLock")
+# Don't declare these as globals - it interferes with our ability to check if it's
+# used in a particular scope.
+def get_cy_pymutex_type():
+    return CythonLockType("PyMutex")
+def get_cy_pythread_type_lock_type():
+    return CythonLockType("PyThreadTypeLock")
 
 fixed_sign_int_types = {
     "bint":       (1, c_bint_type),

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Compiler/Symtab.py

@@ -1236,7 +1236,7 @@ class Scope:
         # e.g. slot, function, method
         return f"{Naming.modulestateglobal_cname}->{cname}"
 
-    def find_shared_usages_of_type(self, type_check_predicate, _seen_scopes=None):
+    def find_shared_usages_of_type(self, type_to_find, _seen_scopes=None):
         if _seen_scopes is None:
             _seen_scopes = set()
         include_all_entries = not self.is_module_scope
@@ -1244,13 +1244,13 @@ class Scope:
             if not (include_all_entries or entry.defined_in_pxd or entry.visibility == "public" or entry.api):
                 continue
             entry_subtypes = PyrexTypes.get_all_subtypes(entry.type)
-            if any(type_check_predicate(sub_tp) for sub_tp in entry_subtypes):
+            if any(type_to_find == sub_tp for sub_tp in entry_subtypes):
                 return True
             type_scope = getattr(entry.type, "scope", None)
             if type_scope is None or type_scope in _seen_scopes:
                 continue
             _seen_scopes.add(type_scope)
-            if type_scope.find_shared_usages_of_type(type_check_predicate, _seen_scopes):
+            if type_scope.find_shared_usages_of_type(type_to_find, _seen_scopes):
                 return True
         return False
 
@@ -1777,6 +1777,9 @@ class ModuleScope(Scope):
             self.utility_code_list.append(entry.utility_code)
         if entry.utility_code_definition:
             self.utility_code_list.append(entry.utility_code_definition)
+        for tp in PyrexTypes.get_all_subtypes(entry.type):
+            if hasattr(tp, "entry") and tp.entry is not entry:
+                self.use_entry_utility_code(tp.entry)
 
     def declare_c_class(self, name, pos, defining=0, implementing=0,
             module_name=None, base_type=None, objstruct_cname=None,

{cython-3.2.0b2 → cython-3.2.0b3}/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.0b2"
+__version__ = "3.2.0b3"
 
 
 # BEGIN shameless copy from Cython/minivect/minitypes.py

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Utility/CommonStructures.c

@@ -3,6 +3,7 @@
 static PyObject *__Pyx_FetchSharedCythonABIModule(void);
 
 /////////////// FetchSharedCythonModule ////////////
+//@requires: ModuleSetupCode.c::AddModuleRef
 
 static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
     return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME);

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Utility/ModuleSetupCode.c

@@ -1186,16 +1186,6 @@ static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key,
   #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o)
 #endif
 
-#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
-  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
-#else
-  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
-      PyObject *module = PyImport_AddModule(name);
-      Py_XINCREF(module);
-      return module;
-  }
-#endif
-
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString)
   #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
 #endif
@@ -2220,6 +2210,7 @@ static void __Pyx_FastGilFuncInit(void);
 #endif
 
 /////////////// FastGil ///////////////
+//@requires: AddModuleRef
 // The implementations of PyGILState_Ensure/Release calls PyThread_get_key_value
 // several times which is turns out to be quite slow (slower in fact than
 // acquiring the GIL itself).  Simply storing it in a thread local for the
@@ -3149,3 +3140,64 @@ static CYTHON_INLINE int __Pyx_UnknownThreadStateMayHaveHadGil(__Pyx_UnknownThre
   return state != NULL;
   #endif
 }
+
+///////////////////// AddModuleRef.proto ///////////////////////
+
+#if ((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING /* && __PYX_LIMITED_VERSION_HEX < some future value */) || \
+     __PYX_LIMITED_VERSION_HEX < 0x030d0000) 
+  // https://github.com/python/cpython/issues/137422 - PyImport_AddModule(Ref) isn't thread safe!
+  static PyObject *__Pyx_PyImport_AddModuleRef(const char *name); /* proto */
+#else
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#endif
+
+///////////////////// AddModuleRef ////////////////////////////
+
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING /* && __PYX_LIMITED_VERSION_HEX < some future value */
+  // https://github.com/python/cpython/issues/137422 - PyImport_AddModule(Ref) isn't thread safe!
+  static PyObject *__Pyx_PyImport_AddModuleObjectRef(PyObject *name) {
+      // We're going to assume nobody is swapping the module dict out from under us
+      // (even though they're allowed to) because we really can't write code that's
+      // safe against that.
+      PyObject *module_dict = PyImport_GetModuleDict();
+      PyObject *m;
+      if (PyMapping_GetOptionalItem(module_dict, name, &m) < 0) { 
+          return NULL; 
+      } 
+      if (m != NULL && PyModule_Check(m)) { 
+          return m; 
+      }
+      Py_XDECREF(m); 
+      m = PyModule_NewObject(name);
+      if (m == NULL) 
+          return NULL; 
+      if (PyDict_CheckExact(module_dict)) {
+          PyObject *new_m;
+          (void)PyDict_SetDefaultRef(module_dict, name, m, &new_m);
+          Py_DECREF(m);
+          return new_m;
+      } else {
+            // For non-dict sys-modules I don't think it's possible to reliably make thread-safe.
+           if (PyObject_SetItem(module_dict, name, m) != 0) { 
+                Py_DECREF(m); 
+                return NULL; 
+            }         
+            return m; 
+      }
+  }
+  static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *py_name = PyUnicode_FromString(name);
+      if (!py_name) return NULL;
+      PyObject *module = __Pyx_PyImport_AddModuleObjectRef(py_name); 
+      Py_DECREF(py_name);
+      return module;
+  }
+#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
+#endif

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Utility/ObjectHandling.c

@@ -2244,7 +2244,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObj
 }
 
 /////////////// PyObjectFastCallMethod.proto ///////////////
-//@requires PyObjectFastCall
+//@requires: PyObjectFastCall
 
 #if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000
 #define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL)
@@ -3207,7 +3207,7 @@ static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, P
 CYTHON_INLINE
 static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue); /* proto */
 #endif
-    
+
 
 //////////////////////// OwnedDictNext //////////////////////////////////////
 //@requires: Builtins.c::py_dict_values
@@ -3251,7 +3251,7 @@ static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, P
   bad:
     Py_XDECREF(next);
     // PyDict_Next can't fail, so neither can this
-#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000
     PyErr_FormatUnraisable("Exception ignored in __Pyx_PyDict_NextRef");
 #else
     PyErr_WriteUnraisable(PYIDENT("__Pyx_PyDict_NextRef"));

{cython-3.2.0b2 → cython-3.2.0b3}/Cython/Utility/Optimize.c

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