mainsequence 4.2.37__tar.gz → 4.2.39__tar.gz

{mainsequence-4.2.37/mainsequence.egg-info → mainsequence-4.2.39}/PKG-INFO

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

{mainsequence-4.2.37 → mainsequence-4.2.39}/agent_scaffold/skills/data_publishing/data_nodes/SKILL.md

@@ -191,6 +191,12 @@ MetaTable migration provider and run `mainsequence migrations upgrade --provider
 ... head`. Do not call `PricesTable.register()` directly and do not rely on
 DataNode construction to register storage tables.
 
+`__index_names__` is the full DataNode storage grain. `PlatformTimeIndexMetaData`
+automatically adds a SQLAlchemy unique index over that tuple before Alembic
+autogenerate runs. Do not manually repeat the full grain unique index in
+`__table_args__`; add ordinary SQLAlchemy `Index(...)` entries only for
+additional lookup/performance paths.
+
 `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.

{mainsequence-4.2.37 → mainsequence-4.2.39}/agent_scaffold/skills/data_publishing/meta_tables/SKILL.md

@@ -292,6 +292,12 @@ SQLAlchemy class and calling normal registration again. Shape-addressed
 foreign keys, or constraints change, so new code cannot reliably recover the
 previous shape-derived table.
 
+Do not modify Alembic revision files that have already been implemented/applied.
+MetaTable migrations are database-backed history: once a revision may exist in a
+database `alembic_version` table, changing that file corrupts the relationship
+between source history and deployed state. For any follow-up schema change,
+create a new Alembic revision on top of the current head.
+
 For contract evolution, define or update one selected
 `AlembicMetaTableMigration` provider:
 

{mainsequence-4.2.37 → mainsequence-4.2.39}/mainsequence/meta_tables/migrations.py

@@ -534,9 +534,15 @@ class AlembicMetaTableMigration:
                 table_name = target_table_names[model]
                 existing_meta_table = existing_by_table_name.get(table_name)
                 if existing_meta_table is not None:
-                    _bind_model_to_existing_metatable(model, existing_meta_table)
-                    reserved_by_model[model] = existing_meta_table
-                    continue
+                    if _meta_table_provisioning_status(existing_meta_table) == "active":
+                        _bind_model_to_existing_metatable(model, existing_meta_table)
+                        reserved_by_model[model] = existing_meta_table
+                        continue
+                    if on_metatable_reservation_status is not None:
+                        on_metatable_reservation_status(
+                            "Restaging existing reserved MetaTable "
+                            f"table_name={table_name} with current provider contract."
+                        )
                 else:
                     bound_meta_table = _bound_meta_table_for_model(model)
                     if bound_meta_table is not None:
@@ -1055,6 +1061,13 @@ def _meta_table_physical_table_name(meta_table: MetaTable) -> str | None:
     return str(physical_table_name)
 
 
+def _meta_table_provisioning_status(meta_table: MetaTable) -> str | None:
+    provisioning_status = meta_table.provisioning_status
+    if provisioning_status in (None, ""):
+        return None
+    return str(provisioning_status)
+
+
 def _meta_table_uid(meta_table: MetaTable) -> str | None:
     uid = meta_table.uid
     if uid in (None, ""):
@@ -1066,7 +1079,6 @@ def _finalize_table_failed(item: ManagedMetaTableFinalizeTableResult) -> bool:
     return (
         item.provisioning_status != "active"
         or item.physical_table_exists is False
-        or item.finalized is False
         or item.error not in (None, "", {})
     )
 

{mainsequence-4.2.37 → mainsequence-4.2.39}/mainsequence/meta_tables/sqlalchemy_contracts.py

@@ -28,6 +28,7 @@ from mainsequence.client.metatables import (
 )
 
 from .hashing import build_meta_table_configured_storage_hash
+from .schema_names import schema_index_name
 
 DEFAULT_PLATFORM_MANAGED_PROVISIONING = {
     "create_table": True,
@@ -322,7 +323,9 @@ class PlatformTimeIndexMetaData(PlatformManagedMetaTable):
 
         from sqlalchemy import Table
 
-        return Table(str(name), metadata, *table_items, **kwargs)
+        table = Table(str(name), metadata, *table_items, **kwargs)
+        _ensure_time_index_unique_grain_index(table=table, index_names=index_names)
+        return table
 
     @classmethod
     def build_registration_request(
@@ -1391,6 +1394,75 @@ def _validate_time_index_contract(
         )
 
 
+def _ensure_time_index_unique_grain_index(
+    *,
+    table: Any,
+    index_names: Sequence[str],
+) -> None:
+    grain_names = [str(name) for name in index_names]
+    if _has_unique_grain_enforcement(table=table, index_names=grain_names):
+        return
+
+    from sqlalchemy import Index
+
+    Index(
+        schema_index_name(_table_name(table), grain_names, unique=True),
+        *(table.c[name] for name in grain_names),
+        unique=True,
+    )
+
+
+def _has_unique_grain_enforcement(
+    *,
+    table: Any,
+    index_names: Sequence[str],
+) -> bool:
+    for index in _iter_indexes(table):
+        if bool(getattr(index, "unique", False)) and _grain_columns_match(
+            _index_column_names(index),
+            index_names,
+        ):
+            return True
+
+    for constraint in _iter_unique_constraints(table):
+        if _grain_columns_match(_constraint_column_names(constraint), index_names):
+            return True
+
+    return False
+
+
+def _grain_columns_match(existing_names: Sequence[str], index_names: Sequence[str]) -> bool:
+    existing = [str(name) for name in existing_names]
+    expected = [str(name) for name in index_names]
+    if len(existing) != len(expected):
+        return False
+    return set(existing) == set(expected)
+
+
+def _index_column_names(index: Any) -> list[str]:
+    return [_storage_item_name(item) for item in _iter_index_items(index)]
+
+
+def _iter_unique_constraints(table: Any) -> list[Any]:
+    from sqlalchemy import UniqueConstraint
+
+    constraints = getattr(table, "constraints", None)
+    if constraints is None:
+        return []
+    return [
+        constraint
+        for constraint in constraints
+        if isinstance(constraint, UniqueConstraint)
+    ]
+
+
+def _constraint_column_names(constraint: Any) -> list[str]:
+    columns = getattr(constraint, "columns", None)
+    if columns is None:
+        return []
+    return [_storage_item_name(column) for column in columns]
+
+
 def _storage_identity_from_parts(
     *,
     columns: Sequence[Any],

{mainsequence-4.2.37 → mainsequence-4.2.39/mainsequence.egg-info}/PKG-INFO

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

{mainsequence-4.2.37 → mainsequence-4.2.39}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "4.2.37"
+version = "4.2.39"
 description = "Main Sequence SDK "
 readme = "README.md"
 requires-python = ">=3.11"

{mainsequence-4.2.37 → mainsequence-4.2.39}/tests/test_meta_table_migrations.py

@@ -1069,6 +1069,7 @@ def test_prepare_for_alembic_reserves_existing_table_name_with_provider_identity
     def fake_bulk_create(rows, *, timeout=None, on_status=None):
         reserved_payloads.extend(rows)
         assert [table["identifier"] for table in rows] == [
+            "example_assets__account",
             "example_assets__asset",
         ]
         assert all(table["migration_package"] == "sample" for table in rows)
@@ -1079,11 +1080,17 @@ def test_prepare_for_alembic_reserves_existing_table_name_with_provider_identity
         assert not hasattr(rows[0]["table_contract"], "foreign_keys")
         assert all("schema_management" not in table for table in rows)
         return [
+            _reserved_metatable(
+                uid="aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+                identifier="example_assets__account",
+                physical_table_name="example_assets__account",
+                storage_hash=rows[0]["storage_hash"],
+            ),
             _reserved_metatable(
                 uid="bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
                 identifier="example_assets__asset",
                 physical_table_name="example_assets__asset",
-                storage_hash=rows[0]["storage_hash"],
+                storage_hash=rows[1]["storage_hash"],
             ),
         ]
 
@@ -1106,6 +1113,7 @@ def test_prepare_for_alembic_reserves_existing_table_name_with_provider_identity
 
     assert len(filter_calls) == 1
     assert [payload["identifier"] for payload in reserved_payloads] == [
+        "example_assets__account",
         "example_assets__asset",
     ]
     assert "schema_management" not in reserved_payloads[0]
@@ -1115,6 +1123,10 @@ def test_prepare_for_alembic_reserves_existing_table_name_with_provider_identity
     ]
     assert Account.__table__.name == "example_assets__account"
     assert Asset.__table__.name == "example_assets__asset"
+    assert (
+        "Restaging existing reserved MetaTable table_name=example_assets__account "
+        "with current provider contract."
+    ) in reservation_statuses
 
 
 def test_prepare_for_alembic_reserves_already_staged_existing_rows(monkeypatch):

{mainsequence-4.2.37 → mainsequence-4.2.39}/tests/test_meta_tables_sqlalchemy_contracts.py

@@ -22,6 +22,8 @@ from mainsequence.meta_tables import (
     external_registered_registration_request_from_sqlalchemy_model,
     platform_managed_migration_registration_context,
     platform_managed_registration_request_from_sqlalchemy_model,
+    schema_index_name,
+    sqlalchemy_naming_convention,
     table_contract_from_sqlalchemy_model,
     time_indexed_registration_request_from_sqlalchemy_model,
 )
@@ -1535,6 +1537,85 @@ def test_platform_managed_metatable_preserves_authored_tablename_with_sqlalchemy
     assert not hasattr(request.table_contract, "foreign_keys")
 
 
+def test_time_index_metadata_generates_unique_grain_index_with_schema_name():
+    pytest.importorskip("sqlalchemy")
+
+    from sqlalchemy import DateTime, Float, MetaData, String
+    from sqlalchemy.orm import DeclarativeBase, mapped_column
+
+    class Base(DeclarativeBase):
+        metadata = MetaData(naming_convention=sqlalchemy_naming_convention())
+
+    class Prices(PlatformTimeIndexMetaData, Base):
+        __tablename__ = "ms_markets__prices__mainsequence_examples"
+        __metatable_namespace__ = "mainsequence.examples"
+        __time_index_name__ = "time_index"
+        __index_names__ = ["time_index", "asset_identifier"]
+
+        time_index: Mapped[datetime.datetime] = mapped_column(
+            DateTime(timezone=True),
+            nullable=False,
+        )
+        asset_identifier: Mapped[str] = mapped_column(String(255), nullable=False)
+        close: Mapped[float] = mapped_column(Float, nullable=True)
+
+    grain_indexes = [
+        index
+        for index in Prices.__table__.indexes
+        if index.unique
+        and [column.name for column in index.columns] == ["time_index", "asset_identifier"]
+    ]
+
+    assert len(grain_indexes) == 1
+    assert grain_indexes[0].name == schema_index_name(
+        "ms_markets__prices__mainsequence_examples",
+        ["time_index", "asset_identifier"],
+        unique=True,
+    )
+
+
+def test_time_index_metadata_reuses_existing_unique_grain_constraint():
+    pytest.importorskip("sqlalchemy")
+
+    from sqlalchemy import DateTime, Float, MetaData, String, UniqueConstraint
+    from sqlalchemy.orm import DeclarativeBase, mapped_column
+
+    class Base(DeclarativeBase):
+        metadata = MetaData(naming_convention=sqlalchemy_naming_convention())
+
+    class Prices(PlatformTimeIndexMetaData, Base):
+        __tablename__ = "ms_markets__prices__mainsequence_examples"
+        __table_args__ = (
+            UniqueConstraint(
+                "asset_identifier",
+                "time_index",
+                name="uix_custom_asset_time",
+            ),
+        )
+        __metatable_namespace__ = "mainsequence.examples"
+        __time_index_name__ = "time_index"
+        __index_names__ = ["time_index", "asset_identifier"]
+
+        time_index: Mapped[datetime.datetime] = mapped_column(
+            DateTime(timezone=True),
+            nullable=False,
+        )
+        asset_identifier: Mapped[str] = mapped_column(String(255), nullable=False)
+        close: Mapped[float] = mapped_column(Float, nullable=True)
+
+    assert not Prices.__table__.indexes
+    unique_constraints = [
+        constraint
+        for constraint in Prices.__table__.constraints
+        if isinstance(constraint, UniqueConstraint)
+    ]
+    assert len(unique_constraints) == 1
+    assert [column.name for column in unique_constraints[0].columns] == [
+        "asset_identifier",
+        "time_index",
+    ]
+
+
 def test_platform_managed_register_preserves_authored_sqlalchemy_table_name(
     monkeypatch,
 ):