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.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
fix + chore: cache version bump (#8793)
Dylan Madisettib5747c66d0ba
diff --git a/marimo/_runtime/context/kernel_context.py b/marimo/_runtime/context/kernel_context.pyindex 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 CacheStatefrom 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_registrydiff --git a/marimo/_runtime/context/script_context.py b/marimo/_runtime/context/script_context.pyindex 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 CacheStatefrom marimo._save.stores import get_storeruntime_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.pyindex 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, QueryParamsfrom marimo._runtime.state import State, StateRegistryfrom marimo._runtime.virtual_file import VirtualFileRegistry- from marimo._save.stores import Store+ from marimo._save.cache import CacheStatefrom marimo._types.ids import CellId_t@@ -90,7 +90,7 @@ class RuntimeContext(abc.ABC):virtual_file_registry: VirtualFileRegistryvirtual_files_supported: boolapp_kernel_runner_registry: AppKernelRunnerRegistry- cache_store: Store+ cache: CacheState# stream, stdout, stderr are _not_ owned by the contextstream: Streamstdout: Stdout | Nonediff --git a/marimo/_save/cache.py b/marimo/_save/cache.pyindex 6a84211a7b..f61bce8e25 100644--- a/marimo/_save/cache.py+++ b/marimo/_save/cache.py@@ -5,10 +5,11 @@ import abcimport inspectimport refrom collections import namedtuple-from dataclasses import dataclass+from dataclasses import dataclass, fieldfrom typing import TYPE_CHECKING, Any, Literal, Optional, get_argsfrom marimo._plugins.ui._core.ui_element import UIElement+from marimo._runtime.cell_lifecycle_item import CellLifecycleItemfrom marimo._runtime.context import ContextNotInitializedError, get_contextfrom marimo._runtime.state import SetFunctorfrom 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 RuntimeContextfrom marimo._runtime.state import Statefrom marimo._save.hash import HashKeyfrom 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 = 4CacheType = 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 functoolsdiff --git a/marimo/_save/encode.py b/marimo/_save/encode.pyindex 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.pyindex 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, SideEffectfrom marimo._runtime.state import SetFunctor, Statefrom marimo._runtime.watch._path import PathState-from marimo._save.cache import Cache, CacheType+from marimo._save.cache import Cache, CacheType, HashMemoCleanupfrom 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 = Nonerefs, 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_refsunhashable_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 utilizedin 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:continuevalue = 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 = Noneif is_primitive(value):serial_value = primitive_to_bytes(value)@@ -734,9 +759,31 @@ class BlockHasher:continueif 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.pyindex 7bba456b63..14aec5a471 100644--- a/marimo/_save/loaders/loader.py+++ b/marimo/_save/loaders/loader.py@@ -208,7 +208,7 @@ class BasePersistenceLoader(Loader):self.store = storeelse:try:- self.store = get_context().cache_store+ self.store = get_context().cache.storeexcept ContextNotInitializedError:self.store = DEFAULT_STORE()diff --git a/pyproject.toml b/pyproject.tomlindex 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.jsonnew file mode 100644index 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 filediff --git a/tests/_save/cache-dumps/pickle-dump-v4/E_le-zRML4XfcOLHYcruA5WYVltqeZ2yDH7yOv8sUkIYA.pickle b/tests/_save/cache-dumps/pickle-dump-v4/E_le-zRML4XfcOLHYcruA5WYVltqeZ2yDH7yOv8sUkIYA.picklenew file mode 100644index 0000000000..26cea3dc9aBinary files /dev/null and b/tests/_save/cache-dumps/pickle-dump-v4/E_le-zRML4XfcOLHYcruA5WYVltqeZ2yDH7yOv8sUkIYA.pickle differdiff --git a/tests/_save/test_cache_versions.py b/tests/_save/test_cache_versions.pyindex 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.celldef _():unhashable = [object()]@@ -21,7 +21,7 @@ class TestVersionCache:ref = 1with 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) + refassert 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.celldef _():unhashable = [object()]@@ -43,7 +43,7 @@ class TestVersionCache:ref = 1with 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.pyindex 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_cachefrom 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_cachefrom 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_cachefrom 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_cachefrom 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_cachefrom 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_cachefrom 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_cachefrom 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_cachefrom 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_cachefrom 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_cachefrom tests._save.loaders.mocks import MockLoader- expected_hash = "jMEurCFLl9VI2sSaQOdCShS1MnudIRZNu84578qM3Jc"+ expected_hash = "1HlOXWU-oQ5MNB5B9YRNLnHcn3I8sngJvLuHV_ICLGY"return MockLoader, persistent_cache, expected_hash, pl@app.cell