akernel 0.2.0__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.2.0 → akernel-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: akernel
-Version: 0.2.0
+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)
@@ -90,7 +81,7 @@ If you want to go all the way and have cells execute concurrently, you can also
 
 ## 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`):

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

@@ -49,7 +49,7 @@ If you want to go all the way and have cells execute concurrently, you can also
 
 ## 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`):

{akernel-0.2.0 → 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.2.0 → 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.2.0 → 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"

akernel-0.3.0/src/akernel/akernel.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import json
+from typing import cast
+
+import typer
+from anyio import create_memory_object_stream, create_task_group, run, sleep_forever
+
+from .connect import connect_channel
+from .kernel import Kernel
+from .kernelspec import write_kernelspec
+from .message import receive_message, send_message
+
+
+cli = typer.Typer()
+
+
+@cli.command()
+def install(
+    mode: str = typer.Argument("", help="Mode of the kernel to install."),
+    cache_dir: str | None = typer.Option(
+        None, "-c", help="Path to the cache directory, if mode is 'cache'."
+    ),
+):
+    kernel_name = "akernel"
+    if mode:
+        modes = mode.split("-")
+        modes.sort()
+        mode = "-".join(modes)
+        kernel_name += f"-{mode}"
+    display_name = f"Python 3 ({kernel_name})"
+    write_kernelspec(kernel_name, mode, display_name, cache_dir)
+
+
+@cli.command()
+def launch(
+    mode: str = typer.Argument("", help="Mode of the kernel to launch."),
+    cache_dir: str | None = typer.Option(
+        None, "-c", help="Path to the cache directory, if mode is 'cache'."
+    ),
+    connection_file: str | None = typer.Option(None, "-f", help="Path to the connection file."),
+):
+    akernel = AKernel(mode, cache_dir, connection_file)
+    run(akernel.start)
+
+
+class AKernel:
+    def __init__(self, mode, cache_dir, connection_file):
+        self._to_shell_send_stream, self._to_shell_receive_stream = create_memory_object_stream[list[bytes]]()
+        self._from_shell_send_stream, self._from_shell_receive_stream = create_memory_object_stream[list[bytes]]()
+        self._to_control_send_stream, self._to_control_receive_stream = create_memory_object_stream[list[bytes]]()
+        self._from_control_send_stream, self._from_control_receive_stream = create_memory_object_stream[list[bytes]]()
+        self._to_stdin_send_stream, self._to_stdin_receive_stream = create_memory_object_stream[list[bytes]]()
+        self._from_stdin_send_stream, self._from_stdin_receive_stream = create_memory_object_stream[list[bytes]]()
+        self._from_iopub_send_stream, self._from_iopub_receive_stream = create_memory_object_stream[list[bytes]](max_buffer_size=float("inf"))
+        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,
+            mode,
+            cache_dir,
+        )
+        with open(connection_file) as f:
+            connection_cfg = json.load(f)
+        self.kernel.key = cast(str, connection_cfg["key"])
+        self.shell_channel = connect_channel("shell", connection_cfg)
+        self.iopub_channel = connect_channel("iopub", connection_cfg)
+        self.control_channel = connect_channel("control", connection_cfg)
+        self.stdin_channel = connect_channel("stdin", connection_cfg)
+
+    async def start(self) -> None:
+        async with (
+            create_task_group() as tg,
+            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.shell_channel,
+            self.control_channel,
+            self.stdin_channel,
+            self.iopub_channel,
+        ):
+            tg.start_soon(self.kernel.start)
+            tg.start_soon(self.to_shell)
+            tg.start_soon(self.from_shell)
+            tg.start_soon(self.to_control)
+            tg.start_soon(self.from_control)
+            tg.start_soon(self.to_stdin)
+            tg.start_soon(self.from_stdin)
+            tg.start_soon(self.from_iopub)
+            await sleep_forever()
+
+    async def to_shell(self) -> None:
+        while True:
+            msg = await receive_message(self.shell_channel)
+            await self._to_shell_send_stream.send(msg)
+
+    async def from_shell(self) -> None:
+        async for msg in self._from_shell_receive_stream:
+            await send_message(msg, self.shell_channel)
+
+    async def to_control(self) -> None:
+        while True:
+            msg = await receive_message(self.control_channel)
+            await self._to_control_send_stream.send(msg)
+
+    async def from_control(self) -> None:
+        async for msg in self._from_control_receive_stream:
+            await send_message(msg, self.control_channel)
+
+    async def to_stdin(self) -> None:
+        while True:
+            msg = await receive_message(self.stdin_channel)
+            await self._to_stdin_send_stream.send(msg)
+
+    async def from_stdin(self) -> None:
+        async for msg in self._from_stdin_receive_stream:
+            await send_message(msg, self.stdin_channel)
+
+    async def from_iopub(self) -> None:
+        async for msg in self._from_iopub_receive_stream:
+            await send_message(msg, self.iopub_channel)
+
+
+if __name__ == "__main__":
+    cli()

{akernel-0.2.0 → akernel-0.3.0/src}/akernel/cache.py

@@ -1,17 +1,16 @@
+from __future__ import annotations
+
 import os
 import pickle
 import sys
 import zlib
-from typing import Optional
 
 from zict import File, Func, LRU  # type: ignore
 
 
-def cache(cache_dir: Optional[str]):
+def cache(cache_dir: str | None):
     if not cache_dir:
-        cache_dir = os.path.join(
-            sys.prefix, "share", "jupyter", "kernels", "akernel", "cache"
-        )
+        cache_dir = os.path.join(sys.prefix, "share", "jupyter", "kernels", "akernel", "cache")
 
     l4 = File(cache_dir)
     l3 = Func(zlib.compress, zlib.decompress, l4)