composeui 0.1.0__py3-none-any.whl

composeui/textualcore/widgets/composemarkdown.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from textual.widgets import Markdown
+
+
+class ComposeMarkdown(Markdown):
+    """A `Markdown` whose text is set at any time, mounted or not.
+
+    Its links open in the browser (Textual's `open_links`).
+    """
+
+    def set_text(self, text: str) -> None:
+        if self.is_mounted:
+            # not awaited: Textual mounts the new blocks in a task, one update after another
+            self.update(text)
+        else:
+            self._initial_markdown = text  # what `Markdown` shows once mounted

composeui/textualcore/widgets/composemetric.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.containers import Vertical
+from textual.widgets import Label
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+
+class ComposeMetric(Vertical):
+    """A metric: its label, its value in bold, then its change as a badge.
+
+    A terminal has one font size; the value stands out by its weight alone.
+    """
+
+    DEFAULT_CSS = """
+    ComposeMetric {
+        height: auto;
+        width: 1fr;
+    }
+    ComposeMetric > .metric--label {
+        color: $text-muted;
+    }
+    ComposeMetric > .metric--value {
+        text-style: bold;
+    }
+    ComposeMetric > .metric--badge {
+        padding: 0 1;
+        background: $surface-lighten-1;
+        &.-rise {
+            color: $text-success;
+            background: $success-muted;
+        }
+        &.-fall {
+            color: $text-error;
+            background: $error-muted;
+        }
+    }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.label = Label(classes="metric--label", markup=False)
+        self.value = Label(classes="metric--value", markup=False)
+        self.badge = Label(classes="metric--badge", markup=False)
+        self.badge.display = False
+
+    def compose(self) -> ComposeResult:
+        yield self.label
+        yield self.value
+        yield self.badge
+
+    def set_delta(self, badge: str, sign: int) -> None:
+        """Show `badge`, colored by the `sign` of its change; an empty one hides it."""
+        self.badge.update(badge)
+        self.badge.display = badge != ""
+        self.badge.set_class(sign > 0, "-rise")
+        self.badge.set_class(sign < 0, "-fall")

composeui/textualcore/widgets/composeradioset.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Generic, Optional, TypeVar
+
+from textual.content import Content
+from textual.widgets import RadioButton, RadioSet
+
+from composeui.core.signal import Signal
+
+TValue = TypeVar("TValue")
+
+
+class ComposeRadioSet(RadioSet, Generic[TValue]):
+    """A `RadioSet` built from a `{label: value}` mapping, like Qt's `QRadioGroup`.
+
+    Textual dispatches `RadioSet.Changed` by calling `on_radio_set_changed` on the
+    widget itself first; a renderer isn't part of the DOM, so it can't bind to that
+    directly. Re-emitting it through a plain composeui `Signal` lets
+    `TextualRadioGroupRenderer` connect like it would to any other composeui signal.
+    """
+
+    # a form row's field while the row is invalid (see `ROW_INVALID_CLASS`)
+    DEFAULT_CSS = """
+    ComposeRadioSet.-row-invalid {
+        border: tall $error 60%;
+        &:focus {
+            border: tall $error;
+        }
+    }
+    """
+
+    def __init__(self, values: dict[str, TValue]) -> None:
+        self._values: dict[str, TValue] = dict(values)
+        super().__init__(*(RadioButton(Content(label)) for label in self._values))
+        self.value_changed: Signal[Optional[TValue]] = Signal()
+
+    def set_values(self, values: dict[str, TValue]) -> None:
+        """Rebuild the radio buttons for a new set of options."""
+        self.remove_children()
+        self._values = dict(values)
+        for label in self._values:
+            self.mount(RadioButton(Content(label)))
+
+    def set_value(self, value: Optional[TValue]) -> None:
+        for button, candidate in zip(self.query(RadioButton), self._values.values()):
+            if value is not None and value == candidate and not button.value:
+                button.value = True
+
+    def value(self) -> TValue:
+        assert self.pressed_index != -1  # asked once a button is pressed
+        return list(self._values.values())[self.pressed_index]
+
+    def on_radio_set_changed(self, event: RadioSet.Changed) -> None:
+        self.value_changed.emit(self.value())

composeui/textualcore/widgets/composesidebar.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+from textual.binding import Binding, BindingType
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.widgets import Label, Static
+
+from composeui.core.signal import Signal
+
+if TYPE_CHECKING:
+    from textual import events
+    from textual.widget import Widget
+
+
+class ComposeSidebarToggle(Static, can_focus=True):
+    """The arrow retracting or expanding a sidebar, by a click or Enter."""
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("enter,space", "press", "Retract or expand", show=False),
+    ]
+
+    def __init__(self, sidebar: ComposeSidebar) -> None:
+        super().__init__(classes="sidebar--toggle")
+        self._sidebar = sidebar
+
+    def on_click(self, _event: events.Click) -> None:
+        self.action_press()
+
+    def action_press(self) -> None:
+        self._sidebar.toggle_by_user()
+
+
+class ComposeSidebar(VerticalScroll):
+    """A column on the screen's left: its title and an arrow, then its views, scrolling.
+
+    As wide as a third of the screen at most: the content beside it keeps the rest. The
+    arrow retracts it to a strip holding only the arrow, and expands it back; `toggled`
+    reports those, and `set_expanded` is quiet, as Qt's renderers block their widget's
+    signals while refreshing it.
+    """
+
+    DEFAULT_CSS = """
+    ComposeSidebar {
+        width: 36;
+        max-width: 33%;
+        height: 1fr;
+        padding: 0 1;
+        margin-right: 1;
+        border-right: vkey $foreground 20%;
+        & > .sidebar--header {
+            height: auto;
+            margin-bottom: 1;
+        }
+        & .sidebar--title {
+            width: 1fr;
+            text-style: bold;
+        }
+        & .sidebar--toggle {
+            width: 3;
+            content-align: center middle;
+            &:focus {
+                background: $accent;
+                color: $text-accent;
+            }
+            &:hover {
+                background: $boost;
+            }
+        }
+        & > .sidebar--content {
+            height: auto;
+        }
+        &.-retracted {
+            width: 5;
+            & > .sidebar--content {
+                display: none;
+            }
+        }
+    }
+    """
+
+    def __init__(self, *children: Widget) -> None:
+        self.title = Label(classes="sidebar--title", markup=False)
+        self.toggle = ComposeSidebarToggle(self)
+        super().__init__(
+            Horizontal(self.title, self.toggle, classes="sidebar--header"),
+            Vertical(*children, classes="sidebar--content"),
+        )
+        self.toggled: Signal[bool] = Signal()
+        self._title_text = ""
+        self.set_expanded(True)
+
+    @property
+    def is_expanded(self) -> bool:
+        return not self.has_class("-retracted")
+
+    def set_title(self, title: str) -> None:
+        self.title.update(title)
+        self._title_text = title
+        self.title.display = title != "" and self.is_expanded
+
+    def set_expanded(self, is_expanded: bool) -> None:
+        self.set_class(not is_expanded, "-retracted")
+        self.title.display = self._title_text != "" and is_expanded
+        # pointing the way the sidebar goes: left to retract it, right to expand it
+        self.toggle.update("◀" if is_expanded else "▶")
+
+    def toggle_by_user(self) -> None:
+        is_expanded = not self.is_expanded
+        self.set_expanded(is_expanded)
+        self.toggled.emit(is_expanded)

composeui/textualcore/widgets/composeslider.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+from rich.text import Text
+from textual.binding import Binding, BindingType
+from textual.widget import Widget
+
+from composeui.core.signal import Signal
+
+if TYPE_CHECKING:
+    from textual import events
+    from textual.app import RenderResult
+
+
+class ComposeSlider(Widget, can_focus=True):
+    """A slider from `first` by `step`, its value on the right of the track.
+
+    Textual has none. Its positions count steps (0 to `last`), so the handle only stops
+    on a step. The arrow keys move it a step, Page Up/Down a tenth of the way, Home/End
+    to an end; a click or a drag moves it under the mouse. `moved` reports the user's
+    moves only, as Qt's renderers block their widget's signals while refreshing it.
+
+    Three lines tall, the track on the middle one, as an input's text: a form row is as
+    tall as an input's. The value has a slot as wide as the widest one, so the track
+    keeps its length as the value changes.
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("left,down", "move(-1)", "Decrease", show=False),
+        Binding("right,up", "move(1)", "Increase", show=False),
+        Binding("pagedown", "move_page(-1)", show=False),
+        Binding("pageup", "move_page(1)", show=False),
+        Binding("home", "move_to_end(0)", show=False),
+        Binding("end", "move_to_end(1)", show=False),
+    ]
+
+    COMPONENT_CLASSES: ClassVar[set[str]] = {
+        "slider--value",
+        "slider--filled",
+        "slider--handle",
+        "slider--empty",
+    }
+
+    # a form row's field while the row is invalid (see `ROW_INVALID_CLASS`)
+    DEFAULT_CSS = """
+    ComposeSlider {
+        height: 3;
+        width: 1fr;
+        padding: 1 1;
+        & > .slider--filled {
+            color: $primary;
+        }
+        & > .slider--handle {
+            color: $primary;
+        }
+        & > .slider--empty {
+            color: $foreground 30%;
+        }
+        &:focus > .slider--handle {
+            color: $accent;
+            text-style: bold;
+        }
+        &.-row-invalid > .slider--filled, &.-row-invalid > .slider--handle {
+            color: $error;
+        }
+    }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.first = 0
+        self.step = 1
+        self.last = 0
+        self.position = 0
+        self._is_dragging = False
+        self.moved: Signal[int] = Signal()
+
+    @property
+    def shown_value(self) -> int:
+        return self.first + self.position * self.step
+
+    def set_steps(self, first: int, step: int, last: int, position: int) -> None:
+        """Show `position` out of `last` steps of `step` from `first`, without `moved`."""
+        self.first, self.step, self.last, self.position = first, step, last, position
+        self.refresh()
+
+    def render(self) -> RenderResult:
+        width = self._track_width()
+        if width <= 0:
+            return ""
+        handle = self._handle_column(width)
+        text = Text(no_wrap=True, overflow="crop")
+        text.append("━" * handle, style=self.get_component_rich_style("slider--filled"))
+        text.append("●", style=self.get_component_rich_style("slider--handle"))
+        empty = "─" * (width - handle - 1)
+        text.append(empty, style=self.get_component_rich_style("slider--empty"))
+        value = str(self.shown_value).rjust(self._slot_width())
+        text.append(f" {value}", style=self.get_component_rich_style("slider--value"))
+        return text
+
+    def _slot_width(self) -> int:
+        return max(len(str(self.first)), len(str(self.first + self.last * self.step)))
+
+    def _track_width(self) -> int:
+        """Get the track's columns: the content's, less the value's slot and a space."""
+        return self.content_size.width - self._slot_width() - 1
+
+    def _handle_column(self, width: int) -> int:
+        return 0 if self.last == 0 else round(self.position * (width - 1) / self.last)
+
+    def action_move(self, steps: int) -> None:
+        self._move_to(self.position + steps)
+
+    def action_move_page(self, direction: int) -> None:
+        self._move_to(self.position + direction * max(1, self.last // 10))
+
+    def action_move_to_end(self, end: int) -> None:
+        self._move_to(end * self.last)
+
+    def on_mouse_down(self, event: events.MouseDown) -> None:
+        self._is_dragging = True
+        self.capture_mouse()
+        self._move_to_column(event.get_content_offset_capture(self).x)
+
+    def on_mouse_move(self, event: events.MouseMove) -> None:
+        if self._is_dragging:
+            self._move_to_column(event.get_content_offset_capture(self).x)
+
+    def on_mouse_up(self, _event: events.MouseUp) -> None:
+        self._is_dragging = False
+        self.release_mouse()
+
+    def _move_to_column(self, column: int) -> None:
+        width = self._track_width()
+        if width > 1:
+            self._move_to(round(column * self.last / (width - 1)))
+
+    def _move_to(self, position: int) -> None:
+        position = min(max(0, position), self.last)
+        if position != self.position:
+            self.position = position
+            self.refresh()
+            self.moved.emit(self.shown_value)

composeui/textualcore/widgets/composesourcetable.py

@@ -0,0 +1,288 @@
+"""A large table's widget: a scrolled view that asks its view for the lines it draws."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Protocol
+
+from rich.segment import Segment
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical
+from textual.geometry import Size
+from textual.scroll_view import ScrollView
+from textual.strip import Strip
+from textual.widgets import Static
+from textual_fspicker import FileSave, Filters
+from textual_fspicker.path_filters import Filter
+
+from composeui.core.signal import Signal, SignalNoArgs
+from composeui.textualcore.widgets.composefiltertable import ComposeFilterBar
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from textual import events
+    from textual.app import ComposeResult
+
+
+#: the key exporting the rows shown as CSV
+EXPORT_KEY = "e"
+#: the characters a cell shows as spaces, on one line
+_SPACES = str.maketrans(dict.fromkeys("\t\n\r\v\f", " "))
+
+
+def _is_csv(path: Path) -> bool:
+    return path.suffix.lower() == ".csv"
+
+
+class SourceTableLike(Protocol):
+    """What the widget reads from a `SourceTableView`."""
+
+    @property
+    def headers(self) -> list[str]: ...
+    @property
+    def row_count(self) -> int: ...
+    def rows(self, start: int, stop: int) -> list[tuple[Any, list[str]]]: ...
+    def is_selected(self, row_id: Any) -> bool: ...
+
+
+class ComposeSourceTable(ScrollView, can_focus=True):
+    """A large table: its headers on its first line, then a line per row, as scrolled.
+
+    Textual asks for the lines it draws (`render_line`), and the view reads their rows
+    from its source a window at a time: the widget keeps no row. Each line starts with
+    its row's position, from 1; the columns share the rest of the width, a cell too long
+    cut short. `reset` shows a new order of the rows, `repaint` the same rows formatted
+    or selected again.
+
+    `header_clicked` emits the column whose header the user clicked; the header shows
+    the order `set_sort` gives (▲ or ▼ after its header), the table never sorting its
+    rows itself.
+
+    A cursor marks a row, which the arrow keys, Page Up, Page Down, Home and End move,
+    the table scrolling to keep it shown. The table selects no row itself: `row_clicked`
+    emits the position of the row the user clicked, or the cursor's on Space, and whether
+    Shift extends the selection to it; `row_activated` emits it on a double click or
+    Enter. A selected row has the primary color. `copy_requested` emits on Ctrl+C. Its
+    key `e` asks where to export the rows as CSV, which `export_path_chosen` emits.
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("up", "move_cursor(-1)", "Up", show=False),
+        Binding("down", "move_cursor(1)", "Down", show=False),
+        Binding("pageup", "move_cursor('-page')", "Page up", show=False),
+        Binding("pagedown", "move_cursor('page')", "Page down", show=False),
+        Binding("home", "move_cursor('-all')", "First row", show=False),
+        Binding("end", "move_cursor('all')", "Last row", show=False),
+        Binding("space", "click_cursor(False)", "Select", show=False),
+        Binding("shift+space", "click_cursor(True)", "Select up to", show=False),
+        Binding("enter", "activate_cursor", "Activate", show=False),
+        Binding("ctrl+c", "copy_rows", "Copy", show=False),
+    ]
+    COMPONENT_CLASSES: ClassVar[set[str]] = {
+        "data-table--header",
+        "data-table--even-row",
+        "data-table--cursor",
+        "data-table--selected",
+    }
+    DEFAULT_CSS = """
+    ComposeSourceTable {
+        height: 1fr;
+        min-height: 5;
+        overflow-x: hidden;
+        & > .data-table--header {
+            text-style: bold;
+            background: $panel;
+        }
+        & > .data-table--even-row {
+            background: $surface-lighten-1;
+        }
+        & > .data-table--selected {
+            background: $primary;
+            color: $text;
+        }
+        & > .data-table--cursor {
+            text-style: reverse;
+        }
+    }
+    """
+
+    def __init__(self, table: SourceTableLike) -> None:
+        super().__init__()
+        self._table = table
+        self._sort: tuple[int, bool] | None = None
+        #: the position of the row the cursor marks
+        self.cursor = 0
+        self.header_clicked: Signal[int] = Signal()
+        self.row_clicked: Signal[int, bool] = Signal()
+        self.row_activated: Signal[int] = Signal()
+        self.copy_requested: SignalNoArgs = SignalNoArgs()
+        self.export_path_chosen: Signal[Path] = Signal()
+        #: the name the export's dialog offers
+        self.export_filename = "table.csv"
+        self.set_export_text("Export CSV")
+
+    def set_export_text(self, text: str) -> None:
+        """Describe the key exporting the rows, e.g. in the app's footer."""
+        self._bindings.key_to_bindings.pop(EXPORT_KEY, None)
+        self._bindings.bind(EXPORT_KEY, "export", text)
+        self.refresh_bindings()
+
+    def action_export(self) -> None:
+        dialog = FileSave(
+            filters=Filters(Filter("CSV", _is_csv)), default_file=self.export_filename
+        )
+        self.app.push_screen(dialog, self._export_path_chosen)
+
+    def _export_path_chosen(self, path: Path | None) -> None:
+        if path is not None:
+            self.export_path_chosen.emit(
+                path if _is_csv(path) else path.with_name(f"{path.name}.csv")
+            )
+
+    def set_sort(self, sort: tuple[int, bool] | None) -> None:
+        """Show the order: by a column, descending or not; None for the source's own."""
+        self._sort = sort
+        self.refresh()
+
+    def action_move_cursor(self, step: int | str) -> None:
+        """Move the cursor by `step` rows, a page of them (``"page"``) or to an end."""
+        steps = {"page": self._shown_rows(), "-page": -self._shown_rows()}
+        steps.update({"all": self._table.row_count, "-all": -self._table.row_count})
+        count = int(steps.get(step, step) if isinstance(step, str) else step)
+        self.cursor = min(max(self.cursor + count, 0), max(self._table.row_count - 1, 0))
+        self._show_cursor()
+
+    def action_click_cursor(self, is_extended: bool) -> None:
+        if self.cursor < self._table.row_count:
+            self.row_clicked.emit(self.cursor, is_extended)
+
+    def action_copy_rows(self) -> None:
+        self.copy_requested.emit()
+
+    def action_activate_cursor(self) -> None:
+        if self.cursor < self._table.row_count:
+            self.row_activated.emit(self.cursor)
+
+    def on_click(self, event: events.Click) -> None:
+        if event.y > 0:
+            row = round(self.scroll_offset.y) + event.y - 1
+            if row < self._table.row_count:
+                self.cursor = row
+                self.refresh()
+                if event.chain == 2:  # noqa: PLR2004 (a double click)
+                    self.row_activated.emit(row)
+                else:
+                    self.row_clicked.emit(row, event.shift)
+            return
+        number_width = self._number_width()
+        count = len(self._table.headers)
+        if count == 0 or event.x < number_width:
+            return
+        share = max((self._width() - number_width) // count, 1)
+        column = (event.x - number_width) // share
+        if column < count:
+            self.header_clicked.emit(column)
+
+    def reset(self) -> None:
+        # the header's line, then the rows'
+        self.virtual_size = Size(self._width(), self._table.row_count + 1)
+        self.cursor = min(self.cursor, max(self._table.row_count - 1, 0))
+        self.refresh()
+
+    def repaint(self) -> None:
+        self.refresh()
+
+    def on_resize(self, _event: events.Resize) -> None:
+        self.virtual_size = Size(self._width(), self._table.row_count + 1)
+
+    def render_line(self, y: int) -> Strip:
+        width = self._width()
+        number_width = self._number_width()
+        if y == 0:  # the headers stay on top, whatever the scroll
+            headers = list(self._table.headers)
+            if self._sort is not None and self._sort[0] < len(headers):
+                column, is_descending = self._sort
+                headers[column] += " ▼" if is_descending else " ▲"
+            text = self._line(" " * number_width, headers, width - number_width)
+            return Strip([Segment(text, self.get_component_rich_style("data-table--header"))])
+        row = round(self.scroll_offset.y) + y - 1
+        rows = self._table.rows(row, row + 1)
+        if len(rows) == 0:
+            return Strip.blank(width, self.rich_style)
+        row_id, cells = rows[0]
+        position = f"{row + 1:,}".rjust(number_width - 1) + " "
+        text = self._line(position, cells, width - number_width)
+        style = self.rich_style
+        if self._table.is_selected(row_id):
+            style += self.get_component_rich_style("data-table--selected")
+        elif row % 2 == 1:
+            style += self.get_component_rich_style("data-table--even-row")
+        if row == self.cursor and self.has_focus:
+            style += self.get_component_rich_style("data-table--cursor")
+        return Strip([Segment(text, style)])
+
+    def _shown_rows(self) -> int:
+        """Get the number of rows shown at once, under the headers' line."""
+        return max(self.scrollable_content_region.height - 1, 1)
+
+    def _show_cursor(self) -> None:
+        """Scroll as little as needed for the cursor's row to show."""
+        top = round(self.scroll_offset.y)
+        if self.cursor < top:
+            self.scroll_to(y=self.cursor, animate=False)
+        elif self.cursor >= top + self._shown_rows():
+            self.scroll_to(y=self.cursor - self._shown_rows() + 1, animate=False)
+        self.refresh()
+
+    def _width(self) -> int:
+        """Get the width of the lines: the widget's, but its vertical scroll bar's."""
+        return self.scrollable_content_region.width
+
+    def _number_width(self) -> int:
+        """Get the width of the rows' positions, before their cells."""
+        return len(f"{self._table.row_count:,}") + 1
+
+    @staticmethod
+    def _line(start: str, cells: list[str], width: int) -> str:
+        """Get a line of `cells` after `start`, each in an equal share of `width`."""
+        if len(cells) == 0:
+            return start.ljust(len(start) + max(width, 0))
+        share = max(width // len(cells), 1)
+        # a line break or a tab would break the line: a space, as Ctrl+C copies it
+        flat = [cell.translate(_SPACES) for cell in cells]
+        parts = [
+            (cell if len(cell) < share else cell[: max(share - 2, 0)] + "…").ljust(share)
+            for cell in flat
+        ]
+        return (start + "".join(parts)).ljust(len(start) + max(width, 0))
+
+
+class ComposeDataFilterTable(Vertical):
+    """A large table under its filter bar, which shows only while a column filters.
+
+    When the search or the filters hide every row, `empty` says so under the headers.
+    """
+
+    DEFAULT_CSS = """
+    ComposeDataFilterTable {
+        height: 1fr;
+        & > Static.empty {
+            color: $text-muted;
+            text-align: center;
+            width: 1fr;
+        }
+    }
+    """
+
+    def __init__(self, table: SourceTableLike) -> None:
+        super().__init__()
+        self.bar = ComposeFilterBar()
+        self.bar.display = False
+        self.table = ComposeSourceTable(table)
+        self.empty = Static("", classes="empty", markup=False)
+        self.empty.display = False
+
+    def compose(self) -> ComposeResult:
+        yield self.bar
+        yield self.table
+        yield self.empty