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

data_engine/ui/tui/controllers/flows.py

@@ -0,0 +1,349 @@
+"""Flow/workspace/detail controllers for the terminal UI."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.widgets import ListView, Select, Static
+
+from data_engine.application import FlowCatalogApplication, OperatorControlApplication, WorkspaceSessionApplication
+from data_engine.services import LogService
+from data_engine.domain import FlowRunState, FlowSummaryRow
+from data_engine.views.text import render_operation_lines, render_run_group_lines, render_selected_flow_lines
+from data_engine.ui.tui.widgets import FlowListItem, GroupHeaderListItem, InfoModal, RunGroupListItem
+
+if TYPE_CHECKING:
+    from data_engine.ui.tui.app import DataEngineTui
+
+
+class TuiFlowController:
+    """Compose narrower TUI flow collaborators behind one stable controller seam."""
+
+    def __init__(
+        self,
+        *,
+        workspace_session_application: WorkspaceSessionApplication,
+        flow_catalog_application: FlowCatalogApplication,
+        control_application: OperatorControlApplication,
+        log_service: LogService,
+    ) -> None:
+        self.workspace = _TuiWorkspaceCatalogController(
+            workspace_session_application=workspace_session_application,
+            flow_catalog_application=flow_catalog_application,
+            control_application=control_application,
+        )
+        self.presentation = _TuiFlowPresentationController(
+            control_application=control_application,
+            log_service=log_service,
+        )
+
+    def action_refresh_flows(self, window: "DataEngineTui") -> None:
+        self.workspace.action_refresh_flows(window, self.presentation)
+
+    def action_run_selected(self, window: "DataEngineTui") -> None:
+        self.presentation.action_run_selected(window)
+
+    def action_start_engine(self, window: "DataEngineTui") -> None:
+        self.presentation.action_start_engine(window)
+
+    def action_stop_engine(self, window: "DataEngineTui") -> None:
+        self.presentation.action_stop_engine(window)
+
+    def action_view_config(self, window: "DataEngineTui") -> None:
+        self.presentation.action_view_config(window)
+
+    def action_clear_flow_log(self, window: "DataEngineTui") -> None:
+        self.presentation.action_clear_flow_log(window)
+
+    def action_view_log(self, window: "DataEngineTui") -> None:
+        self.presentation.action_view_log(window)
+
+    def load_flows(self, window: "DataEngineTui") -> None:
+        self.workspace.load_flows(window, self.presentation)
+
+    def reload_workspace_options(self, window: "DataEngineTui") -> None:
+        self.workspace.reload_workspace_options(window)
+
+    def switch_workspace(self, window: "DataEngineTui", workspace_id: str) -> None:
+        self.workspace.switch_workspace(window, workspace_id, self.presentation)
+
+    def render_selected_flow(self, window: "DataEngineTui") -> None:
+        self.presentation.render_selected_flow(window)
+
+    def selected_run_group(self, window: "DataEngineTui") -> "FlowRunState | None":
+        return self.presentation.selected_run_group(window)
+
+
+class _TuiWorkspaceCatalogController:
+    """Own TUI workspace binding and catalog refresh orchestration."""
+
+    def __init__(
+        self,
+        *,
+        workspace_session_application: WorkspaceSessionApplication,
+        flow_catalog_application: FlowCatalogApplication,
+        control_application: OperatorControlApplication,
+    ) -> None:
+        self.workspace_session_application = workspace_session_application
+        self.flow_catalog_application = flow_catalog_application
+        self.control_application = control_application
+
+    def action_refresh_flows(self, window: "DataEngineTui", presentation: "_TuiFlowPresentationController") -> None:
+        result = self.control_application.refresh_flows(
+            paths=window.workspace_paths,
+            runtime_session=window.runtime_session,
+            has_authored_workspace=window._has_authored_workspace(),
+            timeout=5.0,
+        )
+        if result.error_text is not None:
+            window._set_status(result.error_text)
+            return
+        if result.reload_catalog:
+            self.reload_workspace_options(window)
+            self.load_flows(window, presentation)
+        if result.sync_after:
+            window._sync_daemon_state()
+        if result.warning_text is not None:
+            window._set_status(result.warning_text)
+            return
+        if result.status_text is not None:
+            window._set_status(result.status_text)
+
+    def load_flows(self, window: "DataEngineTui", presentation_controller: "_TuiFlowPresentationController") -> None:
+        list_view = window.query_one("#flow-list", ListView)
+        list_view.clear()
+        missing_message = (
+            "Workspace collection root is not configured."
+            if not window.workspace_paths.workspace_configured
+            else "No flow modules discovered."
+        )
+        result = self.flow_catalog_application.load_workspace_catalog(
+            workspace_paths=window.workspace_paths,
+            current_state=window.flow_catalog_state,
+            missing_message=missing_message,
+        )
+        window.flow_catalog_state = result.catalog_state
+        presentation = self.flow_catalog_application.build_presentation(
+            catalog_state=window.flow_catalog_state,
+        )
+        if not result.loaded:
+            window.selected_flow_name = None
+            window.query_one("#detail-view", Static).update(window.flow_catalog_state.empty_message or missing_message)
+            window.query_one("#log-run-list", ListView).clear()
+            window._rebuild_runtime_snapshot()
+            return
+        for card in presentation.cards:
+            window.operation_tracker = window.operation_tracker.ensure_flow(card.name, card.operation_items)
+        for group_name, grouped in presentation.grouped_cards:
+            list_view.append(GroupHeaderListItem(group_name, len(grouped)))
+            for card in grouped:
+                list_view.append(FlowListItem(card, window.flow_states[card.name]))
+        if presentation.cards:
+            window.selected_flow_name = presentation.selected_flow_name
+            index = presentation.selected_list_index or 0
+            list_view.index = index
+            presentation_controller.render_selected_flow(window)
+        else:
+            window.selected_flow_name = None
+            window.query_one("#detail-view", Static).update("No flows discovered.")
+            window.query_one("#log-run-list", ListView).clear()
+        window._rebuild_runtime_snapshot()
+
+    def reload_workspace_options(self, window: "DataEngineTui") -> None:
+        window.workspace_session_state = self.workspace_session_application.refresh_session(
+            workspace_paths=window.workspace_paths,
+            override_root=window.workspace_collection_root_override,
+        )
+        current_id = window.workspace_session_state.current_workspace_id
+        workspace_ids = window.workspace_session_state.discovered_workspace_ids
+        selector = window.query_one("#workspace-select", Select)
+        window._workspace_switch_suppressed = True
+        try:
+            if not workspace_ids:
+                selector.set_options([("(no workspace)", Select.BLANK)])
+                selector.value = Select.BLANK
+                selector.disabled = True
+            else:
+                selector.set_options([(workspace_id, workspace_id) for workspace_id in workspace_ids])
+                if current_id in workspace_ids:
+                    selector.value = current_id
+                else:
+                    selector.value = workspace_ids[0]
+                selector.disabled = False
+        finally:
+            window._workspace_switch_suppressed = False
+
+    def switch_workspace(self, window: "DataEngineTui", workspace_id: str, presentation: "_TuiFlowPresentationController") -> None:
+        try:
+            window.runtime_binding_service.remove_client_session(window.runtime_binding, window.client_session_id)
+        except Exception:
+            pass
+        window.runtime_binding_service.close_binding(window.runtime_binding)
+        window.workspace_paths = window.workspace_service.resolve_paths(
+            workspace_id=workspace_id,
+            workspace_collection_root=window.workspace_collection_root_override,
+        )
+        binding = self.workspace_session_application.bind_workspace(
+            workspace_paths=window.workspace_paths,
+            override_root=window.workspace_collection_root_override,
+        )
+        window._operator_session_state = binding.operator_session
+        window.runtime_binding = window.runtime_binding_service.open_binding(window.workspace_paths)
+        window._register_client_session()
+        window.flow_cards = ()
+        window.flow_states = {}
+        window.selected_flow_name = None
+        window._last_daemon_spawn_attempt = 0.0
+        window._daemon_startup_in_progress = False
+        window.selected_run_key = None
+        window._last_rendered_flow_signature = None
+        window._last_run_list_signature = None
+        window._last_detail_signature = None
+        self.reload_workspace_options(window)
+        if window._has_authored_workspace():
+            window._ensure_daemon_started()
+        self.load_flows(window, presentation)
+        window._sync_daemon_state()
+        window._set_status(f"Switched to workspace {workspace_id}.")
+
+
+class _TuiFlowPresentationController:
+    """Own TUI selected-flow, run-list, and action orchestration."""
+
+    def __init__(
+        self,
+        *,
+        control_application: OperatorControlApplication,
+        log_service: LogService,
+    ) -> None:
+        self.control_application = control_application
+        self.log_service = log_service
+
+    def action_run_selected(self, window: "DataEngineTui") -> None:
+        window._sync_daemon_state()
+        card = window._selected_card()
+        result = self.control_application.run_selected_flow(
+            paths=window.workspace_paths,
+            runtime_session=window.runtime_session,
+            selected_flow_name=card.name if card is not None else None,
+            selected_flow_valid=bool(card is not None and card.valid),
+            selected_flow_group=card.group if card is not None else None,
+            selected_flow_group_active=bool(card is not None and window.runtime_session.is_group_active(card.group, {flow.name: flow.group for flow in window.flow_cards})),
+            blocked_status_text=window.workspace_control_state.blocked_status_text,
+            timeout=2.0,
+        )
+        if result.error_text is not None:
+            window._set_status(result.error_text)
+            return
+        if result.status_text is not None:
+            window._set_status(result.status_text)
+        if result.sync_after:
+            window._sync_daemon_state()
+
+    def action_start_engine(self, window: "DataEngineTui") -> None:
+        window._sync_daemon_state()
+        result = self.control_application.start_engine(
+            paths=window.workspace_paths,
+            runtime_session=window.runtime_session,
+            has_automated_flows=any(card.valid and card.mode in {"poll", "schedule"} for card in window.flow_cards),
+            blocked_status_text=window.workspace_control_state.blocked_status_text,
+            timeout=2.0,
+        )
+        if result.error_text is not None:
+            window._set_status(result.error_text)
+            return
+        if result.status_text is not None:
+            window._set_status(result.status_text)
+        if result.sync_after:
+            window._sync_daemon_state()
+
+    def action_stop_engine(self, window: "DataEngineTui") -> None:
+        window._sync_daemon_state()
+        card = window._selected_card()
+        result = self.control_application.stop_pipeline(
+            paths=window.workspace_paths,
+            runtime_session=window.runtime_session,
+            selected_flow_group=card.group if card is not None else None,
+            blocked_status_text=window.workspace_control_state.blocked_status_text,
+            timeout=2.0,
+        )
+        if result.error_text is not None:
+            window._set_status(result.error_text)
+            return
+        if result.status_text is not None:
+            window._set_status(result.status_text)
+        if result.sync_after:
+            window._sync_daemon_state()
+
+    def action_view_config(self, window: "DataEngineTui") -> None:
+        card = window._selected_card()
+        if card is None:
+            window._set_status("Select one flow first.")
+            return
+        lines = [card.title]
+        if card.description:
+            lines.extend(["", card.description])
+        lines.extend([""])
+        lines.extend(f"{row.label}: {row.value}" for row in FlowSummaryRow.rows_for_flow(card, window.flow_states))
+        window.push_screen(InfoModal(title=card.title, body="\n".join(lines)))
+
+    def action_clear_flow_log(self, window: "DataEngineTui") -> None:
+        if window.selected_flow_name is None:
+            return
+        self.log_service.clear_flow(window.runtime_binding.log_store, window.selected_flow_name)
+        self.render_selected_flow(window)
+        window._set_status(f"Cleared log history for {window.selected_flow_name}.")
+
+    def action_view_log(self, window: "DataEngineTui") -> None:
+        run_group = self.selected_run_group(window)
+        if run_group is None:
+            window._set_status("Select one run first.")
+            return
+        window._show_run_group_modal(run_group)
+
+    def render_selected_flow(self, window: "DataEngineTui") -> None:
+        card = window._selected_card()
+        detail = window.query_one("#detail-view", Static)
+        run_list = window.query_one("#log-run-list", ListView)
+        run_groups = self.log_service.runs_for_flow(window.runtime_binding.log_store, card.name) if card is not None else ()
+        presentation = window.detail_application.build_selected_flow_presentation(
+            card=card,
+            tracker=window.operation_tracker,
+            flow_states=window.flow_states,
+            run_groups=tuple(run_groups),
+            selected_run_key=window.selected_run_key,
+        )
+        window.selected_run_key = presentation.selected_run_key
+        if presentation.detail_state is None:
+            detail.update(presentation.empty_text)
+            run_list.clear()
+            window._last_run_list_signature = ()
+            return
+        detail_lines = render_selected_flow_lines(card, window.operation_tracker)
+        detail.update("\n".join(detail_lines))
+        signature = presentation.run_group_signature
+        if signature != window._last_run_list_signature:
+            run_list.clear()
+            for run_group in presentation.visible_run_groups:
+                run_list.append(RunGroupListItem(run_group))
+            window._last_run_list_signature = signature
+        else:
+            visible_items = [child for child in run_list.children if isinstance(child, RunGroupListItem)]
+            for item, run_group in zip(visible_items, presentation.visible_run_groups):
+                item.refresh_view(run_group)
+
+    def selected_run_group(self, window: "DataEngineTui") -> "FlowRunState | None":
+        card = window._selected_card()
+        run_groups = self.log_service.runs_for_flow(window.runtime_binding.log_store, card.name) if card is not None else ()
+        presentation = window.detail_application.build_selected_flow_presentation(
+            card=card,
+            tracker=window.operation_tracker,
+            flow_states=window.flow_states,
+            run_groups=tuple(run_groups),
+            selected_run_key=window.selected_run_key,
+        )
+        window.selected_run_key = presentation.selected_run_key
+        return presentation.selected_run_group
+
+
+__all__ = ["TuiFlowController"]

data_engine/ui/tui/controllers/runtime.py

@@ -0,0 +1,167 @@
+"""Runtime/daemon controllers for the terminal UI."""
+
+from __future__ import annotations
+
+import threading
+from typing import TYPE_CHECKING
+
+from textual.css.query import NoMatches
+from textual.widgets import Button, ListView, Select, Static
+
+from data_engine.application import RuntimeApplication
+from data_engine.services import DaemonService, LogService
+from data_engine.domain import RuntimeSessionState, WorkspaceControlState
+from data_engine.views import TuiActionState, WORKSPACE_UNAVAILABLE_TEXT, surface_control_status_text
+from data_engine.ui.tui.widgets import FlowListItem
+
+if TYPE_CHECKING:
+    from data_engine.ui.tui.app import DataEngineTui
+
+
+class TuiRuntimeController:
+    """Own daemon/runtime orchestration for the terminal UI."""
+
+    def __init__(
+        self,
+        *,
+        runtime_application: RuntimeApplication,
+        daemon_service: DaemonService,
+        log_service: LogService,
+    ) -> None:
+        self.runtime_application = runtime_application
+        self.daemon_service = daemon_service
+        self.log_service = log_service
+
+    def refresh_flow_list_items(self, window: "DataEngineTui") -> None:
+        list_view = window.query_one("#flow-list", ListView)
+        for child in list_view.children:
+            if isinstance(child, FlowListItem):
+                child.refresh_view(window.flow_states.get(child.card.name, child.card.state))
+
+    def refresh_buttons(self, window: "DataEngineTui") -> None:
+        action_state = TuiActionState.from_context(
+            window.action_state_application.build_action_context(
+                card=window._selected_card(),
+                flow_states=window.flow_states,
+                runtime_session=window.runtime_session,
+                flow_groups_by_name={card.name: card.group for card in window.flow_cards},
+                active_flow_states=window._ACTIVE_FLOW_STATES,
+                has_logs=bool(
+                    window.selected_flow_name is not None
+                    and self.log_service.entries_for_flow(window.runtime_binding.log_store, window.selected_flow_name)
+                ),
+                has_automated_flows=any(card.valid and card.mode in {"poll", "schedule"} for card in window.flow_cards),
+                workspace_available=window._has_authored_workspace(),
+                selected_run_group_present=window.flow_controller.selected_run_group(window) is not None,
+            )
+        )
+        window.query_one("#refresh", Button).disabled = action_state.refresh_disabled
+        window.query_one("#run-once", Button).disabled = action_state.run_once_disabled
+        window.query_one("#start-engine", Button).disabled = action_state.start_engine_disabled
+        window.query_one("#stop-engine", Button).disabled = action_state.stop_engine_disabled
+        window.query_one("#view-config", Button).disabled = action_state.view_config_disabled
+        window.query_one("#view-log", Button).disabled = action_state.view_log_disabled
+        window.query_one("#clear-flow-log", Button).disabled = action_state.clear_flow_log_disabled
+        window.query_one("#workspace-select", Select).disabled = action_state.workspace_select_disabled
+
+    def sync_daemon_state(self, window: "DataEngineTui") -> None:
+        if not window._has_authored_workspace():
+            window.runtime_session = RuntimeSessionState.empty()
+            window.workspace_control_state = WorkspaceControlState.empty()
+            window.flow_controller.reload_workspace_options(window)
+            window.flow_controller.load_flows(window)
+            try:
+                window.query_one("#control-status", Static).update(WORKSPACE_UNAVAILABLE_TEXT)
+            except NoMatches:
+                return
+            return
+        try:
+            live = self.daemon_service.is_live(window.workspace_paths)
+        except Exception:
+            live = False
+        if not live:
+            self.ensure_daemon_started(window)
+        sync_state = self.runtime_application.sync_state(
+            paths=window.workspace_paths,
+            daemon_manager=window.runtime_binding.daemon_manager,
+            flow_cards=window.flow_cards,
+            runtime_ledger=window.runtime_binding.runtime_ledger,
+            daemon_startup_in_progress=window._daemon_startup_in_progress,
+        )
+        window.runtime_session = sync_state.runtime_session
+        window.workspace_control_state = sync_state.workspace_control_state
+        try:
+            window.query_one("#control-status", Static).update(
+                surface_control_status_text(window.workspace_control_state.control_status_text)
+            )
+        except NoMatches:
+            return
+        self.rebuild_runtime_snapshot(window)
+
+    def ensure_daemon_started(self, window: "DataEngineTui") -> bool:
+        if not window._has_authored_workspace():
+            return False
+        try:
+            if self.daemon_service.is_live(window.workspace_paths):
+                return True
+        except Exception:
+            pass
+        if window._daemon_startup_in_progress:
+            return False
+        now = window._monotonic()
+        if now - window._last_daemon_spawn_attempt < 2.0:
+            return False
+        window._last_daemon_spawn_attempt = now
+        window._daemon_startup_in_progress = True
+        threading.Thread(target=window._start_daemon_worker, daemon=True).start()
+        return False
+
+    def start_daemon_worker(self, window: "DataEngineTui") -> None:
+        success = False
+        error_text = ""
+        spawn_result = self.runtime_application.spawn_daemon(window.workspace_paths)
+        if not spawn_result.ok:
+            error_text = spawn_result.error
+        else:
+            success = self.daemon_service.is_live(window.workspace_paths)
+        if not success and not error_text:
+            error_text = "Daemon startup did not provide any additional error details."
+        window.call_from_thread(window._finish_daemon_startup, success, error_text)
+
+    def finish_daemon_startup(self, window: "DataEngineTui", success: bool, error_text: str) -> None:
+        window._daemon_startup_in_progress = False
+        if success:
+            self.sync_daemon_state(window)
+            return
+        if error_text:
+            window._set_status(error_text)
+        else:
+            window._set_status("Daemon startup did not provide any additional error details.")
+        self.sync_daemon_state(window)
+
+    def rebuild_runtime_snapshot(self, window: "DataEngineTui") -> None:
+        self.log_service.reload(window.runtime_binding.log_store)
+        snapshot = self.runtime_application.build_runtime_snapshot(
+            flow_cards=window.flow_cards,
+            log_entries=self.log_service.all_entries(window.runtime_binding.log_store),
+            runtime_session=window.runtime_session,
+            now=window._monotonic(),
+        )
+        refresh_plan = self.runtime_application.plan_flow_state_refresh(
+            previous_states=window.flow_states,
+            next_states=snapshot.flow_states,
+            runtime_session=window.runtime_session,
+        )
+        window.operation_tracker = snapshot.operation_tracker
+        states_changed = refresh_plan.signature != window._last_rendered_flow_signature
+        window.flow_states = refresh_plan.flow_states
+        if not window.runtime_session.workspace_owned:
+            window._set_status(window.workspace_control_state.blocked_status_text)
+        if states_changed:
+            self.refresh_flow_list_items(window)
+            window._last_rendered_flow_signature = refresh_plan.signature
+        self.refresh_buttons(window)
+        window.flow_controller.render_selected_flow(window)
+
+
+__all__ = ["TuiRuntimeController"]

data_engine/ui/tui/runtime.py

@@ -0,0 +1,34 @@
+"""Runtime/logging helpers for the terminal UI."""
+
+from __future__ import annotations
+
+import logging
+from queue import Queue
+
+from data_engine.domain import FlowLogEntry, format_log_line, parse_runtime_event
+
+
+class QueueLogHandler(logging.Handler):
+    """Logging handler that forwards runtime lines into a queue."""
+
+    def __init__(self, queue: Queue[FlowLogEntry]) -> None:
+        super().__init__(level=logging.INFO)
+        self.queue = queue
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            event = parse_runtime_event(record)
+            kind = "flow" if event is not None and event.flow_name is not None else "system"
+            self.queue.put_nowait(
+                FlowLogEntry(
+                    line=format_log_line(record),
+                    kind=kind,
+                    event=event,
+                    flow_name=event.flow_name if event is not None else None,
+                )
+            )
+        except Exception:
+            self.handleError(record)
+
+
+__all__ = ["QueueLogHandler"]