batrachian-toad 0.5.22__py3-none-any.whl

toad/widgets/flash.py

@@ -0,0 +1,81 @@
+from typing import Literal
+
+from textual.content import Content
+from textual.reactive import var
+from textual.widgets import Static
+from textual.timer import Timer
+from textual import getters
+
+
+from toad.app import ToadApp
+
+
+class Flash(Static):
+    DEFAULT_CSS = """
+    Flash {
+        height: 1;
+        width: 1fr;
+        background: $success 10%;
+        color: $text-success;
+        text-align: center;
+        visibility: hidden;
+        text-wrap: nowrap;
+        text-overflow: ellipsis;     
+        # overlay: screen;
+        # offset-y: -1;           
+        &.-default {
+            background: $primary 10%;
+            color: $text-primary;
+        }
+        
+        &.-success {
+            background: $success 10%;
+            color: $text-success;
+        }
+        
+        
+        &.-warning {
+            background: $warning 10%;
+            color: $text-warning;
+        }
+
+        &.-error {
+            background: $error 10%;
+            color: $text-error;
+        }
+    }
+    """
+    app = getters.app(ToadApp)
+    flash_timer: var[Timer | None] = var(None)
+
+    def flash(
+        self,
+        content: str | Content,
+        *,
+        duration: float | None = None,
+        style: Literal["default", "success", "warning", "error"] = "default",
+    ) -> None:
+        """Flash the content for a brief period.
+
+        Args:
+            content: Content to show.
+            duration: Duration in seconds to show content.
+            style: A semantic style.
+        """
+        if self.flash_timer is not None:
+            self.flash_timer.stop()
+        self.visible = False
+
+        def hide() -> None:
+            """Hide the content after a while."""
+            self.visible = False
+
+        self.update(content)
+        self.remove_class("-default", "-success", "-warning", "-error", update=False)
+        self.add_class(f"-{style}")
+        self.visible = True
+
+        if duration is None:
+            duration = self.app.settings.get("ui.flash_duration", float)
+
+        self.flash_timer = self.set_timer(duration or 3, hide)

toad/widgets/future_text.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from math import ceil
+from typing import ClassVar
+from time import monotonic
+
+from textual.color import Color
+from textual.reactive import var
+from textual.content import Content
+from textual.style import Style
+from textual.timer import Timer
+from textual.widgets import Static
+
+
+class FutureText(Static):
+    """Text which appears one letter at time, like the movies."""
+
+    DEFAULT_CSS = """
+    FutureText {
+        width: auto;
+        height: 1;
+        text-wrap: nowrap;
+        text-align: center;
+        color: $primary;
+        &>.future-text--cursor {
+            color: $primary;
+        }
+    }
+    """
+    ALLOW_SELECT = False
+    COMPONENT_CLASSES = {"future-text--cursor"}
+
+    BARS: ClassVar[list[str]] = ["▉", "▊", "▋", "▌", "▍", "▎", "▏", " "]
+    text_offset = var(0)
+
+    def __init__(
+        self,
+        text_list: list[Content],
+        *,
+        speed: float = 16.0,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ):
+        self.text_list = text_list
+        self.speed = speed
+        self.start_time = monotonic()
+        super().__init__(name=name, id=id, classes=classes)
+        self._update_timer: Timer | None = None
+
+    @property
+    def text(self) -> Content:
+        return self.text_list[self.text_offset % len(self.text_list)]
+
+    @property
+    def time(self) -> float:
+        return monotonic() - self.start_time
+
+    def on_mount(self) -> None:
+        self.start_time = monotonic()
+        self.set_interval(1 / 60, self._update_text)
+
+    def _update_text(self) -> None:
+        if not self.is_attached or not self.screen.is_active:
+            return
+        text = self.text + " "
+        speed_time = self.time * self.speed
+        progress, fractional_progress = divmod(speed_time, 1)
+        end = progress >= len(text)
+        cursor_progress = 0 if end else int(fractional_progress * 8)
+        text = text[: ceil(progress)]
+
+        bar_character = self.BARS[7 - cursor_progress]
+
+        cursor_styles = self.get_component_styles("future-text--cursor")
+        cursor_style = Style(foreground=cursor_styles.color)
+        reverse_cursor_style = cursor_style + Style(reverse=True)
+
+        # Fade in last character
+        fade_style = Style(
+            foreground=Color.blend(
+                cursor_styles.background, cursor_styles.color, ceil(fractional_progress)
+            )
+        )
+
+        fade_text = Content.assemble(
+            text[:-1],
+            ((text[-1].plain if text else " "), fade_style),
+        )
+
+        if speed_time >= 1:
+            text = Content.assemble(
+                fade_text,
+                (bar_character, reverse_cursor_style),
+                (bar_character, cursor_style),
+                " " * (len(self.text) + 1 - len(fade_text)),
+            )
+        self.update(text, layout=False)
+
+        if progress > len(text) + 10 * 5:
+            self.text_offset += 1
+            self.start_time = monotonic()
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+
+    TEXT = [Content("Thinking..."), Content("Working hard..."), Content("Nearly there")]
+
+    class TextApp(App):
+        CSS = """
+        Screen {
+            padding: 2 4;
+            FutureText {
+                width: auto;
+                max-width: 1fr;
+                height: auto;
+               
+            }
+        }
+        """
+
+        def compose(self) -> ComposeResult:
+            yield FutureText(TEXT)
+
+    TextApp().run()

toad/widgets/grid_select.py

@@ -0,0 +1,223 @@
+from dataclasses import dataclass
+
+from textual import containers
+from textual.binding import Binding
+from textual import events
+from textual.message import Message
+from textual.reactive import reactive
+from textual.layouts.grid import GridLayout
+from textual.widget import Widget
+
+
+class GridSelect(containers.ItemGrid, can_focus=True):
+    FOCUS_ON_CLICK = False
+    CURSOR_GROUP = Binding.Group("Select")
+    FOCUS_GROUP = Binding.Group("Focus")
+    BINDINGS = [
+        Binding("up", "cursor_up", "Cursor Up", group=CURSOR_GROUP),
+        Binding("down", "cursor_down", "Cursor Down", group=CURSOR_GROUP),
+        Binding("left", "cursor_left", "Cursor Left", group=CURSOR_GROUP),
+        Binding("right", "cursor_right", "Cursor Right", group=CURSOR_GROUP),
+        Binding("enter", "select", "Select"),
+    ]
+
+    highlighted: reactive[int | None] = reactive(None)
+
+    @dataclass
+    class Selected(Message):
+        grid_select: "GridSelect"
+        selected_widget: Widget
+
+        @property
+        def control(self) -> Widget:
+            return self.grid_select
+
+    @dataclass
+    class LeaveUp(Message):
+        grid_select: "GridSelect"
+
+    @dataclass
+    class LeaveDown(Message):
+        grid_select: "GridSelect"
+
+    def __init__(
+        self,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        min_column_width: int = 30,
+        max_column_width: int | None = None,
+    ):
+        super().__init__(
+            name=name,
+            id=id,
+            classes=classes,
+            min_column_width=min_column_width,
+            max_column_width=max_column_width,
+        )
+
+    @property
+    def grid_size(self) -> tuple[int, int] | None:
+        assert isinstance(self.layout, GridLayout)
+        return self.layout.grid_size
+
+    def highlight_first(self) -> None:
+        self.highlighted = 0
+
+    def highlight_last(self) -> None:
+        if (grid_size := self.grid_size) is not None:
+            width, height = grid_size
+
+            if width == 1:
+                self.highlighted = len(self.children) - 1
+            else:
+                self.highlighted = (height - 1) * width
+
+    def on_focus(self):
+        if self.highlighted is None:
+            self.highlighted = 0
+        self.reveal_highlight()
+
+    def on_blur(self) -> None:
+        self.highlighted = None
+
+    def reveal_highlight(self):
+        if self.highlighted is None:
+            return
+        try:
+            highlighted_widget = self.children[self.highlighted]
+        except IndexError:
+            pass
+        else:
+            if not self.screen.can_view_entire(highlighted_widget):
+                self.screen.scroll_to_center(highlighted_widget, origin_visible=True)
+
+    def watch_highlighted(
+        self, old_highlighted: int | None, highlighted: int | None
+    ) -> None:
+        if old_highlighted is not None:
+            try:
+                self.children[old_highlighted].remove_class("-highlight")
+            except IndexError:
+                pass
+        if highlighted is not None:
+            try:
+                highlighted_widget = self.children[highlighted]
+                highlighted_widget.add_class("-highlight")
+            except IndexError:
+                pass
+        self.reveal_highlight()
+
+    def validate_highlighted(self, highlighted: int | None) -> int | None:
+        if highlighted is None:
+            return None
+
+        if not self.children:
+            return None
+        if highlighted < 0:
+            return 0
+        if highlighted >= len(self.children):
+            return len(self.children) - 1
+        return highlighted
+
+    def action_cursor_up(self):
+        if (grid_size := self.grid_size) is None:
+            self.post_message(self.LeaveUp(self))
+            return
+        if self.highlighted is None:
+            self.highlighted = 0
+        else:
+            width, _height = grid_size
+            if self.highlighted >= width:
+                self.highlighted -= width
+            else:
+                self.post_message(self.LeaveUp(self))
+
+    def action_cursor_down(self):
+        if (grid_size := self.grid_size) is None:
+            self.post_message(self.LeaveDown(self))
+            return
+
+        if self.highlighted is None:
+            self.highlighted = 0
+        else:
+            width, height = grid_size
+            if self.highlighted + width < len(self.children):
+                self.highlighted += width
+            else:
+                self.post_message(self.LeaveDown(self))
+
+    def action_cursor_left(self):
+        if self.highlighted is None:
+            self.highlighted = 0
+        else:
+            self.highlighted -= 1
+
+    def action_cursor_right(self):
+        if self.highlighted is None:
+            self.highlighted = 0
+        else:
+            self.highlighted += 1
+
+    def on_click(self, event: events.Click) -> None:
+        if event.widget is None:
+            return
+
+        highlighted_widget: Widget | None = None
+        if self.highlighted is not None:
+            try:
+                highlighted_widget = self.children[self.highlighted]
+            except IndexError:
+                pass
+        for widget in event.widget.ancestors_with_self:
+            if widget in self.children:
+                if highlighted_widget is not None and highlighted_widget is widget:
+                    self.action_select()
+                else:
+                    self.highlighted = self.children.index(widget)
+                break
+        self.focus()
+
+    def action_select(self):
+        if self.highlighted is not None:
+            try:
+                highlighted_widget = self.children[self.highlighted]
+            except IndexError:
+                pass
+            else:
+                self.post_message(self.Selected(self, highlighted_widget))
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+    from textual import widgets
+
+    class GridApp(App):
+        CSS = """
+        .grid-item {
+            width: 1fr;
+            padding: 0 1;
+            # background: blue 20%;        
+            border: blank;
+
+            &:hover {
+                background: $panel;
+            }
+
+            &.-highlight {
+                border: tall $primary;
+                background: $panel;
+            }
+        }
+        """
+
+        def compose(self) -> ComposeResult:
+            yield widgets.Footer()
+            with GridSelect():
+                for n in range(50):
+                    yield widgets.Label(
+                        f"#{n} Where there is a Will, there is a Way!",
+                        classes="grid-item",
+                    )
+
+    GridApp().run()

toad/widgets/highlighted_textarea.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import re2 as re
+from typing import Sequence
+
+from rich.text import Text
+
+from textual import on
+from textual.reactive import reactive
+from textual.content import Content
+from textual.highlight import highlight, HighlightTheme, TokenType
+from textual.message import Message
+from textual.widgets import TextArea
+from textual.widgets.text_area import Selection
+
+from pygments.token import Token
+
+
+RE_MATCH_FILE_PROMPT = re.compile(r"(@\S+)|@\"(.*)\"")
+RE_SLASH_COMMAND = re.compile(r"(\/\S*)(\W.*)?$")
+
+
+class TextualHighlightTheme(HighlightTheme):
+    """Contains the style definition for user with the highlight method."""
+
+    STYLES: dict[TokenType, str] = {
+        Token.Comment: "$text 60%",
+        Token.Error: "$text-error on $error-muted",
+        Token.Generic.Strong: "bold",
+        Token.Generic.Emph: "italic",
+        Token.Generic.Error: "$text-error on $error-muted",
+        Token.Generic.Heading: "$text-primary underline",
+        Token.Generic.Subheading: "$text-primary",
+        Token.Keyword: "$text-accent",
+        Token.Keyword.Constant: "bold $text-success 80%",
+        Token.Keyword.Namespace: "$text-error",
+        Token.Keyword.Type: "bold",
+        Token.Literal.Number: "$text-warning",
+        Token.Literal.String.Backtick: "$text 60%",
+        Token.Literal.String: "$text-success 90%",
+        Token.Literal.String.Doc: "$text-success 80% italic",
+        Token.Literal.String.Double: "$text-success 90%",
+        Token.Name: "$text-primary",
+        Token.Name.Attribute: "$text-warning",
+        Token.Name.Builtin: "$text-accent",
+        Token.Name.Builtin.Pseudo: "italic",
+        Token.Name.Class: "$text-warning bold",
+        Token.Name.Constant: "$text-error",
+        Token.Name.Decorator: "$text-primary bold",
+        Token.Name.Entity: "$text",
+        Token.Name.Function: "$text-warning underline",
+        Token.Name.Function.Magic: "$text-warning underline",
+        Token.Name.Tag: "$text-primary bold",
+        Token.Name.Variable: "$text-secondary",
+        Token.Number: "$text-warning",
+        Token.Operator: "bold",
+        Token.Operator.Word: "bold $text-error",
+        Token.String: "$text-success",
+        Token.Whitespace: "",
+    }
+
+
+class HighlightedTextArea(TextArea):
+    highlight_language = reactive("markdown")
+
+    @dataclass
+    class CursorMove(Message):
+        selection: Selection
+
+    def __init__(
+        self,
+        text: str = "",
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+        placeholder: str | Content = "",
+    ):
+        self._text_cache: dict[int, Text] = {}
+        self._highlight_lines: list[Content] | None = None
+        super().__init__(
+            text,
+            name=name,
+            id=id,
+            classes=classes,
+            disabled=disabled,
+            highlight_cursor_line=False,
+            placeholder=placeholder,
+        )
+        self.compact = True
+
+    def _clear_caches(self) -> None:
+        self._highlight_lines = None
+        self._text_cache.clear()
+
+    def notify_style_update(self) -> None:
+        self._clear_caches()
+        return super().notify_style_update()
+
+    def _watch_selection(
+        self, previous_selection: Selection, selection: Selection
+    ) -> None:
+        self.post_message(self.CursorMove(selection))
+        super()._watch_selection(previous_selection, selection)
+
+    @property
+    def highlight_lines(self) -> Sequence[Content]:
+        if self._highlight_lines is None:
+            text = self.text
+            if text.startswith("/") and "\n" not in text:
+                content = self.highlight_slash_command(text)
+                self._highlight_lines = [content]
+                return self._highlight_lines
+
+            language = self.highlight_language
+            if language == "markdown":
+                content = self.highlight_markdown(text)
+                content_lines = content.split("\n", allow_blank=True)[:-1]
+                self._highlight_lines = content_lines
+            elif language == "shell":
+                content = self.highlight_shell(text)
+                content_lines = content.split("\n", allow_blank=True)
+                self._highlight_lines = content_lines
+            else:
+                raise ValueError("highlight_language must be `markdown` or `shell`")
+        return self._highlight_lines
+
+    def highlight_slash_command(self, text: str) -> Content:
+        return Content.styled(text, "$text-success")
+
+    def highlight_markdown(self, text: str) -> Content:
+        """Highlight markdown content.
+
+        Args:
+            text: Text containing Markdown.
+
+        Returns:
+            Highlighted content.
+        """
+        content = highlight(
+            text + "\n```",
+            language="markdown",
+            theme=TextualHighlightTheme,
+        )
+        content = content.highlight_regex(RE_MATCH_FILE_PROMPT, style="$primary")
+        return content
+
+    def highlight_shell(self, text: str) -> Content:
+        """Highlight text with a bash shell command.
+
+        Args:
+            text: Text containing shell command.
+
+        Returns:
+            Highlighted content.
+        """
+        content = highlight(text, language="sh")
+        return content
+
+    @on(TextArea.Changed)
+    def _on_changed(self) -> None:
+        self._highlight_lines = None
+        self._text_cache.clear()
+
+    def get_line(self, line_index: int) -> Text:
+        if (cached_line := self._text_cache.get(line_index)) is not None:
+            return cached_line.copy()
+        try:
+            line = self.highlight_lines[line_index]
+        except IndexError:
+            return Text("", end="", no_wrap=True)
+        rendered_line = list(line.render_segments(self.visual_style))
+        text = Text.assemble(
+            *[(text, style) for text, style, _ in rendered_line],
+            end="",
+            no_wrap=True,
+        )
+        self._text_cache[line_index] = text.copy()
+        return text