dataeval-flow 0.1.0__py3-none-any.whl

dataeval_flow/_app/_viewmodel/_rendering.py

@@ -0,0 +1,189 @@
+"""Item snippet rendering for the configuration builder.
+
+Presentation-layer functions that produce Rich-markup snippets for display
+in the TUI cards.  These live in the ViewModel layer because they transform
+Model data into view-ready strings.  No Textual widget dependency.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import yaml
+
+if TYPE_CHECKING:
+    from dataeval_flow._app._model._execution import TaskExecution
+
+# ---------------------------------------------------------------------------
+# Individual snippet renderers
+# ---------------------------------------------------------------------------
+
+
+def _snippet_steps(item: dict[str, Any], key: str) -> str:
+    lines = [f"[bold]{item.get('name', '?')}[/bold]"]
+    for s in item.get("steps", []):
+        label = s.get(key, "?")
+        params = s.get("params", {})
+        if params:
+            p_str = ", ".join(f"{k}={v}" for k, v in params.items())
+            lines.append(f"  {label}({p_str})")
+        else:
+            lines.append(f"  {label}")
+    return "\n".join(lines)
+
+
+def _snippet_dataset(item: dict[str, Any]) -> str:
+    name = item.get("name", "?")
+    fmt = item.get("format", "?")
+    path = item.get("path", "?")
+    split = item.get("split", "")
+    lines = [f"[bold]{name}[/bold]", f"  format: {fmt}  path: {path}"]
+    if split:
+        lines.append(f"  split: {split}")
+    return "\n".join(lines)
+
+
+def _snippet_source(item: dict[str, Any]) -> str:
+    name = item.get("name", "?")
+    dataset = item.get("dataset", "?")
+    selection = item.get("selection", "")
+    lines = [f"[bold]{name}[/bold]", f"  dataset: {dataset}"]
+    if selection:
+        lines.append(f"  selection: {selection}")
+    return "\n".join(lines)
+
+
+def _snippet_extractor(item: dict[str, Any]) -> str:
+    name = item.get("name", "?")
+    model_type = item.get("model", "?")
+    lines = [f"[bold]{name}[/bold]  [dim]{model_type}[/dim]"]
+    if item.get("model_path"):
+        lines.append(f"  path: {item['model_path']}")
+    if model_type == "bovw" and item.get("vocab_size"):
+        lines.append(f"  vocab_size: {item['vocab_size']}")
+    pre = item.get("preprocessor", "")
+    if pre:
+        lines.append(f"  preprocessor: {pre}")
+    batch = item.get("batch_size", "")
+    if batch:
+        lines.append(f"  batch_size: {batch}")
+    return "\n".join(lines)
+
+
+def _snippet_workflow(item: dict[str, Any]) -> str:
+    name = item.get("name", "?")
+    wf_type = item.get("type", "?")
+    lines = [f"[bold]{name}[/bold]  [dim]{wf_type}[/dim]"]
+    extras = [f"  {k}: {v}" for k, v in item.items() if k not in ("name", "type") and v]
+    lines.extend(extras)
+    return "\n".join(lines)
+
+
+def _snippet_task(item: dict[str, Any]) -> str:
+    enabled = item.get("enabled", True)
+    check = "[bold green]\u2713[/bold green]" if enabled else "[dim]\u2717[/dim]"
+    name = item.get("name", "?")
+    wf = item.get("workflow", "?")
+    srcs = item.get("sources", "")
+    if isinstance(srcs, list):
+        srcs = ", ".join(srcs)
+    lines = [f"{check} [bold]{name}[/bold]"]
+    lines.append(f"    workflow: {wf}  sources: {srcs}")
+    extractor = item.get("extractor", "")
+    if extractor:
+        lines.append(f"    extractor: {extractor}")
+    text = "\n".join(lines)
+    if not enabled:
+        text = f"{check} [dim strikethrough][bold]{name}[/bold]\n    workflow: {wf}  sources: {srcs}"
+        if extractor:
+            text += f"\n    extractor: {extractor}"
+        text += "[/dim strikethrough]"
+    return text
+
+
+# ---------------------------------------------------------------------------
+# Dispatch table and entry point
+# ---------------------------------------------------------------------------
+
+_SNIPPET_RENDERERS: dict[str, Any] = {
+    "datasets": _snippet_dataset,
+    "preprocessors": lambda item: _snippet_steps(item, "step"),
+    "selections": lambda item: _snippet_steps(item, "type"),
+    "sources": _snippet_source,
+    "extractors": _snippet_extractor,
+    "workflows": _snippet_workflow,
+    "tasks": _snippet_task,
+}
+
+
+def _item_to_yaml_snippet(category: str, item: dict[str, Any]) -> str:
+    renderer = _SNIPPET_RENDERERS.get(category)
+    if renderer:
+        return renderer(item)
+    return yaml.dump(item, default_flow_style=True).strip()
+
+
+# ---------------------------------------------------------------------------
+# Execution-aware task snippet (for dashboard task pane)
+# ---------------------------------------------------------------------------
+
+_STATUS_INDICATORS: dict[str, str] = {
+    "idle": "[dim]\u25cf[/dim]",
+    "running": "[bold yellow]\u25d0[/bold yellow] [yellow]running...[/yellow]",
+    "completed": "[bold green]\u2713[/bold green]",
+    "failed": "[bold red]\u2717[/bold red] [red]failed[/red]",
+}
+
+
+def snippet_task_with_execution(task: dict[str, Any], execution: TaskExecution | None = None) -> str:
+    """Render a task card snippet with execution status indicator.
+
+    Used in the dashboard task pane where status is shown inline.
+    """
+    enabled = task.get("enabled", True)
+    check = "[bold green]\u2713[/bold green]" if enabled else "[dim]\u2717[/dim]"
+    name = task.get("name", "?")
+    wf = task.get("workflow", "?")
+    srcs = task.get("sources", "")
+    if isinstance(srcs, list):
+        srcs = ", ".join(srcs)
+
+    # Status indicator
+    if execution is not None:
+        status = _STATUS_INDICATORS.get(execution.status, _STATUS_INDICATORS["idle"])
+        if execution.status == "completed" and execution.elapsed_s is not None:
+            status += f" [dim]{execution.elapsed_s:.1f}s[/dim]"
+    else:
+        status = _STATUS_INDICATORS["idle"]
+
+    # Build the snippet
+    line1 = f"{check} [bold]{name}[/bold]  {status}"
+    line2 = f"    {wf} > {srcs}"
+    extractor = task.get("extractor", "")
+    if extractor:
+        line2 += f"  [dim]({extractor})[/dim]"
+
+    if not enabled:
+        return f"{check} [dim strikethrough]{name}  {wf} > {srcs}[/dim strikethrough]  {status}"
+    return f"{line1}\n{line2}"
+
+
+def snippet_config_item(category: str, item: dict[str, Any]) -> str:
+    """Compact one-line snippet for config sidebar items."""
+    name = item.get("name", "?")
+    if category == "datasets":
+        fmt = item.get("format", "")
+        return f"[bold]{name}[/bold] [dim]{fmt}[/dim]"
+    if category == "extractors":
+        model = item.get("model", "")
+        return f"[bold]{name}[/bold] [dim]{model}[/dim]"
+    if category == "workflows":
+        wf_type = item.get("type", "")
+        return f"[bold]{name}[/bold] [dim]{wf_type}[/dim]"
+    if category == "sources":
+        dataset = item.get("dataset", "")
+        return f"[bold]{name}[/bold] [dim]({dataset})[/dim]"
+    if category in ("preprocessors", "selections"):
+        n_steps = len(item.get("steps", []))
+        return f"[bold]{name}[/bold] [dim]{n_steps} step{'s' if n_steps != 1 else ''}[/dim]"
+    return f"[bold]{name}[/bold]"

dataeval_flow/_app/_viewmodel/_result_vm.py

@@ -0,0 +1,210 @@
+"""ViewModel for rendering workflow results in the TUI.
+
+Transforms ``WorkflowResult`` data into view-ready structures.
+No Textual dependency — consumed by the result modal and result cards.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from dataeval_flow.workflow._text_report import (
+    _brief_value,
+    _render_detail_section,
+    _summary_line,
+)
+
+__all__ = ["FindingSummary", "ResultViewModel"]
+
+
+@dataclass
+class FindingSummary:
+    """View-ready summary of a single report finding."""
+
+    title: str
+    severity: str  # "ok" | "info" | "warning"
+    brief: str
+    report_type: str
+    has_table: bool
+
+
+class ResultViewModel:
+    """Transforms a ``WorkflowResult`` into view-ready structures."""
+
+    def __init__(self, result: Any) -> None:
+        self._result = result
+        self._findings = self._extract_findings()
+
+    def _extract_findings(self) -> list[Any]:
+        report_obj = getattr(self._result.data, "report", None)
+        if report_obj is None:
+            return []
+        return list(getattr(report_obj, "findings", []))
+
+    # -- Summary -----------------------------------------------------------
+
+    def summary_line(self) -> str:
+        """One-line summary: finding count, warning count, duration."""
+        findings = self._findings
+        n = len(findings)
+        warnings = sum(1 for f in findings if getattr(f, "severity", "info") == "warning")
+        parts: list[str] = []
+        parts.append(f"{n} finding{'s' if n != 1 else ''}")
+        if warnings:
+            parts.append(f"{warnings} warning{'s' if warnings != 1 else ''}")
+        meta = self._result.metadata
+        if meta.execution_time_s is not None:
+            parts.append(f"{meta.execution_time_s:.1f}s")
+        return ", ".join(parts)
+
+    def report_summary(self) -> str:
+        """The workflow's own summary string (e.g. 'Data Cleaning Report')."""
+        report_obj = getattr(self._result.data, "report", None)
+        if report_obj is None:
+            return ""
+        return getattr(report_obj, "summary", "")
+
+    # -- Metadata ----------------------------------------------------------
+
+    def metadata_lines(self) -> list[str]:
+        """Human-readable metadata lines (timestamp, duration, source, model)."""
+        meta = self._result.metadata
+        lines: list[str] = []
+        if meta.timestamp:
+            lines.append(f"Timestamp:    {meta.timestamp.isoformat()}")
+        if meta.execution_time_s is not None:
+            lines.append(f"Duration:     {meta.execution_time_s:.2f}s")
+        lines.extend(f"Source:       {desc}" for desc in getattr(meta, "source_descriptions", []))
+        if meta.model_id:
+            lines.append(f"Model:        {meta.model_id}")
+        if meta.preprocessor_id:
+            lines.append(f"Preprocessor: {meta.preprocessor_id}")
+        return lines
+
+    # -- Findings ----------------------------------------------------------
+
+    def finding_count(self) -> int:
+        """Number of findings."""
+        return len(self._findings)
+
+    def warning_count(self) -> int:
+        """Number of findings with severity 'warning'."""
+        return sum(1 for f in self._findings if getattr(f, "severity", "info") == "warning")
+
+    def finding_summaries(self) -> list[FindingSummary]:
+        """Return view-ready summaries for all findings."""
+        summaries: list[FindingSummary] = []
+        for finding in self._findings:
+            rt = finding.report_type
+            summaries.append(
+                FindingSummary(
+                    title=finding.title,
+                    severity=getattr(finding, "severity", "info"),
+                    brief=_brief_value(finding),
+                    report_type=rt,
+                    has_table=rt in ("table", "pivot_table", "classwise_table", "chunk_table"),
+                )
+            )
+        return summaries
+
+    def finding_summary_markup(self, idx: int) -> str:
+        """Rich-markup one-liner for finding at *idx* (dotted summary style)."""
+        if 0 <= idx < len(self._findings):
+            return _summary_line(self._findings[idx])
+        return ""
+
+    def finding_detail_markup(self, idx: int) -> str:
+        """Rich-markup detail block for finding at *idx*."""
+        if 0 <= idx < len(self._findings):
+            lines = _render_detail_section(self._findings[idx])
+            return "\n".join(lines)
+        return ""
+
+    def finding_table_data(self, idx: int) -> tuple[list[str], list[list[str]]] | None:
+        """Extract structured table data for ``DataTable`` rendering.
+
+        Returns ``(headers, rows)`` where each row is a list of strings,
+        or ``None`` if the finding doesn't have tabular data.
+        """
+        if not (0 <= idx < len(self._findings)):
+            return None
+
+        finding = self._findings[idx]
+        data = finding.data
+        if not isinstance(data, dict):
+            return None
+
+        rt = finding.report_type
+
+        if rt == "table":
+            return self._extract_simple_table(data)
+        if rt == "pivot_table":
+            return self._extract_pivot_table(data)
+        if rt in ("classwise_table", "chunk_table"):
+            return self._extract_row_table(data)
+        return None
+
+    # -- Health summary ----------------------------------------------------
+
+    def health_line(self) -> str:
+        """Health status string for the summary section."""
+        warnings = self.warning_count()
+        if warnings:
+            return f"Health: {warnings} warning(s) — review flagged findings"
+        return "Health: All checks passed"
+
+    # -- Table extraction helpers ------------------------------------------
+
+    @staticmethod
+    def _extract_simple_table(data: dict[str, Any]) -> tuple[list[str], list[list[str]]] | None:
+        """Extract from ``table`` report type (dict of name→count)."""
+        table_data: dict[str, int] = data.get("table_data", {})
+        if not table_data:
+            return None
+        headers_raw = data.get("table_headers", ("Name", "Value"))
+        headers: list[str] = [str(h) for h in headers_raw]
+        rows = [[str(k), str(v)] for k, v in sorted(table_data.items(), key=lambda x: -x[1])]
+        return headers, rows
+
+    @staticmethod
+    def _extract_pivot_table(data: dict[str, Any]) -> tuple[list[str], list[list[str]]] | None:
+        """Extract from ``pivot_table`` report type."""
+        rows_data: list[dict[str, Any]] = data.get("table_data", [])
+        headers: list[str] = data.get("table_headers", [])
+        if not rows_data or not headers:
+            return None
+
+        key_aliases: dict[str, str] = {"%": "pct", "Class Name": "class_name", "Count": "count"}
+        keys = [key_aliases.get(h, h) for h in headers]
+
+        rows: list[list[str]] = []
+        for row in rows_data:
+            cells: list[str] = []
+            for key in keys:
+                val = row.get(key, "")
+                if key == "pct" and isinstance(val, (int, float)):
+                    cells.append(f"{val:.1f}%")
+                else:
+                    cells.append(str(val) if val is not None else "")
+            rows.append(cells)
+        return headers, rows
+
+    @staticmethod
+    def _extract_row_table(data: dict[str, Any]) -> tuple[list[str], list[list[str]]] | None:
+        """Extract from ``classwise_table`` or ``chunk_table`` (list of row dicts)."""
+        rows_data: list[dict[str, Any]] = data.get("table_rows", [])
+        if not rows_data:
+            return None
+        headers = list(rows_data[0].keys())
+        rows: list[list[str]] = []
+        for row in rows_data:
+            cells: list[str] = []
+            for h in headers:
+                val = row.get(h, "")
+                if isinstance(val, float):
+                    cells.append(f"{val:.4f}")
+                else:
+                    cells.append(str(val) if val is not None else "")
+            rows.append(cells)
+        return headers, rows

dataeval_flow/_app/_viewmodel/_section_vm.py

@@ -0,0 +1,224 @@
+"""ViewModel for the SectionModal.
+
+Manages field descriptors, step-builder state, union-list state,
+and item collection/validation.  No UI dependencies.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from dataeval_flow._app._model._introspect import FieldDescriptor, FieldKind, introspect_model
+from dataeval_flow._app._model._item import (
+    SKIP,
+    build_item_dict,
+    collect_bool_value,
+    collect_field_value,
+    collect_json_value,
+    collect_multi_select_value,
+    diagnose_collect_failure,
+)
+from dataeval_flow._app._model._registry import (
+    STEP_BUILDER_SECTIONS,
+    get_discriminator_field,
+    get_fields,
+    get_variant_choices,
+)
+from dataeval_flow._app._model._state import ConfigState
+
+__all__ = ["SectionViewModel"]
+
+
+class SectionViewModel:
+    """ViewModel for creating/editing items in any config section."""
+
+    def __init__(
+        self,
+        section: str,
+        existing: dict[str, Any] | None = None,
+        state: ConfigState | None = None,
+    ) -> None:
+        self.section = section
+        self.state = state or ConfigState()
+        self.existing = existing
+        self.original: dict[str, Any] | None = dict(existing) if existing else None
+        self.descriptors: list[FieldDescriptor] = []
+        self.steps: list[dict[str, Any]] = []
+        self.list_items: dict[str, list[dict[str, Any]]] = {}
+        self._step_choices: list[str] = []
+        self._get_step_params: Any = None
+
+        if existing and section in STEP_BUILDER_SECTIONS:
+            self.steps = [dict(s) for s in existing.get("steps", [])]
+
+    # -- Properties --------------------------------------------------------
+
+    @property
+    def is_edit_mode(self) -> bool:
+        return self.existing is not None
+
+    @property
+    def is_step_builder(self) -> bool:
+        return self.section in STEP_BUILDER_SECTIONS
+
+    @property
+    def variant_choices(self) -> list[str] | None:
+        return get_variant_choices(self.section)
+
+    @property
+    def disc_field(self) -> str | None:
+        return get_discriminator_field(self.section)
+
+    @property
+    def step_choices(self) -> list[str]:
+        return self._step_choices
+
+    # -- Field descriptors -------------------------------------------------
+
+    def load_fields(self, variant_value: str | None) -> list[FieldDescriptor]:
+        """Load field descriptors for the given variant. Stores them internally."""
+        self.descriptors = get_fields(self.section, variant_value, self.state)
+        return self.descriptors
+
+    # -- Step builder ------------------------------------------------------
+
+    def init_step_builder(self) -> list[str]:
+        """Initialize step builder and return available step choices."""
+        spec = STEP_BUILDER_SECTIONS[self.section]
+        from dataeval_flow._app._model import _discover
+
+        self._step_choices = getattr(_discover, spec["list_fn"])()
+        self._get_step_params = getattr(_discover, spec["params_fn"])
+        return self._step_choices
+
+    def get_step_params(self, step_name: str) -> list[Any]:
+        """Return parameter info for a step type."""
+        if self._get_step_params:
+            return self._get_step_params(step_name)
+        return []
+
+    def add_step(self, step_name: str, params: dict[str, Any]) -> str:
+        """Add a step with collected params. Returns notification message."""
+        spec = STEP_BUILDER_SECTIONS[self.section]
+        step: dict[str, Any] = {spec["step_key"]: step_name}
+        if params:
+            step["params"] = params
+        self.steps.append(step)
+        return f"Added step '{step_name}'."
+
+    def remove_step(self, index: int) -> bool:
+        """Remove step at index. Returns True if removed."""
+        if 0 <= index < len(self.steps):
+            self.steps.pop(index)
+            return True
+        return False
+
+    def step_display_lines(self) -> list[str]:
+        """Return formatted display strings for each step."""
+        spec = STEP_BUILDER_SECTIONS.get(self.section, {})
+        step_key = spec.get("step_key", "step")
+        lines: list[str] = []
+        for idx, step in enumerate(self.steps):
+            name = step.get(step_key, "?")
+            params = step.get("params", {})
+            if params:
+                p_str = ", ".join(f"{k}={v}" for k, v in params.items())
+                lines.append(f"{idx + 1}. {name}({p_str})")
+            else:
+                lines.append(f"{idx + 1}. {name}")
+        return lines
+
+    # -- Union list builder ------------------------------------------------
+
+    def add_list_item(self, field_name: str, variant_key: str, field_values: dict[str, Any]) -> str:
+        """Add a union-list item. Returns notification message."""
+        desc = next((d for d in self.descriptors if d.name == field_name), None)
+        if not desc or not desc.discriminator:
+            return ""
+        item: dict[str, Any] = {desc.discriminator: variant_key}
+        item.update(field_values)
+        self.list_items.setdefault(field_name, []).append(item)
+        return f"Added {variant_key}."
+
+    def remove_list_item(self, field_name: str, index: int) -> bool:
+        """Remove a union-list item. Returns True if removed."""
+        items = self.list_items.get(field_name, [])
+        if 0 <= index < len(items):
+            items.pop(index)
+            return True
+        return False
+
+    def get_variant_descriptors(self, field_name: str, variant_key: str) -> list[FieldDescriptor]:
+        """Return field descriptors for a union variant, excluding the discriminator and complex fields."""
+        desc = next((d for d in self.descriptors if d.name == field_name), None)
+        if not desc or not desc.union_variants or not desc.discriminator:
+            return []
+        variant_model = desc.union_variants.get(variant_key)
+        if not variant_model:
+            return []
+        return [
+            vd
+            for vd in introspect_model(variant_model)
+            if vd.name != desc.discriminator and vd.kind.value not in ("nested", "list")
+        ]
+
+    # -- Collection (pure logic, takes raw values from view) ---------------
+
+    def collect_field(self, desc: FieldDescriptor, raw_value: Any) -> Any:
+        """Coerce a raw widget value for a single field. Returns SKIP if empty."""
+        if desc.kind == FieldKind.SELECT or (desc.kind == FieldKind.NESTED and desc.union_variants):
+            return raw_value if raw_value else SKIP
+        if desc.kind == FieldKind.MULTI_SELECT:
+            return collect_multi_select_value(raw_value or [], self.section, desc.name)
+        if desc.kind == FieldKind.BOOL:
+            return collect_bool_value(raw_value, desc.default)
+        if desc.kind in (FieldKind.INT, FieldKind.FLOAT, FieldKind.STRING):
+            return collect_field_value(desc, raw_value or "")
+        if desc.kind == FieldKind.LIST and desc.union_variants:
+            items = self.list_items.get(desc.name, [])
+            return list(items) if items else SKIP
+        if desc.kind == FieldKind.NESTED and desc.item_descriptors and isinstance(raw_value, dict):
+            coerced: dict[str, Any] = {}
+            for sub_desc in desc.item_descriptors:
+                sub_raw = raw_value.get(sub_desc.name)
+                sub_val = self.collect_field(sub_desc, sub_raw)
+                if sub_val is not SKIP:
+                    coerced[sub_desc.name] = sub_val
+            return coerced if coerced else SKIP
+        if desc.kind in (FieldKind.LIST, FieldKind.NESTED):
+            return collect_json_value(raw_value or "")
+        return SKIP
+
+    def build_result(
+        self,
+        name: str,
+        variant_value: str | None,
+        field_values: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        """Assemble the final item dict from collected values. Returns None if invalid."""
+        if not name:
+            return None
+        if self.disc_field and not variant_value:
+            return None
+        if self.is_step_builder:
+            if not self.steps:
+                return None
+            return build_item_dict(self.section, name, variant_value, {"steps": list(self.steps)})
+
+        # Preserve existing enabled state for tasks
+        if self.section == "tasks" and self.existing:
+            field_values.setdefault("enabled", self.existing.get("enabled", True))
+
+        return build_item_dict(self.section, name, variant_value, field_values)
+
+    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
+
+    def diagnose_failure(self, name: str, result: dict[str, Any] | None = None) -> str:
+        """Return a human-readable error message when build_result returns None."""
+        return diagnose_collect_failure(self.section, name, self.steps, self.descriptors, result)