euporie 2.8.4__py3-none-any.whl → 2.8.6__py3-none-any.whl

euporie/core/history.py

@@ -8,9 +8,9 @@ from typing import TYPE_CHECKING
 from prompt_toolkit.history import History
 
 if TYPE_CHECKING:
-    from typing import AsyncGenerator, Iterable
+    from collections.abc import AsyncGenerator, Iterable
 
-    from euporie.core.kernel import Kernel
+    from euporie.core.kernel.client import Kernel
 
 log = logging.getLogger(__name__)
 

euporie/core/inspection.py

@@ -7,12 +7,13 @@ from abc import ABCMeta, abstractmethod
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
     from pathlib import Path
-    from typing import Any, Callable, Sequence
+    from typing import Any, Callable
 
     from prompt_toolkit.document import Document
 
-    from euporie.core.kernel import Kernel
+    from euporie.core.kernel.client import Kernel
     from euporie.core.lsp import LspClient
 
 

euporie/core/io.py

@@ -5,40 +5,115 @@ from __future__ import annotations
 import logging
 import re
 from base64 import b64encode
-from typing import TYPE_CHECKING
+from functools import lru_cache
+from typing import TYPE_CHECKING, cast
 
 from prompt_toolkit.input import vt100_parser
+from prompt_toolkit.input.ansi_escape_sequences import ANSI_SEQUENCES
 from prompt_toolkit.input.base import DummyInput, _dummy_context_manager
+from prompt_toolkit.output.color_depth import ColorDepth
 from prompt_toolkit.output.vt100 import Vt100_Output as PtkVt100_Output
 
+from euporie.core.app.current import get_app
+from euporie.core.filters import in_screen, in_tmux
+
 if TYPE_CHECKING:
-    from typing import IO, Any, Callable, ContextManager, TextIO
+    from contextlib import AbstractContextManager
+    from typing import IO, Any, Callable, TextIO
 
     from prompt_toolkit.keys import Keys
 
+    from euporie.core.config import Config
+
 log = logging.getLogger(__name__)
 
-_response_prefix_re = re.compile(
-    r"""^\x1b(
-        \][^\\\x07]*  # Operating System Commands
-        |
-        _[^\\]*  # Application Program Command
-        |
-        \[\?[\d;]*  # Primary device attribute responses
-        |
-        P[ -~]*(\x1b|x1b\\)?
-    )\Z""",
-    re.VERBOSE,
-)
+COLOR_DEPTHS = {
+    1: ColorDepth.DEPTH_1_BIT,
+    4: ColorDepth.DEPTH_4_BIT,
+    8: ColorDepth.DEPTH_8_BIT,
+    24: ColorDepth.DEPTH_24_BIT,
+}
+
+
+@lru_cache
+def _have_termios_tty_fcntl() -> bool:
+    try:
+        import fcntl  # noqa F401
+        import termios  # noqa F401
+        import tty  # noqa F401
+    except ModuleNotFoundError:
+        return False
+    else:
+        return True
+
+
+def _tiocgwinsz() -> tuple[int, int, int, int]:
+    """Get the size and pixel dimensions of the terminal with `termios`."""
+    import array
+
+    output = array.array("H", [0, 0, 0, 0])
+    if _have_termios_tty_fcntl():
+        import fcntl
+        import termios
+
+        try:
+            fcntl.ioctl(1, termios.TIOCGWINSZ, output)
+        except OSError:
+            pass
+    rows, cols, xpixels, ypixels = output
+    return rows, cols, xpixels, ypixels
+
+
+def passthrough(cmd: str, config: Config | None = None) -> str:
+    """Wrap an escape sequence for terminal passthrough."""
+    config = config or get_app().config
+    if config.multiplexer_passthrough:
+        if in_tmux():
+            cmd = cmd.replace("\x1b", "\x1b\x1b")
+            cmd = f"\x1bPtmux;{cmd}\x1b\\"
+        elif in_screen():
+            # Screen limits escape sequences to 768 bytes, so we have to chunk it
+            cmd = "".join(
+                f"\x1bP{cmd[i : i + 764]}\x1b\\" for i in range(0, len(cmd), 764)
+            )
+    return cmd
 
 
 class _IsPrefixOfLongerMatchCache(vt100_parser._IsPrefixOfLongerMatchCache):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        # Pattern for any ANSI escape sequence
+        self._response_prefix_re = re.compile(
+            r"""^\x1b(
+                \][^\\\x07]*  # Operating System Commands
+                |
+                _[^\\]*  # Application Program Command
+                |
+                \[\?[\d;]*  # Primary device attribute responses
+                |
+                P[ -~]*(\x1b|x1b\\)?
+            )\Z""",
+            re.VERBOSE,
+        )
+        # Generate prefix matches for all known ansi escape sequences
+        # This is faster than PTK's method
+        self._ansi_sequence_prefixes = {
+            seq[:i] for seq in ANSI_SEQUENCES for i in range(len(seq))
+        }
+
     def __missing__(self, prefix: str) -> bool:
         """Check if the response might match an OSC or APC code, or DA response."""
-        result = super().__missing__(prefix)
-        if not result and _response_prefix_re.match(prefix):
-            result = True
-            self[prefix] = result
+        result = bool(
+            # (hard coded) If this could be a prefix of a CPR response, return True.
+            vt100_parser._cpr_response_prefix_re.match(prefix)
+            # True if this could be a mouse event sequence
+            or vt100_parser._mouse_event_prefix_re.match(prefix)
+            # True if this could be the prefix of an expected escape sequence
+            or prefix in self._ansi_sequence_prefixes
+            # If this could be a prefix of any other escape sequence, return True
+            or self._response_prefix_re.match(prefix)
+        )
+        self[prefix] = result
         return result
 
 
@@ -51,14 +126,39 @@ class Vt100Parser(vt100_parser.Vt100Parser):
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         """Create a new VT100 parser."""
+        from euporie.core.keys import MoreKeys
+
         super().__init__(*args, **kwargs)
-        self.queries: dict[Keys, re.Pattern] = {}
+        self.patterns: dict[Keys | MoreKeys, re.Pattern] = {
+            MoreKeys.ColorsResponse: re.compile(
+                r"^\x1b\](?P<c>(\d+;)?\d+)+;rgb:"
+                r"(?P<r>[0-9A-Fa-f]{2,4})\/"
+                r"(?P<g>[0-9A-Fa-f]{2,4})\/"
+                r"(?P<b>[0-9A-Fa-f]{2,4})"
+                # Allow BEL or ST as terminator
+                r"(?:\x1b\\|\x9c|\x07)"
+            ),
+            MoreKeys.PixelSizeResponse: re.compile(r"^\x1b\[4;(?P<y>\d+);(?P<x>\d+)t"),
+            MoreKeys.KittyGraphicsStatusResponse: re.compile(
+                r"^\x1b_Gi=(4294967295|0);(?P<status>OK)\x1b\\"
+            ),
+            MoreKeys.SixelGraphicsStatusResponse: re.compile(
+                r"^\x1b\[\?(?:\d+;)*(?P<sixel>4)(?:;\d+)*c"
+            ),
+            MoreKeys.ItermGraphicsStatusResponse: re.compile(
+                r"^\x1bP>\|(?P<term>[^\x1b]+)\x1b\\"
+            ),
+            MoreKeys.SgrPixelStatusResponse: re.compile(r"^\x1b\[\?1016;(?P<Pm>\d)\$"),
+            MoreKeys.ClipboardDataResponse: re.compile(
+                r"^\x1b\]52;(?:c|p)?;(?P<data>[A-Za-z0-9+/=]+)\x1b\\"
+            ),
+        }
 
     def _get_match(self, prefix: str) -> None | Keys | tuple[Keys, ...]:
         """Check for additional key matches first."""
-        for key, pattern in self.queries.items():
+        for key, pattern in self.patterns.items():
             if pattern.match(prefix):
-                return key
+                return cast("Keys", key)
 
         return super()._get_match(prefix)
 
@@ -66,7 +166,9 @@ class Vt100Parser(vt100_parser.Vt100Parser):
 class IgnoredInput(DummyInput):
     """An input which ignores input but does not immediately close the app."""
 
-    def attach(self, input_ready_callback: Callable[[], None]) -> ContextManager[None]:
+    def attach(
+        self, input_ready_callback: Callable[[], None]
+    ) -> AbstractContextManager[None]:
         """Do not call the callback, so the input is never closed."""
         return _dummy_context_manager()
 
@@ -74,14 +176,12 @@ class IgnoredInput(DummyInput):
 class Vt100_Output(PtkVt100_Output):
     """A Vt100 output which enables SGR pixel mouse positioning."""
 
-    def enable_mouse_support(self) -> None:
-        """Additionally enable SGR-pixel mouse positioning."""
-        super().enable_mouse_support()
+    def enable_sgr_pixel(self) -> None:
+        """Enable SGR-pixel mouse positioning."""
         self.write_raw("\x1b[?1016h")
 
-    def disable_mouse_support(self) -> None:
-        """Additionally disable SGR-pixel mouse positioning."""
-        super().disable_mouse_support()
+    def disable_sgr_pixel(self) -> None:
+        """Disable SGR-pixel mouse positioning."""
         self.write_raw("\x1b[?1016l")
 
     def enable_private_sixel_colors(self) -> None:
@@ -115,6 +215,44 @@ class Vt100_Output(PtkVt100_Output):
         """Get clipboard contents using OSC-52."""
         self.write_raw("\x1b]52;c;?\x1b\\")
 
+    def get_colors(self) -> None:
+        """Query terminal colors."""
+        self.write_raw(
+            passthrough(
+                ("\x1b]10;?\x1b\\\x1b]11;?\x1b\\")
+                + "".join(f"\x1b]4;{i};?\x1b\\" for i in range(16))
+            )
+        )
+
+    def get_pixel_size(self) -> None:
+        """Check the terminal's dimensions in pixels."""
+        self.write_raw("\x1b[14t")
+
+    def get_kitty_graphics_status(self) -> None:
+        """Query terminal to check for kitty graphics support."""
+        self.write_raw(
+            "\x1b[s"
+            + passthrough("\x1b_gi=4294967295,s=1,v=1,a=q,t=d,f=24;aaaa\x1b\\")
+            + "\x1b[u\x1b[2k"
+        )
+
+    def get_sixel_graphics_status(self) -> None:
+        """Query terminal for sixel graphics support."""
+        self.write_raw(passthrough("\x1b[c"))
+
+    def get_iterm_graphics_status(self) -> None:
+        """Query terminal for iTerm graphics support."""
+        self.write_raw(passthrough("\x1b[>q"))
+
+    def get_sgr_pixel_status(self) -> None:
+        """Query terminal to check for Pixel SGR support."""
+        # Enable, check, disable
+        self.write_raw("\x1b[?1016h\x1b[?1016$p\x1b[?1016l")
+
+    def get_csiu_status(self) -> None:
+        """Query terminal to check for CSI-u support."""
+        self.write_raw("\x1b[?u")
+
 
 class PseudoTTY:
     """Make an output stream look like a TTY."""
@@ -139,3 +277,44 @@ class PseudoTTY:
     def __getattr__(self, name: str) -> Any:
         """Return an attribute of the wrappeed stream."""
         return getattr(self._underlying, name)
+
+
+def edit_in_editor(filename: str, line_number: int = 0) -> None:
+    """Suspend the current app and edit a file in an external editor."""
+    import os
+    import shlex
+    import subprocess
+
+    from prompt_toolkit.application.run_in_terminal import run_in_terminal
+
+    def _open_file_in_editor(filename: str) -> None:
+        """Call editor executable."""
+        # If the 'VISUAL' or 'EDITOR' environment variable has been set, use that.
+        # Otherwise, fall back to the first available editor that we can find.
+        for editor in [
+            os.environ.get("VISUAL"),
+            os.environ.get("EDITOR"),
+            "editor",
+            "micro",
+            "nano",
+            "pico",
+            "vi",
+            "emacs",
+        ]:
+            if editor:
+                try:
+                    # Use 'shlex.split()' because $VISUAL can contain spaces and quotes
+                    subprocess.call([*shlex.split(editor), filename])
+                    return
+                except OSError:
+                    # Executable does not exist, try the next one.
+                    pass
+
+    async def run() -> None:
+        # Open in editor
+        # (We need to use `run_in_terminal`, because not all editors go to
+        # the alternate screen buffer, and some could influence the cursor
+        # position)
+        await run_in_terminal(lambda: _open_file_in_editor(filename), in_executor=True)
+
+    get_app().create_background_task(run())

euporie/core/kernel/__init__.py

@@ -0,0 +1 @@
+"""Concerns the interaction with Jupyter kernels."""

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

@@ -6,125 +6,27 @@ import asyncio
 import concurrent.futures
 import logging
 import os
-import re
-import sys
 import threading
-from _frozen_importlib import _DeadlockError
 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 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."""
 
@@ -173,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()
@@ -344,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:
@@ -376,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")
@@ -404,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:
@@ -421,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:
@@ -479,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,
@@ -583,6 +504,8 @@ 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",
@@ -709,18 +632,24 @@ class Kernel:
         """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"]):
+            import nbformat
+
             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"]):
+            import nbformat
+
             add_output(nbformat.v4.output_from_msg(rsp), own)
 
     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"]):
+            import nbformat
+
             add_output(nbformat.v4.output_from_msg(rsp), own)
 
         if (execution_count := rsp.get("content", {}).get("execution_count")) and (
@@ -736,6 +665,8 @@ class Kernel:
         """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")):
+            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", {}))
@@ -744,6 +675,8 @@ class Kernel:
         """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"]):
+            import nbformat
+
             add_output(nbformat.v4.output_from_msg(rsp), own)
 
     def on_iopub_clear_output(self, rsp: dict[str, Any], own: bool) -> None:
@@ -1145,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)
 
@@ -1180,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"