Cython 3.0.9__tar.gz → 3.0.10__tar.gz

Cython-3.0.10/.gitrev

@@ -0,0 +1 @@
+7ae85318297ed306b84ecc72d0279e27090b25f3

{Cython-3.0.9 → Cython-3.0.10}/CHANGES.rst

@@ -2,6 +2,44 @@
 Cython Changelog
 ================
 
+3.0.10 (2024-03-30)
+===================
+
+Bugs fixed
+----------
+
+* Cython generated incorrect self-casts when directly calling final methods of subtypes.
+  Patch by Lisandro Dalcin.  (Github issue :issue:`2747`)
+
+* Internal C names generated from C function signatures could become too long for MSVC.
+  (Github issue :issue:`6052`)
+
+* The ``noexcept`` warnings could be misleading in some cases.
+  Patch by Gonzalo Tornaría.  (Github issue :issue:`6087`)
+
+* The ``@cython.ufunc`` implementation could generate incomplete C code.
+  (Github issue :issue:`6064`)
+
+* The ``libcpp.complex`` declarations could result in incorrect C++ code.
+  Patch by Raffi Enficiaud.  (Github issue :issue:`6037`)
+
+* Several tests were adapted to work with both NumPy 1.x and 2.0.
+  Patch by Matti Picus.  (Github issues :issue:`6076`, :issue:`6100`)
+
+* C compiler warnings when the freelist implementation is disabled (e.g. on PyPy) were fixed.
+  It can now be disabled explicitly with the C macro guard ``CYTHON_USE_FREELISTS=0``.
+  (Github issue :issue:`6099`)
+
+* Some C macro guards for feature flags were missing from the NOGIL Python configuration.
+
+* Some recently added builtins were unconditionally looked up at module import time
+  (if used by user code) that weren't available on all Python versions and could thus
+  fail the import.
+
+* A performance hint regarding exported pxd declarations was improved.
+  (Github issue :issue:`6001`)
+
+
 3.0.9 (2024-03-05)
 ==================
 

{Cython-3.0.9 → Cython-3.0.10}/Cython/Compiler/Code.py

@@ -65,6 +65,16 @@ basicsize_builtins_map = {
 uncachable_builtins = [
     # Global/builtin names that cannot be cached because they may or may not
     # be available at import time, for various reasons:
+    ## Python 3.13+
+    'IncompleteInputError',
+    'PythonFinalizationError',
+    ## Python 3.11+
+    'BaseExceptionGroup',
+    'ExceptionGroup',
+    ## - Py3.10+
+    'aiter',
+    'anext',
+    'EncodingWarning',
     ## - Py3.7+
     'breakpoint',  # might deserve an implementation in Cython
     ## - Py3.4+
@@ -432,7 +442,7 @@ class UtilityCodeBase(object):
             code_string = replace_empty_lines('\n', code_string.strip()) + '\n\n'
         return code_string
 
-    def __str__(self):
+    def __repr__(self):
         return "<%s(%s)>" % (type(self).__name__, self.name)
 
     def get_tree(self, **kwargs):
@@ -486,9 +496,11 @@ class UtilityCode(UtilityCodeBase):
         if self_type is not other_type and not (isinstance(other, self_type) or isinstance(self, other_type)):
             return False
 
+        self_init = getattr(self, 'init', None)
+        other_init = getattr(other, 'init', None)
         self_proto = getattr(self, 'proto', None)
         other_proto = getattr(other, 'proto', None)
-        return (self_proto, self.impl) == (other_proto, other.impl)
+        return (self_init, self_proto, self.impl) == (other_init, other_proto, other.impl)
 
     def none_or_sub(self, s, context):
         """

{Cython-3.0.9 → Cython-3.0.10}/Cython/Compiler/ExprNodes.py

@@ -6495,7 +6495,8 @@ class SimpleCallNode(CallNode):
                             PyrexTypes.write_noexcept_performance_hint(
                                 self.pos, code.funcstate.scope,
                                 function_name=perf_hint_entry.name if perf_hint_entry else None,
-                                void_return=self.type.is_void, is_call=True)
+                                void_return=self.type.is_void, is_call=True,
+                                is_from_pxd=(perf_hint_entry and perf_hint_entry.defined_in_pxd))
                         code.globalstate.use_utility_code(
                             UtilityCode.load_cached("ErrOccurredWithGIL", "Exceptions.c"))
                         exc_checks.append("__Pyx_ErrOccurredWithGIL()")
@@ -6521,18 +6522,7 @@ class SimpleCallNode(CallNode):
                         goto_error = code.error_goto_if(" && ".join(exc_checks), self.pos)
                     else:
                         goto_error = ""
-                    undo_gh2747_hack = False
-                    if (self.function.is_attribute and
-                            self.function.entry and self.function.entry.final_func_cname and
-                            not code.funcstate.scope.is_cpp()
-                            ):
-                        # Hack around https://github.com/cython/cython/issues/2747
-                        # Disable GCC warnings/errors for wrong self casts.
-                        code.putln('#pragma GCC diagnostic ignored "-Wincompatible-pointer-types"')
-                        undo_gh2747_hack = True
                     code.putln("%s%s; %s" % (lhs, rhs, goto_error))
-                    if undo_gh2747_hack:
-                        code.putln("#pragma GCC diagnostic pop")
                 if self.type.is_pyobject and self.result():
                     self.generate_gotref(code)
             if self.has_optional_args:

{Cython-3.0.9 → Cython-3.0.10}/Cython/Compiler/ModuleNode.py

@@ -1546,10 +1546,12 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                     slot_func)
         code.putln("")
         if freelist_size:
+            code.putln("#if CYTHON_USE_FREELISTS")
             code.putln("static %s[%d];" % (
                 scope.parent_type.declaration_code(freelist_name),
                 freelist_size))
             code.putln("static int %s = 0;" % freecount_name)
+            code.putln("#endif")
             code.putln("")
         code.putln(
             "static PyObject *%s(PyTypeObject *t, %sPyObject *a, %sPyObject *k) {" % (
@@ -1579,7 +1581,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                 else:
                     type_safety_check = ' & (int)(!__Pyx_PyType_HasFeature(t, (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))'
                 obj_struct = type.declaration_code("", deref=True)
-                code.putln("#if CYTHON_COMPILING_IN_CPYTHON")
+                code.putln("#if CYTHON_USE_FREELISTS")
                 code.putln(
                     "if (likely((int)(%s > 0) & (int)(t->tp_basicsize == sizeof(%s))%s)) {" % (
                         freecount_name, obj_struct, type_safety_check))
@@ -1820,7 +1822,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                         ' & (int)(!__Pyx_PyType_HasFeature(Py_TYPE(o), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))')
 
                 type = scope.parent_type
-                code.putln("#if CYTHON_COMPILING_IN_CPYTHON")
+                code.putln("#if CYTHON_USE_FREELISTS")
                 code.putln(
                     "if (((int)(%s < %d) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(%s))%s)) {" % (
                         freecount_name,
@@ -3418,6 +3420,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                 scope = cclass_type.scope
                 freelist_name = scope.mangle_internal(Naming.freelist_name)
                 freecount_name = scope.mangle_internal(Naming.freecount_name)
+                code.putln('#if CYTHON_USE_FREELISTS')
                 code.putln("while (%s > 0) {" % freecount_name)
                 code.putln("PyObject* o = (PyObject*)%s[--%s];" % (
                     freelist_name, freecount_name))
@@ -3429,6 +3432,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                 code.putln("if (tp_free) tp_free(o);")
                 code.putln("#endif")
                 code.putln("}")
+                code.putln('#endif')  # CYTHON_USE_FREELISTS
 #        for entry in env.pynum_entries:
 #            code.put_decref_clear(entry.cname,
 #                                  PyrexTypes.py_object_type,
@@ -3931,7 +3935,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                 if entry.func_cname]
             if c_method_entries:
                 for meth_entry in c_method_entries:
-                    cast = meth_entry.type.signature_cast_string()
+                    vtable_type = meth_entry.vtable_type or meth_entry.type
+                    cast = vtable_type.signature_cast_string()
                     code.putln(
                         "%s.%s = %s%s;" % (
                             type.vtable_cname,

{Cython-3.0.9 → Cython-3.0.10}/Cython/Compiler/Nodes.py

@@ -711,6 +711,19 @@ class CFuncDeclaratorNode(CDeclaratorNode):
 
         exc_val = None
         exc_check = 0
+
+        if (env.directives["legacy_implicit_noexcept"]
+                and not return_type.is_pyobject
+                and not self.has_explicit_exc_clause
+                and self.exception_check
+                and visibility != 'extern'):
+            # implicit noexcept, with a warning
+            self.exception_check = False
+            warning(self.pos,
+                    "Implicit noexcept declaration is deprecated."
+                    " Function declaration should contain 'noexcept' keyword.",
+                    level=2)
+
         if self.exception_check == '+':
             env.add_include_file('ios')         # for std::ios_base::failure
             env.add_include_file('new')         # for std::bad_alloc

{Cython-3.0.9 → Cython-3.0.10}/Cython/Compiler/Parsing.py

@@ -3128,9 +3128,7 @@ def p_exception_value_clause(s, is_extern):
                 exc_check = False
             # exc_val can be non-None even if exc_check is False, c.f. "except -1"
             exc_val = p_test(s)
-    if not is_extern and not exc_clause and s.context.legacy_implicit_noexcept:
-        exc_check = False
-        warning(s.position(), "Implicit noexcept declaration is deprecated. Function declaration should contain 'noexcept' keyword.", level=2)
+
     return exc_val, exc_check, exc_clause
 
 c_arg_list_terminators = cython.declare(frozenset, frozenset((

{Cython-3.0.9 → Cython-3.0.10}/Cython/Compiler/PyrexTypes.py

@@ -3496,8 +3496,12 @@ class CFuncType(CType):
         def arg_name_part(arg):
             return "%s%s" % (len(arg.name), punycodify_name(arg.name)) if arg.name else "0"
         arg_names = [ arg_name_part(arg) for arg in self.args ]
-        arg_names = "_".join(arg_names)
+        arg_names = cap_length("_".join(arg_names))
         safe_typename = type_identifier(self, pyrex=True)
+        # Note that the length here is slightly bigger than twice the default cap in
+        # "cap_length" (since the length is capped in both arg_names and the type_identifier)
+        # but since this is significantly shorter than compilers should be able to handle,
+        # that is acceptable.
         to_py_function = "__Pyx_CFunc_%s_to_py_%s" % (safe_typename, arg_names)
 
         for arg in self.args:
@@ -5465,13 +5469,15 @@ def type_identifier_from_declaration(decl, scope = None):
         _type_identifier_cache[key] = safe
     return safe
 
-def cap_length(s, max_prefix=63, max_len=1024):
-    if len(s) <= max_prefix:
+def cap_length(s, max_len=63):
+    if len(s) <= max_len:
         return s
     hash_prefix = hashlib.sha256(s.encode('ascii')).hexdigest()[:6]
     return '%s__%s__etc' % (hash_prefix, s[:max_len-17])
 
-def write_noexcept_performance_hint(pos, env, function_name=None, void_return=False, is_call=False):
+def write_noexcept_performance_hint(pos, env,
+                                    function_name=None, void_return=False, is_call=False,
+                                    is_from_pxd=False):
     if function_name:
         # we need it escaped everywhere we use it
         function_name = "'%s'" % function_name
@@ -5494,6 +5500,9 @@ def write_noexcept_performance_hint(pos, env, function_name=None, void_return=Fa
         solutions.append(
             "Use an 'int' return type on %s to allow an error code to be returned." %
             the_function)
+    if is_from_pxd and not void_return:
+        solutions.append(
+            "Declare any exception value explicitly for functions in pxd files.")
     if len(solutions) == 1:
         msg = "%s %s" % (msg, solutions[0])
     else:

{Cython-3.0.9 → Cython-3.0.10}/Cython/Compiler/Symtab.py

@@ -14,7 +14,7 @@ except ImportError:  # Py3
     import builtins
 
 from ..Utils import try_finally_contextmanager
-from .Errors import warning, error, InternalError
+from .Errors import warning, error, InternalError, performance_hint
 from .StringEncoding import EncodedString
 from . import Options, Naming
 from . import PyrexTypes
@@ -242,6 +242,7 @@ class Entry(object):
     known_standard_library_import = None
     pytyping_modifiers = None
     enum_int_value = None
+    vtable_type = None
 
     def __init__(self, name, cname, type, pos = None, init = None):
         self.name = name
@@ -906,6 +907,17 @@ class Scope(object):
                 elif not in_pxd and entry.defined_in_pxd and type.compatible_signature_with(entry.type):
                     # TODO: check that this was done by a signature optimisation and not a user error.
                     #warning(pos, "Function signature does not match previous declaration", 1)
+
+                    # Cython can't assume anything about cimported functions declared without
+                    # an exception value. This is a performance problem mainly for nogil functions.
+                    if entry.type.nogil and entry.type.exception_value is None and type.exception_value:
+                        performance_hint(
+                            entry.pos,
+                            "No exception value declared for '%s' in pxd file.\n"
+                            "Users cimporting this function and calling it without the gil "
+                            "will always require an exception check.\n"
+                            "Suggest adding an explicit exception value." % entry.name,
+                            self)
                     entry.type = type
                 else:
                     error(pos, "Function signature does not match previous declaration")
@@ -2551,6 +2563,9 @@ class CClassScope(ClassScope):
         if self.parent_type.is_final_type or entry.is_inline_cmethod or self.directives.get('final'):
             entry.is_final_cmethod = True
             entry.final_func_cname = entry.func_cname
+            if not type.is_fused:
+                entry.vtable_type = entry.type
+                entry.type = type
 
         return entry
 

{Cython-3.0.9 → Cython-3.0.10}/Cython/Compiler/Tests/TestTypes.py

@@ -61,9 +61,9 @@ class TestTypeIdentifiers(unittest.TestCase):
             ("const &&&std::vector", "const__fwref__refstd__in_vector"),
             ("const &&std::vector", "const__fwrefstd__in_vector"),
             ("void (*func)(int x, float y)",
-             "975d51__void__lParen__ptrfunc__rParen__lParenint__space_x__comma_float__space_y__rParen__etc"),
+             "975d51__void__lParen__ptrfunc__rParen__lParenint__spac__etc"),
             ("float ** (*func)(int x, int[:] y)",
-             "31883a__float__ptr__ptr__lParen__ptrfunc__rParen__lParenint__space_x__comma_int__lArr__D__rArry__rParen__etc"),
+             "31883a__float__ptr__ptr__lParen__ptrfunc__rParen__lPar__etc"),
         ]
         self._test_escape(function_name, test_data)
 
@@ -73,3 +73,5 @@ class TestTypeIdentifiers(unittest.TestCase):
             escaped_value = escape(declaration)
             self.assertEqual(escaped_value, expected, "%s('%s') == '%s' != '%s'" % (
                 func_name, declaration, escaped_value, expected))
+            # test that the length has been successfully capped
+            self.assertLessEqual(len(escaped_value), 64)

{Cython-3.0.9 → Cython-3.0.10}/Cython/Compiler/Tests/TestUtilityLoad.py

@@ -92,3 +92,21 @@ class TestCythonUtilityLoader(TestTempitaUtilityLoader):
 
     test_load = TestUtilityLoader.test_load
     test_load_tempita = TestTempitaUtilityLoader.test_load
+
+
+class TestUtilityCode(unittest.TestCase):
+    def test_equality(self):
+        c1 = Code.UtilityCode.load("NumpyImportUFunc", "NumpyImportArray.c")
+        c2 = Code.UtilityCode.load("NumpyImportArray", "NumpyImportArray.c")
+        c3 = Code.UtilityCode.load("pyunicode_strlen", "StringTools.c")
+        c4 = Code.UtilityCode.load("pyunicode_from_unicode", "StringTools.c")
+        c5 = Code.UtilityCode.load("IncludeStringH", "StringTools.c")
+        c6 = Code.UtilityCode.load("IncludeCppStringH", "StringTools.c")
+
+        codes = [c1, c2, c3, c4, c5, c6]
+        for m in range(len(codes)):
+            for n in range(len(codes)):
+                if n == m:
+                    self.assertEqual(codes[m], codes[n])
+                else:
+                    self.assertNotEqual(codes[m], codes[n])

{Cython-3.0.9 → Cython-3.0.10}/Cython/Includes/cpython/array.pxd

@@ -169,6 +169,6 @@ cdef inline int extend(array self, array other) except -1:
         PyErr_BadArgument()
     return extend_buffer(self, other.data.as_chars, Py_SIZE(other))
 
-cdef inline void zero(array self):
+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)

{Cython-3.0.9 → Cython-3.0.10}/Cython/Includes/cpython/complex.pxd

@@ -16,11 +16,11 @@ cdef extern from "Python.h":
         cdef Py_complex cval
 
         @property
-        cdef inline double real(self):
+        cdef inline double real(self) noexcept:
             return self.cval.real
 
         @property
-        cdef inline double imag(self):
+        cdef inline double imag(self) noexcept:
             return self.cval.imag
 
     # PyTypeObject PyComplex_Type

{Cython-3.0.9 → Cython-3.0.10}/Cython/Includes/cpython/datetime.pxd

@@ -69,32 +69,32 @@ cdef extern from "datetime.h":
 
     ctypedef extern class datetime.date[object PyDateTime_Date]:
         @property
-        cdef inline int year(self):
+        cdef inline int year(self) noexcept:
             return PyDateTime_GET_YEAR(self)
 
         @property
-        cdef inline int month(self):
+        cdef inline int month(self) noexcept:
             return PyDateTime_GET_MONTH(self)
 
         @property
-        cdef inline int day(self):
+        cdef inline int day(self) noexcept:
             return PyDateTime_GET_DAY(self)
 
     ctypedef extern class datetime.time[object PyDateTime_Time]:
         @property
-        cdef inline int hour(self):
+        cdef inline int hour(self) noexcept:
             return PyDateTime_TIME_GET_HOUR(self)
 
         @property
-        cdef inline int minute(self):
+        cdef inline int minute(self) noexcept:
             return PyDateTime_TIME_GET_MINUTE(self)
 
         @property
-        cdef inline int second(self):
+        cdef inline int second(self) noexcept:
             return PyDateTime_TIME_GET_SECOND(self)
 
         @property
-        cdef inline int microsecond(self):
+        cdef inline int microsecond(self) noexcept:
             return PyDateTime_TIME_GET_MICROSECOND(self)
 
         @property
@@ -102,37 +102,37 @@ cdef extern from "datetime.h":
             return <object>PyDateTime_TIME_GET_TZINFO(self)
 
         @property
-        cdef inline int fold(self):
+        cdef inline int fold(self) noexcept:
             # For Python < 3.6 this returns 0 no matter what
             return PyDateTime_TIME_GET_FOLD(self)
 
     ctypedef extern class datetime.datetime[object PyDateTime_DateTime]:
         @property
-        cdef inline int year(self):
+        cdef inline int year(self) noexcept:
             return PyDateTime_GET_YEAR(self)
 
         @property
-        cdef inline int month(self):
+        cdef inline int month(self) noexcept:
             return PyDateTime_GET_MONTH(self)
 
         @property
-        cdef inline int day(self):
+        cdef inline int day(self) noexcept:
             return PyDateTime_GET_DAY(self)
 
         @property
-        cdef inline int hour(self):
+        cdef inline int hour(self) noexcept:
             return PyDateTime_DATE_GET_HOUR(self)
 
         @property
-        cdef inline int minute(self):
+        cdef inline int minute(self) noexcept:
             return PyDateTime_DATE_GET_MINUTE(self)
 
         @property
-        cdef inline int second(self):
+        cdef inline int second(self) noexcept:
             return PyDateTime_DATE_GET_SECOND(self)
 
         @property
-        cdef inline int microsecond(self):
+        cdef inline int microsecond(self) noexcept:
             return PyDateTime_DATE_GET_MICROSECOND(self)
 
         @property
@@ -140,21 +140,21 @@ cdef extern from "datetime.h":
             return <object>PyDateTime_DATE_GET_TZINFO(self)
 
         @property
-        cdef inline int fold(self):
+        cdef inline int fold(self) noexcept:
             # For Python < 3.6 this returns 0 no matter what
             return PyDateTime_DATE_GET_FOLD(self)
 
     ctypedef extern class datetime.timedelta[object PyDateTime_Delta]:
         @property
-        cdef inline int day(self):
+        cdef inline int day(self) noexcept:
             return PyDateTime_DELTA_GET_DAYS(self)
 
         @property
-        cdef inline int second(self):
+        cdef inline int second(self) noexcept:
             return PyDateTime_DELTA_GET_SECONDS(self)
 
         @property
-        cdef inline int microsecond(self):
+        cdef inline int microsecond(self) noexcept:
             return PyDateTime_DELTA_GET_MICROSECONDS(self)
 
     ctypedef extern class datetime.tzinfo[object PyDateTime_TZInfo]:
@@ -279,7 +279,7 @@ cdef extern from "datetime.h":
 
 # Datetime C API initialization function.
 # You have to call it before any usage of DateTime CAPI functions.
-cdef inline void import_datetime():
+cdef inline void import_datetime() noexcept:
     PyDateTime_IMPORT
 
 # Create date object using DateTime CAPI factory function.
@@ -337,84 +337,84 @@ cdef inline object datetime_tzinfo(object o):
     return <object>PyDateTime_DATE_GET_TZINFO(o)
 
 # Get year of date
-cdef inline int date_year(object o):
+cdef inline int date_year(object o) noexcept:
     return PyDateTime_GET_YEAR(o)
 
 # Get month of date
-cdef inline int date_month(object o):
+cdef inline int date_month(object o) noexcept:
     return PyDateTime_GET_MONTH(o)
 
 # Get day of date
-cdef inline int date_day(object o):
+cdef inline int date_day(object o) noexcept:
     return PyDateTime_GET_DAY(o)
 
 # Get year of datetime
-cdef inline int datetime_year(object o):
+cdef inline int datetime_year(object o) noexcept:
     return PyDateTime_GET_YEAR(o)
 
 # Get month of datetime
-cdef inline int datetime_month(object o):
+cdef inline int datetime_month(object o) noexcept:
     return PyDateTime_GET_MONTH(o)
 
 # Get day of datetime
-cdef inline int datetime_day(object o):
+cdef inline int datetime_day(object o) noexcept:
     return PyDateTime_GET_DAY(o)
 
 # Get hour of time
-cdef inline int time_hour(object o):
+cdef inline int time_hour(object o) noexcept:
     return PyDateTime_TIME_GET_HOUR(o)
 
 # Get minute of time
-cdef inline int time_minute(object o):
+cdef inline int time_minute(object o) noexcept:
     return PyDateTime_TIME_GET_MINUTE(o)
 
 # Get second of time
-cdef inline int time_second(object o):
+cdef inline int time_second(object o) noexcept:
     return PyDateTime_TIME_GET_SECOND(o)
 
 # Get microsecond of time
-cdef inline int time_microsecond(object o):
+cdef inline int time_microsecond(object o) noexcept:
     return PyDateTime_TIME_GET_MICROSECOND(o)
 
 # Get fold of time
-cdef inline int time_fold(object o):
+cdef inline int time_fold(object o) noexcept:
     # For Python < 3.6 this returns 0 no matter what
     return PyDateTime_TIME_GET_FOLD(o)
 
 # Get hour of datetime
-cdef inline int datetime_hour(object o):
+cdef inline int datetime_hour(object o) noexcept:
     return PyDateTime_DATE_GET_HOUR(o)
 
 # Get minute of datetime
-cdef inline int datetime_minute(object o):
+cdef inline int datetime_minute(object o) noexcept:
     return PyDateTime_DATE_GET_MINUTE(o)
 
 # Get second of datetime
-cdef inline int datetime_second(object o):
+cdef inline int datetime_second(object o) noexcept:
     return PyDateTime_DATE_GET_SECOND(o)
 
 # Get microsecond of datetime
-cdef inline int datetime_microsecond(object o):
+cdef inline int datetime_microsecond(object o) noexcept:
     return PyDateTime_DATE_GET_MICROSECOND(o)
 
 # Get fold of datetime
-cdef inline int datetime_fold(object o):
+cdef inline int datetime_fold(object o) noexcept:
     # For Python < 3.6 this returns 0 no matter what
     return PyDateTime_DATE_GET_FOLD(o)
 
 # Get days of timedelta
-cdef inline int timedelta_days(object o):
+cdef inline int timedelta_days(object o) noexcept:
     return (<PyDateTime_Delta*>o).days
 
 # Get seconds of timedelta
-cdef inline int timedelta_seconds(object o):
+cdef inline int timedelta_seconds(object o) noexcept:
     return (<PyDateTime_Delta*>o).seconds
 
 # Get microseconds of timedelta
-cdef inline int timedelta_microseconds(object o):
+cdef inline int timedelta_microseconds(object o) noexcept:
     return (<PyDateTime_Delta*>o).microseconds
 
-cdef inline double total_seconds(timedelta obj):
+cdef inline double total_seconds(timedelta obj) noexcept:
     # Mirrors the "timedelta.total_seconds()" method.
     # Note that this implementation is not guaranteed to give *exactly* the same
     # result as the original method, due to potential differences in floating point rounding.

{Cython-3.0.9 → Cython-3.0.10}/Cython/Includes/cpython/time.pxd

@@ -17,7 +17,7 @@ from libc.time cimport (
 )
 
 
-cdef inline double time() nogil:
+cdef inline double time() noexcept nogil:
     cdef:
         _PyTime_t tic
 

{Cython-3.0.9 → Cython-3.0.10}/Cython/Includes/libcpp/complex.pxd

@@ -8,21 +8,25 @@ cdef extern from "<complex>" namespace "std" nogil:
         # How to make the converting constructor, i.e. convert complex[double]
         # to complex[float]?
 
-        complex[T] operator+(complex[T]&)
-        complex[T] operator-(complex[T]&)
         complex[T] operator+(complex[T]&, complex[T]&)
         complex[T] operator+(complex[T]&, T&)
         complex[T] operator+(T&, complex[T]&)
+
         complex[T] operator-(complex[T]&, complex[T]&)
         complex[T] operator-(complex[T]&, T&)
         complex[T] operator-(T&, complex[T]&)
+
         complex[T] operator*(complex[T]&, complex[T]&)
         complex[T] operator*(complex[T]&, T&)
         complex[T] operator*(T&, complex[T]&)
+
         complex[T] operator/(complex[T]&, complex[T]&)
         complex[T] operator/(complex[T]&, T&)
         complex[T] operator/(T&, complex[T]&)
 
+        complex[T] operator+()
+        complex[T] operator-()
+
         bint operator==(complex[T]&, complex[T]&)
         bint operator==(complex[T]&, T&)
         bint operator==(T&, complex[T]&)
@@ -51,6 +55,7 @@ cdef extern from "<complex>" namespace "std" nogil:
     float imag(float)
 
     T abs[T](complex[T]&)
+
     T arg[T](complex[T]&)
     long double arg(long double)
     double arg(double)
@@ -72,7 +77,7 @@ cdef extern from "<complex>" namespace "std" nogil:
     complex[float] proj(float)
 
     complex[T] polar[T](T&, T&)
-    complex[T] ploar[T](T&)
+    complex[T] polar[T](T&)
 
     complex[T] exp[T](complex[T]&)
     complex[T] log[T](complex[T]&)

{Cython-3.0.9 → Cython-3.0.10}/Cython/Shadow.py

@@ -2,7 +2,7 @@
 from __future__ import absolute_import
 
 # Possible version formats: "3.1.0", "3.1.0a1", "3.1.0a1.dev0"
-__version__ = "3.0.9"
+__version__ = "3.0.10"
 
 try:
     from __builtin__ import basestring