Class Cache

marimo/_save/cache.py:149–553

@dataclass
class Cache:
    defs: dict[Name, Any]
    hash: str
    cache_type: CacheType
    stateful_refs: set[str]
    hit: bool
    # meta corresponds to internally used data, kept as a dictionary to allow
    # for backwards pickle compatibility with future entries.
    # TODO: Utilize to store code and output in cache.
    # TODO: Consider storing graph information such that execution history can
    # be explored and visualized.
    meta: dict[MetaKey, Any]

    def restore(self, scope: dict[str, Any]) -> None:
        """Restores values from cache, into scope."""
        memo: dict[int, Any] = {}  # Track processed objects to handle cycles
        for var, lookup in self._restore_order(self.contextual_defs()):
            value = self.defs.get(var, None)
            scope[lookup] = self._restore_from_stub_if_needed(
                value, scope, memo
            )

        for key, value in self.meta.items():
            self.meta[key] = self._restore_from_stub_if_needed(
                value, scope, memo
            )

        defs = {**globals(), **scope}
        for ref in self.stateful_refs:
            if ref not in defs:
                raise CacheException(
                    "Failure while restoring cached values. "
                    "Cache expected a reference to a "
                    f"variable that is not present ({ref})."
                )
            value = defs[ref]
            if isinstance(value, SetFunctor):
                value(self.defs[ref])
            # UI Values cannot be easily programmatically set, so only update
            # state values.
            elif not isinstance(value, UIElement):
                raise CacheException(
                    "Failure while restoring cached values. "
                    "Unexpected stateful reference type "
                    f"({type(ref)}:{ref})."
                )

    def _restore_deps(self, value: Any) -> set[Name]:
        """Cross-def names *value* needs before it can be restored.

        - A re-exec'd class/function needs the defs it references at
          definition time (bases, decorators, class-body calls).
        - A pickled instance of a cell-defined class needs that class
          materialized first (tagged via `requires`).
        """
        if isinstance(value, (ClassStub, FunctionStub)):
            return _source_refs(value.code)
        requires = getattr(value, "requires", "")