experimaestro 2.0.0b8__py3-none-any.whl → 2.0.0b17__py3-none-any.whl

experimaestro/tui/app.tcss

@@ -10,6 +10,10 @@ ExperimentsList {
     height: auto;
 }
 
+ExperimentsList.expanded {
+    height: 1fr;
+}
+
 Monitor {
     height: 100%;
 }
@@ -92,6 +96,10 @@ JobsTable {
     min-height: 5;
 }
 
+ExperimentsList.expanded #experiments-table {
+    height: 1fr;
+}
+
 TabbedContent {
     height: 100%;
 }
@@ -115,6 +123,8 @@ JobDetailView {
 
 #job-detail-content {
     padding: 1;
+    overflow-y: auto;
+    height: 1fr;
 }
 
 #job-detail-content Label {
@@ -351,3 +361,155 @@ HelpScreen {
     width: 100%;
     height: auto;
 }
+
+/* Past run banner */
+#past-run-banner {
+    background: $warning-darken-2;
+    color: $text;
+    padding: 0 1;
+    text-align: center;
+    text-style: bold;
+    height: auto;
+}
+
+/* Runs List */
+RunsList {
+    height: 1fr;
+    width: 100%;
+    display: none;
+}
+
+RunsList.hidden {
+    display: none;
+}
+
+#runs-container {
+    height: 100%;
+    width: 100%;
+    border: solid $primary;
+    padding: 0 1;
+}
+
+#runs-title {
+    text-style: bold;
+    color: $primary;
+    height: auto;
+}
+
+#runs-table {
+    height: 1fr;
+    min-height: 3;
+}
+
+/* Stray Jobs Tab */
+StrayJobsTab {
+    height: 100%;
+    width: 100%;
+    padding: 1;
+}
+
+#stray-title {
+    text-align: center;
+    text-style: bold;
+    margin-bottom: 1;
+    color: $warning;
+}
+
+#stray-warning {
+    background: $warning-darken-2;
+    color: $text;
+    padding: 0 1;
+    margin-bottom: 1;
+    text-align: center;
+    height: auto;
+}
+
+#stray-warning.hidden {
+    display: none;
+}
+
+.warning-banner {
+    height: auto;
+}
+
+#stray-stats {
+    margin-bottom: 1;
+}
+
+#stray-controls {
+    height: auto;
+    margin-bottom: 1;
+    align: left middle;
+}
+
+#stray-controls Button {
+    margin-right: 1;
+}
+
+#stray-controls Switch {
+    margin-right: 0;
+}
+
+#show-orphans-label {
+    margin-right: 2;
+}
+
+.controls-bar {
+    height: auto;
+}
+
+#stray-table {
+    height: 1fr;
+}
+
+#stray-job-info {
+    height: auto;
+    margin-top: 1;
+    padding: 0 1;
+    color: $text-muted;
+}
+
+/* Orphan Jobs Tab */
+OrphanJobsTab {
+    height: 1fr;
+    width: 100%;
+    padding: 1;
+}
+
+OrphanJobsTab #orphan-warning {
+    background: $warning-darken-2;
+    color: $text;
+    padding: 0 1;
+    margin-bottom: 1;
+    text-align: center;
+    height: auto;
+}
+
+OrphanJobsTab #orphan-warning.hidden {
+    display: none;
+}
+
+OrphanJobsTab #orphan-controls {
+    height: auto;
+    margin-bottom: 1;
+    align: left middle;
+}
+
+OrphanJobsTab #orphan-controls Button {
+    margin-right: 1;
+    min-width: 8;
+    height: auto;
+    padding: 0 1;
+}
+
+OrphanJobsTab #orphan-table {
+    height: 1fr;
+    min-height: 10;
+}
+
+OrphanJobsTab #orphan-job-info {
+    height: auto;
+    margin-top: 1;
+    padding: 0 1;
+    color: $text-muted;
+}

experimaestro/tui/dialogs.py

@@ -0,0 +1,172 @@
+"""Modal dialog screens for the TUI"""
+
+from typing import Optional
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.widgets import Button, Static
+from textual.screen import ModalScreen
+from textual.binding import Binding
+
+
+class QuitConfirmScreen(ModalScreen[bool]):
+    """Modal screen for quit confirmation"""
+
+    def __init__(self, has_active_experiment: bool = False):
+        super().__init__()
+        self.has_active_experiment = has_active_experiment
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="quit-dialog"):
+            yield Static("Quit Experimaestro?", id="quit-title")
+
+            if self.has_active_experiment:
+                yield Static(
+                    "⚠️  The experiment is still in progress.\nQuitting will prevent new jobs from being launched.",
+                    id="quit-warning",
+                )
+            else:
+                yield Static("Are you sure you want to quit?", id="quit-message")
+
+            with Horizontal(id="quit-buttons"):
+                yield Button("Quit", variant="error", id="quit-yes")
+                yield Button("Cancel", variant="primary", id="quit-no")
+
+    def on_mount(self) -> None:
+        """Focus Cancel button by default"""
+        self.query_one("#quit-no", Button).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "quit-yes":
+            self.dismiss(True)
+        else:
+            self.dismiss(False)
+
+
+class DeleteConfirmScreen(ModalScreen[bool]):
+    """Modal screen for delete confirmation"""
+
+    def __init__(
+        self, item_type: str, item_name: str, warning: Optional[str] = None
+    ) -> None:
+        super().__init__()
+        self.item_type = item_type
+        self.item_name = item_name
+        self.warning = warning
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="delete-dialog"):
+            yield Static(f"Delete {self.item_type}?", id="delete-title")
+            yield Static(
+                f"This will permanently delete: {self.item_name}", id="delete-message"
+            )
+
+            if self.warning:
+                yield Static(f"Warning: {self.warning}", id="delete-warning")
+
+            with Horizontal(id="delete-buttons"):
+                yield Button("Delete", variant="error", id="delete-yes")
+                yield Button("Cancel", variant="primary", id="delete-no")
+
+    def on_mount(self) -> None:
+        """Focus cancel button by default"""
+        self.query_one("#delete-no", Button).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "delete-yes":
+            self.dismiss(True)
+        else:
+            self.dismiss(False)
+
+
+class KillConfirmScreen(ModalScreen[bool]):
+    """Modal screen for kill confirmation"""
+
+    def __init__(self, item_type: str, item_name: str) -> None:
+        super().__init__()
+        self.item_type = item_type
+        self.item_name = item_name
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="kill-dialog"):
+            yield Static(f"Kill {self.item_type}?", id="kill-title")
+            yield Static(f"This will terminate: {self.item_name}", id="kill-message")
+
+            with Horizontal(id="kill-buttons"):
+                yield Button("Kill", variant="warning", id="kill-yes")
+                yield Button("Cancel", variant="primary", id="kill-no")
+
+    def on_mount(self) -> None:
+        """Focus cancel button by default"""
+        self.query_one("#kill-no", Button).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "kill-yes":
+            self.dismiss(True)
+        else:
+            self.dismiss(False)
+
+
+class HelpScreen(ModalScreen[None]):
+    """Modal screen showing keyboard shortcuts"""
+
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+        Binding("?", "close", "Close"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        help_text = """
+[bold]Keyboard Shortcuts[/bold]
+
+[bold cyan]Navigation[/bold cyan]
+  q         Quit application
+  Esc       Go back / Close dialog
+  r         Refresh data
+  ?         Show this help
+  j         Switch to Jobs tab
+  s         Switch to Services tab
+
+[bold cyan]Experiments[/bold cyan]
+  Enter     Select experiment
+  d         Delete experiment
+  k         Kill all running jobs
+
+[bold cyan]Jobs[/bold cyan]
+  l         View job logs
+  d         Delete job
+  k         Kill running job
+  /         Open search filter
+  c         Clear search filter
+  S         Sort by status
+  T         Sort by task
+  D         Sort by date
+  f         Copy folder path
+
+[bold cyan]Services[/bold cyan]
+  s         Start service
+  x         Stop service
+  u         Copy URL
+
+[bold cyan]Search Filter[/bold cyan]
+  Enter     Apply filter
+  Esc       Close and clear filter
+
+[bold cyan]Orphan Jobs[/bold cyan]
+  o         Show orphan jobs
+  T         Sort by task
+  Z         Sort by size
+  d         Delete selected
+  D         Delete all
+  f         Copy folder path
+"""
+        with Vertical(id="help-dialog"):
+            yield Static("Experimaestro Help", id="help-title")
+            with VerticalScroll(id="help-scroll"):
+                yield Static(help_text, id="help-content")
+            yield Button("Close", id="help-close-btn")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss()
+
+    def action_close(self) -> None:
+        self.dismiss()

experimaestro/tui/log_viewer.py

@@ -1,6 +1,7 @@
 """Log viewer screen for viewing job logs efficiently"""
 
 from pathlib import Path
+from typing import Callable, Optional
 
 from textual.app import ComposeResult
 from textual.binding import Binding
@@ -8,6 +9,8 @@ from textual.containers import Vertical
 from textual.screen import Screen
 from textual.widgets import Footer, Header, RichLog, Static, TabbedContent, TabPane
 
+from experimaestro.scheduler.interfaces import JobState
+
 
 # Default chunk size for reading file (64KB)
 CHUNK_SIZE = 64 * 1024
@@ -129,7 +132,12 @@ class LogWidget(Vertical):
 
 
 class LogViewerScreen(Screen, inherit_bindings=False):
-    """Screen for viewing job logs efficiently"""
+    """Screen for viewing job logs efficiently
+
+    Supports both local and remote log viewing:
+    - Local: reads log files directly
+    - Remote: uses adaptive sync to periodically rsync logs from remote
+    """
 
     CSS = """
     LogViewerScreen {
@@ -144,6 +152,21 @@ class LogViewerScreen(Screen, inherit_bindings=False):
         color: $text-muted;
     }
 
+    .loading-message {
+        content-align: center middle;
+        height: 100%;
+        text-style: italic;
+        color: $text-muted;
+    }
+
+    .sync-status {
+        background: $boost;
+        padding: 0 1;
+        height: auto;
+        text-style: italic;
+        color: $text-muted;
+    }
+
     LogWidget {
         height: 1fr;
     }
@@ -158,21 +181,53 @@ class LogViewerScreen(Screen, inherit_bindings=False):
         Binding("f", "toggle_follow", "Follow"),
         Binding("g", "go_to_top", "Top"),
         Binding("G", "go_to_bottom", "Bottom"),
+        Binding("r", "sync_now", "Sync", show=False),
         Binding("escape", "close_viewer", "Back", priority=True),
         Binding("q", "close_viewer", "Quit", priority=True),
     ]
 
-    def __init__(self, log_files: list[str], job_id: str):
+    def __init__(
+        self,
+        log_files: list[str],
+        job_id: str,
+        sync_func: Optional[Callable[[str], Optional[Path]]] = None,
+        remote_path: Optional[str] = None,
+        task_id: Optional[str] = None,
+        job_state: Optional[JobState] = None,
+    ):
+        """Initialize the log viewer
+
+        Args:
+            log_files: List of local log file paths
+            job_id: Job identifier
+            sync_func: Function to sync remote path (for remote monitoring)
+            remote_path: Remote job directory path (for remote monitoring)
+            task_id: Task ID for log file naming (for remote monitoring)
+            job_state: Current job state (for adaptive sync decisions)
+        """
         super().__init__()
         self.log_files = log_files
         self.job_id = job_id
         self.following = True
         self.log_widgets: list[LogWidget] = []
 
+        # Remote sync support
+        self.sync_func = sync_func
+        self.remote_path = remote_path
+        self.task_id = task_id
+        self.job_state = job_state
+        self._synchronizer = None
+        self._loading = bool(sync_func and not log_files)
+
     def compose(self) -> ComposeResult:
         yield Header()
 
-        if len(self.log_files) == 1:
+        if self._loading:
+            # Show loading message while waiting for first sync
+            yield Static(
+                "Syncing logs from remote...", id="loading", classes="loading-message"
+            )
+        elif len(self.log_files) == 1:
             # Single file - simple view
             widget = LogWidget(self.log_files[0], "log-0")
             self.log_widgets.append(widget)
@@ -187,12 +242,183 @@ class LogViewerScreen(Screen, inherit_bindings=False):
                         self.log_widgets.append(widget)
                         yield widget
 
+        # Sync status for remote monitoring
+        if self.sync_func:
+            yield Static("", id="sync-status", classes="sync-status")
+
         yield Footer()
 
     def on_mount(self) -> None:
         """Start watching for changes"""
         self.set_interval(0.5, self._refresh_logs)
 
+        # Start adaptive sync for remote monitoring
+        if self.sync_func and self.remote_path:
+            self._start_adaptive_sync()
+
+    def _start_adaptive_sync(self) -> None:
+        """Start adaptive sync for remote log files"""
+        import logging
+
+        from experimaestro.scheduler.remote.adaptive_sync import AdaptiveSynchronizer
+
+        logger = logging.getLogger("xpm.tui.log_viewer")
+
+        # Only use adaptive sync for running jobs
+        is_running = self.job_state and self.job_state.running()
+        logger.info(
+            f"Starting sync: job_state={self.job_state}, "
+            f"is_running={is_running}, remote_path={self.remote_path}"
+        )
+
+        # Update loading message to show we're syncing
+        try:
+            loading = self.query_one("#loading", Static)
+            loading.update("Syncing logs from remote (this may take a moment)...")
+        except Exception:
+            pass
+
+        if is_running:
+            # Build a name for logging
+            sync_name = f"job:{self.task_id}" if self.task_id else f"job:{self.job_id}"
+            self._synchronizer = AdaptiveSynchronizer(
+                sync_func=self.sync_func,
+                remote_path=self.remote_path,
+                name=sync_name,
+                on_sync_start=lambda: self.app.call_from_thread(self._on_sync_start),
+                on_sync_complete=lambda p: self.app.call_from_thread(
+                    self._on_sync_complete, p
+                ),
+                on_sync_error=lambda e: self.app.call_from_thread(
+                    self._on_sync_error, e
+                ),
+            )
+            self._synchronizer.start()
+        else:
+            # For completed jobs, just sync once
+            self._do_single_sync()
+
+    def _do_single_sync(self) -> None:
+        """Do a single sync for completed jobs"""
+        import threading
+
+        def sync_thread():
+            try:
+                local_path = self.sync_func(self.remote_path)
+                if local_path:
+                    self.app.call_from_thread(self._on_sync_complete, local_path)
+                else:
+                    self.app.call_from_thread(self._on_sync_error, "Sync failed")
+            except Exception as e:
+                self.app.call_from_thread(self._on_sync_error, str(e))
+
+        thread = threading.Thread(target=sync_thread, daemon=True)
+        thread.start()
+
+    def _on_sync_start(self) -> None:
+        """Handle sync start - update status"""
+        try:
+            status = self.query_one("#sync-status", Static)
+            status.update("⟳ Syncing...")
+        except Exception:
+            pass
+
+    def _on_sync_complete(self, local_path) -> None:
+        """Handle sync completion - update log widgets"""
+        import logging
+
+        logger = logging.getLogger("xpm.tui.log_viewer")
+
+        # Ensure local_path is a Path object
+        if not isinstance(local_path, Path):
+            local_path = Path(local_path)
+
+        logger.info(f"Sync complete: {local_path}, loading={self._loading}")
+
+        # Update sync status
+        try:
+            status = self.query_one("#sync-status", Static)
+            if self._synchronizer:
+                status.update(f"✓ Next sync: {self._synchronizer.interval:.0f}s")
+            else:
+                status.update("✓ Synced")
+        except Exception as e:
+            logger.warning(f"Failed to update sync status: {e}")
+
+        # If loading, find log files and create widgets
+        if self._loading:
+            self._loading = False
+            task_name = self.task_id.split(".")[-1] if self.task_id else "task"
+            stdout_path = local_path / f"{task_name}.out"
+            stderr_path = local_path / f"{task_name}.err"
+
+            logger.info(f"Looking for log files: {stdout_path}, {stderr_path}")
+
+            log_files = []
+            if stdout_path.exists():
+                log_files.append(str(stdout_path))
+            if stderr_path.exists():
+                log_files.append(str(stderr_path))
+
+            if not log_files:
+                try:
+                    loading = self.query_one("#loading", Static)
+                    loading.update(
+                        f"No log files found: {task_name}.out/.err in {local_path}"
+                    )
+                except Exception as e:
+                    logger.warning(f"Failed to update loading: {e}")
+                return
+
+            logger.info(f"Found log files: {log_files}")
+            self.log_files = log_files
+            self._rebuild_log_widgets()
+        else:
+            # Just refresh existing widgets
+            for widget in self.log_widgets:
+                widget.refresh_content()
+
+    def _on_sync_error(self, error: str) -> None:
+        """Handle sync error"""
+        try:
+            status = self.query_one("#sync-status", Static)
+            status.update(f"Sync error: {error}")
+        except Exception:
+            pass
+
+        if self._loading:
+            try:
+                loading = self.query_one("#loading", Static)
+                loading.update(f"Error: {error}")
+            except Exception:
+                pass
+
+    def _rebuild_log_widgets(self) -> None:
+        """Rebuild log widgets after first sync"""
+        # Remove loading message
+        try:
+            loading = self.query_one("#loading", Static)
+            loading.remove()
+        except Exception:
+            pass
+
+        # Add log widgets
+        self.log_widgets = []
+        if len(self.log_files) == 1:
+            widget = LogWidget(self.log_files[0], "log-0")
+            self.log_widgets.append(widget)
+            self.mount(widget, before=self.query_one("#sync-status"))
+        else:
+            tabbed = TabbedContent()
+            self.mount(tabbed, before=self.query_one("#sync-status"))
+            for i, log_file in enumerate(self.log_files):
+                file_name = Path(log_file).name
+                pane = TabPane(file_name, id=f"tab-{i}")
+                widget = LogWidget(log_file, f"log-{i}")
+                self.log_widgets.append(widget)
+                pane.compose_add_child(widget)
+                tabbed.add_pane(pane)
+
     def _refresh_logs(self) -> None:
         """Refresh all log widgets"""
         if not self.following:
@@ -203,6 +429,21 @@ class LogViewerScreen(Screen, inherit_bindings=False):
 
     def action_close_viewer(self) -> None:
         """Go back to the job detail view"""
+        import logging
+
+        logger = logging.getLogger("xpm.tui.log_viewer")
+
+        # Warn if closing during first sync
+        if self._loading:
+            self.notify("Sync in progress, please wait...", severity="warning")
+            logger.info("User tried to close during first sync, ignoring")
+            return
+
+        # Stop adaptive sync if running
+        if self._synchronizer:
+            logger.info("Closing log viewer, stopping sync")
+            self._synchronizer.stop()
+
         self.dismiss()
 
     def action_toggle_follow(self) -> None:
@@ -226,3 +467,12 @@ class LogViewerScreen(Screen, inherit_bindings=False):
         for widget in self.log_widgets:
             widget.following = True
             widget.scroll_to_end()
+
+    def action_sync_now(self) -> None:
+        """Trigger immediate sync (for remote monitoring)"""
+        if self._synchronizer:
+            self._synchronizer.sync_now()
+            self.notify("Syncing...")
+        elif self.sync_func and self.remote_path:
+            self._do_single_sync()
+            self.notify("Syncing...")