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

data_engine/ui/gui/bootstrapper.py

@@ -0,0 +1,140 @@
+"""Bootstrap helpers for the desktop GUI application shell."""
+
+from __future__ import annotations
+
+import logging
+import os
+import threading
+from pathlib import Path
+from queue import Queue
+from uuid import uuid4
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QTimer
+from PySide6.QtGui import QGuiApplication
+
+from data_engine.domain import DaemonStatusState, FlowLogEntry, OperationSessionState, OperatorSessionState, StepOutputIndex
+from data_engine.platform.identity import APP_DISPLAY_NAME, APP_INTERNAL_ID
+from data_engine.platform.workspace_models import DATA_ENGINE_WORKSPACE_COLLECTION_ROOT_ENV_VAR
+from data_engine.ui.gui.bootstrap import GuiServices
+from data_engine.ui.gui.controllers import GuiFlowController, GuiRuntimeController
+from data_engine.ui.gui.helpers import register_client_session as helper_register_client_session
+from data_engine.ui.gui.runtime import QueueLogHandler, UiSignals
+from data_engine.ui.gui.surface import build_default_gui_services
+
+if TYPE_CHECKING:
+    from data_engine.ui.gui.app import DataEngineWindow
+
+
+def bootstrap_gui_window(window: "DataEngineWindow", *, theme_name: str, services: GuiServices | None = None) -> None:
+    """Bind one GUI window to its services, runtime state, and timers."""
+    window.setWindowTitle(APP_DISPLAY_NAME)
+    window.resize(1480, 920)
+    window.setMinimumSize(1180, 760)
+    window.services = services or build_default_gui_services(theme_name)
+    window.workspace_service = window.services.workspace_service
+    window.action_state_application = window.services.action_state_application
+    window.detail_application = window.services.detail_application
+    window.daemon_service = window.services.daemon_service
+    window.daemon_state_service = window.services.daemon_state_service
+    window.runtime_application = window.services.runtime_application
+    window.control_application = window.services.control_application
+    window.ledger_service = window.services.ledger_service
+    window.log_service = window.services.log_service
+    window.runtime_binding_service = window.services.runtime_binding_service
+    window.runtime_history_service = window.services.runtime_history_service
+    window.shared_state_service = window.services.shared_state_service
+    window.settings_service = window.services.settings_service
+    window.theme_service = window.services.theme_service
+    window.workspace_provisioning_service = window.services.workspace_provisioning_service
+    window.workspace_session_application = window.services.workspace_session_application
+    window.flow_catalog_application = window.services.flow_catalog_application
+    window.flow_controller = GuiFlowController(
+        workspace_session_application=window.workspace_session_application,
+        flow_catalog_application=window.flow_catalog_application,
+        log_service=window.log_service,
+    )
+    window.runtime_controller = GuiRuntimeController(
+        runtime_application=window.runtime_application,
+        daemon_service=window.daemon_service,
+        log_service=window.log_service,
+    )
+    window.theme_name = window.theme_service.resolve_name(theme_name)
+    env_collection_root = os.environ.get(DATA_ENGINE_WORKSPACE_COLLECTION_ROOT_ENV_VAR)
+    initial_override = None if env_collection_root and env_collection_root.strip() else window.settings_service.workspace_collection_root()
+    window.workspace_paths = window.workspace_service.resolve_paths(
+        workspace_collection_root=initial_override,
+    )
+    window._operator_session_state = OperatorSessionState.from_paths(window.workspace_paths, override_root=initial_override)
+    window.workspace_session_state = window.workspace_session_application.refresh_session(
+        workspace_paths=window.workspace_paths,
+        override_root=initial_override,
+    )
+    window.client_session_id = uuid4().hex
+
+    window.log_queue: Queue[FlowLogEntry] = Queue()
+    window.log_handler = QueueLogHandler(window.log_queue)
+    logger = logging.getLogger(APP_INTERNAL_ID)
+    logger.addHandler(window.log_handler)
+    logger.setLevel(logging.INFO)
+
+    window.signals = UiSignals()
+    window.signals.run_finished.connect(window._finish_run)
+    window.signals.runtime_finished.connect(window._finish_runtime)
+    window.signals.docs_build_finished.connect(window._finish_docs_build)
+    window.signals.daemon_startup_finished.connect(window._finish_daemon_startup)
+
+    window.engine_runtime_stop_event = threading.Event()
+    window.engine_flow_stop_event = threading.Event()
+    window.manual_flow_stop_events: dict[str, threading.Event] = {}
+    window.operation_row_widgets = []
+    window.operation_tracker = OperationSessionState.empty()
+    window.operation_flash_timers: list[QTimer] = []
+    window.sidebar_flow_widgets: dict[str, QFrame] = {}
+    window.sidebar_group_widgets: dict[str, QFrame] = {}
+    window.step_output_index = StepOutputIndex.empty()
+    window.runtime_binding = window.runtime_binding_service.open_binding(window.workspace_paths)
+    helper_register_client_session(window)
+    window.output_preview_dialog = None
+    window.config_preview_dialog = None
+    window.run_log_preview_dialog = None
+    window._docs_root_dir = None
+    window.docs_uses_webengine = False
+    window._docs_build_running = False
+    window.ui_closing = False
+    window._log_view_refresh_pending = False
+    window._action_buttons_refresh_pending = False
+    window._worker_threads: set[threading.Thread] = set()
+    window._worker_threads_lock = threading.RLock()
+    window._daemon_status = DaemonStatusState.empty()
+    window._last_daemon_spawn_attempt = 0.0
+    window._auto_daemon_enabled = False
+    window._daemon_startup_in_progress = False
+    window._pending_message_box: tuple[str, str, str] | None = None
+    window._message_box_scheduled = False
+    window._message_box_open = False
+    window._message_box_generation = 0
+    window._workspace_switch_generation = 0
+
+    window._build_window()
+    window._reload_workspace_options()
+    window._load_flows()
+    style_hints = QGuiApplication.styleHints()
+    if hasattr(style_hints, "colorSchemeChanged"):
+        style_hints.colorSchemeChanged.connect(window._sync_theme_to_system)
+
+    window.log_timer = QTimer(window)
+    window.log_timer.timeout.connect(window._poll_log_queue)
+    window.log_timer.start(50)
+    window.ui_refresh_timer = QTimer(window)
+    window.ui_refresh_timer.setSingleShot(True)
+    window.ui_refresh_timer.timeout.connect(window._flush_deferred_ui_updates)
+    window.operation_timer = QTimer(window)
+    window.operation_timer.timeout.connect(window._refresh_live_operation_durations)
+    window.operation_timer.start(100)
+    window.daemon_timer = QTimer(window)
+    window.daemon_timer.timeout.connect(window._sync_from_daemon)
+    window.daemon_timer.start(500)
+
+
+__all__ = ["bootstrap_gui_window"]

data_engine/ui/gui/cache_models.py

@@ -0,0 +1,23 @@
+"""Explicit GUI-local cache models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QFrame, QLabel, QPushButton
+
+
+@dataclass(frozen=True)
+class OperationRowWidgets:
+    """Cached widget references for one operation row."""
+
+    row_card: "QFrame"
+    title_label: "QLabel"
+    duration_label: "QLabel"
+    inspect_button: "QPushButton | None"
+    operation_name: str
+
+
+__all__ = ["OperationRowWidgets"]

data_engine/ui/gui/control_support.py

@@ -0,0 +1,185 @@
+"""Flow, runtime, and log coordination helpers for the GUI shell."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from data_engine.domain import FlowLogEntry, FlowRunState, RuntimeStepEvent
+from data_engine.ui.gui.dialogs import show_run_log_preview
+from data_engine.ui.gui.preview_models import RunLogPreviewRequest
+from data_engine.ui.gui.presenters import (
+    add_log_run_item as present_add_log_run_item,
+    apply_daemon_snapshot as present_apply_daemon_snapshot,
+    finish_daemon_startup as present_finish_daemon_startup,
+    refresh_log_view as present_refresh_log_view,
+)
+
+if TYPE_CHECKING:
+    from data_engine.ui.gui.app import DataEngineWindow
+
+
+class GuiControlMixin:
+    """Shell coordination helpers for flows, runtime, daemon, and log refresh."""
+
+    def _load_flows(self: "DataEngineWindow") -> None:
+        self.flow_controller.load_flows(self)
+
+    def _populate_flow_tree(self: "DataEngineWindow") -> None:
+        self.flow_controller.populate_flow_tree(self)
+
+    def _select_flow(self: "DataEngineWindow", flow_name: str | None) -> None:
+        self.flow_controller.select_flow(self, flow_name)
+
+    def _refresh_selection(self: "DataEngineWindow", card) -> None:
+        self.flow_controller.refresh_selection(self, card)
+
+    def _refresh_summary(self: "DataEngineWindow") -> None:
+        self.flow_controller.refresh_summary(self)
+
+    def _refresh_action_buttons(self: "DataEngineWindow") -> None:
+        self.flow_controller.refresh_action_buttons(self)
+
+    def _reload_workspace_options(self: "DataEngineWindow") -> None:
+        self.flow_controller.reload_workspace_options(self)
+
+    def _workspace_selection_changed(self: "DataEngineWindow", index: int) -> None:
+        self.flow_controller.workspace_selection_changed(self, index)
+
+    def _switch_workspace(self: "DataEngineWindow", workspace_id: str) -> None:
+        self.flow_controller.switch_workspace(self, workspace_id)
+
+    def _refresh_lease_status(self: "DataEngineWindow") -> None:
+        self.flow_controller.refresh_lease_status(self)
+
+    def _request_control(self: "DataEngineWindow") -> None:
+        self.flow_controller.request_control(self)
+
+    def _update_engine_button(self: "DataEngineWindow") -> None:
+        self.flow_controller.update_engine_button(self)
+
+    def _set_flow_state(self: "DataEngineWindow", flow_name: str, state: str) -> None:
+        self.flow_controller.set_flow_state(self, flow_name, state)
+
+    def _set_flow_states(self: "DataEngineWindow", updates: dict[str, str]) -> None:
+        self.flow_controller.set_flow_states(self, updates)
+
+    def _sync_from_daemon(self: "DataEngineWindow") -> None:
+        self.runtime_controller.sync_from_daemon(self)
+
+    def _ensure_daemon_started(self: "DataEngineWindow") -> bool:
+        return self.runtime_controller.ensure_daemon_started(self)
+
+    def _start_daemon_worker(self: "DataEngineWindow") -> None:
+        self.runtime_controller.start_daemon_worker(self)
+
+    def _finish_daemon_startup(self: "DataEngineWindow", success: bool, error_text: str) -> None:
+        present_finish_daemon_startup(self, success, error_text)
+
+    def _apply_daemon_snapshot(self: "DataEngineWindow", snapshot) -> None:
+        present_apply_daemon_snapshot(self, snapshot)
+
+    def _rebuild_runtime_snapshot(self: "DataEngineWindow") -> None:
+        self.runtime_controller.rebuild_runtime_snapshot(self)
+
+    def _refresh_log_view(self: "DataEngineWindow", *, force_scroll_to_bottom: bool = False) -> None:
+        present_refresh_log_view(self, force_scroll_to_bottom=force_scroll_to_bottom)
+
+    def _add_log_run_item(self: "DataEngineWindow", run_group: FlowRunState) -> None:
+        present_add_log_run_item(self, run_group)
+
+    def _refresh_flows_requested(self: "DataEngineWindow") -> None:
+        self.flow_controller.refresh_flows_requested(self)
+
+    def _clear_logs(self: "DataEngineWindow") -> None:
+        self.flow_controller.clear_logs(self)
+
+    def _poll_log_queue(self: "DataEngineWindow") -> None:
+        from data_engine.ui.gui.surface import poll_log_queue as surface_poll_log_queue
+
+        surface_poll_log_queue(self)
+
+    def _show_run_log_preview(self: "DataEngineWindow", run_group: FlowRunState) -> None:
+        self.run_log_preview_dialog = show_run_log_preview(self, RunLogPreviewRequest.from_run(run_group))
+
+    def _show_run_error_details(self: "DataEngineWindow", run_group: FlowRunState, entry: FlowLogEntry) -> None:
+        """Show persisted failure detail for one failed run or step entry."""
+        event = entry.event
+        title, detail_text = self.runtime_history_service.error_text_for_entry(
+            self.runtime_binding.runtime_ledger,
+            run_group,
+            entry,
+        )
+        if event is not None and event.step_name is not None:
+            fallback_text = (
+                f'No persisted error detail was available for failed step "{event.step_name}" '
+                f'in run "{run_group.key[0]}".'
+            )
+        else:
+            fallback_text = f'No persisted error detail was available for failed run "{run_group.key[0]}".'
+        self._show_message_box(
+            title=title,
+            text=detail_text.strip() if isinstance(detail_text, str) and detail_text.strip() else fallback_text,
+            tone="error",
+        )
+
+    def _run_selected_flow(self: "DataEngineWindow") -> None:
+        if not self._has_authored_workspace():
+            self._sync_from_daemon()
+            return
+        card = self.flow_cards.get(self.selected_flow_name or "")
+        result = self.control_application.run_selected_flow(
+            paths=self.workspace_paths,
+            runtime_session=self.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 self._is_group_active(card.group)),
+            blocked_status_text=self.workspace_control_state.blocked_status_text,
+            timeout=2.0,
+        )
+        if result.error_text is not None:
+            self._show_message_box_later(
+                title="Data Engine",
+                text=result.error_text,
+                tone="error",
+            )
+            return
+        if not result.requested or card is None:
+            return
+        self._append_log_line(f"Starting one-time flow run: {card.name}", flow_name=card.name)
+        if result.sync_after:
+            self._sync_from_daemon()
+
+    def _start_runtime(self: "DataEngineWindow") -> None:
+        self.runtime_controller.start_runtime(self)
+
+    def _stop_runtime(self: "DataEngineWindow") -> None:
+        self.runtime_controller.stop_runtime(self)
+
+    def _toggle_runtime(self: "DataEngineWindow") -> None:
+        self.runtime_controller.toggle_runtime(self)
+
+    def _stop_pipeline(self: "DataEngineWindow") -> None:
+        self.runtime_controller.stop_pipeline(self)
+
+    def _safe_emit_run_finished(self: "DataEngineWindow", flow_name: str, results: object, error: object) -> None:
+        from data_engine.ui.gui.surface import safe_emit_run_finished as surface_safe_emit_run_finished
+
+        surface_safe_emit_run_finished(self, flow_name, results, error)
+
+    def _safe_emit_runtime_finished(self: "DataEngineWindow", flow_names: tuple[str, ...], results: object, error: object) -> None:
+        from data_engine.ui.gui.surface import safe_emit_runtime_finished as surface_safe_emit_runtime_finished
+
+        surface_safe_emit_runtime_finished(self, flow_names, results, error)
+
+    def _finish_run(self: "DataEngineWindow", flow_name: object, results: object, error: object) -> None:
+        self.runtime_controller.finish_run(self, flow_name, results, error)
+
+    def _finish_runtime(self: "DataEngineWindow", flow_names: object, results: object, error: object) -> None:
+        self.runtime_controller.finish_runtime(self, flow_names, results, error)
+
+    def _is_group_active(self: "DataEngineWindow", group_name: str) -> bool:
+        return self.runtime_controller.is_group_active(self, group_name)
+
+
+__all__ = ["GuiControlMixin"]

data_engine/ui/gui/controllers/__init__.py

@@ -0,0 +1,6 @@
+"""Controller objects for the desktop GUI surface."""
+
+from data_engine.ui.gui.controllers.flows import GuiFlowController
+from data_engine.ui.gui.controllers.runtime import GuiRuntimeController
+
+__all__ = ["GuiFlowController", "GuiRuntimeController"]