objectstate 1.3.1__tar.gz → 2.0.0__tar.gz

{objectstate-1.3.1 → objectstate-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: objectstate
-Version: 1.3.1
+Version: 2.0.0
 Summary: Generic lazy dataclass configuration framework with dual-axis inheritance and contextvars-based resolution
 Project-URL: Homepage, https://github.com/OpenHCSDev/objectstate
 Project-URL: Documentation, https://objectstate.readthedocs.io

{objectstate-1.3.1 → objectstate-2.0.0}/scripts/verify_release_ready.py

@@ -211,13 +211,8 @@ def check_github_workflow():
         print("  ❌ .github/workflows/publish.yml not found")
         return False
     
-    content = workflow_file.read_text()
-    if 'PYPI_API_TOKEN' not in content:
-        print("  ❌ PYPI_API_TOKEN not referenced in workflow")
-        return False
-    
-    print("  ✅ GitHub Actions workflow configured")
-    print("     Remember to set PYPI_API_TOKEN secret in GitHub!")
+    print("  ✅ Publication workflow present")
+    print("     Authentication is checked by the workflow's publisher, not artifact readiness.")
     return True
 
 
@@ -261,7 +256,7 @@ def main():
     if passed == total:
         print("\n🎉 All checks passed! Ready for release!")
         print("\nNext steps:")
-        print("  1. Set PYPI_API_TOKEN in GitHub secrets")
+        print("  1. Verify the publication workflow's PyPI authorization")
         print("  2. Run: python scripts/update_and_release.py")
         return 0
     else:

{objectstate-1.3.1 → objectstate-2.0.0}/src/objectstate/__init__.py

@@ -73,6 +73,7 @@ from objectstate.lazy_factory import (
     is_global_config_instance,
     # Raw-value-preserving utilities
     replace_raw,
+    retain_only_authored_paths,
 )
 
 # Resolver
@@ -100,9 +101,6 @@ from objectstate.context_manager import (
     register_hierarchy_relationship,
     unregister_hierarchy_relationship,
     get_ancestors_from_hierarchy,
-    # Scope key utilities
-    get_root_from_scope_key,
-    is_scope_affected,
     # Context stack building (framework-agnostic)
     build_context_stack,
     # Threading utility for context propagation
@@ -181,8 +179,6 @@ __all__ = [
     'extract_all_configs',
     'get_base_global_config',
     'get_context_type_stack',
-    'get_root_from_scope_key',
-    'is_scope_affected',
     'build_context_stack',
     'spawn_thread_with_context',
     # Placeholder
@@ -216,13 +212,14 @@ __all__ = [
     'ObjectStateEditSession',
 ]
 
-__version__ = "1.3.1"
+__version__ = "2.0.0"
 __author__ = 'OpenHCS Team'
 __description__ = 'Generic configuration framework for lazy dataclass resolution'
 
 
 # Object state management
 from objectstate.object_state_registry import ObjectStateRegistry
+from objectstate.scope_key import ScopeKey
 from objectstate.object_state import ObjectState
 from objectstate.object_state_metadata import (
     ObjectStateMetadataContract,
@@ -259,6 +256,8 @@ __all__ += [
     # Object state
     'ObjectState',
     'ObjectStateRegistry',
+    'ScopeKey',
+    'retain_only_authored_paths',
     'ObjectStateMetadataContract',
     'ObjectStateMetadataContractRegistry',
     'ObjectStateMetadataStore',

{objectstate-1.3.1 → objectstate-2.0.0}/src/objectstate/context_manager.py

@@ -329,56 +329,6 @@ def _is_global_type(t):
 _known_hierarchy: dict = {}
 
 
-def get_root_from_scope_key(scope_key: str) -> str:
-    """Extract root (plate path) from scope_key for visibility checks.
-
-    scope_key format:
-    - Pipeline-level: just plate path (e.g., "/path/to/plate")
-    - Step-level: plate_path::step_token (e.g., "/path/to/plate::step_a")
-    - Global: empty string
-
-    Returns the portion before "::" (or the whole string if no "::" present).
-    """
-    if not scope_key:
-        return ""
-    return scope_key.split("::")[0]
-
-
-def is_scope_affected(target_scope_id: str | None, editing_scope_id: str | None) -> bool:
-    """Check if target scope is affected by edit at editing scope.
-
-    Uses scope_id hierarchy - no type introspection needed:
-    - None/"" (global) → affects all
-    - "plate_path" (pipeline) → affects same plate + all its steps
-    - "plate_path::token" (step) → affects only that step
-
-    Args:
-        target_scope_id: The scope being checked for affectedness (None = global)
-        editing_scope_id: The scope where the edit occurred (None = global)
-
-    Returns:
-        True if target should refresh when editing_scope changes
-    """
-    # Normalize None to empty string
-    target = target_scope_id or ""
-    editing = editing_scope_id or ""
-
-    # Global edit affects all
-    if not editing:
-        return True
-
-    # Different plate roots = not affected
-    target_root = get_root_from_scope_key(target)
-    editing_root = get_root_from_scope_key(editing)
-    if target_root != editing_root:
-        return False
-
-    # Same root: parent affects children, not vice versa
-    # editing="plate" affects target="plate::step" ✓
-    # editing="plate::step" affects target="plate" ✗
-    return target == editing or target.startswith(editing + "::")
-
-
 def _normalize_type_for_hierarchy(t):
     """Normalize a type for hierarchy registry, but preserve lazy-global distinction.
 

objectstate-2.0.0/src/objectstate/inspection.py

@@ -0,0 +1,162 @@
+"""Read-only inspection of registered ObjectStates and their fields."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from objectstate.object_state import ObjectState
+from objectstate.object_state_registry import ObjectStateRegistry
+
+logger = logging.getLogger(__name__)
+
+DIRTY_MARKER = "*"
+"""Marks a field (or a group of fields) whose value differs from the saved value."""
+
+SIGNATURE_DIFF_MARKER = "_"
+"""Marks a field whose raw value differs from its declared signature default."""
+
+
+def field_markers(*, dirty: bool, signature_diff: bool) -> tuple[str, ...]:
+    """The markers views prefix to a field, or to a group of fields, in this order."""
+
+    return tuple(
+        marker
+        for marker, present in ((DIRTY_MARKER, dirty), (SIGNATURE_DIFF_MARKER, signature_diff))
+        if present
+    )
+
+
+def state_markers(state: ObjectState) -> tuple[str, ...]:
+    """The markers of a whole ObjectState: any dirty field, any signature difference."""
+
+    return field_markers(
+        dirty=bool(state.dirty_fields),
+        signature_diff=bool(state.signature_diff_fields),
+    )
+
+
+def type_name(value: object) -> str:
+    return "None" if value is None else type(value).__name__
+
+
+def type_qualname(value_type: type | Callable[..., object]) -> str:
+    return f"{value_type.__module__}.{value_type.__qualname__}"
+
+
+@dataclass(frozen=True, slots=True)
+class FieldProvenance:
+    """The ancestor scope and declaring type a field's inherited value comes from."""
+
+    source_scope_id: str | None
+    source_type: type
+    field_name: str
+
+    @property
+    def source_field_path(self) -> str | None:
+        """The field's path in the source scope's own state, if that scope is registered."""
+
+        source_state = ObjectStateRegistry.get_by_scope(self.source_scope_id)
+        if source_state is None:
+            return None
+        return source_state.project_ui_visible_field_path(self.source_type, self.field_name)
+
+
+@dataclass(frozen=True, slots=True)
+class FieldInspection:
+    """One field of one ObjectState: raw and resolved value, edit state and provenance."""
+
+    state: ObjectState
+    field_path: str
+    raw_value: object
+    resolved_value: object
+    resolved_value_available: bool
+    provenance: FieldProvenance | None
+
+    @classmethod
+    def of(cls, state: ObjectState, field_path: str):
+        """Inspect ``field_path``; a value that fails to resolve is reported unavailable."""
+
+        resolved_value = None
+        resolved_value_available = False
+        try:
+            resolved_value = state.get_resolved_value(field_path)
+            resolved_value_available = True
+        except Exception:
+            logger.debug(
+                "Failed to resolve ObjectState field %s on scope %r.",
+                field_path,
+                state.scope_id,
+                exc_info=True,
+            )
+        provenance = None
+        match state.get_provenance(field_path):
+            case (source_scope_id, source_type) if source_type is not None:
+                provenance = FieldProvenance(
+                    source_scope_id=source_scope_id,
+                    source_type=source_type,
+                    field_name=field_path.rsplit(".", 1)[-1],
+                )
+        return cls(
+            state=state,
+            field_path=field_path,
+            raw_value=state.parameters[field_path],
+            resolved_value=resolved_value,
+            resolved_value_available=resolved_value_available,
+            provenance=provenance,
+        )
+
+    @property
+    def dirty(self) -> bool:
+        return self.field_path in self.state.dirty_fields
+
+    @property
+    def signature_diff(self) -> bool:
+        return self.field_path in self.state.signature_diff_fields
+
+    @property
+    def last_changed(self) -> bool:
+        return self.field_path == self.state.last_changed_field
+
+    @property
+    def raw_value_is_none(self) -> bool:
+        return self.raw_value is None
+
+    @property
+    def resolved_value_is_none(self) -> bool:
+        return self.resolved_value_available and self.resolved_value is None
+
+    @property
+    def inherited_value(self) -> bool:
+        """The field holds no value of its own and inherits a resolved one."""
+
+        return self.raw_value is None and self.resolved_value_available and (
+            self.resolved_value is not None
+        )
+
+    @property
+    def semantic_markers(self) -> tuple[str, ...]:
+        return field_markers(dirty=self.dirty, signature_diff=self.signature_diff)
+
+    @property
+    def field_name(self) -> str:
+        return self.field_path.rsplit(".", 1)[-1]
+
+    @property
+    def container_path(self) -> str:
+        return self.field_path.rsplit(".", 1)[0] if "." in self.field_path else ""
+
+    @property
+    def raw_value_type(self) -> str:
+        return type_name(self.raw_value)
+
+    @property
+    def resolved_value_type(self) -> str | None:
+        return type_name(self.resolved_value) if self.resolved_value_available else None
+
+    @property
+    def declaring_type(self) -> str:
+        """Qualified name of the dataclass that declares this field."""
+
+        return type_qualname(self.state.type_for_path(self.field_path))

{objectstate-1.3.1 → objectstate-2.0.0}/src/objectstate/lazy_factory.py

@@ -250,6 +250,49 @@ def replace_raw(instance, **changes):
     return type(instance)(**field_values)
 
 
+
+def retain_only_authored_paths(value, authored_field_paths) -> Any:
+    """Copy a lazy dataclass, marking only ``authored_field_paths`` as explicitly set.
+
+    An ObjectState rebuild constructs every nested lazy dataclass from all its
+    flattened fields, so every constructor keyword reads as explicit. Clean
+    source generation needs the authored paths ObjectState already tracks
+    (its signature-diff fields); this applies them to the lazy metadata without
+    changing any field value.
+    """
+
+    from objectstate.field_access import DottedFieldPath
+
+    paths = tuple(DottedFieldPath(path) for path in authored_field_paths)
+    return _copy_with_only_authored_paths(value, DottedFieldPath(""), paths)
+
+
+def _copy_with_only_authored_paths(value, prefix, authored_field_paths):
+    from objectstate.field_access import DataclassFieldAccess
+
+    field_values = {}
+    for field_definition in fields(value):
+        field_value = DataclassFieldAccess.raw_value(value, field_definition.name)
+        if isinstance(field_value, LazyDataclass):
+            field_value = _copy_with_only_authored_paths(
+                field_value,
+                prefix.child(field_definition.name),
+                authored_field_paths,
+            )
+        field_values[field_definition.name] = field_value
+
+    projected = type(value)(**field_values)
+    object.__setattr__(
+        projected,
+        "_explicitly_set_fields",
+        {
+            field_definition.name
+            for field_definition in fields(projected)
+            if prefix.child(field_definition.name).contains_any(authored_field_paths)
+        },
+    )
+    return projected
+
 # ContextEventCoordinator removed - replaced with contextvars-based context system
 
 

{objectstate-1.3.1 → objectstate-2.0.0}/src/objectstate/object_state.py

@@ -30,6 +30,7 @@ from objectstate.object_state_metadata import (
     ObjectStateMetadataStore,
 )
 from objectstate.object_state_registry import ObjectStateRegistry
+from objectstate.scope_key import ScopeKey
 from objectstate.parameter_owner import ParameterOwner
 from objectstate.parameter_structure import ParameterStructure
 from objectstate.global_config import GlobalContextValues
@@ -695,9 +696,9 @@ class ObjectState:
             parent_field = field_path or self._parent_field_name
             if parent_field is None:
                 # Auto-detect from a numeric scope suffix.
-                parts = self.scope_id.split('::')
-                if len(parts) >= 2:
-                    last = parts[-1]
+                scope = ScopeKey(self.scope_id)
+                if scope.depth >= 2:
+                    last = scope.last
                     import re
                     m = re.match(r'^(.+?)_\d+$', last)
                     parent_field = m.group(1) if m else last
@@ -2304,23 +2305,11 @@ class ObjectState:
         logger.debug(f"🔧 mark_saved: Total states in registry: {len(ObjectStateRegistry._states)}")
 
         # Collect descendant scopes first to avoid modifying registry during iteration.
-        #
-        # IMPORTANT: Global scope is represented by "" (empty string).
-        # In that case, *every* non-global scope is a descendant, but the naive
-        # prefix check ("" + "::" == "::") matches nothing.
         changed_scope = ObjectStateRegistry._normalize_scope_id(self.scope_id)
-        if changed_scope == "":
-            # Global baseline change affects ALL other states.
-            descendant_scopes = [
-                s.scope_id for s in ObjectStateRegistry._states.values()
-                if ObjectStateRegistry._normalize_scope_id(s.scope_id) != ""
-            ]
-        else:
-            prefix = changed_scope + "::"
-            descendant_scopes = [
-                s.scope_id for s in ObjectStateRegistry._states.values()
-                if s.scope_id is not None and ObjectStateRegistry._normalize_scope_id(s.scope_id).startswith(prefix)
-            ]
+        descendant_scopes = [
+            s.scope_id for s in ObjectStateRegistry._states.values()
+            if changed_scope.strictly_contains(s.scope_id)
+        ]
         logger.debug(f"🔧 mark_saved: Found {len(descendant_scopes)} descendant scopes: {descendant_scopes}")
 
         for descendant_scope in descendant_scopes:
@@ -2456,11 +2445,14 @@ class ObjectState:
         # However, for delegation-based parents that act as context providers (e.g. orchestrator -> pipeline_config),
         # restoring the parent should generally *not* restore descendant raw parameters (steps). Descendants should
         # only have their resolved caches invalidated so they re-resolve against the restored context.
-        if propagate_descendants:
+        # The global scope only provides context to every other scope; it owns none of
+        # their parameters, so restoring it never restores them.
+        own_scope = ScopeKey(self.scope_id)
+        if propagate_descendants and not own_scope.is_global:
             descendant_scopes = [
                 scope
                 for scope in ObjectStateRegistry._states.keys()
-                if scope.startswith(f"{self.scope_id}::")
+                if own_scope.strictly_contains(scope)
             ]
             for descendant_scope in descendant_scopes:
                 state = ObjectStateRegistry._states.get(descendant_scope)

{objectstate-1.3.1 → objectstate-2.0.0}/src/objectstate/object_state_registry.py

@@ -22,7 +22,7 @@ import copy
 
 from objectstate.object_state_metadata import ObjectStateMetadataStore
 from objectstate.construction_binding import StateConstructionBinding
-from objectstate.history_migration import HistoryMigration
+from objectstate.scope_key import ScopeKey
 from objectstate.global_config import GlobalContextValues
 from objectstate.context_manager import clear_current_temp_global
 from objectstate.dual_axis_resolver import clear_mro_resolution_cache
@@ -348,9 +348,9 @@ class ObjectStateRegistry:
         cls._snapshot_dirty_scopes.add(cls._normalize_scope_id(scope_id))
 
     @classmethod
-    def _normalize_scope_id(cls, scope_id: Optional[str]) -> str:
-        """Normalize scope_id: None and "" both represent global scope."""
-        return scope_id if scope_id is not None else ""
+    def _normalize_scope_id(cls, scope_id: str | None) -> ScopeKey:
+        """Return the registry key: None and "" both represent the global scope."""
+        return ScopeKey(scope_id)
 
     @classmethod
     def register(cls, state: 'ObjectState', _skip_snapshot: bool = False) -> None:
@@ -426,14 +426,11 @@ class ObjectStateRegistry:
         scope_key = cls._normalize_scope_id(scope_id)
 
         # Find all scopes to delete: exact match + descendants
-        scopes_to_delete = []
-        for key in cls._states.keys():
-            # Exact match
-            if key == scope_key:
-                scopes_to_delete.append(key)
-            # Descendant (starts with scope_key::)
-            elif scope_key and key.startswith(scope_key + "::"):
-                scopes_to_delete.append(key)
+        scopes_to_delete = [
+            key
+            for key in cls._states.keys()
+            if key == scope_key or (scope_key and scope_key.contains(key))
+        ]
 
         # Delete all matching scopes and fire callbacks
         # NOTE: Unlike plain unregister(), this is often used for hierarchical deletes.
@@ -506,7 +503,7 @@ class ObjectStateRegistry:
         cls._snapshots.clear()
         cls._timelines.clear()
         cls._current_head = None
-        cls._current_timeline = "main"
+        cls._current_timeline = cls.MAIN_BRANCH
         cls._atomic_depth = 0
         cls._atomic_label = None
         cls._atomic_triggering_scope = None
@@ -640,17 +637,9 @@ class ObjectStateRegistry:
         """
         scope_key = cls._normalize_scope_id(scope_id)
 
-        # Build list of ancestor scope keys (least-specific to most-specific)
-        # e.g., "/plate::step_0" -> ["", "/plate", "/plate::step_0"]
-        ancestors = [""]  # Global scope always included
-        if scope_key:
-            parts = scope_key.split("::")
-            for i in range(len(parts)):
-                ancestors.append("::".join(parts[:i+1]))
-
-        # Get objects from ancestor scopes
+        # Get objects from ancestor scopes, least-specific to most-specific
         objects = []
-        for ancestor_key in ancestors:
+        for ancestor_key in scope_key.ancestors():
             state = cls._states.get(ancestor_key)
             if state:
                 if use_saved:
@@ -693,16 +682,9 @@ class ObjectStateRegistry:
         """
         scope_key = cls._normalize_scope_id(scope_id)
 
-        # Build list of ancestor scope keys (least-specific to most-specific)
-        ancestors = [""]  # Global scope always included
-        if scope_key:
-            parts = scope_key.split("::")
-            for i in range(len(parts)):
-                ancestors.append("::".join(parts[:i+1]))
-
         # Get (scope_id, object) tuples from ancestor scopes
         results: List[Tuple[str, Any]] = []
-        for ancestor_key in ancestors:
+        for ancestor_key in scope_key.ancestors():
             state = cls._states.get(ancestor_key)
             if state:
                 # Get object - either with or without delegate sync
@@ -809,20 +791,8 @@ class ObjectStateRegistry:
                 continue
 
             # SCOPE CHECK: must be at or below changed scope
-            # Global scope (empty string) affects ALL states
-            if changed_scope == "":
-                # Global scope - always a descendant (or self if also global)
-                if field_name == 'well_filter':
-                    logger.debug(f"🔍   Checking state: scope={state_scope!r}, obj_type={type(state.object_instance).__name__}")
-                logger.debug(f"[SCOPE] Global change affects state scope={state_scope!r}")
-            else:
-                # Non-global: check exact match or descendant
-                prefix = changed_scope + "::"
-                is_descendant = state_scope.startswith(prefix)
-                if not (is_self or is_descendant):
-                    logger.debug(f"[SCOPE] SKIP: changed_scope={changed_scope!r} does not affect state_scope={state_scope!r}")
-                    continue
-                logger.debug(f"[SCOPE] MATCH: changed_scope={changed_scope!r} affects state_scope={state_scope!r}")
+            if not changed_scope.contains(state_scope):
+                continue
 
             # TYPE + FIELD CHECK: find matching nested state and invalidate field
             cls._invalidate_field_in_matching_states(state, base_changed_type, field_name, invalidate_saved)
@@ -926,11 +896,12 @@ class ObjectStateRegistry:
     # This allows time travel to snapshots that reference deleted objects.
     _graveyard: Dict[str, 'ObjectState'] = {}
 
-    # Timelines (branches): Named branches that point to a head snapshot
-    # "main" is always created automatically on first snapshot
+    # Timelines (branches): Named branches that point to a head snapshot.
+    # MAIN_BRANCH is created automatically on the first snapshot.
     # head_id always points to a valid key in _snapshots (guaranteed by construction)
+    MAIN_BRANCH = "main"
     _timelines: Dict[str, Timeline] = {}
-    _current_timeline: str = "main"
+    _current_timeline: str = MAIN_BRANCH
 
     @classmethod
     @contextmanager
@@ -1033,7 +1004,7 @@ class ObjectStateRegistry:
                         del cls._snapshots[snapshot_id]
                     cls._timelines = timelines_before
                     cls._current_head = current_head_before
-                    cls._current_timeline = current_timeline_before or "main"
+                    cls._current_timeline = current_timeline_before or cls.MAIN_BRANCH
                     cls._in_time_travel = bool(in_time_travel_before)
                     if snapshot_dirty_scopes_before is not None:
                         cls._snapshot_dirty_scopes = snapshot_dirty_scopes_before
@@ -1306,7 +1277,7 @@ class ObjectStateRegistry:
                 name=cls._current_timeline,
                 head_id=snapshot.id,
                 base_id=snapshot.id,
-                description="Main timeline" if cls._current_timeline == "main" else "",
+                description="Main timeline" if cls._current_timeline == cls.MAIN_BRANCH else "",
             )
             logger.info(f"⏱️ BRANCH: Created '{cls._current_timeline}' timeline")
         else:
@@ -1353,18 +1324,10 @@ class ObjectStateRegistry:
         return tuple(
             sorted(
                 cls._states.items(),
-                key=lambda item: (cls._scope_depth(item[0]), item[0]),
+                key=lambda item: (item[0].depth, item[0]),
             )
         )
 
-    @staticmethod
-    def _scope_depth(scope_id: str) -> int:
-        """Return hierarchy depth for ObjectState scope identifiers."""
-
-        if not scope_id:
-            return 0
-        return scope_id.count("::") + 1
-
     @classmethod
     def _prune_unreachable_snapshots(cls) -> None:
         """Remove snapshots not reachable from any branch head.
@@ -2193,6 +2156,11 @@ class ObjectStateRegistry:
         """Check if currently viewing historical state (not at head)."""
         return cls._current_head is not None
 
+    @classmethod
+    def is_restoring_snapshot(cls) -> bool:
+        """Whether a snapshot restore is in progress, so views refresh restored values."""
+        return cls._in_time_travel
+
     # ========== BRANCH OPERATIONS ==========
 
     @classmethod
@@ -2319,9 +2287,7 @@ class ObjectStateRegistry:
         }
 
     @classmethod
-    def import_history_from_dict(
-        cls, data: Dict[str, Any], *, migration: HistoryMigration | None = None
-    ) -> None:
+    def import_history_from_dict(cls, data: dict[str, Any]) -> None:
         """Import a complete typed history document payload.
 
         Version 2 includes exact construction declarations. Older documents
@@ -2330,11 +2296,7 @@ class ObjectStateRegistry:
         Args:
             data: Dict with 'snapshots', 'timelines', 'current_head', 'current_timeline'.
         """
-        document, constructions = copy.deepcopy(
-            (data, {scope: state.construction_binding() for scope, state in cls._states.items()})
-        )
-        if document.get("format_version") != 2 and migration is not None:
-            document = migration.migrate(document, constructions)
+        document = copy.deepcopy(data)
         if document.get("format_version") != 2:
             raise ValueError(
                 "Unsupported ObjectState history version; construction ownership is required."
@@ -2389,9 +2351,7 @@ class ObjectStateRegistry:
         logger.info(f"⏱️ Saved {len(cls._snapshots)} snapshots to {filepath}")
 
     @classmethod
-    def load_history_from_file(
-        cls, filepath: str, *, migration: HistoryMigration | None = None
-    ) -> None:
+    def load_history_from_file(cls, filepath: str) -> None:
         """Load and materialize a trusted ObjectState history document.
 
         Args:
@@ -2407,7 +2367,7 @@ class ObjectStateRegistry:
         )
         try:
             with open(filepath, "rb") as history_file:
-                cls.import_history_from_dict(dill.load(history_file), migration=migration)
+                cls.import_history_from_dict(dill.load(history_file))
             restored_at_head = cls._current_head is None
             snapshot_id = cls._current_snapshot_id()
             if snapshot_id is not None: