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

hpc_runner/tui/components/job_table.py

@@ -0,0 +1,260 @@
+"""Job table widget for displaying HPC jobs."""
+
+from textual.events import Resize
+from textual.message import Message
+from textual.widgets import DataTable
+
+from hpc_runner.core.job_info import JobInfo
+from hpc_runner.core.result import JobStatus
+
+
+class JobTable(DataTable):
+    """DataTable for displaying HPC jobs.
+
+    Displays job information in a tabular format with columns for
+    ID, Name, Queue, Status, Runtime, and Resources.
+
+    Messages:
+        JobSelected: Emitted when a job row is highlighted/selected.
+    """
+
+    class JobSelected(Message):
+        """Message sent when a job is selected in the table."""
+
+        def __init__(self, job_id: str, job_info: JobInfo | None = None) -> None:
+            self.job_id = job_id
+            self.job_info = job_info
+            super().__init__()
+
+    # Column definitions: (key, label, fixed_width)
+    # Fixed columns have set widths; "name" gets remaining space
+    FIXED_COLUMNS = [
+        ("job_id", "ID", 10),
+        ("user", "User", 14),
+        ("queue", "Queue", 12),
+        ("status", "Status", 10),
+        ("runtime", "Runtime", 12),
+        ("slots", "Slots", 6),
+    ]
+    NAME_COL_MIN = 15  # Minimum width for name column
+
+    def __init__(
+        self,
+        *,
+        show_cursor: bool = True,
+        zebra_stripes: bool = True,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        """Initialize the job table.
+
+        Args:
+            show_cursor: Whether to show the cursor/selection.
+            zebra_stripes: Whether to alternate row colors.
+            id: Widget ID.
+            classes: CSS classes.
+        """
+        super().__init__(
+            show_cursor=show_cursor,
+            zebra_stripes=zebra_stripes,
+            cursor_type="row",
+            id=id,
+            classes=classes,
+        )
+        self._jobs: dict[str, JobInfo] = {}
+        self._name_col_width = 20  # Default, will be recalculated
+
+    def on_mount(self) -> None:
+        """Set up columns on mount using the best available width."""
+        self.border_title = "Jobs"
+        self._setup_columns()
+        self.call_after_refresh(self._sync_columns_to_current_width)
+
+    def on_resize(self, event: Resize) -> None:
+        """Handle resize events by syncing column widths to the new size."""
+        del event
+        self.call_after_refresh(self._sync_columns_to_current_width)
+
+    def _get_table_width(self) -> int:
+        """Return the width available for columns within the table."""
+        content_size = getattr(self, "content_size", None)
+        if content_size is not None:
+            return content_size.width
+        return self.size.width or self.app.console.size.width
+
+    def _calculate_name_width(self, table_width: int) -> int:
+        """Calculate the name column width to avoid horizontal overflow."""
+        fixed_total = sum(w for _, _, w in self.FIXED_COLUMNS)
+        column_spacing = (len(self.FIXED_COLUMNS) + 1) * 2
+        name_width = table_width - fixed_total - column_spacing
+        return max(self.NAME_COL_MIN, name_width)
+
+    def _sync_columns_to_current_width(self) -> None:
+        """Sync the name column width after layout updates size information."""
+        table_width = self._get_table_width()
+        if table_width <= 0:
+            return
+        desired_width = self._calculate_name_width(table_width)
+        if desired_width != self._name_col_width:
+            self._set_name_column_width(desired_width)
+        self.call_after_refresh(self._post_layout_adjust, table_width)
+
+    def _post_layout_adjust(self, table_width: int) -> None:
+        """Trim name width if virtual width still overflows after layout."""
+        if table_width <= 0:
+            return
+        scrollbar_width = 1 if self.show_vertical_scrollbar else 0
+        effective_width = table_width - scrollbar_width
+        overflow = self.virtual_size.width - effective_width
+        if overflow <= 0 or self._name_col_width <= self.NAME_COL_MIN:
+            return
+        adjusted_width = max(self.NAME_COL_MIN, self._name_col_width - overflow)
+        if adjusted_width != self._name_col_width:
+            self._set_name_column_width(adjusted_width)
+
+    def _set_name_column_width(self, width: int) -> None:
+        """Apply name column width and refresh rows for correct truncation."""
+        self._name_col_width = width
+        name_column = self.columns.get("name")
+        if name_column is not None:
+            name_column.width = width
+        if self._jobs:
+            self._refresh_rows_for_width()
+
+    def _refresh_rows_for_width(self) -> None:
+        """Rebuild rows in the current order to match the new name width."""
+        row_job_ids = [str(row_key.value) for row_key in self.rows.keys()]
+        ordered_jobs: list[JobInfo] = []
+        seen: set[str] = set()
+        for job_id in row_job_ids:
+            job = self._jobs.get(job_id)
+            if job is not None:
+                ordered_jobs.append(job)
+                seen.add(job_id)
+        if len(ordered_jobs) != len(self._jobs):
+            ordered_jobs.extend(
+                job for job_id, job in self._jobs.items() if job_id not in seen
+            )
+        self.update_jobs(ordered_jobs)
+
+    def _setup_columns(self) -> None:
+        """Set up the table columns."""
+        # Add ID column first
+        self.add_column("ID", key="job_id", width=10)
+        # Add Name column that expands to fill remaining space
+        self.add_column(
+            "Name",
+            key="name",
+            width=self._name_col_width,
+        )
+        # Add remaining fixed columns
+        for key, label, width in self.FIXED_COLUMNS[1:]:  # Skip job_id
+            self.add_column(label, key=key, width=width)
+
+    def _truncate_name(self, name: str) -> str:
+        """Truncate job name to fit in the name column."""
+        if len(name) <= self._name_col_width:
+            return name
+        # Truncate and add ellipsis
+        return name[: self._name_col_width - 1] + "…"
+
+    def update_jobs(self, jobs: list[JobInfo]) -> None:
+        """Update the table with a new list of jobs.
+
+        Args:
+            jobs: List of JobInfo objects to display.
+        """
+        # Save current selection to restore after update
+        selected_job_id: str | None = None
+        if self.cursor_row is not None and self.cursor_row >= 0:
+            try:
+                row_key = self.get_row_at(self.cursor_row)
+                if row_key:
+                    selected_job_id = str(row_key[0])
+            except Exception:
+                pass
+
+        # Clear existing data
+        self.clear()
+        self._jobs.clear()
+
+        # Add new rows
+        for job in jobs:
+            self._jobs[job.job_id] = job
+            self.add_row(
+                job.job_id,
+                self._truncate_name(job.name),
+                job.user,
+                job.queue or "—",
+                self._format_status(job.status),
+                job.runtime_display,
+                str(job.cpu) if job.cpu is not None else "—",
+                key=job.job_id,
+            )
+
+        # Restore selection if the job still exists
+        if selected_job_id and selected_job_id in self._jobs:
+            try:
+                self.move_cursor(row=self._get_row_index(selected_job_id))
+            except Exception:
+                pass
+
+    def _get_row_index(self, job_id: str) -> int | None:
+        """Get the row index for a job ID."""
+        for idx, row_key in enumerate(self.rows.keys()):
+            if str(row_key.value) == job_id:
+                return idx
+        return None
+
+    def _format_status(self, status: JobStatus) -> str:
+        """Format status for display with color hints.
+
+        The actual coloring is done via CSS classes, but we return
+        a clean status string here.
+        """
+        status_map = {
+            JobStatus.RUNNING: "RUNNING",
+            JobStatus.PENDING: "PENDING",
+            JobStatus.COMPLETED: "COMPLETE",
+            JobStatus.FAILED: "FAILED",
+            JobStatus.CANCELLED: "CANCEL",
+            JobStatus.TIMEOUT: "TIMEOUT",
+            JobStatus.UNKNOWN: "UNKNOWN",
+        }
+        return status_map.get(status, str(status.name))
+
+    def on_data_table_row_highlighted(
+        self, event: DataTable.RowHighlighted
+    ) -> None:
+        """Handle row highlight - emit JobSelected message."""
+        if event.row_key is not None:
+            job_id = str(event.row_key.value)
+            job_info = self._jobs.get(job_id)
+            self.post_message(self.JobSelected(job_id, job_info))
+
+    def get_selected_job(self) -> JobInfo | None:
+        """Get the currently selected job.
+
+        Returns:
+            The selected JobInfo, or None if nothing selected.
+        """
+        if self.cursor_row is not None and self.cursor_row >= 0:
+            try:
+                row_key = self.get_row_at(self.cursor_row)
+                if row_key:
+                    # row_key is a tuple of cell values, first is job_id
+                    job_id = str(row_key[0])
+                    return self._jobs.get(job_id)
+            except Exception:
+                pass
+        return None
+
+    @property
+    def job_count(self) -> int:
+        """Get the number of jobs in the table."""
+        return len(self._jobs)
+
+    @property
+    def is_empty(self) -> bool:
+        """Check if the table is empty."""
+        return len(self._jobs) == 0

hpc_runner/tui/providers/__init__.py

@@ -0,0 +1,5 @@
+"""Data providers for HPC Monitor TUI."""
+
+from .jobs import JobProvider
+
+__all__ = ["JobProvider"]

hpc_runner/tui/providers/jobs.py

@@ -0,0 +1,197 @@
+"""Job data provider for HPC Monitor TUI.
+
+Wraps scheduler calls in async methods that run in a thread pool
+to avoid blocking the UI.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from hpc_runner.core.exceptions import AccountingNotAvailable
+from hpc_runner.core.job_info import JobInfo
+from hpc_runner.core.result import JobStatus
+
+if TYPE_CHECKING:
+    from hpc_runner.schedulers.base import BaseScheduler
+
+logger = logging.getLogger(__name__)
+
+# Shared thread pool for scheduler calls
+_executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="hpc-provider")
+
+
+class JobProvider:
+    """Async provider for job data from HPC schedulers.
+
+    Wraps synchronous scheduler calls in async methods that run in a
+    thread pool, preventing UI blocking during data fetches.
+
+    Attributes:
+        scheduler: The HPC scheduler instance to query.
+        current_user: The current username for filtering.
+    """
+
+    def __init__(self, scheduler: "BaseScheduler") -> None:
+        """Initialize the job provider.
+
+        Args:
+            scheduler: The scheduler instance to use for queries.
+        """
+        self.scheduler = scheduler
+        self.current_user = os.environ.get("USER", "unknown")
+
+    async def get_active_jobs(
+        self,
+        user_filter: str = "me",
+        status_filter: set[JobStatus] | None = None,
+        queue_filter: str | None = None,
+    ) -> list[JobInfo]:
+        """Get active jobs asynchronously.
+
+        Args:
+            user_filter: "me" for current user only, "all" for all users.
+            status_filter: Set of statuses to include. None = all.
+            queue_filter: Queue name to filter by. None = all.
+
+        Returns:
+            List of JobInfo objects. Empty list on error.
+        """
+        # Determine user parameter
+        user = self.current_user if user_filter == "me" else None
+
+        try:
+            # Run scheduler call in thread pool
+            loop = asyncio.get_event_loop()
+            jobs = await loop.run_in_executor(
+                _executor,
+                lambda: self.scheduler.list_active_jobs(
+                    user=user,
+                    status=status_filter,
+                    queue=queue_filter,
+                ),
+            )
+            return jobs
+        except NotImplementedError:
+            logger.warning(
+                f"Scheduler {self.scheduler.name} does not implement list_active_jobs"
+            )
+            return []
+        except Exception as e:
+            logger.error(f"Error fetching active jobs: {e}")
+            return []
+
+    async def get_completed_jobs(
+        self,
+        user_filter: str = "me",
+        since: datetime | None = None,
+        until: datetime | None = None,
+        exit_code: int | None = None,
+        queue_filter: str | None = None,
+        limit: int = 100,
+    ) -> list[JobInfo]:
+        """Get completed jobs asynchronously.
+
+        Args:
+            user_filter: "me" for current user only, "all" for all users.
+            since: Only jobs completed after this time.
+            until: Only jobs completed before this time.
+            exit_code: Filter by exit code. None = all.
+            queue_filter: Queue name to filter by. None = all.
+            limit: Maximum number of jobs to return.
+
+        Returns:
+            List of JobInfo objects. Empty list on error.
+
+        Raises:
+            AccountingNotAvailable: If scheduler accounting is not enabled.
+        """
+        user = self.current_user if user_filter == "me" else None
+
+        try:
+            loop = asyncio.get_event_loop()
+            jobs = await loop.run_in_executor(
+                _executor,
+                lambda: self.scheduler.list_completed_jobs(
+                    user=user,
+                    since=since,
+                    until=until,
+                    exit_code=exit_code,
+                    queue=queue_filter,
+                    limit=limit,
+                ),
+            )
+            return jobs
+        except AccountingNotAvailable:
+            # Re-raise so caller can show appropriate message
+            raise
+        except NotImplementedError:
+            logger.warning(
+                f"Scheduler {self.scheduler.name} does not implement list_completed_jobs"
+            )
+            raise AccountingNotAvailable(
+                f"Scheduler {self.scheduler.name} does not support job history"
+            )
+        except Exception as e:
+            logger.error(f"Error fetching completed jobs: {e}")
+            return []
+
+    async def get_job_details(self, job_id: str) -> JobInfo | None:
+        """Get detailed information for a single job.
+
+        Args:
+            job_id: The job ID to look up.
+
+        Returns:
+            JobInfo with details, or None if not found/error.
+        """
+        try:
+            loop = asyncio.get_event_loop()
+            job = await loop.run_in_executor(
+                _executor,
+                lambda: self.scheduler.get_job_details(job_id),
+            )
+            return job
+        except Exception as e:
+            logger.error(f"Error fetching job details for {job_id}: {e}")
+            return None
+
+    async def has_accounting(self) -> bool:
+        """Check if job accounting/history is available.
+
+        Returns:
+            True if completed job history is available.
+        """
+        try:
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(
+                _executor,
+                self.scheduler.has_accounting,
+            )
+        except Exception as e:
+            logger.error(f"Error checking accounting availability: {e}")
+            return False
+
+    async def cancel_job(self, job_id: str) -> bool:
+        """Cancel a job.
+
+        Args:
+            job_id: The job ID to cancel.
+
+        Returns:
+            True if cancellation succeeded.
+        """
+        try:
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(
+                _executor,
+                lambda: self.scheduler.cancel(job_id),
+            )
+        except Exception as e:
+            logger.error(f"Error cancelling job {job_id}: {e}")
+            return False

hpc_runner/tui/screens/__init__.py

@@ -0,0 +1,7 @@
+"""TUI screens for HPC Monitor."""
+
+from .confirm import ConfirmScreen
+from .job_details import JobDetailsScreen
+from .log_viewer import LogViewerScreen
+
+__all__ = ["ConfirmScreen", "JobDetailsScreen", "LogViewerScreen"]

hpc_runner/tui/screens/confirm.py

@@ -0,0 +1,67 @@
+"""Confirmation modal screen."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Static
+
+
+class ConfirmScreen(ModalScreen[bool]):
+    """Modal confirmation dialog.
+
+    Returns True if confirmed, False if cancelled.
+    Styles are defined in monitor.tcss.
+    """
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+        ("y", "confirm", "Yes"),
+        ("s", "screenshot", "Screenshot"),
+    ]
+
+    def action_screenshot(self) -> None:
+        """Save a screenshot."""
+        path = self.app.save_screenshot(path="./")
+        self.app.notify(f"Screenshot saved: {path}", timeout=3)
+
+    def __init__(
+        self,
+        message: str,
+        title: str = "Confirm",
+        confirm_label: str = "Confirm",
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._message = message
+        self._title = title
+        self._confirm_label = confirm_label
+
+    def compose(self) -> ComposeResult:
+        """Create the modal content."""
+        with Vertical(id="confirm-dialog"):
+            yield Static(self._message, id="confirm-message", markup=True)
+            with Horizontal(id="confirm-buttons"):
+                yield Button(self._confirm_label, id="btn-confirm", variant="default")
+            yield Static("Esc to dismiss", id="confirm-hint")
+
+    def on_mount(self) -> None:
+        """Set up the dialog."""
+        dialog = self.query_one("#confirm-dialog", Vertical)
+        dialog.border_title = self._title
+        # Focus the confirm button
+        self.query_one("#btn-confirm", Button).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        if event.button.id == "btn-confirm":
+            self.dismiss(True)
+
+    def action_confirm(self) -> None:
+        """Confirm action (y key)."""
+        self.dismiss(True)
+
+    def action_cancel(self) -> None:
+        """Cancel action (n or escape key)."""
+        self.dismiss(False)