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

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(
     {
@@ -680,6 +675,9 @@ def dent_buffer(event: KeyPressEvent, indenting: bool = True) -> None:
             )
             * sign
         )
+        selection_state.original_cursor_position = max(
+            min(selection_state.original_cursor_position, len(buffer.text)), 0
+        )
     # Maintain the selection state before indentation
     buffer.selection_state = selection_state
 
@@ -722,7 +720,7 @@ def indent_lines(event: KeyPressEvent) -> None:
 @add_cmd(
     filter=buffer_has_focus
     & (cursor_in_leading_ws | has_selection)
-    & ~cursor_at_start_of_line,
+    & (~cursor_at_start_of_line | cursor_at_start_of_line),
 )
 def unindent_lines(event: KeyPressEvent) -> None:
     """Unindent the current or selected lines."""

euporie/core/key_binding/bindings/mouse.py

@@ -22,8 +22,9 @@ from prompt_toolkit.key_binding.bindings.mouse import (
 from prompt_toolkit.keys import Keys
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType, MouseModifier
 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
@@ -102,29 +103,23 @@ def _parse_mouse_data(
         # Parse event type.
         if sgr:
             if sgr_pixels:
-                # Calculate cell position
+                # Scale down pixel-wise mouse position to cell based, and calculate
+                # relative position of mouse within the cell
                 cell_x, cell_y = cell_size_xy
                 px, py = x, y
                 fx, fy = px / cell_x + 1, py / cell_y + 1
                 x, y = int(fx), int(fy)
                 rx, ry = fx - x, fy - y
-
             try:
-                (
-                    mouse_button,
-                    mouse_event_type,
-                    mouse_modifiers,
-                ) = xterm_sgr_mouse_events[mouse_event, m]
+                (mouse_button, mouse_event_type, mouse_modifiers) = (
+                    xterm_sgr_mouse_events[mouse_event, m]
+                )
             except KeyError:
                 return None
 
         else:
             # Some other terminals, like urxvt, Hyper terminal, ...
-            (
-                mouse_button,
-                mouse_event_type,
-                mouse_modifiers,
-            ) = urxvt_mouse_events.get(
+            (mouse_button, mouse_event_type, mouse_modifiers) = urxvt_mouse_events.get(
                 mouse_event, (UNKNOWN_BUTTON, MOUSE_MOVE, UNKNOWN_MODIFIER)
             )
 
@@ -153,13 +148,14 @@ def load_mouse_bindings() -> KeyBindings:
     def _(event: KeyPressEvent) -> NotImplementedOrNone:
         """Handle incoming mouse event, include SGR-pixel mode."""
         # Ensure mypy knows this would only run in a euporie appo
-        assert isinstance(app := event.app, BaseApp)
+        app = event.app
+        assert isinstance(app, BaseApp)
 
-        if not event.app.renderer.height_is_known:
+        if not app.renderer.height_is_known:
             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:
@@ -169,10 +165,9 @@ def load_mouse_bindings() -> KeyBindings:
         if mouse_event.event_type is not None:
             # Take region above the layout into account. The reported
             # coordinates are absolute to the visible part of the terminal.
-            from prompt_toolkit.renderer import HeightIsUnknownError
-
             x, y = mouse_event.position
 
+            # Adjust position to take into account space above non-full screen apps
             try:
                 rows_above = app.renderer.rows_above_layout
             except HeightIsUnknownError:
@@ -180,28 +175,35 @@ def load_mouse_bindings() -> KeyBindings:
             else:
                 y -= rows_above
 
-            # Save global mouse position
-            app.mouse_position = mouse_event.position
+            # Save mouse position within the app
+            app.mouse_position = Point(x=x, y=y)
 
             # Apply limits to mouse position if enabled
             if (mouse_limits := app.mouse_limits) is not None:
                 x = max(
                     mouse_limits.xpos,
-                    min(x, mouse_limits.xpos + (mouse_limits.width - 1)),
+                    min(x, mouse_limits.xpos + (mouse_limits.width) - 1),
                 )
                 y = max(
                     mouse_limits.ypos,
-                    min(y, mouse_limits.ypos + (mouse_limits.height - 1)),
+                    min(y, mouse_limits.ypos + (mouse_limits.height) - 1),
                 )
 
-            mouse_event.position = Point(x=x, y=y)
+            # Do not modify the mouse event in the cache, instead create a new instance
+            mouse_event = MouseEvent(
+                position=Point(x=x, y=y),
+                event_type=mouse_event.event_type,
+                button=mouse_event.button,
+                modifiers=mouse_event.modifiers,
+                cell_position=mouse_event.cell_position,
+            )
 
             # Call the mouse handler from the renderer.
             # Note: This can return `NotImplemented` if no mouse handler was
             #       found for this position, or if no repainting needs to
             #       happen. this way, we avoid excessive repaints during mouse
             #       movements.
-            handler = event.app.renderer.mouse_handlers.mouse_handlers[y][x]
+            handler = app.renderer.mouse_handlers.mouse_handlers[y][x]
 
             return handler(mouse_event)
 

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/bindings/vi.py

@@ -0,0 +1,46 @@
+"""Add additional keys to the prompt_toolkit vi key-bindings."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from prompt_toolkit.buffer import indent, unindent
+from prompt_toolkit.filters.app import vi_insert_mode
+from prompt_toolkit.key_binding.bindings.vi import (
+    load_vi_bindings as load_ptk_vi_bindings,
+)
+
+from euporie.core.filters import cursor_in_leading_ws
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding.key_bindings import (
+        ConditionalKeyBindings,
+        KeyBindings,
+        KeyBindingsBase,
+    )
+    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+
+
+def load_vi_bindings() -> KeyBindingsBase:
+    """Load vi keybindings from PTK, adding additional bindings."""
+    # We know the type of the vi bindings
+    vi_bindings = cast(
+        "KeyBindings",
+        cast("ConditionalKeyBindings", load_ptk_vi_bindings()).key_bindings,
+    )
+    handle = vi_bindings.add
+
+    @handle("c-i", filter=vi_insert_mode & cursor_in_leading_ws)
+    def _indent(event: KeyPressEvent) -> None:
+        """Indent lines."""
+        buffer = event.current_buffer
+        current_row = buffer.document.cursor_position_row
+        indent(buffer, current_row, current_row + event.arg)
+
+    @handle("s-tab", filter=vi_insert_mode & cursor_in_leading_ws)
+    def _unindent(event: KeyPressEvent) -> None:
+        """Unindent lines."""
+        current_row = event.current_buffer.document.cursor_position_row
+        unindent(event.current_buffer, current_row, current_row + event.arg)
+
+    return vi_bindings

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, ...]] = []