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

euporie/core/app/base.py

@@ -0,0 +1,51 @@
+"""Define a base class for configurable apps."""
+
+from __future__ import annotations
+
+from abc import ABC
+from inspect import isabstract
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, ClassVar
+
+    from euporie.core.config import Config
+
+
+class ConfigurableApp(ABC):
+    """An application with configuration."""
+
+    name: str | None = None
+    config: Config
+    _config_defaults: ClassVar[dict[str, Any]] = {"log_level_stdout": "error"}
+
+    def __init_subclass__(cls) -> None:
+        """Create a config instance for each non-abstract subclass."""
+        if not isabstract(cls):
+            from euporie.core.config import Config
+
+            # Load settings
+            cls.load_settings()
+            cls.config = Config(
+                app=cls.name,
+                _help=cls.__doc__ or "",
+                **cls._config_defaults,
+            )
+
+    @classmethod
+    def load_settings(cls) -> None:
+        """Load all known settings for this class."""
+        from euporie.core.utils import import_submodules, root_module
+
+        roots = {
+            root_module(base.__module__)
+            for base in cls.__mro__
+            if base.__module__.startswith("euporie.")
+        }
+        for root in roots:
+            import_submodules(root, ("_settings", "_commands"))
+
+    @classmethod
+    def launch(cls) -> None:
+        """Launch the app."""
+        cls.config.load()

euporie/core/{current.py → app/current.py}

@@ -7,16 +7,25 @@ from typing import TYPE_CHECKING
 from prompt_toolkit.application.current import _current_app_session
 
 if TYPE_CHECKING:
-    from euporie.core.app import BaseApp
+    from euporie.core.app.app import BaseApp
 
 
 def get_app() -> BaseApp:
     """Get the current active (running) Application."""
-    from euporie.core.app import BaseApp
+    from euporie.core.app.app import BaseApp
 
     session = _current_app_session.get()
     if isinstance(session.app, BaseApp):
         return session.app
 
-    # Use a baseapp as our "DummyApplication"
-    return BaseApp()
+    # Create a dummy application if we really need one
+    from euporie.core.app.dummy import DummyApp
+
+    return DummyApp()
+
+
+def get_app_cls(name: str) -> BaseApp:
+    """Load a euporie app by name."""
+    from euporie.core.__main__ import available_apps
+
+    return available_apps()[name].load()

euporie/core/app/cursor.py

@@ -0,0 +1,35 @@
+"""Define configurable cursors."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.cursor_shapes import CursorShape, CursorShapeConfig
+
+from euporie.core.filters import insert_mode, replace_mode
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from prompt_toolkit.application.application import Application
+
+
+class CursorConfig(CursorShapeConfig):
+    """Determine which cursor mode to use."""
+
+    def get_cursor_shape(self, app: Application[Any]) -> CursorShape:
+        """Return the cursor shape to be used in the current state."""
+        from euporie.core.app.app import BaseApp
+
+        if isinstance(app, BaseApp) and app.config.set_cursor_shape:
+            if insert_mode():
+                if app.config.cursor_blink:
+                    return CursorShape.BLINKING_BEAM
+                else:
+                    return CursorShape.BEAM
+            elif replace_mode():
+                if app.config.cursor_blink:
+                    return CursorShape.BLINKING_UNDERLINE
+                else:
+                    return CursorShape.UNDERLINE
+        return CursorShape.BLOCK

euporie/core/app/dummy.py

@@ -0,0 +1,12 @@
+"""Define a dummy application."""
+
+from euporie.core.app.app import BaseApp
+from euporie.core.layout.containers import DummyContainer
+
+
+class DummyApp(BaseApp):
+    """An empty application which does nothing."""
+
+    def load_container(self) -> DummyContainer:
+        """Load a dummy container as the root container."""
+        return DummyContainer()

euporie/core/app/launch.py

@@ -0,0 +1,28 @@
+"""Define a simple app for launching euporie apps."""
+
+from __future__ import annotations
+
+from euporie.core.app import APP_ALIASES
+from euporie.core.app.base import ConfigurableApp
+
+
+class LaunchApp(ConfigurableApp):
+    """Launch a euporie application."""
+
+    @classmethod
+    def launch(cls) -> None:
+        """Launch an app."""
+        super().launch()
+
+        # Detect selected app
+        chosen_app = cls.config.app
+        chosen_app = APP_ALIASES.get(chosen_app, chosen_app)
+
+        # Run the application
+        from euporie.core.__main__ import main
+
+        main(chosen_app)
+
+
+if __name__ == "__main__":
+    LaunchApp.launch()

euporie/core/bars/__init__.py

@@ -0,0 +1,11 @@
+"""Defines various tool bars displayed at the bottom of apps."""
+
+# Define toolbar buffer names
+
+SEARCH_BAR_BUFFER = "SEARCH_BAR_BUFFER"
+COMMAND_BAR_BUFFER = "COMMAND_BAR_BUFFER"
+
+BAR_BUFFERS = {
+    SEARCH_BAR_BUFFER,
+    COMMAND_BAR_BUFFER,
+}

euporie/core/bars/command.py

@@ -0,0 +1,205 @@
+"""Define the global command toolbar."""
+
+from __future__ import annotations
+
+import logging
+import re
+from functools import lru_cache
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.completion.base import Completer, Completion
+from prompt_toolkit.filters import buffer_has_focus, has_focus, vi_navigation_mode
+from prompt_toolkit.key_binding.vi_state import InputMode
+from prompt_toolkit.layout.containers import ConditionalContainer, Container, Window
+from prompt_toolkit.layout.controls import (
+    BufferControl,
+)
+from prompt_toolkit.layout.processors import BeforeInput, HighlightSelectionProcessor
+from prompt_toolkit.lexers import SimpleLexer
+from prompt_toolkit.validation import Validator
+
+from euporie.core.app.current import get_app
+from euporie.core.bars import COMMAND_BAR_BUFFER
+from euporie.core.commands import add_cmd, commands, get_cmd
+from euporie.core.key_binding.registry import (
+    load_registered_bindings,
+    register_bindings,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from prompt_toolkit.completion.base import CompleteEvent
+    from prompt_toolkit.document import Document
+    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+
+    from euporie.core.commands import Command
+
+log = logging.getLogger(__name__)
+
+
+@lru_cache
+def _parse_cmd(text: str) -> tuple[Command | None, str]:
+    """Parse a command line to command and arguments.
+
+    Command names cannot start with digits, so lines staring with digits have an empty
+    command string (this is used for the go-to-cell/go-to-line shortcuts).
+    """
+    if match := re.fullmatch(r"^(?P<cmd>[^\d][^\s]*|)\s*(?P<args>.*)$", text):
+        cmd, args = match.groups()
+    else:
+        cmd, args = "", ""
+    try:
+        return get_cmd(cmd), args
+    except KeyError:
+        return None, args
+
+
+class CommandCompleter(Completer):
+    """Completer of commands."""
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        """Complete registered commands."""
+        prefix = document.text
+        found_so_far: set[Command] = set()
+        for alias, command in commands.items():
+            if (
+                alias.startswith(prefix)
+                and command not in found_so_far
+                and not command.hidden()
+            ):
+                yield Completion(
+                    command.name,
+                    start_position=-len(prefix),
+                    display=command.name,
+                    display_meta=command.description,
+                )
+                found_so_far.add(command)
+
+
+class CommandBar:
+    """Command mode toolbar.
+
+    A modal editor like toolbar to allow entry of commands.
+    """
+
+    def __init__(self) -> None:
+        """Create a new command bar instance."""
+        self.buffer = Buffer(
+            completer=CommandCompleter(),
+            complete_while_typing=True,
+            name=COMMAND_BAR_BUFFER,
+            multiline=False,
+            accept_handler=self._accept,
+            validator=Validator.from_callable(
+                validate_func=self._validate,
+                error_message="Command not recognised",
+                move_cursor_to_end=True,
+            ),
+        )
+        self.control = BufferControl(
+            buffer=self.buffer,
+            lexer=SimpleLexer(style="class:toolbar.text"),
+            input_processors=[
+                BeforeInput(":", style="class:toolbar.title"),
+                HighlightSelectionProcessor(),
+            ],
+            include_default_input_processors=False,
+            key_bindings=load_registered_bindings(
+                "euporie.core.bars.command:CommandBar",
+                config=get_app().config,
+            ),
+        )
+        self.window = Window(
+            self.control,
+            height=1,
+            style="class:toolbar",
+        )
+
+        self.container = ConditionalContainer(
+            content=self.window,
+            filter=has_focus(self.buffer),
+        )
+
+    def _validate(self, text: str) -> bool:
+        """Verify that a valid command has been entered."""
+        cmd, _args = _parse_cmd(text)
+        return bool(cmd)
+
+    def _accept(self, buffer: Buffer) -> bool:
+        """Return value determines if the text is kept."""
+        app = get_app()
+        app.vi_state.input_mode = InputMode.NAVIGATION
+        app.layout.focus_last()
+        text = buffer.text.strip()
+        cmd, args = _parse_cmd(text)
+        if cmd:
+            cmd.run(args)
+        return False
+
+    def __pt_container__(self) -> Container:
+        """Magic method for widget container."""
+        return self.container
+
+    register_bindings(
+        {
+            "euporie.core.app.app:BaseApp": {
+                "activate-command-bar": ":",
+                "activate-command-bar-alt": "A-:",
+                "activate-command-bar-shell": "!",
+                "activate-command-bar-shell-alt": "A-!",
+            },
+            "euporie.core.bars.command:CommandBar": {
+                "deactivate-command-bar": ["escape", "c-c"],
+            },
+        }
+    )
+
+    @staticmethod
+    @add_cmd(name="activate-command-bar-alt", hidden=True)
+    @add_cmd(filter=~buffer_has_focus | vi_navigation_mode)
+    def _activate_command_bar(event: KeyPressEvent) -> None:
+        """Enter command mode."""
+        event.app.layout.focus(COMMAND_BAR_BUFFER)
+        event.app.vi_state.input_mode = InputMode.INSERT
+
+    @staticmethod
+    @add_cmd(filter=~buffer_has_focus)
+    @add_cmd(name="activate-command-bar-shell-alt", hidden=True)
+    def _activate_command_bar_shell(event: KeyPressEvent) -> None:
+        """Enter command mode."""
+        app = event.app
+        layout = app.layout
+        layout.focus(COMMAND_BAR_BUFFER)
+        app.vi_state.input_mode = InputMode.INSERT
+        if isinstance(control := layout.current_control, BufferControl):
+            buffer = control.buffer
+            buffer.text = "shell "
+            buffer.cursor_position = 6
+
+    @staticmethod
+    @add_cmd(hidden=True)
+    def _deactivate_command_bar(event: KeyPressEvent) -> None:
+        """Exit command mode."""
+        app = event.app
+        layout = app.layout
+        layout.focus(COMMAND_BAR_BUFFER)
+        if isinstance(control := layout.current_control, BufferControl):
+            app.vi_state.input_mode = InputMode.NAVIGATION
+            buffer = control.buffer
+            buffer.reset()
+            app.layout.focus_previous()
+
+    @staticmethod
+    @add_cmd(aliases=["shell"])
+    async def _run_shell_command(event: KeyPressEvent) -> None:
+        """Run system command."""
+        app = event.app
+        if event._arg:
+            await app.run_system_command(
+                event._arg,
+                display_before_text=[("bold", "$ "), ("", f"{event._arg}\n")],
+            )

euporie/core/bars/menu.py

@@ -0,0 +1,258 @@
+"""Contains a completion menu for toolbars."""
+
+from __future__ import annotations
+
+import logging
+from math import ceil
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.filters import Condition, has_completions, is_done
+from prompt_toolkit.layout.containers import ConditionalContainer, Window
+from prompt_toolkit.layout.controls import GetLinePrefixCallable, UIContent, UIControl
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.utils import get_cwidth
+
+from euporie.core.app.current import get_app
+from euporie.core.filters import has_toolbar
+from euporie.core.ft.utils import apply_style, pad, truncate
+from euporie.core.layout.containers import HSplit
+
+if TYPE_CHECKING:
+    from prompt_toolkit.buffer import CompletionState
+    from prompt_toolkit.formatted_text import StyleAndTextTuples
+    from prompt_toolkit.key_binding.key_bindings import (
+        KeyBindingsBase,
+        NotImplementedOrNone,
+    )
+    from prompt_toolkit.mouse_events import MouseEvent
+
+log = logging.getLogger(__name__)
+
+
+class ToolbarCompletionMenuControl(UIControl):
+    """A completion menu for toolbars."""
+
+    def __init__(self, min_item_width: int = 5, max_item_width: int = 30) -> None:
+        """Define minimum and maximum item widhth."""
+        self.max_item_width = max_item_width
+        self.min_item_width = min_item_width
+
+    def preferred_width(self, max_available_width: int) -> int | None:
+        """Fill available width."""
+        return max_available_width
+
+    def preferred_height(
+        self,
+        width: int,
+        max_available_height: int,
+        wrap_lines: bool,
+        get_line_prefix: GetLinePrefixCallable | None,
+    ) -> int | None:
+        """Calculate how many rows to use, filling the width first then overflowing."""
+        complete_state = get_app().current_buffer.complete_state
+        if complete_state is None:
+            return 0
+
+        col_width = self._get_col_width(complete_state, width, max_available_height)
+        height = min(
+            ceil(col_width * len(complete_state.completions) / width),
+            max_available_height,
+        )
+        return height
+
+    def _get_col_width(
+        self, complete_state: CompletionState, width: int, height: int
+    ) -> int:
+        """Calculate the optimal width for the items in the menu."""
+        completions = complete_state.completions
+        item_width = max(
+            min(
+                max(get_cwidth(c.display_text) + 3 for c in completions),
+                self.max_item_width,
+            ),
+            self.min_item_width,
+        )
+        col_count = width // item_width
+        # With an overflow reduce column width to show more of the truncated column
+        if len(completions) > col_count * height:
+            col_width = min((width - 6) // col_count, item_width)
+        # With an exact width expand columns to fill the space
+        elif len(completions) == col_count * height:
+            col_width = max(width // col_count, item_width)
+        # Otherwise use the calculated item width
+        else:
+            col_width = item_width
+        return col_width
+
+    def create_content(self, width: int, height: int) -> UIContent:
+        """Create a UIContent object for this control."""
+        complete_state = get_app().current_buffer.complete_state
+        if complete_state is None:
+            return UIContent()
+
+        completions = complete_state.completions
+        index = complete_state.complete_index  # Can be None!
+
+        # Calculate width of completions menu.
+        col_width = self._get_col_width(complete_state, width, height)
+        # Calculate offset to ensure active completion is visible
+        cur_col = (index or 0) // height
+        visible_cols = width // col_width
+        offset = max(0, cur_col - visible_cols + 1) * height
+
+        # Pad and style visible items
+        items: list[StyleAndTextTuples] = []
+        item: StyleAndTextTuples
+        for i in range(offset, offset + ((visible_cols + 1) * height)):
+            if i < len(completions):
+                item = completions[i].display
+                item = truncate(item, col_width - 3)
+                item = pad(item, width=col_width - 3)
+                item = [("", " "), *item, ("", " ")]
+                item = apply_style(item, "class:completion")
+                if i == index:
+                    item = apply_style(item, "class:current")
+                item = [*item, ("", " ")]
+            else:
+                item = [("", " " * col_width)]
+            items.append(item)
+
+        # Construct rows
+        overflow_left = offset > height
+        overflow_right = (len(completions) - offset) - (visible_cols * height) > 0
+        lines: list[StyleAndTextTuples] = (
+            [
+                [("class:overflow", "◀" if i == height // 2 else " ")]
+                for i in range(height)
+            ]
+            if overflow_left
+            else [[] for _ in range(height)]
+        )
+        for i, item in enumerate(items):
+            row = i % height
+            col = i // height
+            if col == visible_cols:
+                item = [
+                    *truncate(
+                        item,
+                        width - overflow_left - overflow_right - col_width * col,
+                        placeholder="",
+                    ),
+                    ("class:overflow", "▶" if row == height // 2 else " "),
+                ]
+            lines[row].extend(item)
+
+        def get_line(i: int) -> StyleAndTextTuples:
+            return lines[i]
+
+        return UIContent(
+            get_line=get_line,
+            cursor_position=Point(x=0, y=0),  # y=index or 0),
+            line_count=len(lines),
+        )
+
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
+        """Handle mouse events.
+
+        When `NotImplemented` is returned, it means that the given event is not
+        handled by the `UIControl` itself. The `Window` or key bindings can
+        decide to handle this event as scrolling or changing focus.
+
+        :param mouse_event: `MouseEvent` instance.
+        """
+        return NotImplemented
+
+    def move_cursor_down(self) -> None:
+        """Request to move the cursor down.
+
+        This happens when scrolling down and the cursor is completely at the top.
+        """
+
+    def move_cursor_up(self) -> None:
+        """Request to move the cursor up."""
+
+    def get_key_bindings(self) -> KeyBindingsBase | None:
+        """Key bindings that are specific for this user control.
+
+        Return a :class:`.KeyBindings` object if some key bindings are
+        specified, or `None` otherwise.
+        """
+
+
+class SelectedCompletionMetaControl(UIControl):
+    """Control that shows the meta information of the selected completion."""
+
+    def preferred_width(self, max_available_width: int) -> int | None:
+        """Report the width of the active meta text."""
+        if (
+            (state := get_app().current_buffer.complete_state)
+            and (current_completion := state.current_completion)
+            and (text := current_completion.display_meta_text)
+        ):
+            return get_cwidth(text) + 2
+        return 0
+
+    def preferred_height(
+        self,
+        width: int,
+        max_available_height: int,
+        wrap_lines: bool,
+        get_line_prefix: GetLinePrefixCallable | None,
+    ) -> int | None:
+        """Maintain a single line."""
+        return 1
+
+    def create_content(self, width: int, height: int) -> UIContent:
+        """Format the current completion meta text."""
+        ft: StyleAndTextTuples = []
+        state = get_app().current_buffer.complete_state
+        if (
+            (state := get_app().current_buffer.complete_state)
+            and (current_completion := state.current_completion)
+            and (meta := current_completion.display_meta)
+        ):
+            ft = apply_style([("", " "), *meta, ("", " ")], style="class:meta")
+
+        def get_line(i: int) -> StyleAndTextTuples:
+            return ft
+
+        return UIContent(get_line=get_line, line_count=1 if ft else 0)
+
+
+class ToolbarCompletionsMenu(ConditionalContainer):
+    """A completion menu widget for toolbars."""
+
+    def __init__(self) -> None:
+        """Create a pre-populated conditional container."""
+        super().__init__(
+            content=HSplit(
+                [
+                    ConditionalContainer(
+                        Window(
+                            content=SelectedCompletionMetaControl(),
+                            height=1,
+                            dont_extend_width=True,
+                        ),
+                        filter=Condition(
+                            lambda: bool(
+                                (
+                                    complete_state
+                                    := get_app().current_buffer.complete_state
+                                )
+                                and (completion := complete_state.current_completion)
+                                and completion.display_meta
+                            )
+                        ),
+                    ),
+                    Window(
+                        content=ToolbarCompletionMenuControl(),
+                        height=Dimension(min=1, max=8),
+                        dont_extend_height=True,
+                        dont_extend_width=False,
+                    ),
+                ],
+                style="class:toolbar,menu",
+            ),
+            filter=has_toolbar & has_completions & ~is_done,
+        )