async-kernel 0.17.0__tar.gz → 0.17.1__tar.gz

{async_kernel-0.17.0 → async_kernel-0.17.1}/.github/workflows/ci.yml

@@ -25,7 +25,7 @@ jobs:
       - name: Type checking with basedpyright
         run: |
           uv sync
-          uvx basedpyright@1.39.2
+          uvx basedpyright@1.39.3
 
   test:
     needs: type-checking
@@ -110,5 +110,5 @@ jobs:
         timeout-minutes: 5
         run: |
           uv sync --group docs
-          uv run async-kernel -a async-docs --shell.timeout=0.1          
+          uv run async-kernel -a async-docs --shell.timeout=1
           uv run mkdocs build -s

{async_kernel-0.17.0 → async_kernel-0.17.1}/.github/workflows/publish-docs.yml

@@ -40,7 +40,7 @@ jobs:
       - name: Install the project
         run: |
           uv sync --group docs
-          uv run async-kernel -a async-docs --shell.timeout=0.1    # The 'async-docs' kernel is specified as the kernel for mkdocs-jupyter
+          uv run async-kernel -a async-docs --shell.timeout=1    # The 'async-docs' kernel is specified as the kernel for mkdocs-jupyter
 
       - name: Version info
         id: version

{async_kernel-0.17.0 → async_kernel-0.17.1}/.pre-commit-config.yaml

@@ -28,12 +28,12 @@ repos:
       - id: check-json5
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.37.0
+    rev: 0.37.1
     hooks:
       - id: check-github-workflows
 
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.8.1
+    rev: v3.8.3
     hooks:
       - id: prettier
         types_or: [yaml, html, json]
@@ -59,7 +59,7 @@ repos:
       - id: python-use-type-annotations
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.6
+    rev: v0.15.11
     hooks:
       - id: ruff-check
         types_or: [python, jupyter]
@@ -68,7 +68,7 @@ repos:
         types_or: [python, jupyter]
 
   - repo: https://github.com/scientific-python/cookie
-    rev: 2026.03.02
+    rev: 2026.04.04
     hooks:
       - id: sp-repo-review
         additional_dependencies: ["repo-review[cli]"]

{async_kernel-0.17.0 → async_kernel-0.17.1}/CHANGELOG.md

@@ -5,7 +5,25 @@ 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.17.0] - 2026-04-20
+## [0.17.1] - 2026-04-23
+
+### <!-- 0 --> 🏗️ Breaking changes
+
+- Drop the tag 'suppress_error'. [#436](https://github.com/fleming79/async-kernel/pull/436)
+
+- BaseKernelInterface refactoring [#434](https://github.com/fleming79/async-kernel/pull/434)
+
+### <!-- 1 --> 🚀 Features
+
+- Add asyncio and trio cell and line magic [#437](https://github.com/fleming79/async-kernel/pull/437)
+
+- Support specifing the thread with cell magic and passing thread options [#435](https://github.com/fleming79/async-kernel/pull/435)
+
+### <!-- 6 --> 🌀 Miscellaneous
+
+- Update pre-commit, uv.lock and basedpyright [#438](https://github.com/fleming79/async-kernel/pull/438)
+
+## [0.17.0] - 2026-04-22
 
 ### <!-- 0 --> 🏗️ Breaking changes
 
@@ -15,6 +33,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Make AsyncInteractiveShell and AsyncInteractiveSubshell easier to subclass. [#430](https://github.com/fleming79/async-kernel/pull/430)
 
+### <!-- 6 --> 🌀 Miscellaneous
+
+- Prepare for release v0.17.0 [#433](https://github.com/fleming79/async-kernel/pull/433)
+
 ## [0.16.4] - 2026-04-15
 
 ### <!-- 2 --> 🐛 Fixes
@@ -1197,6 +1219,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.17.1]: https://github.com/fleming79/async-kernel/compare/v0.17.0..v0.17.1
 [0.17.0]: https://github.com/fleming79/async-kernel/compare/v0.16.4..v0.17.0
 [0.16.4]: https://github.com/fleming79/async-kernel/compare/v0.16.3..v0.16.4
 [0.16.3]: https://github.com/fleming79/async-kernel/compare/v0.16.2..v0.16.3

{async_kernel-0.17.0 → async_kernel-0.17.1}/CONTRIBUTING.md

@@ -25,7 +25,7 @@ Additional steps to build documentation (optional):
 
 ```bash
 uv sync --group docs
-uv run async-kernel -a async-docs --main_shell.timeout=0.1
+uv run async-kernel -a async-docs --main_shell.timeout=1
 ```
 
 ### Running tests
@@ -100,7 +100,7 @@ The 'docs' group specified extra packages are required to build documentation.
 
 ```bash
 uv sync --group docs
-uv run async-kernel -a async-docs --main_shell.timeout=0.1
+uv run async-kernel -a async-docs --main_shell.timeout=1
 ```
 
 #### Test the docs
@@ -114,7 +114,7 @@ uv run mkdocs build -s
     The command:
 
     ```bash
-    uv run async-kernel -a async-docs --main_shell.timeout=0.1
+    uv run async-kernel -a async-docs --main_shell.timeout=1
     ```
 
     Defines a new kernel spec with the name "async-docs" that sets the `shell.timeout` to 100ms.
@@ -145,13 +145,9 @@ Notebooks are included in the documentation by the plugin [mkdocs-jupyter](https
 
 !!! info
 
-    We use the kernel spec named 'async-docs' which has a cell execute timeout of 100ms. This is used
+    We use the kernel spec named 'async-docs' which has a cell execute timeout of 1s. This is used
     to advance execution through long running cells.
 
-    The [suppress-error][async_kernel.typing.Tags.suppress_error] tag is inserted in code cells to enable
-    with generating documentation. The symbol '⚠' is an indicator that the error was suppressed. Normally
-    this is due to the timeout but there is no distinction on the type of error.
-
 #### Useful links
 
 These links are not relevant for docstrings.

{async_kernel-0.17.0 → async_kernel-0.17.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-kernel
-Version: 0.17.0
+Version: 0.17.1
 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.17.0 → async_kernel-0.17.1}/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.17.0'
-__version_tuple__ = version_tuple = (0, 17, 0)
+__version__ = version = '0.17.1'
+__version_tuple__ = version_tuple = (0, 17, 1)
 
 __commit_id__ = commit_id = None

{async_kernel-0.17.0 → async_kernel-0.17.1}/docs/notebooks/caller.ipynb

@@ -233,7 +233,7 @@
    "source": [
     "## Caller methods that return Pending\n",
     "\n",
-    "Pending is like a thread-safe [asyncio.Future](https://docs.python.org/3/library/asyncio-future.html#asyncio.Future) like object to return future results. It was called `Pending` to avoid confusion about differences in functionality to that of `asyncio.Future` and `concurrent.futures.Future`.\n",
+    "Pending is a thread-safe representation of a future result. It was designed to provide thread-safe functionality similar [asyncio.Future](https://docs.python.org/3/library/asyncio-future.html#asyncio.Future) and was named `Pending` to avoid confusion about differences in functionality to that of `asyncio.Future` and `concurrent.futures.Future`.\n",
     "\n",
     "The following functions return a `Pending` object:\n",
     "\n",

{async_kernel-0.17.0 → async_kernel-0.17.1}/docs/notebooks/concurrency.ipynb

@@ -187,10 +187,7 @@
     "editable": true,
     "slideshow": {
      "slide_type": ""
-    },
-    "tags": [
-     "suppress-error"
-    ]
+    }
    },
    "outputs": [],
    "source": [
@@ -223,13 +220,12 @@
      "slide_type": ""
     },
     "tags": [
-     "thread",
-     "suppress-error"
+     "thread"
     ]
    },
    "outputs": [],
    "source": [
-    "# This time we'll use the tag to run the cell in a Thread\n",
+    "# This time we'll use the tag to run the cell in a worker thread\n",
     "await demo()"
    ]
   },
@@ -249,6 +245,160 @@
     "# thread\n",
     "%callers # magic provided by async-kernel"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "11",
+   "metadata": {},
+   "source": [
+    "We can also specify CallerCreateOptions as part of the top line"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# thread name=\"My thread\"\n",
+    "%callers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13",
+   "metadata": {},
+   "source": [
+    "## Asynchronous magic\n",
+    "\n",
+    "Asynchronous line (%) and cell (%%) magic functions are supported. Any line or cell magic that returns an awaitable is awaited before proceeding.\n",
+    "\n",
+    "- **[thread magic](#thread-magic)**\n",
+    "- **[asyncio magic](#specify-the-backend)**\n",
+    "- **[trio magic](#specify-the-backend)**\n",
+    "\n",
+    "### thread magic\n",
+    "\n",
+    "This will run the code in a thread. When no settings are provided a cell worker thread is used.\n",
+    "\n",
+    "#### Comparing thread magic with thread run mode\n",
+    "\n",
+    "- thread magic (`%%thread`) is an asynchronous magic that executes the associated **code** in a separate thread. \n",
+    "- [thread run mode](#run-mode-thread) (`# thread`) instructs the kernel to run the **entire cell** in a separate thread, bypassing the shell execute request queue."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run the magic 'callers' in a caller worker thread.\n",
+    "%thread %callers "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15",
+   "metadata": {},
+   "source": [
+    "To specify a thread (caller) by name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%thread name=\"My executor\" \n",
+    "%callers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17",
+   "metadata": {},
+   "source": [
+    "Many of arguments accepted on `Caller.get` are also supported. Let's use a thread with a trio backend."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%thread name=\"My trio executor\" backend=trio\n",
+    "%callers\n",
+    "\n",
+    "import trio\n",
+    "\n",
+    "await trio.sleep(0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "19",
+   "metadata": {},
+   "source": [
+    "## Specify the backend\n",
+    "\n",
+    "Code that is written for a specific backend ('asyncio' or 'trio') can be run in the same thread with one of the following:\n",
+    "\n",
+    "- Line magic - The code following the magic on the same line is run using the specified backend.\n",
+    "    - `%trio`  \n",
+    "    - `%asyncio`  \n",
+    "\n",
+    "- Cell magic - The code block is run using the specified backend. \n",
+    "    - `%%trio`\n",
+    "    - `%asyncio`\n",
+    "\n",
+    "**Note: trio must be installed for this demo to work.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%asyncio await asyncio.sleep(0) # This code gets run in an asyncio task \n",
+    "%trio await trio.sleep(0) # trio run as line magic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%trio # trio cell magic\n",
+    "\n",
+    "def print_info():\n",
+    "    from aiologic.lowlevel import current_async_library\n",
+    "    print(f\"\"\"\n",
+    "    Kernel backend: {get_ipython().kernel.interface.backend}\n",
+    "    Current backend: { current_async_library()}\n",
+    "    \"\"\")   \n",
+    "\n",
+    "\n",
+    "print_info()\n",
+    "await trio.sleep(0)\n",
+    "\n",
+    "%callers\n",
+    "\n",
+    "%asyncio print_info()\n",
+    "%asyncio %callers\n",
+    "\n",
+    "await trio.sleep(0)"
+   ]
   }
  ],
  "metadata": {

{async_kernel-0.17.0 → async_kernel-0.17.1}/src/async_kernel/asyncshell.py

@@ -19,7 +19,7 @@ from IPython.core.displaypub import DisplayPublisher
 from IPython.core.history import HistoryManager
 from IPython.core.interactiveshell import InteractiveShell
 from IPython.core.interactiveshell import _modified_open as _modified_open_  # pyright: ignore[reportPrivateUsage]
-from IPython.core.magic import Magics, line_cell_magic, line_magic, magics_class
+from IPython.core.magic import Magics, line_cell_magic, line_magic, magics_class, no_var_expand
 from IPython.utils.tokenutil import token_at_cursor
 from jupyter_core.paths import jupyter_runtime_dir
 from traitlets import traitlets
@@ -32,7 +32,7 @@ from async_kernel.common import Fixed, KernelInterrupt, import_item
 from async_kernel.compiler import XCachingCompiler
 from async_kernel.event_loop.run import get_runtime_matplotlib_guis
 from async_kernel.pending import PendingManager
-from async_kernel.typing import Channel, Content, Message, NoValue, Tags
+from async_kernel.typing import Channel, Content, Message, NoValue, RunMode, Tags
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Generator
@@ -402,6 +402,14 @@ class AsyncInteractiveShell(InteractiveShell):
         except TypeError:
             return result
 
+    def transform_cell_async(self, raw_cell: str) -> str:
+        "Transform the cell and substitute magic calls with an awaitable wrapper."
+        return (
+            self.transform_cell(raw_cell)
+            .replace("get_ipython().run_line_magic(", "await get_ipython().run_line_magic_async(")
+            .replace("get_ipython().run_cell_magic(", "await get_ipython().run_cell_magic_async(")
+        )
+
     async def execute_request(
         self,
         code: str = "",
@@ -424,17 +432,11 @@ class AsyncInteractiveShell(InteractiveShell):
         try:
             tags: list[str] = utils.get_tags()
             timeout: float = utils.get_timeout(tags=tags)
-            suppress_error: bool = Tags.suppress_error in tags
             raises_exception: bool = Tags.raises_exception in tags
             stop_on_error_override: bool = Tags.stop_on_error in tags
-            transformed_cell = (
-                self.transform_cell(code)
-                .replace("get_ipython().run_line_magic(", "await get_ipython().run_line_magic_async(")
-                .replace("get_ipython().run_cell_magic(", "await get_ipython().run_cell_magic_async(")
-            )
             if stop_on_error_override:
                 stop_on_error = utils.get_tag_value(Tags.stop_on_error, stop_on_error)
-            elif suppress_error or raises_exception:
+            elif raises_exception:
                 stop_on_error = False
 
             if silent:
@@ -464,7 +466,7 @@ class AsyncInteractiveShell(InteractiveShell):
                             raw_cell=code,
                             store_history=store_history,
                             silent=silent,
-                            transformed_cell=transformed_cell,
+                            transformed_cell=self.transform_cell_async(code),
                             shell_futures=True,
                             cell_id=cell_id,
                         )
@@ -482,7 +484,7 @@ class AsyncInteractiveShell(InteractiveShell):
                     self.events.trigger("post_execute")
                     if not silent:
                         self.events.trigger("post_run_cell", result)
-            if (err) and (suppress_error or (isinstance(err, anyio.get_cancelled_exc_class()) and (timeout != 0))):
+            if (err) and (isinstance(err, anyio.get_cancelled_exc_class()) and (timeout != 0)):
                 # Suppress the error due to either:
                 # 1. tag
                 # 2. timeout
@@ -583,10 +585,6 @@ class AsyncInteractiveShell(InteractiveShell):
 
     @override
     def _showtraceback(self, etype, evalue, stb) -> None:
-        if Tags.suppress_error in utils.get_tags():
-            if msg := utils.get_tag_value(Tags.suppress_error, "⚠"):
-                print(msg)
-            return
         if utils.get_timeout() != 0.0 and etype is anyio.get_cancelled_exc_class():
             etype, evalue, stb = TimeoutError, "Cell execute timeout", []
         self.kernel.interface.iopub_send(
@@ -931,6 +929,7 @@ class KernelMagics(Magics):
         )
         print(f"Current shell:\t{self.shell}\n\n{subshell_list}")
 
+    @no_var_expand
     @line_magic
     async def pip(self, line: str) -> Any | None:
         """Run the pip package manager for the current environment.
@@ -965,6 +964,7 @@ class KernelMagics(Magics):
 
         return None
 
+    @no_var_expand
     @line_magic
     async def uv(self, line) -> None:
         """Run the uv package manager for the current environment.
@@ -979,19 +979,55 @@ class KernelMagics(Magics):
             if process.stderr:
                 tg.start_soon(_forward_transport_stream, process.stderr, sys.stdout)
 
+    @no_var_expand
     @line_cell_magic
-    async def python(self, line: str, cell: str) -> None:
+    async def thread(self, line: str, cell: str | None = None) -> None:
         """
-        Run python code.
+        Run the python code in a caller managed child thread.
 
-        Useful only when the primary language is not Python.
+        Both line and cell magic are supported.
+
+        For cell_magic, [CallerCreateOptions][async_kernel.typing.CallerCreateOptions] can be passed as literals.
+
+        Example:
+            %%thread name="Trio executor" backend=trio
         """
-        shell = SubshellManager.get_shell()
-        cell = cell or line
-        await shell.run_cell_async(
+        shell: AsyncInteractiveShell | AsyncInteractiveSubshell = SubshellManager.get_shell()
+        if cell is None:
+            cell = line
+            options: Any = None
+        else:
+            options = RunMode.line_to_options(line)
+        caller = shell.kernel.caller
+        await (caller.get(**options).call_soon if options else caller.to_thread)(
+            shell.run_cell_async,
             raw_cell=cell,
             store_history=False,
             silent=True,
-            cell_id=utils.get_cell_id(),
-            transformed_cell=shell.transform_cell(cell),
+            cell_id=None,
+            transformed_cell=shell.transform_cell_async(cell),
         )
+
+    async def _call_using_backend(self, backend: Literal["asyncio", "trio"], code: str):
+        shell: AsyncInteractiveShell | AsyncInteractiveSubshell = SubshellManager.get_shell()
+        await Caller().call_using_backend(
+            backend,
+            shell.run_cell_async,
+            raw_cell=code,
+            store_history=False,
+            silent=True,
+            cell_id=None,
+            transformed_cell=shell.transform_cell_async(code),
+        )
+
+    @no_var_expand
+    @line_cell_magic
+    async def asyncio(self, line: str, cell: str | None = None) -> None:
+        ""
+        await self._call_using_backend("asyncio", cell or line)
+
+    @no_var_expand
+    @line_cell_magic
+    async def trio(self, line: str, cell: str | None = None) -> None:
+        ""
+        await self._call_using_backend("trio", cell or line)

{async_kernel-0.17.0 → async_kernel-0.17.1}/src/async_kernel/caller.py

@@ -834,8 +834,7 @@ class Caller(anyio.AsyncContextManagerMixin):
             **kwargs: Keyword arguments to use with `func`.
 
         Notes:
-
-            - **Only use this to execute coroutines that require a specific backend to run in the caller's thread.**
+            **Only use this method to execute coroutines that require a specific backend to run in the caller's thread.**
         """
         return self.schedule_call(func, args, kwargs, None, PendingTracker, Backend(backend))