dataeval-flow 0.1.0__py3-none-any.whl

dataeval_flow/_app/_screens/_base.py

@@ -0,0 +1,242 @@
+"""Base modal class and shared utilities for modal dialogs."""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+from pathlib import Path
+from typing import Any
+
+from textual.app import ComposeResult, ScreenStackError
+from textual.containers import Horizontal
+from textual.css.query import NoMatches
+from textual.screen import ModalScreen
+from textual.widgets import Button, Checkbox, Input, Select
+
+from dataeval_flow._app._model._item import DELETE_SENTINEL
+from dataeval_flow._app._screens._pathpicker import PathPickerScreen
+
+_log = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Value helpers
+# ---------------------------------------------------------------------------
+
+
+def _select_value(sel: Select) -> str:
+    v = sel.value
+    if v is Select.BLANK or v is Select.NULL or v is None:
+        return ""
+    return str(v)
+
+
+# ---------------------------------------------------------------------------
+# Shared modal CSS
+# ---------------------------------------------------------------------------
+
+_MODAL_CSS = """
+.modal-dialog {
+    width: 70;
+    height: auto;
+    max-height: 85%;
+    border: round $accent 40%;
+    background: $surface;
+    padding: 1 2;
+}
+
+.modal-dialog Vertical {
+    height: auto;
+}
+
+SectionModal,
+ComponentModal {
+    align: center middle;
+}
+
+.modal-dialog Label {
+    margin: 1 0 0 0;
+    text-style: bold;
+}
+
+.modal-dialog Input {
+    margin: 0 0 1 0;
+}
+
+.modal-dialog Select {
+    margin: 0 0 1 0;
+}
+
+.modal-button-bar {
+    height: auto;
+    padding: 1 0 0 0;
+    align: right middle;
+}
+
+.modal-button-bar Button {
+    margin: 0 0 0 1;
+    min-width: 10;
+}
+
+.browse-row {
+    height: auto;
+}
+
+.browse-row Input {
+    width: 1fr;
+}
+
+.browse-row Button {
+    width: auto;
+    min-width: 10;
+}
+
+.conditional-field {
+    height: auto;
+}
+
+.hidden {
+    display: none;
+}
+
+.step-row {
+    height: auto;
+    padding: 0 1;
+    margin: 0 0 0 1;
+}
+
+.step-row:hover {
+    background: $accent 8%;
+}
+
+.step-row Static {
+    width: 1fr;
+}
+
+.step-row Button {
+    width: auto;
+    min-width: 4;
+}
+
+#modal-step-list {
+    height: auto;
+    max-height: 15;
+    margin: 0 0 1 0;
+}
+
+#modal-params-form {
+    height: auto;
+}
+
+.step-section-title {
+    text-style: bold;
+    padding: 1 0 0 0;
+}
+
+.nested-group {
+    margin: 0 0 1 1;
+    padding: 0 0 0 1;
+    border-left: tall $accent 40%;
+}
+"""
+
+
+# ---------------------------------------------------------------------------
+# ComponentModal — base class
+# ---------------------------------------------------------------------------
+
+
+class ComponentModal(ModalScreen[dict | str | None]):
+    """Base modal for creating/editing pipeline components."""
+
+    CSS = _MODAL_CSS
+    BINDINGS = [("escape", "cancel", "Cancel")]
+
+    def __init__(
+        self,
+        existing: dict[str, Any] | None = None,
+        data_dir: Path | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._existing = existing
+        self._data_dir = data_dir
+
+    @property
+    def is_edit_mode(self) -> bool:
+        return self._existing is not None
+
+    def _collect_raw(self) -> dict[str, Any] | None:
+        raise NotImplementedError
+
+    def _check_dirty(self) -> bool:
+        raise NotImplementedError
+
+    def _collect(self) -> dict[str, Any] | None:
+        raise NotImplementedError
+
+    def _update_ok_state(self) -> None:
+        try:
+            btn = self.query_one("#btn-modal-ok", Button)
+            btn.disabled = not self._check_dirty()
+        except NoMatches:
+            pass
+
+    def compose_buttons(self) -> ComposeResult:
+        with Horizontal(classes="modal-button-bar"):
+            yield Button("OK", id="btn-modal-ok", variant="primary", disabled=True)
+            yield Button("Cancel", id="btn-modal-cancel")
+            if self.is_edit_mode:
+                yield Button("Delete", id="btn-modal-delete", variant="error")
+
+    def _safe_dismiss(self, result: dict | str | None) -> None:
+        with contextlib.suppress(ScreenStackError):
+            self.dismiss(result)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn = event.button.id or ""
+        if btn == "btn-modal-ok":
+            result = self._collect()
+            if result is not None:
+                self._safe_dismiss(result)
+        elif btn == "btn-modal-cancel":
+            self._safe_dismiss(None)
+        elif btn == "btn-modal-delete":
+            self._safe_dismiss(DELETE_SENTINEL)
+
+    def on_input_changed(self, _event: Input.Changed) -> None:
+        self._update_ok_state()
+
+    def on_select_changed(self, _event: Select.Changed) -> None:
+        self._update_ok_state()
+
+    def on_checkbox_changed(self, _event: Checkbox.Changed) -> None:
+        self._update_ok_state()
+
+    def action_cancel(self) -> None:
+        with contextlib.suppress(ScreenStackError):
+            self.dismiss(None)
+
+    def _browse_for_input(self, input_id: str) -> None:
+        try:
+            current = self.query_one(f"#{input_id}", Input).value.strip() or "."
+        except NoMatches:
+            current = "."
+
+        data_dir = self._data_dir
+
+        def _on_result(result: str | None) -> None:
+            if result is None:
+                return
+            # Auto-relativize absolute paths against data_dir for portability
+            if Path(result).is_absolute() and data_dir is not None:
+                from dataeval_flow.config._paths import relativize_to_data_dir
+
+                try:
+                    result = relativize_to_data_dir(result, data_dir)
+                except ValueError:
+                    _log.warning("Browsed path '%s' is not under data root '%s'", result, data_dir)
+            with contextlib.suppress(NoMatches):
+                self.query_one(f"#{input_id}", Input).value = result
+
+        self.app.push_screen(PathPickerScreen(start_path=current, mode="folder"), callback=_on_result)

dataeval_flow/_app/_screens/_detail.py

@@ -0,0 +1,333 @@
+"""Result detail modal for the dashboard.
+
+Full-screen modal showing metadata, finding summaries, and expandable
+detail sections for a single task's ``WorkflowResult``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Vertical, VerticalScroll
+from textual.css.query import NoMatches
+from textual.screen import ModalScreen
+from textual.widgets import Button, DataTable, Static
+
+from dataeval_flow._app._viewmodel._result_vm import ResultViewModel
+
+__all__ = ["ErrorDetailModal", "ResultDetailModal"]
+
+_SEVERITY_MARKUP: dict[str, str] = {
+    "ok": "[green][ok][/green]",
+    "info": "[blue][..][/blue]",
+    "warning": "[bold red][!!][/bold red]",
+}
+
+# Plain-text markers emitted by _summary_line() → Rich-markup replacements
+_MARKER_COLORS: list[tuple[str, str]] = [
+    ("  [!!]", "  [bold red]\\[!!][/bold red]"),
+    ("  [ok]", "  [green]\\[ok][/green]"),
+    ("  [..]", "  [blue]\\[..][/blue]"),
+]
+
+
+def _colorize_marker(line: str) -> str:
+    """Replace the trailing plain-text severity marker with a colored Rich-markup version."""
+    for plain, colored in _MARKER_COLORS:
+        if line.endswith(plain):
+            return line[: -len(plain)] + colored
+    return line
+
+
+_CSS = """
+ResultDetailModal {
+    align: center middle;
+}
+
+#rd-dialog {
+    width: 90%;
+    height: 90%;
+    border: round $accent 40%;
+    background: $surface;
+    padding: 1 2;
+}
+
+#rd-scroll {
+    height: 1fr;
+}
+
+#rd-title {
+    text-style: bold;
+    margin: 0 0 1 0;
+}
+
+.rd-metadata {
+    margin: 0 0 1 0;
+    color: $text-muted;
+}
+
+.rd-summary-line {
+    height: auto;
+    padding: 0 1;
+}
+
+.rd-health {
+    margin: 1 0;
+    text-style: bold;
+}
+
+.rd-finding-header {
+    height: 3;
+    padding: 0 1;
+    margin: 1 0 0 0;
+    background: $boost;
+    content-align: left middle;
+}
+
+.rd-finding-header:focus {
+    background: $accent 20%;
+    color: $text;
+    border-left: tall $accent;
+}
+
+.rd-finding-detail {
+    padding: 0 1 0 2;
+    height: auto;
+    background: $surface;
+}
+
+.rd-separator {
+    height: 1;
+    margin: 1 0;
+    background: $accent 15%;
+}
+
+#rd-buttons {
+    height: auto;
+    align: right middle;
+    margin: 1 0 0 0;
+}
+"""
+
+
+class _FindingHeader(Static):
+    """Clickable finding header — toggles detail expansion."""
+
+    can_focus = True
+
+    def __init__(self, content: str, finding_idx: int, **kw: Any) -> None:
+        super().__init__(content, **kw)
+        self.finding_idx = finding_idx
+
+
+class ResultDetailModal(ModalScreen[None]):
+    """Full-screen modal showing detailed results for a single task."""
+
+    CSS = _CSS
+    BINDINGS = [("escape", "close", "Close")]
+
+    def __init__(self, task_name: str, result: Any, **kw: Any) -> None:
+        super().__init__(**kw)
+        self._task_name = task_name
+        self._result = result
+        self._rvm = ResultViewModel(result)
+        self._expanded_findings: set[int] = set()
+        self._gen: int = 0
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="rd-dialog"):
+            yield Static(f"[bold]Result: {self._task_name}[/bold]", id="rd-title", markup=True)
+            with VerticalScroll(id="rd-scroll"):
+                yield from self._compose_content()
+            with Vertical(id="rd-buttons"):
+                yield Button("Close", id="btn-rd-close", variant="primary")
+
+    def _compose_content(self) -> ComposeResult:
+        # Metadata
+        for line in self._rvm.metadata_lines():
+            yield Static(f"[dim]{line}[/dim]", classes="rd-metadata", markup=True)
+
+        yield Static("", classes="rd-separator")
+
+        # Summary
+        yield Static("[bold]SUMMARY[/bold]", markup=True)
+        summaries = self._rvm.finding_summaries()
+        for idx, _fs in enumerate(summaries):
+            line = self._rvm.finding_summary_markup(idx)
+            line = _colorize_marker(line)
+            yield Static(f"  {line}", classes="rd-summary-line", markup=True)
+
+        # Health
+        health = self._rvm.health_line()
+        if "warning" in health.lower():
+            yield Static(f"[bold red]  {health}[/bold red]", classes="rd-health", markup=True)
+        else:
+            yield Static(f"[green]  {health}[/green]", classes="rd-health", markup=True)
+
+        yield Static("", classes="rd-separator")
+
+        # Finding detail sections
+        gen = self._gen
+        for idx, fs in enumerate(summaries):
+            expanded = idx in self._expanded_findings
+            arrow = "\u25bc" if expanded else "\u25b6"
+            marker = _SEVERITY_MARKUP.get(fs.severity, _SEVERITY_MARKUP["info"])
+            header = _FindingHeader(
+                f"{arrow} DETAIL: {fs.title}  {marker}",
+                finding_idx=idx,
+                classes="rd-finding-header",
+                id=f"rd-fh-{gen}-{idx}",
+                markup=True,
+            )
+            yield header
+
+            if expanded:
+                # Try DataTable for tabular findings
+                table_data = self._rvm.finding_table_data(idx)
+                if table_data is not None:
+                    headers, rows = table_data
+                    dt = DataTable(id=f"rd-dt-{gen}-{idx}")
+                    yield dt
+                    # DataTable columns/rows added in _populate_tables
+                else:
+                    # Rich markup detail
+                    detail_text = self._rvm.finding_detail_markup(idx)
+                    if detail_text.strip():
+                        yield Static(detail_text, classes="rd-finding-detail", markup=False)
+
+    def on_mount(self) -> None:
+        """Populate DataTable widgets after initial compose."""
+        self._populate_tables()
+
+    def _populate_tables(self) -> None:
+        """Fill DataTable widgets with data for expanded findings."""
+        gen = self._gen
+        for idx in self._expanded_findings:
+            table_data = self._rvm.finding_table_data(idx)
+            if table_data is not None:
+                headers, rows = table_data
+                try:
+                    dt = self.query_one(f"#rd-dt-{gen}-{idx}", DataTable)
+                    for h in headers:
+                        dt.add_column(h)
+                    for row in rows:
+                        dt.add_row(*row)
+                except NoMatches:
+                    pass
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn-rd-close":
+            self.dismiss(None)
+
+    def on_click(self, event: Any) -> None:
+        widget = event.widget
+        while widget is not None:
+            if isinstance(widget, _FindingHeader):
+                self._toggle_finding(widget.finding_idx)
+                event.stop()
+                return
+            if isinstance(widget, VerticalScroll):
+                break
+            widget = widget.parent
+
+    async def _on_key(self, event: Any) -> None:
+        if event.key == "enter":
+            focused = self.app.focused
+            if isinstance(focused, _FindingHeader):
+                self._toggle_finding(focused.finding_idx)
+                event.stop()
+                event.prevent_default()
+                return
+        await super()._on_key(event)
+
+    def _toggle_finding(self, idx: int) -> None:
+        if idx in self._expanded_findings:
+            self._expanded_findings.discard(idx)
+        else:
+            self._expanded_findings.add(idx)
+        self._rebuild_content()
+
+    def _rebuild_content(self) -> None:
+        self._gen += 1
+        try:
+            scroll = self.query_one("#rd-scroll", VerticalScroll)
+        except NoMatches:
+            return
+        scroll.remove_children()
+        for widget in self._compose_content():
+            scroll.mount(widget)
+        self._populate_tables()
+
+    def action_close(self) -> None:
+        self.dismiss(None)
+
+
+# ---------------------------------------------------------------------------
+# Error detail modal (for failed tasks)
+# ---------------------------------------------------------------------------
+
+_ERROR_CSS = """
+ErrorDetailModal {
+    align: center middle;
+}
+
+#ed-dialog {
+    width: 80%;
+    height: auto;
+    max-height: 70%;
+    border: round $error 50%;
+    background: $surface;
+    padding: 1 2;
+}
+
+#ed-title {
+    text-style: bold;
+    color: $error;
+    margin: 0 0 1 0;
+}
+
+#ed-error {
+    height: auto;
+    max-height: 40;
+    padding: 1;
+    background: $boost;
+    margin: 1 0;
+}
+
+#ed-buttons {
+    height: auto;
+    align: right middle;
+    margin: 1 0 0 0;
+}
+"""
+
+
+class ErrorDetailModal(ModalScreen[None]):
+    """Modal showing error details for a failed task."""
+
+    CSS = _ERROR_CSS
+    BINDINGS = [("escape", "close", "Close")]
+
+    def __init__(self, task_name: str, error: str, **kw: Any) -> None:
+        super().__init__(**kw)
+        self._task_name = task_name
+        self._error = error
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="ed-dialog"):
+            yield Static(
+                f"[bold]FAILED: {self._task_name}[/bold]",
+                id="ed-title",
+                markup=True,
+            )
+            yield Static(self._error, id="ed-error")
+            with Vertical(id="ed-buttons"):
+                yield Button("Close", id="btn-ed-close", variant="primary")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn-ed-close":
+            self.dismiss(None)
+
+    def action_close(self) -> None:
+        self.dismiss(None)

dataeval_flow/_app/_screens/_model.py

@@ -0,0 +1,102 @@
+"""ModelModal — flattened model creation/editing."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.css.query import NoMatches
+from textual.widgets import Button, Input, Label, Select, Static
+
+from dataeval_flow._app._screens._base import ComponentModal, _select_value
+from dataeval_flow._app._viewmodel._model_vm import MODEL_TYPES, ModelViewModel
+
+
+class ModelModal(ComponentModal):
+    """Create or edit a model entry (flattened — no nested extractor).
+
+    Delegates business logic to :class:`ModelViewModel`.
+    """
+
+    def __init__(self, existing: dict[str, Any] | None = None, **kwargs: Any) -> None:
+        super().__init__(existing, **kwargs)
+        self._vm = ModelViewModel(existing)
+
+    def compose(self) -> ComposeResult:
+        title = "Edit Model" if self.is_edit_mode else "New Model"
+        with VerticalScroll(classes="modal-dialog"):
+            yield Static(f"[bold]{title}[/bold]")
+            yield Label("Name:")
+            yield Input(id="md-model-name", placeholder="e.g. resnet50")
+            yield Label("Type:")
+            yield Select(
+                [(t, t) for t in MODEL_TYPES],
+                id="md-model-type",
+                prompt="Select type",
+            )
+            with Vertical(id="md-model-path-group", classes="conditional-field hidden"):
+                yield Label("Model Path:")
+                with Horizontal(classes="browse-row"):
+                    yield Input(id="md-model-path", placeholder="e.g. ./models/resnet50.onnx")
+                    yield Button("Browse", id="btn-browse-md-model-path")
+            with Vertical(id="md-model-vocab-group", classes="conditional-field hidden"):
+                yield Label("Vocab Size:")
+                yield Input(id="md-model-vocab", placeholder="2048")
+            yield from self.compose_buttons()
+
+    def on_mount(self) -> None:
+        if self._existing:
+            try:
+                self.query_one("#md-model-name", Input).value = self._existing.get("name", "")
+                model_type = self._existing.get("type", "")
+                if model_type:
+                    self.query_one("#md-model-type", Select).value = model_type
+                if self._existing.get("model_path"):
+                    self.query_one("#md-model-path", Input).value = self._existing["model_path"]
+                if self._existing.get("vocab_size"):
+                    self.query_one("#md-model-vocab", Input).value = str(self._existing["vocab_size"])
+            except NoMatches:
+                pass
+        self._toggle_fields()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn-browse-md-model-path":
+            self._browse_for_input("md-model-path")
+            return
+        super().on_button_pressed(event)
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        if event.select.id == "md-model-type":
+            self._toggle_fields()
+        super().on_select_changed(event)
+
+    def _toggle_fields(self) -> None:
+        model_type = _select_value(self.query_one("#md-model-type", Select))
+        path_group = self.query_one("#md-model-path-group")
+        vocab_group = self.query_one("#md-model-vocab-group")
+        if ModelViewModel.needs_path(model_type):
+            path_group.remove_class("hidden")
+        else:
+            path_group.add_class("hidden")
+        if ModelViewModel.needs_vocab(model_type):
+            vocab_group.remove_class("hidden")
+        else:
+            vocab_group.add_class("hidden")
+
+    def _collect_raw(self) -> dict[str, Any] | None:
+        return self._vm.build_result(
+            name=self.query_one("#md-model-name", Input).value.strip(),
+            model_type=_select_value(self.query_one("#md-model-type", Select)),
+            model_path=self.query_one("#md-model-path", Input).value.strip(),
+            vocab_size_str=self.query_one("#md-model-vocab", Input).value.strip(),
+        )
+
+    def _check_dirty(self) -> bool:
+        return self._vm.check_dirty(self._collect_raw())
+
+    def _collect(self) -> dict[str, Any] | None:
+        result = self._collect_raw()
+        if result is None:
+            self.app.notify(ModelViewModel.validation_message(), severity="error")
+        return result