furu 0.0.3__py3-none-any.whl → 0.0.4__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/runtime/logging.py

@@ -28,16 +28,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 +69,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()
@@ -163,7 +163,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 +174,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)
@@ -288,7 +288,7 @@ 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"

furu/storage/state.py

@@ -400,15 +400,41 @@ class StateManager:
 
     @classmethod
     def release_lock(cls, fd: int | None, lock_path: Path) -> None:
-        if fd is not None:
+        """Release a lock acquired via :meth:`try_lock`.
+
+        We best-effort avoid deleting a lock that was broken and replaced by
+        another process by verifying the inode of the open fd matches the
+        current lock_path inode before unlinking.
+        """
+        if fd is None:
+            return
+        try:
+            fd_stat = os.fstat(fd)
+        except OSError:
+            fd_stat = None
+        try:
+            path_stat = lock_path.stat()
+        except FileNotFoundError:
+            path_stat = None
+        try:
+            if (
+                fd_stat is not None
+                and path_stat is not None
+                and fd_stat.st_ino == path_stat.st_ino
+                and fd_stat.st_dev == path_stat.st_dev
+            ):
+                lock_path.unlink(missing_ok=True)
+        finally:
             os.close(fd)
-        lock_path.unlink(missing_ok=True)
 
     @classmethod
     def _read_lock_info(cls, lock_path: Path) -> _LockInfoDict | None:
         if not lock_path.is_file():
             return None
-        text = lock_path.read_text().strip()
+        try:
+            text = lock_path.read_text().strip()
+        except FileNotFoundError:
+            return None
         if not text:
             return None
         lines = text.splitlines()
@@ -978,6 +1004,7 @@ def compute_lock(
     wait_log_every_sec: float = 10.0,
     reconcile_fn: Callable[[Path], None] | None = None,
     allow_failed: bool = False,
+    allow_success: bool = False,
 ) -> Generator[ComputeLockContext, None, None]:
     """
     Context manager that atomically acquires lock + records attempt + starts heartbeat.
@@ -1002,6 +1029,7 @@ def compute_lock(
         wait_log_every_sec: Interval between "waiting for lock" log messages
         reconcile_fn: Optional function to call to reconcile stale attempts
         allow_failed: Allow recomputation even if state is failed
+        allow_success: Allow recomputation even if state is successful
 
     Yields:
         ComputeLockContext with attempt_id and stop_heartbeat callable
@@ -1097,7 +1125,7 @@ def compute_lock(
         lock_fd = StateManager.try_lock(lock_path)
         if lock_fd is not None:
             state = StateManager.read_state(directory)
-            if isinstance(state.result, _StateResultSuccess):
+            if isinstance(state.result, _StateResultSuccess) and not allow_success:
                 StateManager.release_lock(lock_fd, lock_path)
                 raise FuruLockNotAcquired(
                     "Cannot acquire lock: experiment already succeeded"
@@ -1117,7 +1145,7 @@ def compute_lock(
                 if reconcile_fn is not None:
                     reconcile_fn(directory)
                     state = StateManager.read_state(directory)
-                if isinstance(state.result, _StateResultSuccess):
+                if isinstance(state.result, _StateResultSuccess) and not allow_success:
                     raise FuruLockNotAcquired(
                         "Cannot acquire lock: experiment already succeeded"
                     )
@@ -1151,7 +1179,7 @@ def compute_lock(
         attempt = state.attempt
 
         # If result is terminal, no point waiting
-        if isinstance(state.result, _StateResultSuccess):
+        if isinstance(state.result, _StateResultSuccess) and not allow_success:
             raise FuruLockNotAcquired(
                 "Cannot acquire lock: experiment already succeeded"
             )

{furu-0.0.3.dist-info → furu-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: furu
-Version: 0.0.3
+Version: 0.0.4
 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>
@@ -44,7 +44,7 @@ The `[dashboard]` extra includes the web dashboard. Omit it for the core library
 1. Subclass `furu.Furu[T]`
 2. Implement `_create(self) -> T` (compute and write to `self.furu_dir`)
 3. Implement `_load(self) -> T` (load from `self.furu_dir`)
-4. Call `load_or_create()`
+4. Call `get()`
 
 ```python
 # my_project/pipelines.py
@@ -75,10 +75,10 @@ class TrainModel(furu.Furu[Path]):
 from my_project.pipelines import TrainModel
 
 # First call: runs _create(), caches result
-artifact = TrainModel(lr=3e-4, steps=5000).load_or_create()
+artifact = TrainModel(lr=3e-4, steps=5000).get()
 
 # Second call with same config: loads from cache via _load()
-artifact = TrainModel(lr=3e-4, steps=5000).load_or_create()
+artifact = TrainModel(lr=3e-4, steps=5000).get()
 ```
 
 > **Tip:** Define Furu classes in importable modules (not `__main__`); the artifact namespace is derived from the class's module + qualified name.
@@ -96,7 +96,7 @@ Each `Furu` instance maps deterministically to a directory based on its config:
 - **namespace**: Derived from the class's module + qualified name (e.g., `my_project.pipelines/TrainModel`)
 - **hash**: Computed from the object's config values using Blake2s
 
-When you call `load_or_create()`:
+When you call `get()`:
 1. If no cached result exists → run `_create()`, save state as "success"
 2. If cached result exists → run `_load()` to retrieve it
 3. If another process is running → wait for it to finish, then load
@@ -123,7 +123,7 @@ class TrainTextModel(furu.Furu[str]):
     dataset: Dataset = furu.chz.field(default_factory=Dataset)
 
     def _create(self) -> str:
-        data = self.dataset.load_or_create()  # Triggers Dataset cache
+        data = self.dataset.get()  # Triggers Dataset cache
         (self.furu_dir / "model.txt").write_text(f"trained on:\n{data}")
         return "trained"
 
@@ -131,6 +131,58 @@ class TrainTextModel(furu.Furu[str]):
         return (self.furu_dir / "model.txt").read_text()
 ```
 
+### Executors (Local + Slurm)
+
+Use the execution helpers for batch runs and cluster scheduling:
+
+```python
+from furu.execution import run_local
+
+run_local(
+    [TrainModel(lr=3e-4, steps=5000), TrainModel(lr=1e-3, steps=2000)],
+    max_workers=8,
+    window_size="bfs",
+)
+```
+
+```python
+from furu.execution import SlurmSpec, submit_slurm_dag
+
+specs = {
+    "default": SlurmSpec(partition="cpu", cpus=8, mem_gb=32, time_min=120),
+    "gpu": SlurmSpec(partition="gpu", gpus=1, cpus=8, mem_gb=64, time_min=720),
+}
+
+submit_slurm_dag([TrainModel(lr=3e-4, steps=5000)], specs=specs)
+```
+
+```python
+from furu.execution import run_slurm_pool
+
+run_slurm_pool(
+    [TrainModel(lr=3e-4, steps=5000)],
+    specs=specs,
+    max_workers_total=50,
+    window_size="bfs",
+)
+```
+
+Submitit logs are stored under `<FURU_PATH>/submitit` by default. Override with
+`FURU_SUBMITIT_PATH` when you want a different logs root.
+
+### Breaking Changes and Executor Semantics
+
+- `load_or_create()` is removed; use `get()` exclusively.
+- `get()` no longer accepts per-call `retry_failed` overrides. Configure retries via
+  `FURU_RETRY_FAILED` or `FURU_CONFIG.retry_failed`.
+- Executor runs (`run_local`, `run_slurm_pool`, `submit_slurm_dag`) fail fast if a
+  dependency is FAILED while `retry_failed` is disabled; with retries enabled, failed
+  compute nodes are retried (bounded by `FURU_MAX_COMPUTE_RETRIES` retries).
+- Pool protocol/queue failures (invalid payloads, spec mismatch, missing artifacts) are
+  fatal even when `retry_failed` is enabled; only compute failures are retried.
+- `FURU_ALWAYS_RERUN` causes matching nodes to recompute once per executor run, but
+  repeated references in the same run reuse that result.
+
 ### Storage Structure
 
 Furu uses two roots: `FURU_PATH` for `data/` + `raw/`, and
@@ -176,7 +228,7 @@ class MyExperiments(furu.FuruList[TrainModel]):
 
 # Iterate over all experiments
 for exp in MyExperiments:
-    exp.load_or_create()
+    exp.get()
 
 # Access by name
 exp = MyExperiments.by_name("baseline")
@@ -191,14 +243,17 @@ for name, exp in MyExperiments.items():
 
 ### Custom Validation
 
-Override `_validate()` to add custom cache invalidation logic:
+Override `_validate()` to add custom cache invalidation logic. Return False or
+raise `furu.FuruValidationError` to force re-computation. In executor planning,
+any other exception is logged and treated as invalid (no crash); in interactive
+`exists()` calls, exceptions still surface:
 
 ```python
 class ModelWithValidation(furu.Furu[Path]):
     checkpoint_name: str = "model.pt"
 
     def _validate(self) -> bool:
-        # Return False to force re-computation
+        # Return False (or raise FuruValidationError) to force re-computation
         ckpt = self.furu_dir / self.checkpoint_name
         return ckpt.exists() and ckpt.stat().st_size > 0
 
@@ -220,7 +275,7 @@ if obj.exists():
 
 # Get metadata without triggering computation
 metadata = obj.get_metadata()
-print(f"Hash: {obj._furu_hash}")
+print(f"Hash: {obj.furu_hash}")
 print(f"Dir: {obj.furu_dir}")
 ```
 
@@ -251,7 +306,7 @@ class LargeDataProcessor(furu.Furu[Path]):
     def _create(self) -> Path:
         # self.raw_dir is shared across all configs
         # Create a subfolder for isolation if needed
-        my_raw = self.raw_dir / self._furu_hash
+        my_raw = self.raw_dir / self.furu_hash
         my_raw.mkdir(exist_ok=True)
         
         large_file = my_raw / "huge_dataset.bin"
@@ -303,8 +358,8 @@ HHMMSS file.py:line message
 
 Furu emits status messages like:
 ```
-load_or_create TrainModel abc123def (missing->create)
-load_or_create TrainModel abc123def (success->load)
+get TrainModel abc123def (missing->create)
+get TrainModel abc123def (success->load)
 ```
 
 ### Explicit Setup
@@ -325,7 +380,7 @@ logger = furu.get_logger()
 from furu import FuruComputeError, FuruWaitTimeout, FuruLockNotAcquired
 
 try:
-    result = obj.load_or_create()
+    result = obj.get()
 except FuruComputeError as e:
     print(f"Computation failed: {e}")
     print(f"State file: {e.state_path}")
@@ -336,8 +391,8 @@ except FuruLockNotAcquired:
     print("Could not acquire lock")
 ```
 
-By default, failed artifacts are retried on the next `load_or_create()` call. Set
-`FURU_RETRY_FAILED=0` or pass `retry_failed=False` to keep failures sticky.
+By default, failed artifacts are retried on the next `get()` call. Set
+`FURU_RETRY_FAILED=0` to keep failures sticky.
 
 `FURU_MAX_WAIT_SECS` overrides the per-class `_max_wait_time_sec` (default 600s)
 timeout used when waiting for compute locks before raising `FuruWaitTimeout`.
@@ -349,27 +404,8 @@ and `furu.log`.
 
 ## Submitit Integration
 
-Run computations on SLURM clusters via [submitit](https://github.com/facebookincubator/submitit):
-
-```python
-import submitit
-import furu
-
-executor = submitit.AutoExecutor(folder="submitit_logs")
-executor.update_parameters(
-    timeout_min=60,
-    slurm_partition="gpu",
-    gpus_per_node=1,
-)
-
-# Submit job and return immediately
-job = my_furu_obj.load_or_create(executor=executor)
-
-# Job ID is tracked in .furu/state.json
-print(job.job_id)
-```
-
-Furu handles preemption, requeuing, and state tracking automatically.
+Furu includes a `SubmititAdapter` for integrating submitit executors with the
+state system. Executor helpers in `furu.execution` handle submission workflows.
 
 ## Dashboard
 
@@ -427,6 +463,7 @@ The `/api/experiments` endpoint supports:
 | `FURU_IGNORE_DIFF` | `false` | Skip embedding git diff in metadata |
 | `FURU_ALWAYS_RERUN` | `""` | Comma-separated class qualnames to always rerun (use `ALL` to bypass cache globally; cannot combine with other entries; entries must be importable) |
 | `FURU_RETRY_FAILED` | `true` | Retry failed artifacts by default (set to `0` to keep failures sticky) |
+| `FURU_MAX_COMPUTE_RETRIES` | `3` | Maximum compute retries per node after the first failure |
 | `FURU_POLL_INTERVAL_SECS` | `10` | Polling interval for queued/running jobs |
 | `FURU_MAX_WAIT_SECS` | unset | Override wait timeout (falls back to `_max_wait_time_sec`, default 600s) |
 | `FURU_WAIT_LOG_EVERY_SECS` | `10` | Interval between "waiting" log messages |

{furu-0.0.3.dist-info → furu-0.0.4.dist-info}/RECORD

@@ -1,11 +1,11 @@
-furu/__init__.py,sha256=c0rtDRCWRafo0gB4x7qOMVL8ZXtxHOrPnJIs_CwrWlY,1818
+furu/__init__.py,sha256=Z8VssTuQm2nH7bgB8SQc8pXsNGc-H1QGHFffKzNzqk8,2018
 furu/adapters/__init__.py,sha256=onLzEj9hccPK15g8a8va2T19nqQXoxb9rQlJIjKSKnE,69
-furu/adapters/submitit.py,sha256=OuCP0pEkO1kI4WLcSUvMqXwVCCy-8uwUE7v1qvkLZnU,6214
-furu/config.py,sha256=UvSkUDNh0iuMKyl0OelKO5i7FAdkHnqnfbTFXaIaXvY,6886
+furu/adapters/submitit.py,sha256=FV3XEUSQuS5vIyzkW-Iuqtf8SRL-fsokPG67u7tMF5I,7276
+furu/config.py,sha256=1nlJff4KNrWDvLhmnuLrsc7FJIxFLFhz3eOXZ8-ngX4,7349
 furu/core/__init__.py,sha256=6hH7i6r627c0FZn6eQVsSG7LD4QmTta6iQw0AiPQPTM,156
-furu/core/furu.py,sha256=Uz5vVo161Duvl94hwn7u2WH9MaDFQFqlxowzHGigkkY,51592
-furu/core/list.py,sha256=hwwlvqaKB1grPBGKXc15scF1RCqDvWc0AoDbhKlN4W0,3625
-furu/dashboard/__init__.py,sha256=zNVddterfpjQtcpihIl3TRJdgdjOHYR0uO0cOSaGABg,172
+furu/core/furu.py,sha256=Cy2cOnM5vsQoSk9nIVYj2Fx017wOQFPbxhnvYQsh7nI,58881
+furu/core/list.py,sha256=xSuBT35p1anJ2fKQPxb-3cRTONUamFjfzkreVaI9Jo4,3614
+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
@@ -14,14 +14,24 @@ furu/dashboard/frontend/dist/assets/index-BXAIKNNr.css,sha256=qhsN0Td3mM-GAR8mZ0
 furu/dashboard/frontend/dist/assets/index-DS3FsqcY.js,sha256=nfrKjhWThPtL8n5iTd9_1W-bsyMGwg2O8Iq2jkjj9Lg,544699
 furu/dashboard/frontend/dist/favicon.svg,sha256=3TSLHNZITFe3JTPoYHZnDgiGsJxIzf39v97l2A1Hodo,369
 furu/dashboard/frontend/dist/index.html,sha256=d9a8ZFKZ5uDtN3urqVNmS8LWMBhOC0eW7X0noT0RcYQ,810
-furu/dashboard/main.py,sha256=8JYc79gbJ9MjvIRdGDuAcR2Mme9kyY4ryZb11ZZ4uVA,4069
+furu/dashboard/main.py,sha256=gj9Cdj2qyaSCEkmfNHUMQXlXv6GpWTQ9IZEi7WzlCSo,4463
 furu/dashboard/scanner.py,sha256=qXCvkvFByBc09TUdth5Js67rS8zpRBlRkVQ9dJ7YbdE,34696
-furu/errors.py,sha256=tWKLOtkP5uYDuqozeImCN7WzjFforPj1WImW0AWc4Vk,3684
+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
+furu/execution/local.py,sha256=TkKrRdmaQrN7i7Sxe87eHibRJOnz5OxU0Oj8qL_xP4I,7059
+furu/execution/paths.py,sha256=0MfQk5Kh7bxvJiWvG40TJe7RF5Q5Na6uvi6qV0OT3Vc,460
+furu/execution/plan.py,sha256=fM7CkXm_M0lL3vqdiNnWzbvMJAoSYKDBAnC82Af_rYM,6860
+furu/execution/plan_utils.py,sha256=TAQqlPeJfOdH2MT-X7g3j1Se_0e4oKvG0tJaWC1kM40,381
+furu/execution/slurm_dag.py,sha256=FOJcPKmIzRyrbJIq7heqGjKN0EFRMyOcV-yP7Ci87Qs,9360
+furu/execution/slurm_pool.py,sha256=bi90fzZXAnoWHSPQba8Z3tk4_QMaqikWxCCzRfvDMvk,30400
+furu/execution/slurm_spec.py,sha256=A1VX5K6aG8Ricg4fhnkz3Alkw_fx1bx53D0p4Ms3FqA,979
+furu/execution/submitit_factory.py,sha256=B2vkDtmscuAX0sBaj9V5pNlgOtkkV35yJ1fZ7A-DSvU,1119
 furu/migrate.py,sha256=x_Uh7oXAv40L5ZAHJhdnw-o7ct56rWUSZLbHHfRObeY,1313
 furu/migration.py,sha256=R2-tARMx4VKryiqJ7WHia_dPVxRbTqofPpCFVE9zQ8U,31411
 furu/runtime/__init__.py,sha256=fQqE7wUuWunLD73Vm3lss7BFSij3UVxXOKQXBAOS8zw,504
 furu/runtime/env.py,sha256=o1phhoTDhOnhALr3Ozf1ldrdvk2ClyEvBWbebHM6BXg,160
-furu/runtime/logging.py,sha256=JkuTFtbv6dYk088P6_Bga46bnKSDt-ElAqmiY86hMys,9773
+furu/runtime/logging.py,sha256=WS3mB8VqMYUxPPI0yv1K-LnzVBj84Mnu1Qf9P2hCUUE,9652
 furu/runtime/tracebacks.py,sha256=PGCuOq8QkWSoun791gjUXM8frOP2wWV8IBlqaA4nuGE,1631
 furu/serialization/__init__.py,sha256=L7oHuIbxdSh7GCY3thMQnDwlt_ERH-TMy0YKEAZLrPs,341
 furu/serialization/migrations.py,sha256=HD5g8JCBdH3Y0rHJYc4Ug1IXBVcUDxLE7nfiXZnXcUE,7772
@@ -29,8 +39,8 @@ furu/serialization/serializer.py,sha256=_nfUaAOy_KHegvfXlpPh4rCuvkzalJva75OvDg5n
 furu/storage/__init__.py,sha256=cLLL-GPpSu9C72Mdk5S6TGu3g-SnBfEuxzfpx5ZJPtw,616
 furu/storage/metadata.py,sha256=MH6w5hs-2rwHD6G9erMPM5pE3hm0h5Pk_G3Z6eyyGB0,9899
 furu/storage/migration.py,sha256=Ars9aYwvhXpIBDf6L9ojGjp_l656-RfdtEAFKN0sZZY,2640
-furu/storage/state.py,sha256=rAzR0XJS3OvwGMATlppxNQwX1FrSIffUTkptSwOjBcs,42627
-furu-0.0.3.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
-furu-0.0.3.dist-info/entry_points.txt,sha256=hZkjtFzNlb33Zk-aUfLMRj-XgVDxdT82-JXG9d4bu2E,60
-furu-0.0.3.dist-info/METADATA,sha256=NY6H_CMvm2-wc21GdRpMWxa5cK4HMxMwylTDVaZy2aY,14615
-furu-0.0.3.dist-info/RECORD,,
+furu/storage/state.py,sha256=SFonqragT2eMCZbBKIvcA4JVe78rVmDRvo4Ky2IcNgc,43632
+furu-0.0.4.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+furu-0.0.4.dist-info/entry_points.txt,sha256=hZkjtFzNlb33Zk-aUfLMRj-XgVDxdT82-JXG9d4bu2E,60
+furu-0.0.4.dist-info/METADATA,sha256=fdUBvn-vEnVim9V5hAamE1sFuaKzWdwWPI17VU2Vyfc,16162
+furu-0.0.4.dist-info/RECORD,,