mainsequence 4.2.1__tar.gz → 4.2.4__tar.gz

{mainsequence-4.2.1/mainsequence.egg-info → mainsequence-4.2.4}/PKG-INFO

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

{mainsequence-4.2.1 → mainsequence-4.2.4}/agent_scaffold/skills/data_publishing/data_nodes/SKILL.md

@@ -184,7 +184,7 @@ class PricesTable(PlatformTimeIndexMetaData, Base):
 
 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
+... head`. Do not call `PricesTable.register()` directly and do not rely on
 DataNode construction to register storage tables.
 
 `PlatformTimeIndexMetaData.register()` remains SDK plumbing for the migration

{mainsequence-4.2.1 → mainsequence-4.2.4}/agent_scaffold/skills/data_publishing/meta_tables/SKILL.md

@@ -95,6 +95,27 @@ 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 upgrade --provider mainsequence_migrations:migration head
+```
+
 ### 1. SQLAlchemy metadata is the authoring source
 
 Keep the application table model as the authoring source for the neutral table contract.
@@ -166,8 +187,8 @@ class Account(PlatformManagedMetaTable, Base):
 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.
+`mainsequence migrations upgrade --provider ... head` reserve, migrate, refresh,
+and bind them.
 
 For platform-managed migration registration, the data source is resolved from
 the active Main Sequence project/session, the same way DataNode does. Do not
@@ -287,13 +308,11 @@ request shape is reference material in the tutorial; the user-facing path is:
 ```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
+mainsequence migrations upgrade --provider mainsequence_migrations:migration head
 ```
 
-`current` and `upgrade` automatically register the provider's
-`AlembicVersionMetaTable` binding when backend migration state is needed.
+All migration commands prepare the provider, reserve provider-scoped
+platform-managed MetaTables, bind backend names, and call Alembic directly.
 `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.

{mainsequence-4.2.1 → mainsequence-4.2.4}/mainsequence/cli/cli.py

@@ -337,7 +337,6 @@ connection = typer.Typer(help="Connection commands")
 organization = typer.Typer(help="Organization commands")
 organization_teams_group = typer.Typer(help="Organization team commands")
 meta_table_group = typer.Typer(help="MetaTable table-storage commands")
-migrations_root_group = migrations_group
 data_node_storage_group = typer.Typer(help="DataNode update/read-helper commands")
 project = typer.Typer(help="Project commands (remote + local operations)")
 project_list_group = typer.Typer(help="List-related project commands")
@@ -377,7 +376,6 @@ app.add_typer(organization, name="organization")
 app.add_typer(skills, name="skills")
 app.add_typer(meta_table_group, name="meta-table")
 app.add_typer(meta_table_group, name="meta_table")
-app.add_typer(migrations_root_group, name="migrations")
 app.add_typer(data_node_storage_group, name="data-node")
 app.add_typer(data_node_storage_group, name="data_node")
 app.add_typer(data_node_storage_group, name="data-node-storage", hidden=True)
@@ -391,6 +389,7 @@ project.add_typer(project_jobs_group, name="jobs")
 project_jobs_group.add_typer(project_job_runs_group, name="runs")
 app.add_typer(settings, name="settings")
 app.add_typer(sdk, name="sdk")
+app.add_typer(migrations_group, name="migrations")
 
 
 @app.callback()

mainsequence-4.2.4/mainsequence/cli/migrations.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import dataclasses
+import json
+import re
+from typing import Any
+
+import click
+import typer
+
+from mainsequence.client.metatables import (
+    DynamicTableDataSource,
+    DynamicTableDataSourceMigrationConnectionRequest,
+)
+from mainsequence.meta_tables.migrations import (
+    AlembicMetaTableMigration,
+    alembic_config_for_provider,
+    load_alembic_metatable_migration_provider,
+)
+
+migrations = typer.Typer(help="Alembic-owned MetaTable migration commands")
+
+
+def _load_migration(provider: str | None) -> AlembicMetaTableMigration:
+    try:
+        return load_alembic_metatable_migration_provider(provider)
+    except Exception as exc:
+        raise typer.BadParameter(str(exc), param_hint="--provider") from exc
+
+
+def _jsonable(value: Any) -> Any:
+    if hasattr(value, "model_dump"):
+        return value.model_dump(mode="json")
+    if dataclasses.is_dataclass(value):
+        return dataclasses.asdict(value)
+    if isinstance(value, dict):
+        return {str(key): _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [_jsonable(item) for item in value]
+    return value
+
+
+def _emit(payload: Any, *, json_output: bool = False) -> None:
+    if json_output or _json_output_enabled():
+        typer.echo(json.dumps(_jsonable(payload), indent=2, ensure_ascii=False))
+        return
+    if isinstance(payload, str):
+        typer.echo(payload)
+        return
+    for key, value in _jsonable(payload).items():
+        typer.echo(f"{key}: {value}")
+
+
+def _json_output_enabled() -> bool:
+    ctx = click.get_current_context(silent=True)
+    if ctx is None:
+        return False
+    root = ctx.find_root()
+    obj = getattr(root, "obj", None) or {}
+    return bool(obj.get("json_output"))
+
+
+def _prepare_alembic_config(
+    migration: AlembicMetaTableMigration,
+    *,
+    timeout: float | None,
+    ttl_seconds: int,
+) -> tuple[Any, Any]:
+    migration.ensure_alembic_registry(timeout=timeout)
+    prepared = migration.prepare_for_alembic(timeout=timeout)
+    data_source = DynamicTableDataSource.get_by_uid(prepared.data_source_uid)
+    connection = data_source.issue_migration_connection(
+        DynamicTableDataSourceMigrationConnectionRequest(
+            package=migration.package,
+            migration_namespace=migration.migration_namespace,
+            meta_table_uids=prepared.meta_table_uids,
+            ttl_seconds=ttl_seconds,
+        ),
+        timeout=timeout,
+    )
+    config = alembic_config_for_provider(
+        migration,
+        sqlalchemy_url=connection.uri,
+        owner_role_name=connection.owner_role_name or prepared.owner_role_name,
+    )
+    return prepared, config
+
+
+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
+
+    script = ScriptDirectory.from_config(
+        alembic_config_for_provider(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")
+def current(
+    provider: str | None = typer.Option(
+        None,
+        "--provider",
+        help="Migration provider reference, for example msm.migrations:migration.",
+    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v"),
+    timeout: float | None = typer.Option(None, "--timeout"),
+    ttl_seconds: int = typer.Option(900, "--ttl-seconds", min=1),
+) -> None:
+    """Read current Alembic revision through a scoped migration credential."""
+
+    try:
+        from alembic import command
+    except ImportError as exc:
+        raise typer.BadParameter("Alembic is required for migration commands.") from exc
+
+    migration = _load_migration(provider)
+    _, config = _prepare_alembic_config(
+        migration,
+        timeout=timeout,
+        ttl_seconds=ttl_seconds,
+    )
+    command.current(config, verbose=verbose)
+
+
+@migrations.command("revision")
+def revision(
+    message: str | None = typer.Option(
+        None,
+        "--message",
+        "-m",
+        help="Alembic revision message. Defaults to 'migration'.",
+    ),
+    autogenerate: bool = typer.Option(
+        True,
+        "--autogenerate/--no-autogenerate",
+        help="Use Alembic autogenerate against the reserved MetaTable metadata.",
+    ),
+    provider: str | None = typer.Option(
+        None,
+        "--provider",
+        help="Migration provider reference, for example msm.migrations:migration.",
+    ),
+    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."),
+    timeout: float | None = typer.Option(None, "--timeout"),
+    ttl_seconds: int = typer.Option(900, "--ttl-seconds", min=1),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON."),
+) -> None:
+    """Create a normal Alembic revision for the selected provider."""
+
+    try:
+        from alembic import command
+    except ImportError as exc:
+        raise typer.BadParameter("Alembic is required for revision generation.") from exc
+
+    migration = _load_migration(provider)
+    resolved_message = (message or "").strip() or "migration"
+    resolved_rev_id = rev_id or _next_sequential_revision_id(migration)
+    prepared, config = _prepare_alembic_config(
+        migration,
+        timeout=timeout,
+        ttl_seconds=ttl_seconds,
+    )
+    script = command.revision(
+        config,
+        message=resolved_message,
+        autogenerate=autogenerate,
+        rev_id=resolved_rev_id,
+        head=head,
+    )
+    _emit(
+        {
+            "revision": getattr(script, "revision", None),
+            "path": getattr(script, "path", None),
+            "package": migration.package,
+            "migration_namespace": migration.migration_namespace,
+            "meta_table_uids": prepared.meta_table_uids,
+        },
+        json_output=json_output,
+    )
+
+
+@migrations.command("upgrade")
+def upgrade(
+    target_revision: str = typer.Argument("head", help="Target Alembic revision."),
+    provider: str | None = typer.Option(
+        None,
+        "--provider",
+        help="Migration provider reference, for example msm.migrations:migration.",
+    ),
+    timeout: float | None = typer.Option(None, "--timeout"),
+    ttl_seconds: int = typer.Option(900, "--ttl-seconds", min=1),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON."),
+) -> None:
+    """Run Alembic upgrade directly and refresh MetaTable catalog rows."""
+
+    try:
+        from alembic import command
+    except ImportError as exc:
+        raise typer.BadParameter("Alembic is required for migration commands.") from exc
+
+    migration = _load_migration(provider)
+    prepared, config = _prepare_alembic_config(
+        migration,
+        timeout=timeout,
+        ttl_seconds=ttl_seconds,
+    )
+    command.upgrade(config, target_revision)
+    registered = migration.refresh_metatable_catalog(timeout=timeout)
+    _emit(
+        {
+            "ok": True,
+            "revision": target_revision,
+            "package": migration.package,
+            "migration_namespace": migration.migration_namespace,
+            "meta_table_uids": prepared.meta_table_uids,
+            "registered_count": len(registered),
+        },
+        json_output=json_output,
+    )
+
+
+@migrations.command("downgrade")
+def downgrade(
+    target_revision: str = typer.Argument(..., help="Target Alembic downgrade revision."),
+    provider: str | None = typer.Option(
+        None,
+        "--provider",
+        help="Migration provider reference, for example msm.migrations:migration.",
+    ),
+    timeout: float | None = typer.Option(None, "--timeout"),
+    ttl_seconds: int = typer.Option(900, "--ttl-seconds", min=1),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON."),
+) -> None:
+    """Run Alembic downgrade directly and refresh MetaTable catalog rows."""
+
+    try:
+        from alembic import command
+    except ImportError as exc:
+        raise typer.BadParameter("Alembic is required for migration commands.") from exc
+
+    migration = _load_migration(provider)
+    prepared, config = _prepare_alembic_config(
+        migration,
+        timeout=timeout,
+        ttl_seconds=ttl_seconds,
+    )
+    command.downgrade(config, target_revision)
+    registered = migration.refresh_metatable_catalog(timeout=timeout)
+    _emit(
+        {
+            "ok": True,
+            "revision": target_revision,
+            "package": migration.package,
+            "migration_namespace": migration.migration_namespace,
+            "meta_table_uids": prepared.meta_table_uids,
+            "registered_count": len(registered),
+        },
+        json_output=json_output,
+    )

{mainsequence-4.2.1 → mainsequence-4.2.4}/mainsequence/client/metatables/__init__.py

@@ -4,14 +4,9 @@ import sys
 import types
 
 from . import core as core
-from . import migrations as migrations
 from .core import *  # noqa: F403
-from .migrations import *  # noqa: F403
-
-migrations._bind_meta_table_migration_methods(core.MetaTable)
 
 __all__ = [
-    *migrations.__all__,
     *core.__all__,
 ]
 
@@ -19,8 +14,6 @@ __all__ = [
 def __getattr__(name: str):
     if hasattr(core, name):
         return getattr(core, name)
-    if hasattr(migrations, name):
-        return getattr(migrations, name)
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
@@ -28,8 +21,6 @@ class _MetaTablesModule(types.ModuleType):
     def __setattr__(self, name: str, value):
         if hasattr(core, name):
             setattr(core, name, value)
-        if hasattr(migrations, name):
-            setattr(migrations, name, value)
         super().__setattr__(name, value)
 
 

{mainsequence-4.2.1 → mainsequence-4.2.4}/mainsequence/client/metatables/core.py

@@ -286,7 +286,7 @@ class MetaTableColumnContract(BasePydanticModel):
 
 
 class MetaTableIndexContract(BasePydanticModel):
-    name: str
+    name: str | None = None
     columns: list[str] = Field(default_factory=list)
     unique: bool = False
     method: str | None = None
@@ -487,6 +487,69 @@ class MetaTableValidateContractRequest(BasePydanticModel):
         return self
 
 
+class DynamicTableDataSourceMigrationConnectionRequest(BasePydanticModel):
+    purpose: Literal["schema_migration"] = "schema_migration"
+    package: str = ""
+    migration_namespace: str = ""
+    meta_table_uids: list[str]
+    ttl_seconds: int = Field(default=900, ge=1)
+
+
+class DynamicTableDataSourceMigrationConnection(BasePydanticModel):
+    ok: bool
+    data_source_uid: str
+    dialect: str
+    credential_kind: str
+    role_name: str
+    owner_role_name: str | None = None
+    expires_at: datetime.datetime
+    uri: str
+
+    model_config = ConfigDict(extra="allow")
+
+
+class ManagedMetaTableReservationTable(BasePydanticModel):
+    identifier: str
+    namespace: str | None = None
+    data_source_uid: str | None = None
+    management_mode: Literal["platform_managed"] = "platform_managed"
+    storage_hash: str | None = None
+    physical_table_name: str | None = None
+    description: str | None = None
+    labels: list[str] = Field(default_factory=list)
+    protect_from_deletion: bool = False
+    open_for_everyone: bool = False
+    table_contract: MetaTableContract | dict[str, Any]
+    time_index_name: str | None = None
+    partition_strategy: str | None = None
+
+
+class ManagedMetaTableReservationRequest(BasePydanticModel):
+    version: Literal["managed-metatable-reservation.v1"] = "managed-metatable-reservation.v1"
+    data_source_uid: str | None = None
+    tables: list[ManagedMetaTableReservationTable]
+
+
+class ManagedMetaTableReservationItem(BasePydanticModel):
+    identifier: str
+    namespace: str | None = None
+    meta_table_uid: str
+    data_source_uid: str
+    management_mode: str
+    storage_hash: str
+    physical_table_name: str
+    table_contract: dict[str, Any]
+    reservation_status: str
+    existing: bool
+
+    model_config = ConfigDict(extra="allow")
+
+
+class ManagedMetaTableReservationResponse(BasePydanticModel):
+    version: Literal["managed-metatable-reservation.v1"] = "managed-metatable-reservation.v1"
+    tables: list[ManagedMetaTableReservationItem]
+
+
 class DataSource(BasePydanticModel, BaseObjectOrm):
     uid: str | None = Field(
         None,
@@ -736,6 +799,44 @@ class DynamicTableDataSource(BasePydanticModel, BaseObjectOrm):
         dump["related_resource"] = self.related_resource.model_dump()
         return json.dumps(dump, **json_dumps_kwargs)
 
+    def _public_uid(self) -> str:
+        if self.uid in (None, ""):
+            raise ValueError("DynamicTableDataSource must have a uid before calling this endpoint.")
+        return str(self.uid)
+
+    def issue_migration_connection(
+        self,
+        request: DynamicTableDataSourceMigrationConnectionRequest | Mapping[str, Any] | None = None,
+        *,
+        timeout: int | float | tuple[float, float] | None = None,
+        **kwargs: Any,
+    ) -> DynamicTableDataSourceMigrationConnection:
+        if request is not None and kwargs:
+            raise ValueError("Pass either request or keyword fields, not both.")
+        payload = (
+            request
+            if request is not None
+            else DynamicTableDataSourceMigrationConnectionRequest(**kwargs)
+        )
+        if isinstance(payload, Mapping):
+            payload = DynamicTableDataSourceMigrationConnectionRequest(**payload)
+
+        url = (
+            f"{type(self).get_object_url().rstrip('/')}/{self._public_uid()}/migration-connection/"
+        )
+        request_payload = {"json": _payload_json(payload)}
+        response = make_request(
+            s=type(self).build_session(),
+            loaders=type(self).LOADERS,
+            r_type="POST",
+            url=url,
+            payload=request_payload,
+            time_out=timeout,
+        )
+        if response.status_code != 200:
+            raise_for_response(response, payload=request_payload)
+        return DynamicTableDataSourceMigrationConnection(**response.json())
+
     @classmethod
     def get_or_create_duck_db(cls, time_out=None, *args, **kwargs):
         url = cls.get_object_url() + "/get_or_create_duck_db/"
@@ -1068,6 +1169,25 @@ class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, B
         )
         return cls(**response_json)
 
+    @classmethod
+    def reserve_managed(
+        cls,
+        request: ManagedMetaTableReservationRequest | Mapping[str, Any] | None = None,
+        *,
+        timeout: int | float | tuple[float, float] | None = None,
+        **kwargs: Any,
+    ) -> ManagedMetaTableReservationResponse:
+        if request is not None and kwargs:
+            raise ValueError("Pass either request or keyword fields, not both.")
+        payload = request if request is not None else ManagedMetaTableReservationRequest(**kwargs)
+        response_json = cls._post_action(
+            "reserve-managed",
+            payload,
+            timeout=timeout,
+            expected_statuses=(200, 201),
+        )
+        return ManagedMetaTableReservationResponse(**response_json)
+
     @classmethod
     def validate_contract(
         cls,
@@ -1102,6 +1222,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):
@@ -4272,12 +4411,18 @@ __all__ = [
     "DataNodeUpdateDetails",
     "DataSource",
     "DynamicTableDataSource",
+    "DynamicTableDataSourceMigrationConnection",
+    "DynamicTableDataSourceMigrationConnectionRequest",
     "DUCK_DB",
     "HistoricalUpdateRecord",
     "LastUpdateIndexTimePayload",
     "LastUpdateMultiIndexStatsPayload",
     "LOCAL_DATA_SOURCE_CLASS_TYPES",
     "LocalTimeSeriesHistoricalUpdate",
+    "ManagedMetaTableReservationItem",
+    "ManagedMetaTableReservationRequest",
+    "ManagedMetaTableReservationResponse",
+    "ManagedMetaTableReservationTable",
     "MetaTable",
     "MetaTableColumnContract",
     "MetaTableColumnPayload",

{mainsequence-4.2.1 → mainsequence-4.2.4}/mainsequence/meta_tables/__init__.py

@@ -14,10 +14,6 @@ _LAZY_IMPORTS = {
     "AlembicVersionMetaTable": (".migrations", "AlembicVersionMetaTable"),
     "PlatformManagedMetaTable": (".sqlalchemy_contracts", "PlatformManagedMetaTable"),
     "PlatformTimeIndexMetaData": (".sqlalchemy_contracts", "PlatformTimeIndexMetaData"),
-    "PackagedAlembicMigrationArtifact": (
-        ".migrations",
-        "PackagedAlembicMigrationArtifact",
-    ),
     "POSTGRES_IDENTIFIER_MAX_LENGTH": (".hashing", "POSTGRES_IDENTIFIER_MAX_LENGTH"),
     "BaseConfiguration": (".data_nodes", "BaseConfiguration"),
     "APIDataNode": (".data_nodes", "APIDataNode"),
@@ -77,18 +73,19 @@ _LAZY_IMPORTS = {
         ".sqlalchemy_contracts",
         "resolve_metatable_identifier",
     ),
-    "render_packaged_alembic_migration": (
-        ".migrations",
-        "render_packaged_alembic_migration",
-    ),
-    "render_packaged_alembic_migration_for_provider": (
+    "alembic_config_for_provider": (".migrations", "alembic_config_for_provider"),
+    "apply_mainsequence_migration_role": (
         ".migrations",
-        "render_packaged_alembic_migration_for_provider",
+        "apply_mainsequence_migration_role",
     ),
     "load_alembic_metatable_migration_provider": (
         ".migrations",
         "load_alembic_metatable_migration_provider",
     ),
+    "PreparedAlembicMetaTableMigration": (
+        ".migrations",
+        "PreparedAlembicMetaTableMigration",
+    ),
     "resolve_alembic_revision_metadata": (
         ".migrations",
         "resolve_alembic_revision_metadata",

{mainsequence-4.2.1 → mainsequence-4.2.4}/mainsequence/meta_tables/data_nodes/build_operations.py

@@ -97,7 +97,7 @@ def _(value: type[Any]) -> Any:
     if uid in (None, ""):
         raise ValueError(
             "PlatformTimeIndexMetaData config value is not registered. Run "
-            "`mainsequence migrations upgrade --provider <provider> --to head` "
+            "`mainsequence migrations upgrade --provider <provider> head` "
             "before using it in DataNode configuration."
         )
 

{mainsequence-4.2.1 → mainsequence-4.2.4}/mainsequence/meta_tables/data_nodes/persist_managers.py

@@ -99,14 +99,19 @@ def ensure_registered_storage_table(
     if storage_table.get_time_index_metadata() is None:
         raise ValueError(
             f"{context} storage_table is not registered. Run "
-            "`mainsequence migrations upgrade --provider <provider> --to head` "
+            "`mainsequence migrations upgrade --provider <provider> 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 is missing TimeIndexMetaData metadata."
+        raise ValueError(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.")