euporie 2.8.1__py3-none-any.whl → 2.8.5__py3-none-any.whl

euporie/core/{kernel.py → kernel/client.py}

@@ -6,131 +6,34 @@ import asyncio
 import concurrent.futures
 import logging
 import os
-import re
-import sys
 import threading
 from collections import defaultdict
 from subprocess import PIPE, STDOUT  # S404 - Security implications considered
 from typing import TYPE_CHECKING, TypedDict
 from uuid import uuid4
 
-import nbformat
-from _frozen_importlib import _DeadlockError
-from jupyter_client import AsyncKernelManager, KernelManager
-from jupyter_client.kernelspec import NATIVE_KERNEL_NAME, NoSuchKernel
-from jupyter_client.provisioning import KernelProvisionerFactory as KPF
-from jupyter_client.provisioning.local_provisioner import LocalProvisioner
-from jupyter_core.paths import jupyter_path, jupyter_runtime_dir
 from upath import UPath
 
 if TYPE_CHECKING:
+    from collections.abc import Coroutine
     from pathlib import Path
-    from typing import Any, Callable, Coroutine, TextIO
+    from typing import Any, Callable
 
     from jupyter_client import KernelClient
-    from jupyter_client.connect import KernelConnectionInfo
 
-    from euporie.core.comm.base import KernelTab
+    from euporie.core.tabs.kernel import KernelTab
 
 
 log = logging.getLogger(__name__)
 
 
-class LoggingLocalProvisioner(LocalProvisioner):  # type:ignore[misc]
-    """A Jupyter kernel provisionser which logs kernel output."""
-
-    async def launch_kernel(
-        self, cmd: list[str], **kwargs: Any
-    ) -> KernelConnectionInfo:
-        """Launch a kernel with a command."""
-        await super().launch_kernel(cmd, **kwargs)
-
-        def log_kernel_output(pipe: TextIO, log_func: Callable) -> None:
-            try:
-                with pipe:
-                    for line in iter(pipe.readline, ""):
-                        log_func(line.rstrip())
-            except StopIteration:
-                pass
-
-        if self.process is not None:
-            # Start thread to listen for kernel output
-            threading.Thread(
-                target=log_kernel_output,
-                args=(self.process.stdout, log.warning),
-                daemon=True,
-            ).start()
-
-        return self.connection_info
-
-
-KPF.instance().default_provisioner_name = "logging-local-provisioner"
-
-
-class EuporieKernelManager(AsyncKernelManager):
-    """Kernel Manager subclass.
-
-    ``jupyter_client`` replaces a plain ``python`` command with the current executable,
-    but this is not desirable if the client is running in its own prefix (e.g. with
-    ``pipx``). We work around this here.
-
-    See https://github.com/jupyter/jupyter_client/issues/949
-    """
-
-    def format_kernel_cmd(self, extra_arguments: list[str] | None = None) -> list[str]:
-        """Replace templated args (e.g. {connection_file})."""
-        extra_arguments = extra_arguments or []
-        assert self.kernel_spec is not None
-        cmd = self.kernel_spec.argv + extra_arguments
-
-        v_major, v_minor = sys.version_info[:2]
-        if cmd and cmd[0] in {
-            "python",
-            f"python{v_major}",
-            f"python{v_major}.{v_minor}",
-        }:
-            # If the command is `python` without an absolute path and euporie is
-            # running in the same prefix as the kernel_spec file is located, use
-            # sys.executable: otherwise fall back to the executable in the base prefix
-            if (
-                os.path.commonpath((sys.prefix, self.kernel_spec.resource_dir))
-                == sys.prefix
-            ):
-                cmd[0] = sys.executable
-            else:
-                cmd[0] = sys._base_executable  # type: ignore [attr-defined]
-
-        # Make sure to use the realpath for the connection_file
-        # On windows, when running with the store python, the connection_file path
-        # is not usable by non python kernels because the path is being rerouted when
-        # inside of a store app.
-        # See this bug here: https://bugs.python.org/issue41196
-        ns = {
-            "connection_file": os.path.realpath(self.connection_file),
-            "prefix": sys.prefix,
-        }
-
-        if self.kernel_spec:
-            ns["resource_dir"] = self.kernel_spec.resource_dir
-
-        if self._launch_args:
-            ns.update({str(k): str(v) for k, v in self._launch_args.items()})
-
-        pat = re.compile(r"\{([A-Za-z0-9_]+)\}")
-
-        def _from_ns(match: re.Match) -> str:
-            """Get the key out of ns if it's there, otherwise no change."""
-            return ns.get(match.group(1), match.group())
-
-        return [pat.sub(_from_ns, arg) for arg in cmd]
-
-
 class MsgCallbacks(TypedDict, total=False):
     """Typed dictionary for named message callbacks."""
 
     get_input: Callable[[str, bool], None] | None
     set_execution_count: Callable[[int], None] | None
-    add_output: Callable[[dict[str, Any]], None] | None
+    add_output: Callable[[dict[str, Any], bool], None] | None
+    add_input: Callable[[dict[str, Any], bool], None] | None
     clear_output: Callable[[bool], None] | None
     done: Callable[[dict[str, Any]], None] | None
     set_metadata: Callable[[tuple[str, ...], Any], None] | None
@@ -151,6 +54,8 @@ class Kernel:
     Has the ability to run itself in it's own thread.
     """
 
+    _CLIENT_ID = f"euporie-{os.getpid()}"
+
     def __init__(
         self,
         kernel_tab: KernelTab,
@@ -170,6 +75,15 @@ class Kernel:
                 kernel connection information
 
         """
+        from jupyter_core.paths import jupyter_path
+
+        from euporie.core.kernel.manager import (
+            EuporieKernelManager,
+            set_default_provisioner,
+        )
+
+        set_default_provisioner()
+
         self.threaded = threaded
         if threaded:
             self.loop = asyncio.new_event_loop()
@@ -341,6 +255,8 @@ class Kernel:
     @property
     def missing(self) -> bool:
         """Return True if the requested kernel is not found."""
+        from jupyter_client.kernelspec import NoSuchKernel
+
         try:
             self.km.kernel_spec  # noqa B018
         except NoSuchKernel:
@@ -373,6 +289,8 @@ class Kernel:
 
     async def start_(self) -> None:
         """Start the kernel asynchronously and set its status."""
+        from jupyter_core.paths import jupyter_runtime_dir
+
         if self.km.kernel_name is None:
             self.status = "error"
         log.debug("Starting kernel")
@@ -401,16 +319,18 @@ class Kernel:
         # Otherwise, start a new kernel using the kernel manager
         else:
             runtime_dir.mkdir(exist_ok=True, parents=True)
-            while True:
+            for attempt in range(1, 4):
                 try:
                     # TODO - send stdout to log
                     await self.km.start_kernel(stdout=PIPE, stderr=STDOUT, text=True)
-                except _DeadlockError:
-                    # Keep trying if we get an import deadlock
-                    await asyncio.sleep(0.1)
-                    continue
                 except Exception as e:
-                    log.error("Kernel '%s' could not start", self.km.kernel_name)
+                    log.error(
+                        "Kernel '%s' could not start on attempt %s",
+                        self.km.kernel_name,
+                        attempt,
+                    )
+                    if attempt > 2:
+                        continue
                     self.status = "error"
                     self.error = e
                 else:
@@ -418,12 +338,14 @@ class Kernel:
                     # Create a client for the newly started kernel
                     if self.km.has_kernel:
                         self.kc = self.km.client()
-                break
+                    break
 
         await self.post_start_()
 
     async def post_start_(self) -> None:
         """Wait for the kernel to become ready."""
+        from jupyter_client.kernelspec import NoSuchKernel
+
         try:
             ks = self.km.kernel_spec
         except NoSuchKernel as e:
@@ -457,6 +379,9 @@ class Kernel:
                         ]
                         self.dead = False
 
+                    # Set username so we can identify our own messages
+                    self.kc.session.username = self._CLIENT_ID
+
             # Start monitoring the kernel status
             if self.monitor_task is not None:
                 self.monitor_task.cancel()
@@ -473,6 +398,8 @@ class Kernel:
             timeout: How long to wait until failure is assumed
 
         """
+        from jupyter_client.kernelspec import NATIVE_KERNEL_NAME
+
         # Attempt to import ipykernel if it is installed
         # ipykernel is imported by jupyter_client, but since starting the kernel runs
         # in another thread, we do the import here first to prevent import deadlocks,
@@ -507,22 +434,24 @@ class Kernel:
             rsp = await msg_getter_coro()
             # Run msg type handler
             msg_type = rsp.get("header", {}).get("msg_type")
+            own = rsp.get("parent_header", {}).get("username") == self._CLIENT_ID
             if callable(handler := getattr(self, f"on_{channel}_{msg_type}", None)):
-                handler(rsp)
+                handler(rsp, own)
             else:
-                self.on_unhandled(channel, rsp)
+                self.on_unhandled(channel, rsp, own)
 
-    def on_unhandled(self, channel: str, rsp: dict[str, Any]) -> None:
+    def on_unhandled(self, channel: str, rsp: dict[str, Any], own: bool) -> None:
         """Report unhandled messages to the debug log."""
         log.debug(
-            "Unhandled %s message:\nparent_id = '%s'\ntype = '%s'\ncontent='%s'",
+            "Unhandled %s message:\nparent_id = '%s'\ntype = '%s'\ncontent='%s'\nown: %s",
             channel,
             rsp.get("parent_header", {}).get("msg_id"),
             rsp["header"]["msg_type"],
             rsp.get("content"),
+            own,
         )
 
-    def on_stdin_input_request(self, rsp: dict[str, Any]) -> None:
+    def on_stdin_input_request(self, rsp: dict[str, Any], own: bool) -> None:
         """Call ``get_input`` callback for a stdin input request message."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         content = rsp.get("content", {})
@@ -532,7 +461,7 @@ class Kernel:
                 content.get("password", False),
             )
 
-    def on_shell_status(self, rsp: dict[str, Any]) -> None:
+    def on_shell_status(self, rsp: dict[str, Any], own: bool) -> None:
         """Call ``set_execution_count`` callback for a shell status response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         content = rsp.get("content", {})
@@ -548,7 +477,7 @@ class Kernel:
         ):
             set_execution_count(execution_count)
 
-    def on_shell_execute_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_execute_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell execute reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         content = rsp.get("content", {})
@@ -575,11 +504,14 @@ class Kernel:
                     if callable(
                         add_output := self.msg_id_callbacks[msg_id]["add_output"]
                     ) and (data := payload.get("data", {})):
+                        import nbformat
+
                         add_output(
                             nbformat.v4.new_output(
                                 "execute_result",
                                 data=data,
-                            )
+                            ),
+                            own,
                         )
                 elif source == "set_next_input":
                     if callable(
@@ -605,7 +537,7 @@ class Kernel:
         ):
             done(content)
 
-    def on_shell_kernel_info_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_kernel_info_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell kernel info response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(
@@ -613,25 +545,25 @@ class Kernel:
         ):
             set_kernel_info(rsp.get("content", {}))
 
-    def on_shell_complete_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_complete_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell completion reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_shell_history_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_history_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell history reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_shell_inspect_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_inspect_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell inspection reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_shell_is_complete_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_is_complete_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell completeness reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(
@@ -641,7 +573,7 @@ class Kernel:
         ):
             completeness_status(rsp.get("content", {}))
 
-    def on_iopub_status(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_status(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub status response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         status = rsp.get("content", {}).get("execution_state")
@@ -670,9 +602,11 @@ class Kernel:
                 rsp["header"]["date"].isoformat(),
             )
 
-    def on_iopub_execute_input(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_execute_input(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub execute input response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
+        content = rsp.get("content", {})
+
         if self.kernel_tab.app.config.record_cell_timing and callable(
             set_metadata := self.msg_id_callbacks[msg_id]["set_metadata"]
         ):
@@ -681,23 +615,42 @@ class Kernel:
                 rsp["header"]["date"].isoformat(),
             )
 
-    def on_iopub_display_data(self, rsp: dict[str, Any]) -> None:
+        execution_count: int | None = None
+        if (execution_count := content.get("execution_count")) and (
+            callable(
+                set_execution_count := self.msg_id_callbacks[msg_id][
+                    "set_execution_count"
+                ]
+            )
+        ):
+            set_execution_count(execution_count)
+
+        if callable(add_input := self.msg_id_callbacks[msg_id].get("add_input")):
+            add_input(content, own)
+
+    def on_iopub_display_data(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub display data response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
-            add_output(nbformat.v4.output_from_msg(rsp))
+            import nbformat
 
-    def on_iopub_update_display_data(self, rsp: dict[str, Any]) -> None:
+            add_output(nbformat.v4.output_from_msg(rsp), own)
+
+    def on_iopub_update_display_data(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub update display data response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
-            add_output(nbformat.v4.output_from_msg(rsp))
+            import nbformat
+
+            add_output(nbformat.v4.output_from_msg(rsp), own)
 
-    def on_iopub_execute_result(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_execute_result(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub execute result response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
-            add_output(nbformat.v4.output_from_msg(rsp))
+            import nbformat
+
+            add_output(nbformat.v4.output_from_msg(rsp), own)
 
         if (execution_count := rsp.get("content", {}).get("execution_count")) and (
             callable(
@@ -708,21 +661,25 @@ class Kernel:
         ):
             set_execution_count(execution_count)
 
-    def on_iopub_error(self, rsp: dict[str, dict[str, Any]]) -> None:
+    def on_iopub_error(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub error response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id", "")
         if callable(add_output := self.msg_id_callbacks[msg_id].get("add_output")):
-            add_output(nbformat.v4.output_from_msg(rsp))
+            import nbformat
+
+            add_output(nbformat.v4.output_from_msg(rsp), own)
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_iopub_stream(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_stream(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub stream response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
-            add_output(nbformat.v4.output_from_msg(rsp))
+            import nbformat
 
-    def on_iopub_clear_output(self, rsp: dict[str, Any]) -> None:
+            add_output(nbformat.v4.output_from_msg(rsp), own)
+
+    def on_iopub_clear_output(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub clear output response."""
         # Clear cell output, either now or when we get the next output
         msg_id = rsp.get("parent_header", {}).get("msg_id")
@@ -737,7 +694,7 @@ class Kernel:
         )
     '''
 
-    def on_iopub_comm_open(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_comm_open(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an comm open response."""
         # TODO
         # "If the target_name key is not found on the receiving side, then it should
@@ -747,13 +704,13 @@ class Kernel:
             content=rsp.get("content", {}), buffers=rsp.get("buffers", [])
         )
 
-    def on_iopub_comm_msg(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_comm_msg(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub comm message response."""
         self.kernel_tab.comm_msg(
             content=rsp.get("content", {}), buffers=rsp.get("buffers", [])
         )
 
-    def on_iopub_comm_close(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_comm_close(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub comm close response."""
         self.kernel_tab.comm_close(
             content=rsp.get("content", {}), buffers=rsp.get("buffers", [])
@@ -795,7 +752,7 @@ class Kernel:
         source: str,
         get_input: Callable[[str, bool], None] | None = None,
         set_execution_count: Callable[[int], None] | None = None,
-        add_output: Callable[[dict[str, Any]], None] | None = None,
+        add_output: Callable[[dict[str, Any], bool], None] | None = None,
         clear_output: Callable[[bool], None] | None = None,
         done: Callable[[dict[str, Any]], None] | None = None,
         set_metadata: Callable[[tuple[str, ...], Any], None] | None = None,
@@ -1121,6 +1078,8 @@ class Kernel:
         kernel's event loop to finish.
         """
         if self.km.has_kernel:
+            from jupyter_client import KernelManager
+
             log.debug("Interrupting kernel %s", self.id)
             KernelManager.interrupt_kernel(self.km)
 
@@ -1156,6 +1115,8 @@ class Kernel:
             cb: Callback to run once restarted
 
         """
+        from euporie.core.kernel.manager import EuporieKernelManager
+
         self.connection_file = connection_file
         self.status = "starting"
 

euporie/core/kernel/manager.py

@@ -0,0 +1,114 @@
+"""Contain classes relating to kernel management."""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import sys
+import threading
+from typing import TYPE_CHECKING
+
+from jupyter_client import AsyncKernelManager
+from jupyter_client.provisioning.local_provisioner import LocalProvisioner
+
+if TYPE_CHECKING:
+    from typing import Any, Callable, TextIO
+
+    from jupyter_client.connect import KernelConnectionInfo
+
+
+log = logging.getLogger(__name__)
+
+
+class LoggingLocalProvisioner(LocalProvisioner):  # type:ignore[misc]
+    """A Jupyter kernel provisionser which logs kernel output."""
+
+    async def launch_kernel(
+        self, cmd: list[str], **kwargs: Any
+    ) -> KernelConnectionInfo:
+        """Launch a kernel with a command."""
+        await super().launch_kernel(cmd, **kwargs)
+
+        def log_kernel_output(pipe: TextIO, log_func: Callable) -> None:
+            try:
+                with pipe:
+                    for line in iter(pipe.readline, ""):
+                        log_func(line.rstrip())
+            except StopIteration:
+                pass
+
+        if self.process is not None:
+            # Start thread to listen for kernel output
+            threading.Thread(
+                target=log_kernel_output,
+                args=(self.process.stdout, log.warning),
+                daemon=True,
+            ).start()
+
+        return self.connection_info
+
+
+def set_default_provisioner() -> None:
+    """Set the default kernel provisioner to euporie's logging provisioner."""
+    from jupyter_client.provisioning import KernelProvisionerFactory as KPF
+
+    KPF.instance().default_provisioner_name = "logging-local-provisioner"
+
+
+class EuporieKernelManager(AsyncKernelManager):
+    """Kernel Manager subclass.
+
+    ``jupyter_client`` replaces a plain ``python`` command with the current executable,
+    but this is not desirable if the client is running in its own prefix (e.g. with
+    ``pipx``). We work around this here.
+
+    See https://github.com/jupyter/jupyter_client/issues/949
+    """
+
+    def format_kernel_cmd(self, extra_arguments: list[str] | None = None) -> list[str]:
+        """Replace templated args (e.g. {connection_file})."""
+        extra_arguments = extra_arguments or []
+        assert self.kernel_spec is not None
+        cmd = self.kernel_spec.argv + extra_arguments
+
+        v_major, v_minor = sys.version_info[:2]
+        if cmd and cmd[0] in {
+            "python",
+            f"python{v_major}",
+            f"python{v_major}.{v_minor}",
+        }:
+            # If the command is `python` without an absolute path and euporie is
+            # running in the same prefix as the kernel_spec file is located, use
+            # sys.executable: otherwise fall back to the executable in the base prefix
+            if (
+                os.path.commonpath((sys.prefix, self.kernel_spec.resource_dir))
+                == sys.prefix
+            ):
+                cmd[0] = sys.executable
+            else:
+                cmd[0] = sys._base_executable  # type: ignore [attr-defined]
+
+        # Make sure to use the realpath for the connection_file
+        # On windows, when running with the store python, the connection_file path
+        # is not usable by non python kernels because the path is being rerouted when
+        # inside of a store app.
+        # See this bug here: https://bugs.python.org/issue41196
+        ns = {
+            "connection_file": os.path.realpath(self.connection_file),
+            "prefix": sys.prefix,
+        }
+
+        if self.kernel_spec:
+            ns["resource_dir"] = self.kernel_spec.resource_dir
+
+        if self._launch_args:
+            ns.update({str(k): str(v) for k, v in self._launch_args.items()})
+
+        pat = re.compile(r"\{([A-Za-z0-9_]+)\}")
+
+        def _from_ns(match: re.Match) -> str:
+            """Get the key out of ns if it's there, otherwise no change."""
+            return ns.get(match.group(1), match.group())
+
+        return [pat.sub(_from_ns, arg) for arg in cmd]

euporie/core/key_binding/bindings/__init__.py

@@ -1,11 +1,5 @@
 """Define collections of generic key-bindings which do not belong to widgets."""
 
-from euporie.core.key_binding.bindings import (
-    basic,
-    completion,
-    micro,
-    mouse,
-    page_navigation,
-)
+from . import basic, completion, micro, mouse, page_navigation, vi
 
-__all__ = ["basic", "completion", "micro", "mouse", "page_navigation"]
+__all__ = ["basic", "completion", "micro", "mouse", "page_navigation", "vi"]