Method serialize_and_dequeue_content_refs

marimo/_save/hash.py:663–793

Use hashable references to update the hash object and dequeue them. NB. "Hashable" types are primitives, data primitives, and pure functions. With modules being "hashed" by version number, or ignored. The current "hashables" are: - module (with pin by version)

(
        self,
        refs: set[Name],
        scope: dict[Name, Any],
        ctx: RuntimeContext | None = None,
    )

        return SerialRefs(refs, {}, stateful_refs)

    def serialize_and_dequeue_content_refs(
        self,
        refs: set[Name],
        scope: dict[Name, Any],
        ctx: RuntimeContext | None = None,
    ) -> SerialRefs:
        """Use hashable references to update the hash object and dequeue them.

        NB. "Hashable" types are primitives, data primitives, and pure
        functions. With modules being "hashed" by version number, or ignored.

        The current "hashables" are:
         - module (with pin by version)
         - primitive (bytes, str, numbers.Number, type(None))
         - data primitive (e.g. numpy array, torch tensor)
         - external module definitions (imported anything)
         - pure functions (no state, no external dependencies)
         - pure containers of the above (list, dict, set, tuple)
         - custom types defined in CUSTOM_STUBS

        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.
        """
        self._hash = None

        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)
        for local_ref in sorted(refs):
            ref = if_local_then_mangle(local_ref, self.cell_id)
            if ref in imports:
                # TODO: There may be a way to tie this in with module watching.
                # e.g. module watcher could mutate the version number based
                # last updated timestamp.
                version = ""
                module = None
                if self.pin_modules:
                    # `.get`: a cached module def restored as a missing-
                    # module placeholder is in scope but not sys.modules.
                    module = sys.modules.get(imports[ref].module)
                    version = getattr(module, "__version__", "") or ""
                    if not version:
                        module = sys.modules.get(imports[ref].namespace)
                        version = getattr(module, "__version__", "") or ""

                content_serialization[ref] = type_sign(
                    bytes(f"module:{ref}:{version}", "utf-8"), "module"
                )
                # No need to watch the module otherwise. If the block depends
                # on it then it should be caught when hashing the block.