hpc-runner 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

hpc_runner/schedulers/sge/scheduler.py

@@ -6,31 +6,12 @@ import os
 import subprocess
 import tempfile
 import uuid
+import xml.etree.ElementTree as ET
 from datetime import datetime
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 from hpc_runner.core.config import get_config
-
-
-def get_script_dir() -> Path:
-    """Get directory for temporary job scripts.
-
-    Uses HPC_SCRIPT_DIR environment variable if set, otherwise
-    defaults to ~/.cache/hpc-runner/scripts/.
-
-    Returns:
-        Path to script directory (created if needed).
-    """
-    if env_dir := os.environ.get("HPC_SCRIPT_DIR"):
-        script_dir = Path(env_dir)
-    else:
-        script_dir = Path.home() / ".cache" / "hpc-runner" / "scripts"
-
-    script_dir.mkdir(parents=True, exist_ok=True)
-    return script_dir
-
-
 from hpc_runner.core.job_info import JobInfo
 from hpc_runner.core.result import ArrayJobResult, JobResult, JobStatus
 from hpc_runner.schedulers.base import BaseScheduler
@@ -64,6 +45,24 @@ if TYPE_CHECKING:
     from hpc_runner.core.job_array import JobArray
 
 
+def get_script_dir() -> Path:
+    """Get directory for temporary job scripts.
+
+    Uses HPC_SCRIPT_DIR environment variable if set, otherwise
+    defaults to ~/.cache/hpc-runner/scripts/.
+
+    Returns:
+        Path to script directory (created if needed).
+    """
+    if env_dir := os.environ.get("HPC_SCRIPT_DIR"):
+        script_dir = Path(env_dir)
+    else:
+        script_dir = Path.home() / ".cache" / "hpc-runner" / "scripts"
+
+    script_dir.mkdir(parents=True, exist_ok=True)
+    return script_dir
+
+
 class SGEScheduler(BaseScheduler):
     """Sun Grid Engine scheduler implementation."""
 
@@ -80,7 +79,7 @@ class SGEScheduler(BaseScheduler):
         self.time_resource = sge_config.get("time_resource", "h_rt")
 
         # Module handling config
-        self.purge_modules = sge_config.get("purge_modules", False)
+        self.purge_modules = sge_config.get("purge_modules", True)
         self.silent_modules = sge_config.get("silent_modules", False)
         self.module_init_script = sge_config.get("module_init_script", "")
 
@@ -119,7 +118,7 @@ class SGEScheduler(BaseScheduler):
 
     def generate_script(
         self,
-        job: "Job",
+        job: Job,
         array_range: str | None = None,
         keep_script: bool = False,
         script_path: str | None = None,
@@ -142,7 +141,19 @@ class SGEScheduler(BaseScheduler):
             keep_script=keep_script,
         )
 
-    def _build_directives(self, job: "Job", array_range: str | None = None) -> list[str]:
+    def generate_interactive_script(
+        self, job: Job, script_path: str, keep_script: bool = False
+    ) -> str:
+        """Generate wrapper script for interactive jobs."""
+        return render_template(
+            "sge/templates/interactive.sh.j2",
+            job=job,
+            scheduler=self,
+            script_path=script_path,
+            keep_script=keep_script,
+        )
+
+    def _build_directives(self, job: Job, array_range: str | None = None) -> list[str]:
         """Build complete list of #$ directives for the job.
 
         Uses the rendering protocol from BaseScheduler, then adds
@@ -182,7 +193,7 @@ class SGEScheduler(BaseScheduler):
 
         return directives
 
-    def _build_dependency_string(self, job: "Job") -> str | None:
+    def _build_dependency_string(self, job: Job) -> str | None:
         """Build SGE dependency string from job dependencies."""
         # String-based dependency from CLI
         if job.dependency:
@@ -200,7 +211,7 @@ class SGEScheduler(BaseScheduler):
     # Command Building
     # =========================================================================
 
-    def build_submit_command(self, job: "Job") -> list[str]:
+    def build_submit_command(self, job: Job) -> list[str]:
         """Build qsub command line."""
         cmd = ["qsub"]
         cmd.extend(self.render_args(job))
@@ -208,7 +219,7 @@ class SGEScheduler(BaseScheduler):
         cmd.extend(job.sge_args)
         return cmd
 
-    def build_interactive_command(self, job: "Job") -> list[str]:
+    def build_interactive_command(self, job: Job) -> list[str]:
         """Build qrsh command for interactive jobs.
 
         Note: qrsh supports a subset of qsub options. Notably:
@@ -242,9 +253,7 @@ class SGEScheduler(BaseScheduler):
     # Job Submission
     # =========================================================================
 
-    def submit(
-        self, job: "Job", interactive: bool = False, keep_script: bool = False
-    ) -> JobResult:
+    def submit(self, job: Job, interactive: bool = False, keep_script: bool = False) -> JobResult:
         """Submit a job to SGE.
 
         Args:
@@ -257,7 +266,7 @@ class SGEScheduler(BaseScheduler):
             return self._submit_interactive(job, keep_script=keep_script)
         return self._submit_batch(job, keep_script=keep_script)
 
-    def _submit_batch(self, job: "Job", keep_script: bool = False) -> JobResult:
+    def _submit_batch(self, job: Job, keep_script: bool = False) -> JobResult:
         """Submit via qsub."""
         # Determine script path first (needed for self-deletion in template)
         script_dir = get_script_dir()
@@ -265,17 +274,18 @@ class SGEScheduler(BaseScheduler):
         script_path = script_dir / script_name
 
         # Generate script with cleanup instruction
-        script = self.generate_script(
-            job, keep_script=keep_script, script_path=str(script_path)
-        )
+        script = self.generate_script(job, keep_script=keep_script, script_path=str(script_path))
 
         script_path.write_text(script)
         script_path.chmod(0o755)
 
         if keep_script:
             import sys
+
             print(f"Script saved: {script_path}", file=sys.stderr)
 
+        workdir = Path(job.workdir).resolve() if job.workdir else None
+
         try:
             result = subprocess.run(
                 ["qsub", str(script_path)],
@@ -283,6 +293,7 @@ class SGEScheduler(BaseScheduler):
                 text=True,
                 errors="replace",
                 check=True,
+                cwd=workdir,
             )
             job_id = parse_qsub_output(result.stdout)
 
@@ -296,7 +307,7 @@ class SGEScheduler(BaseScheduler):
             if not keep_script:
                 script_path.unlink(missing_ok=True)
 
-    def _submit_interactive(self, job: "Job", keep_script: bool = False) -> JobResult:
+    def _submit_interactive(self, job: Job, keep_script: bool = False) -> JobResult:
         """Submit via qrsh for interactive execution.
 
         Creates a wrapper script with full environment setup (modules, venv, etc.)
@@ -312,9 +323,7 @@ class SGEScheduler(BaseScheduler):
         script_path = script_dir / script_name
 
         # Generate wrapper script with the actual path (for self-deletion)
-        script = self._generate_interactive_script(
-            job, str(script_path), keep_script=keep_script
-        )
+        script = self.generate_interactive_script(job, str(script_path), keep_script=keep_script)
 
         # Write script to shared filesystem
         script_path.write_text(script)
@@ -323,13 +332,16 @@ class SGEScheduler(BaseScheduler):
         if keep_script:
             # Print script path for debugging
             import sys
+
             print(f"Script saved: {script_path}", file=sys.stderr)
 
         # Build qrsh command with script path
         cmd = self._build_qrsh_command(job, str(script_path))
 
+        workdir = Path(job.workdir).resolve() if job.workdir else None
+
         # Run and capture exit code
-        result = subprocess.run(cmd, check=False)
+        result = subprocess.run(cmd, check=False, cwd=workdir)
 
         # Clean up if script still exists and we're not keeping it
         if not keep_script:
@@ -342,19 +354,7 @@ class SGEScheduler(BaseScheduler):
             _exit_code=result.returncode,
         )
 
-    def _generate_interactive_script(
-        self, job: "Job", script_path: str, keep_script: bool = False
-    ) -> str:
-        """Generate wrapper script for interactive jobs."""
-        return render_template(
-            "sge/templates/interactive.sh.j2",
-            job=job,
-            scheduler=self,
-            script_path=script_path,
-            keep_script=keep_script,
-        )
-
-    def _build_qrsh_command(self, job: "Job", script_path: str) -> list[str]:
+    def _build_qrsh_command(self, job: Job, script_path: str) -> list[str]:
         """Build qrsh command to run wrapper script."""
         cmd = ["qrsh"]
 
@@ -376,22 +376,23 @@ class SGEScheduler(BaseScheduler):
 
         return cmd
 
-    def submit_array(self, array: "JobArray") -> ArrayJobResult:
+    def submit_array(self, array: JobArray) -> ArrayJobResult:
         """Submit array job."""
         script = self.generate_script(array.job, array_range=array.range_str)
 
-        with tempfile.NamedTemporaryFile(
-            mode="w", suffix=".sh", delete=False, prefix="hpc_"
-        ) as f:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False, prefix="hpc_") as f:
             f.write(script)
             script_path = f.name
 
+        workdir = Path(array.job.workdir).resolve() if array.job.workdir else None
+
         try:
             result = subprocess.run(
                 ["qsub", script_path],
                 capture_output=True,
                 text=True,
                 check=True,
+                cwd=workdir,
             )
             job_id = parse_qsub_output(result.stdout)
 
@@ -636,17 +637,19 @@ class SGEScheduler(BaseScheduler):
         if basic_info:
             # Merge detailed info with basic info
             if job_data.get("stdout_path"):
-                basic_info.stdout_path = job_data["stdout_path"]
+                basic_info.stdout_path = cast(Path, job_data["stdout_path"])
             if job_data.get("stderr_path"):
-                basic_info.stderr_path = job_data["stderr_path"]
+                basic_info.stderr_path = cast(Path, job_data["stderr_path"])
             if job_data.get("node"):
-                basic_info.node = job_data["node"]
+                basic_info.node = cast(str, job_data["node"])
 
             # Always use timing from detailed qstat -j output (more reliable)
             if job_data.get("submit_time"):
-                basic_info.submit_time = datetime.fromtimestamp(job_data["submit_time"])
+                ts = cast(float, job_data["submit_time"])
+                basic_info.submit_time = datetime.fromtimestamp(ts)
             if job_data.get("start_time"):
-                basic_info.start_time = datetime.fromtimestamp(job_data["start_time"])
+                ts = cast(float, job_data["start_time"])
+                basic_info.start_time = datetime.fromtimestamp(ts)
                 # Calculate runtime if running
                 if basic_info.status == JobStatus.RUNNING:
                     basic_info.runtime = datetime.now() - basic_info.start_time
@@ -656,19 +659,19 @@ class SGEScheduler(BaseScheduler):
             # Build from scratch using qstat -j data
             job_info = JobInfo(
                 job_id=job_id,
-                name=job_data.get("name", job_id),
-                user=job_data.get("user", "unknown"),
-                status=job_data.get("status", JobStatus.UNKNOWN),
-                queue=job_data.get("queue"),
-                stdout_path=job_data.get("stdout_path"),
-                stderr_path=job_data.get("stderr_path"),
-                node=job_data.get("node"),
+                name=cast(str, job_data.get("name", job_id)),
+                user=cast(str, job_data.get("user", "unknown")),
+                status=cast(JobStatus, job_data.get("status", JobStatus.UNKNOWN)),
+                queue=cast("str | None", job_data.get("queue")),
+                stdout_path=cast("Path | None", job_data.get("stdout_path")),
+                stderr_path=cast("Path | None", job_data.get("stderr_path")),
+                node=cast("str | None", job_data.get("node")),
             )
             # Add timing info
             if job_data.get("submit_time"):
-                job_info.submit_time = datetime.fromtimestamp(job_data["submit_time"])
+                job_info.submit_time = datetime.fromtimestamp(cast(float, job_data["submit_time"]))
             if job_data.get("start_time"):
-                job_info.start_time = datetime.fromtimestamp(job_data["start_time"])
+                job_info.start_time = datetime.fromtimestamp(cast(float, job_data["start_time"]))
                 if job_info.status == JobStatus.RUNNING:
                     job_info.runtime = datetime.now() - job_info.start_time
             return job_info, extra_details
@@ -684,7 +687,6 @@ class SGEScheduler(BaseScheduler):
         - Dependencies: list of job IDs
         - Other: project, department
         """
-        import xml.etree.ElementTree as ET
 
         data: dict[str, object] = {}
 
@@ -748,9 +750,7 @@ class SGEScheduler(BaseScheduler):
                 pass
 
         # Start time (for running jobs) - in JB_ja_tasks/ulong_sublist/JAT_start_time
-        task_start_text = job_info.findtext(
-            ".//JB_ja_tasks/ulong_sublist/JAT_start_time"
-        )
+        task_start_text = job_info.findtext(".//JB_ja_tasks/ulong_sublist/JAT_start_time")
         if task_start_text:
             try:
                 data["start_time"] = int(task_start_text)
@@ -850,9 +850,8 @@ class SGEScheduler(BaseScheduler):
 
         return data
 
-    def _strip_xml_namespaces(self, root: "ET.Element") -> None:
+    def _strip_xml_namespaces(self, root: ET.Element) -> None:
         """Strip namespaces so ElementTree can match tag names directly."""
-        import xml.etree.ElementTree as ET
 
         for elem in root.iter():
             if isinstance(elem.tag, str) and "}" in elem.tag:
@@ -863,9 +862,8 @@ class SGEScheduler(BaseScheduler):
         cleaned = "".join(ch if 32 <= ord(ch) < 127 else " " for ch in value)
         return " ".join(cleaned.split())
 
-    def _parse_xml_root(self, xml_output: str) -> "ET.Element | None":
+    def _parse_xml_root(self, xml_output: str) -> ET.Element | None:
         """Parse XML output, tolerating leading/trailing non-XML noise."""
-        import xml.etree.ElementTree as ET
 
         try:
             return ET.fromstring(xml_output)

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

@@ -80,11 +80,6 @@ if [ -n "$MAKEFLAGS" ]; then
 fi
 {% endif %}
 
-{% if job.workdir %}
-# Change to working directory
-cd {{ job.workdir }}
-{% endif %}
-
 # Execute command
 {{ job.command }}
 _exit_code=$?

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

@@ -76,11 +76,6 @@ if [ -n "$MAKEFLAGS" ]; then
 fi
 {% endif %}
 
-{% if job.workdir %}
-# Change to working directory
-cd {{ job.workdir }}
-{% endif %}
-
 # Execute command
 {{ job.command }}
 _exit_code=$?

hpc_runner/tui/app.py

@@ -31,7 +31,6 @@ from hpc_runner.tui.components import (
 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).
@@ -110,9 +109,7 @@ class HpcMonitorApp(App[None]):
                     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"
-                )
+                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")
@@ -167,10 +164,10 @@ class HpcMonitorApp(App[None]):
         """Quit the application."""
         self.exit()
 
-    def action_screenshot(self) -> None:
+    def action_screenshot(self, filename: str | None = None, path: str | None = None) -> None:
         """Save a screenshot to the current directory."""
-        path = self.save_screenshot(path="./")
-        self.notify(f"Screenshot saved: {path}", timeout=3)
+        result = self.save_screenshot(path=path or "./", filename=filename)
+        self.notify(f"Screenshot saved: {result}", timeout=3)
 
     def action_help(self) -> None:
         """Show help popup."""
@@ -206,7 +203,7 @@ class HpcMonitorApp(App[None]):
         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)
+        self.run_worker(self._fetch_and_update_jobs, exclusive=True)  # type: ignore[arg-type]
 
     async def _fetch_and_update_jobs(self) -> None:
         """Async coroutine to fetch jobs and update the table."""
@@ -237,10 +234,7 @@ class HpcMonitorApp(App[None]):
 
         # Filter by status
         if self._status_filter:
-            filtered = [
-                j for j in filtered
-                if j.status.name.lower() == self._status_filter.lower()
-            ]
+            filtered = [j for j in filtered if j.status.name.lower() == self._status_filter.lower()]
 
         # Filter by queue
         if self._queue_filter:
@@ -250,8 +244,7 @@ class HpcMonitorApp(App[None]):
         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()
+                j for j in filtered if search in j.name.lower() or search in j.job_id.lower()
             ]
 
         # Update table
@@ -301,9 +294,7 @@ class HpcMonitorApp(App[None]):
         """Focus the search input."""
         self.query_one(FilterStatusLine).focus_search()
 
-    def on_filter_panel_filter_changed(
-        self, event: FilterPanel.FilterChanged
-    ) -> None:
+    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
@@ -311,9 +302,7 @@ class HpcMonitorApp(App[None]):
             self._queue_filter = event.value
         self._apply_filters_and_display()
 
-    def on_filter_status_line_search_changed(
-        self, event: FilterStatusLine.SearchChanged
-    ) -> None:
+    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()
@@ -325,6 +314,8 @@ class HpcMonitorApp(App[None]):
         """
         # Start with basic info from the event
         job_info = event.job_info
+        if job_info is None:
+            return
         self._selected_job_extra = {}
         self._last_detail_error: str | None = None
 
@@ -394,17 +385,14 @@ class HpcMonitorApp(App[None]):
         """Handle request to cancel a job."""
         job = event.job
 
-        def handle_confirm(confirmed: bool) -> None:
+        def handle_confirm(confirmed: bool | None) -> 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}"
-        )
+        message = f"[bold]Job ID:[/]  {job.job_id}\n[bold]Name:[/]    {job.name}"
         self.push_screen(
             ConfirmScreen(
                 message=message,
@@ -423,6 +411,7 @@ class HpcMonitorApp(App[None]):
         try:
             # Run cancel in thread pool to avoid blocking
             import asyncio
+
             loop = asyncio.get_event_loop()
             await loop.run_in_executor(
                 None,

hpc_runner/tui/components/filter_bar.py

@@ -9,8 +9,6 @@ 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
 
@@ -112,9 +110,9 @@ class FilterBar(Horizontal):
     def on_select_changed(self, event: Select.Changed) -> None:
         """Handle dropdown selection changes."""
         if event.select.id == "status-filter":
-            self._current_status = event.value
+            self._current_status = str(event.value) if event.value != Select.BLANK else None
         elif event.select.id == "queue-filter":
-            self._current_queue = event.value
+            self._current_queue = str(event.value) if event.value != Select.BLANK else None
 
         self._emit_filter_changed()
 

hpc_runner/tui/components/filter_popup.py

@@ -2,8 +2,13 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
+from typing import Any
+
 from textual import events, on
+from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical
+from textual.geometry import Region
 from textual.message import Message
 from textual.widgets import Input, OptionList, Static
 from textual.widgets.option_list import Option
@@ -42,7 +47,7 @@ class HelpPopup(Static, can_focus=True):
     }
     """
 
-    def __init__(self, **kwargs) -> None:
+    def __init__(self, **kwargs: Any) -> None:
         super().__init__(self.HELP_TEXT, **kwargs)
         self.add_class("hidden")
 
@@ -116,8 +121,8 @@ class FilterPanelPopup(OptionList):
         self,
         options: list[tuple[str, str | None]],
         current_index: int = 0,
-        on_select: callable = None,
-        **kwargs,
+        on_select: Callable[[int], None] | None = None,
+        **kwargs: Any,
     ) -> None:
         super().__init__(**kwargs)
         self._panel_options = options
@@ -140,7 +145,7 @@ class FilterPanelPopup(OptionList):
         self,
         options: list[tuple[str, str | None]],
         current_index: int,
-        on_select: callable = None,
+        on_select: Callable[[int], None] | None = None,
     ) -> None:
         """Update options and current selection."""
         self._panel_options = options
@@ -150,7 +155,7 @@ class FilterPanelPopup(OptionList):
         if self.is_mounted:
             self._refresh_options()
 
-    def show_popup(self, region) -> None:
+    def show_popup(self, region: Region) -> None:
         """Show popup positioned relative to parent widget."""
         self.remove_class("hidden")
         self.styles.offset = (region.x, region.y + region.height)
@@ -199,7 +204,7 @@ class FilterPanel(Static, can_focus=True):
         filter_type: str,
         options: list[tuple[str, str | None]],
         title: str = "",
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         """Initialize filter panel.
 
@@ -296,12 +301,12 @@ class FilterStatusLine(Horizontal):
         ("Held", "held"),
     ]
 
-    def __init__(self, **kwargs) -> None:
+    def __init__(self, **kwargs: Any) -> None:
         super().__init__(id="filter-status", **kwargs)
         self._search: str = ""
         self._queues: list[str] = []
 
-    def compose(self):
+    def compose(self) -> ComposeResult:
         """Create the status line widgets."""
         yield FilterPanel(
             "status",

hpc_runner/tui/components/job_table.py

@@ -8,7 +8,7 @@ from hpc_runner.core.job_info import JobInfo
 from hpc_runner.core.result import JobStatus
 
 
-class JobTable(DataTable):
+class JobTable(DataTable[str]):
     """DataTable for displaying HPC jobs.
 
     Displays job information in a tabular format with columns for
@@ -79,7 +79,7 @@ class JobTable(DataTable):
         """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 int(content_size.width)
         return self.size.width or self.app.console.size.width
 
     def _calculate_name_width(self, table_width: int) -> int:
@@ -115,7 +115,7 @@ class JobTable(DataTable):
     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")
+        name_column = self.columns.get("name")  # type: ignore[call-overload]
         if name_column is not None:
             name_column.width = width
         if self._jobs:
@@ -132,9 +132,7 @@ class JobTable(DataTable):
                 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
-            )
+            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:
@@ -223,9 +221,7 @@ class JobTable(DataTable):
         }
         return status_map.get(status, str(status.name))
 
-    def on_data_table_row_highlighted(
-        self, event: DataTable.RowHighlighted
-    ) -> None:
+    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)

hpc_runner/tui/providers/jobs.py

@@ -37,7 +37,7 @@ class JobProvider:
         current_user: The current username for filtering.
     """
 
-    def __init__(self, scheduler: "BaseScheduler") -> None:
+    def __init__(self, scheduler: BaseScheduler) -> None:
         """Initialize the job provider.
 
         Args:
@@ -78,9 +78,7 @@ class JobProvider:
             )
             return jobs
         except NotImplementedError:
-            logger.warning(
-                f"Scheduler {self.scheduler.name} does not implement list_active_jobs"
-            )
+            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}")
@@ -141,7 +139,7 @@ class JobProvider:
             logger.error(f"Error fetching completed jobs: {e}")
             return []
 
-    async def get_job_details(self, job_id: str) -> JobInfo | None:
+    async def get_job_details(self, job_id: str) -> tuple[JobInfo, dict[str, object]] | None:
         """Get detailed information for a single job.
 
         Args: