async-kernel 0.19.1__tar.gz → 0.19.2__tar.gz

{async_kernel-0.19.1 → async_kernel-0.19.2}/CHANGELOG.md

@@ -5,7 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.19.1] - 2026-05-26
+## [0.19.2] - 2026-06-04
+
+### <!-- 0 --> 🏗️ Breaking changes
+
+- Rename methods on the shell to more resemble those on the kerenel. [#477](https://github.com/fleming79/async-kernel/pull/477)
+
+### <!-- 6 --> 🌀 Miscellaneous
+
+- Run do_execute in tasks [#478](https://github.com/fleming79/async-kernel/pull/478)
+
+## [0.19.1] - 2026-05-27
 
 ### <!-- 2 --> 🐛 Fixes
 
@@ -15,6 +25,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### <!-- 6 --> 🌀 Miscellaneous
 
+- Prepare for release v0.19.1 [#476](https://github.com/fleming79/async-kernel/pull/476)
+
 - Bump setup-uv from v7 to v8.1.0. [#473](https://github.com/fleming79/async-kernel/pull/473)
 
 ## [0.19.0] - 2026-05-26
@@ -1323,6 +1335,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Bump the actions group across 1 directory with 2 updates [#3](https://github.com/fleming79/async-kernel/pull/3)
 
+[0.19.2]: https://github.com/fleming79/async-kernel/compare/v0.19.1..v0.19.2
 [0.19.1]: https://github.com/fleming79/async-kernel/compare/v0.19.0..v0.19.1
 [0.19.0]: https://github.com/fleming79/async-kernel/compare/v0.18.3..v0.19.0
 [0.18.3]: https://github.com/fleming79/async-kernel/compare/v0.18.2..v0.18.3

{async_kernel-0.19.1 → async_kernel-0.19.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-kernel
-Version: 0.19.1
+Version: 0.19.2
 Summary: A concurrent python kernel for Jupyter supporting AnyIO, AsyncIO and Trio.
 Project-URL: Homepage, https://fleming79.github.io/async-kernel
 Project-URL: Documentation, https://fleming79.github.io/async-kernel

{async_kernel-0.19.1 → async_kernel-0.19.2}/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.19.1'
-__version_tuple__ = version_tuple = (0, 19, 1)
+__version__ = version = '0.19.2'
+__version_tuple__ = version_tuple = (0, 19, 2)
 
 __commit_id__ = commit_id = None

{async_kernel-0.19.1 → async_kernel-0.19.2}/src/async_kernel/kernel.py

@@ -44,6 +44,7 @@ if TYPE_CHECKING:
     from contextvars import ContextVar
     from types import CoroutineType, FrameType
 
+    from async_kernel.pending import Pending
     from async_kernel.typing import Content, Message
 
 __all__ = ["Kernel", "KernelInterrupt"]
@@ -156,8 +157,10 @@ class Kernel(HasInterface[T_interface_co], LoggingConfigurable, Generic[T_interf
     comm_manager = Fixed(CommManager)
     "Creates [async_kernel.comm.Comm][] instances and maintains a mapping to `comm_id` to `Comm` instances."
 
-    interrupts: Fixed[Self, set[Callable[[], object]]] = Fixed(set)
-    "A set for callbacks to register for calling when `interrupt` is called."
+    active_execute_requests: Fixed[Self, set[Pending[Any]]] = Fixed(set)
+    "A set of active execute requests that gets updated by the shell."
+
+    _interrupt_message = "Kernel interrupted"
 
     _restart = False
     _handler_cache: ClassVar[dict[tuple[str | None, MsgType, Callable], HandlerType]] = {}
@@ -319,17 +322,15 @@ class Kernel(HasInterface[T_interface_co], LoggingConfigurable, Generic[T_interf
             else:
                 os.kill(os.getpid(), signal.SIGINT)
 
-    def interrupt(self) -> None:
+    def do_interrupt(self) -> None:
         """
-        Perform a keyboard interrupt.
+        Interrupt/cancel non-silent active execute requests.
         """
         if (sys.platform != "emscripten") and (not self.debugger.enabled or not self.debugger.stopped_threads):
             self._interrupt_now()
-        while self.interrupts:
-            try:
-                self.interrupts.pop()()
-            except Exception:
-                pass
+        for pen in tuple(self.active_execute_requests):
+            if not pen.metadata.get("kwargs", {}).get("silent", False):
+                pen.cancel(self._interrupt_message)
 
     def _patch_signal(self) -> Callable[[], None]:
 
@@ -541,22 +542,27 @@ class Kernel(HasInterface[T_interface_co], LoggingConfigurable, Generic[T_interf
 
     async def execute_request(self, job: Job[ExecuteContent], /) -> Content:
         """Handle an [execute request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#execute)."""
-        return await self.shell.execute_request(job)
+        return await self.shell.do_execute(
+            cell_id=job["msg"]["metadata"].get("cellId"),
+            received_time=job["received_time"],
+            tags=job["msg"]["metadata"].get("tags", ()),
+            **job["msg"]["content"],  # pyright: ignore[reportArgumentType]
+        )
 
     async def complete_request(self, job: Job[Content], /) -> Content:
         """Handle an [completion request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#completion)."""
-        return await self.shell.do_complete_request(
+        return await self.shell.do_complete(
             code=job["msg"]["content"].get("code", ""), cursor_pos=job["msg"]["content"].get("cursor_pos", 0)
         )
 
     async def is_complete_request(self, job: Job[Content], /) -> Content:
         """Handle an [is_complete request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#code-completeness)."""
-        return await self.shell.is_complete_request(job["msg"]["content"].get("code", ""))
+        return await self.shell.is_complete(job["msg"]["content"].get("code", ""))
 
     async def inspect_request(self, job: Job[Content], /) -> Content:
         """Handle an [inspect request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#introspection)."""
         c = job["msg"]["content"]
-        return await self.shell.inspect_request(
+        return await self.shell.do_inspect(
             code=c.get("code", ""),
             cursor_pos=c.get("cursor_pos", 0),
             detail_level=c.get("detail_level", 0),
@@ -564,7 +570,7 @@ class Kernel(HasInterface[T_interface_co], LoggingConfigurable, Generic[T_interf
 
     async def history_request(self, job: Job[Content], /) -> Content:
         """Handle an [history request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#history)."""
-        return await self.shell.history_request(**job["msg"]["content"])
+        return await self.shell.do_history(**job["msg"]["content"])
 
     async def comm_open(self, job: Job[Content], /) -> None:
         """Handle an [comm open request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#opening-a-comm)."""
@@ -580,7 +586,7 @@ class Kernel(HasInterface[T_interface_co], LoggingConfigurable, Generic[T_interf
 
     async def interrupt_request(self, job: Job[Content], /) -> Content:
         """Handle an [interrupt request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#kernel-interrupt)."""
-        self.interrupt()
+        self.do_interrupt()
         return {}
 
     async def shutdown_request(self, job: Job[Content], /) -> Content:
@@ -624,11 +630,13 @@ class Kernel(HasInterface[T_interface_co], LoggingConfigurable, Generic[T_interf
 
     async def do_complete(self, code: str, cursor_pos: int | None) -> Content:
         "Matches signature of [ipykernel.kernelbase.Kernel.do_complete][]."
-        return await self.shell.do_complete_request(code=code, cursor_pos=cursor_pos)
+        return await self.shell.do_complete(code=code, cursor_pos=cursor_pos)
 
-    async def do_inspect(self, code: str, cursor_pos: int | None, detail_level=0, omit_sections=()) -> Content:
+    async def do_inspect(
+        self, code: str, cursor_pos: int = 0, detail_level: Literal[0, 1] = 0, omit_sections=()
+    ) -> Content:
         "Matches signature of [ipykernel.kernelbase.Kernel.do_inspect][]."
-        return await self.shell.inspect_request(code=code, cursor_pos=cursor_pos)  # pyright: ignore[reportArgumentType]
+        return await self.shell.do_inspect(code=code, cursor_pos=cursor_pos, detail_level=detail_level)
 
     async def do_history(
         self,
@@ -643,7 +651,7 @@ class Kernel(HasInterface[T_interface_co], LoggingConfigurable, Generic[T_interf
         unique=False,
     ) -> Content:
         "Matches signature of [ipykernel.kernelbase.Kernel.do_history][]."
-        return await self.shell.history_request(
+        return await self.shell.do_history(
             output=output,
             raw=raw,
             hist_access_type=hist_access_type,
@@ -655,37 +663,24 @@ class Kernel(HasInterface[T_interface_co], LoggingConfigurable, Generic[T_interf
     async def do_execute(
         self,
         code: str,
-        silent: bool,
+        silent: bool = True,
         store_history: bool = True,
         user_expressions: dict[str, str] | None = None,
         allow_stdin: bool = False,
         *,
         cell_meta: dict[str, Any] | None = None,
         cell_id: str | None = None,
+        **_ignored,
     ) -> Content:
         "Matches signature of [ipykernel.kernelbase.Kernel.do_execute][]."
-        if cell_meta is None:
-            cell_meta = {}
-        if cell_id is not None:
-            cell_meta["cellId"] = cell_id
-        msg = self.parent.msg(
-            "execute_request",
-            content=ExecuteContent(
-                code=code,
-                silent=silent,
-                store_history=store_history,
-                user_expressions=user_expressions or {},
-                allow_stdin=allow_stdin,
-                stop_on_error=False,
-            ),
-            metadata=cell_meta,
+        return await self.shell.do_execute(
+            code=code,
+            silent=silent,
+            store_history=store_history,
+            user_expressions=user_expressions,
+            allow_stdin=allow_stdin,
+            cell_id=cell_id,
         )
-        job: Job[ExecuteContent] = Job(msg=msg, ident=[], received_time=time.monotonic())
-        token = utils._job_var.set(job)  # pyright: ignore[reportPrivateUsage]
-        try:
-            return await self.shell.execute_request(job)
-        finally:
-            utils._job_var.reset(token)  # pyright: ignore[reportPrivateUsage]
 
     def getpass(self, prompt="", stream=None) -> str:
         "Matches signature of [ipykernel.kernelbase.Kernel.getpass][]."

{async_kernel-0.19.1 → async_kernel-0.19.2}/src/async_kernel/shell/base.py

@@ -16,10 +16,10 @@ from async_kernel import utils
 from async_kernel.common import Fixed
 from async_kernel.interface import HasInterface
 from async_kernel.pending import PendingManager
-from async_kernel.typing import ExecuteContent, Job, T_interface_co
+from async_kernel.typing import T_interface_co
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Generator
+    from collections.abc import Callable, Generator, Iterable
 
     from async_kernel import Kernel
     from async_kernel.typing import Content
@@ -207,23 +207,38 @@ class BaseShell(HasInterface[T_interface_co], LoggingConfigurable, Generic[T_int
             content["metadata"] = {}
             self.parent.iopub_send("execute_result", content=content)
 
-    async def execute_request(self, job: Job[ExecuteContent]) -> Content:
-        """Handle an [execute request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#execute)."""
+    async def do_execute(
+        self,
+        code: str = "",
+        *,
+        silent: bool = False,
+        store_history: bool = False,
+        user_expressions: dict[str, str] | None = None,
+        allow_stdin: bool = False,
+        stop_on_error: bool = False,
+        cell_id: str | None = None,
+        received_time: float = 0,
+        tags: Iterable[str] = (),
+        **_ignored,
+    ) -> Content:
+        """
+        Execute code in the shell.
+        """
         raise NotImplementedError
 
-    async def do_complete_request(self, code: str, cursor_pos: int | None = None) -> Content:
-        """Handle an [completion request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#completion)."""
+    async def do_complete(self, code: str, cursor_pos: int | None = None) -> Content:
+        ""
         raise NotImplementedError
 
-    async def is_complete_request(self, code: str) -> Content:
-        """Handle an [is_complete request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#code-completeness)."""
+    async def is_complete(self, code: str) -> Content:
+        ""
         raise NotImplementedError
 
-    async def inspect_request(self, code: str, cursor_pos: int = 0, detail_level: Literal[0, 1] = 0) -> Content:
-        """Handle an [inspect request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#introspection)."""
+    async def do_inspect(self, code: str, cursor_pos: int = 0, detail_level: Literal[0, 1] = 0) -> Content:
+        ""
         raise NotImplementedError
 
-    async def history_request(
+    async def do_history(
         self,
         *,
         output: bool = False,
@@ -237,5 +252,5 @@ class BaseShell(HasInterface[T_interface_co], LoggingConfigurable, Generic[T_int
         unique: bool = False,
         **_ignored,
     ) -> Content:
-        """Handle an [history request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#history)."""
+        ""
         raise NotImplementedError

{async_kernel-0.19.1 → async_kernel-0.19.2}/src/async_kernel/shell/ipshell.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import builtins
 import json
+import math
 import pathlib
 import shlex
 import sys
@@ -15,11 +16,10 @@ import weakref
 from collections.abc import Callable
 from contextlib import contextmanager
 from sqlite3 import OperationalError
-from typing import TYPE_CHECKING, Any, Literal, Never, Self, TextIO, cast
+from typing import TYPE_CHECKING, Any, Literal, Never, Self, TextIO
 
 import anyio
 import IPython.core.release
-from aiologic.lowlevel import async_checkpoint
 from anyio.streams.text import TextReceiveStream
 from IPython.core.completer import provisionalcompleter, rectify_completions
 from IPython.core.displayhook import DisplayHook
@@ -46,10 +46,10 @@ from async_kernel.compiler import XCachingCompiler
 from async_kernel.event_loop.run import get_runtime_matplotlib_guis
 from async_kernel.interface.base import BaseInterface, HasInterface
 from async_kernel.shell.base import BaseShell
-from async_kernel.typing import Content, ExecuteContent, Job, RunMode, Tags
+from async_kernel.typing import Content, RunMode, Tags
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Iterable
     from types import CodeType
 
     from anyio.abc import ByteReceiveStream
@@ -379,7 +379,7 @@ class IPShell(BaseShell, InteractiveShell):  # pyright: ignore[reportUnsafeMulti
     tempdirs = Fixed(list, mode="ignore")
 
     _main_mod_cache = Fixed(dict)
-    _stop_on_error_pool: Fixed[Self, set[Callable[[], object]]] = Fixed(set)
+    _stop_on_error_pool: Fixed[Self, set[Pending[Any]]] = Fixed(set)
 
     # Disabled attributes
     loop_runner_map = None
@@ -641,106 +641,120 @@ class IPShell(BaseShell, InteractiveShell):  # pyright: ignore[reportUnsafeMulti
         )
 
     @override
-    async def execute_request(self, job: Job[ExecuteContent]) -> Content:
-        """Handle an [execute request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#execute)."""
-
-        content = cast("ExecuteContent", job["msg"]["content"])
-        code = content["code"]
-        silent = content.get("silent", False)
-        cell_id = job["msg"]["metadata"].get("cellId")
-        stop_on_error = content.get("stop_on_error", False)
+    async def run_cell_async(
+        self,
+        raw_cell: str,
+        store_history=False,
+        silent=False,
+        shell_futures=True,
+        *,
+        transformed_cell: str | None = None,
+        preprocessing_exc_tuple: Any = None,
+        cell_id=None,
+    ) -> ExecutionResult:
+        token = utils._cell_id_var.set(cell_id)  # pyright: ignore[reportPrivateUsage]
+        result = None
+        try:
+            result = await super().run_cell_async(
+                raw_cell=raw_cell,
+                store_history=store_history,
+                silent=silent,
+                shell_futures=shell_futures,
+                transformed_cell=transformed_cell,
+                preprocessing_exc_tuple=preprocessing_exc_tuple,
+                cell_id=cell_id,
+            )
+            return result  # noqa: RET504
+        finally:
+            self.events.trigger("post_execute")
+            if not silent:
+                self.events.trigger("post_run_cell", result)
+            utils._cell_id_var.reset(token)  # pyright: ignore[reportPrivateUsage]
 
-        if (job["received_time"] < self._stop_on_error_info.get("time", 0)) and not silent:
+    @override
+    async def do_execute(
+        self,
+        code: str = "",
+        *,
+        silent: bool = False,
+        store_history: bool = False,
+        user_expressions: dict[str, str] | None = None,
+        allow_stdin: bool = False,
+        stop_on_error: bool = False,
+        cell_id: str | None = None,
+        received_time: float = 0,
+        tags: Iterable[str] = (),
+        **_ignored,
+    ) -> Content:
+        """
+        Execute code in the shell's user_ns and global_ns.
+        """
+        if received_time > 0 and (received_time < self._stop_on_error_info.get("time", 0)) and not silent:
             return utils.error_to_content(RuntimeError("Aborting due to prior exception")) | {
                 "execution_count": self._stop_on_error_info.get("execution_count", 0)
             }
-        token = utils._cell_id_var.set(cell_id)  # pyright: ignore[reportPrivateUsage]
+        if math.isnan(timeout := utils.get_tag_value(Tags.timeout, math.nan, tags=tags)):
+            timeout = self.timeout
+
+        if Tags.stop_on_error in tags:
+            stop_on_error = utils.get_tag_value(Tags.stop_on_error, stop_on_error, tags=tags)
+        elif Tags.raises_exception in tags or timeout:
+            stop_on_error = False
+
+        if silent:
+            execution_count: int = self.execution_count
+        else:
+            execution_count = self._execution_count = self._execution_count + 1
+            self.parent.iopub_send(
+                msg_or_type="execute_input",
+                content={"code": code, "execution_count": execution_count},
+                ident=b"kernel.execute_input",
+            )
+
+        pen = Caller().call_soon(
+            self.run_cell_async,
+            raw_cell=code,
+            store_history=store_history,
+            silent=silent,
+            transformed_cell=self.transform_cell_async(code),
+            shell_futures=True,
+            cell_id=cell_id,
+        )
+        err = result = None
         try:
-            tags: list[str] = utils.get_tags()
-            timeout: float = utils.get_timeout(tags=tags)
-            raises_exception: bool = Tags.raises_exception in tags
-            stop_on_error_override: bool = Tags.stop_on_error in tags
-            if stop_on_error_override:
-                stop_on_error = utils.get_tag_value(Tags.stop_on_error, stop_on_error)
-            elif raises_exception:
-                stop_on_error = False
-
-            if silent:
-                execution_count: int = self.execution_count
-            else:
-                execution_count = self._execution_count = self._execution_count + 1
-                self.parent.iopub_send(
-                    msg_or_type="execute_input",
-                    content={"code": code, "execution_count": execution_count},
-                    ident=b"kernel.execute_input",
-                )
-            caller = Caller()
-            err = None
-            result = None
-            with anyio.CancelScope() as scope:
-
-                def cancel():
-                    if not silent:
-                        caller.call_direct(scope.cancel, "Interrupted")
-
-                try:
-                    self.kernel.interrupts.add(cancel)
-                    if stop_on_error:
-                        self._stop_on_error_pool.add(cancel)
-                    with anyio.fail_after(delay=timeout or None):
-                        result = await self.run_cell_async(
-                            raw_cell=code,
-                            store_history=content.get("store_history", False),
-                            silent=silent,
-                            transformed_cell=self.transform_cell_async(code),
-                            shell_futures=True,
-                            cell_id=cell_id,
-                        )
-                except (Exception, anyio.get_cancelled_exc_class()) as e:
-                    # A safeguard to catch exceptions not caught by the shell.
-                    if utils.LAUNCHED_BY_DEBUGPY_PYTEST:
-                        raise
-                    err = KernelInterrupt() if self.parent.last_interrupt_frame else e
-                else:
-                    err = result.error_before_exec or result.error_in_exec if result else KernelInterrupt()
-                    if not err and Tags.raises_exception in tags:
-                        msg = "An expected exception was not raised!"
-                        err = RuntimeError(msg)
-                finally:
-                    self._stop_on_error_pool.discard(cancel)
-                    self.kernel.interrupts.discard(cancel)
-                    self.events.trigger("post_execute")
-                    if not silent:
-                        self.events.trigger("post_run_cell", result)
-            if (err) and (isinstance(err, anyio.get_cancelled_exc_class()) and (timeout != 0)):
-                # Suppress the error due to either:
-                # 1. tag
-                # 2. timeout
-                err = None
-            content = {
-                "status": "error" if err else "ok",
-                "execution_count": execution_count,
-                "user_expressions": self.user_expressions(content.get("user_expressions", {})),
-            }
-            if err:
-                content |= utils.error_to_content(err)
-                if (not silent) and stop_on_error:
-                    with anyio.CancelScope(shield=True):
-                        await async_checkpoint(force=True)
-                        self._stop_on_error_info["time"] = time.monotonic() + float(self.stop_on_error_time_offset)
-                        self._stop_on_error_info["execution_count"] = execution_count
-                        self.log.info("An error occurred in a non-silent execution request")
-                        if stop_on_error:
-                            for c in frozenset(self._stop_on_error_pool):
-                                c()
-                                await async_checkpoint(force=True)
-            return content
-        finally:
-            utils._cell_id_var.reset(token)  # pyright: ignore[reportPrivateUsage]
+            self.kernel.active_execute_requests.add(pen)
+            pen.add_done_callback(self.kernel.active_execute_requests.discard)
+            if stop_on_error:
+                self._stop_on_error_pool.add(pen)
+                pen.add_done_callback(self._stop_on_error_pool.discard)
+            result = await pen.wait(timeout=timeout or None)
+        except Exception as e:
+            err = KernelInterrupt() if str(e) == self.kernel._interrupt_message else e  # pyright: ignore[reportPrivateUsage]
+        else:
+            err = result.error_before_exec or result.error_in_exec if result else KernelInterrupt()
+            if not err and Tags.raises_exception in tags:
+                msg = "An expected exception was not raised!"
+                err = RuntimeError(msg)
+
+        content = {
+            "status": "error" if err else "ok",
+            "execution_count": execution_count,
+            "user_expressions": self.user_expressions(user_expressions if user_expressions is not None else {}),
+        }
+        if err:
+            content |= utils.error_to_content(err)
+            if (not silent) and stop_on_error:
+                self._stop_on_error_info["time"] = time.monotonic() + float(self.stop_on_error_time_offset)
+                self._stop_on_error_info["execution_count"] = execution_count
+                self.log.info("An error occurred in %s %s", self, pen)
+                if stop_on_error:
+                    for pen in tuple(self._stop_on_error_pool):
+                        pen.cancel("Stop on error cancellation")
+        return content
 
     @override
-    async def do_complete_request(self, code: str, cursor_pos: int | None = None) -> Content:
-        """Handle an [completion request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#completion)."""
+    async def do_complete(self, code: str, cursor_pos: int | None = None) -> Content:
+        ""
 
         cursor_pos = cursor_pos or len(code)
         with provisionalcompleter():
@@ -767,8 +781,8 @@ class IPShell(BaseShell, InteractiveShell):  # pyright: ignore[reportUnsafeMulti
         }
 
     @override
-    async def is_complete_request(self, code: str) -> Content:
-        """Handle an [is_complete request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#code-completeness)."""
+    async def is_complete(self, code: str) -> Content:
+        ""
         status, indent_spaces = self.input_transformer_manager.check_complete(code)
         content = {"status": status}
         if status == "incomplete":
@@ -776,8 +790,8 @@ class IPShell(BaseShell, InteractiveShell):  # pyright: ignore[reportUnsafeMulti
         return content
 
     @override
-    async def inspect_request(self, code: str, cursor_pos: int = 0, detail_level: Literal[0, 1] = 0) -> Content:
-        """Handle an [inspect request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#introspection)."""
+    async def do_inspect(self, code: str, cursor_pos: int = 0, detail_level: Literal[0, 1] = 0) -> Content:
+        ""
         content = {"data": {}, "metadata": {}, "found": True}
         try:
             oname = token_at_cursor(code, cursor_pos)
@@ -788,7 +802,7 @@ class IPShell(BaseShell, InteractiveShell):  # pyright: ignore[reportUnsafeMulti
         return content
 
     @override
-    async def history_request(
+    async def do_history(
         self,
         *,
         output: bool = False,
@@ -802,7 +816,7 @@ class IPShell(BaseShell, InteractiveShell):  # pyright: ignore[reportUnsafeMulti
         unique: bool = False,
         **_ignored,
     ) -> Content:
-        """Handle an [history request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#history)."""
+        ""
         history_manager = self.history_manager
         assert history_manager
         match hist_access_type:
@@ -818,7 +832,7 @@ class IPShell(BaseShell, InteractiveShell):  # pyright: ignore[reportUnsafeMulti
 
     @override
     def _showtraceback(self, etype, evalue, stb) -> None:
-        if utils.get_timeout() != 0.0 and etype is anyio.get_cancelled_exc_class():
+        if self.timeout != 0.0 and etype is anyio.get_cancelled_exc_class():
             etype, evalue, stb = TimeoutError, "Cell execute timeout", []
         if isinstance(evalue, KernelInterrupt):
             stb = []

{async_kernel-0.19.1 → async_kernel-0.19.2}/src/async_kernel/utils.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import math
 import sys
 import threading
 import traceback
@@ -13,15 +12,14 @@ from traitlets import traitlets
 from typing_extensions import TypeVar
 
 import async_kernel.interface
-from async_kernel.typing import Tags
 
 if TYPE_CHECKING:
-    from collections.abc import Generator, Mapping
+    from collections.abc import Generator, Iterable, Mapping
     from contextlib import _SupportsRedirect, _SupportsRedirectT  # pyright: ignore[reportPrivateUsage]
 
     from async_kernel.kernel import Kernel
     from async_kernel.shell import BaseShell
-    from async_kernel.typing import Content, Job, Message
+    from async_kernel.typing import Content, Job, Message, Tags
 
 __all__ = [
     "apply_settings",
@@ -34,7 +32,6 @@ __all__ = [
     "get_subshell_id",
     "get_tag_value",
     "get_tags",
-    "get_timeout",
     "mark_thread_pydev_do_not_trace",
     "redirect_stderr",
     "redirect_stdout",
@@ -134,7 +131,7 @@ def get_cell_id(job: Job | None = None, /) -> str | None:
 _TagType = TypeVar("_TagType", str, float, int, bool)
 
 
-def get_tag_value(tag: Tags, default: _TagType, /, *, tags: list[str] | None = None) -> _TagType:
+def get_tag_value(tag: Tags, default: _TagType, /, *, tags: Iterable[str] | None = None) -> _TagType:
     """
     Get the value for the tag from a collection of tags.
 
@@ -158,13 +155,6 @@ def get_tag_value(tag: Tags, default: _TagType, /, *, tags: list[str] | None = N
     return default
 
 
-def get_timeout(*, tags: list[str] | None = None) -> float:
-    "Gets the timeout from tags or using the current context."
-    if math.isnan(timeout := get_tag_value(Tags.timeout, math.nan, tags=tags)):
-        return get_kernel().shell.timeout
-    return max(timeout, 0.0)
-
-
 def setattr_nested(obj: object, name: str, value: str | Any, *, _return_value=False) -> dict[str, Any]:
     """
     Replace an existing nested attribute/trait of an object.

{async_kernel-0.19.1 → async_kernel-0.19.2}/tests/test_callable_interface.py

@@ -12,6 +12,7 @@ import async_kernel
 from async_kernel.compat.json import pack_json_str, unpack_json
 from async_kernel.interface import start_kernel_callable_interface
 from async_kernel.interface.callable import CallableInterface
+from tests import utils
 
 if TYPE_CHECKING:
     from async_kernel.typing import Message
@@ -92,3 +93,24 @@ class TestCallableInterface:
     async def test_keyboard_interrupt(self, interface) -> None:
         with pytest.raises(KeyboardInterrupt):
             signal.raise_signal(signal.SIGINT)
+
+    async def test_kernel_interrupt_pending(self, interface: CallableInterface):
+        interface.kernel.shell.user_ns["ready_event"] = ready = Event()
+        code = "ready_event.set()\nimport anyio\nawait anyio.sleep_forever()"
+        pen = interface.kernel.caller.call_soon(interface.kernel.do_execute, code, silent=False)
+        await ready
+        interface.kernel.do_interrupt()
+        result = await pen
+        assert result
+
+    async def test_kernel_interrupt_keyboard(self, interface: CallableInterface):
+        interface.kernel.shell.user_ns["ready_event"] = ready = Event()
+
+        async def run_code():
+            code = f"ready_event.set()\nimport time\ntime.sleep({utils.TIMEOUT * 2})"
+            pen = interface.kernel.caller.call_soon(interface.kernel.do_execute, code, silent=False)
+            await ready
+            interface.kernel.do_interrupt()
+            await pen.wait(result=False)
+
+        await interface.kernel.caller.to_thread(run_code)

{async_kernel-0.19.1 → async_kernel-0.19.2}/tests/test_kernel_ipshell.py

@@ -38,14 +38,9 @@ async def test_execute_shell_timeout(client: AsyncKernelClient, kernel: Kernel,
     last_stop_time = kernel.shell._stop_on_error_info
     try:
         code = "\n".join(["import anyio", "await anyio.sleep_forever()"])
-        msg_id, content = await utils.execute(client, code=code, metadata=metadata, clear_pub=False)
+        _, content = await utils.execute(client, code=code, metadata=metadata, clear_pub=False)
         assert last_stop_time == kernel.shell._stop_on_error_info, "Should not cause cancellation"
-        assert content["status"] == "ok"
-        await utils.check_pub_message(client, msg_id, execution_state="busy")
-        await utils.check_pub_message(client, msg_id, msg_type="execute_input")
-        expected = {"traceback": [], "ename": "TimeoutError", "evalue": "Cell execute timeout"}
-        await utils.check_pub_message(client, msg_id, msg_type="error", **expected)
-        await utils.check_pub_message(client, msg_id, execution_state="idle")
+        assert content["status"] == "error"
     finally:
         kernel.shell.timeout = 0.0
 
@@ -88,7 +83,7 @@ async def test_save_history(client: AsyncKernelClient, tmp_path):
         ("%%timeit\na\n\n", "complete"),
     ],
 )
-async def test_is_complete(client: AsyncKernelClient, code: str, status: str):
+async def test_is_complete_2(client: AsyncKernelClient, code: str, status: str):
     # There are more test cases for this in core - here we just check
     # that the kernel exposes the interface correctly.
     client.is_complete(code)

{async_kernel-0.19.1 → async_kernel-0.19.2}/tests/test_message_spec.py

@@ -141,7 +141,7 @@ async def test_execute_stop_on_error_task(client: AsyncKernelClient):
     assert content.get("status") == "error"
     assert "ValueError" in "".join(content["traceback"])
     content = await utils.get_shell_message(client, msg_id_1, "execute_reply")
-    assert "await anyio.sleep_forever()" in "".join(content["traceback"])
+    assert "Stop on error cancellation" in "".join(content["traceback"])
 
 
 async def test_user_expressions(client: AsyncKernelClient):

{async_kernel-0.19.1 → async_kernel-0.19.2}/tests/test_zmq_interface.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 import pathlib
-import threading
 from typing import TYPE_CHECKING, Any, Literal
 
 import anyio
 import pytest
 
+from async_kernel import Pending
 from async_kernel.interface.zmq import ZMQInterface
 from async_kernel.typing import MsgType
 from tests import utils
@@ -87,12 +87,12 @@ async def test_input(
 
 
 async def test_interrupt_request(client: AsyncKernelClient, kernel: Kernel):
-    event = threading.Event()
-    kernel.interrupts.add(event.set)
+    pen: Any = Pending()
+    kernel.active_execute_requests.add(pen)
     reply = await utils.send_control_message(client, MsgType.interrupt_request)
     assert reply["header"]["msg_type"] == "interrupt_reply"
     assert reply["content"] == {"status": "ok"}
-    assert event
+    assert pen.cancelled()
 
 
 async def test_interrupt_request_async_request(subprocess_kernels_client: AsyncKernelClient):