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

data_engine/ui/gui/widgets/sidebar.py

@@ -0,0 +1,130 @@
+"""Sidebar row builders for the desktop UI."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QIcon, QPixmap
+from PySide6.QtWidgets import QFrame, QHBoxLayout, QLabel, QSizePolicy, QVBoxLayout
+
+from data_engine.views.flow_display import FlowRowDisplay, GroupRowDisplay
+from data_engine.views.presentation import status_color_name as shared_status_color_name
+
+if TYPE_CHECKING:
+    from data_engine.ui.gui.app import DataEngineWindow
+    from data_engine.views.models import QtFlowCard
+
+
+def group_secondary_text(window: "DataEngineWindow", group_name: str, entries: list["QtFlowCard"]) -> str:
+    return GroupRowDisplay.from_group(group_name, entries, window.flow_states).secondary
+
+
+def flow_secondary_text(window: "DataEngineWindow", card: "QtFlowCard") -> str:
+    state = window.flow_states.get(card.name, card.state)
+    return FlowRowDisplay.from_card(card, state, primary="name").secondary
+
+
+def flow_primary_text(card: "QtFlowCard") -> str:
+    return card.name
+
+
+def status_color_name(state: str) -> str:
+    return shared_status_color_name(state)
+
+
+def icon_label(icon: QIcon, size: int = 18) -> QLabel:
+    label = QLabel()
+    label.setObjectName("sidebarIcon")
+    pixmap = icon.pixmap(size, size)
+    label.setPixmap(QPixmap(pixmap))
+    label.setFixedSize(size + 8, size + 8)
+    label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+    return label
+
+
+def build_group_row_widget(window: "DataEngineWindow", group_name: str, entries: list["QtFlowCard"]) -> QFrame:
+    group_display = GroupRowDisplay.from_group(group_name, entries, window.flow_states)
+    frame = QFrame()
+    frame.setObjectName("sidebarGroupRow")
+    frame.setProperty("groupName", group_name)
+    frame.setProperty("hovered", False)
+    frame.setFixedHeight(44)
+    row = QHBoxLayout(frame)
+    row.setContentsMargins(0, 8, 0, 2)
+    row.setSpacing(8)
+    icon = QLabel()
+    icon.setObjectName("sidebarIcon")
+    icon.setPixmap(window._render_group_icon_pixmap(group_name, 16))
+    icon.setFixedSize(24, 24)
+    icon.setAlignment(Qt.AlignmentFlag.AlignCenter)
+    row.addWidget(icon)
+
+    text_col = QVBoxLayout()
+    text_col.setContentsMargins(0, 0, 0, 0)
+    text_col.setSpacing(1)
+    title = QLabel(group_display.title)
+    title.setObjectName("sidebarGroupTitle")
+    subtitle = QLabel(group_display.secondary)
+    subtitle.setObjectName("sidebarGroupMeta")
+    text_col.addWidget(title)
+    text_col.addWidget(subtitle)
+    row.addLayout(text_col, 1)
+    frame.enterEvent = lambda event, widget=frame: window._set_hovered(widget, True)
+    frame.leaveEvent = lambda event, widget=frame: window._set_hovered(widget, False)
+    return frame
+
+
+def build_flow_row_widget(window: "DataEngineWindow", card: "QtFlowCard") -> QFrame:
+    flow_display = FlowRowDisplay.from_card(card, window.flow_states.get(card.name, card.state), primary="name")
+    frame = QFrame()
+    frame.setObjectName("sidebarFlowRow")
+    frame.setProperty("selected", False)
+    frame.setProperty("hovered", False)
+    frame.setFixedHeight(42)
+    row = QHBoxLayout(frame)
+    row.setContentsMargins(12, 4, 8, 4)
+    row.setSpacing(10)
+    number = QLabel("00")
+    number.setObjectName("sidebarFlowNumber")
+    row.addWidget(number)
+
+    text_col = QVBoxLayout()
+    text_col.setContentsMargins(0, 0, 0, 0)
+    text_col.setSpacing(1)
+    title = QLabel(flow_primary_text(card))
+    title.setObjectName("sidebarFlowCode")
+    subtitle = QLabel(flow_display.secondary)
+    subtitle.setObjectName("sidebarFlowMeta")
+    subtitle.setProperty("stateColor", flow_display.state_color)
+    text_col.addWidget(title)
+    text_col.addWidget(subtitle)
+    row.addLayout(text_col, 1)
+
+    state_dot = QLabel("\u25cf")
+    state_dot.setObjectName("sidebarStateDot")
+    state_dot.setProperty("stateColor", flow_display.state_color)
+    state_dot.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+    state_dot.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Preferred)
+    row.addWidget(state_dot)
+    frame.setToolTip(flow_display.tooltip)
+    frame.mousePressEvent = lambda event, flow_name=card.name: window._select_flow(flow_name)
+    frame.enterEvent = lambda event, widget=frame: window._set_hovered(widget, True)
+    frame.leaveEvent = lambda event, widget=frame: window._set_hovered(widget, False)
+    return frame
+
+
+def group_label(group_name: str) -> str:
+    return GroupRowDisplay.from_group(group_name, [], {}).title
+
+
+__all__ = [
+    "build_flow_row_widget",
+    "build_group_row_widget",
+    "flow_primary_text",
+    "flow_secondary_text",
+    "group_label",
+    "group_secondary_text",
+    "icon_label",
+    "status_color_name",
+]

data_engine/ui/gui/widgets/steps.py

@@ -0,0 +1,84 @@
+"""Step-list view helpers for the desktop UI."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QFrame, QHBoxLayout, QLabel, QPushButton
+from data_engine.ui.gui.cache_models import OperationRowWidgets
+
+if TYPE_CHECKING:
+    from data_engine.ui.gui.app import DataEngineWindow
+
+
+def set_operation_cards(window: "DataEngineWindow", operation_items: tuple[str, ...]) -> None:
+    for timer in list(window.operation_flash_timers):
+        timer.stop()
+    window.operation_flash_timers.clear()
+
+    while window.operation_layout.count() > 1:
+        item = window.operation_layout.takeAt(0)
+        widget = item.widget()
+        if widget is not None:
+            widget.deleteLater()
+        window.operation_row_widgets = []
+
+    if not operation_items:
+        empty = QFrame()
+        empty.setObjectName("operationCard")
+        row = QHBoxLayout(empty)
+        row.setContentsMargins(12, 9, 12, 9)
+        label = QLabel("No steps configured.")
+        label.setObjectName("bodyText")
+        row.addWidget(label)
+        window.operation_layout.insertWidget(0, empty)
+        window._update_operation_scroll_cues()
+        return
+
+    for index, name in enumerate(operation_items, start=1):
+        card = QFrame()
+        card.setObjectName("operationCard")
+        row = QHBoxLayout(card)
+        row.setContentsMargins(12, 9, 12, 9)
+        row.setSpacing(10)
+        step = QLabel(f"{index:02d}")
+        step.setObjectName("operationStep")
+        title = QLabel(format_operation_title(name))
+        title.setObjectName("operationTitle")
+        title.setTextFormat(Qt.TextFormat.RichText)
+        duration = QLabel("")
+        duration.setObjectName("operationDuration")
+        duration.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+        inspect_button: QPushButton | None = None
+        row.addWidget(step)
+        row.addWidget(title, 1)
+        if window._is_inspectable_operation(name):
+            inspect_button = QPushButton("Inspect")
+            inspect_button.setObjectName("inspectOutputButton")
+            inspect_button.clicked.connect(lambda _checked=False, operation_name=name: window._inspect_step_output(operation_name))
+            row.addWidget(inspect_button)
+        row.addWidget(duration)
+        window.operation_layout.insertWidget(index - 1, card)
+        window.operation_row_widgets.append(
+            OperationRowWidgets(
+                row_card=card,
+                title_label=title,
+                duration_label=duration,
+                inspect_button=inspect_button,
+                operation_name=name,
+            )
+        )
+    if window.selected_flow_name is not None:
+        window._refresh_operation_buttons(window.selected_flow_name)
+    window._update_operation_scroll_cues()
+
+
+def format_operation_title(operation_name: str) -> str:
+    head, separator, tail = operation_name.partition(":")
+    if not separator:
+        return f"<b>{head}</b>"
+    return f"<b>{head}</b><span style='font-weight: 400;'> </span><i><span style='font-weight: 400;'>{tail}</span></i>"
+
+
+__all__ = ["format_operation_title", "set_operation_cards"]

data_engine/ui/tui/__init__.py

@@ -0,0 +1,5 @@
+"""Textual TUI surface for Data Engine."""
+
+from data_engine.ui.tui.app import DataEngineTui, main
+
+__all__ = ["DataEngineTui", "main"]

data_engine/ui/tui/app.py

@@ -0,0 +1,222 @@
+"""Textual-based terminal UI for Data Engine."""
+
+from __future__ import annotations
+
+import logging
+from queue import Empty
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Grid, Horizontal, Vertical
+from textual.widgets import Button, Footer, ListView, Select, Static
+
+from data_engine.domain import (
+    FlowRunState,
+    RunDetailState,
+)
+from data_engine.authoring.model import FlowValidationError
+from data_engine.views.text import render_run_group_lines
+from data_engine.ui.tui.bootstrap import TuiServices
+from data_engine.ui.tui.bootstrapper import bootstrap_tui_app
+from data_engine.ui.tui.theme import DEFAULT_THEME, stylesheet as tui_stylesheet
+from data_engine.ui.tui.state_support import TuiStateMixin
+from data_engine.ui.tui.support import TuiWindowSupportMixin
+from data_engine.ui.tui.widgets import FlowListItem, InfoModal, RunGroupListItem
+
+
+class DataEngineTui(TuiWindowSupportMixin, TuiStateMixin, App[None]):
+    """Full-screen terminal UI for headless Data Engine operation."""
+
+    CSS = tui_stylesheet(DEFAULT_THEME)
+    _ACTIVE_FLOW_STATES = {"running", "polling", "scheduled", "stopping flow", "stopping runtime"}
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("r", "refresh_flows", "Refresh"),
+        Binding("enter", "run_selected", "Run"),
+        Binding("e", "start_engine", "Start Engine"),
+        Binding("s", "stop_engine", "Stop"),
+        Binding("v", "view_log", "View Log"),
+    ]
+
+    def __init__(self, *, theme_name: str = DEFAULT_THEME, services: TuiServices | None = None) -> None:
+        super().__init__()
+        bootstrap_tui_app(self, theme_name=theme_name, services=services)
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="header"):
+            with Vertical(id="header-copy"):
+                yield Static("Flow Control", id="screen-title")
+                yield Static("Monitor and operate one workspace daemon from the terminal.", id="screen-subtitle")
+                yield Static("Workspace runtime is idle.", id="status-line")
+                yield Static("", id="control-status")
+            with Horizontal(id="header-actions"):
+                with Horizontal(id="header-controls"):
+                    yield Button("Start Engine", id="start-engine")
+                    yield Button("Stop", id="stop-engine")
+                    yield Button("Refresh", id="refresh")
+                    yield Select([], prompt="Workspace", allow_blank=True, id="workspace-select")
+        with Grid(id="body"):
+            with Container(id="flow-list-pane"):
+                yield Static("CONFIGURED FLOWS", classes="pane-title")
+                yield ListView(id="flow-list")
+            with Container(id="detail-pane"):
+                yield Static("STEPS", classes="pane-title")
+                with Horizontal(classes="pane-toolbar"):
+                    yield Button("Run Once", id="run-once")
+                    yield Button("View Config", id="view-config")
+                yield Static("", id="detail-view")
+            with Container(id="log-pane"):
+                yield Static("LOGS", classes="pane-title")
+                with Horizontal(classes="pane-toolbar"):
+                    yield Button("View Log", id="view-log")
+                    yield Button("Clear Flow Log", id="clear-flow-log")
+                yield ListView(id="log-run-list")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        logger = logging.getLogger("data_engine")
+        logger.setLevel(logging.INFO)
+        logger.addHandler(self.log_handler)
+        self._register_client_session()
+        self._reload_workspace_options()
+        self._load_flows()
+        if self._has_authored_workspace():
+            self._ensure_daemon_started()
+        self._sync_daemon_state()
+        self.set_interval(0.15, self._poll_ui)
+        self._refresh_buttons()
+
+    def on_unmount(self) -> None:
+        logging.getLogger("data_engine").removeHandler(self.log_handler)
+        if self._unregister_client_session_and_check_for_shutdown():
+            self._shutdown_daemon_on_close()
+        self.runtime_binding_service.close_binding(self.runtime_binding)
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        if isinstance(event.item, FlowListItem):
+            self.selected_flow_name = event.item.card.name
+            self._render_selected_flow()
+        elif isinstance(event.item, RunGroupListItem):
+            self.selected_run_key = event.item.run_group.key
+            self._show_run_group_modal(event.item.run_group)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        button_id = event.button.id
+        if button_id == "refresh":
+            self.action_refresh_flows()
+        elif button_id == "run-once":
+            self.action_run_selected()
+        elif button_id == "start-engine":
+            self.action_start_engine()
+        elif button_id == "stop-engine":
+            self.action_stop_engine()
+        elif button_id == "view-config":
+            self.action_view_config()
+        elif button_id == "view-log":
+            self.action_view_log()
+        elif button_id == "clear-flow-log":
+            self.action_clear_flow_log()
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        if event.select.id != "workspace-select":
+            return
+        if self._workspace_switch_suppressed or not self.is_mounted:
+            return
+        if event.value in {Select.NULL, Select.BLANK}:
+            return
+        workspace_id = str(event.value or "").strip()
+        if not workspace_id or workspace_id == self.workspace_paths.workspace_id:
+            return
+        self._switch_workspace(workspace_id)
+
+    def action_refresh_flows(self) -> None:
+        self.flow_controller.action_refresh_flows(self)
+
+    def action_run_selected(self) -> None:
+        self.flow_controller.action_run_selected(self)
+
+    def action_start_engine(self) -> None:
+        self.flow_controller.action_start_engine(self)
+
+    def action_stop_engine(self) -> None:
+        self.flow_controller.action_stop_engine(self)
+
+    def action_view_config(self) -> None:
+        self.flow_controller.action_view_config(self)
+
+    def action_clear_flow_log(self) -> None:
+        self.flow_controller.action_clear_flow_log(self)
+
+    def action_view_log(self) -> None:
+        self.flow_controller.action_view_log(self)
+
+    def _load_flows(self) -> None:
+        self.flow_controller.load_flows(self)
+
+    def _reload_workspace_options(self) -> None:
+        self.flow_controller.reload_workspace_options(self)
+
+    def _switch_workspace(self, workspace_id: str) -> None:
+        self.flow_controller.switch_workspace(self, workspace_id)
+
+    def _render_selected_flow(self) -> None:
+        self.flow_controller.render_selected_flow(self)
+
+    def _selected_run_group(self) -> FlowRunState | None:
+        return self.flow_controller.selected_run_group(self)
+
+    def _show_run_group_modal(self, run_group: FlowRunState) -> None:
+        detail = RunDetailState.from_run(run_group)
+        lines = render_run_group_lines(run_group)
+        self.push_screen(InfoModal(title=f"Run Details · {detail.source_label}", body="\n".join(lines)))
+
+    def _poll_ui(self) -> None:
+        while True:
+            try:
+                entry = self.log_queue.get_nowait()
+            except Empty:
+                break
+            del entry
+        self._sync_daemon_state()
+
+    def _refresh_flow_list_items(self) -> None:
+        self.runtime_controller.refresh_flow_list_items(self)
+
+    def _refresh_buttons(self) -> None:
+        self.runtime_controller.refresh_buttons(self)
+
+    def _set_status(self, message: str) -> None:
+        self.query_one("#status-line", Static).update(message)
+
+    def _sync_daemon_state(self) -> None:
+        self.runtime_controller.sync_daemon_state(self)
+
+    def _ensure_daemon_started(self) -> bool:
+        return self.runtime_controller.ensure_daemon_started(self)
+
+    def _start_daemon_worker(self) -> None:
+        self.runtime_controller.start_daemon_worker(self)
+
+    def _finish_daemon_startup(self, success: bool, error_text: str) -> None:
+        self.runtime_controller.finish_daemon_startup(self, success, error_text)
+
+    def _rebuild_runtime_snapshot(self) -> None:
+        self.runtime_controller.rebuild_runtime_snapshot(self)
+
+
+def main() -> None:
+    """Launch the Textual terminal UI."""
+    try:
+        app = DataEngineTui()
+        app.run()
+    except ModuleNotFoundError as exc:  # pragma: no cover - import-time dependency guard
+        raise SystemExit(
+            "The terminal UI requires the 'textual' package. Reinstall Data Engine after updating dependencies."
+        ) from exc
+    except FlowValidationError as exc:
+        raise SystemExit(str(exc)) from exc
+
+
+__all__ = ["DataEngineTui", "main"]
+__all__ += ["FlowListItem", "GroupHeaderListItem", "RunGroupListItem", "InfoModal", "QueueLogHandler"]