dataeval-flow 0.1.0__py3-none-any.whl

dataeval_flow/_app/_panes/_config_pane.py

@@ -0,0 +1,173 @@
+"""Config sidebar pane — rebuild, section update, and focus management."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+from textual.containers import VerticalScroll
+from textual.css.query import NoMatches
+from textual.widgets import Static
+
+from dataeval_flow._app._panes._widgets import (
+    _CONFIG_SECTIONS,
+    SECTION_TITLES,
+    CfgItem,
+    CfgSectionHeader,
+    PaneWidget,
+    uid,
+)
+from dataeval_flow._app._viewmodel._rendering import snippet_config_item
+
+if TYPE_CHECKING:
+    from textual.app import App
+    from textual.widget import Widget
+
+    from dataeval_flow._app._viewmodel._builder_vm import BuilderViewModel
+else:
+    App = object
+
+
+class ConfigPaneMixin(App):
+    """Mixin providing config sidebar rebuild logic for FlowApp.
+
+    Expects the host class to also inherit from ``App`` and to provide
+    ``_vm`` and ``_get_pane_widgets`` (both supplied by ``FlowApp``).
+    """
+
+    if TYPE_CHECKING:
+        _vm: BuilderViewModel
+
+        def _get_pane_widgets(self, pane_id: str) -> list[PaneWidget]: ...
+
+    def _rebuild_config_pane(self) -> None:
+        """Full rebuild of the config sidebar."""
+        try:
+            container = cast(VerticalScroll, self.query_one("#config-pane", VerticalScroll))
+        except NoMatches:
+            return
+
+        focused = self.focused
+        restore = self._save_config_focus(focused)
+
+        if restore[0] is not None:
+            self.set_focus(None)
+
+        container.remove_children()
+        for category, _ in _CONFIG_SECTIONS:
+            self._mount_config_section(container, category)
+
+        if restore[0] is not None:
+            self.call_after_refresh(self._restore_config_focus, *restore)
+
+    def _rebuild_config_section(self, category: str) -> None:
+        """Rebuild a single config section in place."""
+        try:
+            container = cast(VerticalScroll, self.query_one("#config-pane", VerticalScroll))
+        except NoMatches:
+            return
+
+        focused = self.focused
+        restore = self._save_config_focus(focused)
+
+        if restore[0] == category:
+            self.set_focus(None)
+
+        insert_before = self._remove_section_widgets(container, category)
+        self._mount_config_section(container, category, before=insert_before)
+
+        if restore[0] == category:
+            self.call_after_refresh(self._restore_config_focus, *restore)
+
+    def _remove_section_widgets(self, container: VerticalScroll, category: str) -> PaneWidget | None:
+        """Remove all widgets for *category* and return the next section's header (or None)."""
+        in_section = False
+        insert_before: PaneWidget | None = None
+        to_remove: list[Widget] = []
+        for child in list(container.children):
+            if isinstance(child, CfgSectionHeader) and child.fc_category == category:
+                in_section = True
+                to_remove.append(child)
+            elif in_section:
+                if isinstance(child, CfgSectionHeader):
+                    insert_before = child
+                    break
+                to_remove.append(child)
+        for w in to_remove:
+            w.remove()
+        return insert_before
+
+    def _mount_config_section(self, container: VerticalScroll, category: str, before: PaneWidget | None = None) -> None:
+        """Mount header + items for one config section."""
+        title = SECTION_TITLES.get(category, category)
+        items = self._vm.items(category)
+
+        widgets: list[Static] = []
+        widgets.append(
+            CfgSectionHeader(
+                f"[bold]{title}[/bold] [dim]({len(items)})[/dim]",
+                category=category,
+                classes="cfg-section-header",
+                id=uid("ch"),
+                markup=True,
+            )
+        )
+        if not items:
+            widgets.append(Static("[dim]  (empty)[/dim]"))
+        else:
+            for idx, item in enumerate(items):
+                snippet = snippet_config_item(category, item)
+                widgets.append(
+                    CfgItem(
+                        snippet,
+                        category=category,
+                        index=idx,
+                        classes="cfg-item",
+                        id=uid("ci"),
+                        markup=True,
+                    )
+                )
+
+        if before is not None:
+            for w in widgets:
+                container.mount(w, before=before)
+        else:
+            for w in widgets:
+                container.mount(w)
+
+    # -- Config focus save/restore -----------------------------------------
+
+    def _save_config_focus(self, focused: Any) -> tuple[str | None, int | None, bool]:
+        """Extract focus context from the currently focused widget."""
+        if isinstance(focused, CfgItem) and focused.pane == "config-pane":
+            return focused.fc_category, focused.fc_index, False
+        if isinstance(focused, CfgSectionHeader) and focused.pane == "config-pane":
+            return focused.fc_category, None, True
+        return None, None, False
+
+    def _restore_config_focus(self, category: str | None, index: int | None, is_header: bool) -> None:
+        """Restore focus by finding the widget with matching attributes."""
+        if category is None:
+            return
+        widgets = self._get_pane_widgets("config-pane")
+        if is_header or index is None:
+            target = next((w for w in widgets if isinstance(w, CfgSectionHeader) and w.fc_category == category), None)
+        else:
+            target = next(
+                (w for w in widgets if isinstance(w, CfgItem) and w.fc_category == category and w.fc_index == index),
+                None,
+            )
+            if target is None and index > 0:
+                target = next(
+                    (
+                        w
+                        for w in reversed(widgets)
+                        if isinstance(w, CfgItem) and w.fc_category == category and w.fc_index < index
+                    ),
+                    None,
+                )
+            if target is None:
+                target = next(
+                    (w for w in widgets if isinstance(w, CfgSectionHeader) and w.fc_category == category), None
+                )
+        if target is not None:
+            self.set_focus(target, scroll_visible=False)

dataeval_flow/_app/_panes/_result_pane.py

@@ -0,0 +1,125 @@
+"""Result pane — rebuild, incremental append/update."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from textual.containers import VerticalScroll
+from textual.css.query import NoMatches
+from textual.widgets import Static
+
+from dataeval_flow._app._panes._widgets import PaneWidget, ResultCard, uid
+
+if TYPE_CHECKING:
+    from textual.app import App
+
+    from dataeval_flow._app._viewmodel._builder_vm import BuilderViewModel
+else:
+    App = object
+
+
+class ResultPaneMixin(App):
+    """Mixin providing result pane rebuild logic for FlowApp.
+
+    Expects the host class to also inherit from ``App`` and to provide ``_vm``.
+    """
+
+    if TYPE_CHECKING:
+        _vm: BuilderViewModel
+
+    def _rebuild_result_pane(self) -> None:
+        """Full rebuild of the result pane (used on undo/redo/load/new)."""
+        try:
+            container = self.query_one("#result-pane", VerticalScroll)
+        except NoMatches:
+            return
+
+        container.remove_children()
+        executions = [e for e in self._vm.all_executions() if e.status in ("completed", "failed")]
+        count = len(executions)
+        header_text = f"[bold]Results[/bold] [dim]({count})[/dim]" if count else "[bold]Results[/bold]"
+        container.mount(Static(header_text, classes="result-pane-header", id=uid("rh"), markup=True))
+
+        if not executions:
+            container.mount(Static("[dim]  (no results yet)[/dim]"))
+            return
+
+        for entry in executions:
+            snippet = self._render_result_snippet(entry)
+            card = ResultCard(
+                snippet,
+                task_name=entry.task_name,
+                classes="result-card",
+                id=uid("rc"),
+                markup=True,
+            )
+            container.mount(card)
+
+    def _render_result_snippet(self, entry: Any) -> str:
+        """Render a result card snippet for a single execution entry."""
+        from dataeval_flow._app._screens._detail import _colorize_marker
+        from dataeval_flow._app._viewmodel._result_vm import ResultViewModel
+
+        if entry.status == "completed" and entry.result is not None:
+            rvm = ResultViewModel(entry.result)
+            summary = rvm.summary_line()
+            warnings = rvm.warning_count()
+            severity_tag = " [bold red][!!][/bold red]" if warnings else " [green][ok][/green]"
+            lines = [f"[bold]{entry.task_name}[/bold] — {summary}{severity_tag}"]
+            for fi in range(rvm.finding_count()):
+                fline = _colorize_marker(rvm.finding_summary_markup(fi))
+                lines.append(f"  {fline}")
+            return "\n".join(lines)
+        error_brief = (entry.error or "unknown error")[:60]
+        return f"[bold]{entry.task_name}[/bold] — [bold red]FAILED[/bold red]: {error_brief}"
+
+    def _append_or_update_result(self, task_name: str) -> None:
+        """Add or update a single result card without full rebuild."""
+        entry = self._vm.task_execution(task_name)
+        if entry is None or entry.status not in ("completed", "failed"):
+            return
+
+        snippet = self._render_result_snippet(entry)
+
+        # Try to update existing card (re-run of same task)
+        try:
+            container = self.query_one("#result-pane", VerticalScroll)
+        except NoMatches:
+            return
+        for child in container.children:
+            if isinstance(child, ResultCard) and child.task_name == task_name:
+                child.update(snippet)
+                self._update_result_header()
+                return
+
+        # Remove "no results yet" placeholder
+        for child in list(container.children):
+            is_placeholder = isinstance(child, Static) and not isinstance(child, PaneWidget)
+            if is_placeholder and "no results" in str(getattr(child, "content", "")):
+                child.remove()
+                break
+
+        # Append new card
+        card = ResultCard(
+            snippet,
+            task_name=task_name,
+            classes="result-card",
+            id=uid("rc"),
+            markup=True,
+        )
+        container.mount(card)
+        self._update_result_header()
+
+    def _update_result_header(self) -> None:
+        """Update the result pane header count without rebuilding."""
+        executions = [e for e in self._vm.all_executions() if e.status in ("completed", "failed")]
+        count = len(executions)
+        header_text = f"[bold]Results[/bold] [dim]({count})[/dim]" if count else "[bold]Results[/bold]"
+        try:
+            container = self.query_one("#result-pane", VerticalScroll)
+        except NoMatches:
+            return
+        for child in container.children:
+            if isinstance(child, Static) and "result-pane-header" in (child.classes or set()):
+                child.update(header_text)
+                break

dataeval_flow/_app/_panes/_task_pane.py

@@ -0,0 +1,91 @@
+"""Task pane — rebuild and targeted card updates."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.containers import VerticalScroll
+from textual.css.query import NoMatches
+from textual.widgets import Static
+
+from dataeval_flow._app._panes._widgets import TaskCard, TaskPaneHeader, uid
+from dataeval_flow._app._viewmodel._rendering import snippet_task_with_execution
+
+if TYPE_CHECKING:
+    from textual.app import App
+
+    from dataeval_flow._app._viewmodel._builder_vm import BuilderViewModel
+else:
+    App = object
+
+
+class TaskPaneMixin(App):
+    """Mixin providing task pane rebuild logic for FlowApp.
+
+    Expects the host class to also inherit from ``App`` and to provide ``_vm``.
+    """
+
+    if TYPE_CHECKING:
+        _vm: BuilderViewModel
+
+    def _rebuild_task_pane(self) -> None:
+        """Full rebuild of the task pane (structural changes only)."""
+        try:
+            container = self.query_one("#task-pane", VerticalScroll)
+        except NoMatches:
+            return
+
+        focused = self.focused
+        restore_index: int | None = None
+        if isinstance(focused, TaskCard):
+            restore_index = focused.fc_index
+
+        container.remove_children()
+        tasks = self._vm.items("tasks")
+        header = TaskPaneHeader(
+            f"[bold]Tasks[/bold] [dim]({len(tasks)})[/dim]",
+            classes="task-pane-header",
+            id=uid("th"),
+            markup=True,
+        )
+        container.mount(header)
+
+        if not tasks:
+            container.mount(Static("[dim]  (no tasks defined)[/dim]"))
+        else:
+            for idx, task in enumerate(tasks):
+                task_name = task.get("name", "")
+                execution = self._vm.task_execution(task_name)
+                snippet = snippet_task_with_execution(task, execution)
+                card = TaskCard(
+                    snippet,
+                    index=idx,
+                    task_name=task_name,
+                    classes="task-card",
+                    id=uid("tc"),
+                    markup=True,
+                )
+                container.mount(card)
+
+        if restore_index is not None:
+            target = next(
+                (w for w in container.children if isinstance(w, TaskCard) and w.fc_index == restore_index), None
+            )
+            if target is not None:
+                self.set_focus(target)
+
+    def _update_task_card_by_name(self, task_name: str) -> None:
+        """Update a single task card's content without rebuilding the pane."""
+        try:
+            container = self.query_one("#task-pane", VerticalScroll)
+        except NoMatches:
+            return
+        for child in container.children:
+            if isinstance(child, TaskCard) and child.task_name == task_name:
+                execution = self._vm.task_execution(task_name)
+                task = next((t for t in self._vm.items("tasks") if t.get("name") == task_name), None)
+                if task is not None:
+                    child.update(snippet_task_with_execution(task, execution))
+                return
+        # Card not found — structural change happened, full rebuild
+        self._rebuild_task_pane()

dataeval_flow/_app/_panes/_widgets.py

@@ -0,0 +1,111 @@
+"""Focusable widget classes shared across panes."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.widgets import Static
+
+# Pane IDs used for Tab-cycling between panes
+PANE_IDS = ("config-pane", "task-pane", "result-pane")
+
+_CONFIG_SECTIONS = [
+    ("datasets", "Datasets"),
+    ("selections", "Selections"),
+    ("sources", "Sources"),
+    ("preprocessors", "Preprocessors"),
+    ("extractors", "Extractors"),
+    ("workflows", "Workflows"),
+]
+
+SECTION_TITLES: dict[str, str] = dict(_CONFIG_SECTIONS)
+
+# ---------------------------------------------------------------------------
+# Global unique-ID factory — avoids Textual DuplicateIds on rebuild
+# ---------------------------------------------------------------------------
+
+_next_uid: int = 0
+
+
+def uid(prefix: str) -> str:
+    """Return a globally unique widget ID like ``prefix-42``."""
+    global _next_uid
+    _next_uid += 1
+    return f"{prefix}-{_next_uid}"
+
+
+# ---------------------------------------------------------------------------
+# Focusable pane widgets
+# ---------------------------------------------------------------------------
+
+
+class PaneWidget(Static):
+    """Base for focusable widgets that know which pane they live in."""
+
+    can_focus = True
+    pane: str = ""
+
+    def key_down(self) -> None:
+        self.app._focus_within_pane(self.pane, 1)  # type: ignore[attr-defined]  # noqa: SLF001
+
+    def key_up(self) -> None:
+        self.app._focus_within_pane(self.pane, -1)  # type: ignore[attr-defined]  # noqa: SLF001
+
+    def key_tab(self) -> None:
+        self.app._cycle_pane(1)  # type: ignore[attr-defined]  # noqa: SLF001
+
+    def key_shift_tab(self) -> None:
+        self.app._cycle_pane(-1)  # type: ignore[attr-defined]  # noqa: SLF001
+
+    async def _on_key(self, event: Any) -> None:
+        if event.key in ("tab", "shift+tab", "down", "up"):
+            event.stop()
+            event.prevent_default()
+        await super()._on_key(event)
+
+
+class CfgSectionHeader(PaneWidget):
+    pane = "config-pane"
+
+    def __init__(self, content: str, category: str, **kw: Any) -> None:
+        super().__init__(content, **kw)
+        self.fc_category = category
+
+
+class CfgItem(PaneWidget):
+    pane = "config-pane"
+
+    def __init__(self, content: str, category: str, index: int, **kw: Any) -> None:
+        super().__init__(content, **kw)
+        self.fc_category = category
+        self.fc_index = index
+
+
+class TaskPaneHeader(PaneWidget):
+    pane = "task-pane"
+
+    def __init__(self, content: str, **kw: Any) -> None:
+        super().__init__(content, **kw)
+        self.fc_category = "tasks"
+
+
+class TaskCard(PaneWidget):
+    pane = "task-pane"
+
+    def __init__(self, content: str, index: int, task_name: str = "", **kw: Any) -> None:
+        super().__init__(content, **kw)
+        self.fc_category = "tasks"
+        self.fc_index = index
+        self.task_name = task_name
+
+
+class ResultPaneHeader(PaneWidget):
+    pane = "result-pane"
+
+
+class ResultCard(PaneWidget):
+    pane = "result-pane"
+
+    def __init__(self, content: str, task_name: str, **kw: Any) -> None:
+        super().__init__(content, **kw)
+        self.task_name = task_name

dataeval_flow/_app/_screens/__init__.py

@@ -0,0 +1,25 @@
+"""Screen and modal components for the TUI app."""
+
+from dataeval_flow._app._screens._base import _MODAL_CSS, ComponentModal, _select_value
+from dataeval_flow._app._screens._detail import ErrorDetailModal, ResultDetailModal
+from dataeval_flow._app._screens._model import ModelModal
+from dataeval_flow._app._screens._params import build_param_form, collect_param_form, validate_param_form
+from dataeval_flow._app._screens._pathpicker import PathPickerScreen
+from dataeval_flow._app._screens._section import SectionModal
+from dataeval_flow._app._screens._settings import ExecutionSettings, SettingsModal
+
+__all__ = [
+    "ComponentModal",
+    "ErrorDetailModal",
+    "ExecutionSettings",
+    "ModelModal",
+    "PathPickerScreen",
+    "ResultDetailModal",
+    "SectionModal",
+    "SettingsModal",
+    "_MODAL_CSS",
+    "_select_value",
+    "build_param_form",
+    "collect_param_form",
+    "validate_param_form",
+]