hpc-runner 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

hpc_runner/schedulers/sge/templates/batch.sh.j2

@@ -0,0 +1,82 @@
+#!/bin/bash
+# Generated by hpc-tools (SGE scheduler)
+
+{% for directive in directives %}
+{{ directive }}
+{% endfor %}
+
+# Exit on error
+set -e
+
+# Module system initialization
+{% if scheduler.module_init_script %}
+. {{ scheduler.module_init_script }}
+{% else %}
+if [ -f /etc/profile.d/modules.sh ]; then
+    . /etc/profile.d/modules.sh
+elif [ -f /usr/share/Modules/init/bash ]; then
+    . /usr/share/Modules/init/bash
+fi
+{% endif %}
+
+{% if scheduler.purge_modules %}
+# Purge modules for clean environment
+module purge{% if scheduler.silent_modules %} -s{% endif %}
+
+{% endif %}
+{% if job.modules_path %}
+# Additional module paths
+{% for path in job.modules_path %}
+module use {{ path }}
+{% endfor %}
+{% endif %}
+
+{% if job.modules %}
+# Load modules
+{% for mod in job.modules %}
+module load {{ mod }}{% if scheduler.silent_modules %} -s{% endif %}
+
+{% endfor %}
+{% endif %}
+
+{% if job.venv %}
+# Activate virtual environment
+source {{ job.venv }}/bin/activate
+{% endif %}
+
+{% if scheduler.unset_vars %}
+# Unset environment variables
+{% for var in scheduler.unset_vars %}
+unset {{ var }}
+{% endfor %}
+{% endif %}
+
+{% if job.env_vars %}
+# Set custom environment variables
+{% for key, value in job.env_vars.items() %}
+export {{ key }}="{{ value }}"
+{% endfor %}
+{% endif %}
+
+{% if scheduler.expand_makeflags %}
+# Expand MAKEFLAGS (e.g., -j$NSLOTS)
+if [ -n "$MAKEFLAGS" ]; then
+    export MAKEFLAGS=$(echo "$MAKEFLAGS" | envsubst)
+fi
+{% endif %}
+
+{% if job.workdir %}
+# Change to working directory
+cd {{ job.workdir }}
+{% endif %}
+
+# Execute command
+{{ job.command }}
+_exit_code=$?
+
+{% if script_path and not keep_script %}
+# Cleanup temporary script
+rm -f {{ script_path }}
+{% endif %}
+
+exit $_exit_code

hpc_runner/schedulers/sge/templates/interactive.sh.j2

@@ -0,0 +1,78 @@
+#!/bin/bash
+# Generated by hpc-tools (SGE interactive job)
+
+# Exit on error
+set -e
+
+# Module system initialization
+{% if scheduler.module_init_script %}
+. {{ scheduler.module_init_script }}
+{% else %}
+if [ -f /etc/profile.d/modules.sh ]; then
+    . /etc/profile.d/modules.sh
+elif [ -f /usr/share/Modules/init/bash ]; then
+    . /usr/share/Modules/init/bash
+fi
+{% endif %}
+
+{% if scheduler.purge_modules %}
+# Purge modules for clean environment
+module purge{% if scheduler.silent_modules %} -s{% endif %}
+
+{% endif %}
+{% if job.modules_path %}
+# Additional module paths
+{% for path in job.modules_path %}
+module use {{ path }}
+{% endfor %}
+{% endif %}
+
+{% if job.modules %}
+# Load modules
+{% for mod in job.modules %}
+module load {{ mod }}{% if scheduler.silent_modules %} -s{% endif %}
+
+{% endfor %}
+{% endif %}
+
+{% if job.venv %}
+# Activate virtual environment
+source {{ job.venv }}/bin/activate
+{% endif %}
+
+{% if scheduler.unset_vars %}
+# Unset environment variables
+{% for var in scheduler.unset_vars %}
+unset {{ var }}
+{% endfor %}
+{% endif %}
+
+{% if job.env_vars %}
+# Set custom environment variables
+{% for key, value in job.env_vars.items() %}
+export {{ key }}="{{ value }}"
+{% endfor %}
+{% endif %}
+
+{% if scheduler.expand_makeflags %}
+# Expand MAKEFLAGS (e.g., -j$NSLOTS)
+if [ -n "$MAKEFLAGS" ]; then
+    export MAKEFLAGS=$(echo "$MAKEFLAGS" | envsubst)
+fi
+{% endif %}
+
+{% if job.workdir %}
+# Change to working directory
+cd {{ job.workdir }}
+{% endif %}
+
+# Execute command
+{{ job.command }}
+_exit_code=$?
+
+{% if not keep_script %}
+# Cleanup temporary script
+rm -f {{ script_path }}
+{% endif %}
+
+exit $_exit_code

hpc_runner/tui/__init__.py

@@ -0,0 +1,5 @@
+"""HPC Monitor TUI - Textual-based terminal UI for monitoring HPC jobs."""
+
+from .app import HpcMonitorApp
+
+__all__ = ["HpcMonitorApp"]

hpc_runner/tui/app.py

@@ -0,0 +1,436 @@
+"""Main HPC Monitor TUI application.
+
+Uses modern Textual patterns:
+- Reactive attributes for automatic UI updates
+- run_worker for async scheduler calls
+- set_interval for auto-refresh
+- Message-based event handling
+"""
+
+import os
+import socket
+from pathlib import Path
+from typing import ClassVar
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import HorizontalGroup, Vertical
+from textual.reactive import reactive
+from textual.theme import Theme
+from textual.widgets import DataTable, Header, Static, TabbedContent, TabPane
+
+from hpc_runner.core.job_info import JobInfo
+from hpc_runner.schedulers import get_scheduler
+from hpc_runner.tui.components import (
+    DetailPanel,
+    FilterPanel,
+    FilterStatusLine,
+    HelpPopup,
+    JobTable,
+)
+from hpc_runner.tui.providers import JobProvider
+from hpc_runner.tui.screens import ConfirmScreen, JobDetailsScreen, LogViewerScreen
+
+
+# Custom theme inspired by Nord color palette for a muted, professional look.
+# NOTE: We intentionally do NOT set 'background' or 'foreground' here.
+# This allows the terminal's own colors to show through (transparency).
+# The theme only defines accent colors used for highlights and status.
+HPC_MONITOR_THEME = Theme(
+    name="hpc-monitor",
+    primary="#88C0D0",  # Muted teal (not bright blue)
+    secondary="#81A1C1",  # Lighter blue-gray
+    accent="#B48EAD",  # Muted purple
+    success="#A3BE8C",  # Muted green
+    warning="#EBCB8B",  # Muted yellow
+    error="#BF616A",  # Muted red
+    surface="#3B4252",  # For elevated surfaces
+    panel="#434C5E",  # Panel accents
+    dark=True,
+)
+
+
+class HpcMonitorApp(App[None]):
+    """Textual app for monitoring HPC jobs.
+
+    Attributes:
+        refresh_interval: Seconds between auto-refresh of job data.
+        user_filter: Filter jobs by "me" (current user) or "all" users.
+        auto_refresh_enabled: Whether auto-refresh is active.
+    """
+
+    TITLE = "hpc monitor"
+
+    CSS_PATH: ClassVar[Path] = Path(__file__).parent / "styles" / "monitor.tcss"
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("r", "refresh", "Refresh"),
+        Binding("u", "toggle_user", "Toggle User"),
+        Binding("/", "filter_search", "Search", show=False),
+        Binding("s", "screenshot", "Screenshot", show=False),
+        Binding("question_mark", "help", "Help", show=False),
+    ]
+
+    # Reactive attributes - changes automatically trigger watch methods
+    user_filter: reactive[str] = reactive("me")
+    auto_refresh_enabled: reactive[bool] = reactive(True)
+
+    def __init__(self, refresh_interval: int = 10) -> None:
+        """Initialize the HPC Monitor app.
+
+        Args:
+            refresh_interval: Seconds between auto-refresh cycles.
+        """
+        super().__init__()
+        self._refresh_interval = refresh_interval
+        self._user = os.environ.get("USER", "unknown")
+        self._hostname = socket.gethostname().split(".")[0]  # Short hostname
+
+        # Initialize scheduler and job provider
+        self._scheduler = get_scheduler()
+        self._job_provider = JobProvider(self._scheduler)
+
+        # Store full job list for client-side filtering
+        self._all_jobs: list[JobInfo] = []
+        self._status_filter: str | None = None
+        self._queue_filter: str | None = None
+        self._search_filter: str = ""
+
+        # Store extra details for currently selected job (for Enter popup)
+        self._selected_job_extra: dict[str, object] = {}
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets for the app."""
+        yield Header()
+        with TabbedContent(id="tabs"):
+            with TabPane("Active", id="active-tab"):
+                with Vertical(id="active-content"):
+                    yield FilterStatusLine()
+                    yield JobTable(id="active-jobs")
+                    yield DetailPanel(id="detail-panel")
+            with TabPane("Completed", id="completed-tab"):
+                yield Static(
+                    "Completed jobs will appear here", id="completed-placeholder"
+                )
+        # Custom footer for ANSI transparency (Textual's Footer doesn't respect it)
+        with HorizontalGroup(id="footer"):
+            yield Static(" q", classes="footer-key")
+            yield Static("Quit", classes="footer-label")
+            yield Static(" r", classes="footer-key")
+            yield Static("Refresh", classes="footer-label")
+            yield Static(" u", classes="footer-key")
+            yield Static("User", classes="footer-label")
+            yield Static(" ↵", classes="footer-key")
+            yield Static("Details", classes="footer-label")
+            yield Static(" /", classes="footer-key")
+            yield Static("Search", classes="footer-label")
+            yield Static(" ?", classes="footer-key")
+            yield Static("Help", classes="footer-label")
+
+    def on_mount(self) -> None:
+        """Called when app is mounted - set up timers and initial data fetch."""
+        # Register and apply custom theme for muted, professional aesthetic
+        self.register_theme(HPC_MONITOR_THEME)
+        self.theme = "hpc-monitor"
+
+        # Enable ANSI color mode for transparent backgrounds
+        # This allows the terminal's own background to show through
+        self.ansi_color = True
+
+        # Update header subtitle with user@hostname and scheduler info
+        self.sub_title = f"{self._user}@{self._hostname} ({self._scheduler.name})"
+
+        # Set up auto-refresh timer
+        self._refresh_timer = self.set_interval(
+            self._refresh_interval,
+            self._on_refresh_timer,
+            pause=False,  # Start immediately
+        )
+
+        # Mount help popup
+        self._help_popup = HelpPopup(id="help-popup")
+        self.mount(self._help_popup)
+
+        # Fetch initial data
+        self._refresh_active_jobs()
+
+        # Focus the job table by default
+        self.query_one("#active-jobs", JobTable).focus()
+
+    def _on_refresh_timer(self) -> None:
+        """Called by the refresh timer - triggers data fetch."""
+        if self.auto_refresh_enabled:
+            self._refresh_active_jobs()
+
+    async def action_quit(self) -> None:
+        """Quit the application."""
+        self.exit()
+
+    def action_screenshot(self) -> None:
+        """Save a screenshot to the current directory."""
+        path = self.save_screenshot(path="./")
+        self.notify(f"Screenshot saved: {path}", timeout=3)
+
+    def action_help(self) -> None:
+        """Show help popup."""
+        self._help_popup.show_popup()
+
+    def action_refresh(self) -> None:
+        """Manually trigger a data refresh."""
+        self._refresh_active_jobs()
+
+    def action_view_details(self) -> None:
+        """Open full details popup for selected job."""
+        try:
+            detail_panel = self.query_one("#detail-panel", DetailPanel)
+            job = detail_panel._job
+            if job is None:
+                self.notify("No job selected", severity="warning", timeout=2)
+                return
+
+            def refocus_table(_: None) -> None:
+                """Restore focus to job table after modal closes."""
+                self.query_one("#active-jobs", JobTable).focus()
+
+            self.push_screen(
+                JobDetailsScreen(job=job, extra_details=self._selected_job_extra),
+                refocus_table,
+            )
+        except Exception as e:
+            self.notify(f"Error: {e}", severity="error", timeout=3)
+
+    def _refresh_active_jobs(self) -> None:
+        """Fetch active jobs and update the table.
+
+        Uses run_worker to run as a background task without blocking UI.
+        The exclusive=True ensures only one refresh runs at a time.
+        """
+        self.run_worker(self._fetch_and_update_jobs, exclusive=True)
+
+    async def _fetch_and_update_jobs(self) -> None:
+        """Async coroutine to fetch jobs and update the table."""
+        try:
+            jobs = await self._job_provider.get_active_jobs(
+                user_filter=self.user_filter,
+            )
+            # Store all jobs for client-side filtering
+            self._all_jobs = jobs
+
+            # Update queue filter with available queues
+            queues = sorted(set(j.queue for j in jobs if j.queue))
+            try:
+                status_line = self.query_one(FilterStatusLine)
+                status_line.update_queues(queues)
+            except Exception:
+                pass
+
+            # Apply filters and update display
+            self._apply_filters_and_display()
+
+        except Exception as e:
+            self.notify(f"Error: {e}", severity="error", timeout=3)
+
+    def _apply_filters_and_display(self) -> None:
+        """Apply current filters and update the job table."""
+        filtered = self._all_jobs
+
+        # Filter by status
+        if self._status_filter:
+            filtered = [
+                j for j in filtered
+                if j.status.name.lower() == self._status_filter.lower()
+            ]
+
+        # Filter by queue
+        if self._queue_filter:
+            filtered = [j for j in filtered if j.queue == self._queue_filter]
+
+        # Filter by search (name or ID)
+        if self._search_filter:
+            search = self._search_filter.lower()
+            filtered = [
+                j for j in filtered
+                if search in j.name.lower() or search in j.job_id.lower()
+            ]
+
+        # Update table
+        table = self.query_one("#active-jobs", JobTable)
+        table.update_jobs(filtered)
+
+        # Clear detail panel if filtered list is empty or selected job no longer in list
+        try:
+            detail_panel = self.query_one("#detail-panel", DetailPanel)
+            if not filtered:
+                # No jobs after filtering - clear detail panel
+                detail_panel.update_job(None)
+            elif detail_panel._job is not None:
+                # Check if currently displayed job is still in filtered list
+                current_job_id = detail_panel._job.job_id
+                if not any(j.job_id == current_job_id for j in filtered):
+                    detail_panel.update_job(None)
+        except Exception:
+            pass
+
+        # Update subtitle with counts
+        total = len(self._all_jobs)
+        shown = len(filtered)
+        filter_text = "my" if self.user_filter == "me" else "all"
+        if shown == total:
+            self.sub_title = (
+                f"{self._user}@{self._hostname} ({self._scheduler.name}) "
+                f"· {total} {filter_text} job{'s' if total != 1 else ''}"
+            )
+        else:
+            self.sub_title = (
+                f"{self._user}@{self._hostname} ({self._scheduler.name}) "
+                f"· {shown}/{total} {filter_text} jobs"
+            )
+
+    def action_toggle_user(self) -> None:
+        """Toggle between showing current user's jobs and all jobs."""
+        self.user_filter = "all" if self.user_filter == "me" else "me"
+
+    def watch_user_filter(self, old_value: str, new_value: str) -> None:
+        """React to user filter changes."""
+        self.notify(f"Filter: {new_value}", timeout=1)
+        # Trigger refresh with new filter
+        self._refresh_active_jobs()
+
+    def action_filter_search(self) -> None:
+        """Focus the search input."""
+        self.query_one(FilterStatusLine).focus_search()
+
+    def on_filter_panel_filter_changed(
+        self, event: FilterPanel.FilterChanged
+    ) -> None:
+        """Handle filter panel changes (arrow key navigation)."""
+        if event.filter_type == "status":
+            self._status_filter = event.value
+        elif event.filter_type == "queue":
+            self._queue_filter = event.value
+        self._apply_filters_and_display()
+
+    def on_filter_status_line_search_changed(
+        self, event: FilterStatusLine.SearchChanged
+    ) -> None:
+        """Handle inline search changes."""
+        self._search_filter = event.value
+        self._apply_filters_and_display()
+
+    def on_job_table_job_selected(self, event: JobTable.JobSelected) -> None:
+        """Handle job selection in the table.
+
+        Fetches detailed job info (including output paths) when a job is selected.
+        """
+        # Start with basic info from the event
+        job_info = event.job_info
+        self._selected_job_extra = {}
+        self._last_detail_error: str | None = None
+
+        # Try to get detailed info (including stdout/stderr paths)
+        try:
+            result = self._scheduler.get_job_details(job_info.job_id)
+            # Handle tuple return (JobInfo, extra_details)
+            if isinstance(result, tuple):
+                job_info, self._selected_job_extra = result
+            else:
+                job_info = result
+        except (NotImplementedError, Exception) as exc:
+            # Scheduler doesn't support details or call failed - use basic info
+            self._last_detail_error = f"{type(exc).__name__}: {exc}"
+            pass
+
+        try:
+            detail_panel = self.query_one("#detail-panel", DetailPanel)
+            detail_panel.update_job(job_info)
+            if self._last_detail_error:
+                self.notify(
+                    f"Details fallback for job {job_info.job_id}: {self._last_detail_error}",
+                    severity="warning",
+                    timeout=5,
+                )
+        except Exception:
+            pass
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        """Handle Enter key on job table row - open full details popup."""
+        # Get the currently displayed job from the detail panel
+        try:
+            detail_panel = self.query_one("#detail-panel", DetailPanel)
+            job = detail_panel._job
+            if job is None:
+                return
+
+            def refocus_table(_: None) -> None:
+                """Restore focus to job table after modal closes."""
+                self.query_one("#active-jobs", JobTable).focus()
+
+            self.push_screen(
+                JobDetailsScreen(job=job, extra_details=self._selected_job_extra),
+                refocus_table,
+            )
+        except Exception:
+            pass
+
+    def on_detail_panel_view_logs(self, event: DetailPanel.ViewLogs) -> None:
+        """Handle request to view job logs."""
+        job = event.job
+        stream = event.stream
+        path = job.stdout_path if stream == "stdout" else job.stderr_path
+
+        if path is None:
+            self.notify(f"No {stream} path available", severity="warning", timeout=3)
+            return
+
+        def refocus_table(_: None) -> None:
+            """Restore focus to job table after modal closes."""
+            self.query_one("#active-jobs", JobTable).focus()
+
+        title = f"{stream}: {job.name}"
+        self.push_screen(LogViewerScreen(file_path=path, title=title), refocus_table)
+
+    def on_detail_panel_cancel_job(self, event: DetailPanel.CancelJob) -> None:
+        """Handle request to cancel a job."""
+        job = event.job
+
+        def handle_confirm(confirmed: bool) -> None:
+            """Handle confirmation result and refocus table."""
+            if confirmed:
+                self._do_cancel_job(job)
+            self.query_one("#active-jobs", JobTable).focus()
+
+        # Format job details for confirmation dialog
+        message = (
+            f"[bold]Job ID:[/]  {job.job_id}\n"
+            f"[bold]Name:[/]    {job.name}"
+        )
+        self.push_screen(
+            ConfirmScreen(
+                message=message,
+                title="Terminate Job",
+                confirm_label="Confirm",
+            ),
+            handle_confirm,
+        )
+
+    def _do_cancel_job(self, job: JobInfo) -> None:
+        """Actually cancel the job."""
+        self.run_worker(self._cancel_job_worker(job), exclusive=False)
+
+    async def _cancel_job_worker(self, job: JobInfo) -> None:
+        """Worker to cancel job in background."""
+        try:
+            # Run cancel in thread pool to avoid blocking
+            import asyncio
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(
+                None,
+                self._scheduler.cancel,
+                job.job_id,
+            )
+            self.notify(f"Job {job.job_id} cancelled", severity="information", timeout=3)
+            # Refresh the job list
+            self._refresh_active_jobs()
+        except Exception as e:
+            self.notify(f"Failed to cancel: {e}", severity="error", timeout=5)

hpc_runner/tui/components/__init__.py

@@ -0,0 +1,17 @@
+"""TUI components for HPC Monitor."""
+
+from .detail_panel import DetailPanel
+from .filter_popup import (
+    FilterPanel,
+    FilterStatusLine,
+    HelpPopup,
+)
+from .job_table import JobTable
+
+__all__ = [
+    "DetailPanel",
+    "FilterPanel",
+    "FilterStatusLine",
+    "HelpPopup",
+    "JobTable",
+]