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

furu/core/furu.py

@@ -46,6 +46,7 @@ from ..errors import (
 from ..runtime import current_holder
 from ..runtime.logging import enter_holder, get_logger, log, write_separator
 from ..runtime.tracebacks import format_traceback
+from ..runtime.overrides import has_override, lookup_override
 from ..serialization import FuruSerializer
 from ..serialization.serializer import JsonValue
 from ..storage import (
@@ -316,6 +317,8 @@ class Furu[T](ABC):
         return log(message, level=level)
 
     def _exists_quiet(self: Self) -> bool:
+        if has_override(self.furu_hash):
+            return True
         directory = self._base_furu_dir()
         success_dir = self._success_marker_dir(directory)
         if success_dir is None:
@@ -345,6 +348,9 @@ class Furu[T](ABC):
         """Check if result exists and is valid."""
         logger = get_logger()
         directory = self._base_furu_dir()
+        if has_override(self.furu_hash):
+            logger.info("exists %s -> true (override)", directory)
+            return True
         success_dir = self._success_marker_dir(directory)
         if success_dir is None:
             logger.info("exists %s -> false", directory)
@@ -376,6 +382,9 @@ class Furu[T](ABC):
         Raises:
             FuruComputeError: If computation fails with detailed error information
         """
+        has_override_value, override_value = lookup_override(self.furu_hash)
+        if has_override_value:
+            return cast(T, override_value)
         from furu.errors import (
             FuruExecutionError,
             FuruMissingArtifact,

furu/runtime/overrides.py

@@ -0,0 +1,37 @@
+from collections.abc import Generator, Mapping
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Any
+
+
+OverrideValue = Any
+
+_OVERRIDES: ContextVar[dict[str, OverrideValue]] = ContextVar(
+    "FURU_RESULT_OVERRIDES",
+    default={},
+)
+
+
+def has_override(furu_hash: str) -> bool:
+    return furu_hash in _OVERRIDES.get()
+
+
+def lookup_override(furu_hash: str) -> tuple[bool, OverrideValue]:
+    overrides = _OVERRIDES.get()
+    if furu_hash in overrides:
+        return True, overrides[furu_hash]
+    return False, None
+
+
+@contextmanager
+def override_furu_hashes(
+    overrides: Mapping[str, OverrideValue],
+) -> Generator[None, None, None]:
+    current = _OVERRIDES.get()
+    merged = dict(current)
+    merged.update(overrides)
+    token = _OVERRIDES.set(merged)
+    try:
+        yield
+    finally:
+        _OVERRIDES.reset(token)

furu/storage/metadata.py

@@ -150,7 +150,8 @@ class MetadataManager:
             except (subprocess.CalledProcessError, FileNotFoundError) as e:
                 raise RuntimeError(
                     "Git remote 'origin' is required for provenance but was not found. "
-                    "Set FURU_ALLOW_NO_GIT_ORIGIN=1 to allow missing origin."
+                    "Set FURU_ALLOW_NO_GIT_ORIGIN=1 to allow missing origin, "
+                    "or set FURU_RECORD_GIT=ignore to disable git metadata."
                 ) from e
 
         if ignore_diff:

furu/testing.py

@@ -0,0 +1,232 @@
+from collections.abc import Generator, Mapping, Sequence
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import cast, overload
+
+import chz
+import pytest
+
+from .config import FURU_CONFIG, RecordGitMode
+from .core import Furu
+from .runtime.overrides import OverrideValue, override_furu_hashes
+
+OverrideKey = Furu | str
+_PATH_MISSING = object()
+
+
+@dataclass(frozen=True)
+class _FuruConfigSnapshot:
+    base_root: Path
+    version_controlled_root_override: Path | None
+    record_git: RecordGitMode
+    allow_no_git_origin: bool
+    poll_interval: float
+    stale_timeout: float
+    max_wait_time_sec: float | None
+    lease_duration_sec: float
+    heartbeat_interval_sec: float
+    cancelled_is_preempted: bool
+    retry_failed: bool
+    submitit_root: Path
+
+    @classmethod
+    def capture(cls) -> "_FuruConfigSnapshot":
+        return cls(
+            base_root=FURU_CONFIG.base_root,
+            version_controlled_root_override=FURU_CONFIG.version_controlled_root_override,
+            record_git=FURU_CONFIG.record_git,
+            allow_no_git_origin=FURU_CONFIG.allow_no_git_origin,
+            poll_interval=FURU_CONFIG.poll_interval,
+            stale_timeout=FURU_CONFIG.stale_timeout,
+            max_wait_time_sec=FURU_CONFIG.max_wait_time_sec,
+            lease_duration_sec=FURU_CONFIG.lease_duration_sec,
+            heartbeat_interval_sec=FURU_CONFIG.heartbeat_interval_sec,
+            cancelled_is_preempted=FURU_CONFIG.cancelled_is_preempted,
+            retry_failed=FURU_CONFIG.retry_failed,
+            submitit_root=FURU_CONFIG.submitit_root,
+        )
+
+    def restore(self) -> None:
+        FURU_CONFIG.base_root = self.base_root
+        FURU_CONFIG.version_controlled_root_override = (
+            self.version_controlled_root_override
+        )
+        FURU_CONFIG.record_git = self.record_git
+        FURU_CONFIG.allow_no_git_origin = self.allow_no_git_origin
+        FURU_CONFIG.poll_interval = self.poll_interval
+        FURU_CONFIG.stale_timeout = self.stale_timeout
+        FURU_CONFIG.max_wait_time_sec = self.max_wait_time_sec
+        FURU_CONFIG.lease_duration_sec = self.lease_duration_sec
+        FURU_CONFIG.heartbeat_interval_sec = self.heartbeat_interval_sec
+        FURU_CONFIG.cancelled_is_preempted = self.cancelled_is_preempted
+        FURU_CONFIG.retry_failed = self.retry_failed
+        FURU_CONFIG.submitit_root = self.submitit_root
+
+
+def _apply_test_config(base_root: Path) -> Path:
+    root = base_root.resolve()
+    FURU_CONFIG.base_root = root
+    FURU_CONFIG.version_controlled_root_override = root / "furu-data" / "artifacts"
+    FURU_CONFIG.record_git = "ignore"
+    FURU_CONFIG.allow_no_git_origin = False
+    FURU_CONFIG.poll_interval = 0.01
+    FURU_CONFIG.stale_timeout = 0.1
+    FURU_CONFIG.max_wait_time_sec = None
+    FURU_CONFIG.lease_duration_sec = 0.05
+    FURU_CONFIG.heartbeat_interval_sec = 0.01
+    FURU_CONFIG.cancelled_is_preempted = True
+    FURU_CONFIG.retry_failed = True
+    FURU_CONFIG.submitit_root = root / "submitit"
+    return root
+
+
+@contextmanager
+def furu_test_env(base_root: Path) -> Generator[Path, None, None]:
+    snapshot = _FuruConfigSnapshot.capture()
+    root = _apply_test_config(base_root)
+    try:
+        yield root
+    finally:
+        snapshot.restore()
+
+
+@overload
+def override_results(
+    overrides: Mapping[Furu, OverrideValue],
+) -> Generator[None, None, None]: ...
+
+
+@overload
+def override_results(
+    overrides: Mapping[str, OverrideValue],
+) -> Generator[None, None, None]: ...
+
+
+@contextmanager
+def override_results(
+    overrides: Mapping[OverrideKey, OverrideValue],
+) -> Generator[None, None, None]:
+    """Override specific Furu results within the context.
+
+    Overrides are keyed by furu_hash, so identical configs share a stub.
+    Keys may be a Furu instance or a furu_hash string.
+    """
+    hash_overrides: dict[str, OverrideValue] = {}
+    for key, value in overrides.items():
+        hash_key: str
+        if isinstance(key, Furu):
+            hash_key = cast(str, key.furu_hash)
+        elif isinstance(key, str):
+            if not key:
+                raise ValueError("override furu_hash must be non-empty")
+            hash_key = key
+        else:
+            raise TypeError(
+                "override_results keys must be Furu instances or furu_hash strings"
+            )
+        hash_overrides[hash_key] = value
+    with override_furu_hashes(hash_overrides):
+        yield
+
+
+@overload
+def override_results_for(
+    root: Furu,
+    overrides: Mapping[str, OverrideValue],
+) -> Generator[None, None, None]: ...
+
+
+@contextmanager
+def override_results_for(
+    root: Furu,
+    overrides: Mapping[str, OverrideValue],
+) -> Generator[None, None, None]:
+    """Override results by dotted field path relative to a root Furu object.
+
+    Paths follow chz traversal: use numeric segments for list indices and
+    key segments for mappings (e.g. "deps.0" or "deps.key").
+    """
+    hash_overrides: dict[str, OverrideValue] = {}
+    for path, value in overrides.items():
+        target = _resolve_override_path(root, path)
+        hash_overrides[cast(str, target.furu_hash)] = value
+    with override_furu_hashes(hash_overrides):
+        yield
+
+
+def _resolve_override_path(root: Furu, path: str) -> Furu:
+    if not path:
+        raise ValueError("override path must be non-empty")
+    current: object = root
+    for segment in path.split("."):
+        if not segment:
+            raise ValueError(f"override path has empty segment: {path!r}")
+        current = _resolve_path_segment(current, segment, path)
+    if not isinstance(current, Furu):
+        raise TypeError(
+            f"override path {path!r} must resolve to a Furu instance; got {type(current).__name__}"
+        )
+    return current
+
+
+def _resolve_path_segment(current: object, segment: str, path: str) -> object:
+    if chz.is_chz(current):
+        value = getattr(current, segment, _PATH_MISSING)
+        if value is _PATH_MISSING:
+            raise AttributeError(f"override path {path!r} has no attribute {segment!r}")
+        return value
+    if isinstance(current, Mapping):
+        mapping = cast(Mapping[object, OverrideValue], current)
+        return _resolve_mapping_segment(mapping, segment, path)
+    if _is_indexable_sequence(current):
+        sequence = cast(Sequence[OverrideValue], current)
+        return _resolve_sequence_segment(sequence, segment, path)
+    raise TypeError(
+        f"override path {path!r} cannot traverse into {type(current).__name__}"
+    )
+
+
+def _resolve_mapping_segment(
+    mapping: Mapping[object, OverrideValue],
+    segment: str,
+    path: str,
+) -> OverrideValue:
+    if segment in mapping:
+        return mapping[segment]
+    index = _parse_index_segment(segment)
+    if index is not None and index in mapping:
+        return mapping[index]
+    raise KeyError(f"override path {path!r} has no key {segment!r}")
+
+
+def _resolve_sequence_segment(
+    sequence: Sequence[OverrideValue],
+    segment: str,
+    path: str,
+) -> OverrideValue:
+    index = _parse_index_segment(segment)
+    if index is None:
+        raise TypeError(f"override path {path!r} index {segment!r} is not an integer")
+    if index < 0:
+        raise ValueError(f"override path {path!r} index must be non-negative")
+    return sequence[index]
+
+
+def _parse_index_segment(segment: str) -> int | None:
+    if not segment.isdigit():
+        return None
+    return int(segment)
+
+
+def _is_indexable_sequence(value: object) -> bool:
+    if isinstance(value, (str, bytes, bytearray)):
+        return False
+    return isinstance(value, Sequence)
+
+
+@pytest.fixture()
+def furu_tmp_root(tmp_path: Path) -> Generator[Path, None, None]:
+    """Configure furu to use a temporary root for the test."""
+    with furu_test_env(tmp_path) as root:
+        yield root

{furu-0.0.5.dist-info → furu-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: furu
-Version: 0.0.5
+Version: 0.0.6
 Summary: Cacheable, nested pipelines for Python. Define computations as configs; furu handles caching, state tracking, and result reuse across runs.
 Author: Herman Brunborg
 Author-email: Herman Brunborg <herman@brunborg.com>
@@ -503,6 +503,89 @@ furu.FURU_CONFIG.record_git = "uncached"
 furu.FURU_CONFIG.poll_interval = 5.0
 ```
 
+### Testing with pytest
+
+Use the built-in pytest fixture to isolate Furu storage in tests (each test gets
+its own temp root, so identical configs in separate tests will not collide):
+
+```python
+# conftest.py
+pytest_plugins = ["furu.testing"]
+```
+
+```python
+# test_pipeline.py
+import json
+from pathlib import Path
+
+import furu
+
+
+class TrainModel(furu.Furu[Path]):
+    lr: float = furu.chz.field(default=1e-3)
+
+    def _create(self) -> Path:
+        path = self.furu_dir / "metrics.json"
+        path.write_text(json.dumps({"lr": self.lr}))
+        return path
+
+    def _load(self) -> Path:
+        return self.furu_dir / "metrics.json"
+
+
+def test_create_and_reload(furu_tmp_root):
+    obj = TrainModel(lr=1e-3)
+    first = obj.get()
+    second = obj.get()
+    assert first.read_text() == second.read_text()
+    assert (furu_tmp_root / "data").exists()
+```
+
+Override specific dependencies when you want to skip deeper chains:
+
+```python
+from furu.testing import override_results
+
+
+class Normalize(furu.Furu[str]):
+    def _create(self) -> str:
+        return "normalized"
+
+    def _load(self) -> str:
+        return "normalized"
+
+
+class TrainModel(furu.Furu[str]):
+    normalizer: Normalize = furu.chz.field(default_factory=Normalize)
+
+    def _create(self) -> str:
+        return f"trained:{self.normalizer.get()}"
+
+    def _load(self) -> str:
+        return "trained"
+
+
+def test_override_dependency(furu_tmp_root):
+    normalizer = Normalize()
+    model = TrainModel(normalizer=normalizer)
+    with override_results({normalizer: "stub"}):
+        assert model.get() == "trained:stub"
+```
+
+If you want to override without instantiating the dependency directly, target it
+by dotted path from the root object (chz-style paths, e.g. `deps.0` for lists and
+`deps.key` for mappings):
+
+```python
+from furu.testing import override_results_for
+
+
+def test_override_by_path(furu_tmp_root):
+    model = TrainModel()
+    with override_results_for(model, {"normalizer": "stub"}):
+        assert model.get() == "trained:stub"
+```
+
 ### Class-Level Options
 
 ```python

{furu-0.0.5.dist-info → furu-0.0.6.dist-info}/RECORD

@@ -3,7 +3,7 @@ furu/adapters/__init__.py,sha256=onLzEj9hccPK15g8a8va2T19nqQXoxb9rQlJIjKSKnE,69
 furu/adapters/submitit.py,sha256=FV3XEUSQuS5vIyzkW-Iuqtf8SRL-fsokPG67u7tMF5I,7276
 furu/config.py,sha256=UGnH8QAKMUgrGMGNkfBgLXideXEpDlozUSsX9iNN8Lw,6844
 furu/core/__init__.py,sha256=6hH7i6r627c0FZn6eQVsSG7LD4QmTta6iQw0AiPQPTM,156
-furu/core/furu.py,sha256=tGUtHVAgSV_oKeW5hlSH5h6OvZG1h4BDBltpjFyJByQ,61375
+furu/core/furu.py,sha256=2KTeMjQjRoDaXNIoKUlYmJ0JWJFG4krom7w6UsUpvDg,61785
 furu/core/list.py,sha256=QaGSh8NFg1K2WFncM8duOYQ6KLZ6EW2pRLArN_e5Juw,3662
 furu/dashboard/__init__.py,sha256=ziAordJfkbbXNIM7iA9O7vR2gsCq34AInYiMYOCfWOc,362
 furu/dashboard/__main__.py,sha256=cNs65IMl4kwZFpxa9xLXmFSy4-M5D1X1ZBfTDxW11vo,144
@@ -32,15 +32,17 @@ furu/migration.py,sha256=EYWULuH8lEVvESthO2qEF95WJTo1Uj6d4L6VU2zmWpw,31350
 furu/runtime/__init__.py,sha256=fQqE7wUuWunLD73Vm3lss7BFSij3UVxXOKQXBAOS8zw,504
 furu/runtime/env.py,sha256=lb-LWl-1EM_CP8sy0z3HAY20NXQ-v3QdOgte1i0HYVA,214
 furu/runtime/logging.py,sha256=Xni1hWyH21bKc6D2owBZzThsj6q8yQOBD9zUrDS4jtI,10760
+furu/runtime/overrides.py,sha256=E3fsZ0ReNOnC9xioHHFlmudm5K2DZLFFcEIvrnA6t2o,871
 furu/runtime/tracebacks.py,sha256=PGCuOq8QkWSoun791gjUXM8frOP2wWV8IBlqaA4nuGE,1631
 furu/serialization/__init__.py,sha256=L7oHuIbxdSh7GCY3thMQnDwlt_ERH-TMy0YKEAZLrPs,341
 furu/serialization/migrations.py,sha256=HD5g8JCBdH3Y0rHJYc4Ug1IXBVcUDxLE7nfiXZnXcUE,7772
 furu/serialization/serializer.py,sha256=_nfUaAOy_KHegvfXlpPh4rCuvkzalJva75OvDg5nXiI,10114
 furu/storage/__init__.py,sha256=cLLL-GPpSu9C72Mdk5S6TGu3g-SnBfEuxzfpx5ZJPtw,616
-furu/storage/metadata.py,sha256=fJ_0G0vWRl9vNb7IigjXd__aokTok2ZHowmttoXjTsM,9581
+furu/storage/metadata.py,sha256=V16aePXsVo4qIBsKCVtNQvZDpMl0AcCCD2Fr-f-Q75I,9659
 furu/storage/migration.py,sha256=FNExLdPu1ekKZR2XJkAgags9U8pV2FfkKAECSXkSra8,2585
 furu/storage/state.py,sha256=kcIfAwdKWT8Q2ElbC5qofQC6noS_k6eNSPkNAdYXoaY,43707
-furu-0.0.5.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
-furu-0.0.5.dist-info/entry_points.txt,sha256=hZkjtFzNlb33Zk-aUfLMRj-XgVDxdT82-JXG9d4bu2E,60
-furu-0.0.5.dist-info/METADATA,sha256=1ugdjmF6ECLzzO21v123_GdyMmSb6tni6avp6YJRbG4,17101
-furu-0.0.5.dist-info/RECORD,,
+furu/testing.py,sha256=lS-30bOu_RI1l4OV4lGWNpx5HOAwX2JYHHqakOkz8so,7804
+furu-0.0.6.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+furu-0.0.6.dist-info/entry_points.txt,sha256=hZkjtFzNlb33Zk-aUfLMRj-XgVDxdT82-JXG9d4bu2E,60
+furu-0.0.6.dist-info/METADATA,sha256=Z22LYfC7htpUg9VleX9vYA-GlruCYyycpe8VTpm5aYQ,19117
+furu-0.0.6.dist-info/RECORD,,

{furu-0.0.5.dist-info → furu-0.0.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.27
+Generator: uv 0.9.28
 Root-Is-Purelib: true
 Tag: py3-none-any