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

{async_kernel-0.19.0 → async_kernel-0.19.2}/.github/workflows/ci.yml

@@ -20,7 +20,7 @@ jobs:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v7
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
 
       - name: Type checking with basedpyright
         run: |
@@ -45,7 +45,7 @@ jobs:
         uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v7
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           version-file: "pyproject.toml"
           python-version: ${{ matrix.python-version }}
@@ -70,7 +70,7 @@ jobs:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v7
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           version-file: "pyproject.toml"
           python-version: "3.13"
@@ -99,7 +99,7 @@ jobs:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v7
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           version-file: "pyproject.toml"
 

{async_kernel-0.19.0 → async_kernel-0.19.2}/.github/workflows/new_release.yml

@@ -31,7 +31,7 @@ jobs:
           fetch-depth: 0
           ref: main
       - name: Install uv
-        uses: astral-sh/setup-uv@v7
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           version-file: "pyproject.toml"
 

{async_kernel-0.19.0 → async_kernel-0.19.2}/.github/workflows/publish-docs.yml

@@ -27,7 +27,7 @@ jobs:
           git config user.email 41898282+github-actions[bot]@users.noreply.github.com
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v7
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           version-file: "pyproject.toml"
 

{async_kernel-0.19.0 → async_kernel-0.19.2}/.github/workflows/publish-to-pypi.yml

@@ -31,7 +31,7 @@ jobs:
           # Fetch full history for setuptools-scm
           fetch-depth: 0
           ref: main
-      - uses: astral-sh/setup-uv@v7
+      - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           version-file: "pyproject.toml"
 

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

@@ -5,6 +5,30 @@ 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.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
+
+- Support flags instead of boolean operational action argv syntax. [#475](https://github.com/fleming79/async-kernel/pull/475)
+
+- Remove python verson from default kernelspec. [#474](https://github.com/fleming79/async-kernel/pull/474)
+
+### <!-- 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
 
 ### <!-- 0 --> 🏗️ Breaking changes
@@ -21,6 +45,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### <!-- 6 --> 🌀 Miscellaneous
 
+- Prepare for release v0.19.0 [#472](https://github.com/fleming79/async-kernel/pull/472)
+
 - Bump uv and basedpyright [#470](https://github.com/fleming79/async-kernel/pull/470)
 
 - Add message to task.cancel in task_factory [#461](https://github.com/fleming79/async-kernel/pull/461)
@@ -1309,6 +1335,8 @@ 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
 [0.18.2]: https://github.com/fleming79/async-kernel/compare/v0.18.1..v0.18.2

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-kernel
-Version: 0.19.0
+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.0 → 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.0'
-__version_tuple__ = version_tuple = (0, 19, 0)
+__version__ = version = '0.19.2'
+__version_tuple__ = version_tuple = (0, 19, 2)
 
 __commit_id__ = commit_id = None

{async_kernel-0.19.0 → async_kernel-0.19.2}/hatch_build.py

@@ -22,4 +22,9 @@ class CustomHook(BuildHookInterface):
 
             name = "async"
             spec_folder = here.joinpath("data_kernelspec", name)
-            write_kernel_spec(path=spec_folder, name=name, command=("python", "-m", "async_kernel", "start"))
+            write_kernel_spec(
+                path=spec_folder,
+                name=name,
+                command=("python", "-m", "async_kernel", "start"),
+                display_name=f"Python 3 ({name})",
+            )

{async_kernel-0.19.0 → async_kernel-0.19.2}/src/async_kernel/command.py

@@ -21,17 +21,16 @@ if TYPE_CHECKING:
     __all__ = ["command_line"]
 
 
-def args_to_dict(args: list[str]) -> dict[str, Any]:
+def to_flags_and_settings(args: list[str]) -> tuple[list[str], dict[str, Any]]:
     """
-    Convert `argvs` to a dict.
+    Convert `argvs` to flags and settings.
 
     Args:
         args: A list of arguments, the first of which must start with '-' or '--'.
 
     Notes:
         - There is no distinction made between '-' and '--'.
-        - Flags prefixed with 'no-' are assumed to be binary `False`.
-
+        - Flags are returned without '--' prefix.
     """
 
     def safe_eval(val: str) -> Any:
@@ -43,7 +42,7 @@ def args_to_dict(args: list[str]) -> dict[str, Any]:
     def add(k: str, v: Any) -> None:
         settings[k.strip()] = safe_eval(v)
 
-    settings = {}
+    flags, settings = [], {}
     args = list(args)
     while args:
         k = args.pop(0)
@@ -61,11 +60,10 @@ def args_to_dict(args: list[str]) -> dict[str, Any]:
                 v = settings.get(k, {}) | {a: safe_eval(v)}
                 add(k, v)
             else:
-                add(k, v)
+                add(k, safe_eval(v))
         else:
-            # https://docs.python.org/3/library/argparse.html#argparse.BooleanOptionalAction
-            add(k.removeprefix("no-"), not k.startswith("no-"))
-    return settings
+            flags.append(k)
+    return flags, settings
 
 
 def command_line() -> None:
@@ -189,11 +187,11 @@ Tips:
                 mode = mode_
                 break
 
-    settings = args_to_dict(unknownargs)
+    flags, settings = to_flags_and_settings(unknownargs)
 
     match mode:
         case Mode.install:
-            path = write_kernel_spec(user=args.user, name=args.name, **settings)
+            path = write_kernel_spec(user=args.user, name=args.name, flags=flags, **settings)
             print(f"Installed kernelspec {str(path)!r}")
 
         case Mode.uninstall:
@@ -224,6 +222,7 @@ Tips:
             print("async-kernel", async_kernel.__version__)
         case Mode.start | Mode.help_all | Mode.show_config | Mode.show_config_json:
             launcher: InterfaceStartType = import_launcher(settings.get("launcher", ""))
+            settings["--flags"] = flags
             try:
                 launcher(settings)
             except KeyboardInterrupt:

{async_kernel-0.19.0 → 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.0 → async_kernel-0.19.2}/src/async_kernel/kernelspec.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Iterable
 
     InterfaceStartType = Callable[[dict[str, Any]], Any]
 
@@ -49,6 +49,7 @@ def make_argv(
     name: str = "async",
     launcher: str | InterfaceStartType = DEFAULT_LAUNCHER,
     command: tuple[str, ...] = DEFAULT_COMMAND,
+    flags: Iterable[str] = (),
     **kwargs: Any,
 ) -> list[str]:
     """Returns an argument vector (argv) that can be used to start a `Kernel`.
@@ -68,15 +69,13 @@ def make_argv(
                 - "start_kernel_zmq_interface"
         name: The name to use for the kernel.
         command: The command line command to call.
+        flags: Any number of flags to insert in argv. Flags will be prefixed with '--'.
         **kwargs: Additional settings to pass when creating the kernel passed to `launcher`.
 
     Returns:
         list: A list of command-line arguments to launch the kernel module.
     """
-    argv = [
-        *command,
-        f"--connection_file={connection_file}",
-    ]
+    argv = [*command, f"--connection_file={connection_file}", *(f"--{f.strip('-')}" for f in flags)]
     for k, v in ({"launcher": launcher, "name": name} | kwargs).items():
         argv.append(f"--{k}={v}")
     return list(map(str, argv))
@@ -125,6 +124,7 @@ def write_kernel_spec(
     metadata: dict | None = None,
     language="python",
     resources: Path | None = RESOURCES,
+    flags: Iterable[str] = (),
     **kwargs: Any,
 ) -> Path:
     """
@@ -157,6 +157,8 @@ def write_kernel_spec(
             A mapping of additional attributes to aid the client in kernel selection.
         resources:
             The path to the resources folder to include with the kernel spec.
+        flags:
+            Flags to insert directly into the argv string.
         **kwargs:
             Pass additional settings to set on the instance of the `Kernel` when it is instantiated.
             Each setting should correspond to the dotted path to the attribute relative to the kernel.
@@ -194,6 +196,7 @@ def write_kernel_spec(
             connection_file=connection_file,
             name=name,
             command=command,
+            flags=flags,
             **kwargs,
         )
         spec: dict[str, list[Any] | Any | dict[Any, Any] | str | dict[str, bool]] = {

{async_kernel-0.19.0 → 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