Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

fix + chore: cache version bump (#8793)

Dylan Madisettib5747c66d0ba
diff --git a/marimo/_runtime/context/kernel_context.py b/marimo/_runtime/context/kernel_context.py
index 3048c8a28f..599d10d81d 100644
--- a/marimo/_runtime/context/kernel_context.py
+++ b/marimo/_runtime/context/kernel_context.py
@@ -155,6 +155,7 @@ def create_kernel_context(
SharedMemoryStorage,
VirtualFileRegistry,
)
+ from marimo._save.cache import CacheState
from marimo._save.stores import get_store
# Use shared memory in edit mode,
@@ -172,7 +173,7 @@ def create_kernel_context(
ui_element_registry=UIElementRegistry(),
state_registry=StateRegistry(),
function_registry=FunctionRegistry(),
- cache_store=get_store(kernel.app_metadata.filename),
+ cache=CacheState(store=get_store(kernel.app_metadata.filename)),
cell_lifecycle_registry=CellLifecycleRegistry(),
app_kernel_runner_registry=(
parent.app_kernel_runner_registry
diff --git a/marimo/_runtime/context/script_context.py b/marimo/_runtime/context/script_context.py
index 12537c8d67..5657ac1e1e 100644
--- a/marimo/_runtime/context/script_context.py
+++ b/marimo/_runtime/context/script_context.py
@@ -150,6 +150,7 @@ def initialize_script_context(
InMemoryStorage,
VirtualFileRegistry,
)
+ from marimo._save.cache import CacheState
from marimo._save.stores import get_store
runtime_context = ScriptRuntimeContext(
@@ -157,7 +158,7 @@ def initialize_script_context(
ui_element_registry=UIElementRegistry(),
state_registry=StateRegistry(),
function_registry=FunctionRegistry(),
- cache_store=get_store(filename),
+ cache=CacheState(store=get_store(filename)),
cell_lifecycle_registry=CellLifecycleRegistry(),
app_kernel_runner_registry=AppKernelRunnerRegistry(),
virtual_file_registry=VirtualFileRegistry(storage=InMemoryStorage()),
diff --git a/marimo/_runtime/context/types.py b/marimo/_runtime/context/types.py
index 385c270d4d..978c13dc1e 100644
--- a/marimo/_runtime/context/types.py
+++ b/marimo/_runtime/context/types.py
@@ -35,7 +35,7 @@ if TYPE_CHECKING:
from marimo._runtime.params import CLIArgs, QueryParams
from marimo._runtime.state import State, StateRegistry
from marimo._runtime.virtual_file import VirtualFileRegistry
- from marimo._save.stores import Store
+ from marimo._save.cache import CacheState
from marimo._types.ids import CellId_t
@@ -90,7 +90,7 @@ class RuntimeContext(abc.ABC):
virtual_file_registry: VirtualFileRegistry
virtual_files_supported: bool
app_kernel_runner_registry: AppKernelRunnerRegistry
- cache_store: Store
+ cache: CacheState
# stream, stdout, stderr are _not_ owned by the context
stream: Stream
stdout: Stdout | None
diff --git a/marimo/_save/cache.py b/marimo/_save/cache.py
index 6a84211a7b..f61bce8e25 100644
--- a/marimo/_save/cache.py
+++ b/marimo/_save/cache.py
@@ -5,10 +5,11 @@ import abc
import inspect
import re
from collections import namedtuple
-from dataclasses import dataclass
+from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Any, Literal, Optional, get_args
from marimo._plugins.ui._core.ui_element import UIElement
+from marimo._runtime.cell_lifecycle_item import CellLifecycleItem
from marimo._runtime.context import ContextNotInitializedError, get_context
from marimo._runtime.state import SetFunctor
from marimo._save.stubs import (
@@ -32,12 +33,14 @@ UNEXPECTED_FAILURE_BOILERPLATE = (
if TYPE_CHECKING:
from marimo._ast.visitor import Name
+ from marimo._runtime.context.types import RuntimeContext
from marimo._runtime.state import State
from marimo._save.hash import HashKey
from marimo._save.loaders import Loader
+ from marimo._save.stores import Store
# NB. Increment on cache breaking changes.
-MARIMO_CACHE_VERSION: int = 3
+MARIMO_CACHE_VERSION: int = 4
CacheType = Literal[
"ContextExecutionPath",
@@ -57,6 +60,51 @@ CACHE_PREFIX: dict[CacheType, str] = {
"Unknown": "U_",
}
+
+@dataclass
+class CacheState:
+ """Groups cache-related state on RuntimeContext.
+
+ The ``is_memoizable`` method controls which value types are eligible
+ for content-hash memoization. Override (or swap the instance) to
+ broaden memoization for cached / parallel execution.
+ """
+
+ store: Store
+ hash_memo: dict[str, bytes] = field(default_factory=dict)
+
+ def is_memoizable(self, value: Any) -> bool:
+ """Whether *value* is eligible for content-hash memoization.
+
+ Currently restricted to non-primitive data primitives (tensors,
+ arrays) — they are expensive to serialize and typically long-lived.
+ """
+ from marimo._runtime.primitives import is_data_primitive, is_primitive
+
+ return not is_primitive(value) and is_data_primitive(value)
+
+
+class HashMemoCleanup(CellLifecycleItem):
+ """Clears memoized content hashes when a defining cell is re-executed.
+
+ Deduped via __hash__/__eq__ — at most one per cell's lifecycle set.
+ Gets cache from context at disposal time.
+ """
+
+ def __hash__(self) -> int:
+ return hash("HashMemoCleanup")
+
+ def __eq__(self, other: object) -> bool:
+ return isinstance(other, HashMemoCleanup)
+
+ def create(self, context: RuntimeContext | None) -> None:
+ pass
+
+ def dispose(self, context: RuntimeContext, deletion: bool) -> bool: # noqa: ARG002
+ context.cache.hash_memo.clear()
+ return True
+
+
ValidCacheSha = namedtuple("ValidCacheSha", ("sha", "cache_type"))
MetaKey = Literal["return", "version", "runtime"]
# Matches functools
diff --git a/marimo/_save/encode.py b/marimo/_save/encode.py
index 38efdf742b..4fa9233b56 100644
--- a/marimo/_save/encode.py
+++ b/marimo/_save/encode.py
@@ -41,14 +41,14 @@ def type_sign(value: bytes, label: str) -> bytes:
# TODO: Benchmark something like `sha1 (integrity) + delimiter`, this
# method is chosen because it was assumed to be fast, but might be slow
# with a copy of large data.
- return b"".join([value, bytes(len(value)), bytes(":" + label, "utf-8")])
+ length = struct.pack("!Q", len(value))
+ return b"".join([value, length, bytes(":" + label, "utf-8")])
def iterable_sign(value: Iterable[Any], label: str) -> bytes:
values = list(value)
- return b"".join(
- [b"".join(values), bytes(len(values)), bytes(":" + label, "utf-8")]
- )
+ length = struct.pack("!Q", len(values))
+ return b"".join([b"".join(values), length, bytes(":" + label, "utf-8")])
def standardize_tensor(tensor: Tensor) -> Tensor:
diff --git a/marimo/_save/hash.py b/marimo/_save/hash.py
index d2ff36e74a..a5a8c26f13 100644
--- a/marimo/_save/hash.py
+++ b/marimo/_save/hash.py
@@ -33,7 +33,7 @@ from marimo._runtime.primitives import (
from marimo._runtime.side_effect import CellHash, SideEffect
from marimo._runtime.state import SetFunctor, State
from marimo._runtime.watch._path import PathState
-from marimo._save.cache import Cache, CacheType
+from marimo._save.cache import Cache, CacheType, HashMemoCleanup
from marimo._save.encode import (
attempt_signed_bytes,
common_container_to_bytes,
@@ -315,10 +315,6 @@ class BlockHasher:
# Default type, means that there are no references at all.
cache_type: CacheType = "Pure"
- # TODO: Consider memoizing the serialized contents and hashed cells,
- # such that a parent cell's BlockHasher can be used to speed up the
- # hashing of child.
-
# Collect references that will be utilized for a content hash.
content_serialization: dict[Name, bytes] = {}
if refs:
@@ -442,6 +438,20 @@ class BlockHasher:
cache_type=self.cache_type,
)
+ def _is_memoizable(
+ self,
+ local_ref: Name,
+ value: Any,
+ ctx: RuntimeContext,
+ ) -> bool:
+ """Check if a variable's content hash can be memoized."""
+ return (
+ ctx.cache.is_memoizable(value)
+ and local_ref not in self.stateful_refs
+ and self.cell_id
+ not in self.graph.definitions.get(local_ref, set())
+ )
+
def _apply_content_hash(
self, content_serialization: dict[Name, bytes]
) -> None:
@@ -459,7 +469,7 @@ class BlockHasher:
) -> SerialRefs:
self._hash = None
refs, content_serialization, _ = (
- self.serialize_and_dequeue_content_refs(refs, scope)
+ self.serialize_and_dequeue_content_refs(refs, scope, ctx)
)
# If scoped refs are present, then they are unhashable
# and we should fallback to normal hash or fail.
@@ -483,7 +493,7 @@ class BlockHasher:
closure -= set(content_serialization.keys()) | self.execution_refs
unhashable_closure, relevant_serialization, _ = (
self.serialize_and_dequeue_content_refs(
- closure - unhashable, scope
+ closure - unhashable, scope, ctx
)
)
unhashable |= unhashable_closure
@@ -647,7 +657,10 @@ class BlockHasher:
return SerialRefs(refs, {}, stateful_refs)
def serialize_and_dequeue_content_refs(
- self, refs: set[Name], scope: dict[Name, Any]
+ self,
+ refs: set[Name],
+ scope: dict[Name, Any],
+ ctx: Optional[RuntimeContext] = None,
) -> SerialRefs:
"""Use hashable references to update the hash object and dequeue them.
@@ -666,6 +679,7 @@ class BlockHasher:
Args:
refs: A set of reference names unaccounted for.
scope: A dictionary representing the current scope.
+ ctx: Optional runtime context for memoization.
Returns a filtered list of remaining references that were not utilized
in updating the hash, and a dictionary of the content serialization.
@@ -674,6 +688,7 @@ class BlockHasher:
content_serialization = {}
refs = set(refs)
+ defining_cells: set[CellId_t] = set()
# Content addressed hash is valid if every reference is accounted for
# and can be shown to be a primitive value.
imports = get_imports(scope)
@@ -705,6 +720,16 @@ class BlockHasher:
continue
value = scope[local_ref]
+ # Check memo before expensive serialization
+ if (
+ ctx is not None
+ and self._is_memoizable(local_ref, value, ctx)
+ and local_ref in ctx.cache.hash_memo
+ ):
+ content_serialization[ref] = ctx.cache.hash_memo[local_ref]
+ refs.remove(local_ref)
+ continue
+
serial_value = None
if is_primitive(value):
serial_value = primitive_to_bytes(value)
@@ -734,9 +759,31 @@ class BlockHasher:
continue
if serial_value is not None:
- content_serialization[ref] = serial_value
+ _hash = hashlib.new(self.hash_alg.name, usedforsecurity=False)
+ _hash.update(serial_value)
+ hash_digest = _hash.digest()
+ content_serialization[ref] = hash_digest
+ if ctx is not None and self._is_memoizable(
+ local_ref, value, ctx
+ ):
+ # Local ref as a key is sufficient, because values defined in
+ # cell are not memoizable and rebinds will clean up the
+ # cache via cell life cycle.
+ ctx.cache.hash_memo[local_ref] = hash_digest
+ defining_cells |= self.graph.definitions.get(
+ local_ref, set()
+ )
# Fall through means that the references should be dequeued.
refs.remove(local_ref)
+
+ # Register lifecycle cleanup — deduped, at most one per cell
+ if ctx:
+ for def_cell in defining_cells:
+ ctx.cell_lifecycle_registry.inject(
+ def_cell,
+ HashMemoCleanup(),
+ )
+
return SerialRefs(refs, content_serialization, set())
def serialize_and_dequeue_stateful_content_refs(
@@ -780,6 +827,8 @@ class BlockHasher:
refs, scope, ctx
)
# Attempt content hash again on the extracted stateful refs.
+ # Do not pass ctx — stateful values can change between cells,
+ # so memoization is unsafe here.
refs, content_serialization, _ = (
self.serialize_and_dequeue_content_refs(refs, scope)
)
diff --git a/marimo/_save/loaders/loader.py b/marimo/_save/loaders/loader.py
index 7bba456b63..14aec5a471 100644
--- a/marimo/_save/loaders/loader.py
+++ b/marimo/_save/loaders/loader.py
@@ -208,7 +208,7 @@ class BasePersistenceLoader(Loader):
self.store = store
else:
try:
- self.store = get_context().cache_store
+ self.store = get_context().cache.store
except ContextNotInitializedError:
self.store = DEFAULT_STORE()
diff --git a/pyproject.toml b/pyproject.toml
index 7cecdb542e..d90dc62f5c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -482,7 +482,7 @@ markers = [
omit = ["marimo/_tutorials/*"]
[tool.typos.default]
-extend-ignore-re = ["[0-9a-zA-Z]{43}"]
+extend-ignore-re = ["[0-9a-zA-Z_-]{43}"]
[tool.typos.default.extend-words]
wheres = "wheres"
diff --git a/tests/_save/cache-dumps/json-dump-v4/E_le-zRML4XfcOLHYcruA5WYVltqeZ2yDH7yOv8sUkIYA.json b/tests/_save/cache-dumps/json-dump-v4/E_le-zRML4XfcOLHYcruA5WYVltqeZ2yDH7yOv8sUkIYA.json
new file mode 100644
index 0000000000..438772b932
--- /dev/null
+++ b/tests/_save/cache-dumps/json-dump-v4/E_le-zRML4XfcOLHYcruA5WYVltqeZ2yDH7yOv8sUkIYA.json
@@ -0,0 +1,13 @@
+{
+ "defs": {
+ "value": 3
+ },
+ "hash": "le-zRML4XfcOLHYcruA5WYVltqeZ2yDH7yOv8sUkIYA",
+ "cache_type": "ExecutionPath",
+ "stateful_refs": [],
+ "hit": false,
+ "meta": {
+ "runtime": 7.390975952148438e-05,
+ "version": 4
+ }
+}
\ No newline at end of file
diff --git a/tests/_save/cache-dumps/pickle-dump-v4/E_le-zRML4XfcOLHYcruA5WYVltqeZ2yDH7yOv8sUkIYA.pickle b/tests/_save/cache-dumps/pickle-dump-v4/E_le-zRML4XfcOLHYcruA5WYVltqeZ2yDH7yOv8sUkIYA.pickle
new file mode 100644
index 0000000000..26cea3dc9a
Binary files /dev/null and b/tests/_save/cache-dumps/pickle-dump-v4/E_le-zRML4XfcOLHYcruA5WYVltqeZ2yDH7yOv8sUkIYA.pickle differ
diff --git a/tests/_save/test_cache_versions.py b/tests/_save/test_cache_versions.py
index 73aa7d6873..24db9a425d 100644
--- a/tests/_save/test_cache_versions.py
+++ b/tests/_save/test_cache_versions.py
@@ -9,7 +9,7 @@ class TestVersionCache:
@pytest.mark.skipif(
"sys.version_info < (3, 12) or sys.version_info >= (3, 13)"
)
- def test_load_v3_pickle(app) -> None:
+ def test_load_v4_pickle(app) -> None:
@app.cell
def _():
unhashable = [object()]
@@ -21,7 +21,7 @@ class TestVersionCache:
ref = 1
with persistent_cache(
- name="pickle-dump-v3", save_path="tests/_save/cache-dumps"
+ name="pickle-dump-v4", save_path="tests/_save/cache-dumps"
) as cache:
value = 1 + len(unhashable) + ref
assert cache.hit
@@ -31,7 +31,7 @@ class TestVersionCache:
@pytest.mark.skipif(
"sys.version_info < (3, 12) or sys.version_info >= (3, 13)"
)
- def test_load_v3_json(app) -> None:
+ def test_load_v4_json(app) -> None:
@app.cell
def _():
unhashable = [object()]
@@ -43,7 +43,7 @@ class TestVersionCache:
ref = 1
with persistent_cache(
- name="json-dump-v3",
+ name="json-dump-v4",
save_path="tests/_save/cache-dumps",
method="json",
) as cache:
diff --git a/tests/_save/test_hash.py b/tests/_save/test_hash.py
index c77bfcd1ba..533b7eca2f 100644
--- a/tests/_save/test_hash.py
+++ b/tests/_save/test_hash.py
@@ -52,7 +52,7 @@ class TestHash:
from marimo._save.save import persistent_cache
from tests._save.loaders.mocks import MockLoader
- expected_hash = "haIqC9yzlTaNo-ClmY11Kvtiv08oQPz3-SlnOLfhJYM"
+ expected_hash = "RSccsMCC0dBqvdcnBN1mdxlvKUr4zzR_qupKBW_P_qE"
return expected_hash, persistent_cache, MockLoader
@@ -538,6 +538,208 @@ class TestHash:
assert direct() == module(), "direct() != module()"
+class TestHashMemo:
+ @staticmethod
+ @pytest.mark.skipif(
+ not DependencyManager.numpy.has(),
+ reason="optional dependencies not installed",
+ )
+ def test_data_primitive_memoized_across_cells(app) -> None:
+ """Data primitives should be memoized — same array used in two cells
+ should only be serialized once."""
+
+ @app.cell
+ def load() -> tuple[Any]:
+ import numpy as np
+
+ from marimo._save.save import persistent_cache
+ from tests._save.loaders.mocks import MockLoader
+
+ arr = np.ones((64, 64))
+ return MockLoader, persistent_cache, arr, np
+
+ @app.cell
+ def one(MockLoader, persistent_cache, arr, np) -> tuple[Any]:
+ from marimo._runtime.context.types import get_context
+
+ ctx = get_context()
+ with persistent_cache(name="one", _loader=MockLoader()) as c1:
+ _v = np.sum(arr)
+ # After hashing, arr should be memoized
+ assert len(ctx.cache.hash_memo) > 0
+ return c1, ctx
+
+ @app.cell
+ def two(MockLoader, persistent_cache, arr, np, c1, ctx) -> None:
+ memo_before = dict(ctx.cache.hash_memo)
+ with persistent_cache(name="two", _loader=MockLoader()) as c2:
+ _v = np.sum(arr)
+ # Same arr, so memo should have been used (same entry)
+ assert c1._cache.hash == c2._cache.hash
+ assert memo_before == dict(ctx.cache.hash_memo)
+
+ @staticmethod
+ @pytest.mark.skipif(
+ not DependencyManager.numpy.has(),
+ reason="optional dependencies not installed",
+ )
+ def test_same_cell_def_not_memoized(app) -> None:
+ """Variables defined by the current cell should not use memo
+ (values can mutate within a cell)."""
+
+ @app.cell
+ def one() -> tuple[Any]:
+ import numpy as np
+
+ from marimo._runtime.context.types import get_context
+ from marimo._save.save import persistent_cache
+ from tests._save.loaders.mocks import MockLoader
+
+ arr = np.ones((4, 4))
+ with persistent_cache(name="one", _loader=MockLoader()) as c:
+ _v = np.sum(arr)
+ ctx = get_context()
+ # arr is defined in this cell, so should NOT be memoized
+ assert len(ctx.cache.hash_memo) == 0
+ return c, ctx
+
+ @staticmethod
+ def test_list_mutation_not_stale(app) -> None:
+ """Lists are not memoized, so in-place mutation produces different
+ hashes."""
+
+ @app.cell
+ def one() -> tuple[Any]:
+ from marimo._save.save import persistent_cache
+ from tests._save.loaders.mocks import MockLoader
+
+ data = [1, 2, 3]
+ with persistent_cache(name="one", _loader=MockLoader()) as c1:
+ _v = sum(data)
+ data.append(4)
+ with persistent_cache(name="two", _loader=MockLoader()) as c2:
+ _v = sum(data)
+ assert c1._cache.hash != c2._cache.hash
+
+ @staticmethod
+ def test_dict_mutation_not_stale(app) -> None:
+ """Dicts are not memoized, so mutation produces different hashes."""
+
+ @app.cell
+ def one() -> tuple[Any]:
+ from marimo._save.save import persistent_cache
+ from tests._save.loaders.mocks import MockLoader
+
+ data = {"a": 1}
+ with persistent_cache(name="one", _loader=MockLoader()) as c1:
+ _v = sum(data.values())
+ data["b"] = 2
+ with persistent_cache(name="two", _loader=MockLoader()) as c2:
+ _v = sum(data.values())
+ assert c1._cache.hash != c2._cache.hash
+
+ @staticmethod
+ @pytest.mark.skipif(
+ not DependencyManager.numpy.has(),
+ reason="optional dependencies not installed",
+ )
+ def test_memo_with_cached_function(app) -> None:
+ """Memoization works with @mo.cache deferred hashing."""
+
+ @app.cell
+ def load() -> tuple[Any]:
+ import numpy as np
+
+ import marimo as mo
+
+ arr = np.ones((32, 32))
+ return mo, np, arr
+
+ @app.cell
+ def one(mo, np, arr) -> tuple[Any]:
+ @mo.cache
+ def compute(x):
+ return np.sum(x)
+
+ r1 = compute(arr)
+ r2 = compute(arr)
+ assert r1 == r2
+ assert compute.hits == 1
+ return (compute,)
+
+ @staticmethod
+ @pytest.mark.skipif(
+ not DependencyManager.numpy.has(),
+ reason="optional dependencies not installed",
+ )
+ def test_lifecycle_cleanup(app) -> None:
+ """HashMemoCleanup clears memo when defining cell is disposed."""
+
+ @app.cell
+ def load() -> tuple[Any]:
+ import numpy as np
+
+ from marimo._runtime.context.types import get_context
+ from marimo._save.cache import HashMemoCleanup
+ from marimo._save.save import persistent_cache
+ from tests._save.loaders.mocks import MockLoader
+
+ arr = np.ones((4, 4))
+ return (
+ MockLoader,
+ persistent_cache,
+ arr,
+ np,
+ get_context,
+ HashMemoCleanup,
+ )
+
+ @app.cell
+ def one(
+ MockLoader, persistent_cache, arr, np, get_context, HashMemoCleanup
+ ) -> tuple[Any]:
+ with persistent_cache(name="one", _loader=MockLoader()) as c:
+ _v = np.sum(arr)
+ ctx = get_context()
+ assert len(ctx.cache.hash_memo) > 0
+ # Simulate lifecycle disposal — should clear memo
+ cleanup = HashMemoCleanup()
+ cleanup.dispose(ctx, deletion=False)
+ assert len(ctx.cache.hash_memo) == 0
+
+ @staticmethod
+ @pytest.mark.skipif(
+ not DependencyManager.numpy.has(),
+ reason="optional dependencies not installed",
+ )
+ def test_globals_mutation_stale_memo(app) -> None:
+ """Known limitation: mutating a data primitive via globals() bypasses
+ lifecycle cleanup, producing a stale memo hit. This is expected (but
+ highly discouraged) since globals() sidesteps marimo's reactivity — but
+ we capture the behavior so it doesn't silently change."""
+
+ @app.cell
+ def load() -> tuple[Any]:
+ import numpy as np
+
+ from marimo._save.save import persistent_cache
+ from tests._save.loaders.mocks import MockLoader
+
+ arr = np.ones((4, 4))
+ return MockLoader, persistent_cache, arr, np
+
+ @app.cell
+ def one(MockLoader, persistent_cache, arr, np) -> tuple[Any]:
+ with persistent_cache(name="one", _loader=MockLoader()) as c1:
+ _v = np.sum(arr)
+ # Mutate via globals — no lifecycle disposal triggered
+ globals()["arr"] = np.zeros((4, 4))
+ with persistent_cache(name="two", _loader=MockLoader()) as c2:
+ _v = np.sum(arr)
+ # Stale memo: hashes match even though arr changed
+ assert c1._cache.hash == c2._cache.hash
+
+
class TestDataHash:
@staticmethod
@pytest.mark.skipif(
@@ -557,7 +759,7 @@ class TestDataHash:
from marimo._save.save import persistent_cache
from tests._save.loaders.mocks import MockLoader
- expected_hash = "w_Bjhpz2xMVQC6Y61GgqB8O80u_UyoJ-1xQmJU3j0Gg"
+ expected_hash = "zLpFb6ANG99kP-4yWoH4zdV_FfrUodnEom1tILpF55c"
return MockLoader, persistent_cache, expected_hash, np
@app.cell
@@ -610,7 +812,7 @@ class TestDataHash:
from marimo._save.save import persistent_cache
from tests._save.loaders.mocks import MockLoader
- expected_hash = "aAL9QNoQIQ1zOJgm_xDbHG63Bc4Atnpn58pGW9x9A_A"
+ expected_hash = "IaLyzmZZ4nwXMveSQjMVAa682QAyd2O90iSeHJvlb44"
return MockLoader, persistent_cache, expected_hash, np
@app.cell
@@ -663,7 +865,7 @@ class TestDataHash:
from marimo._save.save import persistent_cache
from tests._save.loaders.mocks import MockLoader
- expected_hash = "stIOtiKIn4yscvKd-uK6mbmZpWzzfGm8Ccz7mvnRrnI"
+ expected_hash = "6EJfKOu_iB6jpSTtCnUV1kjYy2u96m_w_3VzOUOn5Hg"
return MockLoader, persistent_cache, expected_hash, torch
@app.cell
@@ -723,7 +925,7 @@ class TestDataHash:
from marimo._save.save import persistent_cache
from tests._save.loaders.mocks import MockLoader
- expected_hash = "rTAh8yNbBbq9qkF1nGNUw4DXhZSxRqGe4ptbDh2AwBI"
+ expected_hash = "QIjIEzceYIH7WIvdIasBLceU3Ad40kYqTCSBnUmJZV4"
return MockLoader, persistent_cache, expected_hash, torch
@app.cell
@@ -763,7 +965,7 @@ class TestDataHash:
from marimo._save.save import persistent_cache
from tests._save.loaders.mocks import MockLoader
- expected_hash = "ggxwHLzWcyDQltN_Zq0_zYVP_w86a9AAQLQwleAMuH8"
+ expected_hash = "1eEgTTthH-FyKbziqYse1ITogQUMat0JW1meFZtMWCI"
return MockLoader, persistent_cache, expected_hash, DNA, copy
@app.cell
@@ -801,7 +1003,7 @@ class TestDataHash:
from marimo._save.save import persistent_cache
from tests._save.loaders.mocks import MockLoader
- expected_hash = "wtrS6NoH2AOH3DnWm7wooK4Bgw8TmMotgMbiY0bu5as"
+ expected_hash = "ycCqtVaQAODpfHyimtlbxj1TIQB3WtLnhDIGq59yiqw"
return MockLoader, persistent_cache, expected_hash, np, pd
@app.cell
@@ -865,7 +1067,7 @@ class TestDataHash:
from marimo._save.save import persistent_cache
from tests._save.loaders.mocks import MockLoader
- expected_hash = "n4KGJ3wrRHd6pDCyekTWZXShmtT_ZkDY4Wo3C6BXzh4"
+ expected_hash = "C9MbH1ov4US2mrm_T_clm4VpI9WT97tg5BGEpOAbF1g"
return MockLoader, persistent_cache, expected_hash, np, pd
@app.cell
@@ -906,7 +1108,7 @@ class TestDataHash:
from marimo._save.save import persistent_cache
from tests._save.loaders.mocks import MockLoader
- expected_hash = "rC6YiNsuaZKQ1JqMgSRa0iyEDwi7ZTl6InABjuM0RDY"
+ expected_hash = "DtWHQ972QmRo2kBlzgoGQDi-bRnRknWZsSFk_rT4lRA"
return MockLoader, persistent_cache, expected_hash, pl
@app.cell
@@ -963,7 +1165,7 @@ class TestDataHash:
from marimo._save.save import persistent_cache
from tests._save.loaders.mocks import MockLoader
- expected_hash = "jMEurCFLl9VI2sSaQOdCShS1MnudIRZNu84578qM3Jc"
+ expected_hash = "1HlOXWU-oQ5MNB5B9YRNLnHcn3I8sngJvLuHV_ICLGY"
return MockLoader, persistent_cache, expected_hash, pl
@app.cell