furu 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

furu/__init__.py

@@ -17,8 +17,12 @@ from .core import DependencyChzSpec, DependencySpec, Furu, FuruList
 from .errors import (
     FuruComputeError,
     FuruError,
+    FuruExecutionError,
     FuruLockNotAcquired,
+    FuruMissingArtifact,
     FuruMigrationRequired,
+    FuruSpecMismatch,
+    FuruValidationError,
     FuruWaitTimeout,
     MISSING,
 )
@@ -51,9 +55,13 @@ __all__ = [
     "FuruComputeError",
     "FuruConfig",
     "FuruError",
+    "FuruExecutionError",
     "FuruList",
     "FuruLockNotAcquired",
+    "FuruMissingArtifact",
     "FuruMigrationRequired",
+    "FuruSpecMismatch",
+    "FuruValidationError",
     "FuruSerializer",
     "FuruWaitTimeout",
     "DependencyChzSpec",

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

@@ -1,6 +1,10 @@
 import os
 from importlib import import_module
 from pathlib import Path
+from typing import Literal, cast
+
+
+RecordGitMode = Literal["ignore", "cached", "uncached"]
 
 
 class FuruConfig:
@@ -18,6 +22,11 @@ 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"))
@@ -30,26 +39,20 @@ class FuruConfig:
             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",
-            "yes",
-        }
-        self.require_git = os.getenv("FURU_REQUIRE_GIT", "1").lower() in {
-            "1",
-            "true",
-            "yes",
-        }
-        self.require_git_remote = os.getenv("FURU_REQUIRE_GIT_REMOTE", "1").lower() in {
-            "1",
-            "true",
-            "yes",
-        }
+        self.record_git = self._parse_record_git(os.getenv("FURU_RECORD_GIT", "cached"))
+        self.allow_no_git_origin = self._parse_bool(
+            os.getenv("FURU_ALLOW_NO_GIT_ORIGIN", "0")
+        )
+        if self.allow_no_git_origin and self.record_git == "ignore":
+            raise ValueError(
+                "FURU_ALLOW_NO_GIT_ORIGIN cannot be enabled when FURU_RECORD_GIT=ignore"
+            )
         always_rerun_items = {
             item.strip()
             for item in os.getenv("FURU_ALWAYS_RERUN", "").split(",")
@@ -71,35 +74,25 @@ class FuruConfig:
             "FURU_CANCELLED_IS_PREEMPTED", "false"
         ).lower() in {"1", "true", "yes"}
 
-        # Parse FURU_CACHE_METADATA: "never", "forever", or duration like "5m", "1h"
-        # Default: "5m" (5 minutes) - balances performance with freshness
-        self.cache_metadata_ttl_sec: float | None = self._parse_cache_duration(
-            os.getenv("FURU_CACHE_METADATA", "5m")
-        )
-
     @staticmethod
-    def _parse_cache_duration(value: str) -> float | None:
-        """Parse cache duration string into seconds. Returns None for 'never', float('inf') for 'forever'."""
-        value = value.strip().lower()
-        if value in {"never", "0", "false", "no"}:
-            return None  # No caching
-        if value in {"forever", "inf", "true", "yes", "1"}:
-            return float("inf")  # Cache forever
-
-        # Parse duration like "5m", "1h", "30s"
-        import re
-
-        match = re.match(r"^(\d+(?:\.\d+)?)\s*([smh]?)$", value)
-        if not match:
+    def _parse_bool(value: str) -> bool:
+        return value.strip().lower() in {"1", "true", "yes"}
+
+    @classmethod
+    def _parse_record_git(cls, value: str) -> RecordGitMode:
+        normalized = value.strip().lower()
+        allowed = {"ignore", "cached", "uncached"}
+        if normalized not in allowed:
             raise ValueError(
-                f"Invalid FURU_CACHE_METADATA value: {value!r}. "
-                "Use 'never', 'forever', or duration like '5m', '1h', '30s'"
+                "FURU_RECORD_GIT must be one of 'ignore', 'cached', or 'uncached'"
             )
+        return cast(RecordGitMode, normalized)
 
-        num = float(match.group(1))
-        unit = match.group(2) or "s"
-        multipliers = {"s": 1, "m": 60, "h": 3600}
-        return num * multipliers[unit]
+    @property
+    def cache_metadata_ttl_sec(self) -> float | None:
+        if self.record_git == "cached":
+            return float("inf")
+        return None
 
     def get_root(self, version_controlled: bool = False) -> Path:
         """Get root directory for storage (version_controlled uses its own root)."""
@@ -109,6 +102,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")
@@ -175,4 +171,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()