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

furu/execution/slurm_spec.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Mapping, Protocol
+
+
+SlurmSpecValue = str | int | float | bool
+SlurmSpecExtraValue = SlurmSpecValue | Mapping[str, "SlurmSpecExtraValue"]
+
+
+@dataclass(frozen=True)
+class SlurmSpec:
+    partition: str | None = None
+    gpus: int = 0
+    cpus: int = 4
+    mem_gb: int = 16
+    time_min: int = 60
+    extra: Mapping[str, SlurmSpecExtraValue] | None = None
+
+
+class _SpecNode(Protocol):
+    furu_hash: str
+
+    def _executor_spec_key(self) -> str: ...
+
+
+def resolve_slurm_spec(specs: Mapping[str, SlurmSpec], node: _SpecNode) -> SlurmSpec:
+    if "default" not in specs:
+        raise KeyError("Missing slurm spec for key 'default'.")
+
+    spec_key = node._executor_spec_key()
+    if spec_key not in specs:
+        raise KeyError(
+            "Missing slurm spec for key "
+            f"'{spec_key}' for node {node.__class__.__name__} ({node.furu_hash})."
+        )
+
+    return specs[spec_key]

furu/execution/submitit_factory.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from .paths import submitit_logs_dir
+from .slurm_spec import SlurmSpec, SlurmSpecExtraValue
+
+if TYPE_CHECKING:
+    import submitit
+
+
+
+def make_executor_for_spec(
+    spec_key: str,
+    spec: SlurmSpec,
+    *,
+    kind: str,
+    submitit_root: Path | None,
+    run_id: str | None = None,
+) -> submitit.AutoExecutor:
+    import submitit
+
+    folder = submitit_logs_dir(
+        kind,
+        spec_key,
+        override=submitit_root,
+        run_id=run_id,
+    )
+    folder.mkdir(parents=True, exist_ok=True)
+
+    executor = submitit.AutoExecutor(folder=str(folder))
+    params: dict[str, SlurmSpecExtraValue | None] = {
+        "timeout_min": spec.time_min,
+        "slurm_partition": spec.partition,
+        "cpus_per_task": spec.cpus,
+        "mem_gb": spec.mem_gb,
+    }
+    if spec.gpus:
+        params["gpus_per_node"] = spec.gpus
+    if spec.extra:
+        params.update(spec.extra)
+
+    executor.update_parameters(
+        **{key: value for key, value in params.items() if value is not None}
+    )
+    return executor

furu/migration.py

@@ -456,6 +456,7 @@ def _apply_single_migration(
         shutil.rmtree(to_dir)
 
     to_dir.mkdir(parents=True, exist_ok=True)
+    StateManager.ensure_internal_dir(to_dir)
     now = _dt.datetime.now(_dt.timezone.utc).isoformat(timespec="seconds")
 
     if policy in {"move", "copy"}:
@@ -557,8 +558,6 @@ def _copy_state(from_dir: Path, to_dir: Path, *, clear_source: bool) -> None:
     src_internal = from_dir / StateManager.INTERNAL_DIR
     if not src_internal.exists():
         return
-    dst_internal = to_dir / StateManager.INTERNAL_DIR
-    dst_internal.mkdir(parents=True, exist_ok=True)
     state_path = StateManager.get_state_path(from_dir)
     if state_path.is_file():
         shutil.copy2(state_path, StateManager.get_state_path(to_dir))

furu/runtime/env.py

@@ -5,4 +5,4 @@ def load_env() -> None:
 
 
 # Preserve previous behavior: attempt to load `.env` at import-time.
-load_env()
+# load_env() # TODO: find a nice way to auto load .env if needed

furu/runtime/logging.py

@@ -4,6 +4,7 @@ import datetime
 import logging
 import os
 import threading
+import sys
 from pathlib import Path
 from typing import Generator, Protocol
 
@@ -28,16 +29,16 @@ _FURU_HOLDER_STACK: contextvars.ContextVar[tuple[HolderType, ...]] = (
 _FURU_LOG_LOCK = threading.Lock()
 _FURU_CONSOLE_LOCK = threading.Lock()
 
-_LOAD_OR_CREATE_PREFIX = "load_or_create"
+_GET_PREFIX = "get"
 
 
-def _strip_load_or_create_decision_suffix(message: str) -> str:
+def _strip_get_decision_suffix(message: str) -> str:
     """
-    Strip a trailing `(<decision>)` suffix from `load_or_create ...` console lines.
+    Strip a trailing `(<decision>)` suffix from `get ...` console lines.
 
     This keeps detailed decision info in file logs, but makes console output cleaner.
     """
-    if not message.startswith(_LOAD_OR_CREATE_PREFIX):
+    if not message.startswith(_GET_PREFIX):
         return message
     if not message.endswith(")"):
         return message
@@ -69,7 +70,7 @@ def enter_holder(holder: HolderType) -> Generator[None, None, None]:
     """
     Push a holder object onto the logging stack for this context.
 
-    Furu calls this automatically during `load_or_create()`, so nested
+    Furu calls this automatically during `get()`, so nested
     dependencies will log to the active dependency's folder and then revert.
     """
     configure_logging()
@@ -102,6 +103,16 @@ class _FuruLogFormatter(logging.Formatter):
         dt = datetime.datetime.fromtimestamp(record.created, tz=datetime.timezone.utc)
         return dt.isoformat(timespec="seconds")
 
+    def format(self, record: logging.LogRecord) -> str:
+        caller_file = getattr(record, "furu_caller_file", None)
+        caller_line = getattr(record, "furu_caller_line", None)
+        if isinstance(caller_file, str) and isinstance(caller_line, int):
+            location = f"{Path(caller_file).name}:{caller_line}"
+        else:
+            location = f"{record.filename}:{record.lineno}"
+        record.furu_location = location  # type: ignore[attr-defined]
+        return super().format(record)
+
 
 class _FuruContextFileHandler(logging.Handler):
     """
@@ -112,7 +123,8 @@ class _FuruContextFileHandler(logging.Handler):
         message = self.format(record)
 
         directory = current_log_dir()
-        directory.mkdir(parents=True, exist_ok=True)
+        if directory.name != ".furu":
+            directory.mkdir(parents=True, exist_ok=True)
 
         log_path = directory / "furu.log"
         with _FURU_LOG_LOCK:
@@ -163,7 +175,7 @@ class _FuruRichConsoleHandler(logging.Handler):
 
     @staticmethod
     def _format_location(record: logging.LogRecord) -> str:
-        # Use caller location if available (for load_or_create messages)
+        # Use caller location if available (for get messages)
         caller_file = getattr(record, "furu_caller_file", None)
         caller_line = getattr(record, "furu_caller_line", None)
         if caller_file is not None and caller_line is not None:
@@ -174,10 +186,10 @@ class _FuruRichConsoleHandler(logging.Handler):
 
     @staticmethod
     def _format_message_text(record: logging.LogRecord) -> Text:
-        message = _strip_load_or_create_decision_suffix(record.getMessage())
+        message = _strip_get_decision_suffix(record.getMessage())
         action_color = getattr(record, "furu_action_color", None)
-        if isinstance(action_color, str) and message.startswith(_LOAD_OR_CREATE_PREFIX):
-            prefix = _LOAD_OR_CREATE_PREFIX
+        if isinstance(action_color, str) and message.startswith(_GET_PREFIX):
+            prefix = _GET_PREFIX
             rest = message[len(prefix) :]
             text = Text()
             text.append(prefix, style=action_color)
@@ -241,7 +253,7 @@ def configure_logging() -> None:
         handler.addFilter(_FuruFileFilter())
         handler.setFormatter(
             _FuruLogFormatter(
-                "%(asctime)s [%(levelname)s] %(name)s %(filename)s:%(lineno)d %(message)s"
+                "%(asctime)s [%(levelname)s] %(name)s %(furu_location)s %(message)s"
             )
         )
         root.addHandler(handler)
@@ -280,7 +292,20 @@ def log(message: str, *, level: str = "INFO") -> Path:
         raise ValueError(f"Unknown log level: {level!r}")
 
     configure_logging()
-    get_logger().log(level_no, message)
+    caller_info: dict[str, object] = {}
+    frame = sys._getframe(1)
+    if frame is not None:
+        furu_pkg_dir = str(Path(__file__).parent.parent)
+        while frame is not None:
+            filename = frame.f_code.co_filename
+            if not filename.startswith(furu_pkg_dir):
+                caller_info = {
+                    "furu_caller_file": filename,
+                    "furu_caller_line": frame.f_lineno,
+                }
+                break
+            frame = frame.f_back
+    get_logger().log(level_no, message, extra=caller_info)
     return log_path
 
 
@@ -288,12 +313,13 @@ def write_separator(line: str = "------------------") -> Path:
     """
     Write a raw separator line to the current holder's `furu.log`.
 
-    This bypasses standard formatting so repeated `load_or_create()` calls are easy to spot.
+    This bypasses standard formatting so repeated `get()` calls are easy to spot.
     """
     directory = current_log_dir()
     log_path = directory / "furu.log"
 
-    directory.mkdir(parents=True, exist_ok=True)
+    if directory.name != ".furu":
+        directory.mkdir(parents=True, exist_ok=True)
 
     with _FURU_LOG_LOCK:
         with log_path.open("a", encoding="utf-8") as fp:

furu/storage/metadata.py

@@ -19,7 +19,7 @@ from ..serialization.serializer import JsonValue
 if TYPE_CHECKING:
     from ..core.furu import Furu
 
-# Module-level cache for metadata (controlled via FURU_CACHE_METADATA)
+# Module-level cache for metadata (controlled via FURU_RECORD_GIT=cached)
 _cached_git_info: "GitInfo | None" = None
 _cached_git_info_time: float = 0.0
 
@@ -113,6 +113,16 @@ class MetadataManager:
         global _cached_git_info, _cached_git_info_time
         import time
 
+        record_git = FURU_CONFIG.record_git
+        if record_git == "ignore":
+            return GitInfo(
+                git_commit="<ignored>",
+                git_branch="<ignored>",
+                git_remote=None,
+                git_patch="<ignored>",
+                git_submodules={},
+            )
+
         ttl = FURU_CONFIG.cache_metadata_ttl_sec
         # Return cached result if caching is enabled and not expired
         if ttl is not None and _cached_git_info is not None:
@@ -120,41 +130,28 @@ class MetadataManager:
             if age < ttl:
                 return _cached_git_info
 
-        if not FURU_CONFIG.require_git:
+        try:
+            head = cls.run_git_command(["rev-parse", "HEAD"])
+            branch = cls.run_git_command(["rev-parse", "--abbrev-ref", "HEAD"])
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            raise RuntimeError(
+                "Failed to read git commit/branch for provenance. "
+                "If this is expected, set FURU_RECORD_GIT=ignore."
+            ) from e
+
+        if FURU_CONFIG.allow_no_git_origin:
             try:
-                head = cls.run_git_command(["rev-parse", "HEAD"])
-                branch = cls.run_git_command(["rev-parse", "--abbrev-ref", "HEAD"])
+                remote = cls.run_git_command(["remote", "get-url", "origin"])
             except (subprocess.CalledProcessError, FileNotFoundError):
-                return GitInfo(
-                    git_commit="<no-git>",
-                    git_branch="<no-git>",
-                    git_remote=None,
-                    git_patch="<no-git>",
-                    git_submodules={},
-                )
+                remote = None
         else:
-            try:
-                head = cls.run_git_command(["rev-parse", "HEAD"])
-                branch = cls.run_git_command(["rev-parse", "--abbrev-ref", "HEAD"])
-            except (subprocess.CalledProcessError, FileNotFoundError) as e:
-                raise RuntimeError(
-                    "Failed to read git commit/branch for provenance. "
-                    "If this is expected, set FURU_REQUIRE_GIT=0."
-                ) from e
-
-        if FURU_CONFIG.require_git_remote:
             try:
                 remote = cls.run_git_command(["remote", "get-url", "origin"])
             except (subprocess.CalledProcessError, FileNotFoundError) as e:
                 raise RuntimeError(
                     "Git remote 'origin' is required for provenance but was not found. "
-                    "Set FURU_REQUIRE_GIT_REMOTE=0 to allow missing origin."
+                    "Set FURU_ALLOW_NO_GIT_ORIGIN=1 to allow missing origin."
                 ) from e
-        else:
-            try:
-                remote = cls.run_git_command(["remote", "get-url", "origin"])
-            except (subprocess.CalledProcessError, FileNotFoundError):
-                remote = None
 
         if ignore_diff:
             patch = "<ignored-diff>"
@@ -187,7 +184,7 @@ class MetadataManager:
             if len(patch) > 50_000:
                 raise ValueError(
                     f"Git diff too large ({len(patch):,} bytes). "
-                    "Use ignore_diff=True or FURU_IGNORE_DIFF=1"
+                    "Set FURU_RECORD_GIT=ignore to skip git metadata."
                 )
 
         submodules: dict[str, str] = {}
@@ -265,7 +262,6 @@ class MetadataManager:
     def write_metadata(cls, metadata: FuruMetadata, directory: Path) -> None:
         """Write metadata to file."""
         metadata_path = cls.get_metadata_path(directory)
-        metadata_path.parent.mkdir(parents=True, exist_ok=True)
         metadata_path.write_text(
             json.dumps(
                 metadata.model_dump(mode="json"),

furu/storage/migration.py

@@ -52,7 +52,6 @@ class MigrationManager:
     @classmethod
     def write_migration(cls, record: MigrationRecord, directory: Path) -> None:
         path = cls.get_migration_path(directory)
-        path.parent.mkdir(parents=True, exist_ok=True)
         tmp = path.with_suffix(".tmp")
         tmp.write_text(json.dumps(record.model_dump(mode="json"), indent=2))
         tmp.replace(path)