Cython 3.3.0a1__py3-none-any.whl → 3.3.0a2.dev0__py3-none-any.whl

Cython/Compiler/ModuleNode.py

@@ -2196,14 +2196,17 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
         if not entry or not entry.is_special:
             return
 
+        code.globalstate.use_utility_code(
+            UtilityCode.load_cached("DeallocKeepAlive", "ExtensionTypes.c"))
         code.putln("{")
         code.putln("PyObject *etype, *eval, *etb;")
         code.putln("__Pyx_PyErr_FetchException(&etype, &eval, &etb);")
-        # increase the refcount while we are calling into user code
-        # to prevent recursive deallocation
-        code.putln("Py_SET_REFCNT(o, Py_REFCNT(o) + 1);")
+        # Keep the object alive while we are calling into user code, to prevent
+        # the user code from triggering recursive deallocation.  On free-threading
+        # this must not use Py_SET_REFCNT() (see DeallocKeepAlive in ExtensionTypes.c).
+        code.putln("__Pyx_DeallocKeepAliveBegin(o);")
         code.putln("%s(o);" % entry.func_cname)
-        code.putln("Py_SET_REFCNT(o, Py_REFCNT(o) - 1);")
+        code.putln("__Pyx_DeallocKeepAliveEnd(o);")
         code.putln("__Pyx_PyErr_RestoreException(etype, eval, etb);")
         code.putln("}")
 

Cython/Includes/cpython/array.pxd

@@ -122,23 +122,23 @@ cdef inline array clone(array template, Py_ssize_t length, bint zero):
     if zero is true, new array will be initialized with zeroes."""
     cdef array op = newarrayobject(Py_TYPE(template), length, template.ob_descr)
     if zero and op is not None:
-        memset(op.data.as_chars, 0, length * op.ob_descr.itemsize)
+        memset(op.data.as_chars, 0, <size_t> length * <size_t> op.ob_descr.itemsize)
     return op
 
 cdef inline array copy(array self):
     """ make a copy of an array. """
     cdef array op = newarrayobject(Py_TYPE(self), Py_SIZE(self), self.ob_descr)
-    memcpy(op.data.as_chars, self.data.as_chars, Py_SIZE(op) * op.ob_descr.itemsize)
+    memcpy(op.data.as_chars, self.data.as_chars, <size_t> Py_SIZE(op) * <size_t> op.ob_descr.itemsize)
     return op
 
 cdef inline int extend_buffer(array self, char* stuff, Py_ssize_t n) except -1:
     """ efficient appending of new stuff of same type
     (e.g. of same array type)
     n: number of elements (not number of bytes!) """
-    cdef Py_ssize_t itemsize = self.ob_descr.itemsize
+    cdef size_t itemsize = <size_t> self.ob_descr.itemsize
     cdef Py_ssize_t origsize = Py_SIZE(self)
     resize_smart(self, origsize + n)
-    memcpy(self.data.as_chars + origsize * itemsize, stuff, n * itemsize)
+    memcpy(self.data.as_chars + <size_t> origsize * itemsize, stuff, <size_t> n * itemsize)
     return 0
 
 cdef inline int extend(array self, array other) except -1:
@@ -149,4 +149,4 @@ cdef inline int extend(array self, array other) except -1:
 
 cdef inline void zero(array self) noexcept:
     """ set all elements of array to zero. """
-    memset(self.data.as_chars, 0, Py_SIZE(self) * self.ob_descr.itemsize)
+    memset(self.data.as_chars, 0, <size_t> Py_SIZE(self) * <size_t> self.ob_descr.itemsize)

Cython/Shadow.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 # Possible version formats: "3.1.0", "3.1.0a1", "3.1.0a1.dev0"
-__version__ = "3.3.0a1"
+__version__ = "3.3.0a2.dev0"
 
 from types import TracebackType
 from typing import (

Cython/Utility/AsyncGen.c

@@ -45,12 +45,13 @@ if (likely(__pyx_AsyncGen_init($module_cname) == 0)); else
 //@requires: Coroutine.c::Coroutine
 
 #define __Pyx_AsyncGen_USED
+
 typedef struct {
     __pyx_CoroutineObject coro;
     PyObject *ag_finalizer;
-    int ag_hooks_inited;
-    int ag_closed;
-    int ag_running_async;
+    char ag_hooks_inited;
+    char ag_closed;
+    char ag_running_async;
 } __pyx_PyAsyncGenObject;
 
 #define __Pyx_AsyncGen_CheckExact(obj) Py_IS_TYPE(obj, CGLOBAL(__pyx_AsyncGenType))
@@ -352,8 +353,6 @@ static PyGetSetDef __Pyx_async_gen_getsetlist[] = {
      PyDoc_STR("name of the async generator"), 0},
     {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname,
      PyDoc_STR("qualified name of the async generator"), 0},
-    //REMOVED: {(char*) "ag_await", (getter)coro_get_cr_await, NULL,
-    //REMOVED:  (char*) PyDoc_STR("object being awaited on, or None")},
     {0, 0, 0, 0, 0} /* Sentinel */
 };
 
@@ -361,7 +360,6 @@ static PyMemberDef __Pyx_async_gen_memberlist[] = {
     //REMOVED: {(char*) "ag_frame",   T_OBJECT, offsetof(__pyx_PyAsyncGenObject, ag_frame),   READONLY},
     {"ag_running", T_BOOL,   offsetof(__pyx_PyAsyncGenObject, ag_running_async), READONLY, NULL},
     //REMOVED: {(char*) "ag_code",    T_OBJECT, offsetof(__pyx_PyAsyncGenObject, ag_code),    READONLY},
-    //ADDED: "ag_await"
     {"ag_await", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY,
      PyDoc_STR("object being awaited on, or None")},
     {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0},

Cython/Utility/Coroutine.c

@@ -1676,6 +1676,10 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit(
     Py_XINCREF(code);
     gen->gi_code = code;
     gen->gi_frame = NULL;
+#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE)
+    memset(gen->$monitoring_states_cname, 0, sizeof(gen->$monitoring_states_cname));
+    gen->$monitoring_version_cname = 0;
+#endif
 
     PyObject_GC_Track(gen);
     return gen;

Cython/Utility/CythonFunction.c

@@ -254,6 +254,7 @@ static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject
 //@requires: Exceptions.c::IgnoreException
 //@requires: ModuleSetupCode.c::IncludeStructmemberH
 //@requires: ObjectHandling.c::PyObjectGetAttrStr
+//@requires: ObjectHandling.c::PyObjectCallOneArg
 //@requires: ExtensionTypes.c::CallTypeTraverse
 //@requires: Synchronization.c::CriticalSections
 //@substitute: naming
@@ -547,6 +548,8 @@ __Pyx_CyFunction_get_kwdefaults(PyObject *op, void *context) {
     return result;
 }
 
+static int __Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value); /*proto*/
+
 static int
 __Pyx_CyFunction_set_annotations(PyObject *op_in, PyObject* value, void *context) {
     CYTHON_UNUSED_VAR(context);
@@ -562,9 +565,59 @@ __Pyx_CyFunction_set_annotations(PyObject *op_in, PyObject* value, void *context
     __Pyx_BEGIN_CRITICAL_SECTION(op_in);
     __Pyx_Py_XDECREF_SET(op->func_annotations, value);
     __Pyx_END_CRITICAL_SECTION();
+    if (unlikely(__Pyx_CyFunction_set_annotate_in_dict_if_exists(op_in, Py_None) < 0)) return -1;
     return 0;
 }
 
+static int
+__Pyx_CyFunction_get_dict_if_exists(PyObject *op_in, PyObject **dict) {
+    /* Return 1 if the function dict exists, 0 otherwise.  This cannot fail:
+     * _PyObject_GetDictPtr() may clear errors internally, but never reports them. */
+#if CYTHON_COMPILING_IN_PYPY
+    *dict = PyObject_GenericGetDict(op_in, NULL);
+#elif CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030C0000
+    *dict = __Pyx_as_CyFunctionObject(op_in)->func_dict;
+#else
+    PyObject **dictptr = _PyObject_GetDictPtr(op_in);
+    *dict = likely(dictptr) ? *dictptr : NULL;
+#endif
+    return *dict ? 1 : 0;
+}
+
+static int
+__Pyx_CyFunction_get_annotate_from_dict_if_exists(PyObject *op_in, PyObject **annotate) {
+    PyObject *dict;
+    int dict_found;
+    *annotate = NULL;
+    dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict);
+    if (!dict_found) return 0;
+    return __Pyx_PyDict_GetItemRef(dict, PYIDENT("__annotate__"), annotate);
+}
+
+static int
+__Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value) {
+    PyObject *dict;
+    int dict_found;
+    dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict);
+    if (!dict_found) return 0;
+    return PyDict_SetItem(dict, PYIDENT("__annotate__"), value);
+}
+
+static int
+__Pyx_CyFunction_set_annotate_in_dict(PyObject *op_in, PyObject *value) {
+    PyObject *dict;
+    int result;
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
+    dict = __Pyx_CyFunction_get_dict(__Pyx_as_CyFunctionObject(op_in), NULL);
+#else
+    dict = PyObject_GenericGetDict(op_in, NULL);
+#endif
+    if (unlikely(!dict)) return -1;
+    result = PyDict_SetItem(dict, PYIDENT("__annotate__"), value);
+    Py_DECREF(dict);
+    return result;
+}
+
 static PyObject *
 __Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) {
     PyObject* result = op->func_annotations;
@@ -579,16 +632,43 @@ __Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) {
 
 static PyObject *
 __Pyx_CyFunction_get_annotations(PyObject *op_in, void *context) {
-    PyObject *result;
+    PyObject *annotate = NULL;
+    PyObject *result = NULL;
     __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in);
     CYTHON_UNUSED_VAR(context);
     __Pyx_BEGIN_CRITICAL_SECTION(op_in);
-    result = __Pyx_CyFunction_get_annotations_locked(op);
+    result = __Pyx_XNewRef(op->func_annotations);
+    __Pyx_END_CRITICAL_SECTION();
+    if (result) return result;
+
+    if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL;
+    if (!annotate || annotate == Py_None) {
+        Py_XDECREF(annotate);
+        __Pyx_BEGIN_CRITICAL_SECTION(op_in);
+        result = __Pyx_CyFunction_get_annotations_locked(op);
+        __Pyx_END_CRITICAL_SECTION();
+        return result;
+    }
+
+    PyObject *format = PyLong_FromLong(1L);  // annotationlib.Format.VALUE
+    if (likely(format)) {
+        result = __Pyx_PyObject_CallOneArg(annotate, format);
+        Py_DECREF(format);
+    }
+    Py_DECREF(annotate);
+    if (unlikely(!result)) return NULL;
+    if (unlikely(!PyDict_Check(result))) {
+        PyErr_SetString(PyExc_TypeError, "__annotate__ must return a dict");
+        Py_DECREF(result);
+        return NULL;
+    }
+    __Pyx_BEGIN_CRITICAL_SECTION(op_in);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, __Pyx_NewRef(result));
     __Pyx_END_CRITICAL_SECTION();
     return result;
 }
 
-static PyObject *__Pyx_CyFunction_annotate_impl(PyObject *self, 
+static PyObject *__Pyx_CyFunction_annotate_impl(PyObject *self,
 #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
     PyObject *args
 #else
@@ -622,11 +702,13 @@ static PyMethodDef __Pyx_CyFunction_annotate_method = {
 
 // We don't yet support PEP649 properly, so __annotate__ is
 // implemented in a minimal way, just so that functools.wraps works.
-// Essentially the effect of doing func.__annotate__ = other.__annotate__
-// is to copy the annotations dictionary.
 static PyObject *
 __Pyx_CyFunction_get_annotate(PyObject *op_in, void *context) {
+    PyObject *annotate = NULL;
     CYTHON_UNUSED_VAR(context);
+    if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL;
+    if (annotate) return annotate;
+
     PyObject *annotations = __Pyx_CyFunction_get_annotations(op_in, NULL);
     if (unlikely(!annotations)) return NULL;
     PyObject *method = PyCFunction_New(
@@ -643,15 +725,17 @@ __Pyx_CyFunction_set_annotate(PyObject *op_in, PyObject* value, void *context) {
         PyErr_SetString(PyExc_TypeError, "__annotate__ cannot be deleted");
         return -1;
     }
-    if (value == Py_None) {
-        // PEP 649 says "Setting o.__annotate__ to None has no effect on the cached annotations dict."
-        return 0;
+    if (unlikely(value != Py_None && !PyCallable_Check(value))) {
+        PyErr_SetString(PyExc_TypeError, "__annotate__ must be callable or None");
+        return -1;
     }
-    PyObject *annotations = PyObject_CallObject(value, NULL);
-    if (!annotations) return -1;
-    int result = __Pyx_CyFunction_set_annotations(op_in, annotations, NULL);
-    Py_DECREF(annotations);
-    return result;
+    if (value != Py_None) {
+        __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in);
+        __Pyx_BEGIN_CRITICAL_SECTION(op_in);
+        Py_CLEAR(op->func_annotations);
+        __Pyx_END_CRITICAL_SECTION();
+    }
+    return __Pyx_CyFunction_set_annotate_in_dict(op_in, value);
 }
 
 #if __PYX_LIMITED_VERSION_HEX < 0x030B0000

Cython/Utility/ExtensionTypes.c

@@ -295,6 +295,34 @@ static int __Pyx_PyType_Ready(PyTypeObject *t) {
 #define __Pyx_TRASHCAN_END
 #endif
 
+/////////////// DeallocKeepAlive.proto ///////////////
+
+// Keep `o` alive across a call into user __dealloc__ code, to prevent the user
+// code from triggering recursive deallocation, then drop the temporary reference.
+//
+// On the GIL build this is a plain refcount bump.  On free-threading we must NOT
+// use Py_SET_REFCNT(o, 1): the object reaching tp_dealloc is unowned and merged
+// (ob_ref_shared == _Py_REF_MERGED), so Py_SET_REFCNT takes the unowned branch and
+// writes ob_ref_shared = _Py_REF_SHARED(1, _Py_REF_MERGED), i.e. "merged, shared
+// count 1" -- indistinguishable from a live object.  A concurrent
+// PyUnstable_TryIncRef() would then succeed and resurrect the dying object
+// (use-after-free).  Instead we mirror CPython's _PyObject_ResurrectStart/End:
+// re-take ownership and keep the *shared* refcount at the refuse sentinel (0), so
+// the bump is invisible to other threads and TryIncRef keeps refusing.
+
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+#define __Pyx_DeallocKeepAliveBegin(o) do {                                  \
+        _Py_atomic_store_uintptr_relaxed(&(o)->ob_tid, _Py_ThreadId());      \
+        _Py_atomic_store_uint32_relaxed(&(o)->ob_ref_local, 1);              \
+        _Py_atomic_store_ssize_relaxed(&(o)->ob_ref_shared, 0);             \
+    } while (0)
+#define __Pyx_DeallocKeepAliveEnd(o) \
+        _Py_atomic_store_uint32_relaxed(&(o)->ob_ref_local, 0)
+#else
+#define __Pyx_DeallocKeepAliveBegin(o) Py_SET_REFCNT(o, Py_REFCNT(o) + 1)
+#define __Pyx_DeallocKeepAliveEnd(o)   Py_SET_REFCNT(o, Py_REFCNT(o) - 1)
+#endif
+
 /////////////// CallNextTpDealloc.proto ///////////////
 
 static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc);

Cython/Utility/arrayarray.h

@@ -81,9 +81,9 @@ static CYTHON_INLINE PyObject * newarrayobject(PyTypeObject *type, Py_ssize_t si
         return NULL;
     }
 
-    nbytes = size * descr->itemsize;
+    nbytes = (size_t) size * (size_t) descr->itemsize;
     // Check for overflow
-    if (nbytes / descr->itemsize != (size_t)size) {
+    if (nbytes / (size_t) descr->itemsize != (size_t) size) {
         return PyErr_NoMemory();
     }
     op = (arrayobject *) type->tp_alloc(type, 0);
@@ -128,7 +128,7 @@ static CYTHON_INLINE int resize(arrayobject *self, Py_ssize_t n) {
     return GraalPyArray_Resize((PyObject*)self, n);
 #else
     void *items = (void*) self->data.ob_item;
-    PyMem_Resize(items, char, (size_t)(n * self->ob_descr->itemsize));
+    PyMem_Resize(items, char, (size_t) n * (size_t) self->ob_descr->itemsize);
     if (items == NULL) {
         PyErr_NoMemory();
         return -1;
@@ -146,25 +146,27 @@ static CYTHON_INLINE int resize_smart(arrayobject *self, Py_ssize_t n) {
     return GraalPyArray_Resize((PyObject*)self, n);
 #else
     void *items = (void*) self->data.ob_item;
-    Py_ssize_t newsize;
-    if (n < self->allocated && n*4 > self->allocated) {
+    size_t newsize, requested_size = (size_t) n;
+    if (requested_size < (size_t) self->allocated && requested_size > (size_t) self->allocated / 4) {
         Py_SET_SIZE(self, n);
         return 0;
     }
-    newsize = n + (n / 2) + 1;
-    if (newsize <= n) {   /* overflow */
-        PyErr_NoMemory();
-        return -1;
-    }
-    PyMem_Resize(items, char, (size_t)(newsize * self->ob_descr->itemsize));
-    if (items == NULL) {
-        PyErr_NoMemory();
-        return -1;
-    }
+    newsize = requested_size + (requested_size / 2) + 1U;
+    /* check for overflow */
+    if (newsize <= requested_size || newsize >= (size_t) PY_SSIZE_T_MAX / (size_t) self->ob_descr->itemsize)
+        goto no_memory;
+
+    PyMem_Resize(items, char, newsize * (size_t) self->ob_descr->itemsize);
+    if (items == NULL)
+        goto no_memory;
     self->data.ob_item = (char*) items;
     Py_SET_SIZE(self, n);
-    self->allocated = newsize;
+    self->allocated = (Py_ssize_t) newsize;
     return 0;
+
+no_memory:
+    PyErr_NoMemory();
+    return -1;
 #endif
 }
 

cython-3.3.0a2.dev0.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: Cython
+Version: 3.3.0a2.dev0
+Summary: The Cython compiler for writing C extensions in the Python language.
+Home-page: https://cython.org/
+Author: Robert Bradshaw, Stefan Behnel, David Woods, Greg Ewing, et al.
+Author-email: cython-devel@python.org
+License: Apache-2.0
+Project-URL: Documentation, https://cython.readthedocs.io/
+Project-URL: Donate, https://cython.readthedocs.io/en/latest/src/donating.html
+Project-URL: Source Code, https://github.com/cython/cython
+Project-URL: Bug Tracker, https://github.com/cython/cython/issues/
+Project-URL: User Group, https://groups.google.com/g/cython-users
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: C
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Cython
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+The Cython language makes writing C extensions for the Python language as
+easy as Python itself.  Cython is a source code translator based on Pyrex_,
+but supports more cutting edge functionality and optimizations.
+
+The Cython language is a superset of the Python language (almost all Python
+code is also valid Cython code), but Cython additionally supports optional
+static typing to natively call C functions, operate with C++ classes and
+declare fast C types on variables and class attributes.  This allows the
+compiler to generate very efficient C code from Cython code.
+
+This makes Cython the ideal language for writing glue code for external
+C/C++ libraries, and for fast C modules that speed up the execution of
+Python code.
+
+The newest Cython release can always be downloaded from https://cython.org/.
+Unpack the tarball or zip file, enter the directory, and then run::
+
+    pip install .
+
+Note that for one-time builds, e.g. for CI/testing, on platforms that are not
+covered by one of the wheel packages provided on PyPI *and* the pure Python wheel
+that we provide is not used, it is substantially faster than a full source build
+to install an uncompiled (slower) version of Cython with::
+
+    NO_CYTHON_COMPILE=true pip install .
+
+.. _Pyrex: https://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/
+

{cython-3.3.0a1.dist-info → cython-3.3.0a2.dev0.dist-info}/RECORD

@@ -3,7 +3,7 @@ Cython/CodeWriter.py,sha256=k1SAPvsjXum7dhX9IjZ3wXuDUOzzFKYEbNZSxMKEwos,24276
 Cython/Coverage.py,sha256=WGY5BW1nBcJ86f4Lrs6ZZIuFKCdngsEizs4Kor0iRsc,18783
 Cython/Debugging.py,sha256=vFtJhn7QstMf5gnYru2qHIz5ZjPg1KSlZVGHr-pBCwM,552
 Cython/LZSS.py,sha256=wypD6hSDweKe_e-ScebyzhpYb_9E9oCP2LrfxKeTbcU,5640
-Cython/Shadow.py,sha256=39eKn3UgvUU18_a_19WTGqdauOKCsBZF5EcoMdB55_w,38923
+Cython/Shadow.py,sha256=ThtZ7bofR6F9DTQo4b2WSIuPJZ_BYBPSCZ0gkT5CS8g,38928
 Cython/StringIOTree.py,sha256=xg-sJreuZwfvxEZyyHpL1spF_z3aWM4nRzV_JBSlq4c,5510
 Cython/TestUtils.py,sha256=eqUSiFBTWr2V4bT10Z0xCzknW--oOMPxE1T3AA4hxvg,16659
 Cython/Utils.py,sha256=zG-43h0OuWH3IHydvsc8Tfky8kqybx9S4Y8_tlbq8jk,20775
@@ -50,7 +50,7 @@ Cython/Compiler/LineTable.py,sha256=epP6DoefUR7JCK9OUOyoYcxMWhBEwyTWOr3E7vJRqa4,
 Cython/Compiler/Main.py,sha256=0jzmtq3Xd0HzyiUDxYnhsakqF2RMwAce2tSZN1XfK1c,34995
 Cython/Compiler/MatchCaseNodes.py,sha256=4yxMzyP7WNk-S95A0Eca0OtCKXBJ22fHwUp0c86I5ws,85602
 Cython/Compiler/MemoryView.py,sha256=C5FLzTauQZF47MQq6Zml5etoSequLTGgeQ7QS6qcxHs,32778
-Cython/Compiler/ModuleNode.py,sha256=gfgN4BzPmb0r6_NY7_QeUod4Uth9uH60eFRs_CDUR60,208259
+Cython/Compiler/ModuleNode.py,sha256=Ikih3OJQRWp_YIBxR12aC1iHF2wChp-7d5nbgD4qPrY,208508
 Cython/Compiler/Naming.py,sha256=I-y_gaQZMpfCOwPS3ohBCanEEScSZoySkAdrT7tn6Zg,11351
 Cython/Compiler/Nodes.py,sha256=PCRPaIEchrg49vXhE3E-0PHsHQbdOXQ7jWm4mlaktvQ,461570
 Cython/Compiler/Optimize.py,sha256=_h4wbm6zEiS-V9rrOQxTPu5ndZNcwZ3oqhE7sD_1es8,235010
@@ -112,7 +112,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=k2Cto07JWlxV6KuFuA6eXkjCOvEr-EQ8ZlLp5eg0wXM,5645
+Cython/Includes/cpython/array.pxd,sha256=68uPLBvGTiKfQGJc5riQxBApYo6_USR_aceNqOitOHg,5722
 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
@@ -267,7 +267,7 @@ Cython/Tests/TestStringIOTree.py,sha256=VJ6xbi7obugZlJ63qImRaeG0FerSs9JbBA0Kxocb
 Cython/Tests/TestTestUtils.py,sha256=BOaRzxyQ_OIpSs_LVk_kOc1qw_HmPwck84MFvKwCayk,2888
 Cython/Tests/__init__.py,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
 Cython/Tests/xmlrunner.py,sha256=1X79TBIYWOcZIzoylOSu9zULxVIR4xvq-RZ7f8Fn600,14612
-Cython/Utility/AsyncGen.c,sha256=1eA6owNsgNLFzYq_zq-fpIuEX3BAb4UWm7GeVYJZH6g,34572
+Cython/Utility/AsyncGen.c,sha256=w32B8SE7acqXdvQzoO5POhCZX7s_O51Q-sXXxjzOBuw,34411
 Cython/Utility/Buffer.c,sha256=MbklacjSbPHkfrf15-ZqqHeaX8BD6-lESqwpd__KaI0,28311
 Cython/Utility/BufferFormatFromTypeInfo.pxd,sha256=KoGGKw7rW8Utav9xrwVZpsLX-vlpFe3Xv0hmp45PimM,97
 Cython/Utility/Builtins.c,sha256=FcrsUxHWXEpEkwNxSPd0kJWZNi_bn8tskmWSMDjewSA,31640
@@ -275,15 +275,15 @@ Cython/Utility/CConvert.pyx,sha256=8hQnAPExrkh4HnJcMcR1VZ1ZTJeVreQRSb1lpDpJ3Q4,4
 Cython/Utility/CMath.c,sha256=rP6O5u23EybDGimRCHfy8WTpyxhPu5G1F6ksEmrgKnQ,3044
 Cython/Utility/CommonStructures.c,sha256=HOibirnL5WyYbPUthb269QTu9MYuoTt-EMsBhFRFkY4,8626
 Cython/Utility/Complex.c,sha256=nxxtxZk74ykGPoVhkHtYAnITLWLKYNHBSs8NEEmRf38,14033
-Cython/Utility/Coroutine.c,sha256=Bol7nl-GW3-zdANGP-I6kWtGiz7q4Mj5NdjWxHnTRiQ,85739
+Cython/Utility/Coroutine.c,sha256=DTCsBwK_HAeq9ekv3tkbSc2FI6hppyDXjww0wTU9eyE,85937
 Cython/Utility/CpdefEnums.pyx,sha256=Lnsx0BqA_rxwxP4RZlMupMp4WGUF7QUC1K-hFvUsL0o,3737
 Cython/Utility/CppConvert.pyx,sha256=onbI09dQzC6ZJxvzosS-WuvweIeh3f0rd65Xor7G3AU,7317
 Cython/Utility/CppSupport.cpp,sha256=vR1G8qqdyLWTk4quKz5v6Z1syIMrfPldB9IzbwkYxDo,5464
-Cython/Utility/CythonFunction.c,sha256=S73suIAY-4LkFZFVHVRGG-pFBl7pItCK8haJbfblOTo,71478
+Cython/Utility/CythonFunction.c,sha256=njyIqHAOvHL9Y1aN2rZjHWUKLDosJfjk7G9pNJCysek,74595
 Cython/Utility/Dataclasses.c,sha256=eCa9JHHg6bj-WSKw1xTDjazghmXAkMd9J5TnELNTVOI,4023
 Cython/Utility/Embed.c,sha256=lGOiz05yR0nQ574hqIkDHd3S-imJiVDAApH3maaH0dg,3846
 Cython/Utility/Exceptions.c,sha256=NWAgRgl272Dt3Z--PEyJ9WPC51D-UaAlSsbmjblwpog,36603
-Cython/Utility/ExtensionTypes.c,sha256=7606vyIHasXw-WDRGjg43vXBOjWPL9CVQhXO-r7TNRM,42431
+Cython/Utility/ExtensionTypes.c,sha256=RE3ON_wNZ-JDwWnMMoyo5O9-t5A3KO49fmwuWvt-g4Q,44002
 Cython/Utility/FunctionArguments.c,sha256=2fICNrvzp5o3nlkzgQtBSGvc1XdG_0xJ6-0PBtDg4zU,34343
 Cython/Utility/FusedFunction.pyx,sha256=3reL7n6L2M3gU_OXSYAvoDEVVjJxMWvpiesvGmRAEc8,1494
 Cython/Utility/ImportExport.c,sha256=XTVcbigdw8PgCWAXcxunD6OBrWKCmorhacafnokjPOY,30989
@@ -308,12 +308,12 @@ Cython/Utility/TypeConversion.c,sha256=AECBQhxO5-xMhkkn9EcgcK69zsGROT5EYGmQVN-2B
 Cython/Utility/UFuncs.pyx,sha256=ZcCCNCMMfrtqsSCwN31jJ4CVOiveDyseDcpJPgAdhPk,2026
 Cython/Utility/UFuncs_C.c,sha256=yf9apP9NQlDlBrljn6YXYpNrwb5ILjxUt96Wzz2a6LM,3203
 Cython/Utility/__init__.py,sha256=QBJ9uZ80GHBZG-TJevWaVWgx6HobLwQkZzWog9U9rb0,1158
-Cython/Utility/arrayarray.h,sha256=e0VVJX6uW7sdAvk5wd-Ru0SCy8Ypixp9QM60XG_78-w,4737
+Cython/Utility/arrayarray.h,sha256=j2IS9arZo9AGDqZbwhfkuy0cpGRxtjddZirDrVwQ2Y4,4974
 pyximport/__init__.py,sha256=9hOyKolFtOerPiVEyktKrT1VtzbGexq9UmORzo52iHI,79
 pyximport/pyxbuild.py,sha256=AsL1tyLxG61Mj7Ah-DxtDBuaXF94W2Tb6KTos7r0w8I,5702
 pyximport/pyximport.py,sha256=BnXVwq1cwo1EYRjPU0J-RUDcwzGjUlzKWZOOMDNcu-s,18510
-cython-3.3.0a1.dist-info/METADATA,sha256=Xl1AV_Tb4rz7CRdqwVPktHkvbzI5xKrnf4zR9yF1-sk,19678
-cython-3.3.0a1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-cython-3.3.0a1.dist-info/entry_points.txt,sha256=VU8NX8gnQyFbyqiWMzfh9BHvYMuoQRS3Nbm3kKcKQeY,139
-cython-3.3.0a1.dist-info/top_level.txt,sha256=jLV8tZV98iCbIfiJR4DVzTX5Ru1Y_pYMZ59wkMCe6SY,24
-cython-3.3.0a1.dist-info/RECORD,,
+cython-3.3.0a2.dev0.dist-info/METADATA,sha256=1L8LkVjr6Rq511bArf5UGiVofO8ZUU3ITYs2NTN9YFI,3219
+cython-3.3.0a2.dev0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cython-3.3.0a2.dev0.dist-info/entry_points.txt,sha256=VU8NX8gnQyFbyqiWMzfh9BHvYMuoQRS3Nbm3kKcKQeY,139
+cython-3.3.0a2.dev0.dist-info/top_level.txt,sha256=jLV8tZV98iCbIfiJR4DVzTX5Ru1Y_pYMZ59wkMCe6SY,24
+cython-3.3.0a2.dev0.dist-info/RECORD,,

cython-3.3.0a1.dist-info/METADATA

@@ -1,394 +0,0 @@
-Metadata-Version: 2.4
-Name: Cython
-Version: 3.3.0a1
-Summary: The Cython compiler for writing C extensions in the Python language.
-Home-page: https://cython.org/
-Author: Robert Bradshaw, Stefan Behnel, David Woods, Greg Ewing, et al.
-Author-email: cython-devel@python.org
-License: Apache-2.0
-Project-URL: Documentation, https://cython.readthedocs.io/
-Project-URL: Donate, https://cython.readthedocs.io/en/latest/src/donating.html
-Project-URL: Source Code, https://github.com/cython/cython
-Project-URL: Bug Tracker, https://github.com/cython/cython/issues/
-Project-URL: User Group, https://groups.google.com/g/cython-users
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Programming Language :: C
-Classifier: Programming Language :: C++
-Classifier: Programming Language :: Cython
-Classifier: Topic :: Software Development :: Code Generators
-Classifier: Topic :: Software Development :: Compilers
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Typing :: Typed
-Requires-Python: >=3.9
-Description-Content-Type: text/x-rst
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: project-url
-Dynamic: requires-python
-Dynamic: summary
-
-The Cython language makes writing C extensions for the Python language as
-easy as Python itself.  Cython is a source code translator based on Pyrex_,
-but supports more cutting edge functionality and optimizations.
-
-The Cython language is a superset of the Python language (almost all Python
-code is also valid Cython code), but Cython additionally supports optional
-static typing to natively call C functions, operate with C++ classes and
-declare fast C types on variables and class attributes.  This allows the
-compiler to generate very efficient C code from Cython code.
-
-This makes Cython the ideal language for writing glue code for external
-C/C++ libraries, and for fast C modules that speed up the execution of
-Python code.
-
-The newest Cython release can always be downloaded from https://cython.org/.
-Unpack the tarball or zip file, enter the directory, and then run::
-
-    pip install .
-
-Note that for one-time builds, e.g. for CI/testing, on platforms that are not
-covered by one of the wheel packages provided on PyPI *and* the pure Python wheel
-that we provide is not used, it is substantially faster than a full source build
-to install an uncompiled (slower) version of Cython with::
-
-    NO_CYTHON_COMPILE=true pip install .
-
-.. _Pyrex: https://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/
-
-3.3.0a1 (2026-06-24)
-====================
-
-Features added
---------------
-
-* Changes were made to adapt to Python 3.15 and its Limited API.
-  (Github issues https://github.com/cython/cython/issues/6405, https://github.com/cython/cython/issues/7190, https://github.com/cython/cython/issues/7347, https://github.com/cython/cython/issues/7348, https://github.com/cython/cython/issues/7358)
-
-* PEP-634 Pattern Matching is implemented.
-  (Github issue https://github.com/cython/cython/issues/4029)
-
-* Declared container item types (e.g. ``list[float]``) are now used by the type system.
-  (Github issue https://github.com/cython/cython/issues/7288)
-
-* Type inference was improved for builtin Python types.
-  (Github issues https://github.com/cython/cython/issues/7536, https://github.com/cython/cython/issues/7644)
-
-* Extension types can declare themselves explicitly as sequence or mapping with
-  ``@cython.collection_type("sequence")`` or ``@cython.collection_type("mapping")``.
-  This has an effect on their behaviour in pattern matching and subscripting.
-  (Github issue https://github.com/cython/cython/issues/5027)
-
-* Sequence types that have their ``Py_TPFLAGS_SEQUENCE`` type flag set can benefit from
-  faster subscripting via the sequence protocol as Cython now bypasses the mapping protocol
-  for them if both protocols are implemented.
-  (Github issue https://github.com/cython/cython/issues/7432)
-
-* Sequence types marked as ``@cython.collection_type("sequence")`` that use C integers
-  in the subscript special methods now implement only the sequence and not the mapping protocol.
-  This allows subscripting code to avoid creating Python index objects when the index
-  is already available as C integer.
-  (Github issue https://github.com/cython/cython/issues/7435)
-
-* The Py3.15 ``frozendict`` builtin type is supported and has been backported as an alias
-  for ``dict`` in older Python versions.
-  Patches to adapt existing ``dict`` optimisations were contributed by Omkar Kabde.
-  (Github issues https://github.com/cython/cython/issues/7545, https://github.com/cython/cython/issues/7647)
-
-* The Py3.15 ``sentinel`` builtin is supported and its C-API declarations are available in
-  ``cpython.sentinel``.
-
-* The builtin Python types ``int``, ``float``, ``str``, ``bytes`` and ``bytearray``
-  are special cased in comparisons to speed them up.
-  (Github issues https://github.com/cython/cython/issues/7452, https://github.com/cython/cython/issues/7474)
-
-* The builtin Python types ``int`` and ``float`` are special cased in ``+``, ``-`` and ``*``
-  operations with (compile-time) unknown Python types in order to speed them up.
-  The bit operations ``^``, ``|`` and ``&`` are additionally special cased for ``int``.
-  (Github issues https://github.com/cython/cython/issues/7485, https://github.com/cython/cython/issues/7541)
-
-* ``<bool>`` casts can be used to convert C values to Python ``True`` / ``False``.
-  (Github issue https://github.com/cython/cython/issues/7513)
-
-* ``cdef`` property methods support setters.
-  (Github issue https://github.com/cython/cython/issues/7505)
-
-* The C ``restrict`` modifier can be used in declarations.
-  (Github issue https://github.com/cython/cython/issues/7617)
-
-* C arrays may now be declared with (``extern`` or internal) enum values as their size.
-  (Github issues https://github.com/cython/cython/issues/7401, https://github.com/cython/cython/issues/7406)
-
-* ``prange(num_threads=0)`` automatically selects the maximum number of OpenMP threads.
-  (Github issue https://github.com/cython/cython/issues/7586)
-
-* ``prange()`` and ``parallel()`` sections can be used without releasing the GIL, which
-  helps in freethreading builds.  When releasing the GIL as part of the section declaration,
-  re-acquiring it immediately inside is now faster, e.g. to do per-thread Python initialisations.
-  (Github issue https://github.com/cython/cython/issues/6562)
-
-* ``cython.pymutex`` and ``cython.pythread_type_lock`` now support a ``.locked()`` method
-  to check if the lock is currently held without blocking. The method works on all Python
-  versions using atomic reads on Python 3.13+ and a try-acquire approach on older versions.
-  (Github issue https://github.com/cython/cython/issues/7275)
-
-* A simpler mechanism was added for implementing C++ exception handlers in Cython code.
-  (Github issues https://github.com/cython/cython/issues/7388, https://github.com/cython/cython/issues/7390)
-
-* Repeated memoryview slicing inside of loops now avoids redundant reference counting,
-  making it substantially faster.
-  (Github issue https://github.com/cython/cython/issues/5507)
-
-* Indexing into Cython memoryview objects from Python is faster.
-  (Github issue https://github.com/cython/cython/issues/7529)
-
-* Some internal call overhead in the memoryview code was removed.
-  (Github issue https://github.com/cython/cython/issues/7609)
-
-* Extension types use the vectorcall interface for their instantiation in many cases.
-  This can be configured with a new C feature macro ``CYTHON_VECTORCALL_TPNEW``.
-  (Github issue https://github.com/cython/cython/issues/7698)
-
-* Coroutine methods use the faster vectorcall interface.
-  (Github issue https://github.com/cython/cython/issues/7678)
-
-* Vectorcalls with literal keyword arguments use cached constant keyword name tuples.
-  (Github issue https://github.com/cython/cython/issues/7713)
-
-* List comprehensions that generate new objects avoid refcounting overhead for appending.
-  (Github issue https://github.com/cython/cython/issues/7748)
-
-* Method calls in older Limited API versions are slightly faster.
-  (Github issue https://github.com/cython/cython/issues/7707)
-
-* C arrays are substituted for sequence iteration in more cases, also inside of generators.
-  Ad-hoc C array storage on the stack and in closures was reworked along the way.
-  (Github issues https://github.com/cython/cython/issues/7323, https://github.com/cython/cython/issues/7339)
-
-* Unicode string comparisons to single character literals are faster.
-  (Github issue https://github.com/cython/cython/issues/7418)
-
-* F-strings are a little faster in some cases.
-  (Github issues https://github.com/cython/cython/issues/7495, https://github.com/cython/cython/issues/7526)
-
-* PyPy and GraalPython use the vectorcall protocol to enable faster Python calls in future releases.
-  (Github issue https://github.com/cython/cython/issues/7614)
-
-* The runtime conversion from a Python mapping to a C struct/union uses less code.
-  (Github issue https://github.com/cython/cython/issues/7343)
-
-* The error handling of memoryviews uses less code.
-  (Github issue https://github.com/cython/cython/issues/7525)
-
-* The runtime dispatch code of fused types uses less code.
-  (Github issue https://github.com/cython/cython/issues/7501)
-
-* More code is extracted to the shared utility code module.
-  (Github issues https://github.com/cython/cython/issues/7556, https://github.com/cython/cython/issues/7570)
-
-* Cython compiled functions have a more efficient memory layout in the Limited API.
-  (Github issue https://github.com/cython/cython/issues/7519)
-
-* Module string content is now compressed with LZSS by default, which reduces the footprint of the
-  decompressor code compared to the 3.2.x default ``zlib``.  This also avoids a runtime dependency
-  on the ``zlib`` module since the tiny LZSS decompressor can be embedded in the module.
-  (Github issue https://github.com/cython/cython/issues/7577)
-
-* The Py2 ``print`` statement is now implemented in Cython instead of C to make it
-  thread-safe and uses a vectorcall into Python.
-  (Github issue https://github.com/cython/cython/issues/7642)
-
-* Several C++ exception declarations were added to ``libcpp.exceptions``.
-  (Github issue https://github.com/cython/cython/issues/7389)
-
-* Missing Python type flag declarations were added to ``cpython.object``.
-  (Github issue https://github.com/cython/cython/issues/7441)
-
-* Declarations for ``PyType_GetSlot()`` and the corresponding type slot IDs were added
-  to ``cpython.type``.
-
-* Declarations for specialised byte-conversion functions were added to ``cpython.long`` and ``cpython.float``.
-  Patch by Valentin Valls.  (Github issue https://github.com/cython/cython/issues/7738)
-
-* Error detection when assigning to ``const`` variables was improved.
-  (Github issue https://github.com/cython/cython/issues/7359)
-
-* Some cases of likely misuse of ``critical_section`` now generate warnings.
-  (Github issue https://github.com/cython/cython/issues/6766)
-
-* Programmatic use of Cython has become easier by avoiding the need to manually set up
-  the error reporting.
-  (Github issue https://github.com/cython/cython/issues/7235)
-
-* Autoscaling in ``cymeit`` is a little faster.
-
-* Unicode 17.0.0 is used to parse identifiers.
-
-Bugs fixed
-----------
-
-* Generated Cython language features like properties, auto-pickle or dataclasses
-  now use a critical section (on the object itself) as guard for concurrent access.
-  (Github issue https://github.com/cython/cython/issues/6621)
-
-* The star-import implementation needlessly rejected several names in internal use.
-  They are now allowed and become regular Python module attributes.
-  (Github issue https://github.com/cython/cython/issues/4931)
-
-* Mixing function signature declarations in Python modules and their ``.pxd`` modules could fail.
-  (Github issues https://github.com/cython/cython/issues/5970, https://github.com/cython/cython/issues/4388)
-
-* C array declarations with type and size could fail with an exception in pure Python code.
-  (Github issue https://github.com/cython/cython/issues/7372)
-
-* A ``const`` modifier in C++ template type arguments could be mapped incorrectly.
-  (Github issue https://github.com/cython/cython/issues/6294)
-
-* C++ ``typeid()`` failed to compile on more complex expressions.
-  (Github issue https://github.com/cython/cython/issues/7069)
-
-* Optimised Python ``int`` and ``float`` operations did not remember their result type,
-  leading to less optimised code in longer expressions.
-  (Github issues https://github.com/cython/cython/issues/7363, https://github.com/cython/cython/issues/7502)
-
-* Slices as dictionary keys confused the type inference of item access.
-  (Github issue https://github.com/cython/cython/issues/7702)
-
-* A race condition when ``return``ing from a ``cython.parallel.parallel`` section was fixed.
-  (Github issue https://github.com/cython/cython/issues/6521)
-
-* Cython still used ``(type, exc, traceback)`` for saving and restoring exception state,
-  even though modern CPython versions only store the exception object itself internally.
-  This is now modernised in many places to reduce overhead.
-  (Github issue https://github.com/cython/cython/issues/7481)
-
-* Exceptions originating from the ``Py_UNICODE_IS*()`` character classification macros and
-  the corresponding ``str.is*()`` methods, which they alias, were not handled but ignored in
-  the Limited API.
-  (Github issue https://github.com/cython/cython/issues/7602)
-
-* In the Limited API, import time failures to create code objects for compiled functions,
-  e.g. due to future Python API changes, are no longer fatal but generate a warning.
-  (Github issue https://github.com/cython/cython/issues/5718)
-
-* Several internal cases where exceptions are caught and discarded now propagate the
-  ``BaseException`` errors and only discard the expected exceptions.
-  (Github issue https://github.com/cython/cython/issues/7600)
-
-* Error handling was improved when setting up the table of ``cdef`` methods for extension types
-  and unexpected errors are propagated.
-  (Github issue https://github.com/cython/cython/issues/7613)
-
-* Exceptions while setting up the automatic pickle support are now propagated.
-  (Github issue https://github.com/cython/cython/issues/7613)
-
-* Exceptions thrown into async generators could leave the generator in an unclosed state.
-  (Github issue https://github.com/cython/cython/issues/7618)
-
-* In the Limited API, failures while formatting type names in exceptions are now uniformly handled.
-  (Github issue https://github.com/cython/cython/issues/7680)
-
-* The global module state struct now lives in an anonymous namespace in C++ mode to
-  allow linking multiple modules together in one shared library file.
-  (Github issue https://github.com/cython/cython/issues/7159)
-
-* Dict iteration generates safer code in PyPy/GraalPy/free-threading.
-  (Github issue https://github.com/cython/cython/issues/7637)
-
-* The floating point parsing code relied on C implementation specific "pointer compare after free" behaviour.
-  Patch by stratakis.  (Github issue https://github.com/cython/cython/issues/7463)
-
-* When non-heap types were used as base classes of extension heap types, the heap types
-  were not correctly reference counted by their instances.
-  (Github issue https://github.com/cython/cython/issues/7483)
-
-* The ``.__signatures__`` dict of fused functions is no longer writable.
-  (Github issue https://github.com/cython/cython/issues/7386)
-
-* A minimal implementation of ``.__annotate__`` was added to Cython compiled functions to make
-  ``@functools.wraps`` work in Python 3.14+.
-  (Github issue https://github.com/cython/cython/issues/7675)
-
-* The ``--embed-positions`` option no longer includes absolute file paths in the C code.
-  (Github issue https://github.com/cython/cython/issues/6755)
-
-* Error reporting on missing braces in f-strings was misleading.
-  (Github issue https://github.com/cython/cython/issues/7436)
-
-* ``None`` default values for function arguments declared as ``not None`` are now rejected at compile time
-  rather than leading to errors at runtime.
-  Patch by Vyas Ramasubramani.  (Github issue https://github.com/cython/cython/issues/7762)
-
-* Cython did not reject code with multiple contradicting type annotations on the same variable.
-  (Github issue https://github.com/cython/cython/issues/7246)
-
-* Cython no longer warns if ``@profile`` or ``@linetrace`` is applied to a function
-  without changing the global/outer setting.  This avoids annoyance when users leave
-  such redundant decorators in the code for occasional use.
-
-* Cached methods of builtin types were not GC-traversed and cleaned up as part of the module state.
-  Patch by Maxwell Bernstein.  (Github issue https://github.com/cython/cython/issues/7468)
-
-* Modules with non-ASCII names could end up with UTF-8 characters in their C code.
-  (Github issue https://github.com/cython/cython/issues/7588)
-
-* Several C compiler warnings related to mixed signed/unsigned C integer usage were resolved.
-
-* Includes all fixes as of Cython 3.2.6.
-
-3.2.6 (2026-06-24):
-
-* ``@functools.wraps()`` was broken in Py3.14+ for Cython compiled functions.
-  (Github issue https://github.com/cython/cython/issues/7675)
-
-* A double-free in the t-string code was fixed.
-  (Github issue https://github.com/cython/cython/issues/7712)
-
-* The ``-`` operator declarations for iterators in ``libcpp.vector`` we corrected.
-  Patch by Vadim Markovtsev.  (Github issue https://github.com/cython/cython/issues/7717)
-
-* The shared utility code module no longer uses a temporary file path that
-  changed the C code on each generation.
-  (Github issue https://github.com/cython/cython/issues/7723)
-
-* On 32 bit platforms, cached constants are no longer made immortal during module import.
-  (Github issue https://github.com/cython/cython/issues/7744)
-
-Other changes
--------------
-
-* Support for Python 3.8 has been removed.
-  As a side-effekt, support for StacklessPython and Pyston (last release was 3.8) was also removed.
-  Python 3.9 is planned to remain supported for several years due to its use in LTS Linux distributions.
-  (Github issue https://github.com/cython/cython/issues/7271)
-
-* The vectorcall feature macros were unified to make ``CYTHON_VECTORCALL`` the only way to
-  disable this feature (if need arises).  Previously the option macros ``CYTHON_METH_FASTCALL``,
-  ``CYTHON_FAST_PYCALL`` and ``CYTHON_VECTORCALL`` all controlled different aspects of the
-  implementation.
-  (Github issue https://github.com/cython/cython/issues/7616)
-
-* Coroutines no longer provide the legacy ``_is_coroutine`` property.
-  (Github issue https://github.com/cython/cython/issues/7709)
-
-* ``Cython/Shadow.pyi`` has been merged into ``Cython/Shadow.py``.
-  (Github issue https://github.com/cython/cython/issues/7376)
-
-* The documentation now uses the "Clarity" Sphinx theme.
-  Patch by Libor Jelínek.  (Github issue https://github.com/cython/cython/issues/7564)