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

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,12 +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,
-    vi,
-)
+from . import basic, completion, micro, mouse, page_navigation, vi
 
 __all__ = ["basic", "completion", "micro", "mouse", "page_navigation", "vi"]

euporie/core/key_binding/bindings/basic.py

@@ -3,16 +3,18 @@
 from __future__ import annotations
 
 import logging
+from functools import partial
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.filters import (
     buffer_has_focus,
 )
-from prompt_toolkit.key_binding import ConditionalKeyBindings
 
 from euporie.core.commands import add_cmd
 from euporie.core.filters import (
-    micro_mode,
+    char_after_cursor,
+    has_matching_bracket,
+    insert_mode,
     replace_mode,
 )
 from euporie.core.key_binding.registry import (
@@ -37,6 +39,12 @@ class TextEntry:
         {
             "euporie.core.key_binding.bindings.basic.TextEntry": {
                 "type-key": "<any>",
+                "complete-bracket-()": "(",
+                "complete-bracket-[]": "[",
+                "complete-bracket-{}": "{",
+                "close-bracket-()": ")",
+                "close-bracket-[]": "]",
+                "close-bracket-{}": "}",
             },
         }
     )
@@ -44,16 +52,18 @@ class TextEntry:
 
 def load_basic_bindings(config: Config | None = None) -> KeyBindingsBase:
     """Load basic key-bindings for text entry."""
-    return ConditionalKeyBindings(
-        load_registered_bindings(
-            "euporie.core.key_binding.bindings.basic.TextEntry", config=config
-        ),
-        micro_mode,
+    # Load additional key definitions
+    from euporie.core import keys  # noqa: F401
+
+    return load_registered_bindings(
+        "euporie.core.key_binding.bindings.basic.TextEntry", config=config
     )
 
 
 # Commands
 
+## Typing keys
+
 
 @add_cmd(filter=buffer_has_focus, save_before=if_no_repeat, hidden=True)
 def type_key(event: KeyPressEvent) -> None:
@@ -63,3 +73,33 @@ def type_key(event: KeyPressEvent) -> None:
         event.current_buffer.insert_text(
             event.data * event.arg, overwrite=replace_mode()
         )
+
+
+## Add automatic bracket completion
+
+
+def _complete_bracket(right: str, event: KeyPressEvent) -> None:
+    event.current_buffer.insert_text(right, move_cursor=False)
+    event.key_processor.feed(event.key_sequence[0], first=True)
+
+
+def _close_bracket(right: str, event: KeyPressEvent) -> None:
+    event.current_buffer.cursor_position += 1
+
+
+for left, right in [("(", ")"), ("[", "]"), ("{", "}")]:
+    add_cmd(
+        name=f"complete-bracket-{left}{right}",
+        filter=buffer_has_focus & insert_mode & ~char_after_cursor(right),
+        save_before=if_no_repeat,
+        hidden=True,
+    )(partial(_complete_bracket, right))
+    add_cmd(
+        name=f"close-bracket-{left}{right}",
+        filter=buffer_has_focus
+        & insert_mode
+        & char_after_cursor(right)
+        & has_matching_bracket,
+        save_before=if_no_repeat,
+        hidden=True,
+    )(partial(_close_bracket, right))

euporie/core/key_binding/bindings/completion.py

@@ -18,18 +18,14 @@ from prompt_toolkit.key_binding.bindings.named_commands import (
 )
 
 from euporie.core.commands import add_cmd
-from euporie.core.filters import buffer_is_code, cursor_in_leading_ws, insert_mode
+from euporie.core.filters import cursor_in_leading_ws, insert_mode
 from euporie.core.key_binding.registry import register_bindings
 
 log = logging.getLogger(__name__)
 
 
 add_cmd(
-    filter=buffer_has_focus
-    & insert_mode
-    & ~has_selection
-    & buffer_is_code
-    & ~cursor_in_leading_ws,
+    filter=buffer_has_focus & insert_mode & ~has_selection & ~cursor_in_leading_ws,
     hidden=True,
     name="next-completion",
     description="Show the completion menu and select the next completion.",
@@ -65,12 +61,11 @@ def accept_completion() -> None:
     complete_state = buffer.complete_state
     if complete_state and isinstance(complete_state.current_completion, Completion):
         buffer.apply_completion(complete_state.current_completion)
-        get_app().layout.focus(buffer)
 
 
 register_bindings(
     {
-        "euporie.core.app.BaseApp": {
+        "euporie.core.app.app:BaseApp": {
             "next-completion": "c-i",
             "previous-completion": "s-tab",
             "cancel-completion": "escape",

euporie/core/key_binding/bindings/micro.py

@@ -7,10 +7,8 @@ import re
 from functools import partial
 from typing import TYPE_CHECKING
 
-from aenum import extend_enum
 from prompt_toolkit.buffer import indent, unindent
 from prompt_toolkit.document import Document
-from prompt_toolkit.enums import EditingMode
 from prompt_toolkit.filters import (
     buffer_has_focus,
     has_selection,
@@ -40,8 +38,8 @@ from prompt_toolkit.key_binding.bindings.scroll import (
 from prompt_toolkit.keys import Keys
 from prompt_toolkit.selection import SelectionState, SelectionType
 
+from euporie.core.app.current import get_app
 from euporie.core.commands import add_cmd, get_cmd
-from euporie.core.current import get_app
 from euporie.core.filters import (
     buffer_is_code,
     buffer_is_markdown,
@@ -74,9 +72,6 @@ class EditMode:
     """Micro style editor key-bindings."""
 
 
-# Register micro edit mode
-extend_enum(EditingMode, "MICRO", "MICRO")
-
 # Register default bindings for micro edit mode
 register_bindings(
     {

euporie/core/key_binding/bindings/mouse.py

@@ -24,7 +24,7 @@ from prompt_toolkit.mouse_events import MouseButton, MouseEventType, MouseModifi
 from prompt_toolkit.mouse_events import MouseEvent as PtkMouseEvent
 from prompt_toolkit.renderer import HeightIsUnknownError
 
-from euporie.core.app import BaseApp
+from euporie.core.app.app import BaseApp
 
 if TYPE_CHECKING:
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
@@ -155,7 +155,7 @@ def load_mouse_bindings() -> KeyBindings:
             return NotImplemented
 
         mouse_event = _MOUSE_EVENT_CACHE[
-            event.data, app.term_info.sgr_pixel_status.value, app.term_info.cell_size_px
+            event.data, app.term_sgr_pixel, app.cell_size_px
         ]
 
         if mouse_event is None:

euporie/core/key_binding/bindings/terminal.py

@@ -0,0 +1,193 @@
+"""Contains key handlers for terminal queries."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from euporie.core.commands import add_cmd
+from euporie.core.key_binding.registry import (
+    load_registered_bindings,
+    register_bindings,
+)
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding import KeyBindingsBase, KeyPressEvent
+
+    from euporie.core.config import Config
+
+log = logging.getLogger(__name__)
+
+_COLOR_NAMES: dict[str, str] = {
+    "10": "fg",
+    "11": "bg",
+    "4;0": "ansiblack",
+    "4;1": "ansired",
+    "4;2": "ansigreen",
+    "4;3": "ansiyellow",
+    "4;4": "ansiblue",
+    "4;5": "ansipurple",
+    "4;6": "ansicyan",
+    "4;7": "ansiwhite",
+    "4;8": "ansirbightblack",
+    "4;9": "ansirbightred",
+    "4;10": "ansirbightgreen",
+    "4;11": "ansirbightyellow",
+    "4;12": "ansirbightblue",
+    "4;13": "ansirbightpurple",
+    "4;14": "ansirbightcyan",
+    "4;15": "ansirbightwhite",
+}
+
+
+def get_match(event: KeyPressEvent) -> dict[str, str] | None:
+    """Get pattern matches from a key press event."""
+    if (
+        (parser := getattr(event.app.input, "vt100_parser", None))
+        and (patterns := getattr(parser, "patterns", None))
+        and (pattern := patterns.get(event.key_sequence[-1].key))
+        and (match := pattern.match(event.data))
+        and (values := match.groupdict())
+    ):
+        return values
+    return None
+
+
+@add_cmd(hidden=True, is_global=True)
+def _set_terminal_color(event: KeyPressEvent) -> object:
+    """Run when the terminal receives a terminal color query response.
+
+    Args:
+        event: The key press event received when the termina sends a response
+
+    Returns:
+        :py:obj:`NotImplemented`, so the application is not invalidated when a
+        response from the terminal is received
+
+    """
+    from euporie.core.app.app import BaseApp
+
+    if isinstance(app := event.app, BaseApp) and (colors := get_match(event)):
+        c = colors["c"]
+        r, g, b = colors.get("r", "00"), colors.get("g", "00"), colors.get("b", "00")
+        app.term_colors[_COLOR_NAMES.get(c, c)] = f"#{r[:2]}{g[:2]}{b[:2]}"
+        app.update_style()
+    return NotImplemented
+
+
+@add_cmd(hidden=True, is_global=True)
+def _set_terminal_pixel_size(event: KeyPressEvent) -> object:
+    """Run when the terminal receives a pixel dimension query response."""
+    from euporie.core.app.app import BaseApp
+
+    if (
+        isinstance(app := event.app, BaseApp)
+        and (values := get_match(event))
+        and (x := values.get("x"))
+        and (y := values.get("y"))
+    ):
+        app.term_size_px = int(x), int(y)
+    return NotImplemented
+
+
+@add_cmd(hidden=True, is_global=True)
+def _set_terminal_graphics_sixel(event: KeyPressEvent) -> object:
+    """Run when the terminal receives a sixel graphics support query response."""
+    from euporie.core.app.app import BaseApp
+
+    if (
+        isinstance(app := event.app, BaseApp)
+        and (values := get_match(event))
+        and values.get("sixel")
+    ):
+        app.term_graphics_sixel = True
+    return NotImplemented
+
+
+@add_cmd(hidden=True, is_global=True)
+def _set_terminal_graphics_iterm(event: KeyPressEvent) -> object:
+    """Run when the terminal receives a iterm graphics support query response."""
+    from euporie.core.app.app import BaseApp
+
+    if (
+        isinstance(app := event.app, BaseApp)
+        and (values := get_match(event))
+        and (term := values.get("term"))
+        and term.startswith(("WezTerm", "Konsole", "mlterm"))
+    ):
+        app.term_graphics_iterm = True
+    return NotImplemented
+
+
+@add_cmd(hidden=True, is_global=True)
+def _set_terminal_graphics_kitty(event: KeyPressEvent) -> object:
+    """Run when the terminal receives a kitty graphics support query response."""
+    from euporie.core.app.app import BaseApp
+
+    if (
+        isinstance(app := event.app, BaseApp)
+        and (values := get_match(event))
+        and values.get("status") == "OK"
+    ):
+        app.term_graphics_kitty = True
+    return NotImplemented
+
+
+@add_cmd(hidden=True, is_global=True)
+def _set_terminal_sgr_pixel(event: KeyPressEvent) -> object:
+    """Run when the terminal receives a SGR-pixel mode support query response."""
+    from euporie.core.app.app import BaseApp
+
+    if (
+        isinstance(app := event.app, BaseApp)
+        and (values := get_match(event))
+        and (values.get("Pm") in {"1", "3"})
+    ):
+        app.term_sgr_pixel = True
+    return NotImplemented
+
+
+@add_cmd(hidden=True, is_global=True)
+def _set_terminal_clipboard_data(event: KeyPressEvent) -> object:
+    """Run when the terminal receives a clipboard data query response."""
+    from base64 import b64decode
+
+    from euporie.core.app.app import BaseApp
+    from euporie.core.clipboard import Osc52Clipboard
+
+    if (
+        isinstance(app := event.app, BaseApp)
+        and isinstance(clipboard := app.clipboard, Osc52Clipboard)
+        and (values := get_match(event))
+    ):
+        value = values.get("data", "")
+        text = b64decode(value).decode()
+        log.warning(repr(text))
+        clipboard.sync(text)
+    return NotImplemented
+
+
+class TerminalQueries:
+    """Key bindings for terminal query responses."""
+
+
+register_bindings(
+    {
+        "euporie.core.io.TerminalInfo": {
+            "set-terminal-color": "<colors-response>",
+            "set-terminal-pixel-size": "<pixel-size-response>",
+            "set-terminal-graphics-kitty": "<kitty-graphics-status-response>",
+            "set-terminal-graphics-sixel": "<sixel-graphics-status-response>",
+            "set-terminal-graphics-iterm": "<iterm-graphics-status-response>",
+            "set-terminal-sgr-pixel": "<sgr-pixel-status-response>",
+            "set-terminal-clipboard-data": "<clipboard-data-response>",
+        }
+    }
+)
+
+
+def load_terminal_bindings(config: Config | None = None) -> KeyBindingsBase:
+    """Load editor key-bindings in the style of the ``micro`` text editor."""
+    return load_registered_bindings(
+        "euporie.core.key_binding.bindings.terminal.TerminalQueries", config=config
+    )

euporie/core/key_binding/key_processor.py

@@ -4,21 +4,39 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import time
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.application.current import get_app
+from prompt_toolkit.key_binding.key_processor import KeyPress, _Flush
 from prompt_toolkit.key_binding.key_processor import KeyProcessor as PtKeyProcessor
-from prompt_toolkit.key_binding.key_processor import _Flush
 from prompt_toolkit.keys import Keys
 
+from euporie.core.keys import MoreKeys
+
 if TYPE_CHECKING:
     from typing import Any
 
-    from prompt_toolkit.key_binding.key_processor import KeyPress
 
 log = logging.getLogger(__name__)
 
 
+def _kp_init(
+    self: KeyPress, key: Keys | MoreKeys | str, data: str | None = None
+) -> None:
+    """Include more keys when creating a KeyPress."""
+    assert isinstance(key, (Keys | MoreKeys)) or len(key) == 1, (
+        f"key {key!r} ({type(key)}) not recoognised {MoreKeys(key)}"
+    )
+    if data is None:
+        data = key.value if isinstance(key, (Keys, MoreKeys)) else key
+    self.key = key
+    self.data = data
+
+
+setattr(KeyPress, "__init__", _kp_init)  # noqa: B010
+
+
 class KeyProcessor(PtKeyProcessor):
     """A subclass of prompt_toolkit's keyprocessor.
 
@@ -125,3 +143,26 @@ class KeyProcessor(PtKeyProcessor):
         # Skip timeout if the last key was flush.
         if not is_flush:
             self._start_timeout()
+
+    def await_key(self, key: Keys | MoreKeys, timeout: float = 1.0) -> None:
+        """Wait for a particular key, processing it before all other keys.
+
+        Args:
+            key: The key to wait for
+            timeout: How long to wait for the key, in seconds
+        """
+        # Wait up to 1 second for response from terminal
+        start = time.monotonic()
+        input = get_app().input
+        tkp = self.__class__(key_bindings=self._bindings)
+        while (time.monotonic() - start) < timeout:
+            time.sleep(0.05)
+            for press in input.read_keys():
+                if press.key == key:
+                    # If we find the key we're after, process it immediately
+                    tkp.feed_multiple([press, _Flush])
+                    tkp.process_keys()
+                    return
+                else:
+                    # If we get other keys, add them to the input queue
+                    self.feed(press)

euporie/core/key_binding/registry.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from functools import lru_cache
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.key_binding import KeyBindings
@@ -31,6 +32,7 @@ def register_bindings(bindings: dict[str, KeyBindingDefs]) -> None:
             BINDINGS[group][command] = keys
 
 
+@lru_cache
 def load_registered_bindings(
     *names: str, config: Config | None = None
 ) -> KeyBindingsBase:

euporie/core/key_binding/utils.py

@@ -4,9 +4,11 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from prompt_toolkit.key_binding.key_bindings import _parse_key
+from prompt_toolkit.key_binding import key_bindings
+from prompt_toolkit.key_binding.key_bindings import _parse_key as _ptk_parse_key
+from prompt_toolkit.keys import Keys
 
-from euporie.core.keys import Keys
+from euporie.core.keys import MoreKeys
 
 if TYPE_CHECKING:
     from prompt_toolkit.key_binding import KeyPressEvent
@@ -28,6 +30,24 @@ def if_no_repeat(event: KeyPressEvent) -> bool:
     return not event.is_repeat
 
 
+def _parse_key(key: AnyKeys | MoreKeys | str) -> Keys | MoreKeys | str:
+    """Parse a key or string, including additional keys."""
+    if isinstance(key, (Keys, str)):
+        try:
+            return _ptk_parse_key(key)
+        except ValueError:
+            pass
+    if isinstance(key, MoreKeys):
+        return key
+    try:
+        return MoreKeys(key)
+    except ValueError as err:
+        raise ValueError("Key binding not recognised") from err
+
+
+key_bindings._parse_key = _parse_key
+
+
 def parse_keys(keys: AnyKeys) -> list[tuple[str | Keys, ...]]:
     """Pare a list of keys."""
     output: list[tuple[str | Keys, ...]] = []