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

hpc_runner/tui/components/detail_panel.py

@@ -0,0 +1,187 @@
+"""Job detail panel component."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.events import Key
+from textual.message import Message
+from textual.widgets import Button, Static
+
+from hpc_runner.core.job_info import JobInfo
+
+
+class ButtonBar(Horizontal):
+    """Horizontal container with arrow key navigation between buttons."""
+
+    def on_key(self, event: Key) -> None:
+        """Handle arrow key navigation between buttons."""
+        if event.key not in ("left", "right"):
+            return
+
+        buttons = [btn for btn in self.query(Button).results(Button) if not btn.disabled]
+        if not buttons:
+            return
+
+        focused = self.app.focused
+        if not isinstance(focused, Button) or focused not in buttons:
+            return
+
+        idx = buttons.index(focused)
+        if event.key == "right":
+            next_idx = (idx + 1) % len(buttons)
+        else:
+            next_idx = (idx - 1) % len(buttons)
+
+        buttons[next_idx].focus()
+        event.prevent_default()
+        event.stop()
+
+
+class DetailPanel(Vertical):
+    """Panel showing detailed information for selected job.
+
+    Styles are defined in monitor.tcss, not DEFAULT_CSS.
+    Arrow keys navigate between buttons.
+    """
+
+    class ViewLogs(Message):
+        """Request to view job logs."""
+
+        def __init__(self, job: JobInfo, stream: str) -> None:
+            super().__init__()
+            self.job = job
+            self.stream = stream  # "stdout" or "stderr"
+
+    class CancelJob(Message):
+        """Request to cancel a job."""
+
+        def __init__(self, job: JobInfo) -> None:
+            super().__init__()
+            self.job = job
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._job: JobInfo | None = None
+
+    def compose(self) -> ComposeResult:
+        """Create panel content."""
+        yield Static("Select a job to view details", id="no-selection")
+        with Vertical(id="detail-content", classes="hidden"):
+            # Row 1: ID and Status
+            with Horizontal(classes="detail-row"):
+                yield Static("Job ID:", classes="detail-label")
+                yield Static("", id="detail-id", classes="detail-value")
+                yield Static("Status:", classes="detail-label")
+                yield Static("", id="detail-status", classes="detail-value")
+
+            # Row 2: Queue and Runtime
+            with Horizontal(classes="detail-row"):
+                yield Static("Queue:", classes="detail-label")
+                yield Static("", id="detail-queue", classes="detail-value")
+                yield Static("Runtime:", classes="detail-label")
+                yield Static("", id="detail-runtime", classes="detail-value")
+
+            # Row 3: Resources and Node
+            with Horizontal(classes="detail-row"):
+                yield Static("Resources:", classes="detail-label")
+                yield Static("", id="detail-resources", classes="detail-value")
+                yield Static("Node:", classes="detail-label")
+                yield Static("", id="detail-node", classes="detail-value")
+
+            # Row 4: User and Submit time
+            with Horizontal(classes="detail-row"):
+                yield Static("User:", classes="detail-label")
+                yield Static("", id="detail-user", classes="detail-value")
+                yield Static("Submitted:", classes="detail-label")
+                yield Static("", id="detail-submitted", classes="detail-value")
+
+            # Row 5: Output path
+            with Horizontal(classes="detail-row"):
+                yield Static("Output:", classes="detail-label")
+                yield Static("", id="detail-output", classes="detail-value")
+
+            # Buttons (styled via monitor.tcss)
+            with ButtonBar(id="detail-buttons"):
+                yield Button("View stdout", id="btn-stdout")
+                yield Button("View stderr", id="btn-stderr")
+                yield Button("Cancel", id="btn-cancel")
+
+    def on_mount(self) -> None:
+        """Set up the panel."""
+        self.border_title = "Job Details"
+
+    def update_job(self, job: JobInfo | None) -> None:
+        """Update the panel with job details."""
+        self._job = job
+
+        no_selection = self.query_one("#no-selection", Static)
+        detail_content = self.query_one("#detail-content", Vertical)
+
+        if job is None:
+            no_selection.remove_class("hidden")
+            detail_content.add_class("hidden")
+            self.border_title = "Job Details"
+            return
+
+        no_selection.add_class("hidden")
+        detail_content.remove_class("hidden")
+
+        # Update border title
+        self.border_title = f"Job: {job.name}"
+
+        # Update fields
+        self.query_one("#detail-id", Static).update(job.job_id)
+        self.query_one("#detail-status", Static).update(job.status.name)
+        self.query_one("#detail-queue", Static).update(job.queue or "—")
+        self.query_one("#detail-runtime", Static).update(job.runtime_display)
+        self.query_one("#detail-resources", Static).update(job.resources_display)
+        self.query_one("#detail-node", Static).update(job.node or "—")
+        self.query_one("#detail-user", Static).update(job.user)
+
+        # Format submit time
+        if job.submit_time:
+            submitted = job.submit_time.strftime("%Y-%m-%d %H:%M:%S")
+        else:
+            submitted = "—"
+        self.query_one("#detail-submitted", Static).update(submitted)
+
+        # Format output path
+        if job.stdout_path:
+            output = str(job.stdout_path)
+            # Truncate if too long
+            if len(output) > 50:
+                output = "..." + output[-47:]
+        else:
+            output = "—"
+        self.query_one("#detail-output", Static).update(output)
+
+        # Update button states
+        btn_stdout = self.query_one("#btn-stdout", Button)
+        btn_stderr = self.query_one("#btn-stderr", Button)
+        btn_cancel = self.query_one("#btn-cancel", Button)
+
+        btn_stdout.disabled = job.stdout_path is None
+        btn_stderr.disabled = job.stderr_path is None
+        btn_cancel.disabled = not job.is_active
+
+    @on(Button.Pressed, "#btn-stdout")
+    def on_view_stdout(self, event: Button.Pressed) -> None:
+        """Handle stdout button click."""
+        if self._job:
+            self.post_message(self.ViewLogs(self._job, "stdout"))
+
+    @on(Button.Pressed, "#btn-stderr")
+    def on_view_stderr(self, event: Button.Pressed) -> None:
+        """Handle stderr button click."""
+        if self._job:
+            self.post_message(self.ViewLogs(self._job, "stderr"))
+
+    @on(Button.Pressed, "#btn-cancel")
+    def on_cancel_job(self, event: Button.Pressed) -> None:
+        """Handle cancel button click."""
+        if self._job:
+            self.post_message(self.CancelJob(self._job))

hpc_runner/tui/components/filter_bar.py

@@ -0,0 +1,174 @@
+"""Filter bar component for job tables."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from textual.containers import Horizontal
+from textual.message import Message
+from textual.widgets import Input, Select, Static
+
+from hpc_runner.core.result import JobStatus
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+
+# Status options for the dropdown
+STATUS_OPTIONS: list[tuple[str, str | None]] = [
+    ("All", None),
+    ("Running", "running"),
+    ("Pending", "pending"),
+    ("Held", "held"),
+]
+
+
+class FilterBar(Horizontal):
+    """Composable filter bar for job tables.
+
+    Provides status filter, queue filter, and search input.
+    Emits FilterChanged messages when any filter value changes.
+    """
+
+    @dataclass
+    class FilterChanged(Message):
+        """Emitted when any filter value changes."""
+
+        status: str | None
+        queue: str | None
+        search: str
+
+        @property
+        def control(self) -> FilterBar:
+            """The FilterBar that sent this message."""
+            return self._sender  # type: ignore[return-value]
+
+    DEFAULT_CSS = """
+    FilterBar {
+        height: 3;
+        padding: 0 1;
+        background: transparent;
+    }
+
+    FilterBar > Static.filter-label {
+        width: auto;
+        padding: 0 1 0 0;
+        content-align: center middle;
+    }
+
+    FilterBar > Select {
+        width: 16;
+        margin-right: 2;
+    }
+
+    FilterBar > Input {
+        width: 24;
+    }
+    """
+
+    def __init__(
+        self,
+        queues: list[str] | None = None,
+        *,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        """Initialize the filter bar.
+
+        Args:
+            queues: List of queue names for the queue dropdown.
+            id: Widget ID.
+            classes: CSS classes.
+        """
+        super().__init__(id=id, classes=classes)
+        self._queues = queues or []
+        self._current_status: str | None = None
+        self._current_queue: str | None = None
+        self._current_search: str = ""
+
+    def compose(self) -> ComposeResult:
+        """Create filter bar widgets."""
+        yield Static("Status:", classes="filter-label")
+        yield Select(
+            STATUS_OPTIONS,
+            value=None,
+            allow_blank=False,
+            id="status-filter",
+        )
+
+        yield Static("Queue:", classes="filter-label")
+        queue_options: list[tuple[str, str | None]] = [("All", None)]
+        queue_options.extend((q, q) for q in self._queues)
+        yield Select(
+            queue_options,
+            value=None,
+            allow_blank=False,
+            id="queue-filter",
+        )
+
+        yield Input(placeholder="Search name/ID...", id="search-filter")
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        """Handle dropdown selection changes."""
+        if event.select.id == "status-filter":
+            self._current_status = event.value
+        elif event.select.id == "queue-filter":
+            self._current_queue = event.value
+
+        self._emit_filter_changed()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Handle search input changes."""
+        if event.input.id == "search-filter":
+            self._current_search = event.value
+            self._emit_filter_changed()
+
+    def _emit_filter_changed(self) -> None:
+        """Emit a FilterChanged message with current filter values."""
+        self.post_message(
+            self.FilterChanged(
+                status=self._current_status,
+                queue=self._current_queue,
+                search=self._current_search,
+            )
+        )
+
+    def update_queues(self, queues: list[str]) -> None:
+        """Update the queue dropdown options.
+
+        Args:
+            queues: New list of queue names.
+        """
+        self._queues = queues
+        try:
+            queue_select = self.query_one("#queue-filter", Select)
+            queue_options: list[tuple[str, str | None]] = [("All", None)]
+            queue_options.extend((q, q) for q in queues)
+            queue_select.set_options(queue_options)
+        except Exception:
+            pass  # Widget not yet mounted
+
+    def clear_filters(self) -> None:
+        """Reset all filters to default values."""
+        try:
+            self.query_one("#status-filter", Select).value = None
+            self.query_one("#queue-filter", Select).value = None
+            self.query_one("#search-filter", Input).value = ""
+        except Exception:
+            pass
+
+    @property
+    def status_filter(self) -> str | None:
+        """Current status filter value."""
+        return self._current_status
+
+    @property
+    def queue_filter(self) -> str | None:
+        """Current queue filter value."""
+        return self._current_queue
+
+    @property
+    def search_filter(self) -> str:
+        """Current search filter value."""
+        return self._current_search

hpc_runner/tui/components/filter_popup.py

@@ -0,0 +1,345 @@
+"""Filter popup components for job tables."""
+
+from __future__ import annotations
+
+from textual import events, on
+from textual.containers import Horizontal, Vertical
+from textual.message import Message
+from textual.widgets import Input, OptionList, Static
+from textual.widgets.option_list import Option
+
+
+class HelpPopup(Static, can_focus=True):
+    """Centered help popup with keybindings."""
+
+    HELP_TEXT = """\
+ Keybindings
+
+ q       Quit
+ r       Refresh jobs
+ u       Toggle user (me/all)
+ /       Focus search
+ s       Save screenshot
+ Tab     Navigate panels
+ ↑/↓ jk  Cycle filter options
+ Enter   Open filter popup
+ Esc     Close popup\
+"""
+
+    DEFAULT_CSS = """
+    HelpPopup {
+        layer: overlay;
+        width: auto;
+        height: auto;
+        background: transparent;
+        border: round $primary;
+        border-title-color: $primary;
+        padding: 0 1;
+    }
+
+    HelpPopup.hidden {
+        display: none;
+    }
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(self.HELP_TEXT, **kwargs)
+        self.add_class("hidden")
+
+    def on_mount(self) -> None:
+        """Set up the popup."""
+        self.border_title = "Help"
+
+    def show_popup(self) -> None:
+        """Show the popup centered on screen."""
+        self.remove_class("hidden")
+        # Calculate size based on content
+        lines = self.HELP_TEXT.split("\n")
+        width = max(len(line) for line in lines) + 4
+        height = len(lines) + 2
+        self.styles.width = width
+        self.styles.height = height
+        self.styles.offset = (
+            (self.app.size.width - width) // 2,
+            (self.app.size.height - height) // 2,
+        )
+        self.focus()
+
+    def hide_popup(self) -> None:
+        """Hide the popup."""
+        self.add_class("hidden")
+
+    @on(events.Key)
+    def on_key(self, event: events.Key) -> None:
+        """Hide on any key press."""
+        self.hide_popup()
+        event.stop()
+
+    @on(events.Blur)
+    def on_blur(self, event: events.Blur) -> None:
+        """Hide on blur."""
+        self.hide_popup()
+
+
+class FilterPanelPopup(OptionList):
+    """Popup for FilterPanel showing all options."""
+
+    SCOPED_CSS = False
+
+    DEFAULT_CSS = """
+    FilterPanelPopup {
+        layer: overlay;
+        width: auto;
+        height: auto;
+        max-height: 10;
+        min-width: 16;
+        background: transparent;
+        border: round $primary !important;
+        padding: 0 1;
+    }
+
+    FilterPanelPopup > .option-list--option {
+        background: transparent;
+    }
+
+    FilterPanelPopup > .option-list--option-highlighted {
+        background: $primary;
+        color: $background;
+    }
+
+    FilterPanelPopup.hidden {
+        display: none;
+    }
+    """
+
+    def __init__(
+        self,
+        options: list[tuple[str, str | None]],
+        current_index: int = 0,
+        on_select: callable = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._panel_options = options
+        self._current_index = current_index
+        self._on_select = on_select
+
+    def on_mount(self) -> None:
+        """Populate options."""
+        self._refresh_options()
+
+    def _refresh_options(self) -> None:
+        """Refresh the option list."""
+        self.clear_options()
+        for label, value in self._panel_options:
+            self.add_option(Option(f" {label} ", id=str(value) if value else "none"))
+        if self._current_index < len(self._panel_options):
+            self.highlighted = self._current_index
+
+    def update_options(
+        self,
+        options: list[tuple[str, str | None]],
+        current_index: int,
+        on_select: callable = None,
+    ) -> None:
+        """Update options and current selection."""
+        self._panel_options = options
+        self._current_index = current_index
+        if on_select is not None:
+            self._on_select = on_select
+        if self.is_mounted:
+            self._refresh_options()
+
+    def show_popup(self, region) -> None:
+        """Show popup positioned relative to parent widget."""
+        self.remove_class("hidden")
+        self.styles.offset = (region.x, region.y + region.height)
+        self.focus()
+
+    def hide_popup(self) -> None:
+        """Hide the popup."""
+        self.add_class("hidden")
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Handle option selection."""
+        index = self.highlighted if self.highlighted is not None else 0
+        self.hide_popup()
+        if self._on_select is not None:
+            self._on_select(index)
+
+    @on(events.Key)
+    def on_key_escape(self, event: events.Key) -> None:
+        """Hide on escape."""
+        if event.key == "escape":
+            self.hide_popup()
+            event.stop()
+
+    @on(events.Blur)
+    def on_blur(self, event: events.Blur) -> None:
+        """Hide on blur."""
+        self.hide_popup()
+
+
+class FilterPanel(Static, can_focus=True):
+    """A focusable filter panel that cycles through options with arrow keys.
+
+    Press Enter to open a popup showing all options.
+    """
+
+    class FilterChanged(Message):
+        """Emitted when filter value changes."""
+
+        def __init__(self, filter_type: str, value: str | None) -> None:
+            super().__init__()
+            self.filter_type = filter_type
+            self.value = value
+
+    def __init__(
+        self,
+        filter_type: str,
+        options: list[tuple[str, str | None]],
+        title: str = "",
+        **kwargs,
+    ) -> None:
+        """Initialize filter panel.
+
+        Args:
+            filter_type: Type of filter (e.g., "status", "queue")
+            options: List of (display_label, value) tuples
+            title: Border title
+        """
+        super().__init__("All", **kwargs)
+        self._filter_type = filter_type
+        self._options = options
+        self._current_index = 0
+        self._title = title
+        self._popup: FilterPanelPopup | None = None
+
+    def on_mount(self) -> None:
+        """Set border title and create popup on mount."""
+        self.border_title = self._title
+        self._popup = FilterPanelPopup(
+            self._options,
+            self._current_index,
+            on_select=self._on_popup_select,
+            id=f"{self._filter_type}-popup",
+        )
+        self._popup.add_class("hidden")
+        self.app.mount(self._popup)
+
+    def _on_popup_select(self, index: int) -> None:
+        """Handle popup selection callback."""
+        self._current_index = index
+        self._update_display()
+        self.focus()
+
+    def on_key(self, event: events.Key) -> None:
+        """Handle arrow keys to cycle through options, Enter to open popup."""
+        if event.key == "down" or event.key == "j":
+            self._current_index = (self._current_index + 1) % len(self._options)
+            self._update_display()
+            event.stop()
+        elif event.key == "up" or event.key == "k":
+            self._current_index = (self._current_index - 1) % len(self._options)
+            self._update_display()
+            event.stop()
+        elif event.key == "enter" or event.key == "space":
+            self._show_popup()
+            event.stop()
+
+    def _show_popup(self) -> None:
+        """Show the options popup."""
+        if self._popup is not None:
+            self._popup.update_options(
+                self._options,
+                self._current_index,
+                on_select=self._on_popup_select,
+            )
+            self._popup.show_popup(self.region)
+
+    def _update_display(self) -> None:
+        """Update the displayed value and emit change event."""
+        label, value = self._options[self._current_index]
+        self.update(label)
+        self.post_message(self.FilterChanged(self._filter_type, value))
+
+    def set_options(self, options: list[tuple[str, str | None]]) -> None:
+        """Update available options."""
+        self._options = options
+        if self._current_index >= len(options):
+            self._current_index = 0
+            self._update_display()
+
+    def get_value(self) -> str | None:
+        """Get current filter value."""
+        return self._options[self._current_index][1]
+
+
+class FilterStatusLine(Horizontal):
+    """Filter status bar with bordered panels.
+
+    Shows: [Job Status] [Queue] [Search.....................]
+    Tab into Status/Queue and use up/down arrows to change.
+    """
+
+    class SearchChanged(Message):
+        """Emitted when search value changes."""
+
+        def __init__(self, value: str) -> None:
+            super().__init__()
+            self.value = value
+
+    STATUS_OPTIONS: list[tuple[str, str | None]] = [
+        ("All", None),
+        ("Running", "running"),
+        ("Pending", "pending"),
+        ("Held", "held"),
+    ]
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(id="filter-status", **kwargs)
+        self._search: str = ""
+        self._queues: list[str] = []
+
+    def compose(self):
+        """Create the status line widgets."""
+        yield FilterPanel(
+            "status",
+            self.STATUS_OPTIONS,
+            title="Status",
+            id="status-panel",
+        )
+
+        yield FilterPanel(
+            "queue",
+            [("All", None)],
+            title="Queue",
+            id="queue-panel",
+        )
+
+        with Vertical(id="search-container") as search_container:
+            search_container.border_title = "Search"
+            yield Input(placeholder="", id="search-input")
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Handle search input changes."""
+        if event.input.id == "search-input":
+            self._search = event.value
+            self.post_message(self.SearchChanged(event.value))
+
+    def focus_search(self) -> None:
+        """Focus the search input."""
+        self.query_one("#search-input", Input).focus()
+
+    def update_queues(self, queues: list[str]) -> None:
+        """Update available queue options."""
+        self._queues = queues
+        options: list[tuple[str, str | None]] = [("All", None)]
+        options.extend((q, q) for q in queues)
+        self.query_one("#queue-panel", FilterPanel).set_options(options)
+
+    def update_search(self, value: str) -> None:
+        """Update search display (only if different to avoid loops)."""
+        if self._search != value:
+            self._search = value
+            self.query_one("#search-input", Input).value = value