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

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/schema.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import chz
+
+from .serialization.serializer import JsonValue
+
+
+def schema_key_from_furu_obj(furu_obj: dict[str, JsonValue]) -> tuple[str, ...]:
+    if not isinstance(furu_obj, dict):
+        raise TypeError(f"schema_key requires dict furu_obj, got {type(furu_obj)}")
+    keys: set[str] = set()
+    for key in furu_obj:
+        if not isinstance(key, str):
+            raise TypeError(f"schema_key requires string keys, got {type(key)}")
+        if key.startswith("_"):
+            continue
+        keys.add(key)
+    return tuple(sorted(keys))
+
+
+def schema_key_from_metadata_raw(metadata: dict[str, JsonValue]) -> tuple[str, ...]:
+    raw = metadata.get("schema_key")
+    if raw is None:
+        raise ValueError("metadata missing schema_key")
+    if isinstance(raw, tuple):
+        items = raw
+    elif isinstance(raw, list):
+        items = raw
+    else:
+        raise TypeError(f"metadata schema_key must be list or tuple, got {type(raw)}")
+    keys: list[str] = []
+    for item in items:
+        if not isinstance(item, str):
+            raise TypeError(f"metadata schema_key must be strings, got {type(item)}")
+        keys.append(item)
+    return tuple(keys)
+
+
+def schema_key_from_cls(cls: type) -> tuple[str, ...]:
+    fields = chz.chz_fields(cls)
+    keys = {
+        field.logical_name
+        for field in fields.values()
+        if not field.logical_name.startswith("_")
+    }
+    return tuple(sorted(keys))

furu/storage/metadata.py

@@ -1,5 +1,6 @@
 import datetime
 import getpass
+import importlib.metadata
 import json
 import os
 import platform
@@ -9,9 +10,10 @@ import sys
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, field_validator
 
 from ..config import FURU_CONFIG
+from ..schema import schema_key_from_furu_obj
 from ..serialization import BaseModel as PydanticBaseModel
 from ..serialization import FuruSerializer
 from ..serialization.serializer import JsonValue
@@ -50,6 +52,7 @@ class EnvironmentInfo(BaseModel):
 
     timestamp: str
     command: str
+    furu_package_version: str | None = None
     python_version: str
     executable: str
     platform: str
@@ -66,6 +69,7 @@ class FuruMetadata(BaseModel):
     # Furu-specific fields
     furu_python_def: str
     furu_obj: JsonValue  # Serialized Furu object from FuruSerializer.to_dict()
+    schema_key: tuple[str, ...]
     furu_hash: str
     furu_path: str
 
@@ -79,6 +83,7 @@ class FuruMetadata(BaseModel):
     # Environment info
     timestamp: str
     command: str
+    furu_package_version: str | None = None
     python_version: str
     executable: str
     platform: str
@@ -86,6 +91,13 @@ class FuruMetadata(BaseModel):
     user: str
     pid: int
 
+    @field_validator("schema_key", mode="before")
+    @classmethod
+    def _coerce_schema_key(cls, value: object) -> object:
+        if isinstance(value, list):
+            return tuple(value)
+        return value
+
 
 class MetadataManager:
     """Handles metadata collection and storage."""
@@ -150,7 +162,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:
@@ -216,6 +229,7 @@ class MetadataManager:
                 timespec="microseconds"
             ),
             command=" ".join(sys.argv) if sys.argv else "<unknown>",
+            furu_package_version=importlib.metadata.version("furu"),
             python_version=sys.version,
             executable=sys.executable,
             platform=platform.platform(),
@@ -237,10 +251,12 @@ class MetadataManager:
             raise TypeError(
                 f"Expected FuruSerializer.to_dict to return dict, got {type(serialized_obj)}"
             )
+        schema_key = schema_key_from_furu_obj(serialized_obj)
 
         return FuruMetadata(
             furu_python_def=FuruSerializer.to_python(furu_obj, multiline=False),
             furu_obj=serialized_obj,
+            schema_key=schema_key,
             furu_hash=FuruSerializer.compute_hash(furu_obj),
             furu_path=str(directory.resolve()),
             git_commit=git_info.git_commit,
@@ -250,6 +266,7 @@ class MetadataManager:
             git_submodules=git_info.git_submodules,
             timestamp=env_info.timestamp,
             command=env_info.command,
+            furu_package_version=env_info.furu_package_version,
             python_version=env_info.python_version,
             executable=env_info.executable,
             platform=env_info.platform,

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.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: furu
-Version: 0.0.5
+Version: 0.0.7
 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.7.dist-info}/RECORD

@@ -1,21 +1,22 @@
-furu/__init__.py,sha256=Z8VssTuQm2nH7bgB8SQc8pXsNGc-H1QGHFffKzNzqk8,2018
+furu/__init__.py,sha256=umlKxb3zB5KYsx3meqLFzqNRduGfEVUplTZSelX-p4E,1729
 furu/adapters/__init__.py,sha256=onLzEj9hccPK15g8a8va2T19nqQXoxb9rQlJIjKSKnE,69
 furu/adapters/submitit.py,sha256=FV3XEUSQuS5vIyzkW-Iuqtf8SRL-fsokPG67u7tMF5I,7276
+furu/aliases.py,sha256=C31Oe2w8gTAuVjo-eKCs_Xp3Ir16HRyn327CeczuO6c,1755
 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=PBz9_gykog9J-QY45pt99DR5f03ssFys1DhiEPBRAQA,66692
 furu/core/list.py,sha256=QaGSh8NFg1K2WFncM8duOYQ6KLZ6EW2pRLArN_e5Juw,3662
 furu/dashboard/__init__.py,sha256=ziAordJfkbbXNIM7iA9O7vR2gsCq34AInYiMYOCfWOc,362
 furu/dashboard/__main__.py,sha256=cNs65IMl4kwZFpxa9xLXmFSy4-M5D1X1ZBfTDxW11vo,144
 furu/dashboard/api/__init__.py,sha256=9-WyWOt-VQJJBIsdW29D-7JvR-BivJd9G_SRaRptCz0,80
-furu/dashboard/api/models.py,sha256=SCu-kLJyW7dwSKswdgQNS3wQuj25ORs0pHkvX9xBbo4,4767
-furu/dashboard/api/routes.py,sha256=iZez0khIUvbgfeSoy1BJvmoEEbgUrdSQA8SN8iAIkM8,4813
+furu/dashboard/api/models.py,sha256=ptC1NKMl2zGb8ERR7JY_EQBi-Zxc4NvNhnFxcOsBawk,5133
+furu/dashboard/api/routes.py,sha256=TCGTceH-i7dv1Y6JE4JFBcmyOs6QTTDRp5zdjwuBpPQ,5035
 furu/dashboard/frontend/dist/assets/index-BXAIKNNr.css,sha256=qhsN0Td3mM-GAR8mZ0CtocynABLKa1ncl9ioDrTKOIQ,34768
-furu/dashboard/frontend/dist/assets/index-BjyrY-Zz.js,sha256=fItsQ--Dzobq5KdUcuqDi4txM2-NNqx8JET5Lwkwf7U,544515
+furu/dashboard/frontend/dist/assets/index-NiDdQnqO.js,sha256=Ns1BosYU5xckMAn_b4iUtD6-m7tB9r3GY7_rwFgzumI,545103
 furu/dashboard/frontend/dist/favicon.svg,sha256=3TSLHNZITFe3JTPoYHZnDgiGsJxIzf39v97l2A1Hodo,369
-furu/dashboard/frontend/dist/index.html,sha256=Ig-j0qgTXBSge0GN7PaM7mcLnuRhRMQmkTZjU1wmTXY,810
+furu/dashboard/frontend/dist/index.html,sha256=i7eDqiisdL86W0ZldsUg3z5wsX1NfH98adPxgh0p06Q,810
 furu/dashboard/main.py,sha256=gj9Cdj2qyaSCEkmfNHUMQXlXv6GpWTQ9IZEi7WzlCSo,4463
-furu/dashboard/scanner.py,sha256=qXCvkvFByBc09TUdth5Js67rS8zpRBlRkVQ9dJ7YbdE,34696
+furu/dashboard/scanner.py,sha256=CMLcUTZ2mvaigpMM1qbonpPwvG8Om_FIVd11PruSZFo,35467
 furu/errors.py,sha256=FFbV4M0-ipVGizv5ee80L-NZFVjaRjy8i19mClr6R0g,3959
 furu/execution/__init__.py,sha256=ixVw1Shvg2ulS597OYYeGgSSTwv25j_McuQdDXIiEL8,625
 furu/execution/context.py,sha256=0tAbM0azqEus8hknf_A9-Zs9Sq99bnUkFyV4RO4ZMRU,666
@@ -27,20 +28,22 @@ furu/execution/slurm_dag.py,sha256=xh9EUGdPZaAH3UfcRqo6MsKYBIV-UW3_7owY8kLOwz4,9
 furu/execution/slurm_pool.py,sha256=ft76Gp-HgFWWjGvDclUChLOjY1rvhhfkP5mxhK3ViQk,30395
 furu/execution/slurm_spec.py,sha256=DG8BF4FCga2ZXsqGUvfNibk6II40JcShVZ4jTwxTdec,977
 furu/execution/submitit_factory.py,sha256=B2vkDtmscuAX0sBaj9V5pNlgOtkkV35yJ1fZ7A-DSvU,1119
-furu/migrate.py,sha256=x_Uh7oXAv40L5ZAHJhdnw-o7ct56rWUSZLbHHfRObeY,1313
-furu/migration.py,sha256=EYWULuH8lEVvESthO2qEF95WJTo1Uj6d4L6VU2zmWpw,31350
+furu/migration.py,sha256=OG-GvDscZYNY0Mz8nQJ-F7tWW9Ev6iUwTKOyc6uwBpc,21058
 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/schema.py,sha256=t-XyapYJpYQEmLFo-PGwrCUzfAG-WefTi3OYbveRp0Y,1453
 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=EYT4sRSFz2KY3nlc4DAJBfxuvi2rQedPjPK_NGJlQ3k,10313
 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.7.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+furu-0.0.7.dist-info/entry_points.txt,sha256=hZkjtFzNlb33Zk-aUfLMRj-XgVDxdT82-JXG9d4bu2E,60
+furu-0.0.7.dist-info/METADATA,sha256=v6gNqvq19H4H9WPMl2PcaDIOZVP1Qtz1lQfzBMzN0Yc,19117
+furu-0.0.7.dist-info/RECORD,,

{furu-0.0.5.dist-info → furu-0.0.7.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

furu/migrate.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal, Mapping
-
-from .core.furu import Furu
-from .migration import (
-    MigrationValue,
-    apply_migration,
-    find_migration_candidates_initialized_target,
-)
-from .storage import MigrationRecord
-
-
-MigrationPolicy = Literal["alias", "move", "copy"]
-
-
-def migrate(
-    from_obj: Furu,
-    to_obj: Furu,
-    *,
-    policy: MigrationPolicy = "alias",
-    origin: str | None = None,
-    note: str | None = None,
-    default_values: Mapping[str, MigrationValue] | None = None,
-) -> MigrationRecord:
-    from_namespace = ".".join(from_obj._namespace().parts)
-    candidates = find_migration_candidates_initialized_target(
-        to_obj=to_obj,
-        from_namespace=from_namespace,
-        default_fields=None,
-        drop_fields=None,
-    )
-    if not candidates:
-        raise ValueError("migration: no candidates found for initialized target")
-    if len(candidates) != 1:
-        raise ValueError("migration: expected exactly one candidate")
-    candidate = candidates[0]
-    if default_values:
-        candidate = candidate.with_default_values(default_values)
-    records = apply_migration(
-        candidate,
-        policy=policy,
-        cascade=True,
-        origin=origin,
-        note=note,
-        conflict="throw",
-    )
-    return records[0]