mainsequence 4.3.14__tar.gz → 4.3.16__tar.gz

{mainsequence-4.3.14/mainsequence.egg-info → mainsequence-4.3.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.3.14
+Version: 4.3.16
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

{mainsequence-4.3.14 → mainsequence-4.3.16}/mainsequence/client/metatables/core.py

@@ -2375,6 +2375,23 @@ class DataNodeUpdate(TableUpdateNode, BaseObjectOrm):
 
         return depth_df
 
+    def clear_dependencies(self, timeout=None) -> dict[str, Any] | None:
+        url = self.get_object_url() + f"/{self._public_uid()}/clear-dependencies/"
+        payload = {"json": {}}
+        r = make_request(
+            s=self.build_session(),
+            loaders=self.LOADERS,
+            r_type="POST",
+            url=url,
+            payload=payload,
+            time_out=timeout,
+        )
+        if r.status_code not in (200, 204):
+            raise_for_response(r, payload=payload)
+        if not r.content:
+            return None
+        return r.json()
+
     @classmethod
     def get_upstream_nodes(cls, storage_hash, data_source_uid, timeout=None):
         s = cls.build_session()

{mainsequence-4.3.14 → mainsequence-4.3.16}/mainsequence/meta_tables/data_nodes/data_nodes.py

@@ -807,12 +807,29 @@ class DataNode(DataAccessMixin, ABC):
             local_configuration=self.local_initial_configuration,
         )
 
-    def set_relation_tree(self):
+    def set_relation_tree(
+        self,
+        *,
+        force_rebuild: bool = False,
+        _visited_update_uids: set[str] | None = None,
+    ):
         """Sets the node relationships in the backend by calling the dependencies() method."""
 
         if self.local_persist_manager.data_node_update is None:
             self.verify_and_build_remote_objects()  #
-        if self.local_persist_manager.is_local_relation_tree_set():
+        data_node_update_uid = str(getattr(self.local_persist_manager.data_node_update, "uid", ""))
+        if _visited_update_uids is None:
+            _visited_update_uids = set()
+        if data_node_update_uid:
+            if data_node_update_uid in _visited_update_uids:
+                return
+            _visited_update_uids.add(data_node_update_uid)
+
+        if force_rebuild:
+            self.local_persist_manager.clear_dependencies()
+            self.depth_df = pd.DataFrame()
+            self.dependencies_df = None
+        elif self.local_persist_manager.is_local_relation_tree_set():
             return
         declared_dependencies = self.dependencies() or {}
 
@@ -827,7 +844,11 @@ class DataNode(DataAccessMixin, ABC):
             self.local_persist_manager.depends_on_connect(dependency_ts, is_api=is_api)
 
             # Recursively set the relation tree for the dependency
-            dependency_ts.set_relation_tree()
+            if not is_api:
+                dependency_ts.set_relation_tree(
+                    force_rebuild=force_rebuild,
+                    _visited_update_uids=_visited_update_uids,
+                )
 
         self.local_persist_manager.set_ogm_dependencies_linked()
 

{mainsequence-4.3.14 → mainsequence-4.3.16}/mainsequence/meta_tables/data_nodes/persist_managers.py

@@ -4,6 +4,7 @@ import hashlib
 import inspect
 import threading
 from concurrent.futures import Future
+from dataclasses import dataclass
 from typing import Any, ClassVar
 
 import pandas as pd
@@ -29,6 +30,15 @@ from mainsequence.meta_tables import PlatformTimeIndexMetaTable
 
 from .. import future_registry
 
+_STORAGE_TABLE_LOOKUP_LIMIT = 20
+
+
+@dataclass(frozen=True)
+class _StorageTableLookupResult:
+    table_name: str | None
+    filters: dict[str, Any]
+    matches: list[TimeIndexMetaTable]
+
 
 def get_data_node_source_code(DataNodeClass: type[Any]) -> str:
     """
@@ -96,17 +106,18 @@ def ensure_registered_storage_table(
             f"model class; got {type(storage_table).__name__}."
         )
 
+    lookup_result: _StorageTableLookupResult | None = None
     if storage_table.get_time_index_meta_table() is None:
-        _bind_registered_storage_table(storage_table)
+        lookup_result = _bind_registered_storage_table(storage_table)
 
     storage_metadata = storage_table.get_time_index_meta_table()
     if storage_metadata is None:
         raise ValueError(
-            f"{context} storage_table class is not bound to backend "
-            "TimeIndexMetaTable "
-            "metadata in this Python process. The backend table may already exist; "
-            "the SDK could not resolve a unique TimeIndexMetaTable row for "
-            f"{_storage_table_lookup_label(storage_table)}."
+            _unbound_storage_table_message(
+                storage_table,
+                context=context,
+                lookup_result=lookup_result,
+            )
         )
     if not isinstance(storage_metadata, TimeIndexMetaTable):
         raise TypeError(
@@ -120,25 +131,34 @@ def ensure_registered_storage_table(
     return storage_table
 
 
-def _bind_registered_storage_table(storage_table: type[PlatformTimeIndexMetaTable]) -> None:
-    matches = _registered_storage_table_matches(storage_table)
-    if len(matches) == 1:
-        storage_table._bind_meta_table(matches[0])
+def _bind_registered_storage_table(
+    storage_table: type[PlatformTimeIndexMetaTable],
+) -> _StorageTableLookupResult:
+    lookup_result = _registered_storage_table_lookup(storage_table)
+    if len(lookup_result.matches) == 1:
+        storage_table._bind_meta_table(lookup_result.matches[0])
+    return lookup_result
 
 
-def _registered_storage_table_matches(
+def _registered_storage_table_lookup(
     storage_table: type[PlatformTimeIndexMetaTable],
-) -> list[TimeIndexMetaTable]:
+) -> _StorageTableLookupResult:
     table_name = _storage_table_physical_table_name(storage_table)
     if table_name:
+        filters = {
+            "physical_table_name__in": [table_name],
+            "limit": _STORAGE_TABLE_LOOKUP_LIMIT,
+        }
         matches = TimeIndexMetaTable.filter_by_body(
-            physical_table_name__in=[table_name],
-            limit=1,
+            **filters,
+        )
+        return _StorageTableLookupResult(
+            table_name=table_name,
+            filters=filters,
+            matches=matches,
         )
-        if matches:
-            return matches
 
-    return []
+    return _StorageTableLookupResult(table_name=None, filters={}, matches=[])
 
 
 def _storage_table_physical_table_name(
@@ -159,6 +179,100 @@ def _storage_table_lookup_label(storage_table: type[PlatformTimeIndexMetaTable])
     return f"{storage_table.__name__}(table={table_name})"
 
 
+def _unbound_storage_table_message(
+    storage_table: type[PlatformTimeIndexMetaTable],
+    *,
+    context: str,
+    lookup_result: _StorageTableLookupResult | None,
+) -> str:
+    label = _storage_table_lookup_label(storage_table)
+    identity = _storage_table_identity_summary(storage_table)
+    message = (
+        f"{context} storage_table class is not bound to backend TimeIndexMetaTable "
+        f"metadata in this Python process for {label}. {identity} "
+        "Expected exactly one backend TimeIndexMetaTable catalog row before "
+        "constructing a DataNode."
+    )
+    if lookup_result is None:
+        return (
+            f"{message} The SDK did not run a backend lookup because the model "
+            "already appeared to be bound before validation failed. Check the "
+            "bound MetaTable UID and data-source UID on the storage model."
+        )
+    if lookup_result.table_name is None:
+        return (
+            f"{message} The SDK could not determine a physical table name from "
+            "the storage model, so no backend catalog lookup was possible."
+        )
+
+    filters = _format_lookup_filters(lookup_result.filters)
+    match_count = len(lookup_result.matches)
+    if match_count == 0:
+        return (
+            f"{message} Lookup used TimeIndexMetaTable.filter_by_body({filters}) "
+            "and found no backend TimeIndexMetaTable catalog row. This usually "
+            "means the exact storage model/table has not been reserved and "
+            "finalized by its migration provider. If the SQL table already exists "
+            "without a TimeIndexMetaTable catalog row, it is still unusable by "
+            "DataNodes until the migration finalization step creates that row. "
+            "Add this exact storage model to the relevant migration provider "
+            "or dynamic scoped provider and run the provider upgrade before "
+            "constructing the DataNode."
+        )
+
+    candidates = "; ".join(
+        _time_index_meta_table_candidate_summary(match)
+        for match in lookup_result.matches[:_STORAGE_TABLE_LOOKUP_LIMIT]
+    )
+    qualifier = "at least " if match_count >= _STORAGE_TABLE_LOOKUP_LIMIT else ""
+    return (
+        f"{message} Lookup used TimeIndexMetaTable.filter_by_body({filters}) "
+        f"and found {qualifier}{match_count} matching backend TimeIndexMetaTable "
+        "catalog rows, so the SDK refused to guess. Matching rows: "
+        f"{candidates}. Remove or repair the duplicate catalog state so exactly "
+        "one row owns this physical table."
+    )
+
+
+def _storage_table_identity_summary(storage_table: type[PlatformTimeIndexMetaTable]) -> str:
+    parts = []
+    identifier = getattr(storage_table, "__metatable_identifier__", None)
+    if identifier not in (None, ""):
+        parts.append(f"identifier={identifier!r}")
+    try:
+        storage_hash = storage_table.get_storage_hash()
+    except Exception:
+        storage_hash = None
+    if storage_hash not in (None, ""):
+        parts.append(f"storage_hash={storage_hash!r}")
+    data_source_uid = storage_table.get_data_source_uid()
+    if data_source_uid not in (None, ""):
+        parts.append(f"model_data_source_uid={data_source_uid!r}")
+    if not parts:
+        return "Storage identity is incomplete."
+    return "Storage identity: " + ", ".join(parts) + "."
+
+
+def _format_lookup_filters(filters: dict[str, Any]) -> str:
+    return ", ".join(f"{key}={value!r}" for key, value in filters.items())
+
+
+def _time_index_meta_table_candidate_summary(meta_table: TimeIndexMetaTable) -> str:
+    parts = []
+    for attr in (
+        "uid",
+        "data_source_uid",
+        "identifier",
+        "physical_table_name",
+        "storage_hash",
+        "provisioning_status",
+    ):
+        value = getattr(meta_table, attr, None)
+        if value not in (None, ""):
+            parts.append(f"{attr}={value}")
+    return "{" + ", ".join(parts) + "}" if parts else "{unidentified TimeIndexMetaTable}"
+
+
 class BasePersistManager:
     UPDATE_CLASS: ClassVar[type[Any] | None] = None
     UPDATE_DETAILS_CLASS: ClassVar[type[Any] | None] = None
@@ -336,8 +450,16 @@ class BasePersistManager:
     def get_all_dependencies_update_priority(self) -> pd.DataFrame:
         return self.data_node_update.get_all_dependencies_update_priority()
 
+    def clear_dependencies(self) -> Any:
+        result = self.data_node_update.clear_dependencies()
+        self.set_data_node_update_lazy(force_registry=True, include_relations_detail=True)
+        return result
+
+    def set_ogm_dependencies_unlinked(self) -> None:
+        self.set_data_node_update(self.data_node_update.patch(ogm_dependencies_linked=False))
+
     def set_ogm_dependencies_linked(self) -> None:
-        self.data_node_update.patch(ogm_dependencies_linked=True)
+        self.set_data_node_update(self.data_node_update.patch(ogm_dependencies_linked=True))
 
     @property
     def update_details(self) -> Any | None:

{mainsequence-4.3.14 → mainsequence-4.3.16}/mainsequence/meta_tables/data_nodes/run_operations.py

@@ -307,6 +307,9 @@ class UpdateRunner:
         if self.ts.dependencies_df is None:
             self.ts.set_dependencies_df()
 
+        if self.update_tree:
+            self._ensure_dependency_tree_matches_current_declarations()
+
         # 2. Connect the dependency tree to the scheduler if it hasn't been already.
         if not self.ts._scheduler_tree_connected and self.update_tree:
             self.logger.debug("Connecting dependency tree to scheduler...")
@@ -555,53 +558,15 @@ class UpdateRunner:
         Backend dependency metadata is ordering/state only; it is not used to
         cold-rebuild executable DataNode instances.
         """
-        # 1. Ensure the dependency graph is built in the backend
-        declared_dependencies = self.ts.dependencies() or {}
-        deps_uids = [
-            (
-                _require_uid(d.data_node_update, "DataNodeUpdate")
-                if (not d.is_api and d.data_node_update is not None)
-                else None
-            )
-            for d in declared_dependencies.values()
-        ]
-
-        # 2. Get the list of dependencies to update
-        dependencies_df = self.ts.dependencies_df
-        if (
-            dependencies_df is not None
-            and not dependencies_df.empty
-            and "update_node_uid" not in dependencies_df.columns
-        ):
-            raise ValueError("Dependency dataframe must include 'update_node_uid'.")
-        dependency_uids_in_tree = (
-            dependencies_df["update_node_uid"].astype(str).to_list()
-            if dependencies_df is not None and not dependencies_df.empty
-            else []
+        _, dependencies_df, update_map = (
+            self._ensure_dependency_tree_matches_current_declarations()
         )
 
-        if any([a is None for a in deps_uids]) or any(
-            [d not in dependency_uids_in_tree for d in deps_uids]
-        ):
-            # Datanode not update set
-            self.ts.local_persist_manager.data_node_update.patch(ogm_dependencies_linked=False)
-
-        if not self.ts.local_persist_manager.data_node_update.ogm_dependencies_linked:
-            self.logger.info("Dependency tree not set. Building now...")
-            start_time = time.time()
-            self.ts.set_relation_tree()
-            self.logger.debug(f"Tree build took {time.time() - start_time:.2f}s.")
-            self.ts.set_dependencies_df()
-            dependencies_df = self.ts.dependencies_df
-
         if dependencies_df.empty:
             self.logger.debug("No dependencies to update.")
             return
 
-        # 3. Build the executable dependency map from source declarations.
-        update_map = self._get_update_map(declared_dependencies, logger=self.logger)
-
-        # 4. Delegate to the appropriate execution method
+        # Delegate to the appropriate execution method.
         self.logger.debug(f"Starting update for {len(dependencies_df)} dependencies...")
 
         if self.debug_mode:
@@ -618,6 +583,174 @@ class UpdateRunner:
 
         self.logger.debug(f"Dependency tree evaluation complete for {self.ts}.")
 
+    def _ensure_dependency_tree_matches_current_declarations(
+        self,
+    ) -> tuple[dict[str, DataNode], pd.DataFrame, dict[str, dict[str, Any]]]:
+        declared_dependencies = self.ts.dependencies() or {}
+
+        if self._has_uninitialized_non_api_dependencies(declared_dependencies):
+            self.ts.local_persist_manager.set_ogm_dependencies_unlinked()
+            dependencies_df = self._rebuild_dependency_tree_from_current_declarations(
+                force_rebuild=True,
+                reason="Dependency declarations include uninitialized update nodes.",
+            )
+            declared_dependencies = self.ts.dependencies() or {}
+        elif not self.ts.local_persist_manager.data_node_update.ogm_dependencies_linked:
+            dependencies_df = self._rebuild_dependency_tree_from_current_declarations(
+                force_rebuild=False,
+                reason="Dependency tree not set. Building now.",
+            )
+            declared_dependencies = self.ts.dependencies() or {}
+        else:
+            dependencies_df = self._dependencies_df_or_empty(self.ts.dependencies_df)
+
+        update_map = self._get_update_map(declared_dependencies, logger=self.logger)
+        mismatch = self._dependency_tree_mismatch(
+            dependencies_df=dependencies_df,
+            update_map=update_map,
+        )
+        if self._mismatch_is_empty(mismatch):
+            return declared_dependencies, dependencies_df, update_map
+
+        self._log_dependency_tree_rebuild(mismatch)
+        dependencies_df = self._rebuild_dependency_tree_from_current_declarations(
+            force_rebuild=True,
+            reason="Backend dependency tree drift detected.",
+        )
+        declared_dependencies = self.ts.dependencies() or {}
+        update_map = self._get_update_map(declared_dependencies, logger=self.logger)
+        mismatch = self._dependency_tree_mismatch(
+            dependencies_df=dependencies_df,
+            update_map=update_map,
+        )
+        if not self._mismatch_is_empty(mismatch):
+            raise DependencyUpdateError(
+                self._dependency_tree_mismatch_message(
+                    mismatch,
+                    after_automatic_refresh=True,
+                )
+            )
+
+        return declared_dependencies, dependencies_df, update_map
+
+    @staticmethod
+    def _has_uninitialized_non_api_dependencies(
+        declared_dependencies: dict[str, DataNode],
+    ) -> bool:
+        return any(
+            not dependency_ts.is_api
+            and getattr(dependency_ts, "data_node_update", None) is None
+            for dependency_ts in declared_dependencies.values()
+        )
+
+    def _rebuild_dependency_tree_from_current_declarations(
+        self,
+        *,
+        force_rebuild: bool,
+        reason: str,
+    ) -> pd.DataFrame:
+        self.logger.info(reason)
+        start_time = time.time()
+        self.ts.set_relation_tree(force_rebuild=force_rebuild)
+        self.logger.debug(f"Tree build took {time.time() - start_time:.2f}s.")
+        self.ts.set_dependencies_df()
+        return self._dependencies_df_or_empty(self.ts.dependencies_df)
+
+    @staticmethod
+    def _dependencies_df_or_empty(dependencies_df: pd.DataFrame | None) -> pd.DataFrame:
+        if dependencies_df is None:
+            return pd.DataFrame()
+        if not dependencies_df.empty and "update_node_uid" not in dependencies_df.columns:
+            raise ValueError("Dependency dataframe must include 'update_node_uid'.")
+        return dependencies_df
+
+    @staticmethod
+    def _dependency_tree_mismatch(
+        *,
+        dependencies_df: pd.DataFrame,
+        update_map: dict[str, dict[str, Any]],
+    ) -> dict[str, list[str]]:
+        if not dependencies_df.empty and "update_node_uid" not in dependencies_df.columns:
+            raise ValueError("Dependency dataframe must include 'update_node_uid'.")
+        backend_uids = (
+            set(dependencies_df["update_node_uid"].astype(str).to_list())
+            if not dependencies_df.empty
+            else set()
+        )
+        declared_uids = set(update_map)
+        return {
+            "stale_backend_uids": sorted(backend_uids - declared_uids),
+            "missing_backend_uids": sorted(declared_uids - backend_uids),
+        }
+
+    @staticmethod
+    def _mismatch_is_empty(mismatch: dict[str, list[str]]) -> bool:
+        return not mismatch["stale_backend_uids"] and not mismatch["missing_backend_uids"]
+
+    def _log_dependency_tree_rebuild(self, mismatch: dict[str, list[str]]) -> None:
+        message = self._dependency_tree_mismatch_message(
+            mismatch,
+            after_automatic_refresh=False,
+        )
+        warning = getattr(self.logger, "warning", None)
+        if callable(warning):
+            warning(message)
+        else:
+            self.logger.info(message)
+
+    @staticmethod
+    def _dependency_tree_mismatch_message(
+        mismatch: dict[str, list[str]],
+        *,
+        after_automatic_refresh: bool,
+    ) -> str:
+        stale_backend_uids = mismatch["stale_backend_uids"]
+        missing_backend_uids = mismatch["missing_backend_uids"]
+        message_parts = [
+            "Backend dependency tree is out of sync with the current "
+            "DataNode.dependencies() graph."
+        ]
+        if stale_backend_uids:
+            message_parts.append(
+                "Backend contains stale dependency update UIDs that current Python "
+                f"code does not declare: {stale_backend_uids!r}."
+            )
+        if missing_backend_uids:
+            message_parts.append(
+                "Backend is missing dependency update UIDs declared by current "
+                f"Python code: {missing_backend_uids!r}."
+            )
+        if after_automatic_refresh:
+            message_parts.append(
+                "The SDK already cleared and rebuilt the dependency tree once, but "
+                "the backend response still does not match the current graph."
+            )
+        else:
+            message_parts.append(
+                "The SDK will clear and rebuild backend dependency edges from the "
+                "current declarations before executing dependency updates."
+            )
+        return " ".join(message_parts)
+
+    @staticmethod
+    def _validate_dependency_tree_matches_update_map(
+        *,
+        dependencies_df: pd.DataFrame,
+        update_map: dict[str, dict[str, Any]],
+    ) -> None:
+        mismatch = UpdateRunner._dependency_tree_mismatch(
+            dependencies_df=dependencies_df,
+            update_map=update_map,
+        )
+        if UpdateRunner._mismatch_is_empty(mismatch):
+            return
+        raise DependencyUpdateError(
+            UpdateRunner._dependency_tree_mismatch_message(
+                mismatch,
+                after_automatic_refresh=True,
+            )
+        )
+
     def _get_update_map(
         self,
         declared_dependencies: dict[str, DataNode],

{mainsequence-4.3.14 → mainsequence-4.3.16/mainsequence.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.3.14
+Version: 4.3.16
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

{mainsequence-4.3.14 → mainsequence-4.3.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "4.3.14"
+version = "4.3.16"
 description = "Main Sequence SDK "
 readme = "README.md"
 requires-python = ">=3.11"

{mainsequence-4.3.14 → mainsequence-4.3.16}/tests/test_meta_tables_sqlalchemy_contracts.py

@@ -1566,8 +1566,12 @@ def test_ensure_registered_storage_table_rejects_unbound_storage(monkeypatch):
         classmethod(lambda cls, **filters: []),
     )
 
-    with pytest.raises(ValueError, match="not bound to backend TimeIndexMetaTable"):
+    with pytest.raises(ValueError) as exc_info:
         ensure_registered_storage_table(AssetSnapshots, context="DataNode")
+    message = str(exc_info.value)
+    assert "not bound to backend TimeIndexMetaTable" in message
+    assert "found no backend TimeIndexMetaTable catalog row" in message
+    assert "example_assets__asset_snapshots" in message
 
 
 def test_ensure_registered_storage_table_binds_existing_time_index_meta_table(monkeypatch):
@@ -1607,10 +1611,48 @@ def test_ensure_registered_storage_table_binds_existing_time_index_meta_table(mo
     assert AssetSnapshots.get_meta_table_uid() == "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"
     assert captured == {
         "physical_table_name__in": ["example_assets__asset_snapshots"],
-        "limit": 1,
+        "limit": 20,
     }
 
 
+def test_ensure_registered_storage_table_reports_duplicate_matches(monkeypatch):
+    columns = [
+        FakeColumn("time_index", DateTime(timezone=True), nullable=False),
+        FakeColumn("asset_uid", Uuid(), nullable=False),
+    ]
+    table = FakeTable("example_assets__asset_snapshots", columns=columns)
+    AssetSnapshots = _time_index_model_class(
+        "AssetSnapshots",
+        table,
+        index_names=["time_index", "asset_uid"],
+    )
+    first = TimeIndexMetaTable.model_construct(
+        uid="aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+        data_source_uid="dddddddd-dddd-4ddd-8ddd-dddddddddddd",
+        storage_hash="storage-hash",
+        physical_table_name="example_assets__asset_snapshots",
+    )
+    second = TimeIndexMetaTable.model_construct(
+        uid="bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+        data_source_uid="eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee",
+        storage_hash="storage-hash",
+        physical_table_name="example_assets__asset_snapshots",
+    )
+
+    monkeypatch.setattr(
+        TimeIndexMetaTable,
+        "filter_by_body",
+        classmethod(lambda cls, **filters: [first, second]),
+    )
+
+    with pytest.raises(ValueError) as exc_info:
+        ensure_registered_storage_table(AssetSnapshots, context="DataNode")
+    message = str(exc_info.value)
+    assert "found 2 matching backend TimeIndexMetaTable catalog rows" in message
+    assert "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" in message
+    assert "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb" in message
+
+
 def test_time_index_storage_name_hash_component_separates_identical_table_shapes():
     columns_a = [
         FakeColumn("time_index", DateTime(timezone=True), nullable=False),