akernel 0.1.1__tar.gz → 0.3.0__tar.gz

akernel-0.3.0/.github/workflows/main.yml

@@ -0,0 +1,48 @@
+name: CI
+
+on:
+  push:
+    branches:
+    - main
+  pull_request:
+    branches:
+    - main
+
+defaults:
+  run:
+    shell: bash -l {0}
+
+jobs:
+  test:
+    name: Test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: [ '3.9', '3.10', '3.11', '3.12', '3.13' ]
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Setup Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install akernel
+      run: |
+        pip install . --group test
+
+    - name: Check style and types
+      run: |
+        ruff check --show-fixes
+        ruff format --check
+        mypy src
+
+    - name: Run tests
+      run: |
+        akernel --help
+        test -f ${pythonLocation}/../share/jupyter/kernels/akernel/kernel.json
+        pytest -v --reruns 5

akernel-0.3.0/.pre-commit-config.yaml

@@ -0,0 +1,7 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.13
+    hooks:
+      - id: ruff-check
+        args: [--fix, --show-fixes]
+      - id: ruff-format

{akernel-0.1.1 → akernel-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: akernel
-Version: 0.1.1
+Version: 0.3.0
 Summary: An asynchronous Python Jupyter kernel
 Project-URL: Homepage, https://github.com/davidbrochart/akernel
 Author-email: David Brochart <david.brochart@gmail.com>
@@ -9,34 +9,25 @@ License-File: LICENSE
 Keywords: jupyter
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.8
-Requires-Dist: click
+Requires-Python: >=3.9
 Requires-Dist: colorama
 Requires-Dist: comm<1,>=0.1.3
-Requires-Dist: gast>=0.5.3
+Requires-Dist: gast<0.7.0,>=0.6.0
 Requires-Dist: python-dateutil
-Requires-Dist: pyzmq
-Requires-Dist: typer>=0.4.0
 Provides-Extra: cache
 Requires-Dist: zict; extra == 'cache'
 Provides-Extra: react
 Requires-Dist: ipyx>=0.1.7; extra == 'react'
-Provides-Extra: test
-Requires-Dist: black; extra == 'test'
-Requires-Dist: ipyx>=0.1.7; extra == 'test'
-Requires-Dist: kernel-driver>=0.0.7; extra == 'test'
-Requires-Dist: mypy; extra == 'test'
-Requires-Dist: pytest; extra == 'test'
-Requires-Dist: pytest-asyncio; extra == 'test'
-Requires-Dist: ruff; extra == 'test'
-Requires-Dist: types-python-dateutil; extra == 'test'
-Requires-Dist: zict; extra == 'test'
+Provides-Extra: subprocess
+Requires-Dist: typer>=0.4.0; extra == 'subprocess'
+Requires-Dist: zmq-anyio<0.4.0,>=0.3.9; extra == 'subprocess'
 Description-Content-Type: text/markdown
 
 [![Build Status](https://github.com/davidbrochart/akernel/workflows/CI/badge.svg)](https://github.com/davidbrochart/akernel/actions)
@@ -45,7 +36,8 @@ Description-Content-Type: text/markdown
 
 # akernel
 
-An asynchronous Python Jupyter kernel, with different flavors:
+A Python Jupyter kernel, with different flavors:
+- concurrent cell execution,
 - reactive programming,
 - cell execution caching,
 - multi-kernel emulation.
@@ -61,11 +53,12 @@ pip install akernel
 You can parameterize akernel's execution mode:
 
 ```bash
-akernel install  # default (async)
+akernel install  # default (chained cell execution mode)
+akernel install concurrent  # concurrent cell execution mode
 akernel install react  # reactive programming mode
 akernel install cache  # cell execution caching  mode
 akernel install multi  # multi-kernel emulation mode
-akernel install cache-multi-react  # you can combine several modes
+akernel install cache-multi-react-concurrent  # you can combine several modes
 ```
 
 ## Motivation
@@ -75,13 +68,28 @@ akernel install cache-multi-react  # you can combine several modes
 This means you can `await` at the top-level, outside of an async function. Unfortunately, this will still
 block the kernel.
 
-akernel changes this behavior by launching each cell in a task.
+akernel changes this behavior by launching each cell in a task. By default, cell tasks are chained, which
+means that a cell will start executing after the previous one is done. You might wonder, is it not the same
+as ipykernel then? Well, not quite. In ipykernel, when an async cell is executing, it also blocks the
+processing of
+[Comm messages](https://jupyter-client.readthedocs.io/en/stable/messaging.html#custom-messages), which
+prevents the kernel from interacting with e.g. JupyterLab widgets (see
+[here](https://github.com/ipython/ipykernel/issues/646) and
+[there](https://github.com/ipython/ipykernel/issues/696)). In akernel, it will not be the case.
 
-akernel now also supports reactive programming, although it is still experimental!
+If you want to go all the way and have cells execute concurrently, you can also do so (see below).
 
 ## Features
 
-### Asynchronous execution
+### Concurrent execution
+
+First, set the concurrent execution mode in order to have async cells execute concurrently
+(you could also do that at install-time with `akernel install concurrent`):
+
+```python
+__unchain_execution__()
+# __chain_execution__()
+```
 
 akernel allows for asynchronous code execution. What this means is that when used in a Jupyter
 notebook, you can run cells concurrently if the code is cooperative. For instance, you can run a

{akernel-0.1.1 → akernel-0.3.0}/README.md

@@ -4,7 +4,8 @@
 
 # akernel
 
-An asynchronous Python Jupyter kernel, with different flavors:
+A Python Jupyter kernel, with different flavors:
+- concurrent cell execution,
 - reactive programming,
 - cell execution caching,
 - multi-kernel emulation.
@@ -20,11 +21,12 @@ pip install akernel
 You can parameterize akernel's execution mode:
 
 ```bash
-akernel install  # default (async)
+akernel install  # default (chained cell execution mode)
+akernel install concurrent  # concurrent cell execution mode
 akernel install react  # reactive programming mode
 akernel install cache  # cell execution caching  mode
 akernel install multi  # multi-kernel emulation mode
-akernel install cache-multi-react  # you can combine several modes
+akernel install cache-multi-react-concurrent  # you can combine several modes
 ```
 
 ## Motivation
@@ -34,13 +36,28 @@ akernel install cache-multi-react  # you can combine several modes
 This means you can `await` at the top-level, outside of an async function. Unfortunately, this will still
 block the kernel.
 
-akernel changes this behavior by launching each cell in a task.
+akernel changes this behavior by launching each cell in a task. By default, cell tasks are chained, which
+means that a cell will start executing after the previous one is done. You might wonder, is it not the same
+as ipykernel then? Well, not quite. In ipykernel, when an async cell is executing, it also blocks the
+processing of
+[Comm messages](https://jupyter-client.readthedocs.io/en/stable/messaging.html#custom-messages), which
+prevents the kernel from interacting with e.g. JupyterLab widgets (see
+[here](https://github.com/ipython/ipykernel/issues/646) and
+[there](https://github.com/ipython/ipykernel/issues/696)). In akernel, it will not be the case.
 
-akernel now also supports reactive programming, although it is still experimental!
+If you want to go all the way and have cells execute concurrently, you can also do so (see below).
 
 ## Features
 
-### Asynchronous execution
+### Concurrent execution
+
+First, set the concurrent execution mode in order to have async cells execute concurrently
+(you could also do that at install-time with `akernel install concurrent`):
+
+```python
+__unchain_execution__()
+# __chain_execution__()
+```
 
 akernel allows for asynchronous code execution. What this means is that when used in a Jupyter
 notebook, you can run cells concurrently if the code is cooperative. For instance, you can run a

{akernel-0.1.1 → akernel-0.3.0}/binder/postBuild

@@ -1,4 +1,5 @@
 #!/bin/bash
 
 python -m pip install -e .
+akernel install
 akernel install react

akernel-0.3.0/examples/concurrency.ipynb

@@ -0,0 +1,127 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1424909b-49ae-4f63-938c-c72cb3f84550",
+   "metadata": {},
+   "source": [
+    "If you execute the three following for-loops, you can see that they are executed concurrently."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "97b4a9c1-6818-404d-9e4f-64569dd9351f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "__unchain_execution__()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "073b08dd-d004-4f94-8522-bfa1002c9694",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(5):\n",
+    "    await asyncio.sleep(1)\n",
+    "    print(f\"{i=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ced9a54-9d08-4cb7-bd57-e68db9b1d7fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for j in range(5):\n",
+    "    await asyncio.sleep(1)\n",
+    "    print(f\"{j=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "98e994bb-caa2-45f7-b35d-a183facb1b72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for k in range(5):\n",
+    "    await asyncio.sleep(1)\n",
+    "    print(f\"{k=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "558b8d22-d221-4ea8-bc25-e261ea491b7d",
+   "metadata": {},
+   "source": [
+    "Now if you execute the three following for-loops, you can see that they are executed one after the other."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "422c2851-f7c8-460c-9544-13c9c8ebfe0b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "__chain_execution__()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21b5428c-9fcf-4150-af59-635deab42833",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(5):\n",
+    "    await asyncio.sleep(1)\n",
+    "    print(f\"{i=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5ee578b3-6b4d-4315-ab17-8c845d740b36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for j in range(5):\n",
+    "    await asyncio.sleep(1)\n",
+    "    print(f\"{j=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16f0146a-fdf8-4fbe-bf37-63b2da2fe1e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for k in range(5):\n",
+    "    await asyncio.sleep(1)\n",
+    "    print(f\"{k=}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (akernel)",
+   "language": "python",
+   "name": "akernel"
+  },
+  "language_info": {
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{akernel-0.1.1 → akernel-0.3.0}/examples/reactivity.ipynb

@@ -257,7 +257,7 @@
   "kernelspec": {
    "display_name": "Python 3 (akernel-react)",
    "language": "python",
-   "name": "akernel"
+   "name": "akernel-react"
   },
   "language_info": {
    "file_extension": ".py",

akernel-0.3.0/plugins/akernel_task/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 David Brochart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

akernel-0.3.0/plugins/akernel_task/README.md

@@ -0,0 +1,3 @@
+# fps-akernel-task
+
+An FPS plugin for the kernel task API.

akernel-0.3.0/plugins/akernel_task/fps_akernel_task/__init__.py

@@ -0,0 +1,6 @@
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("fps_akernel_task")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "unknown"

akernel-0.3.0/plugins/akernel_task/fps_akernel_task/akernel_task.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from anyio import TASK_STATUS_IGNORED, create_task_group, sleep_forever
+from anyio.abc import TaskStatus
+from jupyverse_api.kernel import Kernel as _Kernel
+
+from akernel.kernel import Kernel
+
+
+class AKernelTask(_Kernel):
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+
+    async def start(self, *, task_status: TaskStatus[None] = TASK_STATUS_IGNORED) -> None:
+        async with (
+            create_task_group() as self.task_group,
+            self._to_shell_send_stream,
+            self._to_shell_receive_stream,
+            self._from_shell_send_stream,
+            self._from_shell_receive_stream,
+            self._to_control_send_stream,
+            self._to_control_receive_stream,
+            self._from_control_send_stream,
+            self._from_control_receive_stream,
+            self._to_stdin_send_stream,
+            self._to_stdin_receive_stream,
+            self._from_stdin_send_stream,
+            self._from_stdin_receive_stream,
+            self._from_iopub_send_stream,
+            self._from_iopub_receive_stream,
+        ):
+            self.kernel = Kernel(
+                self._to_shell_receive_stream,
+                self._from_shell_send_stream,
+                self._to_control_receive_stream,
+                self._from_control_send_stream,
+                self._to_stdin_receive_stream,
+                self._from_stdin_send_stream,
+                self._from_iopub_send_stream,
+            )
+            self.task_group.start_soon(self.kernel.start)
+            task_status.started()
+            await sleep_forever()
+
+    async def stop(self) -> None:
+        self.task_group.cancel_scope.cancel()
+
+    async def interrupt(self) -> None:
+        pass

akernel-0.3.0/plugins/akernel_task/fps_akernel_task/main.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from fps import Module
+
+from jupyverse_api.kernel import KernelFactory
+from jupyverse_api.kernels import Kernels
+
+from .akernel_task import AKernelTask
+
+
+class AKernelTaskModule(Module):
+    async def prepare(self) -> None:
+        kernels = await self.get(Kernels)
+        kernels.register_kernel_factory("akernel", KernelFactory(AKernelTask))

akernel-0.3.0/plugins/akernel_task/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fps_akernel_task"
+version = "0.1.0"
+description = "An FPS plugin for the kernel task API"
+keywords = ["jupyter", "server", "fastapi", "plugins"]
+requires-python = ">=3.9"
+dependencies = [
+    "jupyverse-api >=0.10.0,<0.11.0",
+    "anyio",
+]
+
+[[project.authors]]
+name = "David Brochart"
+email = "david.brochart@gmail.com"
+
+[project.readme]
+file = "README.md"
+content-type = "text/markdown"
+
+[project.license]
+text = "MIT"
+
+[project.urls]
+Homepage = "https://github.com/davidbrochart/akernel"
+
+[project.entry-points]
+"fps.modules"       = {akernel_task = "fps_akernel_task.main:AKernelTaskModule"}
+"jupyverse.modules" = {akernel_task = "fps_akernel_task.main:AKernelTaskModule"}

{akernel-0.1.1 → akernel-0.3.0}/pyproject.toml

@@ -4,46 +4,50 @@ build-backend = "hatchling.build"
 
 [project]
 name = "akernel"
-dynamic = ["version"]
+version = "0.3.0"
 description = "An asynchronous Python Jupyter kernel"
 readme = "README.md"
 license = {text = "MIT"}
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 authors = [{name = "David Brochart", email = "david.brochart@gmail.com"}]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
 keywords = [ "jupyter" ]
 dependencies = [
-    "pyzmq",
-    "typer >=0.4.0",
-    "click",
     "python-dateutil",
     "colorama",
-    "gast >=0.5.3",
+    "gast >=0.6.0, <0.7.0",
     "comm >=0.1.3,<1",
 ]
 
-[project.optional-dependencies]
+[dependency-groups]
 test = [
     "mypy",
     "ruff",
-    "black",
     "pytest",
     "pytest-asyncio",
+    "pytest-rerunfailures",
     "types-python-dateutil",
     "kernel_driver >=0.0.7",
     "ipyx >=0.1.7",
     "zict",
 ]
 
+[project.optional-dependencies]
+subprocess = [
+    "zmq-anyio >=0.3.9,<0.4.0",
+    "typer >=0.4.0",
+]
+
 react = [
     "ipyx >=0.1.7",
 ]
@@ -55,14 +59,19 @@ cache = [
 [project.scripts]
 akernel = "akernel.akernel:cli"
 
+[tool.hatch.build.targets.wheel]
+ignore-vcs = true
+packages = ["src/akernel"]
+
 [tool.hatch.build.targets.wheel.shared-data]
 "share/jupyter/kernels/akernel/kernel.json" = "share/jupyter/kernels/akernel/kernel.json"
 
 [project.urls]
 Homepage = "https://github.com/davidbrochart/akernel"
 
-[tool.hatch.version]
-path = "akernel/__init__.py"
-
 [tool.ruff]
 line-length = 100
+exclude = ["examples"]
+
+[tool.uv.sources]
+fps-akernel-task = { workspace = true }

akernel-0.3.0/src/akernel/__init__.py

@@ -0,0 +1,6 @@
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("akernel")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "unknown"