Can I have multiple subclasses of one model that differ only by database schema?

[ghost]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the SQLModel documentation, with the integrated search.
• I already searched in Google "How to X in SQLModel" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to SQLModel but to Pydantic.
• I already checked if it is not related to SQLModel but to SQLAlchemy.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from typing import Any
from uuid import UUID, uuid4

from pydantic import create_model
from sqlmodel import Field, SQLModel


class ModelTemplate:
    class_name: str
    table_name: str

    constraints: tuple[Any] = tuple()

    table_args_base: dict[str, bool] = {"extend_existing": True, "table": True}

    field_definitions: dict[str, Any]

    @classmethod
    def create_definition_in_schema(cls, schema_name: str) -> type[SQLModel]:

        cls_kwargs = {"__table_args__": (*cls.constraints,
                                         {"schema"         : schema_name,
                                          "extend_existing": True,
                                          "table"          : True},),
                      "__table_name__": f"{schema_name}.{cls.table_name}"}

        return create_model(
            cls.class_name,
            __base__=SQLModel,
            __cls_kwargs__=cls_kwargs,
            **cls.field_definitions,
        )


class FooTemplate(ModelTemplate):
    class_name: str = "Foo"
    table_name: str = "foos"
    field_definitions: dict[str, Any] = {
        "id"  : (UUID, Field(primary_key=True, default=uuid4)),
        "name": (str, Field(nullable=False)),
    }

foo = FooTemplate.create_definition_in_schema("foo")
bar = FooTemplate.create_definition_in_schema("bar")

__all__ = ["foo", "bar"]

Description

I'm trying to figure out if it's possible to have multiple sets of different SQLModel classes that vary only by schema. My usecase is an application that runs from one database instance (Postgres), but uses schemata to segregate customer data. I have implemented the above code, and it runs! But when I run alembic to generate a migration, the tables are not being defined, because the foo and bar classes aren't being registered in the SQLModel.metadata.

What I'm trying to avoid doing is having to go by hand and create subclass models for each customer by hand, eg

class Foo (SQLModel, table=True):
   # definitions in here

class Bar (Foo):
   # ...

class Baz (Foo):
   # ...

and then having to dispatch to the various classes in the application (FastAPI). If a request comes in from a foo customer for access to a Bar object (in schema foo.bar), I would love to be able to call a method that returned the appropriate class, so that the routing methods in FastAPI would be purely ignorant of the implementation of the models in the database.

Does this make any sense at all?

Operating System

Linux

Operating System Details

No response

SQLModel Version

0.0.11

Python Version

Python 3.12.0

Additional Context

No response

[ghost]

OK, this is totally a different problem, and I'm almost there. n/m this one.