py-data-engine 0.1.0__py3-none-any.whl

data_engine/ui/tui/state_support.py

@@ -0,0 +1,141 @@
+"""State helpers for the terminal UI surface."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from data_engine.domain import (
+    FlowCatalogState,
+    OperationSessionState,
+    OperatorSessionState,
+    RuntimeSessionState,
+    WorkspaceControlState,
+    WorkspaceSessionState,
+)
+from data_engine.views.models import QtFlowCard, flow_catalog_entry_from_qt_card, qt_flow_cards_from_entries
+
+if TYPE_CHECKING:
+    from data_engine.ui.tui.app import DataEngineTui
+
+
+class TuiStateMixin:
+    """Session-state helpers separated from the main TUI shell."""
+
+    @property
+    def runtime_ledger(self: "DataEngineTui"):
+        """Compatibility facade over the current runtime binding ledger."""
+        return self.runtime_binding.runtime_ledger
+
+    @property
+    def log_store(self: "DataEngineTui"):
+        """Compatibility facade over the current runtime binding log store."""
+        return self.runtime_binding.log_store
+
+    @property
+    def _daemon_manager(self: "DataEngineTui"):
+        """Compatibility facade over the current runtime binding daemon manager."""
+        return self.runtime_binding.daemon_manager
+
+    @property
+    def runtime_session(self: "DataEngineTui") -> RuntimeSessionState:
+        """Return the current terminal runtime/control session state."""
+        return self._operator_session_state.runtime
+
+    @runtime_session.setter
+    def runtime_session(self: "DataEngineTui", value: RuntimeSessionState) -> None:
+        self._operator_session_state = self._operator_session_state.with_runtime(value)
+
+    @property
+    def flow_catalog_state(self: "DataEngineTui") -> FlowCatalogState:
+        """Return the current discovered flow catalog state."""
+        return self._operator_session_state.catalog
+
+    @flow_catalog_state.setter
+    def flow_catalog_state(self: "DataEngineTui", value: FlowCatalogState) -> None:
+        self._operator_session_state = self._operator_session_state.with_catalog(value)
+
+    @property
+    def flow_cards(self: "DataEngineTui") -> tuple[QtFlowCard, ...]:
+        return qt_flow_cards_from_entries(self.flow_catalog_state.entries)
+
+    @flow_cards.setter
+    def flow_cards(self: "DataEngineTui", value: tuple[QtFlowCard, ...]) -> None:
+        self.flow_catalog_state = self.flow_catalog_state.with_entries(
+            tuple(flow_catalog_entry_from_qt_card(card) for card in value)
+        )
+
+    @property
+    def flow_states(self: "DataEngineTui") -> dict[str, str]:
+        return self.flow_catalog_state.flow_states or {}
+
+    @flow_states.setter
+    def flow_states(self: "DataEngineTui", value: dict[str, str]) -> None:
+        self.flow_catalog_state = self.flow_catalog_state.with_flow_states(value)
+
+    @property
+    def selected_flow_name(self: "DataEngineTui") -> str | None:
+        return self.flow_catalog_state.selected_flow_name
+
+    @selected_flow_name.setter
+    def selected_flow_name(self: "DataEngineTui", value: str | None) -> None:
+        self.flow_catalog_state = self.flow_catalog_state.with_selected_flow_name(value)
+
+    @property
+    def workspace_control_state(self: "DataEngineTui") -> WorkspaceControlState:
+        """Return the current structured workspace control state."""
+        return self._operator_session_state.workspace_control
+
+    @workspace_control_state.setter
+    def workspace_control_state(self: "DataEngineTui", value: WorkspaceControlState) -> None:
+        self._operator_session_state = self._operator_session_state.with_workspace_control(value)
+
+    @property
+    def workspace_session_state(self: "DataEngineTui") -> WorkspaceSessionState:
+        """Return the current workspace selection/root session state."""
+        return self._operator_session_state.workspace
+
+    @workspace_session_state.setter
+    def workspace_session_state(self: "DataEngineTui", value: WorkspaceSessionState) -> None:
+        self._operator_session_state = self._operator_session_state.with_workspace(value)
+
+    @property
+    def operator_session_state(self: "DataEngineTui") -> OperatorSessionState:
+        """Return the top-level operator session state for this surface."""
+        return self._operator_session_state
+
+    @property
+    def operation_tracker(self: "DataEngineTui") -> OperationSessionState:
+        """Return the current operation/step session state."""
+        return self._operator_session_state.operations
+
+    @operation_tracker.setter
+    def operation_tracker(self: "DataEngineTui", value: OperationSessionState) -> None:
+        self._operator_session_state = self._operator_session_state.with_operations(value)
+
+    @property
+    def workspace_collection_root_override(self: "DataEngineTui") -> Path | None:
+        return self.workspace_session_state.workspace_collection_root_override
+
+    @workspace_collection_root_override.setter
+    def workspace_collection_root_override(self: "DataEngineTui", value: Path | None) -> None:
+        self.workspace_session_state = self.workspace_session_state.with_override_root(value)
+
+    @property
+    def discovered_workspace_ids(self: "DataEngineTui") -> tuple[str, ...]:
+        return self.workspace_session_state.discovered_workspace_ids
+
+    @discovered_workspace_ids.setter
+    def discovered_workspace_ids(self: "DataEngineTui", value: tuple[str, ...]) -> None:
+        self.workspace_session_state = self.workspace_session_state.with_discovered_workspace_ids(value)
+
+    def _selected_card(self: "DataEngineTui") -> QtFlowCard | None:
+        if self.selected_flow_name is None:
+            return None
+        for card in self.flow_cards:
+            if card.name == self.selected_flow_name:
+                return card
+        return None
+
+
+__all__ = ["TuiStateMixin"]

data_engine/ui/tui/support.py

@@ -0,0 +1,63 @@
+"""Window support helpers for the terminal UI surface."""
+
+from __future__ import annotations
+
+import os
+from time import monotonic
+from typing import TYPE_CHECKING
+
+from data_engine.platform.workspace_models import authored_workspace_is_available
+
+if TYPE_CHECKING:
+    from data_engine.ui.tui.app import DataEngineTui
+
+
+class TuiWindowSupportMixin:
+    """Session, workspace, and daemon plumbing separated from the main TUI shell."""
+
+    def _has_authored_workspace(self: "DataEngineTui") -> bool:
+        """Return whether the selected workspace currently has authored flow modules."""
+        return authored_workspace_is_available(self.workspace_paths)
+
+    def _daemon_request(self: "DataEngineTui", paths, payload, *, timeout: float = 0.0):
+        return self.daemon_service.request(paths, payload, timeout=timeout)
+
+    def _is_daemon_live(self: "DataEngineTui", paths) -> bool:
+        return self.daemon_service.is_live(paths)
+
+    def _resolve_workspace_paths(self: "DataEngineTui", *, workspace_id: str | None = None):
+        return self.workspace_service.resolve_paths(
+            workspace_id=workspace_id,
+            workspace_collection_root=self.workspace_collection_root_override,
+        )
+
+    def _monotonic(self: "DataEngineTui") -> float:
+        return monotonic()
+
+    def _register_client_session(self: "DataEngineTui") -> None:
+        """Register this TUI process as one active local client for the workspace."""
+        self.runtime_binding_service.register_client_session(
+            self.runtime_binding,
+            client_id=self.client_session_id,
+            client_kind="tui",
+            pid=os.getpid(),
+        )
+
+    def _unregister_client_session_and_check_for_shutdown(self: "DataEngineTui") -> bool:
+        """Remove this TUI session and return whether no local clients remain."""
+        try:
+            self.runtime_binding_service.remove_client_session(self.runtime_binding, self.client_session_id)
+            remaining = self.runtime_binding_service.count_live_client_sessions(self.runtime_binding)
+            return remaining == 0
+        except Exception:
+            return False
+
+    def _shutdown_daemon_on_close(self: "DataEngineTui") -> None:
+        """Best-effort local daemon shutdown when the last local client closes."""
+        try:
+            if not self._is_daemon_live(self.workspace_paths):
+                return
+            self._daemon_request(self.workspace_paths, {"command": "shutdown_daemon"}, timeout=1.5)
+        except Exception:
+            pass
+__all__ = ["TuiWindowSupportMixin"]

data_engine/ui/tui/theme.py

@@ -0,0 +1,204 @@
+"""Textual theme adapter over the shared Data Engine theme tokens."""
+
+from __future__ import annotations
+
+from data_engine.platform.theme import DEFAULT_THEME, THEMES, resolve_theme_name, system_theme_name
+
+
+def stylesheet(theme_name: str = DEFAULT_THEME) -> str:
+    """Return the TUI stylesheet for the requested theme."""
+    palette = THEMES[resolve_theme_name(theme_name)]
+    return f"""
+    Screen {{
+        layout: vertical;
+        background: {palette.window_bg};
+    }}
+
+    #header {{
+        height: 7;
+        padding: 1 1 0 1;
+        align: left middle;
+    }}
+
+    #header-copy {{
+        width: 1fr;
+        height: 1fr;
+        layout: vertical;
+    }}
+
+    #header-actions {{
+        width: auto;
+        height: 1fr;
+        align: right middle;
+    }}
+
+    #header-controls {{
+        width: auto;
+        height: auto;
+        border: round {palette.panel_border};
+        padding: 0 1;
+        align: left middle;
+        background: {palette.panel_bg};
+    }}
+
+    #screen-title {{
+        width: 1fr;
+        height: auto;
+        text-style: bold;
+        color: {palette.text};
+    }}
+
+    #screen-subtitle {{
+        width: 1fr;
+        height: auto;
+        color: {palette.section_text};
+    }}
+
+    #status-line {{
+        width: 1fr;
+        height: auto;
+        color: {palette.text};
+        padding-top: 1;
+    }}
+
+    #control-status {{
+        width: 1fr;
+        height: auto;
+        color: {palette.muted_text};
+    }}
+
+    #workspace-select {{
+        width: 18;
+        margin-left: 1;
+    }}
+
+    .pane-title {{
+        height: auto;
+        color: {palette.section_text};
+        text-style: bold;
+        padding-bottom: 1;
+    }}
+
+    .pane-toolbar {{
+        height: 3;
+        align: right middle;
+    }}
+
+    #body {{
+        layout: grid;
+        grid-size: 3 1;
+        grid-columns: 40 1.7fr 1.3fr;
+        grid-rows: 1fr;
+        height: 1fr;
+        padding: 1;
+        grid-gutter: 1;
+    }}
+
+    #flow-list-pane {{
+        height: 1fr;
+        layout: vertical;
+        border: round $surface;
+        padding: 1;
+        background: {palette.panel_bg};
+    }}
+
+    #detail-pane {{
+        height: 1fr;
+        layout: vertical;
+        border: round $surface;
+        padding: 1;
+        background: {palette.panel_bg};
+    }}
+
+    #log-pane {{
+        height: 1fr;
+        layout: vertical;
+        border: round $surface;
+        padding: 1;
+        background: {palette.panel_bg};
+    }}
+
+    #flow-list,
+    #detail-view {{
+        height: 1fr;
+    }}
+
+    #detail-view {{
+        color: {palette.text};
+    }}
+
+    #flow-list {{
+        padding: 0 1;
+    }}
+
+    #log-run-list {{
+        height: 1fr;
+        border: round {palette.panel_border};
+        padding: 0 1;
+        background: {palette.panel_bg};
+    }}
+
+    #flow-list .label {{
+        height: auto;
+        color: {palette.text};
+    }}
+
+    #flow-list > GroupHeaderListItem {{
+        background: transparent;
+        color: {palette.muted_text};
+        text-style: bold;
+        margin-top: 1;
+        border-bottom: solid {palette.panel_border};
+    }}
+
+    #flow-list > GroupHeaderListItem.-disabled {{
+        opacity: 1;
+    }}
+
+    #flow-list > FlowListItem {{
+        padding: 0 1;
+    }}
+
+    #log-run-list .label {{
+        height: auto;
+        color: {palette.text};
+    }}
+
+    #log-run-list > .list-view--item-highlight {{
+        background: {palette.selection_bg};
+        color: {palette.selection_text};
+    }}
+
+    #flow-list > .list-view--item-highlight {{
+        background: {palette.selection_bg};
+        color: {palette.selection_text};
+    }}
+
+    Button {{
+        margin-right: 1;
+        height: 3;
+        background: {palette.button_bg};
+        color: {palette.text};
+        border: round {palette.panel_border};
+    }}
+
+    Button:hover {{
+        background: {palette.button_hover};
+    }}
+
+    Button:disabled {{
+        background: {palette.button_disabled_bg};
+        color: {palette.button_disabled_text};
+        border: round {palette.button_disabled_border};
+    }}
+
+    #clear-flow-log {{
+        margin-right: 0;
+    }}
+    """
+
+
+TUI_CSS = stylesheet(DEFAULT_THEME)
+
+
+__all__ = ["DEFAULT_THEME", "TUI_CSS", "resolve_theme_name", "stylesheet", "system_theme_name"]

data_engine/ui/tui/widgets.py

@@ -0,0 +1,123 @@
+"""Textual widget classes for the terminal UI surface."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, ListItem, Static
+
+from data_engine.domain import FlowRunState
+from data_engine.views.flow_display import FlowRowDisplay, GroupRowDisplay
+from data_engine.views.models import QtFlowCard
+from data_engine.views.text import run_group_row_text
+
+
+class FlowListItem(ListItem):
+    """One flow entry in the TUI sidebar."""
+
+    def __init__(self, card: QtFlowCard, state: str) -> None:
+        self.card = card
+        self.card_state = state
+        self.label = Label()
+        super().__init__(self.label)
+        self.refresh_view(state)
+
+    def refresh_view(self, state: str) -> None:
+        self.card_state = state
+        self.label.update(self._render_text(state))
+
+    def _render_text(self, state: str) -> str:
+        display = FlowRowDisplay.from_card(self.card, state, primary="title")
+        return f"{display.dot} {display.primary}\n    {display.secondary}"
+
+
+class GroupHeaderListItem(ListItem):
+    """Non-selectable group header for configured flows."""
+
+    def __init__(self, group_name: str, count: int) -> None:
+        self.group_name = group_name
+        flow_label = "flow" if count == 1 else "flows"
+        display = GroupRowDisplay.from_group(group_name, [], {})
+        self.label = Label(f"{display.uppercase_title}  {count} {flow_label}")
+        super().__init__(self.label, disabled=True)
+
+
+class RunGroupListItem(ListItem):
+    """One grouped flow run entry in the logs pane."""
+
+    def __init__(self, run_group: FlowRunState) -> None:
+        self.run_group = run_group
+        self.label = Label()
+        super().__init__(self.label)
+        self.refresh_view()
+
+    def refresh_view(self, run_group: FlowRunState | None = None) -> None:
+        if run_group is not None:
+            self.run_group = run_group
+        self.label.update(run_group_row_text(self.run_group))
+
+
+class InfoModal(ModalScreen[None]):
+    """Simple centered information modal for TUI drill-ins."""
+
+    def __init__(self, *, title: str, body: str) -> None:
+        super().__init__()
+        self.title = title
+        self.body = body
+
+    CSS = """
+    Screen {
+        background: $background 70%;
+    }
+
+    #modal-shell {
+        width: 1fr;
+        height: 1fr;
+        align: center middle;
+    }
+
+    #modal-card {
+        width: 62;
+        max-width: 72%;
+        height: auto;
+        max-height: 70%;
+        border: round $surface;
+        background: $panel;
+        padding: 1 2;
+    }
+
+    #modal-title {
+        height: auto;
+        text-style: bold;
+        padding-bottom: 1;
+    }
+
+    #modal-body {
+        height: auto;
+        max-height: 20;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "dismiss", "Close"),
+        Binding("enter", "dismiss", "Close"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        with Container(id="modal-shell"):
+            with Vertical(id="modal-card"):
+                yield Static(self.title, id="modal-title")
+                yield Static(self.body, id="modal-body")
+                yield Button("Close", id="close-modal")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "close-modal":
+            self.dismiss(None)
+
+    def action_dismiss(self) -> None:
+        self.dismiss(None)
+
+
+__all__ = ["FlowListItem", "GroupHeaderListItem", "InfoModal", "RunGroupListItem"]

data_engine/views/__init__.py

@@ -0,0 +1,109 @@
+"""Shared presentation models and helpers across Data Engine surfaces."""
+
+from data_engine.domain import (
+    FlowLogEntry,
+    FlowRunState,
+    LogKind,
+    RunKey,
+    RuntimeStepEvent,
+    format_log_line,
+    format_runtime_message,
+    parse_runtime_event,
+    parse_runtime_message,
+    short_source_label,
+)
+from data_engine.views.logs import FlowLogStore
+from data_engine.views.actions import GuiActionState, TuiActionState
+from data_engine.views.artifacts import ArtifactPreviewSpec, classify_artifact_preview, is_text_artifact
+from data_engine.views.flow_display import FlowRowDisplay, GroupRowDisplay
+from data_engine.views.models import (
+    QtFlowCard,
+    default_flow_state,
+    flow_category,
+    load_qt_flow_cards,
+    qt_flow_card_from_entry,
+    qt_flow_cards_from_entries,
+)
+from data_engine.views.presentation import (
+    flow_group_name,
+    flow_secondary_text,
+    format_seconds,
+    group_cards,
+    group_label,
+    group_secondary_text,
+    operation_marker,
+    state_dot,
+    status_color_name,
+)
+from data_engine.views.state import (
+    OperationDisplayState,
+    OperationRowState,
+    artifact_key_for_operation,
+    build_flow_summary,
+    capture_step_outputs,
+    is_inspectable_operation,
+)
+from data_engine.views.status import WORKSPACE_UNAVAILABLE_TEXT, surface_control_status_text
+from data_engine.views.runs import RunGroupDisplay, format_raw_log_message
+from data_engine.views.text import (
+    format_optional_seconds,
+    pad,
+    render_operation_lines,
+    render_run_group_lines,
+    render_selected_flow_lines,
+    run_group_row_text,
+    short_datetime,
+)
+
+__all__ = [
+    "FlowLogStore",
+    "FlowRowDisplay",
+    "FlowLogEntry",
+    "FlowRunState",
+    "GroupRowDisplay",
+    "GuiActionState",
+    "ArtifactPreviewSpec",
+    "LogKind",
+    "OperationDisplayState",
+    "OperationRowState",
+    "QtFlowCard",
+    "RunGroupDisplay",
+    "RunKey",
+    "RuntimeStepEvent",
+    "TuiActionState",
+    "artifact_key_for_operation",
+    "build_flow_summary",
+    "capture_step_outputs",
+    "classify_artifact_preview",
+    "default_flow_state",
+    "flow_category",
+    "flow_group_name",
+    "flow_secondary_text",
+    "format_log_line",
+    "format_raw_log_message",
+    "format_runtime_message",
+    "format_optional_seconds",
+    "format_seconds",
+    "group_cards",
+    "group_label",
+    "group_secondary_text",
+    "is_text_artifact",
+    "is_inspectable_operation",
+    "load_qt_flow_cards",
+    "operation_marker",
+    "pad",
+    "parse_runtime_event",
+    "parse_runtime_message",
+    "render_operation_lines",
+    "render_run_group_lines",
+    "render_selected_flow_lines",
+    "run_group_row_text",
+    "short_datetime",
+    "short_source_label",
+    "surface_control_status_text",
+    "state_dot",
+    "status_color_name",
+    "WORKSPACE_UNAVAILABLE_TEXT",
+    "qt_flow_card_from_entry",
+    "qt_flow_cards_from_entries",
+]