composeui 0.1.0__py3-none-any.whl

composeui/textualcore/widgets/composedialog.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar, Optional
+
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.content import Content
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Static
+
+from composeui.core.view import DialogKind
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.binding import BindingType
+
+    from composeui.core.view import DialogView
+
+
+class ComposeDialog(ModalScreen[Optional[bool]]):
+    """A dialog's modal screen, dismissed with True (accepted), False (rejected) or None.
+
+    None is a dialog closed with Escape, without a button. Built from the dialog's view
+    as it opens.
+    """
+
+    DEFAULT_CSS = """
+    ComposeDialog {
+        align: center middle;
+    }
+    ComposeDialog > Vertical {
+        width: auto;
+        min-width: 40;
+        max-width: 80%;
+        height: auto;
+        padding: 1 2;
+        border: thick $primary 80%;
+        background: $surface;
+    }
+    ComposeDialog .title {
+        text-style: bold;
+        margin-bottom: 1;
+    }
+    ComposeDialog Horizontal {
+        width: 100%;
+        height: auto;
+        align-horizontal: right;
+        margin-top: 1;
+    }
+    ComposeDialog Button {
+        margin-left: 1;
+    }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [Binding("escape", "dismiss_dialog", "Close")]
+
+    def __init__(self, view: DialogView) -> None:
+        super().__init__()
+        self.title_label = Label(view.title, classes="title", markup=False)
+        self.title_label.display = view.title != ""
+        self.text_label = Static(view.text, markup=False)
+        self.accept_button = Button(Content(view.accept_text), variant="primary", id="accept")
+        self.reject_button = Button(Content(view.reject_text), id="reject")
+        self.reject_button.display = view.kind is DialogKind.CONFIRM
+        self.is_enabled = view.is_enabled
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield self.title_label
+            yield self.text_label
+            with Horizontal():
+                yield self.reject_button
+                yield self.accept_button
+
+    def on_mount(self) -> None:
+        self.set_enabled(is_enabled=self.is_enabled)
+        self.accept_button.focus()
+
+    def set_enabled(self, *, is_enabled: bool) -> None:
+        self.is_enabled = is_enabled
+        self.accept_button.disabled = not is_enabled
+        self.reject_button.disabled = not is_enabled
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        event.stop()
+        self.dismiss(event.button is self.accept_button)
+
+    def action_dismiss_dialog(self) -> None:
+        if self.is_enabled:
+            self.dismiss(None)

composeui/textualcore/widgets/composefilepathinput.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import functools
+from pathlib import Path
+
+from textual.containers import Horizontal
+from textual.widgets import Button
+from textual_fspicker import FileOpen
+from textual_fspicker.path_filters import Filter, Filters
+
+from composeui.core.signal import Signal, SignalNoArgs
+from composeui.textualcore.widgets.composeinput import ComposeInput
+
+
+def _has_any_extension(path: Path, extensions: tuple[str, ...]) -> bool:
+    return any(path.name.endswith(extension) for extension in extensions)
+
+
+class ComposeFilePathInput(Horizontal):
+    """A field typing a file's path, then a "…" button picking one, and a reload button.
+
+    The picker is textual-fspicker's, a screen of its own, opening in the directory of
+    the field's path, if any; `path_picked` reports the file picked, once the field shows
+    it. The reload button only reports its presses, and shows with `has_reload`.
+    """
+
+    DEFAULT_CSS = """
+    ComposeFilePathInput {
+        height: auto;
+        & > ComposeInput {
+            width: 1fr;
+        }
+        & > Button {
+            min-width: 5;
+            width: 5;
+        }
+        &.-row-invalid > ComposeInput {
+            border: tall $error 60%;
+            &:focus {
+                border: tall $error;
+            }
+        }
+    }
+    """
+
+    def __init__(self) -> None:
+        self.input = ComposeInput()
+        self.browse_button = Button("…")
+        self.reload_button = Button("↻")
+        self.reload_button.display = False
+        super().__init__(self.input, self.browse_button, self.reload_button)
+        #: the file types the picker offers, by name, as the view's `extensions`
+        self.extensions: dict[str, tuple[str, ...]] = {}
+        #: the picker's title, the view's `browse_text`
+        self.picker_title = ""
+        self.path_picked: Signal[Path] = Signal()
+        self.reload_pressed = SignalNoArgs()
+
+    def open_picker(self) -> None:
+        """Show the file picker in the directory of the field's path, else the current one."""
+        text = self.input.value.strip()
+        location = Path(text).parent if text != "" else Path()
+        if not location.is_dir():  # e.g. a path typed halfway
+            location = Path()
+        filters = Filters(
+            *(
+                Filter(name, functools.partial(_has_any_extension, extensions=extensions))
+                for name, extensions in self.extensions.items()
+            )
+        )
+        picker = FileOpen(location, self.picker_title or "Open", filters=filters)
+        self.app.push_screen(picker, self._pick)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        event.stop()
+        if event.button is self.browse_button:
+            self.open_picker()
+        else:
+            self.reload_pressed.emit()
+
+    def _pick(self, path: Path | None) -> None:
+        if path is not None:
+            self.input.value = str(path)
+            self.path_picked.emit(path)
+        self.input.focus()

composeui/textualcore/widgets/composefiltertable.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable
+
+from textual.binding import Binding
+from textual.containers import Horizontal, HorizontalScroll, Vertical
+from textual.content import Content
+from textual.widgets import Button, Input, Select, Static
+
+from composeui.core.signal import Signal, SignalNoArgs
+from composeui.core.view import SEARCH_DELAY_MS, as_pattern, split_pattern
+from composeui.textualcore.widgets.composetable import ComposeTable
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.timer import Timer
+
+
+#: a chip's remove button: a multiplication sign, as a close button often is
+REMOVE = "\u00d7"
+#: after a chip's text: a pencil, as its click edits the filter
+EDIT = "\u270e"
+
+
+class _ValueInput(Input):
+    """The filter editor's value field: Escape closes the editor."""
+
+    BINDINGS = [Binding("escape", "close_editor", "Close", show=False)]  # noqa: RUF012
+
+    def __init__(self) -> None:
+        super().__init__(compact=True)
+        self.escaped = SignalNoArgs()
+
+    def action_close_editor(self) -> None:
+        self.escaped.emit()
+
+
+class ComposeFilterChip(Horizontal):
+    """A filter, as its column's header then its text, opening it, and a button removing it.
+
+    The pencil after the text and the tooltip say a click edits it.
+    """
+
+    DEFAULT_CSS = """
+    ComposeFilterChip {
+        width: auto;
+        height: 1;
+        margin-right: 1;
+    }
+    """
+
+    def __init__(self, column: int, text: str, edit_text: str, remove_text: str) -> None:
+        super().__init__()
+        self.column = column
+        self.open_button = Button(
+            Content(f"{text} {EDIT}"),
+            compact=True,
+            classes="chip-text",
+            tooltip=Content(edit_text),
+        )
+        self.remove_button = Button(
+            REMOVE, compact=True, classes="chip-remove", tooltip=Content(remove_text)
+        )
+
+    def compose(self) -> ComposeResult:
+        yield self.open_button
+        yield self.remove_button
+
+
+class ComposeFilterBar(Horizontal):
+    """A table's filter bar, on one line: a search, the filters as chips, the rows shown.
+
+    The chips scroll sideways when they don't fit.
+
+    "+ Filter" opens an editor in the bar, of a column, a value and an Add button, and in
+    a text column a toggle (`pattern`, primary while on) making the value a regular
+    expression: Enter or Add adds the filter, unless `check` says why its value can't
+    filter, marking the value field `-invalid` with the reason as its tooltip; Escape
+    closes it. A chip's
+    text opens the editor on its filter, its remove button removes it. The signals emit only for the
+    user: `search_edited` the text typed, `filter_added` a column and its text,
+    `filter_removed` a column, and `filters_cleared`. `search_edited` waits
+    `SEARCH_DELAY_MS` after the last key, but emits at once on Enter or once the search is
+    cleared.
+    """
+
+    DEFAULT_CSS = """
+    ComposeFilterBar {
+        height: 1;
+        margin-bottom: 1;
+        & > Input#search {
+            width: 20;
+            margin-right: 1;
+        }
+        & > Select {
+            width: 28;
+        }
+        & > Input#value {
+            width: 20;
+        }
+        & > Button {
+            margin-right: 1;
+        }
+        /* the chips take the room left, scrolling: Textual lays nothing out wrapping */
+        & > HorizontalScroll#chips {
+            width: 1fr;
+            height: 1;
+            scrollbar-size-horizontal: 0;
+        }
+        & > Static#count {
+            width: auto;
+            color: $text-muted;
+        }
+    }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        #: why a column's text can't filter it, or None if it can
+        self.check: Callable[[int, str], str | None] = lambda _column, _text: None
+        #: a hint at what filters a column, as a regular expression or not
+        self.placeholder: Callable[[int, bool], str] = lambda _column, _is_pattern: ""
+        #: whether a regular expression filters a column
+        self.takes_pattern: Callable[[int], bool] = lambda _column: False
+        self.search_edited: Signal[str] = Signal()
+        self.filter_added: Signal[int, str] = Signal()
+        self.filter_removed: Signal[int] = Signal()
+        self.filters_cleared: SignalNoArgs = SignalNoArgs()
+        self._search_timer: Timer | None = None
+        self._texts: dict[str, str] = {}
+        self._filters: list[tuple[int, str, str, str]] = []
+        #: the column whose chip takes the focus once shown, its filter just added
+        self._focused_chip: int | None = None
+        self.search = Input(id="search", compact=True)
+        self.add_filter = Button("", id="add-filter", compact=True)
+        self.column: Select[int] = Select([], id="column", compact=True, allow_blank=True)
+        self.pattern = Button(".*", id="pattern", compact=True)
+        self.value = _ValueInput()
+        self.value.id = "value"
+        self.value.escaped.connect(self.close_editor)
+        self.add = Button("", id="add", compact=True)
+        self.chips = HorizontalScroll(id="chips")
+        self.clear = Button("", id="clear", compact=True)
+        self.count = Static("", id="count", markup=False)
+        self._columns: list[tuple[int, str]] = []
+        self.close_editor()
+
+    def compose(self) -> ComposeResult:
+        yield self.search
+        yield self.add_filter
+        yield self.column
+        yield self.pattern
+        yield self.value
+        yield self.add
+        yield self.chips
+        yield self.clear
+        yield self.count
+
+    def on_mount(self) -> None:
+        self._offer_columns()
+        self._show_chips()
+
+    def set_texts(self, texts: dict[str, str]) -> None:
+        self._texts = texts
+        self.search.placeholder = texts.get("search", "")
+        self.add_filter.label = Content(texts.get("add_filter", ""))
+        self.add.label = Content(texts.get("add", ""))
+        self.clear.label = Content(texts.get("clear", ""))
+        self.column.tooltip = Content(texts.get("column", ""))
+        self.pattern.tooltip = Content(texts.get("pattern", ""))
+        self.value.tooltip = None
+        self._show_chips()
+
+    def set_columns(self, columns: list[tuple[int, str]]) -> None:
+        """Offer `columns`, each its index and its header, in the editor."""
+        self._columns = columns
+        if self.is_mounted:
+            self._offer_columns()
+
+    def _offer_columns(self) -> None:
+        """Offer the columns, the one picked still picked, else the first."""
+        selected = self.column.value
+        self.column.set_options((Content(header), column) for column, header in self._columns)
+        columns = [column for column, _ in self._columns]
+        if selected in columns:
+            self.column.value = selected
+        elif len(columns) > 0:
+            self.column.value = columns[0]
+
+    def set_search(self, text: str) -> None:
+        if self.search.value != text:
+            self._stop_search_timer()  # the app's search, not the user's typed before
+            with self.search.prevent(Input.Changed):
+                self.search.value = text
+
+    def set_filters(self, filters: list[tuple[int, str, str, str]]) -> None:
+        """Show each filter as a chip: its column, the chip's text, the text typed, the header."""
+        self._filters = filters
+        self._show_chips()
+
+    def set_count(self, text: str) -> None:
+        self.count.update(text)
+        self.count.display = text != ""
+
+    def open_editor(self, column: int | None = None, text: str = "") -> None:
+        if column is not None and self.is_mounted:
+            self.column.value = column
+        text, is_pattern = split_pattern(text)
+        self.set_pattern(is_pattern=is_pattern)
+        with self.value.prevent(Input.Changed):
+            self.value.value = text
+        self._mark_invalid(None)
+        for widget in (self.column, self.value, self.add):
+            widget.display = True
+        self.add_filter.display = False
+        self._show_placeholder()
+        self.value.focus()
+
+    def close_editor(self) -> None:
+        had_focus = self.value.has_focus
+        for widget in (self.column, self.pattern, self.value, self.add):
+            widget.display = False
+        self.add_filter.display = True
+        if had_focus:
+            self.add_filter.focus()
+
+    def is_pattern(self) -> bool:
+        """Tell whether the value is a regular expression: the toggle is on."""
+        return self.pattern.variant == "primary"
+
+    def set_pattern(self, *, is_pattern: bool) -> None:
+        self.pattern.variant = "primary" if is_pattern else "default"
+        self._show_placeholder()
+
+    def is_editing(self) -> bool:
+        return bool(self.value.display)
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        event.stop()
+        if event.input is self.search:
+            self._stop_search_timer()
+            if event.value == "":
+                self._emit_search()
+            else:
+                self._search_timer = self.set_timer(SEARCH_DELAY_MS / 1000, self._emit_search)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        event.stop()
+        if event.input is self.value:
+            self._add()
+        elif event.input is self.search and self._search_timer is not None:
+            self._emit_search()
+
+    def _stop_search_timer(self) -> None:
+        if self._search_timer is not None:
+            self._search_timer.stop()
+            self._search_timer = None
+
+    def _emit_search(self) -> None:
+        self._stop_search_timer()
+        self.search_edited.emit(self.search.value)
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        event.stop()
+        self._show_placeholder()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        event.stop()
+        button = event.button
+        if button is self.add_filter:
+            self.open_editor()
+        elif button is self.add:
+            self._add()
+        elif button is self.pattern:
+            self.set_pattern(is_pattern=not self.is_pattern())
+        elif button is self.clear:
+            self.filters_cleared.emit()
+        else:  # a chip's
+            chip = button.parent
+            assert isinstance(chip, ComposeFilterChip)
+            if button is chip.remove_button:
+                self.filter_removed.emit(chip.column)
+            else:
+                typed = next(
+                    typed for column, _, typed, _ in self._filters if column == chip.column
+                )
+                self.open_editor(chip.column, typed)
+
+    def _show_chips(self) -> None:
+        self.clear.display = len(self._filters) >= 2  # noqa: PLR2004
+        if not self.is_mounted:
+            return
+        self.chips.remove_children()
+        remove, edit = self._texts.get("remove", "{header}"), self._texts.get("edit", "{header}")
+        chips = [
+            ComposeFilterChip(
+                column, text, edit.format(header=header), remove.format(header=header)
+            )
+            for column, text, _typed, header in self._filters
+        ]
+        self.chips.mount_all(chips)
+        for chip in chips:
+            if chip.column == self._focused_chip:
+                self.call_after_refresh(chip.open_button.focus)
+        self._focused_chip = None
+
+    def _add(self) -> None:
+        column = self.column.value
+        if not isinstance(column, int):
+            return
+        text = self.value.value
+        if self.is_pattern() and self.takes_pattern(column):
+            text = as_pattern(text)
+        reason = self.check(column, text)
+        if reason is not None:
+            self._mark_invalid(reason)
+            return
+        self.close_editor()
+        # its chip takes the focus: Enter opens it again
+        self._focused_chip = column
+        self.filter_added.emit(column, text)
+        self._focused_chip = None
+
+    def _mark_invalid(self, reason: str | None) -> None:
+        self.value.set_class(reason is not None, "-invalid")
+        self.value.tooltip = None if reason is None else Content(reason)
+
+    def _show_placeholder(self) -> None:
+        column = self.column.value
+        if not isinstance(column, int):
+            self.value.placeholder = ""
+            return
+        # a toggle only where a regular expression filters, while editing
+        takes_pattern = self.takes_pattern(column)
+        self.pattern.display = takes_pattern and bool(self.value.display)
+        self.value.placeholder = self.placeholder(column, takes_pattern and self.is_pattern())
+
+
+class ComposeFilterTable(Vertical):
+    """A table of text under its filter bar, which shows only while a column filters.
+
+    When the filters hide every row, `empty` says so under the headers.
+    """
+
+    DEFAULT_CSS = """
+    ComposeFilterTable {
+        height: auto;
+        & > Static.empty {
+            color: $text-muted;
+            text-align: center;
+            width: 1fr;
+        }
+    }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.bar = ComposeFilterBar()
+        self.bar.display = False
+        self.table = ComposeTable()
+        self.empty = Static("", classes="empty", markup=False)
+        self.empty.display = False
+
+    def compose(self) -> ComposeResult:
+        yield self.bar
+        yield self.table
+        yield self.empty

composeui/textualcore/widgets/composeformdialog.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+from textual.binding import Binding
+from textual.containers import Horizontal, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Static
+
+from composeui.core.signal import Signal, SignalNoArgs
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.binding import BindingType
+    from textual.widget import Widget
+
+
+class ComposeFormDialog(ModalScreen[None]):
+    """A form dialog's modal screen: its title, text and form, then Cancel and OK.
+
+    Installed once and pushed at each opening, so its form keeps its widgets: a screen
+    dismissed can't be pushed again. It reports the user's answer (`answered`: "accept",
+    "reject", or "dismiss" for Escape) without closing; its renderer pops it once the
+    view closes the dialog, which stays open when its form refuses OK.
+    """
+
+    DEFAULT_CSS = """
+    ComposeFormDialog {
+        align: center middle;
+    }
+    ComposeFormDialog > VerticalScroll {
+        width: 70%;
+        max-width: 100;
+        height: auto;
+        max-height: 90%;
+        padding: 1 2;
+        border: thick $primary 80%;
+        background: $surface;
+    }
+    ComposeFormDialog .title {
+        text-style: bold;
+        margin-bottom: 1;
+    }
+    ComposeFormDialog Horizontal {
+        width: 100%;
+        height: auto;
+        align-horizontal: right;
+        margin-top: 1;
+    }
+    ComposeFormDialog Button {
+        margin-left: 1;
+    }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [Binding("escape", "dismiss_dialog", "Close")]
+
+    def __init__(self, form: Widget) -> None:
+        super().__init__()
+        self.title_label = Label(classes="title", markup=False)
+        self.text_label = Static(markup=False)
+        self.form = form
+        self.accept_button = Button("", variant="primary", id="accept")
+        self.reject_button = Button("", id="reject")
+        self.answered: Signal[str] = Signal()
+        #: the screen's widgets are mounted, its form's among them: once, as it's installed
+        self.mounted: SignalNoArgs = SignalNoArgs()
+
+    def compose(self) -> ComposeResult:
+        with VerticalScroll():
+            yield self.title_label
+            yield self.text_label
+            yield self.form
+            with Horizontal():
+                yield self.reject_button
+                yield self.accept_button
+
+    def on_mount(self) -> None:
+        self.mounted.emit()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        event.stop()
+        self.answered.emit("accept" if event.button is self.accept_button else "reject")
+
+    def action_dismiss_dialog(self) -> None:
+        if not self.reject_button.disabled:  # a disabled dialog can't be closed
+            self.answered.emit("dismiss")

composeui/textualcore/widgets/composeinput.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from textual.widgets import Input
+
+from composeui.core.signal import Signal, SignalNoArgs
+
+if TYPE_CHECKING:
+    from textual import events
+
+
+class ComposeInput(Input):
+    """An `Input` that re-exposes its messages as plain composeui `Signal`s.
+
+    Textual dispatches `Input.Changed`/`Input.Submitted` by calling `on_input_changed`/
+    `on_input_submitted` on the widget itself (and its DOM ancestors); a renderer isn't
+    part of the DOM, so it can't bind to those directly. Bridging them to `Signal`s here
+    lets `TextualInputRenderer` connect like it would to any other composeui signal.
+    """
+
+    # a form row's field while the row is invalid (see `ROW_INVALID_CLASS`): as Input's
+    # own `-invalid`
+    DEFAULT_CSS = """
+    ComposeInput.-row-invalid {
+        border: tall $error 60%;
+        &:focus {
+            border: tall $error;
+        }
+    }
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.value_changed: Signal[str] = Signal()
+        self.value_submitted: SignalNoArgs = SignalNoArgs()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        self.value_changed.emit(event.value)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.value_submitted.emit()
+
+    def on_blur(self, event: events.Blur) -> None:
+        """Match Qt's `QLineEdit.editingFinished`, which fires on Enter *or* blur.
+
+        `Input.Submitted` alone only covers Enter; without this, tabbing/clicking
+        away from a field (instead of pressing Enter) never fires `editing_finished`.
+        """
+        self.value_submitted.emit()

composeui/textualcore/widgets/composelist.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from textual.containers import Vertical
+
+
+class ComposeList(Vertical):
+    """A list's views one above the other, as tall as they are.
+
+    Its collapsed collapsibles (an expander per record) leave out the line under their
+    title, a lone one's room for its content: one line apart, many records stay in view.
+    """
+
+    DEFAULT_CSS = """
+    ComposeList {
+        height: auto;
+        & > Collapsible.-collapsed {
+            padding-bottom: 0;
+        }
+    }
+    """