mainsequence 4.1.18__tar.gz → 4.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.1.18
+Version: 4.2.1
 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.18 → mainsequence-4.2.1}/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.18 → mainsequence-4.2.1}/agent_scaffold/skills/data_publishing/meta_tables/SKILL.md

@@ -161,15 +161,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 +186,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 +196,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 +219,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
@@ -260,27 +267,43 @@ For contract evolution, define or update one selected
 - set `package`, `migration_namespace`, `script_location`, and `target_metadata`
 - set `alembic_registry` to an `AlembicVersionMetaTable` subclass
 - list the post-apply catalog scope in `metatable_models`
-- generate, render, dry-run, apply, and optionally refresh catalog bindings
+- generate, render, dry-run, apply, and refresh catalog bindings
   through `mainsequence migrations ...` commands
 
 `alembic_version_meta_table_uid` is the UID of the catalog binding for Alembic's
 version table. It is not the UID of the table being migrated.
 
+Application MetaTable catalog sync resolves existing rows by exact
+`identifier`. If a model declares `__metatable_identifier__`, that value is the
+global identity. If it does not, the SDK derives the identifier from
+`[project].name` in `pyproject.toml` plus
+`<model.__module__>.<model.__qualname__>`. Pin an explicit identifier when a
+class is renamed or moved but must keep the same platform identity.
+
 Do not ask users to construct backend migration payloads, call low-level
 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 --apply --register-metatables
+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`.
+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.
@@ -336,6 +359,7 @@ Do not claim success until you have checked:
 - migrations are scoped by an `AlembicMetaTableMigration` provider
 - the provider's Alembic version-table binding is registered before apply/current
 - post-apply catalog registration is scoped to `migration.metatable_models`
+- catalog sync resolves application MetaTables by exact `identifier`
 - user-facing migration instructions stay on the documented CLI/provider lifecycle
 
 For related tables, also check:

{mainsequence-4.1.18 → mainsequence-4.2.1}/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,18 +358,7 @@ 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.",
-    ),
-    apply: bool = typer.Option(False, "--apply", help="Apply after validating dry-run."),
     dry_run: bool = typer.Option(False, "--dry-run", help="Validate without executing SQL."),
-    register_metatables: bool = typer.Option(
-        False,
-        "--register-metatables",
-        help="Register provider MetaTable models after a successful apply.",
-    ),
     sqlalchemy_url: str = typer.Option(
         "postgresql://",
         "--sqlalchemy-url",
@@ -327,11 +369,12 @@ def upgrade(
 ) -> None:
     """Dry-run or apply an Alembic-rendered SQL artifact through the backend."""
 
-    if apply and dry_run:
-        raise typer.BadParameter("Use either --apply or --dry-run, not both.")
-
     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(
@@ -349,7 +392,7 @@ def upgrade(
         dry_run=True,
     )
     validation = MetaTable.apply_migration(validation_operation, timeout=timeout)
-    if not apply:
+    if dry_run:
         _emit(validation, json_output=json_output)
         return
     if not validation.ok:
@@ -358,13 +401,21 @@ def upgrade(
 
     apply_operation = validation_operation.model_copy(update={"dry_run": False})
     result = MetaTable.apply_migration(apply_operation, timeout=timeout)
-    registered = []
-    if register_metatables and result.ok:
-        registered = migration.register_metatables(timeout=timeout)
+    if not result.ok:
+        _emit(result, json_output=json_output)
+        raise typer.Exit(code=1)
+    applied_status = MetaTable.get_migration_status(_status_request(migration), timeout=timeout)
+    registered = migration.sync_metatable_catalog(timeout=timeout)
 
     if json_output or _json_output_enabled():
         _emit(
-            {"validation": validation, "apply": result, "registered": registered}, json_output=True
+            {
+                "validation": validation,
+                "apply": result,
+                "status": applied_status,
+                "registered": registered,
+            },
+            json_output=True,
         )
         return
     _emit(result, json_output=False)

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

@@ -453,7 +453,13 @@ class MetaTableRegistrationRequest(BasePydanticModel):
     management_mode: MetaTableManagementMode
     storage_hash: str = Field(..., max_length=63, description="Canonical table storage hash.")
     table_contract: MetaTableContract | dict[str, Any]
-    identifier: str | None = None
+    identifier: str | None = Field(
+        default=None,
+        description=(
+            "Optional logical MetaTable identifier. Non-empty values are globally "
+            "unique per organization and are used to resolve migrated MetaTables."
+        ),
+    )
     namespace: str | None = None
     description: str | None = None
     protect_from_deletion: bool = False
@@ -869,7 +875,13 @@ class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, B
     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 = None
+    identifier: str | None = Field(
+        default=None,
+        description=(
+            "Optional logical MetaTable identifier. Non-empty values are globally "
+            "unique per organization and are used to resolve migrated MetaTables."
+        ),
+    )
     namespace: str | None = None
     description: str | None = None
     labels: list[str] = Field(default_factory=list)
@@ -1387,7 +1399,13 @@ class TimeIndexMetaTableRegistrationRequest(BasePydanticModel):
         max_length=63,
         description="Canonical logical storage identity for the time-indexed MetaTable",
     )
-    identifier: str | None = Field(None, description="Optional published storage identifier")
+    identifier: str | None = Field(
+        None,
+        description=(
+            "Optional published storage identifier. Non-empty values are globally "
+            "unique per organization."
+        ),
+    )
     namespace: str | None = Field(None, description="Optional published storage namespace")
     description: str | None = Field(None, description="Optional storage description")
     labels: list[str] = Field(default_factory=list)
@@ -1635,12 +1653,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",
     }
@@ -2405,7 +2426,13 @@ class DataNodeUpdateDetails(BaseUpdateDetails, BasePydanticModel, BaseObjectOrm)
 
 
 class TableMetaData(BaseModel):
-    identifier: str = None
+    identifier: str | None = Field(
+        default=None,
+        description=(
+            "Optional logical MetaTable identifier. Non-empty values are globally "
+            "unique per organization."
+        ),
+    )
     description: str | None = None
 
 

{mainsequence-4.1.18 → mainsequence-4.2.1}/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.18 → mainsequence-4.2.1}/mainsequence/meta_tables/__init__.py

@@ -65,10 +65,18 @@ _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",
     ),
+    "resolve_metatable_identifier": (
+        ".sqlalchemy_contracts",
+        "resolve_metatable_identifier",
+    ),
     "render_packaged_alembic_migration": (
         ".migrations",
         "render_packaged_alembic_migration",