Cython 3.2.5__tar.gz → 3.2.6__tar.gz

cython-3.2.6/.gitrev

@@ -0,0 +1 @@
+f49dd246c3eaa9291089aa256e5e2752080ae9f0

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

@@ -2,6 +2,35 @@
 Cython Changelog
 ================
 
+3.2.6 (2026-06-24)
+==================
+
+Bugs fixed
+----------
+
+* ``@functools.wraps()`` was broken in Py3.14+ for Cython compiled functions.
+  (Github issue :issue:`7675`)
+
+* A double-free in the t-string code was fixed.
+  (Github issue :issue:`7712`)
+
+* The ``-`` operator declarations for iterators in ``libcpp.vector`` we corrected.
+  Patch by Vadim Markovtsev.  (Github issue :issue:`7717`)
+
+* The shared utility code module no longer uses a temporary file path that
+  changed the C code on each generation.
+  (Github issue :issue:`7723`)
+
+* On 32 bit platforms, cached constants are no longer made immortal during module import.
+  (Github issue :issue:`7744`)
+
+Other changes
+-------------
+
+* Binary wheels are now built with ``-DNDEBUG`` to discard runtime assertions from CPython's
+  inline functions.
+
+
 3.2.5 (2026-05-23)
 ==================
 

{cython-3.2.5 → cython-3.2.6}/Cython/Build/Dependencies.py

@@ -52,7 +52,7 @@ def extended_iglob(pattern):
     # because '/' is generally common for relative paths.
     if '**/' in pattern or os.sep == '\\' and '**\\' in pattern:
         seen = set()
-        first, rest = re.split(r'\*\*[%s]' % ('/\\\\' if os.sep == '\\' else '/'), pattern, 1)
+        first, rest = re.split(r'\*\*[%s]' % ('/\\\\' if os.sep == '\\' else '/'), pattern, maxsplit=1)
         if first:
             first = iglob(first + os.sep)
         else:

{cython-3.2.5 → cython-3.2.6}/Cython/Build/SharedModule.py

@@ -1,13 +1,10 @@
 import os
-import re
-import shutil
-import tempfile
 
 from Cython.Compiler import (
     MemoryView, Code, Options, Pipeline, Errors, Main, Symtab
 )
 from Cython.Compiler.StringEncoding import EncodedString
-from Cython.Compiler.Scanning import FileSourceDescriptor
+from Cython.Compiler.Scanning import SharedUtilitySourceDescriptor
 
 
 def create_shared_library_pipeline(context, scope, options, result):
@@ -72,23 +69,17 @@ def generate_shared_module(options):
     Errors.open_listing_file(None)
 
     dest_c_file = options.shared_c_file_path
+    pyx_file = os.path.splitext(dest_c_file)[0] + '.pyx'
     module_name = os.path.splitext(os.path.basename(dest_c_file))[0]
 
     context = Main.Context.from_options(options)
     scope = Symtab.ModuleScope('MemoryView', parent_module = None, context = context, is_package=False)
 
-    with tempfile.TemporaryDirectory() as tmpdirname:
-        pyx_file = os.path.join(tmpdirname, f'{module_name}.pyx')
-        c_file = os.path.join(tmpdirname, f'{module_name}.c')
-        with open(pyx_file, 'w'):
-            pass
-        source_desc = FileSourceDescriptor(pyx_file)
-        comp_src = Main.CompilationSource(source_desc, EncodedString(module_name), os.getcwd())
-        result = Main.create_default_resultobj(comp_src, options)
-
-        pipeline = create_shared_library_pipeline(context, scope, options, result)
-        err, enddata = Pipeline.run_pipeline(pipeline, comp_src)
-        if err is None:
-            shutil.copy(c_file, dest_c_file)
+    source_desc = SharedUtilitySourceDescriptor(pyx_file)
+    comp_src = Main.CompilationSource(source_desc, EncodedString(module_name), os.getcwd())
+    result = Main.create_default_resultobj(comp_src, options)
+
+    pipeline = create_shared_library_pipeline(context, scope, options, result)
+    err, enddata = Pipeline.run_pipeline(pipeline, comp_src)
 
     return err, enddata

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

@@ -2429,19 +2429,26 @@ class GlobalState:
         writer.putln("{")
         writer.putln(f"PyObject **table = {array_cname};")
         writer.putln(f"for (Py_ssize_t i=0; i<{constant_count}; ++i) {{")
-        writer.putln("#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING")
+        writer.putln("#if PY_VERSION_HEX >= 0x030F0000")
+        writer.putln("PyUnstable_SetImmortal(table[i]);")
+        writer.putln("#elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING")
         # We don't want to set the refcount on shared constants (e.g. cached integers)
         # because setting the refcount isn't thread-safe. The chances are that most of the constants
         # that this applies to are already immortal though so that isn't a great loss.
+        # Overflow, e.g. on 32 bit systems.
+        writer.putln("if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break;")
         writer.putln("#if PY_VERSION_HEX < 0x030E0000")
         writer.putln("if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1)")
         writer.putln("#else")
         writer.putln("if (PyUnstable_Object_IsUniquelyReferenced(table[i]))")
         writer.putln("#endif")
         writer.putln("{")
-        writer.putln("Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL);")
+        # Go one higher than we think we need to because of a bug in SET_REFCNT check in CPython
+        writer.putln("Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1));")
         writer.putln("}")
         writer.putln("#else")
+        # Overflow, e.g. on 32 bit systems.
+        writer.putln("if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break;")
         writer.putln("Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT);")
         writer.putln("#endif")
         writer.putln("}")  # for()

{cython-3.2.5 → cython-3.2.6}/Cython/Compiler/Scanning.py

@@ -281,6 +281,15 @@ class StringSourceDescriptor(SourceDescriptor):
         return "<StringSourceDescriptor:%s>" % self.name
 
 
+class SharedUtilitySourceDescriptor(FileSourceDescriptor):
+    """
+    A specialized source descriptor for shared utility code only. Not part of public API.
+    """
+
+    def get_file_object(self, encoding=None, error_handling=None):
+        from io import StringIO
+        return StringIO('')
+
 #------------------------------------------------------------------
 
 class PyrexScanner(Scanner):

{cython-3.2.5 → cython-3.2.6}/Cython/Includes/libcpp/vector.pxd

@@ -79,8 +79,8 @@ cdef extern from "<vector>" namespace "std" nogil:
             reverse_iterator operator--(int)
             reverse_iterator operator+(size_type)
             reverse_iterator operator-(size_type)
-            difference_type operator-(iterator)
-            difference_type operator-(const_iterator)
+            difference_type operator-(reverse_iterator)
+            difference_type operator-(const_reverse_iterator)
             bint operator==(reverse_iterator)
             bint operator==(const_reverse_iterator)
             bint operator!=(reverse_iterator)
@@ -104,8 +104,8 @@ cdef extern from "<vector>" namespace "std" nogil:
             const_reverse_iterator operator--(int)
             const_reverse_iterator operator+(size_type)
             const_reverse_iterator operator-(size_type)
-            difference_type operator-(iterator)
-            difference_type operator-(const_iterator)
+            difference_type operator-(reverse_iterator)
+            difference_type operator-(const_reverse_iterator)
             bint operator==(reverse_iterator)
             bint operator==(const_reverse_iterator)
             bint operator!=(reverse_iterator)

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

{cython-3.2.5 → cython-3.2.6}/Cython/Utility/CythonFunction.c

@@ -500,6 +500,59 @@ __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
     return result;
 }
 
+static PyObject *__Pyx_CyFunction_annotate_impl(PyObject *self, PyObject *args) {
+    // The signature of this function is 0 or 1 args, where arg should be an int (if passed).
+    // However, for this basic placeholder implementation, we don't care and don't check it.
+    CYTHON_UNUSED_VAR(args);
+    if (unlikely(!self)) {
+        PyErr_SetString(PyExc_SystemError, "cython __annotate__ called without 'self' argument");
+    }
+    Py_XINCREF(self);
+    return self;
+}
+
+static PyMethodDef __Pyx_CyFunction_annotate_method = {
+    "__annotate__",
+    (PyCFunction)(void (*)(void))__Pyx_CyFunction_annotate_impl,
+    METH_VARARGS,
+    "Placeholder __annotate__ function to allow 'functools.wraps' to work "
+    "on Cython functions."
+};
+
+// 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) {
+    CYTHON_UNUSED_VAR(context);
+    PyObject *annotations = __Pyx_CyFunction_get_annotations((__pyx_CyFunctionObject *) op_in, NULL);
+    if (unlikely(!annotations)) return NULL;
+    PyObject *method = PyCFunction_New(
+        &__Pyx_CyFunction_annotate_method,
+        annotations);
+    Py_DECREF(annotations);
+    return method;
+}
+
+static int
+__Pyx_CyFunction_set_annotate(PyObject *op_in, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        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;
+    }
+    PyObject *annotations = PyObject_CallObject(value, NULL);
+    if (!annotations) return -1;
+    int result = __Pyx_CyFunction_set_annotations((__pyx_CyFunctionObject *) op_in, annotations, NULL);
+    Py_DECREF(annotations);
+    return result;
+}
+
 static PyObject *
 __Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) {
     int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
@@ -649,6 +702,7 @@ static PyGetSetDef __pyx_CyFunction_getsets[] = {
     {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
     {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
     {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {"__annotate__", (getter)__Pyx_CyFunction_get_annotate, (setter)__Pyx_CyFunction_set_annotate, 0, 0},
     {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
 //    {"__signature__", (getter)__Pyx_CyFunction_get_signature, 0, 0, 0},
 #if CYTHON_COMPILING_IN_LIMITED_API

{cython-3.2.5 → cython-3.2.6}/Cython/Utility/TString.c

@@ -301,8 +301,8 @@ static PyObject* __Pyx_MakeTemplateLibTemplate(PyObject *strings, PyObject *inte
         if (unlikely(__Pyx_VectorcallBuilder_AddArg(PYIDENT("interpolations"), interpolations, kwargs_builder, args, 1)<0))
             goto failed_shortcut;
         result = __Pyx_Object_Vectorcall_CallFromBuilder(tp, args, 0, kwargs_builder);
-        Py_DECREF(kwargs_builder);
         if (result) {
+            Py_DECREF(kwargs_builder);
             Py_DECREF(tp);
             return result;
         }

cython-3.2.6/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: Cython
+Version: 3.2.6
+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 :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Python :: Implementation :: Stackless
+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.8
+Description-Content-Type: text/x-rst
+
+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.2.6 (2026-06-24)
+==================
+
+Bugs fixed
+----------
+
+* ``@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
+-------------
+
+* Binary wheels are now built with ``-DNDEBUG`` to discard runtime assertions from CPython's
+  inline functions.

{cython-3.2.5 → cython-3.2.6}/tests/pypy_implementation_detail_bugs.txt

@@ -4,6 +4,7 @@
 # that should be tested on PyPy?)
 
 run.starargs
+run.extstarargs
 
 # refcounting-specific tests
 double_dealloc_T796

{cython-3.2.5 → cython-3.2.6}/tests/run/cyfunction.pyx

@@ -7,6 +7,7 @@ cimport cython
 include "skip_limited_api_helper.pxi"
 
 import sys
+from functools import wraps
 
 def inspect_isroutine():
     """
@@ -430,6 +431,81 @@ def test_fused_module(cython.numeric arg):
     """
     pass
 
+
+if sys.version_info < (3, 9):
+    # In Limited API 3.8, @wraps() fails on a missing "__wrapped__" attribute.
+    def wraps(f):
+        def nowrap(func):
+            return f
+        return nowrap
+
+
+def to_be_wrapped(a: int, b: float):
+    """
+    Hello from to_be_wrapped's docstring
+    """
+    pass
+
+to_be_wrapped.__module__ = "other_module"
+
+
+def test_wraps(f):
+    """
+    >>> wrapped_func = test_wraps(to_be_wrapped)
+    >>> wrapped_func.__module__
+    'other_module'
+    >>> wrapped_func.__name__
+    'to_be_wrapped'
+    >>> wrapped_func.__qualname__
+    'to_be_wrapped'
+    >>> wrapped_func.__annotations__ == to_be_wrapped.__annotations__
+    True
+    >>> wrapped_func.__doc__
+    "\\n    Hello from to_be_wrapped's docstring\\n    "
+
+    # __type_params__ should also be copied, but Cython doesn't support this at all
+    """
+    @wraps(f)
+    def wrapper(*args, **kwds):
+        return f(*args, **kwds)
+    return wrapper
+
+
+def test_annotate():
+    """
+    Currently we don't implement PEP 649 fully, so __annotate__ is a limited
+    placeholder version mainly to make `functools.wraps` work on Python 3.14+.
+    Therefore, we shouldn't worry too much if this test needs to change in
+    future.
+
+    >>> f = test_annotate()
+    >>> list(f.__annotate__().keys())
+    ['a', 'b']
+    >>> list(f.__annotate__(1).keys())
+    ['a', 'b']
+
+    Assigning should work
+    >>> f.__annotate__ = lambda arg=0: {'different_argument': 5}
+    >>> f.__annotations__
+    {'different_argument': 5}
+
+    Assigning to None shouldn't change the annotations
+    >>> f = test_annotate()
+    >>> f.__annotate__ = None
+    >>> list(f.__annotate__().keys())
+    ['a', 'b']
+
+    Deleting is banned
+    >>> f = test_annotate()
+    >>> del f.__annotate__
+    Traceback (most recent call last):
+    TypeError: __annotate__ cannot be deleted
+    """
+    def inner(a: int, b: str):
+        pass
+    return inner
+
+
 __doc__ = """
 >>> test_module.__module__
 'cyfunction'

cython-3.2.5/.gitrev

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

cython-3.2.5/PKG-INFO

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