fix compatible issues in python 3.14

.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
       fail-fast: false
       matrix:
         os: ['macos-13', 'macos-latest', 'ubuntu-latest', 'windows-latest']
-        python-version: ['3.10', '3.11', '3.12', '3.13']
+        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14.0-rc.3']
     steps:
     - name: Set up the repository
       uses: actions/checkout@v4

pyproject.toml

@@ -30,7 +30,7 @@ classifiers = [
     "Topic :: Software Development :: Debuggers",
 ]
 urls = { Homepage = "https://github.com/sagemath/cysignals" }
-requires-python = ">=3.9,<3.14"
+requires-python = ">=3.9,<3.15"
 
 [project.entry-points.pkg_config]
 cysignals = 'cysignals'

src/conftest.py

@@ -31,6 +31,7 @@ def pytest_collect_file(
             _, module_name = resolve_pkg_root_and_module_name(file_path)
             module = importlib.import_module(module_name)
             # delete __test__ injected by cython, to avoid duplicate tests
-            del module.__test__
+            if hasattr(module, '__test__'):
+                del module.__test__
             return DoctestModule.from_parent(parent, path=file_path)
     return None

src/cysignals/implementation.c

@@ -392,11 +392,10 @@ static void cysigs_interrupt_handler(int sig)
     {
         if (!cysigs.block_sigint && !custom_signal_is_blocked())
         {
-            /* Raise an exception so Python can see it */
-            do_raise_exception(sig);
-
+            /* Jump back to sig_on() (the first one if there is a stack).
+             * The signal number is encoded in the return value of sigsetjmp.
+             * Do NOT call Python code from signal handler! */
 #if !_WIN32
-            /* Jump back to sig_on() (the first one if there is a stack) */
             siglongjmp(trampoline, sig);
 #endif
         }
@@ -449,10 +448,10 @@ static void cysigs_signal_handler(int sig)
         }
 #endif
 
-        /* Raise an exception so Python can see it */
-        do_raise_exception(sig);
+        /* Jump back to sig_on() (the first one if there is a stack).
+         * The signal number is encoded in the return value of sigsetjmp.
+         * Do NOT call Python code from signal handler! */
     #if !_WIN32
-        /* Jump back to sig_on() (the first one if there is a stack) */
         siglongjmp(trampoline, sig);
     #endif
     }

src/cysignals/macros.h

@@ -143,12 +143,22 @@ static inline int _sig_on_prejmp(const char* message, CYTHON_UNUSED const char*
 /*
  * Process the return value of cysetjmp().
  * Return 0 if there was an exception, 1 otherwise.
+ *
+ * This function propagates the signal number naturally via jmpret
+ * (the return value from sigsetjmp/cylongjmp), which is always nonzero
+ * when a signal occurs. This avoids using global state and eliminates
+ * potential desynchronization between the jump return value and any
+ * stored signal number.
  */
 static inline int _sig_on_postjmp(int jmpret)
 {
     if (unlikely(jmpret > 0))
     {
-        /* An exception occurred */
+        /* A signal occurred and we jumped back via longjmp.
+         * jmpret contains the signal number that was passed to siglongjmp.
+         * Now we're back in a safe context (not in signal handler),
+         * so it's safe to call Python code to raise the exception. */
+        do_raise_exception(jmpret);
         _sig_on_recover();
         return 0;
     }

src/cysignals/pselect.pyx

@@ -33,13 +33,31 @@ We wait for a child created using the ``subprocess`` module::
     >>> p.poll()  # p should be finished
     0
 
-Now using the ``multiprocessing`` module::
+Now using the ``multiprocessing`` module with ANY start method::
 
     >>> from cysignals.pselect import PSelecter
-    >>> from multiprocessing import *
-    >>> import time
+    >>> from multiprocessing import get_context
+    >>> import time, sys
+    >>> # Works with any start method - uses process sentinel
+    >>> ctx = get_context()  # Uses default (forkserver on 3.14+, fork on older)
+    >>> with PSelecter() as sel:
+    ...     p = ctx.Process(target=time.sleep, args=(0.5,))
+    ...     p.start()
+    ...     # Monitor process.sentinel instead of SIGCHLD
+    ...     r, w, x, t = sel.pselect(rlist=[p.sentinel], timeout=2)
+    ...     p.is_alive()  # p should be finished
+    False
+
+For SIGCHLD-based monitoring (requires 'fork' on Python 3.14+)::
+
+    >>> import signal
+    >>> def dummy_handler(sig, frame):
+    ...     pass
+    >>> _ = signal.signal(signal.SIGCHLD, dummy_handler)
+    >>> # Use 'fork' method for SIGCHLD to work properly
+    >>> ctx = get_context('fork') if sys.version_info >= (3, 14) else get_context()
     >>> with PSelecter([signal.SIGCHLD]) as sel:
-    ...     p = Process(target=time.sleep, args=(1,))
+    ...     p = ctx.Process(target=time.sleep, args=(0.5,))
     ...     p.start()
     ...     _ = sel.sleep()
     ...     p.is_alive()  # p should be finished
@@ -289,12 +307,14 @@ cdef class PSelecter:
 
         Start a process which will cause a ``SIGCHLD`` signal::
 
-            >>> import time
-            >>> from multiprocessing import *
+            >>> import time, sys
+            >>> from multiprocessing import get_context
             >>> from cysignals.pselect import PSelecter, interruptible_sleep
+            >>> # For SIGCHLD, must use 'fork' on Python 3.14+
+            >>> ctx = get_context('fork') if sys.version_info >= (3, 14) else get_context()
             >>> w = PSelecter([signal.SIGCHLD])
             >>> with w:
-            ...     p = Process(target=time.sleep, args=(0.25,))
+            ...     p = ctx.Process(target=time.sleep, args=(0.25,))
             ...     t0 = time.time()
             ...     p.start()
 
@@ -501,3 +521,66 @@ cdef class PSelecter:
 
         """
         return self.pselect(timeout=timeout)[3]
+
+    def wait_for_process(self, process, timeout=None):
+        """
+        Wait until a multiprocessing.Process exits or timeout occurs.
+
+        This works with ANY multiprocessing start method (fork, spawn, forkserver)
+        by monitoring the process sentinel file descriptor instead of SIGCHLD.
+
+        NOTE: This is POSIX-only. On Windows, use ``multiprocessing.connection.wait()``
+        instead.
+
+        INPUT:
+
+        - ``process`` -- a ``multiprocessing.Process`` object
+
+        - ``timeout`` -- (default: ``None``) a timeout in seconds,
+          where ``None`` stands for no timeout.
+
+        OUTPUT: A boolean which is ``True`` if the call timed out,
+        False if the process exited.
+
+        EXAMPLES:
+
+        Works with any multiprocessing start method::
+
+            >>> from cysignals.pselect import PSelecter
+            >>> from multiprocessing import get_context
+            >>> import time
+            >>> # Use default start method (forkserver on 3.14+)
+            >>> ctx = get_context()
+            >>> sel = PSelecter()
+            >>> p = ctx.Process(target=time.sleep, args=(0.1,))
+            >>> p.start()
+            >>> timed_out = sel.wait_for_process(p, timeout=1)
+            >>> timed_out  # Should be False (process exited)
+            False
+            >>> p.is_alive()
+            False
+
+        Can also be used in a with block::
+
+            >>> with PSelecter() as sel:
+            ...     p = ctx.Process(target=time.sleep, args=(0.1,))
+            ...     p.start()
+            ...     timed_out = sel.wait_for_process(p, timeout=1)
+            >>> timed_out
+            False
+
+        TESTS:
+
+        Timeout case::
+
+            >>> p = ctx.Process(target=time.sleep, args=(10,))
+            >>> p.start()
+            >>> timed_out = sel.wait_for_process(p, timeout=0.1)
+            >>> timed_out  # Should be True (timeout)
+            True
+            >>> p.terminate()
+            >>> p.join()
+
+        """
+        _, _, _, timed_out = self.pselect(rlist=[process.sentinel], timeout=timeout)
+        return timed_out

src/cysignals/signals.pxd

@@ -91,6 +91,7 @@ cdef nogil:
     cysigs_t cysigs "cysigs"
     void _sig_on_interrupt_received "_sig_on_interrupt_received"() noexcept
     void _sig_on_recover "_sig_on_recover"() noexcept
+    void do_raise_exception "do_raise_exception"(int sig) noexcept
     void _sig_off_warning "_sig_off_warning"(const char*, int) noexcept
     void print_backtrace "print_backtrace"() noexcept
 
@@ -99,5 +100,6 @@ cdef inline void __generate_declarations() noexcept:
     cysigs
     _sig_on_interrupt_received
     _sig_on_recover
+    do_raise_exception
     _sig_off_warning
     print_backtrace

src/cysignals/signals.pyx

@@ -25,7 +25,7 @@ See ``tests.pyx`` for extensive tests.
 
 from libc.signal cimport *
 from libc.stdio cimport freopen, stdin
-from cpython.ref cimport Py_XINCREF, Py_CLEAR
+from cpython.ref cimport Py_XINCREF, Py_CLEAR, _Py_REFCNT
 from cpython.exc cimport (PyErr_Occurred, PyErr_NormalizeException,
         PyErr_Fetch, PyErr_Restore)
 from cpython.version cimport PY_MAJOR_VERSION
@@ -56,6 +56,7 @@ cdef extern from "implementation.c":
     void print_backtrace() nogil
     void _sig_on_interrupt_received() nogil
     void _sig_on_recover() nogil
+    void do_raise_exception(int sig) nogil
     void _sig_off_warning(const char*, int) nogil
 
     # Python library functions for raising exceptions without "except"
@@ -360,7 +361,7 @@ cdef void verify_exc_value() noexcept:
     Check that ``cysigs.exc_value`` is still the exception being raised.
     Clear ``cysigs.exc_value`` if not.
     """
-    if cysigs.exc_value.ob_refcnt == 1:
+    if cysigs.exc_value != NULL and _Py_REFCNT(cysigs.exc_value) == 1:
         # No other references => exception is certainly gone
         Py_CLEAR(cysigs.exc_value)
         return
@@ -408,5 +409,5 @@ cdef void verify_exc_value() noexcept:
     # Make sure we still have cysigs.exc_value at all; if this function was
     # called again during garbage collection it might have already been set
     # to NULL; see https://github.com/sagemath/cysignals/issues/126
-    if cysigs.exc_value != NULL and cysigs.exc_value.ob_refcnt == 1:
+    if cysigs.exc_value != NULL and _Py_REFCNT(cysigs.exc_value) == 1:
         Py_CLEAR(cysigs.exc_value)