mainsequence 4.2.38__tar.gz → 4.2.40__tar.gz

{mainsequence-4.2.38/mainsequence.egg-info → mainsequence-4.2.40}/PKG-INFO

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

{mainsequence-4.2.38 → mainsequence-4.2.40}/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.38 → mainsequence-4.2.40}/agent_scaffold/skills/data_publishing/meta_tables/SKILL.md

@@ -137,7 +137,11 @@ first version, use Alembic. Keep the SDK model as a normal
 `PlatformManagedMetaTable` or `PlatformTimeIndexMetaData` catalog contract, and
 apply physical schema changes through the Alembic migration workflow.
 
-Schema must come from SQLAlchemy table metadata, usually `__table_args__ = {"schema": "public"}` or the tuple form ending in `{"schema": ...}`. Do not add a separate MetaTable-specific schema attribute.
+Default-schema tables must leave SQLAlchemy `Table.schema` unset; do not write
+`__table_args__ = {"schema": "public"}` for the default PostgreSQL schema. Set
+schema metadata only for non-default schemas, using `__table_args__ = {"schema":
+"custom_schema"}` or the tuple form ending in `{"schema": ...}`. Do not add a
+separate MetaTable-specific schema attribute.
 
 Always declare `__metatable_description__` on the model. The description must
 explain the table's business intention, row grain, and expected use, not only
@@ -246,7 +250,7 @@ Use this pattern:
 ```python
 account_uid: Mapped[uuid.UUID] = mapped_column(
     Uuid,
-    ForeignKey("public.sdk_examples__account.uid", ondelete="RESTRICT"),
+    ForeignKey("sdk_examples__account.uid", ondelete="RESTRICT"),
     nullable=False,
 )
 ```

{mainsequence-4.2.38 → mainsequence-4.2.40}/mainsequence/meta_tables/migrations.py

@@ -27,9 +27,14 @@ from mainsequence.meta_tables.hashing import build_meta_table_storage_hash
 from mainsequence.meta_tables.sqlalchemy_contracts import (
     PlatformManagedMetaTable,
     PlatformTimeIndexMetaData,
+    _ensure_time_index_unique_grain_index,
+    _normalize_table_default_schema,
     _resolve_model_data_source_uid,
     _resolve_table,
+    _resolve_time_index_name,
+    _resolve_time_index_names,
     _table_name,
+    _validate_time_index_contract,
     platform_managed_migration_registration_context,
 )
 
@@ -268,6 +273,8 @@ class AlembicMetaTableMigration:
             self.after_register_metatables
         ):
             raise TypeError("after_register_metatables must be callable when provided.")
+        _normalize_provider_default_schemas(self.metatable_models)
+        _ensure_provider_time_index_grain_indexes(self.metatable_models)
 
     @property
     def alembic_version_table(self) -> str:
@@ -956,6 +963,27 @@ def _metadata_table_names(target_metadata: Any) -> list[str]:
     return list(dict.fromkeys(names))
 
 
+def _normalize_provider_default_schemas(models: Sequence[type[Any]]) -> None:
+    for model in models:
+        if _is_platform_managed_metatable_model(model):
+            _normalize_table_default_schema(_resolve_table(model))
+
+
+def _ensure_provider_time_index_grain_indexes(models: Sequence[type[Any]]) -> None:
+    for model in models:
+        if not _is_platform_time_index_metatable_model(model):
+            continue
+        table = _resolve_table(model)
+        time_index_name = _resolve_time_index_name(model)
+        index_names = _resolve_time_index_names(model, time_index_name=time_index_name)
+        _validate_time_index_contract(
+            columns=list(table.columns),
+            time_index_name=time_index_name,
+            index_names=index_names,
+        )
+        _ensure_time_index_unique_grain_index(table=table, index_names=index_names)
+
+
 def _normalize_down_revision(value: Any) -> str | None:
     if value in (None, ""):
         return None

{mainsequence-4.2.38 → mainsequence-4.2.40}/mainsequence/meta_tables/sqlalchemy_contracts.py

@@ -11,6 +11,7 @@ from uuid import UUID
 from sqlalchemy import Table as _SQLAlchemyTable
 from sqlalchemy import inspect as _sqlalchemy_inspect
 from sqlalchemy.orm import declared_attr as _sqlalchemy_declared_attr
+from sqlalchemy.schema import BLANK_SCHEMA as _SQLALCHEMY_BLANK_SCHEMA
 
 from mainsequence.client.dtype_codec import (
     is_temporal_token,
@@ -28,12 +29,14 @@ 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,
     "if_not_exists": True,
 }
 SERVER_GENERATED_UUID_DEFAULT = "gen_random_uuid()"
+DEFAULT_POSTGRES_SCHEMA = "public"
 _PLATFORM_MANAGED_MIGRATION_REGISTRATION_CONTEXT: contextvars.ContextVar[bool] = (
     contextvars.ContextVar(
         "mainsequence_platform_managed_migration_registration_context",
@@ -152,8 +155,14 @@ class PlatformManagedMetaTable:
 
         name, metadata, *table_items = args
         kwargs = dict(kwargs)
-        schema = str(kwargs.get("schema") or _resolve_class_schema(cls, metadata=metadata))
-        if not kwargs.get("schema"):
+        schema = _normalize_sqlalchemy_schema(
+            kwargs.get("schema")
+            if "schema" in kwargs
+            else _resolve_class_schema(cls, metadata=metadata)
+        )
+        if schema is None:
+            kwargs["schema"] = _SQLALCHEMY_BLANK_SCHEMA
+        else:
             kwargs["schema"] = schema
 
         from sqlalchemy import Table
@@ -307,8 +316,14 @@ class PlatformTimeIndexMetaData(PlatformManagedMetaTable):
 
         name, metadata, *table_items = args
         kwargs = dict(kwargs)
-        schema = str(kwargs.get("schema") or _resolve_class_schema(cls, metadata=metadata))
-        if not kwargs.get("schema"):
+        schema = _normalize_sqlalchemy_schema(
+            kwargs.get("schema")
+            if "schema" in kwargs
+            else _resolve_class_schema(cls, metadata=metadata)
+        )
+        if schema is None:
+            kwargs["schema"] = _SQLALCHEMY_BLANK_SCHEMA
+        else:
             kwargs["schema"] = schema
 
         columns = [item for item in table_items if _looks_like_column(item)]
@@ -322,7 +337,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(
@@ -413,7 +430,7 @@ def table_contract_from_sqlalchemy_model(
     include_physical_table_name: bool = True,
 ) -> MetaTableContract:
     table = _resolve_table(model_or_table)
-    _resolve_schema(table, schema=schema)
+    resolved_schema = _resolve_schema(table, schema=schema)
     module, qualname = _resolve_model_path(
         model_or_table,
         table_model_module=table_model_module,
@@ -430,6 +447,7 @@ def table_contract_from_sqlalchemy_model(
             }
         },
         physical=MetaTablePhysicalContract(
+            schema_=resolved_schema,
             table_name=_table_name(table) if include_physical_table_name else None,
         ),
         columns=[
@@ -560,7 +578,10 @@ def time_indexed_registration_request_from_sqlalchemy_model(
                     ),
                 },
             },
-            "physical": {"table_name": _table_name(table)},
+            "physical": {
+                "schema": resolved_schema,
+                "table_name": _table_name(table),
+            },
             "columns": column_contracts,
         },
     )
@@ -741,7 +762,7 @@ def _table_name(table: Any) -> str:
 def _resolve_schema(table: Any, *, schema: str | None = None) -> str:
     resolved_schema = schema or getattr(table, "schema", None)
     if not resolved_schema:
-        raise ValueError("MetaTable SQLAlchemy contracts require a SQLAlchemy table schema.")
+        return DEFAULT_POSTGRES_SCHEMA
     return str(resolved_schema)
 
 
@@ -752,7 +773,7 @@ def _resolve_class_namespace(cls: type[Any]) -> str:
     return str(resolved_namespace)
 
 
-def _resolve_class_schema(cls: type[Any], *, metadata: Any | None = None) -> str:
+def _resolve_class_schema(cls: type[Any], *, metadata: Any | None = None) -> str | None:
     table_args = getattr(cls, "__table_args__", None)
     if isinstance(table_args, Mapping):
         schema = table_args.get("schema")
@@ -762,7 +783,29 @@ def _resolve_class_schema(cls: type[Any], *, metadata: Any | None = None) -> str
         schema = None
     if schema is None and metadata is not None:
         schema = getattr(metadata, "schema", None)
-    return str(schema or "public")
+    return _normalize_sqlalchemy_schema(schema)
+
+
+def _normalize_sqlalchemy_schema(schema: Any | None) -> str | None:
+    if schema is None:
+        return None
+    schema_name = str(schema).strip()
+    if schema_name in ("", DEFAULT_POSTGRES_SCHEMA):
+        return None
+    return schema_name
+
+
+def _normalize_table_default_schema(table: Any) -> None:
+    if getattr(table, "schema", None) != DEFAULT_POSTGRES_SCHEMA:
+        return
+
+    metadata = getattr(table, "metadata", None)
+    if metadata is not None:
+        metadata._remove_table(table.name, table.schema)
+    table.schema = None
+    table.fullname = _table_name(table)
+    if metadata is not None:
+        metadata._add_table(table.name, table.schema, table)
 
 
 def _resolve_data_source_uid(
@@ -1391,6 +1434,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.38 → mainsequence-4.2.40/mainsequence.egg-info}/PKG-INFO

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

{mainsequence-4.2.38 → mainsequence-4.2.40}/pyproject.toml

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

{mainsequence-4.2.38 → mainsequence-4.2.40}/tests/test_meta_table_migrations.py

@@ -16,7 +16,11 @@ from mainsequence.client.metatables import (
     MetaTable,
     TimeIndexMetaData,
 )
-from mainsequence.meta_tables import PlatformManagedMetaTable, PlatformTimeIndexMetaData
+from mainsequence.meta_tables import (
+    PlatformManagedMetaTable,
+    PlatformTimeIndexMetaData,
+    schema_index_name,
+)
 from mainsequence.meta_tables.migrations import (
     DEFAULT_ALEMBIC_VERSION_COLUMN_NAME,
     DEFAULT_ALEMBIC_VERSION_IDENTIFIER,
@@ -1005,6 +1009,68 @@ def test_prepare_for_alembic_routes_time_indexed_models_to_dynamic_table_bulk_cr
     assert "schema_management" not in row
 
 
+def test_provider_adds_time_index_grain_index_when_table_cls_is_overridden():
+    class Base(DeclarativeBase):
+        metadata = MetaData(schema="public")
+
+    class CustomTimeIndexMixin(PlatformTimeIndexMetaData):
+        __abstract__ = True
+
+        @classmethod
+        def __table_cls__(cls, *args, **kwargs):
+            name, metadata, *table_items = args
+            return Table(str(name), metadata, *table_items, **kwargs)
+
+    class ProjectAlembicVersion(AlembicVersionMetaTable):
+        __metatable_uid__ = "registry-meta-table-uid"
+        __metatable_data_source_uid__ = "data-source-uid"
+
+    class Prices(CustomTimeIndexMixin, Base):
+        __tablename__ = "example_assets__prices"
+        __metatable_data_source_uid__ = "data-source-uid"
+        __metatable_namespace__ = "example.assets"
+        __metatable_identifier__ = "Prices"
+        __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[int] = mapped_column(Integer, nullable=True)
+
+    assert not Prices.__table__.indexes
+    assert Prices.__table__.schema == "public"
+    assert "public.example_assets__prices" in Base.metadata.tables
+
+    AlembicMetaTableMigration(
+        package="sample",
+        migration_namespace="markets",
+        script_location="sample:migrations",
+        target_metadata=Base.metadata,
+        alembic_registry=ProjectAlembicVersion,
+        metatable_models=[Prices],
+    )
+
+    assert Prices.__table__.schema is None
+    assert "example_assets__prices" in Base.metadata.tables
+    assert "public.example_assets__prices" not in Base.metadata.tables
+
+    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(
+        "example_assets__prices",
+        ["time_index", "asset_identifier"],
+        unique=True,
+    )
+
+
 def test_prepare_for_alembic_reserves_existing_table_name_with_provider_identity(monkeypatch):
     class Base(DeclarativeBase):
         metadata = MetaData()

{mainsequence-4.2.38 → mainsequence-4.2.40}/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,
 )
@@ -708,6 +710,63 @@ def test_platform_managed_schema_resolves_from_sqlalchemy_table_args_only():
     assert sqlalchemy_contracts._resolve_class_schema(Account) == "table_args_schema"
 
 
+def test_platform_managed_default_public_schema_stays_sqlalchemy_default():
+    pytest.importorskip("sqlalchemy")
+
+    from sqlalchemy import MetaData
+    from sqlalchemy import Uuid as SQLAlchemyUuid
+    from sqlalchemy.orm import DeclarativeBase, mapped_column
+
+    class Base(DeclarativeBase):
+        metadata = MetaData()
+
+    class Account(PlatformManagedMetaTable, Base):
+        __tablename__ = "example_assets__account"
+        __table_args__ = {"schema": "public"}
+        __metatable_namespace__ = "example.assets"
+        __metatable_identifier__ = "Account"
+
+        uid: Mapped[uuid.UUID] = mapped_column(SQLAlchemyUuid, primary_key=True)
+
+    assert Account.__table__.schema is None
+    assert sqlalchemy_contracts._resolve_schema(Account.__table__) == "public"
+
+    request = Account.build_registration_request(
+        data_source_uid="dddddddd-dddd-4ddd-8ddd-dddddddddddd",
+    )
+
+    assert request.table_contract.physical.schema_ == "public"
+
+
+def test_platform_managed_default_public_metadata_schema_stays_sqlalchemy_default():
+    pytest.importorskip("sqlalchemy")
+
+    from sqlalchemy import MetaData
+    from sqlalchemy import Uuid as SQLAlchemyUuid
+    from sqlalchemy.orm import DeclarativeBase, mapped_column
+
+    class Base(DeclarativeBase):
+        metadata = MetaData(schema="public")
+
+    class Account(PlatformManagedMetaTable, Base):
+        __tablename__ = "example_assets__account"
+        __metatable_namespace__ = "example.assets"
+        __metatable_identifier__ = "Account"
+
+        uid: Mapped[uuid.UUID] = mapped_column(SQLAlchemyUuid, primary_key=True)
+
+    assert Account.__table__.schema is None
+    assert Account.__table__.fullname == "example_assets__account"
+    assert "example_assets__account" in Base.metadata.tables
+    assert "public.example_assets__account" not in Base.metadata.tables
+
+    request = Account.build_registration_request(
+        data_source_uid="dddddddd-dddd-4ddd-8ddd-dddddddddddd",
+    )
+
+    assert request.table_contract.physical.schema_ == "public"
+
+
 def test_time_index_optional_table_info_resolvers_allow_pending_declarative_class():
     class PendingTimeIndexTable:
         __time_index_name__ = "time_index"
@@ -1535,6 +1594,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,
 ):
@@ -1582,14 +1720,15 @@ def test_platform_managed_register_preserves_authored_sqlalchemy_table_name(
     assert Account.get_storage_hash() == storage_hash
     assert Account.get_physical_table_name() == "example_assets__account"
     assert Account.__table__.name == "example_assets__account"
-    assert Account.__table__.fullname == "public.example_assets__account"
-    assert Base.metadata.tables["public.example_assets__account"] is Account.__table__
+    assert Account.__table__.schema is None
+    assert Account.__table__.fullname == "example_assets__account"
+    assert Base.metadata.tables["example_assets__account"] is Account.__table__
     assert f"public.{physical_table_name}" not in Base.metadata.tables
 
     compiled_sql = str(
         select(Account.__table__).compile(dialect=postgresql.dialect(paramstyle="pyformat"))
     )
-    assert "FROM public.example_assets__account" in compiled_sql
+    assert "FROM example_assets__account" in compiled_sql
     assert physical_table_name not in compiled_sql
     assert storage_hash not in compiled_sql
 
@@ -1621,7 +1760,8 @@ def test_bound_parent_table_foreign_key_stays_sqlalchemy_only():
         )
     )
 
-    assert Account.__table__.fullname == "public.example_assets__account"
+    assert Account.__table__.schema is None
+    assert Account.__table__.fullname == "example_assets__account"
 
     class Asset(PlatformManagedMetaTable, Base):
         __tablename__ = "example_assets__asset"
@@ -1631,7 +1771,7 @@ def test_bound_parent_table_foreign_key_stays_sqlalchemy_only():
         uid: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
         account_uid: Mapped[uuid.UUID] = mapped_column(
             Uuid,
-            ForeignKey("public.example_assets__account.uid", ondelete="RESTRICT"),
+            ForeignKey("example_assets__account.uid", ondelete="RESTRICT"),
             nullable=False,
         )
         symbol: Mapped[str] = mapped_column(String(64), nullable=False)