Cython 3.1.3__tar.gz → 3.1.5__tar.gz

cython-3.1.5/.gitrev

@@ -0,0 +1 @@
+24eb0d558efe0a92ba87bb7ebed45c14ed4a713e

{cython-3.1.3 → cython-3.1.5}/CHANGES.rst

@@ -2,6 +2,69 @@
 Cython Changelog
 ================
 
+3.1.5 (2025-01-19)
+==================
+
+Bugs fixed
+----------
+
+* 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 :issue:`7157`)
+
+* Optimised unpacking of Python integers in expressions uses a slightly safer scheme.
+  (Github issue :issue:`7134`)
+
+* Empty return statements were not always reported when tracing.
+  (Github issue :issue:`7022`)
+
+* Value conversion errors when tracing C return statements no longer fail the trace
+  but fall back to reporting ``None`` returns instead.
+  (Github issue :issue:`6503`)
+
+
+3.1.4 (2025-09-16)
+==================
+
+Features added
+--------------
+
+* Declarations for the new ``PyUnstable_*()`` refcounting C-API functions in Py3.14 were added.
+  (Github issue :issue:`6836`)
+
+Bugs fixed
+----------
+
+* The monitoring code could crash on tracing.
+  (Github issue :issue:`7050`)
+
+* Initialising the monitoring code could fail with a CPython exception.
+  See https://github.com/nedbat/coveragepy/issues/1790#issuecomment-3257410149
+
+* Optimised integer shifting triggered undefined behaviour in C.
+  (Github issue :issue:`7089`)
+
+* Deallocating objects that inherit from external types defined in pxd files
+  could run into an infinite loop.
+  (Github issue :issue:`7143`)
+
+* A reference to metaclasses could be leaked on instantiation.
+  (Github issue :issue:`7130`)
+
+* (Unlikely) error handling during empty builtin container tests was ineffective.
+  (Github issue :issue:`7190`)
+
+* Generated ``*_api.h`` files used potentially unknown Cython configuration macros.
+  (Github issue :issue:`7108`)
+
+* ``cythonize()`` avoids parallel compiler runs on systems using ``spawn()`` in multiprocessing.
+  Patch by Marcel Bargull.  (Github issue :issue:`3262`)
+
+* The ``@cython.ufunc``  decorator was missing in type checker stubs.
+  Patch by jayClean.  (Github issue :issue:`7109`)
+
+
 3.1.3 (2025-08-13)
 ==================
 

{cython-3.1.3 → cython-3.1.5}/Cython/Build/Dependencies.py

@@ -1129,6 +1129,11 @@ def cythonize(module_list, exclude=None, nthreads=0, aliases=None, quiet=False,
 
     if N <= 1:
         nthreads = 0
+    if nthreads:
+        import multiprocessing
+        if multiprocessing.get_start_method() == 'spawn':
+            print('Disabling parallel cythonization for "spawn" process start method.')
+            nthreads = 0
     if nthreads:
         import multiprocessing
         pool = multiprocessing.Pool(

{cython-3.1.3 → cython-3.1.5}/Cython/Compiler/Annotate.py

@@ -4,7 +4,6 @@
 import os
 import os.path
 import re
-import codecs
 import textwrap
 from datetime import datetime
 from functools import partial
@@ -121,7 +120,7 @@ class AnnotationCCodeWriter(CCodeWriter):
         c_file = Utils.decode_filename(os.path.basename(target_filename))
         html_filename = os.path.splitext(target_filename)[0] + ".html"
 
-        with codecs.open(html_filename, "w", encoding="UTF-8") as out_buffer:
+        with open(html_filename, "w", encoding="UTF-8") as out_buffer:
             out_buffer.write(self._save_annotation(code, generated_code, c_file, source_filename, coverage_xml))
 
     def _save_annotation_header(self, c_file, source_filename, coverage_timestamp=None):

{cython-3.1.3 → cython-3.1.5}/Cython/Compiler/Code.py

@@ -2958,7 +2958,7 @@ class CCodeWriter:
     def put_error_if_neg(self, pos, value):
         # TODO this path is almost _never_ taken, yet this macro makes is slower!
         # return self.putln("if (unlikely(%s < 0)) %s" % (value, self.error_goto(pos)))
-        return self.putln("if (%s < 0) %s" % (value, self.error_goto(pos)))
+        return self.putln("if (%s < (0)) %s" % (value, self.error_goto(pos)))
 
     def put_error_if_unbound(self, pos, entry, in_nogil_context=False, unbound_check_code=None):
         nogil_tag = "Nogil" if in_nogil_context else ""

{cython-3.1.3 → cython-3.1.5}/Cython/Compiler/ExprNodes.py

@@ -14682,7 +14682,9 @@ class CoerceToBooleanNode(CoercionNode):
 
     type = PyrexTypes.c_bint_type
 
-    # Note that all of these need a check if CYTHON_ASSUME_SAFE_MACROS is false
+    # Note that all of these need a check if CYTHON_ASSUME_SAFE_SIZE is false.
+    # They should also all return something compatible with Py_ssize_t
+    # (i.e. Py_ssize_t or a smaller int type).
     _special_builtins = {
         Builtin.list_type:       '__Pyx_PyList_GET_SIZE',
         Builtin.tuple_type:      '__Pyx_PyTuple_GET_SIZE',
@@ -14718,11 +14720,18 @@ class CoerceToBooleanNode(CoercionNode):
             return
         test_func = self._special_builtins.get(self.arg.type)
         if test_func is not None:
-            checks = ["(%s != Py_None)" % self.arg.py_result()] if self.arg.may_be_none() else []
-            checks.append("(%s(%s) != 0)" % (test_func, self.arg.py_result()))
-            code.putln("%s = %s;" % (self.result(), '&&'.join(checks)))
+            if self.arg.may_be_none():
+                code.putln(f"if ({self.arg.py_result()} == Py_None) {self.result()} = 0;")
+                code.putln("else")
+            code.putln("{")
+            # Be aware that __Pyx_PyUnicode_IS_TRUE isn't strictly returning a size (but it does
+            # return an int which fits into a Py_ssize_t).
+            code.putln(f"Py_ssize_t {Naming.quick_temp_cname} = {test_func}({self.arg.py_result()});")
             code.putln(code.error_goto_if(
-                "((!CYTHON_ASSUME_SAFE_MACROS) && %s < 0)" % self.result(), self.pos))
+                f"((!CYTHON_ASSUME_SAFE_SIZE) && {Naming.quick_temp_cname} < 0)", self.pos))
+            code.putln(f"{self.result()} = ({Naming.quick_temp_cname} != 0);")
+            code.putln("}")
+            code.putln()
         else:
             code.putln(
                 "%s = __Pyx_PyObject_IsTrue(%s); %s" % (

{cython-3.1.3 → cython-3.1.5}/Cython/Compiler/Nodes.py

@@ -7010,13 +7010,6 @@ class ReturnStatNode(StatNode):
                     Naming.retval_cname,
                     value.result_as(self.return_type)))
                 value.generate_post_assignment_code(code)
-                if code.globalstate.directives['profile'] or code.globalstate.directives['linetrace']:
-                    code.put_trace_return(
-                        Naming.retval_cname,
-                        self.pos,
-                        return_type=self.return_type,
-                        nogil=not code.funcstate.gil_owned,
-                    )
             value.free_temps(code)
         else:
             if self.return_type.is_pyobject:
@@ -7024,6 +7017,14 @@ class ReturnStatNode(StatNode):
             elif self.return_type.is_returncode:
                 self.put_return(code, self.return_type.default_value)
 
+        if code.globalstate.directives['profile'] or code.globalstate.directives['linetrace']:
+            code.put_trace_return(
+                Naming.retval_cname,
+                self.pos,
+                return_type=self.return_type,
+                nogil=not code.funcstate.gil_owned,
+            )
+
         for cname, type in code.funcstate.temps_holding_reference():
             code.put_decref_clear(cname, type)
 

{cython-3.1.3 → cython-3.1.5}/Cython/Compiler/Scanning.py

@@ -209,22 +209,15 @@ class FileSourceDescriptor(SourceDescriptor):
         # we cache the lines only the second time this is called, in
         # order to save memory when they are only used once
         key = (encoding, error_handling)
-        try:
-            lines = self._lines[key]
-            if lines is not None:
-                return lines
-        except KeyError:
-            pass
+        lines = self._lines.get(key)
+        if lines is not None:
+            return lines
 
         with self.get_file_object(encoding=encoding, error_handling=error_handling) as f:
             lines = f.readlines()
 
-        if key in self._lines:
-            self._lines[key] = lines
-        else:
-            # do not cache the first access, but remember that we
-            # already read it once
-            self._lines[key] = None
+        # Do not cache the first access, but add the key to remember that we already read it once.
+        self._lines[key] = lines if key in self._lines else None
         return lines
 
     def get_file_object(self, encoding=None, error_handling=None):

{cython-3.1.3 → cython-3.1.5}/Cython/Compiler/Symtab.py

@@ -1194,7 +1194,7 @@ class Scope:
 
     def _emit_class_private_warning(self, pos, name):
         warning(pos, "Global name %s matched from within class scope "
-                            "in contradiction to to Python 'class private name' rules. "
+                            "in contradiction to Python 'class private name' rules. "
                             "This may change in a future release." % name, 1)
 
     def use_utility_code(self, new_code):
@@ -2445,6 +2445,9 @@ class CClassScope(ClassScope):
         # C attributes, then it needs to participate in GC.
         if self.has_cyclic_pyobject_attrs and not self.directives.get('no_gc', False):
             return True
+        if self.parent_type.is_external and not self.parent_type.is_builtin_type:
+            # It's impossible to really know - external types are often incomplete.
+            return True
         base_type = self.parent_type.base_type
         if base_type and base_type.scope is not None:
             return base_type.scope.needs_gc()

{cython-3.1.3 → cython-3.1.5}/Cython/Compiler/TypeSlots.py

@@ -424,7 +424,9 @@ class GCDependentSlot(InternalMethodSlot):
         InternalMethodSlot.__init__(self, slot_name, **kargs)
 
     def slot_code(self, scope):
-        if not scope.needs_gc():
+        # We treat external types as needing gc, but don't generate a slot code
+        # because we don't know it to be able to call it directly.
+        if not scope.needs_gc() or scope.parent_type.is_external:
             return "0"
         if not scope.has_cyclic_pyobject_attrs:
             # if the type does not have GC relevant object attributes, it can
@@ -479,16 +481,10 @@ class ConstructorSlot(InternalMethodSlot):
             # delegate GC methods to its parent - iff the parent
             # functions are defined in the same module
             slot_code = self._parent_slot_function(scope)
-            return slot_code or '0'
+            if slot_code is not None:
+                return slot_code
         return InternalMethodSlot.slot_code(self, scope)
 
-    def spec_value(self, scope):
-        slot_function = self.slot_code(scope)
-        if self.slot_name == "tp_dealloc" and slot_function != scope.mangle_internal("tp_dealloc"):
-            # Not used => inherit from base type.
-            return "0"
-        return slot_function
-
     def generate_dynamic_init_code(self, scope, code):
         if self.slot_code(scope) != '0':
             return

cython-3.1.5/Cython/Includes/cpython/ref.pxd

@@ -0,0 +1,141 @@
+from .object cimport PyObject
+from .object cimport PyTypeObject, Py_TYPE  # legacy imports for re-export
+
+cdef extern from "Python.h":
+    #####################################################################
+    # 3. Reference Counts
+    #####################################################################
+    # The macros in this section are used for managing reference counts of Python objects.
+    void Py_INCREF(object o)
+    # Increment the reference count for object o. The object must not
+    # be NULL; if you aren't sure that it isn't NULL, use
+    # Py_XINCREF().
+
+    void Py_XINCREF(PyObject* o)
+    # Increment the reference count for object o. The object may be NULL, in which case the macro has no effect.
+
+    void Py_DECREF(object o)
+    # Decrement the reference count for object o. The object must not
+    # be NULL; if you aren't sure that it isn't NULL, use
+    # Py_XDECREF(). If the reference count reaches zero, the object's
+    # type's deallocation function (which must not be NULL) is
+    # invoked.
+
+    # Warning: The deallocation function can cause arbitrary Python
+    # code to be invoked (e.g. when a class instance with a __del__()
+    # method is deallocated). While exceptions in such code are not
+    # propagated, the executed code has free access to all Python
+    # global variables. This means that any object that is reachable
+    # from a global variable should be in a consistent state before
+    # Py_DECREF() is invoked. For example, code to delete an object
+    # from a list should copy a reference to the deleted object in a
+    # temporary variable, update the list data structure, and then
+    # call Py_DECREF() for the temporary variable.
+
+    void Py_XDECREF(PyObject* o)
+    # Decrement the reference count for object o. The object may be
+    # NULL, in which case the macro has no effect; otherwise the
+    # effect is the same as for Py_DECREF(), and the same warning
+    # applies.
+
+    void Py_CLEAR(PyObject* o)
+    # Decrement the reference count for object o. The object may be
+    # NULL, in which case the macro has no effect; otherwise the
+    # effect is the same as for Py_DECREF(), except that the argument
+    # is also set to NULL. The warning for Py_DECREF() does not apply
+    # with respect to the object passed because the macro carefully
+    # uses a temporary variable and sets the argument to NULL before
+    # decrementing its reference count.
+    # It is a good idea to use this macro whenever decrementing the
+    # value of a variable that might be traversed during garbage
+    # collection.
+
+    Py_ssize_t Py_REFCNT(object o)
+    # Get the reference count of the Python object o.
+
+    # Note that the returned value may not actually reflect how many
+    # references to the object are actually held. For example, some
+    # objects are “immortal” and have a very high refcount that does not
+    # reflect the actual number of references. Consequently, do not rely
+    # on the returned value to be accurate, other than a value of 0 or
+    # 1.
+
+    Py_ssize_t _Py_REFCNT "Py_REFCNT" (PyObject *ptr)
+    # Get the reference count for the PyObject pointer ptr.
+
+    # This is useful when it would be awkward to create an owned reference just
+    # to get the reference count. See the note for Py_REFCNT above about the
+    # accuracy of reference counts.
+
+    int PyUnstable_Object_EnableDeferredRefcount(object o)
+    # Enable deferred reference counting on obj, if supported by the runtime.
+    # In the free-threaded build, this allows the interpreter to avoid reference count
+    # adjustments to obj, which may improve multi-threaded performance.
+    # The tradeoff is that obj will only be deallocated by the tracing garbage collector,
+    # and not when the interpreter no longer has any references to it.
+    #
+    # This function returns 1 if deferred reference counting is enabled on obj,
+    # and 0 if deferred reference counting is not supported or if the hint was ignored
+    # by the interpreter, such as when deferred reference counting is already enabled on obj.
+    # This function is thread-safe, and cannot fail.
+    #
+    # This function does nothing on builds with the GIL enabled, which do not support
+    # deferred reference counting. This also does nothing if obj is not an object tracked
+    # by the garbage collector (see gc.is_tracked() and PyObject_GC_IsTracked()).
+    #
+    # This function is intended to be used soon after obj is created, by the code
+    # that creates it, such as in the object’s tp_new slot.
+    #
+    # Added in CPython 3.14.
+
+    int PyUnstable_Object_IsUniqueReferencedTemporary(object o)
+    # Check if obj is a unique temporary object.
+    # Returns 1 if obj is known to be a unique temporary object, and 0 otherwise.
+    # This function cannot fail, but the check is conservative, and may return 0
+    # in some cases even if obj is a unique temporary object.
+    #
+    # If an object is a unique temporary, it is guaranteed that the current code
+    # has the only reference to the object. For arguments to C functions, this should
+    # be used instead of checking if the reference count is 1.
+    # Starting with Python 3.14, the interpreter internally avoids some reference count
+    # modifications when loading objects onto the operands stack by borrowing references
+    # when possible, which means that a reference count of 1 by itself does not guarantee
+    # that a function argument uniquely referenced.
+    #
+    # Added in CPython 3.14.
+
+    int PyUnstable_IsImmortal(object o)
+    # This function returns non-zero if obj is immortal, and zero otherwise.
+    # This function cannot fail.
+    #
+    # Added in CPython 3.14.
+
+    void PyUnstable_EnableTryIncRef(object o)
+    # Enables subsequent uses of PyUnstable_TryIncRef() on obj.
+    # The caller must hold a strong reference to obj when calling this.
+    #
+    # Added in CPython 3.14.
+
+    bint PyUnstable_TryIncRef(PyObject *o)
+    # Increments the reference count of obj if it is not zero.
+    # Returns 1 if the object’s reference count was successfully incremented.
+    # Otherwise, this function returns 0.
+    #
+    # PyUnstable_EnableTryIncRef() must have been called earlier on obj
+    # or this function may spuriously return 0 in the free threading build.
+    #
+    # Added in CPython 3.14.
+
+    int PyUnstable_Object_IsUniquelyReferenced(object o)
+    # Determine if op only has one reference.
+    #
+    # On GIL-enabled builds, this function is equivalent to Py_REFCNT(op) == 1.
+    #
+    # On a free threaded build, this checks if op’s reference count is equal
+    # to one and additionally checks if op is only used by this thread.
+    # Py_REFCNT(op) == 1 is not thread-safe on free threaded builds; prefer this function.
+    #
+    # The caller must hold an attached thread state, despite the fact that this function
+    # doesn’t call into the Python interpreter. This function cannot fail.
+    #
+    # Added in CPython 3.14.

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

{cython-3.1.3 → cython-3.1.5}/Cython/Shadow.pyi

@@ -38,13 +38,13 @@ _Decorator = Callable[[_C], _C]
 
 _func_deco: _Decorator
 
-cfunc = ccall = compile = _func_deco
+cfunc = ccall = compile = ufunc = _func_deco
 
 def locals(**kwargs: Any) -> _Decorator: ...
 
 def _class_deco(__cls: _TypeT) -> _TypeT: ...
 
-cclass = internal = c_api_binop_methods = type_version_tag = no_gc_clear = no_gc = _class_deco
+cclass = internal = c_api_binop_methods = type_version_tag = no_gc_clear = no_gc = total_ordering = _class_deco
 
 # May be a bit hard to read but essentially means:
 # > Returns a callable that takes another callable with these parameters and *some*

{cython-3.1.3 → cython-3.1.5}/Cython/Utility/CommonStructures.c

@@ -194,6 +194,7 @@ static int __pyx_CommonTypesMetaclass_init(PyObject *module) {
         return -1;
     }
     mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases);
+    Py_DECREF(bases);
     if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) {
         return -1;
     }

{cython-3.1.3 → cython-3.1.5}/Cython/Utility/CppConvert.pyx

@@ -13,7 +13,7 @@ cdef extern from *:
 cdef string {{cname}}(object o) except *:
     cdef Py_ssize_t length = 0
     cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length)
-    return string(data, length)
+    return string(data, <size_t> length)
 
 
 #################### string.to_py ####################
@@ -21,6 +21,7 @@ cdef string {{cname}}(object o) except *:
 #cimport cython
 #from libcpp.string cimport string
 cdef extern from *:
+    const Py_ssize_t PY_SSIZE_T_MAX
     cdef cppclass string "{{type}}":
         char* data()
         size_t size()
@@ -31,7 +32,9 @@ cdef extern from *:
 
 @cname("{{cname.replace("PyObject", py_type, 1)}}")
 cdef inline object {{cname.replace("PyObject", py_type, 1)}}(const string& s):
-    return __Pyx_{{py_type}}_FromStringAndSize(s.data(), s.size())
+    if s.size() > <size_t> PY_SSIZE_T_MAX:
+        raise MemoryError()
+    return __Pyx_{{py_type}}_FromStringAndSize(s.data(), <Py_ssize_t> s.size())
 {{endfor}}
 
 

{cython-3.1.3 → cython-3.1.5}/Cython/Utility/CythonFunction.c

@@ -1530,7 +1530,7 @@ __pyx_FusedFunction_getitem(__pyx_FusedFunctionObject *self, PyObject *idx)
             Py_DECREF(item);
 #endif
             if (unlikely(!string)) goto __pyx_err;
-	    if (__Pyx_PyList_SET_ITEM(list, i, string) < 0) goto __pyx_err;
+	    if (__Pyx_PyList_SET_ITEM(list, i, string) < (0)) goto __pyx_err;
         }
 
         signature = PyUnicode_Join(PYUNICODE("|"), list);
@@ -1610,7 +1610,7 @@ __pyx_FusedFunction_call(PyObject *func, PyObject *args, PyObject *kw)
         self = binding_func->self;
 
         Py_INCREF(self);
-        if (__Pyx_PyTuple_SET_ITEM(new_args, 0, self)) goto bad;
+        if (__Pyx_PyTuple_SET_ITEM(new_args, 0, self) < (0)) goto bad;
         self = NULL;
 
         for (i = 0; i < argc; i++) {
@@ -1620,7 +1620,7 @@ __pyx_FusedFunction_call(PyObject *func, PyObject *args, PyObject *kw)
 #else
             PyObject *item = __Pyx_PySequence_ITEM(args, i);  if (unlikely(!item)) goto bad;
 #endif
-        if (__Pyx_PyTuple_SET_ITEM(new_args, i + 1, item)) goto bad;
+        if (__Pyx_PyTuple_SET_ITEM(new_args, i + 1, item) < (0)) goto bad;
         }
 
         args = new_args;

{cython-3.1.3 → cython-3.1.5}/Cython/Utility/ImportExport.c

@@ -472,6 +472,8 @@ static PyTypeObject *__Pyx_ImportType_$cyversion(PyObject* module, const char *m
 /////////////// TypeImport ///////////////
 //@substitute: naming
 
+// Note that this goes into headers so CYTHON_COMPILING_IN_LIMITED_API may not be available.
+
 #ifndef __PYX_HAVE_RT_ImportType_$cyversion
 #define __PYX_HAVE_RT_ImportType_$cyversion
 static PyTypeObject *__Pyx_ImportType_$cyversion(PyObject *module, const char *module_name, const char *class_name,
@@ -480,7 +482,7 @@ static PyTypeObject *__Pyx_ImportType_$cyversion(PyObject *module, const char *m
     PyObject *result = 0;
     Py_ssize_t basicsize;
     Py_ssize_t itemsize;
-#if CYTHON_COMPILING_IN_LIMITED_API
+#if defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API)
     PyObject *py_basicsize;
     PyObject *py_itemsize;
 #endif
@@ -494,7 +496,7 @@ static PyTypeObject *__Pyx_ImportType_$cyversion(PyObject *module, const char *m
             module_name, class_name);
         goto bad;
     }
-#if !CYTHON_COMPILING_IN_LIMITED_API
+#if !( defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) )
     basicsize = ((PyTypeObject *)result)->tp_basicsize;
     itemsize = ((PyTypeObject *)result)->tp_itemsize;
 #else

{cython-3.1.3 → cython-3.1.5}/Cython/Utility/ModuleSetupCode.c

@@ -1,10 +1,18 @@
 /////////////// InitLimitedAPI ///////////////
 
-#if defined(Py_LIMITED_API) && !defined(CYTHON_LIMITED_API)
+#if defined(Py_LIMITED_API)
+  #if !defined(CYTHON_LIMITED_API)
   // Use Py_LIMITED_API as the main control for Cython's limited API mode.
   // However it's still possible to define CYTHON_LIMITED_API alone to
   // force Cython to use Limited-API code without enforcing it in Python.
   #define CYTHON_LIMITED_API 1
+  #endif
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef _MSC_VER
+  #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.")
+  #else
+  #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.
+  #endif
 #endif
 
 /////////////// CModulePreamble ///////////////
@@ -2397,8 +2405,7 @@ static PyObject* __Pyx_PyCode_New(
         // PyCode_NewEmpty isn't in the limited API. Therefore the two options are
         //  1. Python call of the code type with a long list of positional args.
         //  2. Generate a code object by compiling some trivial code, and customize.
-        // We use the second because it's less sensitive to changes in the code type
-        // constructor with version.
+        // We use the first option here.
         PyObject *exception_table = NULL;
         PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
         #if __PYX_LIMITED_VERSION_HEX < 0x030b0000
@@ -2479,6 +2486,11 @@ static PyObject* __Pyx_PyCode_New(
         PyCode_NewWithPosOnlyArgs
       #endif
         (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, EMPTY(bytes));
+  
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1
+    if (likely(result))
+        result->_co_firsttraceable = 0;
+    #endif
     return result;
   }
 #elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY

{cython-3.1.3 → cython-3.1.5}/Cython/Utility/ObjectHandling.c

@@ -811,7 +811,7 @@ __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
     res = PyTuple_New(n);
     if (unlikely(res == NULL)) return NULL;
     for (i = 0; i < n; i++) {
-        if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < 0)) {
+        if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) {
             Py_DECREF(res);
             return NULL;
         }

{cython-3.1.3 → cython-3.1.5}/Cython/Utility/Optimize.c

@@ -1237,6 +1237,20 @@ static {{c_ret_type}} __Pyx_Unpacked_{{cfunc_name}}(PyObject *op1, PyObject *op2
     PY_LONG_LONG ll{{ival}}, llx;
 #endif
     {{endif}}
+    {{if op == 'Rshift' or op == 'Lshift'}}
+// shifting negative numbers is technically implementation defined on C, and
+// C++ before C++20. Most implementation do the right thing though so
+// special case ones we know are good.
+#if (defined(__cplusplus) && __cplusplus >= 202002L) \
+        || (defined(__GNUC__) || (defined(__clang__))) && \
+            (defined(__arm__) || defined(__x86_64__) || defined(__i386__)) \
+        || (defined(_MSC_VER) && \
+            (defined(_M_ARM) || defined(_M_AMD64) || defined(_M_IX86)))
+    const int negative_shift_works = 1;
+#else
+    const int negative_shift_works = 0;
+#endif
+    {{endif}}
 
     // special cases for 0: + - * % / // | ^ & >> <<
     if (unlikely(__Pyx_PyLong_IsZero({{pyval}}))) {
@@ -1271,10 +1285,8 @@ static {{c_ret_type}} __Pyx_Unpacked_{{cfunc_name}}(PyObject *op1, PyObject *op2
     }
     {{endif}}
 
-    // handle most common case first to avoid indirect branch and optimise branch prediction
-    if (likely(__Pyx_PyLong_IsCompact({{pyval}}))) {
-        {{ival}} = __Pyx_PyLong_CompactValue({{pyval}});
-    } else {
+    // Handle most common case (fits into 'long') first to avoid indirect branch and optimise branch prediction.
+    if (unlikely(!__Pyx_PyLong_CompactAsLong({{pyval}}, &{{ival}}))) {
         const digit* digits = __Pyx_PyLong_Digits({{pyval}});
         const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount({{pyval}});
         switch (size) {
@@ -1348,6 +1360,15 @@ static {{c_ret_type}} __Pyx_Unpacked_{{cfunc_name}}(PyObject *op1, PyObject *op2
                 x = q;
             }
         {{else}}
+             
+            {{if op == 'Rshift' or op == 'Lshift'}}
+            if ((!negative_shift_works) && unlikely(a < 0)) goto fallback;
+            {{endif}}
+            {{if op == 'Rshift'}}
+            if (unlikely(b >= (long) (sizeof(long)*8))) {
+                x = (a < 0) ? -1 : 0;
+            } else
+            {{endif}}
             x = a {{c_op}} b;
             {{if op == 'Lshift'}}
 #ifdef HAVE_LONG_LONG
@@ -1379,6 +1400,14 @@ static {{c_ret_type}} __Pyx_Unpacked_{{cfunc_name}}(PyObject *op1, PyObject *op2
                 llx = q;
             }
         {{else}}
+            {{if op == 'LShift' or op == 'Rshift'}}
+            if ((!negative_shift_works) && unlikely(a < 0)) goto fallback;
+            {{endif}}
+            {{if op == 'Rshift'}}
+            if (unlikely(llb >= (long long) (sizeof(long long)*8))) {
+                llx = (lla < 0) ? -1 : 0;
+            } else
+            {{endif}}
             llx = lla {{c_op}} llb;
             {{if op == 'Lshift'}}
             if (likely(lla == llx >> llb)) /* then execute 'return' below */
@@ -1386,6 +1415,9 @@ static {{c_ret_type}} __Pyx_Unpacked_{{cfunc_name}}(PyObject *op1, PyObject *op2
         {{endif}}
         return PyLong_FromLongLong(llx);
 #endif
+{{if op == 'Lshift' or op == 'Rshift'}}
+  fallback:
+{{endif}}
 
     return __Pyx_Fallback_{{cfunc_name}}(op1, op2, inplace);