Python 3.13: PyThreadState_SetAsyncExc might deliver the exception outside of the thread

[yilei]

Bug report

Bug description:

I have the following naive demo that uses PyThreadState_SetAsyncExc to implement a time-limited interruptible context manager:

import contextlib
import ctypes
import sys
import threading
import time


class Interruptible:
 def __init__(self, seconds: float):
 self.seconds = seconds
 self.finished = False

 def __enter__(self):
 self._thread = threading.Thread(
 target=self._interrupt_in,
 args=(threading.get_ident(), self.seconds),
 daemon=True,
 )
 self._thread.start()
 return self

 def __exit__(self, exc_type, exc_value, traceback):
 self.finished = True

 def _interrupt_in(self, tid: int, seconds: float) -> None:
 time.sleep(self.seconds)
 print(f"Slept for {seconds}")
 if self.finished:
 print("Finished, not interrupting")
 return
 else:
 print("Not finished, interrupting")
 ctypes.pythonapi.PyThreadState_SetAsyncExc(
 ctypes.c_long(tid), ctypes.py_object(TimeoutError)
 )


def busy_loop():
 s = time.monotonic()
 while time.monotonic() - s < 0.5:
 pass


print(f"Python version: {sys.version}")

for i in range(100):
 try:
 with Interruptible(seconds=0.1):
 s = time.monotonic()
 while time.monotonic() - s < 0.5:
 pass
 # NOTE: If we replace above block with the equivalent busy_loop(), it works.
 # busy_loop()
 except TimeoutError:
 print(f"Iteration {i + 1}: ✓ TimeoutError caught")
 else:
 print(f"Iteration {i + 1}: ✗ TimeoutError NOT raised")
 time.sleep(0.01) # Small delay between iterations

In Python 3.13, this might fail with something like:

❯ python /tmp/demo.py
Python version: 3.13.7 (main, Sep 29 2025, 18:42:10) [GCC 11.4.0]
Slept for 0.1
Not finished, interrupting
Iteration 1: ✓ TimeoutError caught
Slept for 0.1
Not finished, interrupting
Iteration 2: ✓ TimeoutError caught
Slept for 0.1
Not finished, interrupting
Iteration 3: ✓ TimeoutError caught
Slept for 0.1
Not finished, interrupting
Iteration 4: ✓ TimeoutError caught
Slept for 0.1
Not finished, interrupting
Traceback (most recent call last):
 File "/tmp/demo.py", line 50, in <module>
 while time.monotonic() - s < 0.5:
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
TimeoutError

Meaning the TimeoutError is raised but not caught by the try/except block. A few other observations:

1. If I wrap the "work" inside the context manager to a wrapper function busy_loop(), it's NOT reproducible.
2. I tested Python 3.11.13, 3.12.11, 3.13.7, and 3.14.0rc3, it is only reproducible in Python 3.13.7.

CPython versions tested on:

3.13, 3.12, 3.14, 3.11

Operating systems tested on:

Linux

[yilei]

One plausible related change in 3.13 is #115194

[Eclips4]

@gpshead FYI, this isn't related to asyncio, though name of this function could be confusing.

[ZeroIntensity]

Bisecting shows that the regressing PR was #106141 and was fixed by #122934, so this appears to be an issue with the eval breaker rather than PyThreadState_SetAsyncExc.

[gpshead]

I'm not sure that PR the bisect shows fixing it was intended to fix this? that might be a side effect of the particular reproducer code vs that change.

[ZeroIntensity]

Yeah, definitely not an intentional fix. I think the problem is that the eval breaker is being checked somewhere it shouldn't (or not being checked somewhere it should), and changing when while statements jump apparently fixed that.

[cjwatson]

I think I'm seeing this in Python 3.14.2 as well, in the test suite of https://github.com/glenfant/stopit. The error is visible in https://bugs.debian.org/1123317. This test looks something like this:

 >>> import threading
 >>> import time
 >>> from stopit import async_raise

 >>> def variable_duration_func(duration):
 ... t0 = time.time()
 ... while True:
 ... dummy = 0
 ... if time.time() - t0 > duration:
 ... break
 >>> exc_traces = []
 >>> def variable_duration_func_handling_exc(duration, exc_traces):
 ... try:
 ... t0 = time.time()
 ... while True:
 ... dummy = 0
 ... if time.time() - t0 > duration:
 ... break
 ... except Exception as exc:
 ... exc_traces.append(exc)

 >>> five_seconds_threads = threading.Thread(
 ... target=variable_duration_func_handling_exc, args=(5.0, exc_traces))
 >>> start_time = time.time()
 >>> five_seconds_threads.start()
 >>> thread_ident = five_seconds_threads.ident
 >>> five_seconds_threads.is_alive()
 True

 >>> async_raise(thread_ident, LookupError)

async_raise calls PyThreadState_SetAsyncExc via ctypes. The same approach suggested in this issue (replacing the body of the try in variable_duration_func_handling_exc with a call to variable_duration_func(duration)) seems to work around it.

Is it possible that something changed between 3.14.0rc3 and 3.14.2 that would have introduced this bug?