Again

Author: davidbrochart

.github/workflows/main.yml

@@ -20,7 +20,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: [ '3.9', '3.10', '3.11', '3.12', '3.13' ]
+        python-version: [ '3.10', '3.11', '3.12', '3.13', '3.14' ]
 
     steps:
     - name: Checkout

plugins/akernel_task/fps_akernel_task/main.py

@@ -17,10 +17,14 @@ def __init__(self, *args, execute_in_thread: bool = False, **kwargs) -> None:
 
     async def prepare(self) -> None:
         kernels = await self.get(Kernels)
-        kernels.register_kernel_factory("akernel", KernelFactory(partial(AKernelTask, execute_in_thread=self.execute_in_thread)))
+        kernels.register_kernel_factory(
+            "akernel", KernelFactory(partial(AKernelTask, execute_in_thread=self.execute_in_thread))
+        )
 
 
 class AKernelThreadTaskModule(Module):
     async def prepare(self) -> None:
         kernels = await self.get(Kernels)
-        kernels.register_kernel_factory("akernel-thread", KernelFactory(partial(AKernelTask, execute_in_thread=True)))
+        kernels.register_kernel_factory(
+            "akernel-thread", KernelFactory(partial(AKernelTask, execute_in_thread=True))
+        )

pyproject.toml

@@ -8,16 +8,16 @@ version = "0.3.4"
 description = "An asynchronous Python Jupyter kernel"
 readme = "README.md"
 license = {text = "MIT"}
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 authors = [{name = "David Brochart", email = "david.brochart@gmail.com"}]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Programming Language :: Python",
-    "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 :: 3.14",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]

src/akernel/akernel.py

@@ -56,13 +56,27 @@ def launch(
 
 class AKernel:
     def __init__(self, mode, cache_dir, connection_file, execute_in_thread):
-        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._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,

src/akernel/code.py

@@ -151,7 +151,7 @@ def get_async_code(self) -> str:
 
     def get_async_bytecode(self) -> CodeType:
         tree = self.get_async_ast()
-        #tree = gast.gast_to_ast(gtree)
+        # tree = gast.gast_to_ast(gtree)
         bytecode = compile(tree, filename="<string>", mode="exec")
         return bytecode
 

src/akernel/kernel.py

@@ -7,7 +7,16 @@
 from contextvars import ContextVar
 from typing import Dict, Any, List, Awaitable
 
-from anyio import Event, create_memory_object_stream, create_task_group, from_thread, get_cancelled_exc_class, run, sleep, to_thread
+from anyio import (
+    Event,
+    create_memory_object_stream,
+    create_task_group,
+    from_thread,
+    get_cancelled_exc_class,
+    run,
+    sleep,
+    to_thread,
+)
 import comm  # type: ignore
 from akernel.comm.manager import CommManager
 from akernel.display import display
@@ -103,6 +112,7 @@ def __init__(
         self.stop_event = Event()
         if execute_in_thread:
             import threading
+
             self._stop_event = threading.Event()
         self.key = "0"
 
@@ -191,7 +201,9 @@ async def thread_execute(self):
                 return
             except Exception:
                 exc_type, exception, traceback = sys.exc_info()
-            from_thread.run_sync(self.from_thread_send_stream.send_nowait, (result, exception, traceback))
+            from_thread.run_sync(
+                self.from_thread_send_stream.send_nowait, (result, exception, traceback)
+            )
 
     async def thread_main(self) -> None:
         async with create_task_group() as tg:
@@ -206,8 +218,11 @@ async def start(self) -> None:
         async with create_task_group() as self.task_group:
             if self.execute_in_thread:
                 from queue import Queue
+
                 self.to_thread_queue = Queue()
-                self.from_thread_send_stream, self.from_thread_receive_stream = create_memory_object_stream(max_buffer_size=1)
+                self.from_thread_send_stream, self.from_thread_receive_stream = (
+                    create_memory_object_stream(max_buffer_size=1)
+                )
                 self.task_group.start_soon(to_thread.run_sync, self.thread)
             msg = self.create_message("status", content={"execution_state": self.execution_state})
             to_send = serialize(msg, self.key)
@@ -250,7 +265,10 @@ async def listen_shell(self) -> None:
             # if there was a blocking cell execution, and it was interrupted,
             # let's ignore all the following execution requests until the pipe
             # is empty
-            if self.interrupted and self.to_shell_receive_stream.statistics().tasks_waiting_send == 0:
+            if (
+                self.interrupted
+                and self.to_shell_receive_stream.statistics().tasks_waiting_send == 0
+            ):
                 self.interrupted = False
             msg_list = await self.to_shell_receive_stream.receive()
             idents, msg_list = feed_identities(msg_list)
@@ -421,7 +439,9 @@ async def execute_and_finish(
         namespace = self.get_namespace(parent_header)
         try:
             if self.execute_in_thread:
-                self.to_thread_queue.put((parent, idents, self.locals[namespace][f"__async_cell{task_i}__"]))
+                self.to_thread_queue.put(
+                    (parent, idents, self.locals[namespace][f"__async_cell{task_i}__"])
+                )
                 result, exception, traceback = await self.from_thread_receive_stream.receive()
             else:
                 PARENT_VAR.set(parent)

src/akernel/message.py

@@ -29,7 +29,7 @@ def utcnow() -> datetime:
 def feed_identities(msg_list: list[bytes]) -> tuple[list[bytes], list[bytes]]:
     idx = msg_list.index(DELIM)
     idents = msg_list[:idx] or [b"foo"]
-    return idents , msg_list[idx + 1 :]  # noqa
+    return idents, msg_list[idx + 1 :]  # noqa
 
 
 def create_message_header(msg_type: str, session_id: str, msg_cnt: int) -> dict[str, Any]:

src/akernel/traceback.py

@@ -10,8 +10,8 @@
 def get_traceback(code: str, exception, traceback, execution_count: int = 0):
     tb_list = extract_tb(traceback)
     tb = format_list(tb_list)
-    #tb += [f"{Fore.RED}{type(exception).__name__}{Style.RESET_ALL}: {exception.args[0]}"]
-    #return tb
+    # tb += [f"{Fore.RED}{type(exception).__name__}{Style.RESET_ALL}: {exception.args[0]}"]
+    # return tb
 
     tb = cast(types.TracebackType, traceback)
     while True:

tests/test_kernel.py

@@ -11,7 +11,9 @@
 
 
 TIMEOUT = 5
-KERNELSPEC_PATH = str(Path(sys.prefix) / "share" / "jupyter" / "kernels" / "akernel" / "kernel.json")
+KERNELSPEC_PATH = str(
+    Path(sys.prefix) / "share" / "jupyter" / "kernels" / "akernel" / "kernel.json"
+)
 
 
 ANSI_ESCAPE = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")