akernel 0.3.4__tar.gz → 0.4.0__tar.gz

{akernel-0.3.4 → akernel-0.4.0}/.github/workflows/main.yml

@@ -10,7 +10,7 @@ on:
 
 defaults:
   run:
-    shell: bash -l {0}
+    shell: bash
 
 jobs:
   test:
@@ -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
@@ -33,7 +33,7 @@ jobs:
 
     - name: Install akernel
       run: |
-        pip install . --group test
+        pip install ".[subprocess]" --group dev
 
     - name: Check style and types
       run: |
@@ -44,5 +44,5 @@ jobs:
     - name: Run tests
       run: |
         akernel --help
-        test -f ${pythonLocation}/../share/jupyter/kernels/akernel/kernel.json
+        python -c "from pathlib import Path; import sys; assert (Path(sys.prefix) / 'share/jupyter/kernels/akernel/kernel.json').is_file()"
         pytest -v --reruns 5

akernel-0.4.0/.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+.ipynb_checkpoints/

akernel-0.4.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.5
+Name: akernel
+Version: 0.4.0
+Summary: An asynchronous Python Jupyter kernel
+Project-URL: Homepage, https://github.com/davidbrochart/akernel
+Author-email: David Brochart <david.brochart@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: jupyter
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+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 :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: anyio<5.0.0,>=4.14.2
+Requires-Dist: comm<1,>=0.1.3
+Requires-Dist: python-dateutil
+Requires-Dist: rich<15,>=14.0
+Provides-Extra: subprocess
+Requires-Dist: cyclopts<5.0.0,>=4.22.2; extra == 'subprocess'
+Requires-Dist: zmq-anyio<0.5.0,>=0.4.1; extra == 'subprocess'
+Description-Content-Type: text/markdown
+
+[![Build Status](https://github.com/davidbrochart/akernel/workflows/CI/badge.svg)](https://github.com/davidbrochart/akernel/actions)
+
+# akernel
+
+An asynchronous Python Jupyter kernel built on AnyIO:
+- runs in a separate process or in-process.
+- supports top-level `await`.
+
+## Install
+
+For a standalone, out-of-process kernel, install the `subprocess` extra:
+
+```bash
+pip install "akernel[subprocess]"
+```
+
+This will give you a `Python 3 (akernel)` in JupyterLab.
+
+`akernel` can also run in-process with [Jupyverse](https://github.com/jupyter-server/jupyverse).
+Install it with:
+
+```bash
+pip install "fps-akernel-task"
+```
+
+This will give you both `Python 3 (akernel)` and `Python 3 (akernel-thread)` kernels
+in JupyterLab.
+
+## In-process kernels
+
+They run in Jupyverse's process, so running blocking user code in the kernel
+will also block Jupyverse.
+
+`akernel-thread` is an in-process kernel that runs user code in a separate thread,
+which won't block Jupyverse.
+
+## Limitations
+
+- Cell output redirection currently uses the kernel's `print` function rather
+  than capturing all writes to `stdout` and `stderr`.
+- In-process kernels cannot be interrupted while running blocking code.

akernel-0.4.0/README.md

@@ -0,0 +1,41 @@
+[![Build Status](https://github.com/davidbrochart/akernel/workflows/CI/badge.svg)](https://github.com/davidbrochart/akernel/actions)
+
+# akernel
+
+An asynchronous Python Jupyter kernel built on AnyIO:
+- runs in a separate process or in-process.
+- supports top-level `await`.
+
+## Install
+
+For a standalone, out-of-process kernel, install the `subprocess` extra:
+
+```bash
+pip install "akernel[subprocess]"
+```
+
+This will give you a `Python 3 (akernel)` in JupyterLab.
+
+`akernel` can also run in-process with [Jupyverse](https://github.com/jupyter-server/jupyverse).
+Install it with:
+
+```bash
+pip install "fps-akernel-task"
+```
+
+This will give you both `Python 3 (akernel)` and `Python 3 (akernel-thread)` kernels
+in JupyterLab.
+
+## In-process kernels
+
+They run in Jupyverse's process, so running blocking user code in the kernel
+will also block Jupyverse.
+
+`akernel-thread` is an in-process kernel that runs user code in a separate thread,
+which won't block Jupyverse.
+
+## Limitations
+
+- Cell output redirection currently uses the kernel's `print` function rather
+  than capturing all writes to `stdout` and `stderr`.
+- In-process kernels cannot be interrupted while running blocking code.

akernel-0.4.0/plugins/akernel_task/README.md

@@ -0,0 +1,15 @@
+# fps-akernel-task
+
+An FPS plugin for the kernel task API.
+
+## Development installation
+
+Install both packages from the repository root, in the environment running Jupyverse:
+
+```bash
+python -m pip install -e . -e plugins/akernel_task
+```
+
+Installing only the plugin can resolve its `akernel` dependency from PyPI instead
+of this checkout. While working on unreleased kernel API changes, the plugin and
+kernel must come from the same checkout. Restart Jupyverse after reinstalling.

{akernel-0.3.4 → akernel-0.4.0}/plugins/akernel_task/fps_akernel_task/akernel_task.py

@@ -2,14 +2,15 @@ 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 jupyverse_kernel import Kernel as _Kernel
 
 from akernel.kernel import Kernel
 
 
 class AKernelTask(_Kernel):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, execute_in_thread: bool = False, **kwargs):
         super().__init__()
+        self.execute_in_thread = execute_in_thread
 
     async def start(self, *, task_status: TaskStatus[None] = TASK_STATUS_IGNORED) -> None:
         async with (
@@ -37,6 +38,7 @@ class AKernelTask(_Kernel):
                 self._to_stdin_receive_stream,
                 self._from_stdin_send_stream,
                 self._from_iopub_send_stream,
+                execute_in_thread=self.execute_in_thread,
             )
             self.task_group.start_soon(self.kernel.start)
             task_status.started()
@@ -47,4 +49,4 @@ class AKernelTask(_Kernel):
         self.task_group.cancel_scope.cancel()
 
     async def interrupt(self) -> None:
-        pass
+        self.kernel.interrupt()

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

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from functools import partial
+
+from fps import Module
+from jupyverse_kernel import KernelFactory
+from jupyverse_kernels import Kernels
+
+from .akernel_task import AKernelTask
+from .models import KernelConfig
+
+
+class AKernelTaskModule(Module):
+    def __init__(self, *args, execute_in_thread: bool = False, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.execute_in_thread = KernelConfig(execute_in_thread=execute_in_thread).execute_in_thread
+
+    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))
+        )
+
+
+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))
+        )

akernel-0.4.0/plugins/akernel_task/fps_akernel_task/models.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class KernelConfig(BaseModel):
+    execute_in_thread: bool

{akernel-0.3.4 → akernel-0.4.0}/plugins/akernel_task/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "hatchling.build"
 
 [project]
 name = "fps_akernel_task"
-version = "0.1.3"
+version = "0.2.0"
 description = "An FPS plugin for the kernel task API"
 keywords = ["jupyter", "server", "fastapi", "plugins"]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 dependencies = [
-    "jupyverse-api >=0.10.1,<0.11.0",
+    "jupyverse-api >=0.15.0,<0.16.0",
     "anyio",
-    "akernel >=0.3.4",
+    "akernel >=0.4.0",
 ]
 
 [[project.authors]]
@@ -29,5 +29,5 @@ text = "MIT"
 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"}
+"fps.modules"       = {akernel_task = "fps_akernel_task.main:AKernelTaskModule", akernelthread_task = "fps_akernel_task.main:AKernelThreadTaskModule"}
+"jupyverse.modules" = {akernel_task = "fps_akernel_task.main:AKernelTaskModule", akernelthread_task = "fps_akernel_task.main:AKernelThreadTaskModule"}

{akernel-0.3.4 → akernel-0.4.0}/pyproject.toml

@@ -4,60 +4,51 @@ build-backend = "hatchling.build"
 
 [project]
 name = "akernel"
-version = "0.3.4"
+version = "0.4.0"
 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",
 ]
 keywords = [ "jupyter" ]
 dependencies = [
+    "anyio >=4.14.2,<5.0.0",
     "python-dateutil",
-    "colorama",
-    "gast >=0.6.0, <0.7.0",
+    "rich >=14.0,<15",
     "comm >=0.1.3,<1",
 ]
 
 [dependency-groups]
-test = [
+dev = [
+    "trio",
     "mypy",
     "ruff",
     "pytest",
-    "pytest-asyncio",
     "pytest-rerunfailures",
     "types-python-dateutil",
     "kernel_driver >=0.0.7",
-    "ipyx >=0.1.7",
-    "zict",
+    "tornado >=6.1; sys_platform == 'win32'",
 ]
 
 [project.optional-dependencies]
 subprocess = [
-    "zmq-anyio >=0.3.9,<0.4.0",
-    "typer >=0.4.0",
-]
-
-react = [
-    "ipyx >=0.1.7",
-]
-
-cache = [
-    "zict",
+    "zmq-anyio >=0.4.1,<0.5.0",
+    "cyclopts >=4.22.2,<5.0.0",
 ]
 
 [project.scripts]
-akernel = "akernel.akernel:cli"
+akernel = "akernel.akernel:app"
 
 [tool.hatch.build.targets.wheel]
 ignore-vcs = true
@@ -65,6 +56,7 @@ packages = ["src/akernel"]
 
 [tool.hatch.build.targets.wheel.shared-data]
 "share/jupyter/kernels/akernel/kernel.json" = "share/jupyter/kernels/akernel/kernel.json"
+"share/jupyter/kernels/akernel-thread/kernel.json" = "share/jupyter/kernels/akernel-thread/kernel.json"
 
 [project.urls]
 Homepage = "https://github.com/davidbrochart/akernel"
@@ -75,3 +67,6 @@ exclude = ["examples"]
 
 [tool.uv.sources]
 fps-akernel-task = { workspace = true }
+
+[tool.pytest.ini_options]
+anyio_mode = "auto"

akernel-0.4.0/share/jupyter/kernels/akernel-thread/kernel.json

@@ -0,0 +1,11 @@
+{
+  "argv": [
+    "akernel",
+    "launch",
+    "--execute-in-thread",
+    "-f",
+    "{connection_file}"
+  ],
+  "display_name": "Python 3 (akernel-thread)",
+  "language": "python"
+}

akernel-0.4.0/src/akernel/__init__.py

@@ -0,0 +1,3 @@
+import importlib.metadata
+
+__version__ = importlib.metadata.version("akernel")

{akernel-0.3.4 → akernel-0.4.0}/src/akernel/akernel.py

@@ -1,57 +1,65 @@
 from __future__ import annotations
 
 import json
-from typing import Optional, cast
+from typing import Annotated, cast
 
-import typer
-from anyio import create_memory_object_stream, create_task_group, run, sleep_forever
+from anyio import Event, create_memory_object_stream, create_task_group, run
+from cyclopts import App, Parameter
 
 from .connect import connect_channel
 from .kernel import Kernel
 from .kernelspec import write_kernelspec
+from .message import deserialize, feed_identities
 
+app = App()
 
-cli = typer.Typer()
 
-
-@cli.command()
-def install(
-    mode: str = typer.Argument("", help="Mode of the kernel to install."),
-    cache_dir: Optional[str] = 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)
+@app.command()
+def install(execute_in_thread: bool = False) -> None:
+    """Install the kernel, optionally executing user code in a thread."""
+    kernel_name = "akernel-thread" if execute_in_thread else "akernel"
+    write_kernelspec(kernel_name, f"Python 3 ({kernel_name})", execute_in_thread)
 
 
-@cli.command()
+@app.command()
 def launch(
-    mode: str = typer.Argument("", help="Mode of the kernel to launch."),
-    cache_dir: Optional[str] = typer.Option(
-        None, "-c", help="Path to the cache directory, if mode is 'cache'."
-    ),
-    connection_file: str = typer.Option(..., "-f", help="Path to the connection file."),
+    connection_file: Annotated[str, Parameter(alias=["-f"])],
+    execute_in_thread: bool = False,
 ):
-    akernel = AKernel(mode, cache_dir, connection_file)
+    """Launch the kernel.
+
+    Args:
+        connection_file: Path to the connection file.
+        execute_in_thread: Whether to run user code in a thread.
+    """
+    akernel = AKernel(connection_file, execute_in_thread)
     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"))
+    def __init__(self, connection_file, execute_in_thread=False):
+        self._shutdown_reply_sent = Event()
+        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,
@@ -60,8 +68,7 @@ class AKernel:
             self._to_stdin_receive_stream,
             self._from_stdin_send_stream,
             self._from_iopub_send_stream,
-            mode,
-            cache_dir,
+            execute_in_thread,
         )
         with open(connection_file) as f:
             connection_cfg = json.load(f)
@@ -73,7 +80,6 @@ class AKernel:
 
     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,
@@ -92,8 +98,8 @@ class AKernel:
             self.control_channel,
             self.stdin_channel,
             self.iopub_channel,
+            create_task_group() as tg,
         ):
-            tg.start_soon(self.kernel.start)
             tg.start_soon(self.to_shell)
             tg.start_soon(self.from_shell)
             tg.start_soon(self.to_control)
@@ -101,39 +107,46 @@ class AKernel:
             tg.start_soon(self.to_stdin)
             tg.start_soon(self.from_stdin)
             tg.start_soon(self.from_iopub)
-            await sleep_forever()
+            await self.kernel.start()
+            # Receiving from the memory stream does not mean the reply has
+            # reached the socket yet. Keep the forwarder alive until it has.
+            await self._shutdown_reply_sent.wait()
+            tg.cancel_scope.cancel()
 
     async def to_shell(self) -> None:
         while True:
-            msg = await self.shell_channel.arecv_multipart().wait()
+            msg = await self.shell_channel.arecv_multipart()
             await self._to_shell_send_stream.send(msg)
 
     async def from_shell(self) -> None:
         async for msg in self._from_shell_receive_stream:
-            await self.shell_channel.asend_multipart(msg, copy=True).wait()
+            await self.shell_channel.asend_multipart(msg, copy=True)
 
     async def to_control(self) -> None:
         while True:
-            msg = await self.control_channel.arecv_multipart().wait()
+            msg = await self.control_channel.arecv_multipart()
             await self._to_control_send_stream.send(msg)
 
     async def from_control(self) -> None:
         async for msg in self._from_control_receive_stream:
-            await self.control_channel.asend_multipart(msg, copy=True).wait()
+            await self.control_channel.asend_multipart(msg, copy=True)
+            reply = deserialize(feed_identities(msg)[1])
+            if reply["header"]["msg_type"] == "shutdown_reply" and not reply["content"]["restart"]:
+                self._shutdown_reply_sent.set()
 
     async def to_stdin(self) -> None:
         while True:
-            msg = await self.stdin_channel.arecv_multipart().wait()
+            msg = await self.stdin_channel.arecv_multipart()
             await self._to_stdin_send_stream.send(msg)
 
     async def from_stdin(self) -> None:
         async for msg in self._from_stdin_receive_stream:
-            await self.stdin_channel.asend_multipart(msg, copy=True).wait()
+            await self.stdin_channel.asend_multipart(msg, copy=True)
 
     async def from_iopub(self) -> None:
         async for msg in self._from_iopub_receive_stream:
-            await self.iopub_channel.asend_multipart(msg, copy=True).wait()
+            await self.iopub_channel.asend_multipart(msg, copy=True)
 
 
 if __name__ == "__main__":
-    cli()
+    app()

{akernel-0.3.4 → akernel-0.4.0}/src/akernel/comm/comm.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 import comm
 

{akernel-0.3.4 → akernel-0.4.0}/src/akernel/comm/manager.py

@@ -1,4 +1,5 @@
-from typing import Dict, Callable, cast
+from collections.abc import Callable
+from typing import cast
 
 import comm
 
@@ -7,7 +8,7 @@ from .comm import Comm
 
 class CommManager(comm.CommManager):
     comms: dict[str, comm.base_comm.BaseComm]
-    targets: Dict[str, Callable]
+    targets: dict[str, Callable]
 
     def __init__(self) -> None:
         super().__init__()

{akernel-0.3.4 → akernel-0.4.0}/src/akernel/connect.py

@@ -1,15 +1,12 @@
 from __future__ import annotations
 
-from typing import Union
-
 import zmq
 from zmq import Context
 from zmq_anyio import Socket
 
-
 context = Context()
 
-cfg_t = dict[str, Union[str, int]]
+cfg_t = dict[str, str | int]
 
 channel_socket_types = {
     "shell": zmq.ROUTER,

{akernel-0.3.4 → akernel-0.4.0}/src/akernel/display/display.py

@@ -8,7 +8,7 @@ def display(*args, raw: bool = False) -> None:
     data = args[0]
     msg = create_message(
         "display_data",
-        content=dict(data=data, transient={}, metadata={}),
+        content={"data": data, "transient": {}, "metadata": {}},
         parent_header=parent_header,
     )
     to_send = serialize(msg, KERNEL.key)

akernel-0.4.0/src/akernel/execution.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+import __future__
+
+import ast
+from dataclasses import dataclass
+from inspect import CO_COROUTINE
+from types import CodeType
+from typing import Any
+
+from .traceback import get_traceback
+
+FUTURE_FLAGS = sum(getattr(__future__, name).compiler_flag for name in __future__.all_feature_names)
+
+
+@dataclass
+class CompiledCell:
+    body: CodeType
+    expression: CodeType | None
+
+
+def compile_cell(code: str, task_i: int = 0) -> CompiledCell:
+    filename = f"<cell-{task_i}>"
+    tree = ast.parse(code, filename=filename)
+    flags = ast.PyCF_ALLOW_TOP_LEVEL_AWAIT
+    # Validate the entire cell before executing any part of it. This also
+    # determines future-import flags needed by the final expression.
+    full_code = compile(tree, filename, "exec", flags=flags, dont_inherit=True)
+    flags |= full_code.co_flags & FUTURE_FLAGS
+    expression = None
+    last_statement = tree.body[-1] if tree.body else None
+    if isinstance(last_statement, ast.Expr):
+        tree.body.pop()
+        expression = compile(
+            ast.Expression(last_statement.value),
+            filename,
+            "eval",
+            flags=flags,
+            dont_inherit=True,
+        )
+    body = compile(tree, filename, "exec", flags=flags, dont_inherit=True)
+    return CompiledCell(body, expression)
+
+
+def prepare_cell(code: str, task_i: int = 0, execution_count: int = 0):
+    traceback = []
+    exception = None
+    cell = None
+    try:
+        cell = compile_cell(code, task_i)
+    except (SyntaxError, ValueError) as exc:
+        # Python 3.10 reports null bytes in source as ValueError.
+        exception = exc
+        traceback = get_traceback(
+            code, exception, None, execution_count, {f"<cell-{task_i}>": code}
+        )
+    return cell, traceback, exception
+
+
+async def execute_cell(cell: CompiledCell, namespace: dict[str, Any]) -> Any:
+    result = eval(cell.body, namespace)
+    if cell.body.co_flags & CO_COROUTINE:
+        await result
+    if cell.expression is not None:
+        result = eval(cell.expression, namespace)
+        if cell.expression.co_flags & CO_COROUTINE:
+            result = await result
+        return result
+    return None