hpc-runner 0.2.0__py3-none-any.whl

hpc_runner/cli/status.py

@@ -0,0 +1,66 @@
+"""Status command - check job status."""
+
+
+import rich_click as click
+from rich.console import Console
+from rich.table import Table
+
+from hpc_runner.cli.main import Context, pass_context
+
+console = Console()
+
+
+@click.command()
+@click.argument("job_id", required=False)
+@click.option("--all", "all_users", is_flag=True, help="Show all users' jobs")
+@click.option("--watch", is_flag=True, help="Watch mode (refresh periodically)")
+@pass_context
+def status(
+    ctx: Context,
+    job_id: str | None,
+    all_users: bool,
+    watch: bool,
+) -> None:
+    """Check job status.
+
+    If JOB_ID is provided, show status of that specific job.
+    Otherwise, list all your jobs.
+    """
+    from hpc_runner.schedulers import get_scheduler
+
+    scheduler = get_scheduler(ctx.scheduler)
+
+    if job_id:
+        # Show specific job status
+        status = scheduler.get_status(job_id)
+        exit_code = scheduler.get_exit_code(job_id)
+
+        table = Table(title=f"Job {job_id}")
+        table.add_column("Property", style="cyan")
+        table.add_column("Value")
+
+        table.add_row("Status", _status_style(status.name))
+        if exit_code is not None:
+            table.add_row("Exit Code", str(exit_code))
+
+        console.print(table)
+    else:
+        # List all jobs (not implemented for all schedulers)
+        console.print(
+            "[yellow]Listing all jobs requires scheduler-specific implementation[/yellow]"
+        )
+        console.print("Use 'hpc status <job_id>' to check a specific job")
+
+
+def _status_style(status: str) -> str:
+    """Apply color to status string."""
+    colors = {
+        "PENDING": "[yellow]PENDING[/yellow]",
+        "RUNNING": "[blue]RUNNING[/blue]",
+        "COMPLETED": "[green]COMPLETED[/green]",
+        "FAILED": "[red]FAILED[/red]",
+        "CANCELLED": "[magenta]CANCELLED[/magenta]",
+        "TIMEOUT": "[red]TIMEOUT[/red]",
+        "UNKNOWN": "[dim]UNKNOWN[/dim]",
+    }
+    return colors.get(status, status)

hpc_runner/core/__init__.py

@@ -0,0 +1,31 @@
+"""Core models and abstractions for hpc-tools."""
+
+from .exceptions import (
+    AccountingNotAvailable,
+    ConfigError,
+    ConfigNotFoundError,
+    HPCToolsError,
+    JobNotFoundError,
+    SchedulerError,
+    SubmissionError,
+    ValidationError,
+)
+from .job_info import JobInfo
+from .result import ArrayJobResult, JobResult, JobStatus
+
+__all__ = [
+    # Exceptions
+    "AccountingNotAvailable",
+    "ConfigError",
+    "ConfigNotFoundError",
+    "HPCToolsError",
+    "JobNotFoundError",
+    "SchedulerError",
+    "SubmissionError",
+    "ValidationError",
+    # Types
+    "JobInfo",
+    "JobResult",
+    "ArrayJobResult",
+    "JobStatus",
+]

hpc_runner/core/config.py

@@ -0,0 +1,177 @@
+"""Configuration loading and management."""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+@dataclass
+class HPCConfig:
+    """Loaded configuration."""
+
+    defaults: dict[str, Any] = field(default_factory=dict)
+    tools: dict[str, dict[str, Any]] = field(default_factory=dict)
+    types: dict[str, dict[str, Any]] = field(default_factory=dict)
+    schedulers: dict[str, dict[str, Any]] = field(default_factory=dict)
+
+    _source_path: Path | None = field(default=None, repr=False)
+
+    def get_job_config(self, tool_or_type: str) -> dict[str, Any]:
+        """Get merged configuration for a tool or type.
+
+        Lookup order:
+        1. Check types[tool_or_type]
+        2. Check tools[tool_or_type]
+        3. Fall back to defaults
+        """
+        config = self.defaults.copy()
+
+        if tool_or_type in self.types:
+            config = _merge(config, self.types[tool_or_type])
+        elif tool_or_type in self.tools:
+            config = _merge(config, self.tools[tool_or_type])
+
+        return config
+
+    def get_tool_config(self, command: str) -> dict[str, Any]:
+        """Get configuration matching a command.
+
+        Extracts tool name from command and looks up config.
+        """
+        # Extract tool name (first word, strip path)
+        tool = command.split()[0]
+        tool = Path(tool).name
+
+        return self.get_job_config(tool)
+
+    def get_scheduler_config(self, scheduler: str) -> dict[str, Any]:
+        """Get scheduler-specific configuration."""
+        return self.schedulers.get(scheduler, {})
+
+
+def _merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    """Deep merge with override taking precedence."""
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _merge(result[key], value)
+        elif key in result and isinstance(result[key], list) and isinstance(value, list):
+            # Check for list reset marker
+            if value and value[0] == "-":
+                result[key] = value[1:]
+            else:
+                result[key] = list(set(result[key] + value))
+        else:
+            result[key] = value
+    return result
+
+
+def find_config_file() -> Path | None:
+    """Find configuration file in priority order.
+
+    Search order:
+    1. ./hpc-tools.toml (current directory)
+    2. ./pyproject.toml [tool.hpc-tools] section
+    3. Git repository root hpc-tools.toml
+    4. ~/.config/hpc-tools/config.toml
+    5. Package defaults
+    """
+    # Current directory
+    cwd = Path.cwd()
+    if (cwd / "hpc-tools.toml").exists():
+        return cwd / "hpc-tools.toml"
+
+    if (cwd / "pyproject.toml").exists():
+        try:
+            with open(cwd / "pyproject.toml", "rb") as f:
+                pyproject = tomllib.load(f)
+            if "tool" in pyproject and "hpc-tools" in pyproject["tool"]:
+                return cwd / "pyproject.toml"
+        except Exception:
+            pass
+
+    # Git root
+    git_root = _find_git_root(cwd)
+    if git_root and (git_root / "hpc-tools.toml").exists():
+        return git_root / "hpc-tools.toml"
+
+    # User config
+    user_config = Path.home() / ".config" / "hpc-tools" / "config.toml"
+    if user_config.exists():
+        return user_config
+
+    # Package defaults
+    package_defaults = Path(__file__).parent.parent.parent.parent / "defaults" / "config.toml"
+    if package_defaults.exists():
+        return package_defaults
+
+    return None
+
+
+def _find_git_root(start: Path) -> Path | None:
+    """Find git repository root."""
+    current = start.resolve()
+    while current != current.parent:
+        if (current / ".git").exists():
+            return current
+        current = current.parent
+    return None
+
+
+def load_config(path: Path | str | None = None) -> HPCConfig:
+    """Load configuration from file.
+
+    Args:
+        path: Explicit config path or None to auto-discover
+    """
+    if path is None:
+        path = find_config_file()
+
+    if path is None:
+        return HPCConfig()  # Empty config, use defaults
+
+    path = Path(path)
+
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    # Handle pyproject.toml
+    if path.name == "pyproject.toml":
+        data = data.get("tool", {}).get("hpc-tools", {})
+
+    config = HPCConfig(
+        defaults=data.get("defaults", {}),
+        tools=data.get("tools", {}),
+        types=data.get("types", {}),
+        schedulers=data.get("schedulers", {}),
+    )
+    config._source_path = path
+
+    return config
+
+
+# Global config cache
+_cached_config: HPCConfig | None = None
+
+
+def get_config() -> HPCConfig:
+    """Get the global configuration (cached)."""
+    global _cached_config
+    if _cached_config is None:
+        _cached_config = load_config()
+    return _cached_config
+
+
+def reload_config(path: Path | str | None = None) -> HPCConfig:
+    """Reload configuration (clears cache)."""
+    global _cached_config
+    _cached_config = load_config(path)
+    return _cached_config

hpc_runner/core/descriptors.py

@@ -0,0 +1,110 @@
+"""Descriptor pattern for job attributes and scheduler arguments."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Generic, TypeVar
+
+T = TypeVar("T")
+
+
+# =============================================================================
+# Job Attribute Descriptor
+# =============================================================================
+
+
+class JobAttribute(Generic[T]):
+    """Descriptor for Job attributes that enables iteration and rendering.
+
+    This descriptor provides:
+    - Clean attribute access on Job instances
+    - Class-level access returns the descriptor itself
+    - Support for default values
+    - Registration for iteration by schedulers
+
+    Example:
+        class Job:
+            name = JobAttribute('name')
+            cpu = JobAttribute('cpu', default=1)
+
+        job = Job()
+        job.name = "test"
+        print(job.name)  # "test"
+        print(Job.name)  # <JobAttribute 'name'>
+    """
+
+    def __init__(self, name: str, *, default: T | None = None):
+        self.public_name = name
+        self.default = default
+        self._private_name: str | None = None
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        self._private_name = f"_{name}"
+
+    def __get__(self, obj: Any, objtype: type | None = None) -> T | "JobAttribute[T]":
+        if obj is None:
+            return self
+        return getattr(obj, self._private_name, self.default)
+
+    def __set__(self, obj: Any, value: T | None) -> None:
+        setattr(obj, self._private_name, value)
+
+    def __repr__(self) -> str:
+        return f"<JobAttribute '{self.public_name}'>"
+
+
+# =============================================================================
+# Scheduler Argument Base Class
+# =============================================================================
+
+
+class SchedulerArg(ABC, Generic[T]):
+    """Base class for scheduler-specific argument renderers.
+
+    Each scheduler backend (SGE, Slurm, PBS) will have subclasses that know
+    how to render job attribute values into that scheduler's syntax.
+
+    Subclasses must implement:
+    - to_args(value) -> list of command-line arguments
+    - to_directive(value) -> script directive string or None
+
+    Example:
+        class SGEJobNameArg(SchedulerArg[str]):
+            def to_args(self, value):
+                return ["-N", value] if value else []
+
+            def to_directive(self, value):
+                return f"#$ -N {value}" if value else None
+    """
+
+    def __init__(
+        self,
+        flag: str,
+        *,
+        doc: str = "",
+    ):
+        self.flag = flag
+        self.doc = doc
+
+    @abstractmethod
+    def to_args(self, value: T | None) -> list[str]:
+        """Convert value to command-line arguments.
+
+        Args:
+            value: The job attribute value (may be None)
+
+        Returns:
+            List of command-line argument strings, empty list if value is None
+        """
+
+    @abstractmethod
+    def to_directive(self, value: T | None) -> str | None:
+        """Convert value to a script directive.
+
+        Args:
+            value: The job attribute value (may be None)
+
+        Returns:
+            Directive string (e.g., "#$ -N jobname") or None if value is None
+        """
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} flag='{self.flag}'>"

hpc_runner/core/exceptions.py

@@ -0,0 +1,38 @@
+"""Custom exceptions for hpc-tools."""
+
+
+class HPCToolsError(Exception):
+    """Base exception for hpc-tools."""
+
+
+class SchedulerError(HPCToolsError):
+    """Error related to scheduler operations."""
+
+
+class SubmissionError(SchedulerError):
+    """Error during job submission."""
+
+
+class JobNotFoundError(SchedulerError):
+    """Job ID not found."""
+
+
+class ConfigError(HPCToolsError):
+    """Error in configuration."""
+
+
+class ConfigNotFoundError(ConfigError):
+    """Configuration file not found."""
+
+
+class ValidationError(HPCToolsError):
+    """Validation error for job parameters."""
+
+
+class AccountingNotAvailable(SchedulerError):
+    """Job accounting/history is not enabled on this cluster.
+
+    Raised when attempting to query historical job data (e.g., via qacct
+    for SGE or sacct for Slurm) but the scheduler's accounting system
+    is not configured or accessible.
+    """