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

data_engine/ui/gui/presenters/steps.py

@@ -0,0 +1,148 @@
+"""Step-list presentation helpers for the desktop UI."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QTimer
+from PySide6.QtWidgets import QFrame
+
+from data_engine.domain import RuntimeStepEvent
+from data_engine.views.models import default_flow_state
+from data_engine.views.presentation import format_seconds
+
+if TYPE_CHECKING:
+    from data_engine.ui.gui.app import DataEngineWindow
+
+
+def reset_operation_state(window: "DataEngineWindow", flow_name: str) -> None:
+    window.operation_tracker = window.operation_tracker.reset_flow(flow_name, window.flow_cards[flow_name].operation_items)
+    if window.selected_flow_name == flow_name:
+        render_operation_durations(window, flow_name)
+
+
+def apply_runtime_event(window: "DataEngineWindow", event: RuntimeStepEvent) -> None:
+    if event.flow_name not in window.flow_cards:
+        return
+    flow_name = event.flow_name
+    card = window.flow_cards[flow_name]
+    if event.step_name is None:
+        if event.status == "failed":
+            window._set_flow_state(flow_name, "failed")
+        elif event.status in {"started", "success", "stopped"}:
+            if window.runtime_session.runtime_active and flow_name in window.runtime_session.active_runtime_flow_names:
+                window._set_flow_state(
+                    flow_name,
+                    "polling" if card.mode == "poll" else "scheduled" if card.mode == "schedule" else default_flow_state(card.mode),
+                )
+            elif window.flow_states.get(flow_name) == "failed":
+                window._set_flow_state(flow_name, default_flow_state(card.mode))
+        return
+    window.operation_tracker, flash_index = window.operation_tracker.apply_event(
+        flow_name,
+        card.operation_items,
+        event,
+        now=window._monotonic(),
+    )
+    if flash_index is not None and window.selected_flow_name == flow_name:
+        flash_operation_row(window, flash_index)
+    if window.selected_flow_name == flow_name:
+        render_operation_durations(window, flow_name)
+
+
+def render_operation_durations(window: "DataEngineWindow", flow_name: str) -> None:
+    card = window.flow_cards.get(flow_name)
+    state = window.operation_tracker.state_for(flow_name)
+    if card is None or state is None:
+        for row_widgets in window.operation_row_widgets:
+            row_widgets.duration_label.setText("")
+        return
+    for index, operation_name in enumerate(card.operation_items):
+        if index >= len(window.operation_row_widgets):
+            break
+        row_widgets = window.operation_row_widgets[index]
+        row_card = row_widgets.row_card
+        duration_label = row_widgets.duration_label
+        row_state = window.operation_tracker.row_state(flow_name, operation_name)
+        apply_operation_row_state(row_card, row_state.status if row_state is not None else "idle")
+        duration_label.setText(duration_text(window, flow_name, operation_name))
+    window._refresh_operation_buttons(flow_name)
+
+
+def duration_text(window: "DataEngineWindow", flow_name: str, operation_name: str) -> str:
+    return window.operation_tracker.duration_text(flow_name, operation_name, now=window._monotonic(), formatter=format_seconds)
+
+
+def refresh_live_operation_durations(window: "DataEngineWindow") -> None:
+    if window.selected_flow_name is None:
+        return
+    card = window.flow_cards.get(window.selected_flow_name)
+    state = window.operation_tracker.state_for(window.selected_flow_name)
+    if card is None or state is None:
+        return
+    for index, operation_name in enumerate(card.operation_items):
+        if index >= len(window.operation_row_widgets):
+            break
+        row_state = window.operation_tracker.row_state(window.selected_flow_name, operation_name)
+        if row_state is None or row_state.status != "running":
+            continue
+        row_widgets = window.operation_row_widgets[index]
+        row_widgets.duration_label.setText(duration_text(window, window.selected_flow_name, operation_name))
+
+
+def apply_operation_row_state(row_card: QFrame, status: str) -> None:
+    if row_card.property("stepState") == status:
+        return
+    row_card.setProperty("stepState", status)
+    style = row_card.style()
+    style.unpolish(row_card)
+    style.polish(row_card)
+    row_card.update()
+
+
+def flash_operation_row(window: "DataEngineWindow", index: int) -> None:
+    if index >= len(window.operation_row_widgets):
+        return
+    row_card = window.operation_row_widgets[index].row_card
+    row_card.setProperty("flashState", "complete")
+    style = row_card.style()
+    style.unpolish(row_card)
+    style.polish(row_card)
+    row_card.update()
+
+    timer = QTimer(window)
+    timer.setSingleShot(True)
+
+    def clear_flash() -> None:
+        try:
+            row_card.setProperty("flashState", "")
+            style = row_card.style()
+            style.unpolish(row_card)
+            style.polish(row_card)
+            row_card.update()
+        except RuntimeError:
+            pass
+        if timer in window.operation_flash_timers:
+            window.operation_flash_timers.remove(timer)
+
+    timer.timeout.connect(clear_flash)
+    window.operation_flash_timers.append(timer)
+    timer.start(140)
+
+
+def normalize_completed_operation_rows(window: "DataEngineWindow", flow_name: str) -> None:
+    window.operation_tracker = window.operation_tracker.normalize_completed(flow_name)
+    if window.selected_flow_name == flow_name:
+        render_operation_durations(window, flow_name)
+
+
+__all__ = [
+    "apply_runtime_event",
+    "duration_text",
+    "flash_operation_row",
+    "format_seconds",
+    "normalize_completed_operation_rows",
+    "refresh_live_operation_durations",
+    "render_operation_durations",
+    "reset_operation_state",
+]

data_engine/ui/gui/presenters/workspace.py

@@ -0,0 +1,39 @@
+"""Compatibility re-exports for the split workspace presenter helpers."""
+
+from data_engine.ui.gui.presenters.docs import (
+    create_docs_browser,
+    docs_build_dir,
+    finish_docs_build,
+    initialize_docs_view,
+    load_docs_page,
+    run_docs_build_worker,
+    start_docs_build,
+)
+from data_engine.ui.gui.presenters.runtime_projection import (
+    apply_daemon_snapshot,
+    finish_daemon_startup,
+)
+from data_engine.ui.gui.presenters.workspace_binding import rebind_workspace_context
+from data_engine.ui.gui.presenters.workspace_settings import (
+    browse_workspace_collection_root_override,
+    refresh_workspace_root_controls,
+    reset_workspace_collection_root_override,
+    save_workspace_collection_root_override,
+)
+
+__all__ = [
+    "apply_daemon_snapshot",
+    "browse_workspace_collection_root_override",
+    "create_docs_browser",
+    "docs_build_dir",
+    "finish_daemon_startup",
+    "finish_docs_build",
+    "initialize_docs_view",
+    "load_docs_page",
+    "rebind_workspace_context",
+    "refresh_workspace_root_controls",
+    "reset_workspace_collection_root_override",
+    "run_docs_build_worker",
+    "save_workspace_collection_root_override",
+    "start_docs_build",
+]

data_engine/ui/gui/presenters/workspace_binding.py

@@ -0,0 +1,75 @@
+"""Workspace rebinding helpers for the desktop UI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from data_engine.domain import StepOutputIndex, WorkspaceControlState
+from data_engine.ui.gui.helpers import register_client_session
+from data_engine.ui.gui.presenters.workspace_settings import refresh_workspace_root_controls
+
+if TYPE_CHECKING:
+    from data_engine.ui.gui.app import DataEngineWindow
+
+
+def _close_workspace_scoped_dialogs(window: "DataEngineWindow") -> None:
+    for attr_name in ("output_preview_dialog", "config_preview_dialog", "run_log_preview_dialog"):
+        dialog = getattr(window, attr_name, None)
+        if dialog is None:
+            continue
+        try:
+            dialog.close()
+        except Exception:
+            pass
+        setattr(window, attr_name, None)
+
+
+def rebind_workspace_context(
+    window: "DataEngineWindow",
+    *,
+    workspace_id: str | None = None,
+    override_root: Path | None | object = ...,
+) -> None:
+    from data_engine.ui.gui.presenters.docs import initialize_docs_view
+
+    window._message_box_generation += 1
+    window._pending_message_box = None
+    window._message_box_scheduled = False
+    _close_workspace_scoped_dialogs(window)
+
+    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)
+    if override_root is ...:
+        override_root = window.workspace_collection_root_override
+    window.workspace_paths = window._resolve_workspace_paths(
+        workspace_id=workspace_id,
+        workspace_collection_root=override_root,
+    )
+    binding = window.workspace_session_application.bind_workspace(
+        workspace_paths=window.workspace_paths,
+        override_root=override_root,
+    )
+    window._operator_session_state = binding.operator_session
+    window.runtime_binding = window.runtime_binding_service.open_binding(window.workspace_paths)
+    register_client_session(window)
+    window.daemon_status = window.daemon_status.empty()
+    window.workspace_control_state = WorkspaceControlState.empty()
+    window._daemon_startup_in_progress = False
+    window._last_daemon_spawn_attempt = 0.0
+    window.manual_flow_stop_events = {}
+    window.step_output_index = StepOutputIndex.empty()
+    window._reload_workspace_options()
+    refresh_workspace_root_controls(window)
+    window._load_flows()
+    window._refresh_log_view(force_scroll_to_bottom=True)
+    window._refresh_action_buttons()
+    initialize_docs_view(window)
+    if window._auto_daemon_enabled:
+        window._sync_from_daemon()
+
+
+__all__ = ["rebind_workspace_context"]

data_engine/ui/gui/presenters/workspace_settings.py

@@ -0,0 +1,182 @@
+"""Workspace-folder settings presentation helpers for the desktop UI."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+import sys
+from typing import TYPE_CHECKING
+
+from PySide6.QtWidgets import QFileDialog
+
+from data_engine.domain.time import parse_utc_text
+
+if TYPE_CHECKING:
+    from data_engine.ui.gui.app import DataEngineWindow
+
+
+def refresh_workspace_root_controls(window: "DataEngineWindow") -> None:
+    window.workspace_root_input.setText(window.workspace_session_state.root.input_text)
+    window.workspace_root_status_label.setText(window.workspace_session_state.root.status_text)
+    refresh_workspace_provisioning_controls(window)
+    refresh_workspace_visibility_panel(window)
+
+
+def save_workspace_collection_root_override(window: "DataEngineWindow") -> None:
+    from data_engine.ui.gui.presenters.workspace_binding import rebind_workspace_context
+
+    raw_value = window.workspace_root_input.text().strip()
+    if not raw_value:
+        reset_workspace_collection_root_override(window)
+        return
+    target_root = Path(raw_value).expanduser().resolve()
+    window.settings_service.set_workspace_collection_root(target_root)
+    rebind_workspace_context(window, override_root=target_root)
+    window.workspace_root_status_label.setText(f"Workspace folder: {target_root}")
+
+
+def reset_workspace_collection_root_override(window: "DataEngineWindow") -> None:
+    from data_engine.ui.gui.presenters.workspace_binding import rebind_workspace_context
+
+    window.settings_service.set_workspace_collection_root(None)
+    rebind_workspace_context(window, override_root=None)
+    window.workspace_root_status_label.setText(window.workspace_session_state.root.status_text)
+
+
+def browse_workspace_collection_root_override(window: "DataEngineWindow") -> None:
+    current_text = window.workspace_root_input.text().strip()
+    if current_text:
+        start_dir = str(Path(current_text).expanduser())
+    elif window.workspace_paths.workspace_configured:
+        start_dir = str(window.workspace_paths.workspace_collection_root)
+    else:
+        start_dir = str(Path.home())
+    selected = QFileDialog.getExistingDirectory(window, "Select Workspace Folder", start_dir)
+    if selected:
+        window.workspace_root_input.setText(str(Path(selected).expanduser().resolve()))
+        save_workspace_collection_root_override(window)
+
+
+def provision_selected_workspace(window: "DataEngineWindow") -> None:
+    if not window.workspace_paths.workspace_configured:
+        window._show_message_box(
+            title="Workspace Folder Required",
+            text="Choose a workspace folder before provisioning a workspace.",
+            tone="error",
+        )
+        return
+    try:
+        result = window.workspace_provisioning_service.provision_workspace(
+            window.workspace_paths,
+            interpreter_path=Path(sys.executable).expanduser(),
+        )
+    except Exception as exc:
+        window.workspace_provision_status_label.setText(f"Provisioning failed: {exc}")
+        window._show_message_box(
+            title="Provisioning Failed",
+            text=str(exc),
+            tone="error",
+        )
+        return
+    created_names = ", ".join(path.name for path in result.created_paths) if result.created_paths else "nothing new"
+    window._rebind_workspace_context(workspace_id=window.workspace_paths.workspace_id)
+    window.workspace_provision_status_label.setText(
+        f"Provisioned {result.workspace_root.name}: created {created_names}."
+    )
+
+
+def force_shutdown_daemon(window: "DataEngineWindow") -> None:
+    result = window.runtime_application.force_shutdown_daemon(window.workspace_paths, timeout=0.5)
+    if not result.ok:
+        window.force_shutdown_daemon_status_label.setText(f"Force stop failed: {result.error}")
+        window._show_message_box(
+            title="Force Stop Failed",
+            text=result.error,
+            tone="error",
+        )
+        return
+    window.force_shutdown_daemon_status_label.setText(
+        "Local daemon force-stopped. Any active engine or manual runs were terminated."
+    )
+    window._sync_from_daemon()
+
+
+def refresh_workspace_provisioning_controls(window: "DataEngineWindow") -> None:
+    if not window.workspace_paths.workspace_configured:
+        window.workspace_target_label.setText("Selected workspace: choose a workspace folder first.")
+        window.provision_workspace_button.setEnabled(False)
+        if not window.workspace_provision_status_label.text().strip():
+            window.workspace_provision_status_label.setText(
+                "Provisioning creates a workspace folder, flow_modules, and VS Code settings without overwriting existing files."
+            )
+        return
+    workspace_root = window.workspace_paths.workspace_root
+    workspace_ready = window.workspace_paths.flow_modules_dir.is_dir()
+    window.workspace_target_label.setText(f"Selected workspace: {workspace_root}")
+    window.provision_workspace_button.setEnabled(True)
+    if workspace_ready:
+        window.workspace_provision_status_label.setText(
+            "Workspace already has flow modules. Provisioning will only add missing folders or VS Code settings."
+        )
+    else:
+        window.workspace_provision_status_label.setText(
+            "Provision the selected workspace to create flow_modules and local VS Code settings."
+        )
+
+
+def refresh_workspace_visibility_panel(window: "DataEngineWindow") -> None:
+    interpreter_path = Path(sys.executable).expanduser()
+    interpreter_mode = "virtual environment" if sys.prefix != getattr(sys, "base_prefix", sys.prefix) else "system/global"
+    window.force_shutdown_daemon_button.setEnabled(window.workspace_paths.workspace_configured)
+    if not window.force_shutdown_daemon_status_label.text().strip():
+        window.force_shutdown_daemon_status_label.setText(
+            "Use only when normal stop does not return control."
+        )
+    window.visibility_interpreter_value.setText(str(interpreter_path))
+    window.visibility_interpreter_mode_value.setText(interpreter_mode.title())
+    window.workspace_counts_footer_label.setText(_workspace_counts_footer_text(window))
+
+
+def _workspace_module_count(flow_modules_dir: Path) -> int:
+    if not flow_modules_dir.is_dir():
+        return 0
+    return sum(
+        1
+        for path in flow_modules_dir.iterdir()
+        if path.is_file() and path.suffix in {".py", ".ipynb"} and path.name != "__init__.py"
+    )
+
+
+def _workspace_counts_footer_text(window: "DataEngineWindow") -> str:
+    cards = tuple(window.flow_cards.values())
+    module_count = _workspace_module_count(window.workspace_paths.flow_modules_dir)
+    group_count = len({card.group for card in cards})
+    flow_count = len(cards)
+    recent_runs_count = _recent_workspace_run_count(window, days=30)
+    return f"{module_count} modules - {group_count} groups - {flow_count} flows - {recent_runs_count} runs last 30 days"
+
+
+def _recent_workspace_run_count(window: "DataEngineWindow", *, days: int) -> int:
+    cutoff = datetime.now(UTC) - timedelta(days=days)
+    count = 0
+    try:
+        runs = window.runtime_binding.runtime_ledger.list_runs()
+    except Exception:
+        return 0
+    for run in runs:
+        started_at = parse_utc_text(run.started_at_utc)
+        if started_at is not None and started_at >= cutoff:
+            count += 1
+    return count
+
+
+__all__ = [
+    "browse_workspace_collection_root_override",
+    "force_shutdown_daemon",
+    "provision_selected_workspace",
+    "refresh_workspace_provisioning_controls",
+    "refresh_workspace_visibility_panel",
+    "refresh_workspace_root_controls",
+    "reset_workspace_collection_root_override",
+    "save_workspace_collection_root_override",
+]

data_engine/ui/gui/preview_models.py

@@ -0,0 +1,37 @@
+"""Explicit request/state models for GUI preview dialogs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from data_engine.domain import ConfigPreviewState, FlowRunState, RunDetailState
+
+
+@dataclass(frozen=True)
+class OutputPreviewRequest:
+    """Request state for one output-preview dialog."""
+
+    operation_name: str
+    output_path: Path
+
+
+@dataclass(frozen=True)
+class RunLogPreviewRequest:
+    """Request state for one run-log preview dialog."""
+
+    run_group: FlowRunState
+    detail: RunDetailState
+
+    @classmethod
+    def from_run(cls, run_group: FlowRunState) -> "RunLogPreviewRequest":
+        """Build one run-log preview request from a grouped run."""
+        return cls(run_group=run_group, detail=RunDetailState.from_run(run_group))
+
+
+@dataclass(frozen=True)
+class ConfigPreviewRequest:
+    """Request state for one config-preview dialog."""
+
+    preview: ConfigPreviewState
+