mainsequence 4.3.30__tar.gz → 4.4.1__tar.gz

{mainsequence-4.3.30/mainsequence.egg-info → mainsequence-4.4.1}/PKG-INFO

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

{mainsequence-4.3.30 → mainsequence-4.4.1}/mainsequence/cli/cli.py

@@ -1489,7 +1489,7 @@ def _require_delete_verification(
 def _format_data_node_storage_delete_preview(storage: dict[str, object]) -> list[tuple[str, str]]:
     return [
         ("UID", str(storage.get("uid") or "-")),
-        ("Storage Hash", str(storage.get("storage_hash") or "-")),
+        ("Physical Table", str(storage.get("physical_table_name") or "-")),
         ("Identifier", str(storage.get("identifier") or "-")),
         ("Source Class", str(storage.get("source_class_name") or "-")),
         ("Data Source", _format_data_node_storage_data_source(storage.get("data_source"))),
@@ -1500,7 +1500,6 @@ def _format_data_node_storage_delete_preview(storage: dict[str, object]) -> list
 def _format_meta_table_delete_preview(meta_table: dict[str, object]) -> list[tuple[str, str]]:
     return [
         ("UID", str(meta_table.get("uid") or "-")),
-        ("Storage Hash", str(meta_table.get("storage_hash") or "-")),
         ("Identifier", str(meta_table.get("identifier") or "-")),
         ("Namespace", str(meta_table.get("namespace") or "-")),
         ("Physical Table", str(meta_table.get("physical_table_name") or "-")),
@@ -5372,7 +5371,6 @@ def _data_node_storage_list_impl(
             "Data Node Storages",
             [
                 "UID",
-                "Storage Hash",
                 "Physical Table",
                 "Source Class",
                 "Identifier",
@@ -5420,7 +5418,6 @@ def _meta_table_list_impl(
             "MetaTables",
             [
                 "UID",
-                "Storage Hash",
                 "Physical Table",
                 "Identifier",
                 "Namespace",
@@ -5440,7 +5437,6 @@ def _build_data_node_storage_rows(storages: list[dict[str, object]]) -> list[lis
         rows.append(
             [
                 str(storage.get("uid") or "-"),
-                str(storage.get("storage_hash") or "-"),
                 str(storage.get("physical_table_name") or "-"),
                 str(storage.get("source_class_name") or "-"),
                 str(storage.get("identifier") or "-"),
@@ -5457,7 +5453,6 @@ def _build_meta_table_rows(meta_tables: list[dict[str, object]]) -> list[list[st
         rows.append(
             [
                 str(meta_table.get("uid") or "-"),
-                str(meta_table.get("storage_hash") or "-"),
                 str(meta_table.get("physical_table_name") or "-"),
                 str(meta_table.get("identifier") or "-"),
                 str(meta_table.get("namespace") or "-"),
@@ -5536,7 +5531,6 @@ def _data_node_storage_search_impl(
             title,
             [
                 "UID",
-                "Storage Hash",
                 "Physical Table",
                 "Source Class",
                 "Identifier",
@@ -5575,7 +5569,6 @@ def _print_data_node_storage_search_section(
             title,
             [
                 "UID",
-                "Storage Hash",
                 "Physical Table",
                 "Source Class",
                 "Identifier",
@@ -6976,7 +6969,6 @@ def _data_node_storage_detail_impl(storage_uid: str, timeout: int | None) -> Non
         "Data Node Storage",
         [
             ("UID", str(storage.get("uid") or storage_uid)),
-            ("Storage Hash", str(storage.get("storage_hash") or "-")),
             ("Physical Table", str(storage.get("physical_table_name") or "-")),
             ("Identifier", str(storage.get("identifier") or "-")),
             ("Source Class", str(storage.get("source_class_name") or "-")),
@@ -7018,7 +7010,6 @@ def _meta_table_detail_impl(meta_table_uid: str, timeout: int | None) -> None:
         "MetaTable",
         [
             ("UID", str(meta_table.get("uid") or meta_table_uid)),
-            ("Storage Hash", str(meta_table.get("storage_hash") or "-")),
             ("Physical Table", str(meta_table.get("physical_table_name") or "-")),
             ("Identifier", str(meta_table.get("identifier") or "-")),
             ("Namespace", str(meta_table.get("namespace") or "-")),
@@ -7089,7 +7080,12 @@ def _data_node_storage_delete_impl(
         error(f"Data node storage fetch failed: {e}")
         raise typer.Exit(1) from e
 
-    verification_value = str(storage.get("storage_hash") or storage.get("uid") or storage_uid)
+    verification_value = str(
+        storage.get("physical_table_name") or storage.get("uid") or storage_uid
+    )
+    verification_label = (
+        "physical table name" if storage.get("physical_table_name") else "storage uid"
+    )
     _require_delete_verification(
         preview_title="Data Node Storage Delete Preview",
         preview_items=_format_data_node_storage_delete_preview(storage)
@@ -7100,7 +7096,7 @@ def _data_node_storage_delete_impl(
             ("override_protection", str(override_protection).lower()),
         ],
         verification_value=verification_value,
-        verification_label="storage hash" if storage.get("storage_hash") else "storage uid",
+        verification_label=verification_label,
     )
 
     try:
@@ -7137,13 +7133,16 @@ def _meta_table_delete_impl(
         raise typer.Exit(1) from e
 
     verification_value = str(
-        meta_table.get("storage_hash") or meta_table.get("uid") or meta_table_uid
+        meta_table.get("physical_table_name") or meta_table.get("uid") or meta_table_uid
+    )
+    verification_label = (
+        "physical table name" if meta_table.get("physical_table_name") else "MetaTable uid"
     )
     _require_delete_verification(
         preview_title="MetaTable Delete Preview",
         preview_items=_format_meta_table_delete_preview(meta_table),
         verification_value=verification_value,
-        verification_label="storage hash" if meta_table.get("storage_hash") else "MetaTable uid",
+        verification_label=verification_label,
     )
 
     try:
@@ -7775,7 +7774,7 @@ def data_node_storage_column_search_cmd(
     --------
     ```bash
     mainsequence data-node column-search weight
-    mainsequence data-node column-search close --filter storage_hash__contains=weights
+    mainsequence data-node column-search close --filter physical_table_name__contains=weights
     ```
     """
     filters = _resolve_cli_list_filters(
@@ -8247,7 +8246,7 @@ def _print_project_data_node_updates(
         storage = u.get("data_node_storage")
         if isinstance(storage, dict):
             storage_value = (
-                storage.get("storage_hash") or storage.get("uid") or storage.get("id") or "-"
+                storage.get("physical_table_name") or storage.get("uid") or storage.get("id") or "-"
             )
         else:
             storage_value = storage if storage is not None else "-"

{mainsequence-4.3.30 → mainsequence-4.4.1}/mainsequence/client/metatables/core.py

@@ -95,6 +95,13 @@ def _local_data_interface(class_type: str):
     raise ValueError(f"Unsupported local data source class_type: {class_type!r}")
 
 
+def _storage_physical_table_name(storage: Any) -> str:
+    table_name = getattr(storage, "physical_table_name", None)
+    if table_name not in (None, ""):
+        return str(table_name)
+    raise ValueError("MetaTable local storage operations require physical_table_name.")
+
+
 def _storage_time_indexed_contract(storage: Any) -> tuple[str, list[str], dict[str, Any]]:
     if hasattr(storage, "_require_time_indexed_table_contract"):
         return storage._require_time_indexed_table_contract()
@@ -401,9 +408,9 @@ class MetaTableForeignKeyPayload(BasePydanticModel):
         None,
         description="Public UID of the target MetaTable.",
     )
-    target_table_storage_hash: str | None = Field(
+    target_table_physical_table_name: str | None = Field(
         None,
-        description="Storage hash of the target MetaTable.",
+        description="Physical table name of the target MetaTable.",
     )
     target_columns: list[str] = Field(
         default_factory=list,
@@ -415,6 +422,15 @@ class MetaTableForeignKeyPayload(BasePydanticModel):
         description="Raw normalized contract fragment for this projected foreign key.",
     )
 
+    @model_validator(mode="before")
+    @classmethod
+    def _strip_legacy_storage_hash(cls, value: Any) -> Any:
+        if isinstance(value, Mapping):
+            data = dict(value)
+            data.pop("target_table_storage_hash", None)
+            return data
+        return value
+
 
 class MetaTableStatementPayload(BasePydanticModel):
     sql: str = Field(..., min_length=1)
@@ -533,7 +549,6 @@ class MetaTableRequestFields(BasePydanticModel):
         ...,
         description="Public UID of the DynamicTableDataSource that owns this MetaTable.",
     )
-    storage_hash: str = Field(..., max_length=63, description="Canonical table storage hash.")
     table_contract: MetaTableContract | dict[str, Any]
     identifier: str | None = Field(
         default=None,
@@ -561,6 +576,15 @@ class MetaTableRequestFields(BasePydanticModel):
             self.table_contract = _normalize_contract_mapping(self.table_contract)
         return self
 
+    @model_validator(mode="before")
+    @classmethod
+    def _strip_legacy_storage_hash(cls, value: Any) -> Any:
+        if isinstance(value, Mapping):
+            data = dict(value)
+            data.pop("storage_hash", None)
+            return data
+        return value
+
 
 class MetaTableRegistrationRequest(MetaTableRequestFields):
     management_mode: MetaTableManagementMode
@@ -571,7 +595,15 @@ class MetaTableRegistrationRequest(MetaTableRequestFields):
 class MetaTableValidateContractRequest(BasePydanticModel):
     table_contract: MetaTableContract | dict[str, Any]
     management_mode: MetaTableManagementMode | None = None
-    storage_hash: str | None = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def _strip_legacy_storage_hash(cls, value: Any) -> Any:
+        if isinstance(value, Mapping):
+            data = dict(value)
+            data.pop("storage_hash", None)
+            return data
+        return value
 
     @model_validator(mode="after")
     def _normalize_table_contract(self) -> MetaTableValidateContractRequest:
@@ -676,7 +708,6 @@ class ManagedMetaTableFinalizeTableResult(BasePydanticModel):
         None,
         description="Organization-global logical MetaTable identifier, when present.",
     )
-    storage_hash: str = Field(..., description="Canonical MetaTable storage hash.")
     physical_table_name: str | None = Field(
         None,
         description="Physical table name reconciled against the data source.",
@@ -729,7 +760,14 @@ class ManagedMetaTableFinalizeTableResult(BasePydanticModel):
     def _normalize_cadence(cls, value: str | None) -> str | None:
         return _normalize_time_indexed_cadence(value)
 
-    model_config = ConfigDict(extra="ignore")
+    @model_validator(mode="before")
+    @classmethod
+    def _strip_legacy_storage_hash(cls, value: Any) -> Any:
+        if isinstance(value, Mapping):
+            data = dict(value)
+            data.pop("storage_hash", None)
+            return data
+        return value
 
 
 class ManagedMetaTableFinalizeResponse(BasePydanticModel):
@@ -847,7 +885,7 @@ class DataSource(BasePydanticModel, BaseObjectOrm):
             storage = data_node_update.data_node_storage
             _local_data_interface(self.class_type).upsert(
                 df=serialized_data_frame,
-                table=getattr(storage, "physical_table_name", None) or storage.storage_hash,
+                table=_storage_physical_table_name(storage),
                 index_names=index_names,
                 time_index_name=time_index_name,
             )
@@ -888,7 +926,7 @@ class DataSource(BasePydanticModel, BaseObjectOrm):
         if self.class_type in LOCAL_DATA_SOURCE_CLASS_TYPES:
             db_interface = _local_data_interface(self.class_type)
             storage = data_node_update.data_node_storage
-            table_name = getattr(storage, "physical_table_name", None) or storage.storage_hash
+            table_name = _storage_physical_table_name(storage)
             time_index_name, index_names, _ = _storage_time_indexed_contract(storage)
 
             adjusted_start, adjusted_end, adjusted_dimension_range_map, _ = (
@@ -964,9 +1002,7 @@ class DataSource(BasePydanticModel, BaseObjectOrm):
         if self.class_type in LOCAL_DATA_SOURCE_CLASS_TYPES:
             db_interface = _local_data_interface(self.class_type)
             storage = data_node_update.data_node_storage
-            table_name = getattr(storage, "physical_table_name", None) or getattr(
-                storage, "storage_hash", None
-            )
+            table_name = _storage_physical_table_name(storage)
             time_index_name, index_names, _ = _storage_time_indexed_contract(storage)
             return db_interface.time_index_minima(
                 table=table_name,
@@ -1133,7 +1169,6 @@ class DynamicTableDataSource(BasePydanticModel, BaseObjectOrm):
 class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, BaseObjectOrm):
     ENDPOINT: ClassVar[str] = "ts_manager/meta_table"
     FILTERSET_FIELDS: ClassVar[dict[str, list[str]]] = {
-        "storage_hash": ["in", "exact", "contains"],
         "identifier": ["in", "exact", "contains"],
         "uid": ["in", "exact"],
         "data_source__uid": ["in", "exact"],
@@ -1177,7 +1212,6 @@ class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, B
     uid: str | None = Field(None, description="Public uid of this MetaTable.")
     data_source: int | DynamicTableDataSource | dict[str, Any] | None = None
     data_source_uid: str | None = None
-    storage_hash: str = Field(..., max_length=63, description="Canonical table storage hash.")
     identifier: str | None = Field(
         default=None,
         description=(
@@ -1215,6 +1249,15 @@ class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, B
 
     model_config = ConfigDict(populate_by_name=True)
 
+    @model_validator(mode="before")
+    @classmethod
+    def _strip_legacy_storage_hash(cls, value: Any) -> Any:
+        if isinstance(value, Mapping):
+            data = dict(value)
+            data.pop("storage_hash", None)
+            return data
+        return value
+
     def _public_uid(self) -> str:
         if self.uid in (None, ""):
             raise ValueError("MetaTable must have a uid before calling this endpoint.")
@@ -1339,11 +1382,6 @@ class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, B
             raise_for_response(response, payload=payload)
         return type(self)(**response.json())
 
-    @classmethod
-    def patch_by_hash(cls, storage_hash: str, *args, **kwargs):
-        metadata = cls.get(storage_hash=storage_hash)
-        return metadata.patch(*args, **kwargs)
-
     @classmethod
     def destroy_by_uid(
         cls,
@@ -1819,7 +1857,7 @@ class UpdateNodeRef(TypedDict):
     uid: str
     node_type: str
     update_hash: str
-    remote_table_hash_id: str
+    physical_table_name: str | None
 
 
 def _require_public_uid(obj: Any, object_name: str) -> str:
@@ -1872,11 +1910,6 @@ class TimeIndexMetaTableRegistrationRequest(BasePydanticModel):
     model_config = ConfigDict(extra="forbid")
 
     data_source_uid: str = Field(..., description="Public uid of the storage data source")
-    storage_hash: str = Field(
-        ...,
-        max_length=63,
-        description="Canonical logical storage identity for the time-indexed MetaTable",
-    )
     identifier: str | None = Field(
         None,
         description=(
@@ -1923,6 +1956,7 @@ class TimeIndexMetaTableRegistrationRequest(BasePydanticModel):
         if not isinstance(value, Mapping):
             return value
         data = dict(value)
+        data.pop("storage_hash", None)
         forbidden = [
             field
             for field in ("columns", "index_names", "foreign_keys", "storage_layout")
@@ -2463,11 +2497,11 @@ class DataNodeUpdate(TableUpdateNode, BaseObjectOrm):
         return r.json()
 
     @classmethod
-    def get_upstream_nodes(cls, storage_hash, data_source_uid, timeout=None):
+    def get_upstream_nodes(cls, table_name, data_source_uid, timeout=None):
         s = cls.build_session()
         url = (
             cls.get_object_url("DataNode")
-            + f"/{storage_hash}/get_upstream_nodes?data_source_uid={data_source_uid}"
+            + f"/{table_name}/get_upstream_nodes?data_source_uid={data_source_uid}"
         )
         r = make_request(s=s, loaders=cls.LOADERS, r_type="GET", url=url, time_out=timeout)
         if r.status_code != 200:
@@ -2952,7 +2986,6 @@ class TableMetaData(BaseModel):
 class TimeIndexMetaTable(MetaTable):
     ENDPOINT: ClassVar[str] = "ts_manager/dynamic_table"
     FILTERSET_FIELDS: ClassVar[dict[str, list[str]]] = {
-        "storage_hash": ["in", "exact", "contains"],
         "identifier": ["in", "exact", "contains"],
         "uid": ["in", "exact"],
         "data_source__uid": ["in", "exact"],
@@ -3321,7 +3354,7 @@ class TimeIndexMetaTable(MetaTable):
                 related_resource = getattr(session_dynamic_data_source, "related_resource", None)
                 class_type = getattr(related_resource, "class_type", None)
             db_interface = _local_data_interface(class_type)
-            db_interface.drop_table(self.storage_hash)
+            db_interface.drop_table(self.physical_table_name)
 
         self.delete()
 
@@ -4731,7 +4764,7 @@ class PodDataSource:
             list_tables=True,
         )
         remote_table_names = [
-            getattr(t, "physical_table_name", None) or t.storage_hash for t in remote_node_storages
+            t.physical_table_name for t in remote_node_storages if t.physical_table_name
         ]
         db_interface = _local_data_interface(class_type)
         local_table_names = db_interface.list_tables()
@@ -4743,9 +4776,9 @@ class PodDataSource:
 
         tables_to_delete_remotely = set(remote_table_names) - set(local_table_names)
         for remote_table in remote_node_storages:
-            remote_physical_table_name = (
-                getattr(remote_table, "physical_table_name", None) or remote_table.storage_hash
-            )
+            remote_physical_table_name = getattr(remote_table, "physical_table_name", None)
+            if not remote_physical_table_name:
+                continue
             if remote_physical_table_name in tables_to_delete_remotely:
                 logger.debug(f"Deleting table remotely {remote_physical_table_name}")
                 if remote_table.protect_from_deletion:

{mainsequence-4.3.30 → mainsequence-4.4.1}/mainsequence/meta_tables/__init__.py

@@ -13,6 +13,10 @@ _LAZY_IMPORTS = {
     "AlembicVersionMetaTable": (".migrations", "AlembicVersionMetaTable"),
     "PlatformManagedMetaTable": (".sqlalchemy_contracts", "PlatformManagedMetaTable"),
     "PlatformTimeIndexMetaTable": (".sqlalchemy_contracts", "PlatformTimeIndexMetaTable"),
+    "compute_metatable_contract_hash": (
+        ".sqlalchemy_contracts",
+        "compute_metatable_contract_hash",
+    ),
     "POSTGRES_IDENTIFIER_MAX_LENGTH": (".hashing", "POSTGRES_IDENTIFIER_MAX_LENGTH"),
     "SchemaTableNameParts": (".schema_names", "SchemaTableNameParts"),
     "BaseConfiguration": (".data_nodes", "BaseConfiguration"),

{mainsequence-4.3.30 → mainsequence-4.4.1}/mainsequence/meta_tables/data_nodes/data_nodes.py

@@ -174,12 +174,19 @@ class APIDataNode(DataAccessMixin):
 
     @classmethod
     def build_from_local_time_serie(cls, source_table: "DataNodeUpdate") -> "APIDataNode":
+        physical_table_name = getattr(source_table, "physical_table_name", None) or getattr(
+            getattr(source_table, "data_node_storage", None),
+            "physical_table_name",
+            None,
+        )
+        if physical_table_name in (None, ""):
+            raise ValueError("APIDataNode.build_from_local_time_serie requires physical_table_name.")
         return cls(
             data_source_uid=cls._require_data_source_uid(
                 source_table.data_source,
                 context="APIDataNode.build_from_local_time_serie",
             ),
-            storage_hash=source_table.storage_hash,
+            physical_table_name=str(physical_table_name),
         )
 
     @classmethod
@@ -195,7 +202,7 @@ class APIDataNode(DataAccessMixin):
                 storage_table,
                 context=context,
             ),
-            storage_hash=cls._require_physical_table_name(
+            physical_table_name=cls._require_physical_table_name(
                 storage_table,
                 context=context,
             ),
@@ -222,7 +229,9 @@ class APIDataNode(DataAccessMixin):
     def __init__(
         self,
         data_source_uid: str,
-        storage_hash: str,
+        physical_table_name: str | None = None,
+        *,
+        storage_hash: str | None = None,
         data_source_local_lake: DataSource | None = None,
         storage_table: MetaTable | None = None,
     ):
@@ -231,7 +240,7 @@ class APIDataNode(DataAccessMixin):
 
         Args:
             data_source_uid: The UID of the data source.
-            storage_hash: The storage hash of the data node table.
+            physical_table_name: The physical table name of the data node table.
             data_source_local_lake: Optional local data source for the lake.
             storage_table: Optional resolved MetaTable backing this read wrapper.
         """
@@ -242,8 +251,11 @@ class APIDataNode(DataAccessMixin):
 
         if data_source_uid in (None, ""):
             raise ValueError("APIDataNode requires data_source_uid.")
+        resolved_physical_table_name = physical_table_name or storage_hash
+        if resolved_physical_table_name in (None, ""):
+            raise ValueError("APIDataNode requires physical_table_name.")
         self.data_source_uid = str(data_source_uid)
-        self.storage_hash = storage_hash
+        self.physical_table_name = str(resolved_physical_table_name)
         self.storage_table = storage_table
         self.data_source = data_source_local_lake
         self._local_persist_manager: APIPersistManager = None
@@ -257,19 +269,19 @@ class APIDataNode(DataAccessMixin):
         return True
 
     @staticmethod
-    def _get_update_hash(storage_hash):
-        return "API_" + f"{storage_hash}"
+    def _get_update_hash(physical_table_name):
+        return "API_" + f"{physical_table_name}"
 
     @property
     def update_hash(self):
-        return self._get_update_hash(storage_hash=self.storage_hash)
+        return self._get_update_hash(physical_table_name=self.physical_table_name)
 
     @property
     def local_persist_manager(self) -> Any:
         """Gets the local persistence manager, initializing it if necessary."""
         if self._local_persist_manager is None:
             self._set_local_persist_manager()
-            self.logger.debug(f"Setting local persist manager for {self.storage_hash}")
+            self.logger.debug(f"Setting local persist manager for {self.physical_table_name}")
         return self._local_persist_manager
 
     def set_relation_tree(self) -> None:
@@ -308,12 +320,12 @@ class APIDataNode(DataAccessMixin):
     def _set_local_persist_manager(self) -> None:
         self._verify_local_data_source()
         self._local_persist_manager = APIPersistManager(
-            storage_hash=self.storage_hash,
+            physical_table_name=self.physical_table_name,
             data_source_uid=self.data_source_uid,
         )
         storage_table = self._local_persist_manager.storage_table
 
-        assert storage_table is not None, f"Verify that the table {self.storage_hash} exists "
+        assert storage_table is not None, f"Verify that the table {self.physical_table_name} exists "
 
     def get_update_statistics(self):
         """

{mainsequence-4.3.30 → mainsequence-4.4.1}/mainsequence/meta_tables/data_nodes/persist_managers.py

@@ -240,11 +240,11 @@ def _storage_table_identity_summary(storage_table: type[PlatformTimeIndexMetaTab
     if identifier not in (None, ""):
         parts.append(f"identifier={identifier!r}")
     try:
-        storage_hash = storage_table.get_storage_hash()
+        contract_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}")
+        contract_hash = None
+    if contract_hash not in (None, ""):
+        parts.append(f"contract_hash={contract_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}")
@@ -264,7 +264,6 @@ def _time_index_meta_table_candidate_summary(meta_table: TimeIndexMetaTable) ->
         "data_source_uid",
         "identifier",
         "physical_table_name",
-        "storage_hash",
         "provisioning_status",
     ):
         value = getattr(meta_table, attr, None)
@@ -602,7 +601,7 @@ class BasePersistManager:
                 db_interface = get_sqlite_interface_class()()
             else:
                 raise ValueError(f"Unsupported local DataSource class_type: {class_type!r}")
-            db_interface.drop_table(self.storage_metadata.storage_hash)
+            db_interface.drop_table(self.storage_metadata.physical_table_name)
 
         self.storage_metadata.delete()
 
@@ -648,21 +647,22 @@ class APIPersistManager:
     def __init__(
         self,
         *,
+        physical_table_name: str | None = None,
         storage_hash: str | None = None,
         data_source_uid: str,
     ):
         if data_source_uid in (None, ""):
             raise ValueError("APIPersistManager requires data_source_uid.")
         self.data_source_uid: str = str(data_source_uid)
-        self.storage_hash: str = storage_hash
+        self.physical_table_name: str | None = physical_table_name or storage_hash
 
-        logger.debug(f"Initializing Time Serie {self.storage_hash}  as APIDataNode")
+        logger.debug(f"Initializing Time Serie {self.physical_table_name} as APIDataNode")
 
         self._storage_table_future = Future()
         future_registry.add_future(self._storage_table_future)
         thread = threading.Thread(
             target=self._init_storage_table,
-            name=f"ApiStorageTableThread-{self.storage_hash}",
+            name=f"ApiStorageTableThread-{self.physical_table_name}",
             daemon=False,
         )
         thread.start()
@@ -676,7 +676,7 @@ class APIPersistManager:
     def _init_storage_table(self) -> None:
         try:
             result = TimeIndexMetaTable.get_or_none(
-                physical_table_name=self.storage_hash,
+                physical_table_name=self.physical_table_name,
                 data_source__uid=self.data_source_uid,
             )
             self._storage_table_future.set_result(result)

{mainsequence-4.3.30 → mainsequence-4.4.1}/mainsequence/meta_tables/data_nodes/run_operations.py

@@ -198,23 +198,17 @@ def _metatable_contract_column_dtypes_map(meta_table: Any) -> dict[str, str]:
     return column_dtypes
 
 
-def _storage_hash(storage_table: Any) -> str | None:
+def _physical_table_name(storage_table: Any) -> str | None:
     if storage_table is None:
         return None
     if isinstance(storage_table, Mapping):
-        storage_hash = storage_table.get("storage_hash") or storage_table.get("physical_table_name")
+        table_name = storage_table.get("physical_table_name")
     else:
-        hash_getter = getattr(storage_table, "get_storage_hash", None)
-        try:
-            storage_hash = hash_getter() if callable(hash_getter) else None
-        except Exception:
-            storage_hash = None
-        storage_hash = storage_hash or getattr(storage_table, "storage_hash", None)
-        storage_hash = storage_hash or getattr(storage_table, "physical_table_name", None)
-        if storage_hash in (None, ""):
+        table_name = getattr(storage_table, "physical_table_name", None)
+        if table_name in (None, ""):
             table = getattr(storage_table, "__table__", None)
-            storage_hash = getattr(table, "name", None)
-    return str(storage_hash) if isinstance(storage_hash, str) and storage_hash else None
+            table_name = getattr(table, "name", None)
+    return str(table_name) if isinstance(table_name, str) and table_name else None
 
 
 def _require_uid(obj: Any, object_name: str) -> str:
@@ -323,11 +317,16 @@ class UpdateRunner:
         # 3. Collect all UIDs in the dependency graph to fetch their metadata.
         # This correctly initializes the list, fixing the original bug.
         if not self.ts.depth_df.empty:
-            update_nodes_in_tree = self.ts.depth_df[
-                ["update_node_uid", "node_type", "update_hash", "remote_table_hash_id"]
-            ].to_dict("records")
+            dependency_columns = ["update_node_uid", "node_type", "update_hash"]
+            if "physical_table_name" in self.ts.depth_df.columns:
+                dependency_columns.append("physical_table_name")
+            elif "remote_table_hash_id" in self.ts.depth_df.columns:
+                dependency_columns.append("remote_table_hash_id")
+            update_nodes_in_tree = self.ts.depth_df[dependency_columns].to_dict("records")
             for update_node in update_nodes_in_tree:
                 update_node["uid"] = str(update_node.pop("update_node_uid"))
+                if "remote_table_hash_id" in update_node:
+                    update_node["physical_table_name"] = update_node.pop("remote_table_hash_id")
         else:
             update_nodes_in_tree = []
 
@@ -336,7 +335,7 @@ class UpdateRunner:
             {
                 "uid": _require_uid(self.ts.data_node_update, "DataNodeUpdate"),
                 "update_hash": self.ts.data_node_update.update_hash,
-                "remote_table_hash_id": _storage_hash(
+                "physical_table_name": _physical_table_name(
                     self.ts.local_persist_manager.storage_metadata
                 ),
                 "node_type": self.ts.data_node_update.NODE_TYPE,
@@ -900,9 +899,11 @@ class UpdateRunner:
                 f"Scheduler Head Update: {self.ts.update_hash}"
             ) as span:
                 span.set_attribute("time_serie_update_hash", self.ts.update_hash)
-                storage_hash = _storage_hash(self.ts.local_persist_manager.storage_metadata)
-                if storage_hash is not None:
-                    span.set_attribute("storage_hash", storage_hash)
+                physical_table_name = _physical_table_name(
+                    self.ts.local_persist_manager.storage_metadata
+                )
+                if physical_table_name is not None:
+                    span.set_attribute("physical_table_name", physical_table_name)
                 span.set_attribute("head_scheduler", self.scheduler.name)
 
                 # 3. Prepare the execution environment (Ray actors, dependency metadata)