mainsequence 4.4.25__tar.gz → 4.4.26__tar.gz

{mainsequence-4.4.25 → mainsequence-4.4.26}/PKG-INFO

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

{mainsequence-4.4.25 → mainsequence-4.4.26}/mainsequence/cli/migrations.py

@@ -260,6 +260,9 @@ def _contract_physical_table_name(item: Any) -> Any:
 
 
 def _contract_physical_schema(item: Any) -> Any:
+    physical_schema = _item_value(item, "physical_schema")
+    if physical_schema not in (None, ""):
+        return physical_schema
     contract = _item_value(item, "table_contract")
     if contract is None:
         return None
@@ -323,6 +326,7 @@ def _metatable_message(
         or model_name
     )
     uid = _item_value(item, "meta_table_uid") or _item_value(item, "uid")
+    physical_schema = _contract_physical_schema(item)
     physical_table_name = _item_value(item, "physical_table_name") or _contract_physical_table_name(
         item
     )
@@ -341,6 +345,8 @@ def _metatable_message(
         parts.append(f"model={model_name}")
     if uid not in (None, ""):
         parts.append(f"uid={uid}")
+    if physical_schema not in (None, ""):
+        parts.append(f"physical_schema={physical_schema}")
     if physical_table_name not in (None, ""):
         parts.append(f"physical_table={physical_table_name}")
     if provisioning_status not in (None, ""):

{mainsequence-4.4.25 → mainsequence-4.4.26}/mainsequence/client/metatables/core.py

@@ -229,6 +229,46 @@ def _normalize_contract_mapping(contract: Mapping[str, Any]) -> dict[str, Any]:
     return normalized
 
 
+def _contract_physical_mapping(contract: Any) -> Any:
+    if isinstance(contract, Mapping):
+        return contract.get("physical")
+    return getattr(contract, "physical", None)
+
+
+def _contract_physical_schema(contract: Any) -> str | None:
+    physical = _contract_physical_mapping(contract)
+    if isinstance(physical, Mapping):
+        value = (
+            physical.get("schema")
+            or physical.get("schema_")
+            or physical.get("physical_schema")
+        )
+    else:
+        value = getattr(physical, "schema_", None) or getattr(
+            physical,
+            "physical_schema",
+            None,
+        )
+    if value in (None, ""):
+        return None
+    return str(value)
+
+
+def _set_contract_physical_schema(contract: Any, schema: str) -> Any:
+    if isinstance(contract, Mapping):
+        normalized = dict(contract)
+        physical = normalized.get("physical")
+        physical_mapping = dict(physical) if isinstance(physical, Mapping) else {}
+        physical_mapping["schema"] = schema
+        normalized["physical"] = physical_mapping
+        return normalized
+
+    physical = getattr(contract, "physical", None)
+    if physical is not None and hasattr(physical, "schema_"):
+        physical.schema_ = schema
+    return contract
+
+
 def _temporal_parameter_names(parameters: dict[str, Any] | list[Any]) -> set[str]:
     if isinstance(parameters, Mapping):
         items = parameters.items()
@@ -246,8 +286,10 @@ class MetaTablePhysicalContract(BasePydanticModel):
         default=None,
         alias="schema",
         serialization_alias="schema",
-        exclude=True,
-        description=("Input-only schema alias. MetaTable uses the data source default schema."),
+        description=(
+            "Physical database schema. This is part of MetaTable physical identity "
+            "together with data_source_uid and table_name."
+        ),
     )
     table_name: str | None = Field(
         default=None,
@@ -257,7 +299,7 @@ class MetaTablePhysicalContract(BasePydanticModel):
         ),
     )
 
-    model_config = ConfigDict(populate_by_name=True)
+    model_config = ConfigDict(populate_by_name=True, serialize_by_alias=True)
 
 
 class MetaTableColumnContract(BasePydanticModel):
@@ -413,6 +455,10 @@ class MetaTableForeignKeyPayload(BasePydanticModel):
         None,
         description="Physical table name of the target MetaTable.",
     )
+    target_table_physical_schema: str | None = Field(
+        None,
+        description="Physical schema of the target MetaTable.",
+    )
     target_columns: list[str] = Field(
         default_factory=list,
         description="Target MetaTable physical column names.",
@@ -550,6 +596,14 @@ class MetaTableRequestFields(BasePydanticModel):
         ...,
         description="Public UID of the DynamicTableDataSource that owns this MetaTable.",
     )
+    physical_schema: str | None = Field(
+        None,
+        description=(
+            "Physical database schema. This is part of the MetaTable physical "
+            "identity and must match table_contract.physical.schema when both "
+            "are provided."
+        ),
+    )
     table_contract: MetaTableContract | dict[str, Any]
     identifier: str | None = Field(
         default=None,
@@ -575,6 +629,19 @@ class MetaTableRequestFields(BasePydanticModel):
     def _normalize_table_contract(self) -> MetaTableRequestFields:
         if isinstance(self.table_contract, Mapping):
             self.table_contract = _normalize_contract_mapping(self.table_contract)
+        contract_schema = _contract_physical_schema(self.table_contract)
+        if self.physical_schema not in (None, "") and contract_schema not in (None, ""):
+            if str(self.physical_schema) != str(contract_schema):
+                raise ValueError(
+                    "physical_schema must match table_contract.physical.schema."
+                )
+        if self.physical_schema in (None, "") and contract_schema not in (None, ""):
+            self.physical_schema = str(contract_schema)
+        elif self.physical_schema not in (None, "") and contract_schema in (None, ""):
+            self.table_contract = _set_contract_physical_schema(
+                self.table_contract,
+                str(self.physical_schema),
+            )
         return self
 
     @model_validator(mode="before")
@@ -713,6 +780,10 @@ class ManagedMetaTableFinalizeTableResult(BasePydanticModel):
         None,
         description="Physical table name reconciled against the data source.",
     )
+    physical_schema: str | None = Field(
+        None,
+        description="Physical schema reconciled against the data source.",
+    )
     previous_provisioning_status: str = Field(
         ...,
         description="Provisioning status before the finalize-managed attempt.",
@@ -1200,6 +1271,7 @@ class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, B
         "provisioning_status": ["exact", "in"],
         "schema_management_mode": ["exact", "in"],
         "migration_provider_key": ["exact", "in"],
+        "physical_schema": ["exact", "in"],
         "physical_table_name": ["exact", "contains", "in"],
         "labels": ["exact", "in", "contains"],
     }
@@ -1208,6 +1280,8 @@ class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, B
         "uid__in": "str",
         "data_source__uid": "uid",
         "data_source__uid__in": "uid",
+        "physical_schema": "str",
+        "physical_schema__in": "str",
         "labels": "str",
         "labels__in": "str",
         "labels__contains": "str",
@@ -1254,6 +1328,7 @@ class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, B
     migration_provider_key: str | None = None
     alembic_version_meta_table_uid: str | None = None
     alembic_revision: str | None = None
+    physical_schema: str | None = None
     physical_table_name: str
     table_contract: dict[str, Any] = Field(default_factory=dict)
     contract_version: str = "relational-table.v1"
@@ -1945,6 +2020,13 @@ class TimeIndexMetaTableRegistrationRequest(BasePydanticModel):
     model_config = ConfigDict(extra="forbid")
 
     data_source_uid: str = Field(..., description="Public uid of the storage data source")
+    physical_schema: str | None = Field(
+        None,
+        description=(
+            "Physical database schema. This must match table_contract.physical.schema "
+            "when both are provided."
+        ),
+    )
     identifier: str | None = Field(
         None,
         description=(
@@ -2027,6 +2109,23 @@ class TimeIndexMetaTableRegistrationRequest(BasePydanticModel):
         data["table_contract"] = normalized_contract
         return data
 
+    @model_validator(mode="after")
+    def _normalize_physical_schema(self) -> TimeIndexMetaTableRegistrationRequest:
+        contract_schema = _contract_physical_schema(self.table_contract)
+        if self.physical_schema not in (None, "") and contract_schema not in (None, ""):
+            if str(self.physical_schema) != str(contract_schema):
+                raise ValueError(
+                    "physical_schema must match table_contract.physical.schema."
+                )
+        if self.physical_schema in (None, "") and contract_schema not in (None, ""):
+            self.physical_schema = str(contract_schema)
+        elif self.physical_schema not in (None, "") and contract_schema in (None, ""):
+            self.table_contract = _set_contract_physical_schema(
+                self.table_contract,
+                str(self.physical_schema),
+            )
+        return self
+
     @field_validator("cadence")
     @classmethod
     def _normalize_cadence(cls, value: str | None) -> str | None:
@@ -3025,6 +3124,7 @@ class TimeIndexMetaTable(MetaTable):
         "uid": ["in", "exact"],
         "data_source__uid": ["in", "exact"],
         "namespace": ["exact", "contains", "in", "isnull"],
+        "physical_schema": ["exact", "in"],
         "physical_table_name": ["exact", "contains", "in"],
         "labels": ["exact", "in", "contains"],
     }
@@ -3033,6 +3133,8 @@ class TimeIndexMetaTable(MetaTable):
         "uid__in": "uid",
         "data_source__uid": "uid",
         "data_source__uid__in": "uid",
+        "physical_schema": "str",
+        "physical_schema__in": "str",
         "labels": "str",
         "labels__in": "str",
         "labels__contains": "str",

{mainsequence-4.4.25 → mainsequence-4.4.26}/mainsequence/meta_tables/data_nodes/data_nodes.py

@@ -134,6 +134,8 @@ class DataAccessMixin:
 
 
 class APIDataNode(DataAccessMixin):
+    LEGACY_DEFAULT_PHYSICAL_SCHEMA = "public"
+
     @staticmethod
     def _require_data_source_uid(data_source: Any, *, context: str) -> str:
         if isinstance(data_source, dict):
@@ -172,6 +174,24 @@ class APIDataNode(DataAccessMixin):
             raise ValueError(f"{context} requires storage_table.physical_table_name.")
         return str(table_name)
 
+    @classmethod
+    def _storage_table_physical_schema(cls, storage_table: Any) -> str:
+        if isinstance(storage_table, dict):
+            physical_schema = storage_table.get("physical_schema")
+            table_contract = storage_table.get("table_contract")
+        else:
+            physical_schema = getattr(storage_table, "physical_schema", None)
+            table_contract = getattr(storage_table, "table_contract", None)
+        if physical_schema not in (None, ""):
+            return str(physical_schema)
+        if isinstance(table_contract, dict):
+            physical = table_contract.get("physical") or {}
+            if isinstance(physical, dict):
+                contract_schema = physical.get("schema") or physical.get("schema_")
+                if contract_schema not in (None, ""):
+                    return str(contract_schema)
+        return cls.LEGACY_DEFAULT_PHYSICAL_SCHEMA
+
     @classmethod
     def build_from_local_time_serie(cls, source_table: "DataNodeUpdate") -> "APIDataNode":
         physical_table_name = getattr(source_table, "physical_table_name", None) or getattr(
@@ -202,6 +222,7 @@ class APIDataNode(DataAccessMixin):
                 storage_table,
                 context=context,
             ),
+            physical_schema=cls._storage_table_physical_schema(storage_table),
             physical_table_name=cls._require_physical_table_name(
                 storage_table,
                 context=context,
@@ -215,22 +236,55 @@ class APIDataNode(DataAccessMixin):
         return cls.build_from_meta_table(storage_table)
 
     @classmethod
-    def build_from_table_name(cls, table_name: str) -> "APIDataNode":
+    def build_from_physical_identity(
+        cls,
+        *,
+        schema: str,
+        table_name: str,
+        data_source_uid: str | None = None,
+    ) -> "APIDataNode":
+        if schema in (None, ""):
+            raise ValueError("APIDataNode.build_from_physical_identity requires schema.")
+        filters = {
+            "physical_schema": str(schema),
+            "physical_table_name": table_name,
+        }
+        if data_source_uid not in (None, ""):
+            filters["data_source__uid"] = str(data_source_uid)
         storage_table = TimeIndexMetaTable.get_or_none(
-            physical_table_name=table_name,
+            **filters,
         )
         if storage_table is None:
             raise DoesNotExist(
                 "No TimeIndexMetaTable found matching "
-                f"{{'physical_table_name': {table_name!r}}}"
+                f"{{'physical_schema': {schema!r}, 'physical_table_name': {table_name!r}}}"
             )
         return cls.build_from_meta_table(storage_table)
 
+    @classmethod
+    def build_from_table_name(
+        cls,
+        table_name: str,
+        *,
+        schema: str = LEGACY_DEFAULT_PHYSICAL_SCHEMA,
+        data_source_uid: str | None = None,
+    ) -> "APIDataNode":
+        logger.warning(
+            "APIDataNode.build_from_table_name is ambiguous across schemas; "
+            "use build_from_physical_identity(schema=..., table_name=...) instead."
+        )
+        return cls.build_from_physical_identity(
+            schema=schema,
+            table_name=table_name,
+            data_source_uid=data_source_uid,
+        )
+
     def __init__(
         self,
         data_source_uid: str,
         physical_table_name: str | None = None,
         *,
+        physical_schema: str | None = None,
         storage_hash: str | None = None,
         data_source_local_lake: DataSource | None = None,
         storage_table: MetaTable | None = None,
@@ -255,6 +309,7 @@ class APIDataNode(DataAccessMixin):
         if resolved_physical_table_name in (None, ""):
             raise ValueError("APIDataNode requires physical_table_name.")
         self.data_source_uid = str(data_source_uid)
+        self.physical_schema = str(physical_schema or self.LEGACY_DEFAULT_PHYSICAL_SCHEMA)
         self.physical_table_name = str(resolved_physical_table_name)
         self.storage_table = storage_table
         self.data_source = data_source_local_lake
@@ -321,6 +376,7 @@ class APIDataNode(DataAccessMixin):
         self._verify_local_data_source()
         self._local_persist_manager = APIPersistManager(
             physical_table_name=self.physical_table_name,
+            physical_schema=self.physical_schema,
             data_source_uid=self.data_source_uid,
         )
         storage_table = self._local_persist_manager.storage_table

{mainsequence-4.4.25 → mainsequence-4.4.26}/mainsequence/meta_tables/data_nodes/persist_managers.py

@@ -31,10 +31,13 @@ from mainsequence.meta_tables import PlatformTimeIndexMetaTable, compute_metatab
 from .. import future_registry
 
 _STORAGE_TABLE_LOOKUP_LIMIT = 20
+_LEGACY_POSTGRES_SCHEMA = "public"
 
 
 @dataclass(frozen=True)
 class _StorageTableLookupResult:
+    data_source_uid: str | None
+    physical_schema: str | None
     table_name: str | None
     filters: dict[str, Any]
     matches: list[TimeIndexMetaTable]
@@ -144,21 +147,51 @@ def _registered_storage_table_lookup(
     storage_table: type[PlatformTimeIndexMetaTable],
 ) -> _StorageTableLookupResult:
     table_name = _storage_table_physical_table_name(storage_table)
-    if table_name:
+    physical_schema = _storage_table_physical_schema(storage_table)
+    data_source_uid = storage_table.get_data_source_uid()
+    if table_name and physical_schema and data_source_uid:
         filters = {
+            "data_source__uid": data_source_uid,
+            "physical_schema__in": [physical_schema],
             "physical_table_name__in": [table_name],
             "limit": _STORAGE_TABLE_LOOKUP_LIMIT,
         }
-        matches = TimeIndexMetaTable.filter_by_body(
-            **filters,
-        )
+        raw_matches = TimeIndexMetaTable.filter_by_body(**filters)
+        matches = [
+            match
+            for match in raw_matches
+            if _time_index_meta_table_identity(match)
+            == (data_source_uid, physical_schema, table_name)
+        ]
         return _StorageTableLookupResult(
+            data_source_uid=data_source_uid,
+            physical_schema=physical_schema,
             table_name=table_name,
             filters=filters,
             matches=matches,
         )
 
-    return _StorageTableLookupResult(table_name=None, filters={}, matches=[])
+    return _StorageTableLookupResult(
+        data_source_uid=data_source_uid,
+        physical_schema=physical_schema,
+        table_name=table_name,
+        filters={},
+        matches=[],
+    )
+
+
+def _storage_table_physical_schema(
+    storage_table: type[PlatformTimeIndexMetaTable],
+) -> str | None:
+    schema_getter = getattr(storage_table, "get_physical_schema", None)
+    physical_schema = schema_getter() if callable(schema_getter) else None
+    if physical_schema not in (None, ""):
+        return str(physical_schema)
+    table = getattr(storage_table, "__table__", None)
+    table_schema = getattr(table, "schema", None)
+    if table_schema not in (None, ""):
+        return str(table_schema)
+    return _LEGACY_POSTGRES_SCHEMA
 
 
 def _storage_table_physical_table_name(
@@ -175,8 +208,9 @@ def _storage_table_physical_table_name(
 
 
 def _storage_table_lookup_label(storage_table: type[PlatformTimeIndexMetaTable]) -> str:
+    physical_schema = _storage_table_physical_schema(storage_table) or "<unknown-schema>"
     table_name = _storage_table_physical_table_name(storage_table) or "<unknown-table>"
-    return f"{storage_table.__name__}(table={table_name})"
+    return f"{storage_table.__name__}(schema={physical_schema}, table={table_name})"
 
 
 def _unbound_storage_table_message(
@@ -204,6 +238,16 @@ def _unbound_storage_table_message(
             f"{message} The SDK could not determine a physical table name from "
             "the storage model, so no backend catalog lookup was possible."
         )
+    if lookup_result.physical_schema is None:
+        return (
+            f"{message} The SDK could not determine a physical schema from "
+            "the storage model, so no backend catalog lookup was possible."
+        )
+    if lookup_result.data_source_uid is None:
+        return (
+            f"{message} The SDK could not determine a data-source UID from "
+            "the storage model, so no backend catalog lookup was possible."
+        )
 
     filters = _format_lookup_filters(lookup_result.filters)
     match_count = len(lookup_result.matches)
@@ -248,6 +292,12 @@ def _storage_table_identity_summary(storage_table: type[PlatformTimeIndexMetaTab
     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}")
+    physical_schema = _storage_table_physical_schema(storage_table)
+    if physical_schema not in (None, ""):
+        parts.append(f"physical_schema={physical_schema!r}")
+    table_name = _storage_table_physical_table_name(storage_table)
+    if table_name not in (None, ""):
+        parts.append(f"physical_table_name={table_name!r}")
     if not parts:
         return "Storage identity is incomplete."
     return "Storage identity: " + ", ".join(parts) + "."
@@ -262,6 +312,7 @@ def _time_index_meta_table_candidate_summary(meta_table: TimeIndexMetaTable) ->
     for attr in (
         "uid",
         "data_source_uid",
+        "physical_schema",
         "identifier",
         "physical_table_name",
         "provisioning_status",
@@ -272,6 +323,35 @@ def _time_index_meta_table_candidate_summary(meta_table: TimeIndexMetaTable) ->
     return "{" + ", ".join(parts) + "}" if parts else "{unidentified TimeIndexMetaTable}"
 
 
+def _time_index_meta_table_identity(
+    meta_table: TimeIndexMetaTable,
+) -> tuple[str, str, str] | None:
+    data_source_uid = getattr(meta_table, "data_source_uid", None)
+    if data_source_uid in (None, ""):
+        data_source = getattr(meta_table, "data_source", None)
+        if isinstance(data_source, dict):
+            data_source_uid = data_source.get("uid") or data_source.get("data_source_uid")
+        else:
+            data_source_uid = getattr(data_source, "uid", None) or getattr(
+                data_source,
+                "data_source_uid",
+                None,
+            )
+    physical_schema = getattr(meta_table, "physical_schema", None)
+    if physical_schema in (None, ""):
+        table_contract = getattr(meta_table, "table_contract", None)
+        if isinstance(table_contract, dict):
+            physical = table_contract.get("physical") or {}
+            if isinstance(physical, dict):
+                physical_schema = physical.get("schema") or physical.get("schema_")
+    if physical_schema in (None, ""):
+        physical_schema = _LEGACY_POSTGRES_SCHEMA
+    table_name = getattr(meta_table, "physical_table_name", None)
+    if data_source_uid in (None, "") or table_name in (None, ""):
+        return None
+    return str(data_source_uid), str(physical_schema), str(table_name)
+
+
 class BasePersistManager:
     UPDATE_CLASS: ClassVar[type[Any] | None] = None
     UPDATE_DETAILS_CLASS: ClassVar[type[Any] | None] = None
@@ -420,10 +500,12 @@ class BasePersistManager:
                 )
                 if result is None:
                     meta_table_uid = self.storage_table.get_meta_table_uid()
+                    physical_schema = _storage_table_physical_schema(self.storage_table)
                     physical_table_name = _storage_table_physical_table_name(self.storage_table)
                     self.logger.warning(
                         f"DataNodeUpdate {self.update_hash} for MetaTable {meta_table_uid} "
-                        f"(physical_table_name={physical_table_name}) not found in backend"
+                        f"(physical_schema={physical_schema}, "
+                        f"physical_table_name={physical_table_name}) not found in backend"
                     )
                 new_future.set_result(result)
             except Exception as exc:
@@ -650,15 +732,20 @@ class APIPersistManager:
         self,
         *,
         physical_table_name: str | None = None,
+        physical_schema: 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.physical_schema: str = str(physical_schema or _LEGACY_POSTGRES_SCHEMA)
         self.physical_table_name: str | None = physical_table_name or storage_hash
 
-        logger.debug(f"Initializing Time Serie {self.physical_table_name} as APIDataNode")
+        logger.debug(
+            "Initializing APIDataNode storage "
+            f"{self.physical_schema}.{self.physical_table_name}"
+        )
 
         self._storage_table_future = Future()
         future_registry.add_future(self._storage_table_future)
@@ -678,6 +765,7 @@ class APIPersistManager:
     def _init_storage_table(self) -> None:
         try:
             result = TimeIndexMetaTable.get_or_none(
+                physical_schema=self.physical_schema,
                 physical_table_name=self.physical_table_name,
                 data_source__uid=self.data_source_uid,
             )