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

hpc_runner/tui/screens/job_details.py

@@ -0,0 +1,210 @@
+"""Job details modal screen."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Static, TextArea
+
+if TYPE_CHECKING:
+    from hpc_runner.core.job_info import JobInfo
+
+
+class JobDetailsScreen(ModalScreen[None]):
+    """Modal screen for viewing full job details.
+
+    Displays comprehensive job information including all resource requests,
+    paths, dependencies, and other metadata.
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+        Binding("q", "close", "Close"),
+        Binding("g", "go_top", "Top", show=False),
+        Binding("G", "go_bottom", "Bottom", show=False),
+        Binding("s", "screenshot", "Screenshot", show=False),
+    ]
+
+    def __init__(
+        self,
+        job: JobInfo,
+        extra_details: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the job details screen.
+
+        Args:
+            job: The JobInfo object to display.
+            extra_details: Additional details from qstat -j (resources, etc.)
+        """
+        super().__init__(**kwargs)
+        self._job = job
+        self._extra = extra_details or {}
+
+    def compose(self) -> ComposeResult:
+        """Create the modal content."""
+        with Vertical(id="job-details-dialog"):
+            yield TextArea(id="job-details-content", read_only=True)
+            yield Static("q/Esc close | g top | G bottom", id="job-details-hint")
+
+    def on_mount(self) -> None:
+        """Set up the dialog with job content."""
+        dialog = self.query_one("#job-details-dialog", Vertical)
+        # Keep title short to avoid truncation
+        dialog.border_title = f"Job: {self._job.job_id}"
+
+        # Build and display content
+        content = self._build_content()
+        text_area = self.query_one("#job-details-content", TextArea)
+        text_area.load_text(content)
+        text_area.focus()
+
+    def _build_content(self) -> str:
+        """Build the formatted job details content."""
+        job = self._job
+        lines: list[str] = []
+        resources = self._extra.get("resources", {})
+
+        # Section: Basic Info
+        lines.append("═══ Basic Information ═══")
+        lines.append("")
+        lines.append(f"  Job ID:      {job.job_id}")
+        lines.append(f"  Name:        {job.name}")
+        lines.append(f"  User:        {job.user}")
+        lines.append(f"  Status:      {job.status.name}")
+        lines.append(f"  Queue:       {job.queue or '—'}")
+        lines.append(f"  Node:        {job.node or '—'}")
+        lines.append("")
+
+        # Section: Command
+        job_args = self._extra.get("job_args", [])
+        script = self._extra.get("script_file")
+        command = self._extra.get("command")  # For qrsh interactive jobs
+        if job_args or script or command:
+            lines.append("═══ Command ═══")
+            lines.append("")
+            if command:
+                # Interactive job command (from QRSH_COMMAND)
+                lines.append(f"  Command:     {command}")
+            elif script:
+                lines.append(f"  Script:      {script}")
+                if job_args:
+                    lines.append(f"  Arguments:   {' '.join(job_args)}")
+            lines.append("")
+
+        # Section: Timing
+        lines.append("═══ Timing ═══")
+        lines.append("")
+        if job.submit_time:
+            lines.append(f"  Submitted:   {job.submit_time.strftime('%Y-%m-%d %H:%M:%S')}")
+        else:
+            lines.append("  Submitted:   —")
+        if job.start_time:
+            lines.append(f"  Started:     {job.start_time.strftime('%Y-%m-%d %H:%M:%S')}")
+        else:
+            lines.append("  Started:     —")
+        if job.end_time:
+            lines.append(f"  Ended:       {job.end_time.strftime('%Y-%m-%d %H:%M:%S')}")
+        lines.append(f"  Runtime:     {job.runtime_display}")
+        lines.append("")
+
+        # Section: Resources
+        lines.append("═══ Resources ═══")
+        lines.append("")
+
+        # Slots from PE
+        pe_name = self._extra.get("pe_name")
+        pe_range = self._extra.get("pe_range")
+        if pe_name:
+            lines.append(f"  PE:          {pe_name} ({pe_range or job.cpu or '?'} slots)")
+        else:
+            lines.append(f"  Slots/CPUs:  {job.cpu or '—'}")
+
+        # Memory - check resources dict for common memory keys
+        memory = job.memory
+        if not memory:
+            for key in ("h_vmem", "mem_free", "virtual_free", "mem", "memory"):
+                if key in resources:
+                    memory = resources[key]
+                    break
+        if memory:
+            lines.append(f"  Memory:      {memory}")
+
+        # GPU
+        if job.gpu:
+            lines.append(f"  GPUs:        {job.gpu}")
+
+        # All requested resources
+        if resources:
+            lines.append("")
+            lines.append("  All Requested Resources:")
+            for name, value in sorted(resources.items()):
+                lines.append(f"    {name}: {value}")
+        lines.append("")
+
+        # Section: Paths
+        lines.append("═══ Paths ═══")
+        lines.append("")
+        cwd = self._extra.get("cwd")
+        if cwd:
+            lines.append(f"  Working Dir: {cwd}")
+        lines.append(f"  Stdout:      {job.stdout_path or '—'}")
+        lines.append(f"  Stderr:      {job.stderr_path or '—'}")
+        lines.append("")
+
+        # Section: Dependencies
+        deps = self._extra.get("dependencies", [])
+        if deps or job.dependencies:
+            lines.append("═══ Dependencies ═══")
+            lines.append("")
+            all_deps = deps or job.dependencies or []
+            if all_deps:
+                for dep in all_deps:
+                    lines.append(f"  • {dep}")
+            else:
+                lines.append("  None")
+            lines.append("")
+
+        # Section: Array Job Info
+        if job.array_task_id is not None:
+            lines.append("═══ Array Job ═══")
+            lines.append("")
+            lines.append(f"  Task ID:     {job.array_task_id}")
+            lines.append("")
+
+        # Section: Other
+        project = self._extra.get("project")
+        department = self._extra.get("department")
+        if project or department:
+            lines.append("═══ Other ═══")
+            lines.append("")
+            if project:
+                lines.append(f"  Project:     {project}")
+            if department:
+                lines.append(f"  Department:  {department}")
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def action_close(self) -> None:
+        """Close the details viewer."""
+        self.dismiss(None)
+
+    def action_go_top(self) -> None:
+        """Scroll to top."""
+        text_area = self.query_one("#job-details-content", TextArea)
+        text_area.cursor_location = (0, 0)
+
+    def action_go_bottom(self) -> None:
+        """Scroll to bottom."""
+        text_area = self.query_one("#job-details-content", TextArea)
+        text_area.cursor_location = (len(text_area.document.lines) - 1, 0)
+
+    def action_screenshot(self) -> None:
+        """Save a screenshot."""
+        path = self.app.save_screenshot(path="./")
+        self.app.notify(f"Screenshot saved: {path}", timeout=3)

hpc_runner/tui/screens/log_viewer.py

@@ -0,0 +1,170 @@
+"""Log viewer modal screen."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Static, TextArea
+
+
+# Maximum lines to read from large files
+MAX_LINES = 5000
+
+
+class LogViewerScreen(ModalScreen[None]):
+    """Modal screen for viewing job log files.
+
+    Displays file content in a scrollable text area.
+    Styles are defined in monitor.tcss.
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+        Binding("q", "close", "Close"),
+        Binding("g", "go_top", "Top", show=False),
+        Binding("G", "go_bottom", "Bottom", show=False),
+        Binding("s", "screenshot", "Screenshot", show=False),
+    ]
+
+    def __init__(
+        self,
+        file_path: Path | str,
+        title: str = "Log Viewer",
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._file_path = Path(file_path) if isinstance(file_path, str) else file_path
+        self._title = title
+        self._content: str = ""
+        self._error: str | None = None
+
+    def compose(self) -> ComposeResult:
+        """Create the modal content."""
+        with Vertical(id="log-viewer-dialog"):
+            yield Static(str(self._file_path), id="log-viewer-path")
+            yield TextArea(id="log-viewer-content", read_only=True)
+            yield Static("q/Esc close | g top | G bottom", id="log-viewer-hint")
+
+    def on_mount(self) -> None:
+        """Set up the dialog and load file content."""
+        dialog = self.query_one("#log-viewer-dialog", Vertical)
+        dialog.border_title = self._title
+
+        # Load file content
+        self._load_file()
+
+        # Update text area with content
+        text_area = self.query_one("#log-viewer-content", TextArea)
+        if self._error:
+            text_area.load_text(self._error)
+        else:
+            text_area.load_text(self._content)
+            # Scroll to bottom by default (most recent output)
+            text_area.action_cursor_line_end()
+            self.call_after_refresh(self._scroll_to_bottom)
+
+        text_area.focus()
+
+    def _scroll_to_bottom(self) -> None:
+        """Scroll text area to bottom."""
+        text_area = self.query_one("#log-viewer-content", TextArea)
+        # Move cursor to end of document
+        text_area.cursor_location = (len(text_area.document.lines) - 1, 0)
+
+    def _load_file(self) -> None:
+        """Load content from the log file."""
+        if not self._file_path.exists():
+            self._error = f"File not found:\n{self._file_path}"
+            return
+
+        try:
+            # Check file size first
+            file_size = self._file_path.stat().st_size
+
+            if file_size == 0:
+                self._content = "(empty file)"
+                return
+
+            # For large files, read only the last N lines
+            if file_size > 1_000_000:  # 1MB threshold
+                self._content = self._read_tail()
+            else:
+                self._content = self._file_path.read_text(encoding="utf-8", errors="replace")
+
+                # Truncate if too many lines
+                lines = self._content.splitlines()
+                if len(lines) > MAX_LINES:
+                    self._content = (
+                        f"[Showing last {MAX_LINES} of {len(lines)} lines]\n\n"
+                        + "\n".join(lines[-MAX_LINES:])
+                    )
+
+        except PermissionError:
+            self._error = f"Permission denied:\n{self._file_path}"
+        except Exception as e:
+            self._error = f"Error reading file:\n{e}"
+
+    def _read_tail(self) -> str:
+        """Read the last N lines of a large file efficiently."""
+        lines: list[str] = []
+        try:
+            with open(self._file_path, "rb") as f:
+                # Seek to end
+                f.seek(0, 2)
+                file_size = f.tell()
+
+                # Read chunks from end
+                chunk_size = 8192
+                position = file_size
+                remaining = b""
+
+                while position > 0 and len(lines) < MAX_LINES:
+                    read_size = min(chunk_size, position)
+                    position -= read_size
+                    f.seek(position)
+                    chunk = f.read(read_size) + remaining
+
+                    # Split into lines
+                    chunk_lines = chunk.split(b"\n")
+                    remaining = chunk_lines[0]
+                    lines = [
+                        line.decode("utf-8", errors="replace")
+                        for line in chunk_lines[1:]
+                    ] + lines
+
+                # Add any remaining content
+                if remaining and len(lines) < MAX_LINES:
+                    lines.insert(0, remaining.decode("utf-8", errors="replace"))
+
+            # Trim to MAX_LINES
+            if len(lines) > MAX_LINES:
+                lines = lines[-MAX_LINES:]
+
+            return f"[Large file - showing last {len(lines)} lines]\n\n" + "\n".join(lines)
+
+        except Exception as e:
+            return f"Error reading file: {e}"
+
+    def action_close(self) -> None:
+        """Close the log viewer."""
+        self.dismiss(None)
+
+    def action_go_top(self) -> None:
+        """Scroll to top of file."""
+        text_area = self.query_one("#log-viewer-content", TextArea)
+        text_area.cursor_location = (0, 0)
+
+    def action_go_bottom(self) -> None:
+        """Scroll to bottom of file."""
+        text_area = self.query_one("#log-viewer-content", TextArea)
+        text_area.cursor_location = (len(text_area.document.lines) - 1, 0)
+
+    def action_screenshot(self) -> None:
+        """Save a screenshot."""
+        path = self.app.save_screenshot(path="./")
+        self.app.notify(f"Screenshot saved: {path}", timeout=3)

hpc_runner/tui/snapshot.py

@@ -0,0 +1,153 @@
+"""TUI Snapshot utility for visual review after edits.
+
+Usage:
+    python -m hpc_runner.tui.snapshot
+
+This captures a screenshot and reports key visual properties to catch
+regressions like solid backgrounds when transparency is expected.
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+from .app import HpcMonitorApp
+
+
+def _is_transparent(color) -> bool:
+    """Check if a color is transparent."""
+    if color is None:
+        return True
+    if color.a == 0:
+        return True
+    if hasattr(color, "ansi") and color.ansi == -1:
+        return True
+    return False
+
+
+def _color_hex(color) -> str:
+    """Convert color to hex string for display."""
+    if color is None:
+        return "None"
+    if hasattr(color, "ansi") and color.ansi == -1:
+        return "ANSI_DEFAULT (transparent)"
+    if color.a == 0:
+        return f"transparent (a=0)"
+    return f"#{color.r:02x}{color.g:02x}{color.b:02x}"
+
+
+async def capture_and_review() -> bool:
+    """Capture snapshot and review visual properties.
+
+    Returns:
+        True if all checks pass, False otherwise.
+    """
+    from textual.containers import HorizontalGroup
+    from textual.widgets import Tab, Header, TabbedContent, Static
+
+    app = HpcMonitorApp()
+    all_passed = True
+
+    async with app.run_test(size=(80, 24)) as pilot:
+        await pilot.pause()
+
+        # Save screenshot
+        screenshot_path = Path("tui_snapshot.svg")
+        app.save_screenshot(str(screenshot_path))
+
+        print("=" * 60)
+        print("TUI SNAPSHOT REVIEW")
+        print("=" * 60)
+        print(f"\nScreenshot saved to: {screenshot_path.absolute()}")
+        print(f"Theme: {app.theme}")
+        print(f"ANSI mode: {app.ansi_color}")
+
+        # Check Screen background
+        print("\n--- Background Transparency ---")
+        screen_bg = app.screen.styles.background
+        screen_ok = _is_transparent(screen_bg)
+        status = "✓ PASS" if screen_ok else "✗ FAIL"
+        print(f"  Screen background: {_color_hex(screen_bg)} {status}")
+        if not screen_ok:
+            all_passed = False
+            print("    ^ Should be transparent for terminal background to show")
+
+        # Check Header
+        header = app.query_one(Header)
+        header_bg = header.styles.background
+        header_ok = _is_transparent(header_bg)
+        status = "✓ PASS" if header_ok else "✗ FAIL"
+        print(f"  Header background: {_color_hex(header_bg)} {status}")
+        if not header_ok:
+            all_passed = False
+
+        # Check custom footer (#footer HorizontalGroup)
+        footer = app.query_one("#footer", HorizontalGroup)
+        footer_bg = footer.styles.background
+        footer_ok = _is_transparent(footer_bg)
+        status = "✓ PASS" if footer_ok else "✗ FAIL"
+        print(f"  Footer background: {_color_hex(footer_bg)} {status}")
+        if not footer_ok:
+            all_passed = False
+
+        # Check footer children (all should be transparent)
+        for child in footer.children:
+            child_bg = child.styles.background
+            child_ok = _is_transparent(child_bg)
+            status = "✓ PASS" if child_ok else "✗ FAIL"
+            child_classes = " ".join(child.classes) if child.classes else "(no class)"
+            print(f"    Footer child ({child_classes}): {_color_hex(child_bg)} {status}")
+            if not child_ok:
+                all_passed = False
+
+        # Check TabbedContent
+        tabbed = app.query_one(TabbedContent)
+        tabbed_bg = tabbed.styles.background
+        tabbed_ok = _is_transparent(tabbed_bg)
+        status = "✓ PASS" if tabbed_ok else "✗ FAIL"
+        print(f"  TabbedContent background: {_color_hex(tabbed_bg)} {status}")
+        if not tabbed_ok:
+            all_passed = False
+
+        # Check tabs
+        print("\n--- Tab Styling ---")
+        tabs = app.query(Tab)
+        for tab in tabs:
+            is_active = tab.has_class("-active")
+            bg = tab.styles.background
+
+            if is_active:
+                # Active tab should have primary color (#88C0D0)
+                active_ok = bg is not None and bg.r == 136 and bg.g == 192 and bg.b == 208
+                status = "✓ PASS" if active_ok else "✗ FAIL"
+                print(f"  Active tab '{tab.label.plain}': {_color_hex(bg)} {status}")
+                if not active_ok:
+                    all_passed = False
+                    print("    ^ Should be #88c0d0 (muted teal)")
+            else:
+                # Inactive tab should be transparent
+                inactive_ok = _is_transparent(bg)
+                status = "✓ PASS" if inactive_ok else "✗ FAIL"
+                print(f"  Inactive tab '{tab.label.plain}': {_color_hex(bg)} {status}")
+                if not inactive_ok:
+                    all_passed = False
+
+        # Summary
+        print("\n" + "=" * 60)
+        if all_passed:
+            print("RESULT: ✓ All visual checks passed")
+        else:
+            print("RESULT: ✗ Some checks failed - review needed!")
+        print("=" * 60)
+
+    return all_passed
+
+
+def main():
+    """Run snapshot review."""
+    passed = asyncio.run(capture_and_review())
+    sys.exit(0 if passed else 1)
+
+
+if __name__ == "__main__":
+    main()