dataeval-flow 0.1.0__py3-none-any.whl

dataeval_flow/_app/_screens/_settings.py

@@ -0,0 +1,183 @@
+"""Settings modal for execution context (F10).
+
+These settings are *not* part of the pipeline JSON/YAML config.
+They control how tasks are executed (paths, resource limits, etc.)
+and are ephemeral to the dashboard session (or persisted separately).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, Static
+
+from dataeval_flow._app._screens._pathpicker import PathPickerScreen
+
+__all__ = ["ExecutionSettings", "SettingsModal"]
+
+_CSS = """
+SettingsModal {
+    align: center middle;
+}
+
+#settings-dialog {
+    width: 70;
+    height: auto;
+    max-height: 80%;
+    border: round $accent 40%;
+    background: $surface;
+    padding: 1 2;
+}
+
+#settings-title {
+    text-style: bold;
+    margin: 0 0 1 0;
+}
+
+.settings-label {
+    margin: 1 0 0 0;
+}
+
+.settings-row {
+    height: auto;
+    margin: 0;
+}
+
+.settings-row Input {
+    width: 1fr;
+}
+
+.settings-row Button {
+    width: auto;
+    min-width: 10;
+    margin: 0 0 0 1;
+}
+
+.settings-hint {
+    color: $text-muted;
+    margin: 0 0 0 1;
+}
+
+#settings-buttons {
+    height: auto;
+    align: right middle;
+    margin: 1 0 0 0;
+}
+"""
+
+
+@dataclass
+class ExecutionSettings:
+    """Execution context settings — not part of pipeline config."""
+
+    data_dir: str = ""
+    cache_dir: str = ""
+    output_dir: str = ""
+
+
+class SettingsModal(ModalScreen[ExecutionSettings | None]):
+    """Modal for editing execution settings (F10)."""
+
+    CSS = _CSS
+    BINDINGS = [("escape", "cancel", "Cancel")]
+
+    def __init__(self, current: ExecutionSettings, **kw: Any) -> None:
+        super().__init__(**kw)
+        self._current = current
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="settings-dialog"):
+            yield Static("[bold]Execution Settings[/bold]", id="settings-title", markup=True)
+            yield Static(
+                "[dim]These control how tasks run — not saved to pipeline config.[/dim]",
+                markup=True,
+            )
+
+            yield Label("Data directory", classes="settings-label")
+            with Horizontal(classes="settings-row"):
+                yield Input(
+                    value=self._current.data_dir,
+                    placeholder="$DATAEVAL_DATA or working directory",
+                    id="input-data-dir",
+                )
+                yield Button("Browse", id="btn-browse-data-dir")
+            yield Static("[dim]Root for resolving relative dataset paths[/dim]", classes="settings-hint", markup=True)
+
+            yield Label("Cache directory", classes="settings-label")
+            with Horizontal(classes="settings-row"):
+                yield Input(
+                    value=self._current.cache_dir,
+                    placeholder="(disabled — no caching)",
+                    id="input-cache-dir",
+                )
+                yield Button("Browse", id="btn-browse-cache-dir")
+            yield Static(
+                "[dim]Disk cache for embeddings, metadata, stats[/dim]",
+                classes="settings-hint",
+                markup=True,
+            )
+
+            yield Label("Output directory", classes="settings-label")
+            with Horizontal(classes="settings-row"):
+                yield Input(
+                    value=self._current.output_dir,
+                    placeholder="(console only — no file output)",
+                    id="input-output-dir",
+                )
+                yield Button("Browse", id="btn-browse-output-dir")
+            yield Static(
+                "[dim]Where to write result.json / result.txt on export[/dim]",
+                classes="settings-hint",
+                markup=True,
+            )
+
+            with Vertical(id="settings-buttons"):
+                yield Button("Save", id="btn-settings-save", variant="primary")
+                yield Button("Cancel", id="btn-settings-cancel")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn_id = event.button.id
+        if btn_id == "btn-settings-save":
+            self.dismiss(self._collect())
+        elif btn_id == "btn-settings-cancel":
+            self.dismiss(None)
+        elif btn_id == "btn-browse-data-dir":
+            self._browse_for("input-data-dir")
+        elif btn_id == "btn-browse-cache-dir":
+            self._browse_for("input-cache-dir")
+        elif btn_id == "btn-browse-output-dir":
+            self._browse_for("input-output-dir")
+
+    def _browse_for(self, input_id: str) -> None:
+        """Open a folder picker and write the result into the input field."""
+        current_value = self.query_one(f"#{input_id}", Input).value.strip()
+        start = current_value if current_value else "."
+
+        def _on_picked(result: str | None, _input_id: str = input_id) -> None:
+            if result is not None:
+                self.query_one(f"#{_input_id}", Input).value = result
+
+        self.app.push_screen(PathPickerScreen(start_path=start, mode="folder"), callback=_on_picked)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    def _collect(self) -> ExecutionSettings:
+        return ExecutionSettings(
+            data_dir=self.query_one("#input-data-dir", Input).value.strip(),
+            cache_dir=self.query_one("#input-cache-dir", Input).value.strip(),
+            output_dir=self.query_one("#input-output-dir", Input).value.strip(),
+        )
+
+    @staticmethod
+    def to_paths(settings: ExecutionSettings) -> tuple[Path | None, Path | None, Path | None]:
+        """Convert settings strings to Path | None triples (data, cache, output)."""
+        data = Path(settings.data_dir) if settings.data_dir else None
+        cache = Path(settings.cache_dir) if settings.cache_dir else None
+        output = Path(settings.output_dir) if settings.output_dir else None
+        return data, cache, output

dataeval_flow/_app/_viewmodel/__init__.py

@@ -0,0 +1,15 @@
+"""ViewModel layer for the configuration builder.
+
+ViewModels expose state and commands that Views bind to.
+They depend on the Model layer but never on UI frameworks.
+"""
+
+from dataeval_flow._app._viewmodel._builder_vm import BuilderViewModel
+from dataeval_flow._app._viewmodel._model_vm import ModelViewModel
+from dataeval_flow._app._viewmodel._section_vm import SectionViewModel
+
+__all__ = [
+    "BuilderViewModel",
+    "ModelViewModel",
+    "SectionViewModel",
+]

dataeval_flow/_app/_viewmodel/_builder_vm.py

@@ -0,0 +1,272 @@
+"""ViewModel for the main builder application.
+
+Orchestrates ConfigState, ExecutionState, UndoStack, and file I/O.
+No UI dependencies.  The View (FlowApp) calls methods here and
+translates return values into notifications and widget updates.
+"""
+
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from dataeval_flow._app._model._execution import ExecutionState, TaskExecution
+from dataeval_flow._app._model._item import DELETE_SENTINEL
+from dataeval_flow._app._model._registry import SECTIONS
+from dataeval_flow._app._model._state import ConfigState
+from dataeval_flow._app._model._undo import UndoStack
+from dataeval_flow._app._viewmodel._rendering import _item_to_yaml_snippet, _snippet_task
+from dataeval_flow._app._viewmodel._section_vm import SectionViewModel
+
+if TYPE_CHECKING:
+    from dataeval_flow.config._models import PipelineConfig
+    from dataeval_flow.workflow import WorkflowResult
+
+__all__ = ["BuilderViewModel"]
+
+
+class BuilderViewModel:
+    """ViewModel for the main builder application."""
+
+    def __init__(self, config_path: str | Path | None = None) -> None:
+        self._state = ConfigState()
+        self._execution = ExecutionState()
+        self.history = UndoStack()
+        self.config_file_path: str = str(config_path) if config_path else ""
+
+    # -- Queries -----------------------------------------------------------
+
+    @property
+    def sections(self) -> list[tuple[str, str]]:
+        """Return the ordered list of (key, title) section pairs."""
+        return SECTIONS
+
+    def section_data(self) -> list[tuple[str, str, list[dict[str, Any]]]]:
+        """Return ``(key, title, items)`` for every section."""
+        return [(key, title, self._state.items(key)) for key, title in SECTIONS]
+
+    def get_item(self, section: str, index: int) -> dict[str, Any] | None:
+        """Return item at *index* in *section*, or ``None``."""
+        return self._state.get(section, index)
+
+    def items(self, section: str) -> list[dict[str, Any]]:
+        """Return a shallow copy of items in *section*."""
+        return self._state.items(section)
+
+    def names(self, section: str) -> list[str]:
+        """Return the names of all items in *section*."""
+        return self._state.names(section)
+
+    def count(self, section: str) -> int:
+        """Return the number of items in *section*."""
+        return self._state.count(section)
+
+    def is_empty(self) -> bool:
+        """Return ``True`` if all sections are empty."""
+        return self._state.is_empty()
+
+    def to_dict(self) -> dict[str, Any]:
+        """Export state as a plain dict suitable for YAML serialization."""
+        return self._state.to_dict()
+
+    def validate_item(self, section: str, data: dict[str, Any]) -> list[str]:
+        """Validate a single item dict. Returns a list of error strings."""
+        return self._state.validate_item(section, data)
+
+    def validate_all(self) -> list[str]:
+        """Validate the full config. Returns errors."""
+        return self._state.validate_all()
+
+    # -- Rendering ---------------------------------------------------------
+
+    def item_snippet(self, category: str, item: dict[str, Any]) -> str:
+        """Render a config item as a Rich-markup snippet string."""
+        return _item_to_yaml_snippet(category, item)
+
+    def task_snippet(self, task: dict[str, Any]) -> str:
+        """Render a task item snippet (used for inline toggle updates)."""
+        return _snippet_task(task)
+
+    # -- Factory -----------------------------------------------------------
+
+    def create_section_vm(
+        self,
+        section: str,
+        existing: dict[str, Any] | None = None,
+    ) -> SectionViewModel:
+        """Create a SectionViewModel bound to this builder's state."""
+        return SectionViewModel(section, existing, self._state)
+
+    # -- Undo / Redo -------------------------------------------------------
+
+    def snapshot(self, description: str) -> None:
+        """Save a state snapshot for undo."""
+        self.history.push(self._state.snapshot(), description)
+
+    def undo(self) -> tuple[bool, str]:
+        """Undo the last action. Returns ``(success, message)``."""
+        entry = self.history.undo(self._state.snapshot())
+        if entry is None:
+            return False, "Nothing to undo."
+        self._state.restore(entry.state)
+        return True, f"Undone: {entry.description}"
+
+    def redo(self) -> tuple[bool, str]:
+        """Redo the last undone action. Returns ``(success, message)``."""
+        entry = self.history.redo(self._state.snapshot())
+        if entry is None:
+            return False, "Nothing to redo."
+        self._state.restore(entry.state)
+        return True, f"Redone: {entry.description}"
+
+    # -- Item mutations ----------------------------------------------------
+
+    def toggle_task(self, index: int) -> str | None:
+        """Toggle a task's enabled state. Returns description or None."""
+        task = self._state.get("tasks", index)
+        if task is None:
+            return None
+        toggling_to = "off" if task.get("enabled", True) else "on"
+        desc = f"Toggle task '{task.get('name', '?')}' {toggling_to}"
+        self.snapshot(desc)
+        task["enabled"] = not task.get("enabled", True)
+        return desc
+
+    def delete_item(self, category: str, index: int) -> tuple[str, list[str]] | None:
+        """Delete an item. Snapshots before mutation.
+
+        Returns ``(description, warnings)`` or None.
+        """
+        existing = self._state.get(category, index)
+        if existing is None:
+            return None
+        desc = f"Delete {category[:-1]} '{existing.get('name', '?')}'"
+        self.snapshot(desc)
+        return self._state.apply_modal_result(category, index, DELETE_SENTINEL)
+
+    def apply_result(self, category: str, index: int, result: dict | str | None) -> tuple[str, list[str]] | None:
+        """Apply a modal result (add/update/delete). Snapshots before mutation.
+
+        Returns ``(description, warnings)`` or None.
+        """
+        if result is None:
+            return None
+
+        if result == DELETE_SENTINEL:
+            return self.delete_item(category, index)
+
+        # Derive description before mutating
+        name = result.get("name", "?") if isinstance(result, dict) else "?"
+        action = "Update" if index >= 0 else "Add"
+        self.snapshot(f"{action} {category[:-1]} '{name}'")
+        return self._state.apply_modal_result(category, index, result)
+
+    # -- File I/O ----------------------------------------------------------
+
+    def new_config(self) -> str:
+        """Reset to empty config. Returns status message."""
+        if not self._state.is_empty():
+            self.snapshot("New config (clear)")
+        self._state = ConfigState()
+        self.config_file_path = ""
+        return "New config."
+
+    def load_file(self, path: Path) -> tuple[bool, str]:
+        """Load config from *path*. Returns ``(success, message)``."""
+        if not path.exists():
+            return False, f"File not found: {path}"
+        self.snapshot("Load config file")
+        try:
+            warning = self._state.load_file(path)
+        except (ValueError, TypeError, OSError) as e:
+            return False, f"Failed to load config: {e}"
+        self.config_file_path = str(path)
+        msg = f"Loaded config from {path}"
+        if warning:
+            msg += f" ({warning})"
+        return True, msg
+
+    def save_file(self, path: Path, *, disable_tasks: bool = False) -> tuple[bool, str]:
+        """Save config to *path*. Returns ``(success, message)``.
+
+        When *disable_tasks* is ``True``, all tasks are written with
+        ``enabled: false`` (for programmatic use).
+        """
+        if self._state.is_empty():
+            return False, "Nothing to save."
+        if disable_tasks:
+            # Temporarily disable all tasks for export
+            tasks = self._state.items("tasks")
+            original_states = [(i, t.get("enabled", True)) for i, t in enumerate(tasks)]
+            for task in tasks:
+                task["enabled"] = False
+            try:
+                self._state.save_file(path)
+            finally:
+                # Restore original enabled states
+                for idx, enabled in original_states:
+                    t = self._state.get("tasks", idx)
+                    if t is not None:
+                        t["enabled"] = enabled
+        else:
+            self._state.save_file(path)
+        self.config_file_path = str(path)
+        return True, f"Saved to {path.resolve()}"
+
+    # -- Config building ---------------------------------------------------
+
+    def build_pipeline_config(self) -> PipelineConfig:
+        """Validate and return a ``PipelineConfig`` from current state.
+
+        Raises ``ValueError`` if the config is invalid.
+        """
+        return self._state.to_pipeline_config()
+
+    # -- Execution ---------------------------------------------------------
+
+    def task_execution(self, name: str) -> TaskExecution | None:
+        """Return execution state for task *name*, or ``None``."""
+        return self._execution.get(name)
+
+    def mark_task_running(self, name: str) -> TaskExecution:
+        """Mark a task as running."""
+        return self._execution.mark_running(name)
+
+    def mark_task_completed(self, name: str, result: WorkflowResult[Any, Any]) -> TaskExecution:
+        """Mark a task as completed with its result."""
+        return self._execution.mark_completed(name, result)
+
+    def mark_task_failed(self, name: str, error: str) -> TaskExecution:
+        """Mark a task as failed."""
+        return self._execution.mark_failed(name, error)
+
+    def clear_task_execution(self, name: str | None = None) -> None:
+        """Clear execution state.  ``None`` clears all."""
+        self._execution.clear(name)
+
+    def all_executions(self) -> list[TaskExecution]:
+        """Return all execution entries."""
+        return self._execution.entries()
+
+    def completed_results(self) -> list[tuple[str, WorkflowResult[Any, Any]]]:
+        """Return ``(name, result)`` for all completed tasks."""
+        return self._execution.completed_results()
+
+    def export_results(self, output_dir: Path) -> tuple[bool, str]:
+        """Write result.json and result.txt for all completed tasks."""
+        results = self._execution.completed_results()
+        if not results:
+            return False, "No completed results to export."
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        merged: dict[str, dict] = {}
+        text_parts: list[str] = []
+        for name, result in results:
+            merged[name] = result.to_dict()
+            text_parts.append(result.report(detailed=True))
+
+        (output_dir / "result.json").write_text(json_mod.dumps(merged, indent=2), encoding="utf-8")
+        (output_dir / "result.txt").write_text("\n".join(text_parts), encoding="utf-8")
+        return True, f"Exported {len(results)} result(s) to {output_dir}"

dataeval_flow/_app/_viewmodel/_model_vm.py

@@ -0,0 +1,70 @@
+"""ViewModel for the ModelModal.
+
+Pure logic for model creation/editing.  No UI dependencies.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = ["ModelViewModel"]
+
+MODEL_TYPES = ["onnx", "bovw", "flatten", "torch", "uncertainty"]
+_PATH_TYPES = frozenset({"onnx", "torch", "uncertainty"})
+
+
+class ModelViewModel:
+    """ViewModel for creating/editing model entries."""
+
+    def __init__(self, existing: dict[str, Any] | None = None) -> None:
+        self.existing = existing
+        self.original: dict[str, Any] | None = dict(existing) if existing else None
+
+    @property
+    def is_edit_mode(self) -> bool:
+        return self.existing is not None
+
+    @staticmethod
+    def needs_path(model_type: str) -> bool:
+        """Return True if this model type requires a model_path."""
+        return model_type in _PATH_TYPES
+
+    @staticmethod
+    def needs_vocab(model_type: str) -> bool:
+        """Return True if this model type requires a vocab_size."""
+        return model_type == "bovw"
+
+    def build_result(
+        self,
+        name: str,
+        model_type: str,
+        model_path: str,
+        vocab_size_str: str,
+    ) -> dict[str, Any] | None:
+        """Assemble the result dict. Returns None if invalid."""
+        if not name or not model_type:
+            return None
+        result: dict[str, Any] = {"name": name, "type": model_type}
+        if self.needs_path(model_type):
+            if not model_path:
+                return None
+            result["model_path"] = model_path
+        if self.needs_vocab(model_type) and vocab_size_str:
+            try:
+                result["vocab_size"] = int(vocab_size_str)
+            except ValueError:
+                return None
+        return result
+
+    def check_dirty(self, collected: dict[str, Any] | None) -> bool:
+        """Return True if collected data differs from original."""
+        if not collected:
+            return False
+        if not self.original:
+            return True
+        return collected != self.original
+
+    @staticmethod
+    def validation_message() -> str:
+        """Return the error message for invalid input."""
+        return "Name and type are required. Path required for onnx/torch/uncertainty."