furu 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

furu/__init__.py

@@ -13,12 +13,16 @@ __version__ = version("furu")
 
 from .config import FURU_CONFIG, FuruConfig, get_furu_root, set_furu_root
 from .adapters import SubmititAdapter
-from .core import Furu, FuruList
+from .core import DependencyChzSpec, DependencySpec, Furu, FuruList
 from .errors import (
     FuruComputeError,
     FuruError,
+    FuruExecutionError,
     FuruLockNotAcquired,
+    FuruMissingArtifact,
     FuruMigrationRequired,
+    FuruSpecMismatch,
+    FuruValidationError,
     FuruWaitTimeout,
     MISSING,
 )
@@ -51,11 +55,17 @@ __all__ = [
     "FuruComputeError",
     "FuruConfig",
     "FuruError",
+    "FuruExecutionError",
     "FuruList",
     "FuruLockNotAcquired",
+    "FuruMissingArtifact",
     "FuruMigrationRequired",
+    "FuruSpecMismatch",
+    "FuruValidationError",
     "FuruSerializer",
     "FuruWaitTimeout",
+    "DependencyChzSpec",
+    "DependencySpec",
     "MISSING",
     "migrate",
     "NamespacePair",

furu/adapters/submitit.py

@@ -6,6 +6,7 @@ from typing import Any, Callable, Protocol
 
 from ..config import FURU_CONFIG
 from ..storage import StateManager
+from ..runtime.logging import get_logger
 from ..storage.state import _FuruState, ProbeResult
 
 
@@ -102,19 +103,39 @@ class SubmititAdapter:
         """Watch for job ID in background thread and update state."""
 
         def watcher():
+            _ = attempt_id  # intentionally unused; queued->running attempt swap is expected
             while True:
                 job_id = self.get_job_id(job)
                 if job_id:
 
                     def mutate(state: _FuruState) -> None:
                         attempt = state.attempt
-                        if attempt is None or attempt.id != attempt_id:
+                        if attempt is None:
+                            return
+                        if attempt.backend != "submitit":
+                            return
+                        if (
+                            attempt.status not in {"queued", "running"}
+                            and attempt.status not in StateManager.TERMINAL_STATUSES
+                        ):
+                            return
+                        existing = attempt.scheduler.get("job_id")
+                        if existing == job_id:
                             return
                         attempt.scheduler["job_id"] = job_id
 
                     StateManager.update_state(directory, mutate)
                     if callback:
-                        callback(job_id)
+                        try:
+                            callback(job_id)
+                        except Exception:
+                            # Avoid killing the watcher thread; state update already happened.
+                            logger = get_logger()
+                            logger.exception(
+                                "submitit watcher: job_id callback failed for %s: %s",
+                                directory,
+                                job_id,
+                            )
                     break
 
                 if self.is_done(job):

furu/config.py

@@ -18,16 +18,29 @@ class FuruConfig:
             return (project_root / self.DEFAULT_ROOT_DIR).resolve()
 
         self.base_root = _get_base_root()
+        self.submitit_root = (
+            Path(os.getenv("FURU_SUBMITIT_PATH", str(self.base_root / "submitit")))
+            .expanduser()
+            .resolve()
+        )
         self.version_controlled_root_override = self._get_version_controlled_override()
         self.poll_interval = float(os.getenv("FURU_POLL_INTERVAL_SECS", "10"))
         self.wait_log_every_sec = float(os.getenv("FURU_WAIT_LOG_EVERY_SECS", "10"))
         self.stale_timeout = float(os.getenv("FURU_STALE_AFTER_SECS", str(30 * 60)))
+        max_wait_env = os.getenv("FURU_MAX_WAIT_SECS")
+        self.max_wait_time_sec = float(max_wait_env) if max_wait_env else None
         self.lease_duration_sec = float(os.getenv("FURU_LEASE_SECS", "120"))
         hb = os.getenv("FURU_HEARTBEAT_SECS")
         self.heartbeat_interval_sec = (
             float(hb) if hb is not None else max(1.0, self.lease_duration_sec / 3.0)
         )
         self.max_requeues = int(os.getenv("FURU_PREEMPT_MAX", "5"))
+        self.max_compute_retries = int(os.getenv("FURU_MAX_COMPUTE_RETRIES", "3"))
+        self.retry_failed = os.getenv("FURU_RETRY_FAILED", "1").lower() in {
+            "1",
+            "true",
+            "yes",
+        }
         self.ignore_git_diff = os.getenv("FURU_IGNORE_DIFF", "0").lower() in {
             "1",
             "true",
@@ -102,6 +115,9 @@ class FuruConfig:
             return self._resolve_version_controlled_root()
         return self.base_root / "data"
 
+    def get_submitit_root(self) -> Path:
+        return self.submitit_root
+
     @classmethod
     def _get_version_controlled_override(cls) -> Path | None:
         env = os.getenv("FURU_VERSION_CONTROLLED_PATH")
@@ -151,8 +167,7 @@ class FuruConfig:
                 value = getattr(target, attr, missing_sentinel)
                 if value is missing_sentinel:
                     raise ValueError(
-                        "FURU_ALWAYS_RERUN entry does not exist: "
-                        f"{namespace!r}"
+                        f"FURU_ALWAYS_RERUN entry does not exist: {namespace!r}"
                     )
                 target = value
 
@@ -169,4 +184,7 @@ def get_furu_root(*, version_controlled: bool = False) -> Path:
 
 
 def set_furu_root(path: Path) -> None:
-    FURU_CONFIG.base_root = path.resolve()
+    root = path.resolve()
+    FURU_CONFIG.base_root = root
+    if os.getenv("FURU_SUBMITIT_PATH") is None:
+        FURU_CONFIG.submitit_root = (root / "submitit").resolve()

furu/core/__init__.py

@@ -1,4 +1,4 @@
-from .furu import Furu
+from .furu import DependencyChzSpec, DependencySpec, Furu
 from .list import FuruList
 
-__all__ = ["Furu", "FuruList"]
+__all__ = ["DependencyChzSpec", "DependencySpec", "Furu", "FuruList"]