batrachian-toad 0.5.22__py3-none-any.whl

toad/widgets/question.py

@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from textual.app import ComposeResult
+from textual import events, on
+from textual.binding import Binding
+from textual import containers
+from textual.content import Content
+from textual.reactive import var, reactive
+from textual.message import Message
+from textual.widget import Widget
+from textual.widgets import Label
+
+from toad.answer import Answer
+
+type Options = list[Answer]
+
+
+@dataclass
+class Ask:
+    """Data for Question."""
+
+    question: str
+    options: Options
+    callback: Callable[[Answer], Any] | None = None
+
+
+class NonSelectableLabel(Label):
+    ALLOW_SELECT = False
+
+
+class Option(containers.HorizontalGroup):
+    ALLOW_SELECT = False
+    DEFAULT_CSS = """
+    Option {
+
+        &:hover {
+            background: $boost;
+        }
+        color: $text-muted;
+        #caret {
+            visibility: hidden;
+            padding: 0 1;
+        }
+        #index {
+            padding-right: 1;
+        }
+        #label {
+            width: 1fr;
+        }
+        &.-active {            
+            color: $text-accent;
+            #caret {
+                visibility: visible;
+            }
+        }
+        &.-selected {
+            opacity: 0.5;
+        }
+        &.-active.-selected {
+            opacity: 1.0;
+            background: transparent;
+            color: $text-accent;            
+            #label {
+                text-style: underline;
+            }
+            #caret {
+                visibility: hidden;
+            }
+        }
+    }
+    """
+
+    @dataclass
+    class Selected(Message):
+        """The option was selected."""
+
+        index: int
+
+    selected: reactive[bool] = reactive(False, toggle_class="-selected")
+
+    def __init__(
+        self, index: int, content: Content, key: str | None, classes: str = ""
+    ) -> None:
+        super().__init__(classes=classes)
+        self.index = index
+        self.content = content
+        self.key = key
+
+    def compose(self) -> ComposeResult:
+        key = self.key
+        yield NonSelectableLabel("❯", id="caret")
+        if key:
+            yield NonSelectableLabel(Content.styled(f"{key}", "b"), id="index")
+        else:
+            yield NonSelectableLabel(Content(" "), id="index")
+
+        yield NonSelectableLabel(self.content, id="label")
+
+    def on_click(self, event: events.Click) -> None:
+        event.stop()
+        self.post_message(self.Selected(self.index))
+
+
+class Question(Widget, can_focus=True):
+    """A text question with a menu of responses."""
+
+    BINDING_GROUP_TITLE = "Question"
+    ALLOW_SELECT = False
+    CURSOR_GROUP = Binding.Group("Cursor", compact=True)
+    ALLOW_GROUP = Binding.Group("Allow once/always", compact=True)
+    REJECT_GROUP = Binding.Group("Reject once/always", compact=True)
+    BINDINGS = [
+        Binding(
+            "up",
+            "selection_up",
+            "Up",
+            group=CURSOR_GROUP,
+        ),
+        Binding(
+            "down",
+            "selection_down",
+            "Down",
+            group=CURSOR_GROUP,
+        ),
+        Binding(
+            "enter",
+            "select",
+            "Select",
+        ),
+        Binding(
+            "a",
+            "select_kind(('allow_once', 'allow'))",
+            "Allow once",
+            group=ALLOW_GROUP,
+        ),
+        Binding(
+            "A",
+            "select_kind('allow_always')",
+            "Allow always",
+            group=ALLOW_GROUP,
+        ),
+        Binding(
+            "r",
+            "select_kind(('reject_once', 'reject'))",
+            "Reject once",
+            group=REJECT_GROUP,
+        ),
+        Binding(
+            "R",
+            "select_kind('reject_always')",
+            "Reject always",
+            group=REJECT_GROUP,
+        ),
+    ]
+
+    DEFAULT_CSS = """
+    Question {
+        width: 1fr;
+        height: auto;
+        padding: 0 1; 
+        background: transparent;
+        #prompt {
+            margin-bottom: 1;
+            color: $text-primary;
+        }                
+        &.-blink Option.-active #caret {
+            opacity: 0.2;
+        }
+        &:blur {
+            #index {
+                opacity: 0.3;
+            }
+            #caret {
+                opacity: 0.3;
+            }
+        }
+    }
+    """
+
+    question: var[str] = var("")
+    options: var[Options] = var(list)
+
+    selection: reactive[int] = reactive(0, init=False)
+    selected: var[bool] = var(False, toggle_class="-selected")
+    blink: var[bool] = var(False)
+
+    DEFAULT_KINDS = {
+        "allow_once": "a",
+        "allow_always": "A",
+        "reject_once": "r",
+        "reject_always": "R",
+    }
+
+    @dataclass
+    class Answer(Message):
+        """User selected a response."""
+
+        index: int
+        answer: Answer
+
+    def __init__(
+        self,
+        question: str = "Ask and you will receive",
+        options: Options | None = None,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+    ):
+        super().__init__(name=name, id=id, classes=classes, disabled=disabled)
+        self.set_reactive(Question.question, question)
+        self.set_reactive(Question.options, options or [])
+
+    def on_mount(self) -> None:
+        def toggle_blink() -> None:
+            if self.has_focus:
+                self.blink = not self.blink
+            else:
+                self.blink = False
+
+        self._blink_timer = self.set_interval(0.5, toggle_blink)
+
+    def _reset_blink(self) -> None:
+        self.blink = False
+        self._blink_timer.reset()
+
+    def update(self, ask: Ask) -> None:
+        self.question = ask.question
+        self.options = ask.options
+        self.selection = 0
+        self.selected = False
+        self.refresh(recompose=True, layout=True)
+
+    def compose(self) -> ComposeResult:
+        with containers.VerticalGroup():
+            if self.question:
+                yield Label(self.question, id="prompt")
+
+            with containers.VerticalGroup(id="option-container"):
+                kinds: set[str] = set()
+                for index, answer in enumerate(self.options):
+                    active = index == self.selection
+                    key = (
+                        self.DEFAULT_KINDS.get(answer.kind)
+                        if (answer.kind and answer.kind not in kinds)
+                        else None
+                    )
+                    yield Option(
+                        index,
+                        Content(answer.text),
+                        key,
+                        classes="-active" if active else "",
+                    ).data_bind(Question.selected)
+                    if answer.kind is not None:
+                        kinds.add(answer.kind)
+
+    def watch_selection(self, old_selection: int, new_selection: int) -> None:
+        self.query("#option-container > .-active").remove_class("-active")
+        if new_selection >= 0:
+            self.query_one("#option-container").children[new_selection].add_class(
+                "-active"
+            )
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        if self.selected and action in ("selection_up", "selection_down"):
+            return False
+        if action == "select_kind":
+            kinds = {answer.kind for answer in self.options if answer.kind is not None}
+            check_kinds = set()
+            for parameter in parameters:
+                if isinstance(parameter, str):
+                    check_kinds.add(parameter)
+                elif isinstance(parameter, tuple):
+                    check_kinds.update(parameter)
+
+            return any(kind in kinds for kind in check_kinds)
+
+        return True
+
+    def watch_blink(self, blink: bool) -> None:
+        self.set_class(blink, "-blink")
+
+    def action_selection_up(self) -> None:
+        self._reset_blink()
+        self.selection = max(0, self.selection - 1)
+
+    def action_selection_down(self) -> None:
+        self._reset_blink()
+        self.selection = min(len(self.options) - 1, self.selection + 1)
+
+    def action_select(self) -> None:
+        self._reset_blink()
+        self.post_message(
+            self.Answer(
+                index=self.selection,
+                answer=self.options[self.selection],
+            )
+        )
+        self.selected = True
+
+    def action_select_kind(self, kind: str | tuple[str]) -> None:
+        kinds = kind if isinstance(kind, tuple) else (kind,)
+        for kind in kinds:
+            for index, answer in enumerate(self.options):
+                if answer.kind == kind:
+                    self.selection = index
+                    self.action_select()
+                    break
+
+    @on(Option.Selected)
+    def on_option_selected(self, event: Option.Selected) -> None:
+        event.stop()
+        self._reset_blink()
+        if not self.selected:
+            self.selection = event.index
+
+
+if __name__ == "__main__":
+    from textual.app import App
+    from textual.widgets import Footer
+
+    OPTIONS = [
+        Answer("Yes, allow once", "proceed_always", kind="allow_once"),
+        Answer("Yes, allow always", "allow_always", kind="allow_always"),
+        Answer("Modify with external editor", "modify", kind="allow_once"),
+        Answer("No, suggest changes (esc)", "reject"),
+    ]
+
+    class QuestionApp(App):
+        def compose(self) -> ComposeResult:
+            yield Question("Apply this change?", OPTIONS)
+            yield Footer()
+
+    QuestionApp().run()

toad/widgets/shell_result.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+from typing import Iterable
+
+from textual.app import ComposeResult
+from textual import containers
+from textual.highlight import highlight
+from textual.widgets import Static
+
+
+from toad.menus import MenuItem
+from toad.widgets.non_selectable_label import NonSelectableLabel
+
+
+class ShellResult(containers.HorizontalGroup):
+    def __init__(
+        self,
+        command: str,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+    ) -> None:
+        self._command = command
+        super().__init__(name=name, id=id, classes=classes, disabled=disabled)
+
+    def compose(self) -> ComposeResult:
+        yield NonSelectableLabel("$", id="prompt")
+        yield Static(highlight(self._command, language="sh"))
+
+    def get_block_menu(self) -> Iterable[MenuItem]:
+        yield from ()
+
+    def get_block_content(self, destination: str) -> str | None:
+        return self._command

toad/widgets/shell_terminal.py

@@ -0,0 +1,18 @@
+from typing import Iterable
+
+from toad.menus import MenuItem
+from toad.widgets.terminal import Terminal
+
+
+class ShellTerminal(Terminal):
+    """Subclass of Terminal used in the Shell view."""
+
+    def get_block_menu(self) -> Iterable[MenuItem]:
+        return
+        yield
+
+    def on_mount(self) -> None:
+        self.border_title = self.name
+
+    def get_block_content(self, destination: str) -> str | None:
+        return "\n".join(line.content.plain for line in self.state.buffer.lines)

toad/widgets/side_bar.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass
+
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual import containers
+from textual import widgets
+from textual.message import Message
+
+
+class SideBar(containers.Vertical):
+    BINDINGS = [("escape", "dismiss", "Dismiss sidebar")]
+
+    class Dismiss(Message):
+        pass
+
+    @dataclass(frozen=True)
+    class Panel:
+        title: str
+        widget: Widget
+        flex: bool = False
+        collapsed: bool = False
+        id: str | None = None
+
+    def __init__(
+        self,
+        *panels: Panel,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+        hide: bool = False,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes, disabled=disabled)
+        self.panels: list[SideBar.Panel] = [*panels]
+        self.hide = hide
+
+    def on_mount(self) -> None:
+        self.trap_focus()
+
+    def compose(self) -> ComposeResult:
+        for panel in self.panels:
+            yield widgets.Collapsible(
+                panel.widget,
+                title=panel.title,
+                collapsed=panel.collapsed,
+                classes="-flex" if panel.flex else "-fixed",
+                id=panel.id,
+            )
+
+    def action_dismiss(self) -> None:
+        self.post_message(self.Dismiss())
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+
+    class SApp(App):
+        def compose(self) -> ComposeResult:
+            yield SideBar(
+                SideBar.Panel("Hello", widgets.Label("Hello, World!")),
+                SideBar.Panel(
+                    "Files",
+                    widgets.DirectoryTree(
+                        "~/",
+                    ),
+                    flex=True,
+                ),
+                SideBar.Panel(
+                    "Hello",
+                    widgets.Static("Where there is a Will! " * 10),
+                ),
+            )
+
+    SApp().run()

toad/widgets/slash_complete.py

@@ -0,0 +1,211 @@
+from dataclasses import dataclass
+from operator import itemgetter
+from typing import Iterable, Self, Sequence
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.content import Content, Span
+
+from textual import getters
+from textual.message import Message
+from textual.reactive import var
+from textual import containers
+from textual import widgets
+from textual.widgets.option_list import Option
+
+from toad.fuzzy import FuzzySearch
+from toad.messages import Dismiss
+from toad.slash_command import SlashCommand
+from toad.visuals.columns import Columns
+
+
+class SlashComplete(containers.VerticalGroup):
+    """A widget to auto-complete slash commands."""
+
+    CURSOR_BINDING_GROUP = Binding.Group(description="Select")
+    BINDINGS = [
+        Binding(
+            "up",
+            "cursor_up",
+            "Cursor up",
+            group=CURSOR_BINDING_GROUP,
+            priority=True,
+        ),
+        Binding(
+            "down",
+            "cursor_down",
+            "Cursor down",
+            group=CURSOR_BINDING_GROUP,
+            priority=True,
+        ),
+        Binding("enter", "submit", "Insert /command", priority=True),
+        Binding("escape", "dismiss", "Dismiss", priority=True),
+    ]
+
+    DEFAULT_CSS = """
+    SlashComplete {
+        OptionList {
+            height: auto;
+        }
+    }
+    """
+
+    input = getters.query_one(widgets.Input)
+    option_list = getters.query_one(widgets.OptionList)
+
+    slash_commands: var[list[SlashCommand]] = var(list)
+
+    @dataclass
+    class Completed(Message):
+        command: str
+
+    def __init__(
+        self,
+        slash_commands: Iterable[SlashCommand] | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(id=id, classes=classes)
+        self.slash_commands = list(slash_commands) if slash_commands else []
+        self.fuzzy_search = FuzzySearch(case_sensitive=False)
+
+    def compose(self) -> ComposeResult:
+        yield widgets.Input(compact=True, placeholder="fuzzy search")
+        yield widgets.OptionList()
+
+    def focus(self, scroll_visible: bool = False) -> Self:
+        self.filter_slash_commands("")
+        self.input.focus(scroll_visible)
+        return self
+
+    def on_mount(self) -> None:
+        self.filter_slash_commands("")
+
+    def on_descendant_blur(self) -> None:
+        self.post_message(Dismiss(self))
+
+    @on(widgets.Input.Changed)
+    def on_input_changed(self, event: widgets.Input.Changed) -> None:
+        event.stop()
+        self.filter_slash_commands(event.value)
+
+    async def watch_slash_commands(self) -> None:
+        self.filter_slash_commands(self.input.value)
+
+    def filter_slash_commands(self, prompt: str) -> None:
+        """Filter slash commands by the given prompt.
+
+        Args:
+            prompt: Text prompt.
+        """
+        prompt = prompt.lstrip("/").casefold()
+        columns = self.columns = Columns("auto", "flex")
+
+        slash_commands = sorted(
+            self.slash_commands,
+            key=lambda slash_command: slash_command.command.casefold(),
+        )
+        deduplicated_slash_commands = {
+            slash_command.command: slash_command for slash_command in slash_commands
+        }
+        self.fuzzy_search.cache.grow(len(deduplicated_slash_commands))
+
+        if prompt:
+            slash_prompt = f"/{prompt}"
+            scores: list[tuple[float, Sequence[int], SlashCommand]] = [
+                (
+                    *self.fuzzy_search.match(prompt, slash_command.command[1:]),
+                    slash_command,
+                )
+                for slash_command in slash_commands
+            ]
+
+            scores = sorted(
+                [
+                    (
+                        (
+                            score * 2
+                            if slash_command.command.casefold().startswith(slash_prompt)
+                            else score
+                        ),
+                        highlights,
+                        slash_command,
+                    )
+                    for score, highlights, slash_command in scores
+                    if score
+                ],
+                key=itemgetter(0),
+                reverse=True,
+            )
+        else:
+            scores = [(1.0, [], slash_command) for slash_command in slash_commands]
+
+        def make_row(
+            slash_command: SlashCommand, indices: Iterable[int]
+        ) -> tuple[Content, ...]:
+            """Make a row for the Columns display.
+
+            Args:
+                slash_command: The slash command instance.
+                indices: Indices of matching characters.
+
+            Returns:
+                A tuple of `Content` instances for use as a column row.
+            """
+            command = Content.styled(slash_command.command, "$text-success")
+            command = command.add_spans(
+                [Span(index + 1, index + 2, "underline not dim") for index in indices]
+            )
+            return (command, Content.styled(slash_command.help, "dim"))
+
+        rows = [
+            (
+                columns.add_row(
+                    *make_row(slash_command, indices),
+                ),
+                slash_command.command,
+            )
+            for _, indices, slash_command in scores
+        ]
+        self.option_list.set_options(
+            Option(row, id=command_name) for row, command_name in rows
+        )
+        if self.display:
+            self.option_list.highlighted = 0
+        else:
+            with self.option_list.prevent(widgets.OptionList.OptionHighlighted):
+                self.option_list.highlighted = 0
+
+    def action_cursor_down(self) -> None:
+        self.option_list.action_cursor_down()
+
+    def action_cursor_up(self) -> None:
+        self.option_list.action_cursor_up()
+
+    def action_dismiss(self) -> None:
+        self.post_message(Dismiss(self))
+
+    def action_submit(self) -> None:
+        if (option := self.option_list.highlighted_option) is not None:
+            with self.input.prevent(widgets.Input.Changed):
+                self.input.clear()
+            self.post_message(Dismiss(self))
+            self.post_message(self.Completed(option.id or ""))
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+
+    COMMANDS = [
+        SlashCommand("/help", "Help with slash commands"),
+        SlashCommand("/foo", "This is FOO"),
+        SlashCommand("/bar", "This is BAR"),
+        SlashCommand("/baz", "This is BAZ"),
+    ]
+
+    class SlashApp(App):
+        def compose(self) -> ComposeResult:
+            yield SlashComplete(COMMANDS)
+
+    SlashApp().run()