mainsequence 4.1.19__tar.gz → 4.2.2__tar.gz

{mainsequence-4.1.19/mainsequence.egg-info → mainsequence-4.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.1.19
+Version: 4.2.2
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement
@@ -63,6 +63,7 @@ Requires-Dist: opentelemetry-exporter-otlp
 Requires-Dist: opentelemetry-sdk
 Requires-Dist: pandas
 Requires-Dist: psutil
+Requires-Dist: psycopg2>=2.9.12
 Requires-Dist: pydantic
 Requires-Dist: pytz
 Requires-Dist: pyyaml

{mainsequence-4.1.19 → mainsequence-4.2.2}/agent_scaffold/skills/data_publishing/data_nodes/SKILL.md

@@ -182,20 +182,14 @@ class PricesTable(PlatformTimeIndexMetaData, Base):
     )
 ```
 
-Storage registration is inferred from the class metadata and active Main
-Sequence project/session. The DataNode constructor ensures the output
-`storage_table` is registered when needed. You may still call it explicitly
-during bootstrap when code needs the returned metadata object:
+Storage registration is migration-first. Add the storage model to the
+MetaTable migration provider and run `mainsequence migrations upgrade --provider
+... --to head`. Do not call `PricesTable.register()` directly and do not rely on
+DataNode construction to register storage tables.
 
-```python
-PricesTable.register()
-```
-
-`PlatformTimeIndexMetaData.register()` is the storage lifecycle path.
-Treat them as idempotent get-or-create operations: the platform returns the
-registered metadata and UID, and the SDK records that metadata on the class. Do
-not manually attach an existing UID, reconstruct a generic `MetaTable`, or use
-manual bind helpers as an authoring step.
+`PlatformTimeIndexMetaData.register()` remains SDK plumbing for the migration
+workflow. Do not manually attach an existing UID, reconstruct a generic
+`MetaTable`, or use manual bind helpers as an authoring step.
 
 ### 2. Keep DataNode As Update Logic
 
@@ -206,17 +200,16 @@ The DataNode constructor should accept:
 - optional `hash_namespace`
 
 The constructor `storage_table` is the output storage contract. Keep it out of
-`DataNodeConfiguration`. Do not pre-register this output storage class just to
-construct the node; `DataNode` and `PersistManager` call the SDK registration
-lifecycle automatically when the class is not yet bound.
+`DataNodeConfiguration`. The storage class must already be registered by the
+migration workflow before the node is constructed or run.
 
 If the DataNode needs to select another DataNode's storage table as a
 dependency, put that dependency storage reference in the config as
 `type[PlatformTimeIndexMetaData]`. Do not add an extra constructor argument for
 dependency storage tables. Config values of this type are hashed by the bound
 `TimeIndexMetaData.uid` from `StorageClass.__time_index_metadata__`. If the
-class is not yet bound, the config serializer calls `StorageClass.register()`
-before reading the UID.
+class is not yet bound, config serialization must fail and tell the user to run
+the migration workflow.
 
 Do not accept `test_node`. It has been removed. Use explicit
 `hash_namespace(...)` or `hash_namespace="..."`.
@@ -398,10 +391,10 @@ Do not ask users to name these foreign keys. `MetaTableForeignKey(...)` derives
 a stable contract name when `name` is omitted; `name=...` is only for deliberate
 overrides.
 
-Registration of the storage class follows the MetaTable lifecycle:
-`register()` recursively registers unresolved FK target model classes, uses the
-local process registry keyed by `storage_hash`, and writes the target
-`MetaTable.uid` into the FK contract.
+Registration of the storage class follows the MetaTable migration lifecycle.
+Migration tooling recursively resolves/registers unresolved FK target model
+classes, uses the local process registry keyed by `storage_hash`, and writes the
+target `MetaTable.uid` into the FK contract.
 
 Do not add DataNode configuration fields just to mutate storage metadata.
 

{mainsequence-4.1.19 → mainsequence-4.2.2}/agent_scaffold/skills/data_publishing/meta_tables/SKILL.md

@@ -95,6 +95,29 @@ For every non-trivial task, decide:
 
 ## Build Rules
 
+### 0. Creation And Deletion Are SDK-Managed
+
+Do not build custom migrations for creating or deleting MetaTables.
+
+MetaTable creation and deletion are handled through `mainsequence-sdk` and the
+Main Sequence CLI. Assistants should define the SQLAlchemy MetaTable model,
+select the SDK migration provider when schema evolution is needed, and use the
+documented `mainsequence migrations ...` commands.
+
+Do not hand-author create/delete migration files, backend migration payloads,
+manifest rows, registry rows, or low-level SDK migration requests for MetaTable
+creation or deletion.
+
+The only migration workflow to recommend is the Main Sequence CLI lifecycle:
+
+```bash
+mainsequence migrations current --provider mainsequence_migrations:migration
+mainsequence migrations revision --provider mainsequence_migrations:migration
+mainsequence migrations render --provider mainsequence_migrations:migration --to head
+mainsequence migrations upgrade --provider mainsequence_migrations:migration --to head --dry-run
+mainsequence migrations upgrade --provider mainsequence_migrations:migration --to head
+```
+
 ### 1. SQLAlchemy metadata is the authoring source
 
 Keep the application table model as the authoring source for the neutral table contract.
@@ -161,15 +184,18 @@ class Account(PlatformManagedMetaTable, Base):
         },
     )
 
-
-account_meta_table = Account.register()
 ```
 
-Registration metadata belongs on the class. Do not pass description, labels,
-provisioning, data-source UID, hash namespace, time-index fields, or storage
-layout into `register()`.
+Registration metadata belongs on the class. Do not call `Account.register()`
+directly for platform-managed models. Add platform-managed models to the
+selected `AlembicMetaTableMigration.metatable_models` list and let
+`mainsequence migrations upgrade --provider ... --to head` resolve/register and
+bind them.
 
-For platform-managed registration, the data source is resolved from the active Main Sequence project/session, the same way DataNode does. Do not require or thread a `data_source_uid` through normal platform-managed example code.
+For platform-managed migration registration, the data source is resolved from
+the active Main Sequence project/session, the same way DataNode does. Do not
+require or thread a `data_source_uid` through normal platform-managed example
+code.
 
 Only call `build_registration_request()` when the task explicitly needs to inspect or validate the payload before registration.
 
@@ -183,7 +209,8 @@ Do not add an environment variable for namespace in examples.
 
 Do not add generic labels such as `"meta-table"` or `"platform-managed"` to examples. Keep labels specific to the example or domain.
 
-Do not add a `MAINSEQUENCE_META_TABLE_REGISTER` toggle in registration examples. Registration examples should register directly.
+Do not add a `MAINSEQUENCE_META_TABLE_REGISTER` toggle in platform-managed
+examples. Platform-managed examples should be migration-first.
 
 ### 3. Register parent tables before child tables
 
@@ -192,8 +219,8 @@ Foreign-key contracts reference the target `MetaTable` UID.
 For `PlatformManagedMetaTable`, define foreign keys with
 `MetaTableForeignKey(TargetModel, column=...)`. Do not write raw SQLAlchemy
 table fullnames, `Parent.__table__.c.<column>` targets, or explicit target UID
-maps in the platform-managed path. Registration is the lifecycle path:
-`register()` recursively registers unresolved target model classes, stores each
+maps in the platform-managed path. Migration is the lifecycle path. Migration
+tooling resolves/registers unresolved target model classes, stores each
 returned `MetaTable` in a local process registry keyed by `storage_hash`, and
 uses the target `MetaTable.uid` in the child FK contract.
 
@@ -215,16 +242,19 @@ account_uid: Mapped[uuid.UUID] = mapped_column(
 Every participating table must include `__metatable_description__` describing
 both the schema and the table's intention.
 
-Example registration order:
+Provider scope:
 
 ```python
-asset_meta_table = Asset.register()
+migration = AlembicMetaTableMigration(
+    ...,
+    metatable_models=[Account, Asset],
+)
 ```
 
-The child registration registers `Account` first if it has not already been
-registered in the current process. The local registry prevents duplicate backend
-registration attempts for the same `storage_hash` and raises a clear error for
-recursive registration cycles.
+Migration tooling registers `Account` first if `Asset` depends on it and it has
+not already been bound in the current process. The local registry prevents
+duplicate backend registration attempts for the same `storage_hash` and raises
+a clear error for recursive registration cycles.
 
 For `external_registered`, there is no platform-managed parent lookup. Register
 the parent first, then build the child registration request with
@@ -278,17 +308,25 @@ migration request models, or use SDK helper functions directly. The backend
 request shape is reference material in the tutorial; the user-facing path is:
 
 ```bash
-mainsequence migrations register-version-table --provider mainsequence_migrations:migration
-mainsequence migrations revision --provider mainsequence_migrations:migration --autogenerate -m "change"
+mainsequence migrations current --provider mainsequence_migrations:migration
+mainsequence migrations revision --provider mainsequence_migrations:migration
 mainsequence migrations render --provider mainsequence_migrations:migration --to head
 mainsequence migrations upgrade --provider mainsequence_migrations:migration --to head --dry-run
 mainsequence migrations upgrade --provider mainsequence_migrations:migration --to head
 ```
 
+`current` and `upgrade` automatically register the provider's
+`AlembicVersionMetaTable` binding when backend migration state is needed.
+`revision` accepts optional `-m/--message`; if omitted, the CLI uses
+`migration`. `revision --autogenerate` is optional and requires an explicit
+`--sqlalchemy-url` for the baseline database.
+
 The SQL must be Alembic-rendered from the selected provider. After SQL apply
 succeeds, register or refresh only the application MetaTable catalog bindings
-listed in `migration.metatable_models`. A migration is not complete until both
-backend SQL execution and catalog sync succeed.
+listed in `migration.metatable_models`. Do not pass the Alembic version-table
+data source into those application model registrations; each model uses its
+own normal MetaTable data-source binding. A migration is not complete until
+both backend SQL execution and catalog sync succeed.
 
 Do not use SDK-managed migration artifact tables, artifact sync helpers, or custom
 `operations()` migration modules.

{mainsequence-4.1.19 → mainsequence-4.2.2}/mainsequence/cli/migrations.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import dataclasses
 import json
+import re
+from collections.abc import Callable, Mapping
 from typing import Any
 
 import click
@@ -66,26 +68,67 @@ def _registry_uid(migration: AlembicMetaTableMigration) -> str:
     uid = migration.alembic_registry.get_meta_table_uid()
     if uid in (None, ""):
         raise typer.BadParameter(
-            "Alembic registry MetaTable UID is not bound. Run register-version-table "
-            "or set __metatable_uid__ on the registry class.",
+            "Alembic registry MetaTable UID is not bound. Run current or upgrade "
+            "to auto-register the registry, or set __metatable_uid__ on the registry class.",
             param_hint="--provider",
         )
     return str(uid)
 
 
+def _model_reference(model: type[Any]) -> str:
+    module = getattr(model, "__module__", None)
+    qualname = getattr(model, "__qualname__", None)
+    if module and qualname:
+        return f"{module}.{qualname}"
+    return repr(model)
+
+
+def _meta_table_value(meta_table: Any, *names: str) -> Any:
+    if isinstance(meta_table, Mapping):
+        for name in names:
+            value = meta_table.get(name)
+            if value not in (None, ""):
+                return value
+        return None
+    for name in names:
+        value = getattr(meta_table, name, None)
+        if value not in (None, ""):
+            return value
+    return None
+
+
+def _print_metatable_resolution_callback(
+    migration: AlembicMetaTableMigration,
+) -> Callable[[type[Any], str, str, Any | None], None]:
+    def _print(model: type[Any], identifier: str, status: str, meta_table: Any | None) -> None:
+        fields = [
+            f"identifier={identifier}",
+            f"model={_model_reference(model)}",
+            f"package={migration.package}",
+            f"migration_namespace={migration.migration_namespace}",
+        ]
+        uid = _meta_table_value(meta_table, "uid", "meta_table_uid")
+        if uid is not None:
+            fields.append(f"uid={uid}")
+        physical_table_name = _meta_table_value(meta_table, "physical_table_name")
+        if physical_table_name is not None:
+            fields.append(f"physical_table_name={physical_table_name}")
+        typer.echo(f"migration MetaTable {status}: " + " ".join(fields), err=True)
+
+    return _print
+
+
 def _ensure_registry(
     migration: AlembicMetaTableMigration,
     *,
-    data_source_uid: str | None,
     timeout: float | None,
 ) -> None:
-    migration.ensure_alembic_registry(data_source_uid=data_source_uid, timeout=timeout)
+    migration.ensure_alembic_registry(timeout=timeout)
 
 
 def _status_request(migration: AlembicMetaTableMigration) -> AlembicMigrationStatusRequest:
     return AlembicMigrationStatusRequest(
         alembic_version_meta_table_uid=_registry_uid(migration),
-        data_source_uid=migration.resolve_data_source_uid(),
         package=migration.package,
         migration_namespace=migration.migration_namespace,
     )
@@ -117,7 +160,6 @@ def _operation(
 ) -> AlembicMigrationOperation:
     return AlembicMigrationOperation(
         alembic_version_meta_table_uid=_registry_uid(migration),
-        data_source_uid=migration.resolve_data_source_uid(),
         package=migration.package,
         migration_namespace=migration.migration_namespace,
         revision=str(artifact.manifest["revision"]),
@@ -152,39 +194,35 @@ def _alembic_config(
     return config
 
 
-@migrations.command("register-version-table")
-def register_version_table(
-    provider: str | None = typer.Option(
-        None,
-        "--provider",
-        help="Migration provider reference, for example msm.migrations:migration.",
-    ),
-    data_source_uid: str | None = typer.Option(
-        None,
-        "--data-source-uid",
-        help="Explicit override for cross-data-source workflows.",
-    ),
-    timeout: float | None = typer.Option(None, "--timeout"),
-    json_output: bool = typer.Option(False, "--json", help="Emit JSON."),
-) -> None:
-    """Register the provider's Alembic version table as an external MetaTable."""
+def _next_sequential_revision_id(migration: AlembicMetaTableMigration) -> str:
+    try:
+        from alembic.script import ScriptDirectory
+    except ImportError as exc:
+        raise RuntimeError("Alembic is required for revision generation.") from exc
 
-    migration = _load_migration(provider)
-    meta_table = migration.register_alembic_registry(
-        data_source_uid=data_source_uid,
-        timeout=timeout,
-    )
-    _emit(
-        {
-            "uid": migration.alembic_registry.get_meta_table_uid()
-            or getattr(meta_table, "uid", None),
-            "data_source_uid": migration.alembic_registry.get_data_source_uid(),
-            "alembic_version_table": migration.alembic_version_table,
-            "package": migration.package,
-            "migration_namespace": migration.migration_namespace,
-        },
-        json_output=json_output,
+    script = ScriptDirectory.from_config(
+        _alembic_config(migration, sqlalchemy_url="postgresql://")
     )
+    heads = list(script.get_heads())
+    if len(heads) > 1:
+        raise typer.BadParameter(
+            "Sequential revision IDs require a single Alembic head. Pass --rev-id "
+            "explicitly for branched histories.",
+            param_hint="--rev-id",
+        )
+    if heads and not re.fullmatch(r"\d{4,}", str(heads[0])):
+        raise typer.BadParameter(
+            "Sequential revision IDs require the current Alembic head to be numeric. "
+            "Pass --rev-id explicitly for non-numeric histories.",
+            param_hint="--rev-id",
+        )
+
+    numeric_revisions: list[int] = []
+    for revision in script.walk_revisions():
+        revision_id = str(revision.revision)
+        if re.fullmatch(r"\d{4,}", revision_id):
+            numeric_revisions.append(int(revision_id))
+    return f"{max(numeric_revisions, default=0) + 1:04d}"
 
 
 @migrations.command("current")
@@ -194,26 +232,30 @@ def current(
         "--provider",
         help="Migration provider reference, for example msm.migrations:migration.",
     ),
-    data_source_uid: str | None = typer.Option(
-        None,
-        "--data-source-uid",
-        help="Explicit override for cross-data-source workflows.",
-    ),
     timeout: float | None = typer.Option(None, "--timeout"),
     json_output: bool = typer.Option(False, "--json", help="Emit JSON."),
 ) -> None:
     """Read current Alembic revision through the provider's registry MetaTable."""
 
     migration = _load_migration(provider)
-    _ensure_registry(migration, data_source_uid=data_source_uid, timeout=timeout)
+    _ensure_registry(migration, timeout=timeout)
     status = MetaTable.get_migration_status(_status_request(migration), timeout=timeout)
     _emit(status, json_output=json_output)
 
 
 @migrations.command("revision")
 def revision(
-    message: str = typer.Option(..., "--message", "-m", help="Alembic revision message."),
-    autogenerate: bool = typer.Option(False, "--autogenerate", help="Use Alembic autogenerate."),
+    message: str | None = typer.Option(
+        None,
+        "--message",
+        "-m",
+        help="Alembic revision message. Defaults to 'migration'.",
+    ),
+    autogenerate: bool = typer.Option(
+        False,
+        "--autogenerate",
+        help="Use Alembic autogenerate. Requires --sqlalchemy-url.",
+    ),
     provider: str | None = typer.Option(
         None,
         "--provider",
@@ -221,10 +263,10 @@ def revision(
     ),
     rev_id: str | None = typer.Option(None, "--rev-id", help="Explicit Alembic revision id."),
     head: str = typer.Option("head", "--head", help="Alembic head to base the revision on."),
-    sqlalchemy_url: str = typer.Option(
-        "postgresql://",
+    sqlalchemy_url: str | None = typer.Option(
+        None,
         "--sqlalchemy-url",
-        help="SQLAlchemy URL passed to the Alembic environment.",
+        help="SQLAlchemy URL passed to the Alembic environment. Required for --autogenerate.",
     ),
     json_output: bool = typer.Option(False, "--json", help="Emit JSON."),
 ) -> None:
@@ -236,11 +278,19 @@ def revision(
         raise typer.BadParameter("Alembic is required for revision generation.") from exc
 
     migration = _load_migration(provider)
+    resolved_message = (message or "").strip() or "migration"
+    if autogenerate and not sqlalchemy_url:
+        raise typer.BadParameter(
+            "--sqlalchemy-url is required with --autogenerate because Alembic "
+            "must connect to a baseline database to compute the diff.",
+            param_hint="--sqlalchemy-url",
+        )
+    resolved_rev_id = rev_id or _next_sequential_revision_id(migration)
     script = command.revision(
-        _alembic_config(migration, sqlalchemy_url=sqlalchemy_url),
-        message=message,
+        _alembic_config(migration, sqlalchemy_url=sqlalchemy_url or "postgresql://"),
+        message=resolved_message,
         autogenerate=autogenerate,
-        rev_id=rev_id,
+        rev_id=resolved_rev_id,
         head=head,
     )
     _emit(
@@ -284,6 +334,9 @@ def render(
     migration = _load_migration(provider)
     if direction not in {"upgrade", "downgrade"}:
         raise typer.BadParameter("direction must be 'upgrade' or 'downgrade'.")
+    migration.resolve_or_register_metatable_models(
+        on_metatable_resolution=_print_metatable_resolution_callback(migration),
+    )
     artifact = _render_artifact(
         migration,
         target_revision=target_revision,
@@ -305,11 +358,6 @@ def upgrade(
         "--provider",
         help="Migration provider reference, for example msm.migrations:migration.",
     ),
-    data_source_uid: str | None = typer.Option(
-        None,
-        "--data-source-uid",
-        help="Explicit override for cross-data-source workflows.",
-    ),
     dry_run: bool = typer.Option(False, "--dry-run", help="Validate without executing SQL."),
     sqlalchemy_url: str = typer.Option(
         "postgresql://",
@@ -322,7 +370,11 @@ def upgrade(
     """Dry-run or apply an Alembic-rendered SQL artifact through the backend."""
 
     migration = _load_migration(provider)
-    _ensure_registry(migration, data_source_uid=data_source_uid, timeout=timeout)
+    _ensure_registry(migration, timeout=timeout)
+    migration.resolve_or_register_metatable_models(
+        timeout=timeout,
+        on_metatable_resolution=_print_metatable_resolution_callback(migration),
+    )
     status = MetaTable.get_migration_status(_status_request(migration), timeout=timeout)
     current_revision = status.current_revision
     artifact = _render_artifact(

{mainsequence-4.1.19 → mainsequence-4.2.2}/mainsequence/client/metatables/core.py

@@ -1102,6 +1102,25 @@ class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, B
         *,
         timeout: int | float | tuple[float, float] | None = None,
     ) -> dict[str, Any]:
+        """
+        Refresh this MetaTable's physical database shape snapshot.
+
+        This calls the backend ``POST /meta_table/<uid>/introspect/`` action.
+        The backend reads the real physical table through the MetaTable's data
+        source, reflects columns, indexes, and constraints, stores that data on
+        ``MetaTable.introspection_snapshot``, and returns the full response.
+
+        This method is intended for admin, debugging, and reconciliation
+        workflows. Use it when a client needs to inspect what the database
+        currently has, diagnose catalog/physical drift, or refresh metadata
+        after an out-of-band DDL change. It is not required for normal reads,
+        writes, registration, or migration-first application startup.
+
+        Returns:
+            Backend response containing ``ok``, ``meta_table_uid``, and
+            ``introspection_snapshot``. When the snapshot is an object, this
+            instance's ``introspection_snapshot`` attribute is updated in place.
+        """
         response_json = self._post_detail_action("introspect", timeout=timeout)
         snapshot = response_json.get("introspection_snapshot")
         if isinstance(snapshot, dict):
@@ -1653,12 +1672,15 @@ class DataNodeUpdate(TableUpdateNode, BaseObjectOrm):
     FILTERSET_FIELDS: ClassVar[dict[str, list[str]]] = {
         "uid": ["in", "exact"],
         "update_hash": ["exact"],
+        "remote_table__uid": ["exact", "in"],
         "remote_table__data_source__uid": ["exact", "in"],
         "related_table__namespace": ["contains", "in", "isnull"],
     }
     FILTER_VALUE_NORMALIZERS: ClassVar[dict[str, str]] = {
         "uid": "uid",
         "uid__in": "uid",
+        "remote_table__uid": "uid",
+        "remote_table__uid__in": "uid",
         "remote_table__data_source__uid": "uid",
         "remote_table__data_source__uid__in": "uid",
     }

{mainsequence-4.1.19 → mainsequence-4.2.2}/mainsequence/client/metatables/migrations.py

@@ -25,7 +25,6 @@ class AlembicMigrationError(BasePydanticModel):
 class AlembicMigrationOperation(BasePydanticModel):
     version: AlembicMigrationVersion = ALEMBIC_MIGRATION_V1
     alembic_version_meta_table_uid: str
-    data_source_uid: str
     package: str = ""
     migration_namespace: str = ""
     revision: str
@@ -42,7 +41,6 @@ class AlembicMigrationOperation(BasePydanticModel):
 
 class AlembicMigrationStatusRequest(BasePydanticModel):
     alembic_version_meta_table_uid: str
-    data_source_uid: str
     package: str = ""
     migration_namespace: str = ""
 
@@ -56,7 +54,7 @@ class AlembicMigrationApplyResponse(BasePydanticModel):
     dry_run: bool = False
     alembic_version_meta_table_uid: str
     alembic_version_table: str
-    data_source_uid: str
+    data_source_uid: str | None = None
     package: str = ""
     migration_namespace: str = ""
     revision: str
@@ -76,7 +74,7 @@ class AlembicMigrationStatusResponse(BasePydanticModel):
     version: AlembicMigrationVersion = ALEMBIC_MIGRATION_V1
     alembic_version_meta_table_uid: str
     alembic_version_table: str
-    data_source_uid: str
+    data_source_uid: str | None = None
     package: str = ""
     migration_namespace: str = ""
     current_revision: str | None = None
@@ -127,7 +125,6 @@ def _get_migration_status(
         "alembic_version_meta_table_uid",
         payload.alembic_version_meta_table_uid,
     )
-    response_payload.setdefault("data_source_uid", payload.data_source_uid)
     response_payload.setdefault("package", payload.package)
     response_payload.setdefault("migration_namespace", payload.migration_namespace)
     return AlembicMigrationStatusResponse(**response_payload)

{mainsequence-4.1.19 → mainsequence-4.2.2}/mainsequence/meta_tables/__init__.py

@@ -65,6 +65,10 @@ _LAZY_IMPORTS = {
         ".sqlalchemy_contracts",
         "platform_managed_registration_request_from_sqlalchemy_model",
     ),
+    "platform_managed_migration_registration_context": (
+        ".sqlalchemy_contracts",
+        "platform_managed_migration_registration_context",
+    ),
     "register_external_sqlalchemy_model": (
         ".sqlalchemy_contracts",
         "register_external_sqlalchemy_model",

{mainsequence-4.1.19 → mainsequence-4.2.2}/mainsequence/meta_tables/data_nodes/build_operations.py

@@ -95,14 +95,15 @@ def _(value: type[Any]) -> Any:
     time_index_metadata = value.get_time_index_metadata()
     uid = getattr(time_index_metadata, "uid", None)
     if uid in (None, ""):
-        value.register()
-        time_index_metadata = value.get_time_index_metadata()
-        uid = getattr(time_index_metadata, "uid", None)
+        raise ValueError(
+            "PlatformTimeIndexMetaData config value is not registered. Run "
+            "`mainsequence migrations upgrade --provider <provider> --to head` "
+            "before using it in DataNode configuration."
+        )
 
     if uid in (None, ""):
         raise ValueError(
-            "PlatformTimeIndexMetaData config value register() did not bind "
-            "TimeIndexMetaData metadata before hashing."
+            "PlatformTimeIndexMetaData config value is missing TimeIndexMetaData metadata."
         )
     return {
         "__type__": "platform_time_index_metadata",

{mainsequence-4.1.19 → mainsequence-4.2.2}/mainsequence/meta_tables/data_nodes/persist_managers.py

@@ -97,14 +97,23 @@ def ensure_registered_storage_table(
         )
 
     if storage_table.get_time_index_metadata() is None:
-        if getattr(storage_table, "__table__", None) is None:
-            raise ValueError(f"{context} storage_table must be registered before use.")
-        storage_table.register()
+        raise ValueError(
+            f"{context} storage_table is not registered. Run "
+            "`mainsequence migrations upgrade --provider <provider> --to head` "
+            "before using this DataNode storage table."
+        )
 
     storage_metadata = storage_table.get_time_index_metadata()
     if storage_metadata is None:
         raise ValueError(
-            f"{context} storage_table.register() did not bind TimeIndexMetaData metadata."
+            f"{context} storage_table is missing TimeIndexMetaData metadata."
+        )
+    from mainsequence.client.metatables import TimeIndexMetaData
+
+    if not isinstance(storage_metadata, TimeIndexMetaData):
+        raise TypeError(
+            f"{context} storage_table must bind TimeIndexMetaData metadata; "
+            f"got {type(storage_metadata).__name__}."
         )
     if storage_table.get_meta_table_uid() in (None, ""):
         raise ValueError(f"{context} storage_table must provide a MetaTable UID.")
@@ -117,7 +126,7 @@ class BasePersistManager:
     UPDATE_CLASS: ClassVar[type[Any] | None] = None
     UPDATE_DETAILS_CLASS: ClassVar[type[Any] | None] = None
 
-    UPDATE_GET_OR_NONE_DATASOURCE_LOOKUP: ClassVar[str] = "remote_table__data_source__uid"
+    UPDATE_GET_OR_NONE_STORAGE_LOOKUP: ClassVar[str] = "remote_table__uid"
     UPDATE_CREATE_STORAGE_LOOKUP: ClassVar[str] = "meta_table_uid"
     TIME_INDEXED_PROFILE_ATTR: ClassVar[str] = "time_indexed_profile"
 
@@ -180,7 +189,7 @@ class BasePersistManager:
             "update_hash": self.update_hash,
             "include_relations_detail": include_relations_detail,
         }
-        kwargs[self.UPDATE_GET_OR_NONE_DATASOURCE_LOOKUP] = self.storage_table.get_data_source_uid()
+        kwargs[self.UPDATE_GET_OR_NONE_STORAGE_LOOKUP] = self.storage_table.get_meta_table_uid()
         return kwargs
 
     def _build_update_get_or_create_kwargs(
@@ -573,7 +582,7 @@ class APIPersistManager:
 class PersistManager(BasePersistManager):
     UPDATE_CLASS = DataNodeUpdate
     UPDATE_DETAILS_CLASS = DataNodeUpdateDetails
-    UPDATE_GET_OR_NONE_DATASOURCE_LOOKUP = "remote_table__data_source__uid"
+    UPDATE_GET_OR_NONE_STORAGE_LOOKUP = "remote_table__uid"
     UPDATE_CREATE_STORAGE_LOOKUP = "meta_table_uid"
 
     @classmethod