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

hpc_runner/core/result.py

@@ -36,6 +36,7 @@ class JobResult:
     job: "Job"
 
     _cached_status: JobStatus | None = field(default=None, repr=False)
+    _exit_code: int | None = field(default=None, repr=False)  # For interactive jobs
 
     @property
     def status(self) -> JobStatus:
@@ -55,6 +56,9 @@ class JobResult:
     @property
     def returncode(self) -> int | None:
         """Get exit code (None if not complete)."""
+        # For interactive jobs, use cached exit code
+        if self._exit_code is not None:
+            return self._exit_code
         if not self.is_complete:
             return None
         return self.scheduler.get_exit_code(self.job_id)

hpc_runner/schedulers/base.py

@@ -1,41 +1,108 @@
-"""Abstract base class for scheduler implementations."""
+"""Base scheduler with rendering protocol."""
+
+from __future__ import annotations
 
 from abc import ABC, abstractmethod
+from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from hpc_runner.core.descriptors import SchedulerArg
+
 if TYPE_CHECKING:
     from hpc_runner.core.job import Job
     from hpc_runner.core.job_array import JobArray
+    from hpc_runner.core.job_info import JobInfo
     from hpc_runner.core.result import ArrayJobResult, JobResult, JobStatus
 
 
 class BaseScheduler(ABC):
-    """Abstract base class for scheduler implementations.
-
-    Each scheduler must implement:
-    - submit(): Submit a job
-    - submit_array(): Submit an array job
-    - cancel(): Cancel a job
-    - get_status(): Query job status
-    - get_exit_code(): Get job exit code
-    - get_output_path(): Get output file path
-    - generate_script(): Generate job script
-    - build_submit_command(): Build submission command
+    """Abstract base class for HPC schedulers.
+
+    Subclasses must:
+    1. Define `name` class attribute
+    2. Populate `ARG_RENDERERS` dict mapping Job attribute names to SchedulerArg instances
+    3. Implement abstract methods for job submission and management
+
+    The rendering protocol:
+    - `render_directives(job)` - Returns list of script directives
+    - `render_args(job)` - Returns list of command-line arguments
+
+    Both methods iterate over job.iter_attributes() and use ARG_RENDERERS
+    to convert values to scheduler-specific syntax.
     """
 
-    name: str  # e.g., "sge", "slurm", "local"
+    name: str = ""
 
-    @abstractmethod
-    def submit(self, job: "Job", interactive: bool = False) -> "JobResult":
-        """Submit a job to the scheduler.
+    # Subclasses populate this in __init__ with config-driven values
+    ARG_RENDERERS: dict[str, SchedulerArg] = {}
+
+    # =========================================================================
+    # Rendering Protocol
+    # =========================================================================
+
+    def render_directives(self, job: "Job") -> list[str]:
+        """Render job attributes as script directives.
+
+        Iterates over job's renderable attributes and uses ARG_RENDERERS
+        to convert each to the appropriate directive format.
+
+        Args:
+            job: The job to render
+
+        Returns:
+            List of directive strings (e.g., ['#$ -N jobname', '#$ -pe smp 4'])
+        """
+        directives: list[str] = []
+
+        for attr_name, value in job.iter_attributes():
+            renderer = self.ARG_RENDERERS.get(attr_name)
+            if renderer is None:
+                continue
+
+            directive = renderer.to_directive(value)
+            if directive is not None:
+                directives.append(directive)
+
+        return directives
+
+    def render_args(self, job: "Job") -> list[str]:
+        """Render job attributes as command-line arguments.
+
+        Iterates over job's renderable attributes and uses ARG_RENDERERS
+        to convert each to command-line argument format.
 
         Args:
-            job: Job specification
-            interactive: Run interactively (blocking)
+            job: The job to render
 
         Returns:
-            JobResult with job ID and methods
+            List of argument strings (e.g., ['-N', 'jobname', '-pe', 'smp', '4'])
+        """
+        args: list[str] = []
+
+        for attr_name, value in job.iter_attributes():
+            renderer = self.ARG_RENDERERS.get(attr_name)
+            if renderer is None:
+                continue
+
+            args.extend(renderer.to_args(value))
+
+        return args
+
+    # =========================================================================
+    # Abstract Methods - Subclasses must implement
+    # =========================================================================
+
+    @abstractmethod
+    def submit(
+        self, job: "Job", interactive: bool = False, keep_script: bool = False
+    ) -> "JobResult":
+        """Submit a job to the scheduler.
+
+        Args:
+            job: Job to submit.
+            interactive: If True, run interactively.
+            keep_script: If True, don't delete job script after submission.
         """
 
     @abstractmethod
@@ -44,33 +111,84 @@ class BaseScheduler(ABC):
 
     @abstractmethod
     def cancel(self, job_id: str) -> bool:
-        """Cancel a job by ID."""
+        """Cancel a job."""
 
     @abstractmethod
     def get_status(self, job_id: str) -> "JobStatus":
-        """Get current status of a job."""
+        """Get job status."""
 
     @abstractmethod
     def get_exit_code(self, job_id: str) -> int | None:
-        """Get exit code of completed job."""
+        """Get job exit code."""
 
     @abstractmethod
+    def generate_script(self, job: "Job", array_range: str | None = None) -> str:
+        """Generate submission script."""
+
+    @abstractmethod
+    def build_submit_command(self, job: "Job") -> list[str]:
+        """Build submission command line."""
+
+    @abstractmethod
+    def build_interactive_command(self, job: "Job") -> list[str]:
+        """Build interactive execution command."""
+
+    # =========================================================================
+    # Optional Methods - Override if scheduler supports these
+    # =========================================================================
+
     def get_output_path(self, job_id: str, stream: str) -> Path | None:
         """Get path to output file.
 
         Args:
             job_id: Job ID
             stream: "stdout" or "stderr"
-        """
 
-    @abstractmethod
-    def generate_script(self, job: "Job") -> str:
-        """Generate job script content."""
-
-    @abstractmethod
-    def build_submit_command(self, job: "Job") -> list[str]:
-        """Build the submission command (e.g., qsub args)."""
+        Returns:
+            Path to output file, or None if not determinable.
+        """
+        return None
 
     def get_scheduler_args(self, job: "Job") -> list[str]:
         """Get scheduler-specific raw args from job."""
         return getattr(job, f"{self.name}_args", [])
+
+    def list_active_jobs(
+        self,
+        user: str | None = None,
+        status: set["JobStatus"] | None = None,
+        queue: str | None = None,
+    ) -> list["JobInfo"]:
+        """List active jobs. Override in subclass."""
+        return []
+
+    def list_completed_jobs(
+        self,
+        user: str | None = None,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        exit_code: int | None = None,
+        queue: str | None = None,
+        limit: int = 100,
+    ) -> list["JobInfo"]:
+        """List completed jobs from accounting. Override in subclass."""
+        return []
+
+    def has_accounting(self) -> bool:
+        """Check if job accounting/history is available."""
+        return False
+
+    def get_job_details(self, job_id: str) -> tuple["JobInfo", dict[str, object]]:
+        """Get detailed information for a single job.
+
+        Args:
+            job_id: The job identifier.
+
+        Returns:
+            Tuple of (JobInfo, extra_details dict).
+
+        Raises:
+            JobNotFoundError: If job doesn't exist.
+            NotImplementedError: If not implemented by scheduler.
+        """
+        raise NotImplementedError(f"{self.name} does not implement get_job_details()")

hpc_runner/schedulers/detection.py

@@ -2,6 +2,23 @@
 
 import os
 import shutil
+import subprocess
+
+
+def _check_sge_via_qstat() -> bool:
+    """Check if qstat is SGE by examining its help output."""
+    try:
+        result = subprocess.run(
+            ["qstat", "-help"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        # SGE's qstat -help starts with "SGE" or "GE" version info
+        output = result.stdout + result.stderr
+        return "SGE" in output or "Grid Engine" in output
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return False
 
 
 def detect_scheduler() -> str:
@@ -9,7 +26,7 @@ def detect_scheduler() -> str:
 
     Order of precedence:
     1. HPC_SCHEDULER environment variable
-    2. SGE (check for qsub with SGE_ROOT)
+    2. SGE (check for SGE_ROOT or qstat -help output)
     3. Slurm (check for sbatch)
     4. PBS (check for qsub with PBS_CONF_FILE)
     5. Local fallback
@@ -18,9 +35,10 @@ def detect_scheduler() -> str:
     if scheduler := os.environ.get("HPC_SCHEDULER"):
         return scheduler.lower()
 
-    # Check for SGE (also uses qsub but has SGE_ROOT)
-    if shutil.which("qsub") and os.environ.get("SGE_ROOT"):
-        return "sge"
+    # Check for SGE (via SGE_ROOT or qstat help output)
+    if shutil.which("qsub"):
+        if os.environ.get("SGE_ROOT") or _check_sge_via_qstat():
+            return "sge"
 
     # Check for Slurm
     if shutil.which("sbatch") and shutil.which("squeue"):

hpc_runner/schedulers/local/scheduler.py

@@ -9,6 +9,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from hpc_runner.core.exceptions import AccountingNotAvailable, JobNotFoundError
+from hpc_runner.core.job_info import JobInfo
 from hpc_runner.core.result import ArrayJobResult, JobResult, JobStatus
 from hpc_runner.schedulers.base import BaseScheduler
 from hpc_runner.templates import render_template
@@ -28,7 +30,9 @@ class LocalScheduler(BaseScheduler):
     _exit_codes: dict[str, int] = {}
     _output_paths: dict[str, dict[str, Path]] = {}
 
-    def submit(self, job: "Job", interactive: bool = False) -> JobResult:
+    def submit(
+        self, job: "Job", interactive: bool = False, keep_script: bool = False
+    ) -> JobResult:
         """Run job as local subprocess."""
         LocalScheduler._job_counter += 1
         job_id = f"local_{LocalScheduler._job_counter}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
@@ -224,7 +228,7 @@ class LocalScheduler(BaseScheduler):
             return LocalScheduler._output_paths[job_id].get(stream)
         return None
 
-    def generate_script(self, job: "Job") -> str:
+    def generate_script(self, job: "Job", array_range: str | None = None) -> str:
         """Generate local execution script."""
         return render_template(
             "local/templates/job.sh.j2",
@@ -235,3 +239,116 @@ class LocalScheduler(BaseScheduler):
     def build_submit_command(self, job: "Job") -> list[str]:
         """Build command - for local, just bash."""
         return ["bash", "-c", job.command if isinstance(job.command, str) else " ".join(job.command)]
+
+    def build_interactive_command(self, job: "Job") -> list[str]:
+        """Build interactive command - for local, just bash."""
+        return ["bash", "-c", job.command if isinstance(job.command, str) else " ".join(job.command)]
+
+    # -------------------------------------------------------------------------
+    # TUI Monitor API (stubs for local scheduler)
+    # -------------------------------------------------------------------------
+
+    def list_active_jobs(
+        self,
+        user: str | None = None,
+        status: set[JobStatus] | None = None,
+        queue: str | None = None,
+    ) -> list[JobInfo]:
+        """List active local jobs.
+
+        The local scheduler tracks running processes in memory.
+        """
+        jobs: list[JobInfo] = []
+        current_user = os.environ.get("USER", "unknown")
+
+        for job_id, proc in LocalScheduler._processes.items():
+            poll = proc.poll()
+            if poll is None:  # Still running
+                job_status = JobStatus.RUNNING
+            else:
+                continue  # Skip completed jobs
+
+            # Apply filters
+            if user is not None and user != current_user:
+                continue
+            if status is not None and job_status not in status:
+                continue
+            # queue filter doesn't apply to local scheduler
+
+            jobs.append(
+                JobInfo(
+                    job_id=job_id,
+                    name=job_id,  # Local scheduler doesn't track job names
+                    user=current_user,
+                    status=job_status,
+                    queue="local",
+                )
+            )
+
+        return jobs
+
+    def list_completed_jobs(
+        self,
+        user: str | None = None,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        exit_code: int | None = None,
+        queue: str | None = None,
+        limit: int = 100,
+    ) -> list[JobInfo]:
+        """List completed local jobs.
+
+        The local scheduler does not persist job history, so this
+        raises AccountingNotAvailable.
+        """
+        raise AccountingNotAvailable(
+            "Local scheduler does not persist job history. "
+            "Completed job information is only available during the current session."
+        )
+
+    def has_accounting(self) -> bool:
+        """Check if job accounting is available.
+
+        Local scheduler does not have persistent accounting.
+        """
+        return False
+
+    def get_job_details(self, job_id: str) -> tuple[JobInfo, dict[str, object]]:
+        """Get details for a local job."""
+        current_user = os.environ.get("USER", "unknown")
+
+        # Check running processes
+        if job_id in LocalScheduler._processes:
+            proc = LocalScheduler._processes[job_id]
+            poll = proc.poll()
+            status = JobStatus.RUNNING if poll is None else (
+                JobStatus.COMPLETED if poll == 0 else JobStatus.FAILED
+            )
+            job_info = JobInfo(
+                job_id=job_id,
+                name=job_id,
+                user=current_user,
+                status=status,
+                queue="local",
+                exit_code=poll if poll is not None else None,
+                stdout_path=LocalScheduler._output_paths.get(job_id, {}).get("stdout"),
+                stderr_path=LocalScheduler._output_paths.get(job_id, {}).get("stderr"),
+            )
+            return job_info, {}
+
+        # Check completed jobs with cached exit codes
+        if job_id in LocalScheduler._exit_codes:
+            exit_code = LocalScheduler._exit_codes[job_id]
+            job_info = JobInfo(
+                job_id=job_id,
+                name=job_id,
+                user=current_user,
+                status=JobStatus.COMPLETED if exit_code == 0 else JobStatus.FAILED,
+                queue="local",
+                exit_code=exit_code,
+                stdout_path=LocalScheduler._output_paths.get(job_id, {}).get("stdout"),
+                stderr_path=LocalScheduler._output_paths.get(job_id, {}).get("stderr"),
+            )
+            return job_info, {}
+
+        raise JobNotFoundError(f"Job {job_id} not found")