Cython 3.2.0b2__py3-none-any.whl → 3.2.0b3__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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
     {

Cython/Utility/Synchronization.c

@@ -229,15 +229,22 @@
 #endif
 
 
-////////////////////// PyThreadTypeLock.proto //////////
+////////////////////// PyThreadTypeLockDecl.proto //////////
 //@proto_block: utility_code_proto_before_types
 
 // This lock type always uses PyThread_type_lock. The main reason
 // to use it is if you are using the Limited API and want to
 // share locks between modules.
 
+#ifndef __PYX_HAVE_PYX_THREAD_TYPE_LOCK_DECL
+#define __PYX_HAVE_PYX_THREAD_TYPE_LOCK_DECL
 #define __Pyx_Locks_PyThreadTypeLock PyThread_type_lock
 #define __Pyx_Locks_PyThreadTypeLock_DECL NULL
+#endif
+
+
+////////////////////// PyThreadTypeLock.proto //////////////////
+
 #define __Pyx_Locks_PyThreadTypeLock_Init(l) l = PyThread_allocate_lock()
 #define __Pyx_Locks_PyThreadTypeLock_Delete(l) PyThread_free_lock(l)
 #define __Pyx_Locks_PyThreadTypeLock_LockNogil(l) (void)PyThread_acquire_lock(l, WAIT_LOCK)
@@ -254,6 +261,7 @@ static CYTHON_INLINE void __Pyx_Locks_PyThreadTypeLock_LockGil(__Pyx_Locks_PyThr
 
 
 ////////////////////// PyThreadTypeLock ////////////////
+//@requires: PyThreadTypeLockDecl
 
 #if CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM < 0x07031400
 #define PY_LOCK_ACQUIRED 1
@@ -319,9 +327,9 @@ static void __Pyx__Locks_PyThreadTypeLock_Lock(__Pyx_Locks_PyThreadTypeLock lock
 }
 
 
-////////////////////// PyMutex.proto ////////////////////
+////////////////////// PyMutexDecl.proto ////////////////////
 //@proto_block: utility_code_proto_before_types
-//@requires: PyThreadTypeLock
+//@requires: PyThreadTypeLockDecl
 
 // We support two implementations - a Py3.13+ version using PyMutex and
 // an older version using PyThread_type_lock.
@@ -336,9 +344,25 @@ static void __Pyx__Locks_PyThreadTypeLock_Lock(__Pyx_Locks_PyThreadTypeLock lock
 // CythonLockType in a public way. However, they can use
 // CythonCompatibleLockType which will always be PyThread_type_lock.
 
-#if PY_VERSION_HEX > 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API
+#ifndef __PYX_HAVE_PYX_PYMUTEX_DECL
+#define __PYX_HAVE_PYX_PYMUTEX_DECL
+// Not CYTHON_COMPILING_IN_LIMITED_API because this code may be in
+// headers where that isn't available
+#if PY_VERSION_HEX > 0x030d0000 && !defined(Py_LIMITED_API)
 #define __Pyx_Locks_PyMutex PyMutex
 #define __Pyx_Locks_PyMutex_DECL {0}
+#else
+#define __Pyx_Locks_PyMutex __Pyx_Locks_PyThreadTypeLock
+#define __Pyx_Locks_PyMutex_DECL __Pyx_Locks_PyThreadTypeLock_DECL
+#endif
+#endif
+
+
+////////////////// PyMutex.proto ///////////////////////////
+//@requires: PyThreadTypeLock
+//@requires: PyMutexDecl
+
+#if PY_VERSION_HEX > 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API
 #define __Pyx_Locks_PyMutex_Init(l) (void)(l)
 #define __Pyx_Locks_PyMutex_Delete(l) (void)(l)
 // Py_Mutex takes care of all GIL handling itself
@@ -349,8 +373,6 @@ static void __Pyx__Locks_PyThreadTypeLock_Lock(__Pyx_Locks_PyThreadTypeLock lock
 
 #else
 
-#define __Pyx_Locks_PyMutex __Pyx_Locks_PyThreadTypeLock
-#define __Pyx_Locks_PyMutex_DECL __Pyx_Locks_PyThreadTypeLock_DECL
 #define __Pyx_Locks_PyMutex_Init(l) __Pyx_Locks_PyThreadTypeLock_Init(l)
 #define __Pyx_Locks_PyMutex_Delete(l) __Pyx_Locks_PyThreadTypeLock_Delete(l)
 #define __Pyx_Locks_PyMutex_Lock(l) __Pyx_Locks_PyThreadTypeLock_Lock(l)

{cython-3.2.0b2.dist-info → cython-3.2.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Cython
-Version: 3.2.0b2
+Version: 3.2.0b3
 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,61 +65,26 @@ to install an uncompiled (slower) version of Cython with::
 
 .. _Pyrex: https://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/
 
-3.2.0b2 (2025-10-27)
+3.2.0b3 (2025-10-30)
 ====================
 
-Features added
---------------
-
-* The code generated for importing and exporting cimports across modules uses less space.
-  (Github issues https://github.com/cython/cython/issues/7255, https://github.com/cython/cython/issues/7265)
-
 Bugs fixed
 ----------
 
-* Iteration over memoryviews could loop indefinitely in 3.2b1 when encountering a ``continue`` statement.
-  (Github issue https://github.com/cython/cython/issues/7259)
-
-* Extension arguments defined for the shared code module were ignored in ``cythonize()``.
-  (Github issue https://github.com/cython/cython/issues/7251)
-
-* Failures while following package attributes in ``import pkg.module as …`` were not handled.
-
-* Trying to instantiate internal types used by Cython is now prohibited.
-  (Github issue https://github.com/cython/cython/issues/7263)
-
-* Includes all fixes as of Cython 3.1.6.
-
-3.1.6 (2025-10-23):
-
-* Unicode characters formatted from C integers with ``f"{value:c}"`` could result in
-  invalid Python string objects since Cython 3.1.0.
-  (Github issue https://github.com/cython/cython/issues/7240)
-
-* ``cythonize`` (program and function) now uses ``concurrent.futures.ProcessPoolExecutor``
-  instead of ``multiprocessing.Pool`` to fix a hang on build failures in parallel builds.
-  A possible work-around is to disable parallel builds.
-  Patch by Sviatoslav Sydorenko.  (Github issue https://github.com/cython/cython/issues/7183)
-
-3.1.5 (2025-10-20):
-
-* Conversion from C++ strings longer than ``PY_SSIZE_T_MAX`` did not validate the length.
-
-* Some non-Limited API code was incorrectly used in generated header files.
-  (Github issue https://github.com/cython/cython/issues/7157)
-
-* Optimised unpacking of Python integers in expressions uses a slightly safer scheme.
-  (Github issue https://github.com/cython/cython/issues/7134)
-
-* Empty return statements were not always reported when tracing.
-  (Github issue https://github.com/cython/cython/issues/7022)
+* Using ``cython.pymutex`` in an extension type declared as ``public`` or ``api``
+  generated invalid C code missing the required ``PyMutex`` declarations.
+  (Github issues https://github.com/cython/cython/issues/6992, https://github.com/cython/cython/issues/6995)
 
-* 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)
+* 3.2.0b2 generated incorrect pointer casts in the ``cimport`` importing code.
+  (Github issue https://github.com/cython/cython/issues/7268)
 
-Other changes
--------------
+* 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 https://github.com/cython/cython/issues/7076)
 
-* The ``musllinux`` platform is now served with an abi3 Cython wheel instead of Python specific ones.
-  (Github issue https://github.com/cython/cython/issues/7250)
+* Cython incorrectly called ``PyList_GetItemRef()`` in PyPy and GraalPython before Py3.13.
+  (Github issue https://github.com/cython/cython/issues/7269)

{cython-3.2.0b2.dist-info → cython-3.2.0b3.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=2DkawWm1fcr8VXHqXVXrUhOHbsYgZbJ0ugAePyIQVLE,19634
+Cython/Shadow.py,sha256=7o4eOnli46IhpOxlw_9tcRhht4HDEpUBVAiCIX3mvvs,19634
 Cython/Shadow.pyi,sha256=BaaRtWtFlBVM14LOD9ql-9Uw1UDZV3AOT2AWULk1WUw,18597
 Cython/StringIOTree.py,sha256=8u4R5jhUzqYvSX1w5_RrvxbgUvaMqW8jhQgXcCNKIkE,5570
 Cython/TestUtils.py,sha256=rph07UD41dNbdOjqQx_vNu2c0b3Ib1UeMxNYao_vxJU,15584
@@ -34,13 +34,13 @@ Cython/Compiler/Buffer.py,sha256=NMqvFYIofuS93840lWrNcvDXlBhuXgKLoEuMs0PffLk,269
 Cython/Compiler/Builtin.py,sha256=KTq5PwVqPe9FwNNtOXrZI7dxArjbMuIB7vwg7wcQK08,42742
 Cython/Compiler/CmdLine.py,sha256=6u--_tFCXMEjDQaqYXbH4AXed5jXcOhBWGefngFB_Aw,13339
 Cython/Compiler/Code.pxd,sha256=-bYyHehjGEiFoe8bqT-2djaHann3jnU86gVgymoIpL0,3918
-Cython/Compiler/Code.py,sha256=qSiVcJY8I7TbKYhR3d5_OXWlTthkhqFu326_lRX-ekk,142972
+Cython/Compiler/Code.py,sha256=r4lz8H_p82zzt7Cl_u2foEM6Vm-QiyBoRvsVfMJUvr4,143778
 Cython/Compiler/CodeGeneration.py,sha256=aEW8IwXvwEOsde0-RxvAi_cb8_qdaDGxH_nS_VFwKWc,1068
-Cython/Compiler/CythonScope.py,sha256=xc--GL42F4k7o7lFRXLOnz0cr_9QuI1UmCLa0F4r5Us,7036
+Cython/Compiler/CythonScope.py,sha256=b_RU0YKr4UYzfrhAJE9xNdYAHi1H44hczsbBA9tiq6E,7325
 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=iAkBVD6B_3sse1h1l-3QoZ6Qy8EEj8BjIExszbQJYds,634684
+Cython/Compiler/ExprNodes.py,sha256=txX6Oy_YqVVxUd1SBNK6naaFhai6xP22xMlHCSjJkBY,634703
 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,9 +51,9 @@ 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=VnH9h_cUgaNSHDinzX_SiXcLp08Q9SV0tK8DDAA2URA,31688
-Cython/Compiler/ModuleNode.py,sha256=81K5amB3Fz-zr5PUeRtsOLJYyCxp35DusDnGVIZxKl0,193852
+Cython/Compiler/ModuleNode.py,sha256=7HAhU4H5VEeZxN42HGlq7dYRGA3faauucz3YsQmyULk,194712
 Cython/Compiler/Naming.py,sha256=xneFFCsB68xZhghXAxA2GnRrooWMumxss20B1I0avqk,11159
-Cython/Compiler/Nodes.py,sha256=B2mm_IEa6m0JpmiEt9O-3DoaDCJWbdL6D8-sVKd_zw8,455820
+Cython/Compiler/Nodes.py,sha256=Ef-QpICjbff3wb-LEzEfNA69fg4rOlAVSBgDLJYYL6E,455923
 Cython/Compiler/Optimize.py,sha256=0pI7dkwJirE2IrlSoLrbbuL9cq1pls5VDoex_5rYTmk,227816
 Cython/Compiler/Options.py,sha256=DegABgz_JQbPN_hHfOTxDd3zKHXvqoYedB9jgco4fnk,32062
 Cython/Compiler/ParseTreeTransforms.pxd,sha256=mkdSaFvc5we32bs0RNFwbODQMsTHIU0jIlpZuFtHnaU,2268
@@ -61,12 +61,12 @@ Cython/Compiler/ParseTreeTransforms.py,sha256=nL6TdknzbWsFTThUaMJeKcDakIYf7cDFk6
 Cython/Compiler/Parsing.pxd,sha256=A5Ckd1TecRLV_NDx4IzhquYdMsM0BGcDWh7LyXOjKIg,351
 Cython/Compiler/Parsing.py,sha256=RsV7WGd7OxK7tEthCOqF2m9z_hSbUn662d-m0z1MCws,156894
 Cython/Compiler/Pipeline.py,sha256=JyYMnRekoKRBe9yOvAuW39Gy-pTitJm5jD_qfO9BAeU,16230
-Cython/Compiler/PyrexTypes.py,sha256=ucSPkoB3DOmjY1gZeXMz46135kTy5pDYImWQnSM8Awc,222609
+Cython/Compiler/PyrexTypes.py,sha256=GlFXj-I2cewlrHzrrJpS6jyklKJADRJaWAS14Nv_PGA,222967
 Cython/Compiler/Pythran.py,sha256=wiRE1buAxQ0NFbxg7DHyyd03I6qgLp-KP_fokAvSii4,7888
 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=-oboJe3vOjp_Ejx95wwIktT1x8iRROKa2BQ0pCCPYkQ,137117
+Cython/Compiler/Symtab.py,sha256=sD_634XgzbtUnTixP6moly-iKCUveRMLMmjo8g_Nc1Y,137271
 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
@@ -272,7 +272,7 @@ Cython/Utility/BufferFormatFromTypeInfo.pxd,sha256=KoGGKw7rW8Utav9xrwVZpsLX-vlpF
 Cython/Utility/Builtins.c,sha256=udHKjWEYYG6CEKTeD6yxY03l2GVwLSa5svM6NKPrGg4,26719
 Cython/Utility/CConvert.pyx,sha256=UFlPDRT9anal0RpY03hXsejEcwp-RXJSnLy6LbbnmPQ,4471
 Cython/Utility/CMath.c,sha256=rP6O5u23EybDGimRCHfy8WTpyxhPu5G1F6ksEmrgKnQ,3044
-Cython/Utility/CommonStructures.c,sha256=RTjw1pGoTKy7BirWBdiFmNAtD7Jfq0ur_rh3396rQq4,7881
+Cython/Utility/CommonStructures.c,sha256=cXOrFQv0DP8QX2CF4u_2O2lFW41WC3nTNwSKRVt3B7M,7926
 Cython/Utility/Complex.c,sha256=nxxtxZk74ykGPoVhkHtYAnITLWLKYNHBSs8NEEmRf38,14033
 Cython/Utility/Coroutine.c,sha256=mnN1zdID44Jn-0qF5Bw17QA5gloWpO8JTjiF7ggzuF8,85395
 Cython/Utility/CpdefEnums.pyx,sha256=TMXyfhDeip3zqatMgNEQTQiss41nnp-PzFGn78tgBAs,3531
@@ -289,15 +289,15 @@ Cython/Utility/ImportExport.c,sha256=69eNLe8HRg8-595JL41wQO9i1su1F2EitC0Ghe5gh5c
 Cython/Utility/MemoryView.pxd,sha256=ch7F03IB3MFqr8OVwN2zjkiveTtzTYUoQ2gERxB1RPg,7184
 Cython/Utility/MemoryView.pyx,sha256=b_H0MFfFOLfBJUxD070EwnJLnZolLjPND96_IIDY-fg,49908
 Cython/Utility/MemoryView_C.c,sha256=g84prOl_eoXc5Dgs7ZiG1DCHQ5jgbJjI1li9-A8KtQ8,28077
-Cython/Utility/ModuleSetupCode.c,sha256=zPKNz8f_oWO4bEx9QW4hDHAiErpsUoc7qxscplDwMBA,116716
+Cython/Utility/ModuleSetupCode.c,sha256=yGvP7_cgJPWH5XNpjAolKgr_ETG4_DR90GoX9nYa3F0,118854
 Cython/Utility/NumpyImportArray.c,sha256=Gwo493DF8JxUxhTTjJYIdyHHJ9TEwFKqDmKsdk_uPyw,2033
-Cython/Utility/ObjectHandling.c,sha256=JDDJ3dmcuUd1Ig_28gqanpbBhz8FL1QrUDqVFqC7gXk,119369
-Cython/Utility/Optimize.c,sha256=cWbQhEfveBMRFupodbgxM0DcHpib2ktdSmKy7erTDmg,60009
+Cython/Utility/ObjectHandling.c,sha256=yKBjDrbzSf5t4kunHiWZHqmN2lDnZvlPq96TCD4vIkU,119365
+Cython/Utility/Optimize.c,sha256=ksJP3HuQl63FSOE351WQLPmCpMdp1tdiyL4dOJPjfwA,59685
 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=D_towCvmTpBfYYYNa01-v0bM0Wk4RyGi0lx32UmGnKM,18686
+Cython/Utility/Synchronization.c,sha256=QuS-59I9g0ftI_Sq5Khfcd4n4PJUJD86yFcJcxAeFk4,19273
 Cython/Utility/TString.c,sha256=UM3kg04oc0qq54ciFZd9X6Bk2acO1TqqZo89UtFvaoQ,13893
 Cython/Utility/TestCyUtilityLoader.pyx,sha256=91lWWJub7l_6xNn3ncrvQZZ94RpkQzEx2NtAaFpvrxY,152
 Cython/Utility/TestCythonScope.pyx,sha256=mWowHlHIs22w6xC5KAc8kelf2f2n6bhLapyqgz0JMpc,1999
@@ -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.0b2.dist-info/METADATA,sha256=t04HJ9-N1-UaovuzIUU6jaHvo26fSBmXxhNgVNV1Vw8,5558
-cython-3.2.0b2.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-cython-3.2.0b2.dist-info/entry_points.txt,sha256=VU8NX8gnQyFbyqiWMzfh9BHvYMuoQRS3Nbm3kKcKQeY,139
-cython-3.2.0b2.dist-info/top_level.txt,sha256=jLV8tZV98iCbIfiJR4DVzTX5Ru1Y_pYMZ59wkMCe6SY,24
-cython-3.2.0b2.dist-info/RECORD,,
+cython-3.2.0b3.dist-info/METADATA,sha256=Rwr2QJnN0l_RH-d0t4ykQsWg9zViW0ZHeFkpP3zJW48,4331
+cython-3.2.0b3.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+cython-3.2.0b3.dist-info/entry_points.txt,sha256=VU8NX8gnQyFbyqiWMzfh9BHvYMuoQRS3Nbm3kKcKQeY,139
+cython-3.2.0b3.dist-info/top_level.txt,sha256=jLV8tZV98iCbIfiJR4DVzTX5Ru1Y_pYMZ59wkMCe6SY,24
+cython-3.2.0b3.dist-info/RECORD,,