Alembic Autogenerate Error

[RicardoJDaleprane]

I have a problem similar to the following discussion https://github.com/sqlalchemy/alembic/discussions/1416.

PostgreSQL 12.20
Ubuntu 12.20-0ubuntu0.20.04.1

My model

from __future__ import annotations
import enum
from datetime import datetime
from typing import List, Annotated
from uuid import UUID as UuidType
from fastapi_users.db import SQLAlchemyBaseUserTable
from fastapi_users_db_sqlalchemy import SQLAlchemyBaseUserTableUUID


from sqlalchemy import Column, String, Boolean, ForeignKey, Table, Integer, Date, Text, Numeric, Enum, MetaData
from sqlalchemy import DateTime, FetchedValue, func
from sqlalchemy.dialects.postgresql import UUID as UuidColumn
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.ext.compiler import compiles
from sqlalchemy.orm import relationship, Mapped, mapped_column, with_polymorphic, DeclarativeBase
from sqlalchemy.sql.expression import FunctionElement
from uuid6 import uuid7

from sqlalchemy.ext.asyncio import AsyncAttrs


from .session import Base


uuid = Annotated[UuidType, mapped_column(primary_key=True)]
str1 = Annotated[str, mapped_column(String(1), nullable=True)]
str2 = Annotated[str, mapped_column(String(2), nullable=True)]
str8 = Annotated[str, mapped_column(String(8), nullable=True)]
str10 = Annotated[str, mapped_column(String(10), nullable=True)]
str10_not_null = Annotated[str, mapped_column(String(10), nullable=False)]
str11 = Annotated[str, mapped_column(String(11), nullable=True)]
str14 = Annotated[str, mapped_column(String(14), nullable=True)]
str20 = Annotated[str, mapped_column(String(20), nullable=True)]
str30_not_null = Annotated[str, mapped_column(String(30), nullable=False)]
str39_uid = Annotated[str, mapped_column(String(39), nullable=True)]
str36_uuid = Annotated[str, mapped_column(String(36), nullable=False)]
str36_uuid_null = Annotated[str, mapped_column(String(36), nullable=True)]
str50 = Annotated[str, mapped_column(String(50), nullable=True)]
str50_null = Annotated[str, mapped_column(String(50), nullable=False)]
str100 = Annotated[str, mapped_column(String(100), nullable=True)]
str150 = Annotated[str, mapped_column(String(150), nullable=True)]
str200 = Annotated[str, mapped_column(String(200), nullable=True)]
url = Annotated[str, mapped_column(String(2083), nullable=True)]
intpk = Annotated[int, mapped_column(primary_key=True, index=True)]
valor_monetario = Annotated[float, mapped_column(Numeric(precision=10, scale=2), nullable=True)]
valor_monetario_not_null = Annotated[float, mapped_column(Numeric(precision=10, scale=2), nullable=False)]
data = Annotated[Date, mapped_column(Date, nullable=True)]
data_null = Annotated[Date, mapped_column(Date, nullable=True)]
data_idx = Annotated[Date, mapped_column(Date, index=True)]
text = Annotated[Text, mapped_column(Text)]
text_null = Annotated[Text, mapped_column(Text, nullable=True)]
boleano = Annotated[Boolean, mapped_column(Boolean, default=True)]


class UuidMixin:
    uuid: Mapped[UuidType] = mapped_column(
        "uuid",
        UuidColumn(as_uuid=True),
        primary_key=True,
        default=uuid7,
        nullable=False,
    )


class IdMixin:
    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, nullable=False)


class utcnow(FunctionElement):
    type = DateTime()
    inherit_cache = True


@compiles(utcnow, "postgresql")
def pg_utcnow(element, compiler, **kw):
    return "TIMEZONE('utc', CURRENT_TIMESTAMP)"


class TimestampMixin:
    created_at: Mapped[datetime] = mapped_column(
        DateTime,
        nullable=False,
        server_default=utcnow(),
    )
    updated_at: Mapped[datetime] = mapped_column(
        DateTime,
        nullable=True,
        index=True,
        onupdate=func.now(),
        server_default=utcnow(),
        server_onupdate=FetchedValue(),
    )



class Inquilino(UuidMixin, Base):
    __tablename__ = "inquilinos"
    __table_args__ = ({"schema": "shared"})

    nome = Column(String(100), nullable=False, unique=False)
    cpf_cnpj = Column(String(14), nullable=False, unique=True)
    pessoa_celular = Column(String(20), nullable=True, unique=False)

    # Relacionamento com a tabela de usuários
    usuario: Mapped[List["RbacUser"]] = relationship(back_populates="inquilino", passive_deletes=True,
                                                     lazy="selectin",
                                                     join_depth=2)







comercial_relacionamento_pessoa_empresa = Table('comercial_relacionamento_pessoa_empresa',
                                                Base.metadata,
                                                Column('relacao_comercial_uuid', UUID(as_uuid=True),
                                                       ForeignKey('comercial_relacoes_comercial.uuid',
                                                                  ondelete="CASCADE")),
                                                Column('pessoa_uuid', UUID(as_uuid=True),
                                                       ForeignKey('comercial_pessoas.uuid', ondelete="CASCADE")),
                                                )


class ComercialRelacaoComercial(Base, TimestampMixin, UuidMixin):
    __tablename__ = "comercial_relacoes_comercial"
    log_auditoria_habilitado = False

    descricao_relacao_comercial: str = Column(String(30), nullable=False)
    pessoa_relacao: Mapped[List["ComercialPessoa"]] = relationship(secondary=comercial_relacionamento_pessoa_empresa,
                                                                   back_populates='rc',
                                                                   passive_deletes=True,
                                                                   lazy="selectin",
                                                                   join_depth=1, )


class ComercialTipoEndereco(Base, TimestampMixin, UuidMixin):
    __tablename__ = "comercial_tipos_endereco"
    log_auditoria_habilitado = False

    tipo_endereco_descricao: str = Column(String(30), nullable=False)
    relacao_endereco_tp: Mapped[List["ComercialEndereco"]] = relationship(back_populates="relacao_tipo_endereco",
                                                                          passive_deletes=True,
                                                                          lazy="selectin",
                                                                          cascade="all, delete-orphan",
                                                                          join_depth=1)


class ComercialPessoa(UuidMixin, Base, TimestampMixin):
    __tablename__ = "comercial_pessoas"
    log_auditoria_habilitado = False

    pessoa_status: bool = Column(Boolean, unique=False, default=True)
    pessoa_telefone: Mapped[str20]
    pessoa_celular: Mapped[str20]
    pessoa_tipo: Mapped[str1]
    pessoa_email: Mapped[str100]
    pessoa_local_evento: bool = Column(Boolean, unique=False, default=False)

    rc: Mapped[List["ComercialRelacaoComercial"]] = relationship(secondary=comercial_relacionamento_pessoa_empresa,
                                                                 back_populates='pessoa_relacao', passive_deletes=True,
                                                                 lazy="selectin", join_depth=1)

    enderecos: Mapped[List["ComercialEndereco"]] = relationship(back_populates="pessoa", passive_deletes=True,
                                                                lazy="selectin",
                                                                join_depth=2)
    

    relacao_conta: Mapped[List["FinanceiroConta"]] = relationship(back_populates="relacao_pessoa", passive_deletes=True,
                                                                  lazy="selectin", cascade="all, delete-orphan",
                                                                  join_depth=1)

    __mapper_args__ = {"polymorphic_identity": "comercial_pessoas",
                       "polymorphic_on": "pessoa_tipo",
                       }


class ComercialJuridica(ComercialPessoa):
    __tablename__ = "comercial_juridicas"
    log_auditoria_habilitado = False

    uuid: Mapped[uuid] = mapped_column(ForeignKey("comercial_pessoas.uuid", ondelete="CASCADE"), primary_key=True)

    juridica_cnpj: Mapped[str14]
    juridica_email_fiscal: Mapped[str100]
    juridica_insc_est: Mapped[str50]
    juridica_ins_mun: Mapped[str50]
    juridica_razao_social: Mapped[str200]
    juridica_representante: Mapped[str100]

    __mapper_args__ = {
        "polymorphic_identity": "0",
        "polymorphic_load": "selectin"
    }


class ComercialFisica(ComercialPessoa):
    __tablename__ = "comercial_fisicas"
    log_auditoria_habilitado = False

    uuid: Mapped[uuid] = mapped_column(ForeignKey("comercial_pessoas.uuid", ondelete="CASCADE"), primary_key=True)

    fisica_cpf: Mapped[str11]
    fisica_rg: Mapped[str20]
    fisica_genero: Mapped[str2]
    fisica_nome: Mapped[str100]

    __mapper_args__ = {
        "polymorphic_identity": "1",
        "polymorphic_load": "selectin"
    }


class ComercialEndereco(Base, TimestampMixin, UuidMixin):
    __tablename__ = "comercial_enderecos"
    log_auditoria_habilitado = False

    endereco_pessoa_status: bool = Column(Boolean, unique=False, default=True)
    endereco_pessoa_descricao: Mapped[str50]
    endereco_pessoa_numero: Mapped[str8]
    endereco_pessoa_complemento: Mapped[str50]
    endereco_pessoa_cep: Mapped[str8]

    fk_pessoa_uuid: Mapped[UuidType] = mapped_column(ForeignKey("comercial_pessoas.uuid", ondelete="CASCADE"),
                                                     nullable=False)
    pessoa: Mapped["ComercialPessoa"] = relationship(back_populates="enderecos", lazy="selectin", join_depth=1)

    fk_tipo_endereco_uuid: Mapped[UuidType] = mapped_column(ForeignKey("comercial_tipos_endereco.uuid",
                                                                       ondelete="CASCADE"), nullable=False)
    relacao_tipo_endereco: Mapped["ComercialTipoEndereco"] = relationship(back_populates="relacao_endereco_tp",
                                                                          lazy="selectin",
                                                                          join_depth=2)



rbac_papeis_usuario = Table(
    'rbac_papeis_usuario', Base.metadata,
    Column('user_uuid', UUID(as_uuid=True), ForeignKey('shared.rbac_usuarios.id'), primary_key=True),
    Column('papel_uuid', UUID(as_uuid=True), ForeignKey('shared.rbac_papeis.uuid'), primary_key=True),
   
    schema='shared'
)

rbac_papel_permissoes = Table(
    'rbac_papel_permissoes', Base.metadata,
    Column('papel_uuid', UUID(as_uuid=True), ForeignKey('shared.rbac_papeis.uuid'), primary_key=True),
    Column('permissao_id', Integer, ForeignKey('shared.rbac_permissoes.id'), primary_key=True),
    
    schema='shared'

)


class RbacPermissao(Base):
    __tablename__ = "rbac_permissoes"
    log_auditoria_habilitado = False
    id = Column(Integer, primary_key=True, index=True)
    nome: Mapped[str50] = mapped_column(nullable=False, unique=True)
    papeis: Mapped[List["RbacPapel"]] = relationship(secondary=rbac_papel_permissoes,
                                                     back_populates='permissoes',
                                                     passive_deletes=True,
                                                     lazy="selectin",
                                                     join_depth=1, )

   
    __table_args__ = ({"schema": "shared"},)


class RbacPapel(UuidMixin, Base):
    __tablename__ = "rbac_papeis"
    log_auditoria_habilitado = False
    # id = Column(Integer, primary_key=True, index=True, autoincrement=True)
    nome: Mapped[str50] = mapped_column(nullable=False, unique=True)
    permissoes: Mapped[List["RbacPermissao"]] = relationship(secondary=rbac_papel_permissoes,
                                                             back_populates='papeis',
                                                             passive_deletes=True,
                                                             lazy="selectin",
                                                             join_depth=2, )
    usuarios: Mapped[List["RbacUser"]] = relationship(secondary=rbac_papeis_usuario,
                                                      back_populates='papeis',
                                                      passive_deletes=True,
                                                      lazy="selectin",
                                                      join_depth=1, )
    
    __table_args__ = ({"schema": "shared"},)


class RbacUser(SQLAlchemyBaseUserTableUUID, Base):
    __tablename__ = "rbac_usuarios"
    log_auditoria_habilitado = False

    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    nome: Mapped[str50_null]
    papeis: Mapped[List[RbacPapel]] = relationship(secondary=rbac_papeis_usuario,
                                                   back_populates='usuarios',
                                                   passive_deletes=True,
                                                   lazy="selectin",
                                                   join_depth=1)
   
    fk_inquilino_uuid: Mapped[UuidType] = mapped_column(ForeignKey("shared.inquilinos.uuid", ondelete="CASCADE"),
                                                        nullable=False)
    inquilino: Mapped["Inquilino"] = relationship(back_populates="usuario",
                                                  lazy="selectin",
                                                  passive_deletes=True,
                                                  join_depth=1)
    __table_args__ = ({"schema": "shared"},)




class EstoqueSetor(Base, UuidMixin):
    __tablename__ = "estoque_setores"
    log_auditoria_habilitado = False

    setor_nome: Mapped[str30_not_null]
    relacao_tipo_equipamento: Mapped[List["EstoqueTipoEquipamento"]] = relationship(
        back_populates="relacao_setor",
        passive_deletes=True,
        lazy="selectin",
        cascade="all, delete-orphan",
        join_depth=1)


class EstoqueTipoEquipamento(Base, UuidMixin):
    __tablename__ = "estoque_tipos_equipamentos"
    log_auditoria_habilitado = False

    tipo_equipamento_nome: Mapped[str50_null]
    fk_setor_uuid: Mapped[UuidType] = mapped_column(ForeignKey("estoque_setores.uuid", ondelete="CASCADE"),
                                                    nullable=False)
    relacao_setor: Mapped["EstoqueSetor"] = relationship(back_populates="relacao_tipo_equipamento",
                                                         lazy="selectin",
                                                         join_depth=4)
    relacao_equipamento: Mapped[List["EstoqueEquipamento"]] = relationship(
        back_populates="relacao_tipo_equipamento",
        passive_deletes=True,
        lazy="selectin",
        cascade="all, delete-orphan",
        join_depth=1)


class EstoqueEquipamento(Base, UuidMixin):
    __tablename__ = "estoque_equipamentos"
    log_auditoria_habilitado = False

    equipamento_nome: Mapped[str50_null]
    equipamento_informacoes: Mapped[text]
    equipamento_eletrico: Mapped[boleano]
    fk_tipo_equipamento_uuid: Mapped[UuidType] = mapped_column(ForeignKey("estoque_tipos_equipamentos.uuid",
                                                                          ondelete="CASCADE"), nullable=False)
    relacao_tipo_equipamento: Mapped["EstoqueTipoEquipamento"] = relationship(back_populates="relacao_equipamento",
                                                                              lazy="selectin",
                                                                              join_depth=3)
    relacao_item_equipamento: Mapped[List["EstoqueItemEquipamento"]] = relationship(
        back_populates="relacao_equipamento",
        passive_deletes=True,
        lazy="selectin",
        cascade="all, delete-orphan",
        join_depth=1)


class EstoqueItemEquipamento(Base, TimestampMixin, UuidMixin):
    __tablename__ = "estoque_itens_equipamentos"
    log_auditoria_habilitado = False

    itens_equipamentos_ns: Mapped[str50]
    itens_equipamentos_patrimonio: Mapped[str10_not_null]
    itens_equipamentos_data_compra: Mapped[data]
    itens_equipamentos_prazo_garantia: Mapped[data]
    itens_equipamentos_voltagem: Mapped[str1]
    itens_equipamentos_valor_aquisicao: Mapped[valor_monetario]
    itens_equipamentos_rfid_uid: Mapped[str39_uid]
    itens_equipamentos_url: Mapped[url]

    fk_equipamento_uuid: Mapped[UuidType] = mapped_column(ForeignKey("estoque_equipamentos.uuid",
                                                                     ondelete="CASCADE"), nullable=False)
    relacao_equipamento: Mapped["EstoqueEquipamento"] = relationship(back_populates="relacao_item_equipamento",
                                                                     lazy="selectin",
                                                                     join_depth=2)
    relacao_manutencao: Mapped[List["EstoqueManutencaoEquipamento"]] = relationship(
        back_populates="relacao_item_equipamento",
        passive_deletes=True,
        lazy="selectin",
        cascade="all, delete-orphan",
        join_depth=1)


class EstoqueManutencaoEquipamento(Base, UuidMixin):
    __tablename__ = "estoque_manutencoes_equipamentos"
    log_auditoria_habilitado = False

    manutencao_equipamento_data_entrada: Mapped[data]
    manutencao_equipamento_data_retorno: Mapped[data_null]
    manutencao_equipamento_defeito_apresentado: Mapped[str100]
    manutencao_equipamento_correcao_realizada: Mapped[text]
    fk_itens_equipamentos_uuid: Mapped[UuidType] = mapped_column(ForeignKey("estoque_itens_equipamentos.uuid",
                                                                            ondelete="CASCADE"), nullable=False)
    relacao_item_equipamento: Mapped["EstoqueItemEquipamento"] = relationship(back_populates="relacao_manutencao",
                                                                              lazy="selectin",
                                                                              join_depth=4)




class FinanceiroTipoContaEnum(enum.Enum):
    PAGAR = "Pagar"
    RECEBER = "Receber"


class FinanceiroTipoMovimentacaoEnum(enum.Enum):
    CREDITO = "Crédito"
    DEBITO = "Débito"


class FinanceiroStatus(Base, IdMixin):
    __tablename__ = "financeiro_status"
    log_auditoria_habilitado = False

    statuss_nome_status: Mapped[str20]
    statuss_descricao: Mapped[str200]
    relacao_conta: Mapped[List["FinanceiroConta"]] = relationship(back_populates="relacao_statuss",
                                                                  passive_deletes=True,
                                                                  lazy="selectin", cascade="all, delete-orphan",
                                                                  join_depth=1)
    relacao_parcelas: Mapped[List["FinanceiroParcela"]] = relationship(back_populates="relacao_statuss",
                                                                       passive_deletes=True,
                                                                       lazy="selectin", cascade="all, delete-orphan",
                                                                       join_depth=1)


class FinanceiroForma_Pagamento(Base, IdMixin):
    __tablename__ = "financeiro_formas_pagamento"
    log_auditoria_habilitado = False

    formas_pagamento_descricao: Mapped[str20]
    relacao_pagamentos: Mapped[List["FinanceiroPagamento"]] = relationship(back_populates="relacao_formas_pagamento",
                                                                           passive_deletes=True, lazy="selectin",
                                                                           cascade="all, delete-orphan", join_depth=1)


class FinanceiroCategoria(Base, IdMixin):
    __tablename__ = "financeiro_categorias"
    log_auditoria_habilitado = False

    categorias_nome: Mapped[str20]

    relacao_conta: Mapped[List["FinanceiroConta"]] = relationship(back_populates="relacao_categorias",
                                                                  passive_deletes=True,
                                                                  lazy="selectin", cascade="all, delete-orphan",
                                                                  join_depth=1)


class FinanceiroCentro_Custo(Base, IdMixin):
    __tablename__ = "financeiro_centros_custo"
    log_auditoria_habilitado = False

    centros_custo_nome: Mapped[str20]
    centros_custo_descricao: Mapped[str100]
    relacao_conta: Mapped[List["FinanceiroConta"]] = relationship(back_populates="relacao_centros_custo",
                                                                  passive_deletes=True,
                                                                  lazy="selectin", cascade="all, delete-orphan",
                                                                  join_depth=1)


class FinanceiroParcela(Base, IdMixin):
    __tablename__ = "financeiro_parcelas"
    log_auditoria_habilitado = True

    parcelas_numero_parcela: Mapped[int] = mapped_column(Integer, nullable=False)
    parcelas_valor_parcela: Mapped[valor_monetario]
    parcelas_valor_juros: Mapped[valor_monetario]
    parcelas_valor_multa: Mapped[valor_monetario]
    parcelas_valor_desconto: Mapped[valor_monetario]
    parcelas_data_vencimento: Mapped[data_idx]
    fk_contas_id: Mapped[int] = mapped_column(ForeignKey("financeiro_contas.id", ondelete="CASCADE"), nullable=False)
    relacao_conta: Mapped["FinanceiroConta"] = relationship(back_populates="relacao_parcelas", lazy="selectin",
                                                            join_depth=2)
    fk_statuss_id: Mapped[int] = mapped_column(ForeignKey("financeiro_status.id", ondelete="CASCADE"),
                                               nullable=False)
    relacao_statuss: Mapped["FinanceiroStatus"] = relationship(back_populates="relacao_parcelas", lazy="selectin",
                                                               join_depth=2)
    relacao_pagamentos: Mapped[List["FinanceiroPagamento"]] = relationship(back_populates="relacao_parcela",
                                                                           passive_deletes=True,
                                                                           lazy="selectin",
                                                                           cascade="all, delete-orphan",
                                                                           join_depth=1)


class FinanceiroPagamento(Base, IdMixin):
    __tablename__ = "financeiro_pagamentos"
    log_auditoria_habilitado = True

    data_pagamento: Mapped[data_idx]
    valor_pago: Mapped[valor_monetario]
    observacao: Mapped[text]
    fk_parcelas_id: Mapped[int] = mapped_column(ForeignKey("financeiro_parcelas.id", ondelete="CASCADE"),
                                                nullable=False)
    relacao_parcela: Mapped["FinanceiroParcela"] = relationship(back_populates="relacao_pagamentos", lazy="selectin",
                                                                join_depth=2)
    fk_contas_corrente_id: Mapped[int] = mapped_column(ForeignKey("financeiro_contas_corrente.id",
                                                                  ondelete="CASCADE"), nullable=False)
    relacao_contas_corrente: Mapped["FinanceiroConta_Corrente"] = relationship(back_populates="relacao_pagamentos",
                                                                               lazy="selectin", join_depth=2)
    fk_formas_pagamento_id: Mapped[int] = mapped_column(ForeignKey("financeiro_formas_pagamento.id",
                                                                   ondelete="CASCADE"), nullable=False)
    relacao_formas_pagamento: Mapped["FinanceiroForma_Pagamento"] = relationship(back_populates="relacao_pagamentos",
                                                                                 lazy="selectin", join_depth=2)
    relacao_movimentacoes_conta: Mapped[List[
        "FinanceiroMovimentacao_Conta"]] = relationship(back_populates="relacao_pagamentos",
                                                        passive_deletes=True,
                                                        lazy="selectin",
                                                        cascade="all, delete-orphan",
                                                        join_depth=1)


class FinanceiroConta(Base, IdMixin):
    __tablename__ = "financeiro_contas"
    log_auditoria_habilitado = True

    contas_tipo_conta: Mapped[FinanceiroTipoContaEnum] = mapped_column(Enum(FinanceiroTipoContaEnum,
                                                                            
                                                                            inherit_schema=True
                                                                            
                                                                            ),
                                                                       nullable=False)
    contas_data_emissao: Mapped[data]
    contas_data_vencimento: Mapped[data]
    contas_valor_total: Mapped[valor_monetario]
    contas_valor_juros: Mapped[valor_monetario]
    contas_valor_multa: Mapped[valor_monetario]
    contas_valor_desconto: Mapped[valor_monetario]
    contas_descricao: Mapped[str200]
    fk_pessoas_uuid: Mapped[int] = mapped_column(ForeignKey("comercial_pessoas.uuid", ondelete="CASCADE"),
                                                 nullable=False)
    relacao_pessoa: Mapped["ComercialPessoa"] = relationship(back_populates="relacao_conta", lazy="selectin",
                                                             join_depth=2)
    fk_statuss_id: Mapped[int] = mapped_column(ForeignKey("financeiro_status.id", ondelete="CASCADE"),
                                               nullable=False)
    relacao_statuss: Mapped["FinanceiroStatus"] = relationship(back_populates="relacao_conta", lazy="selectin",
                                                               join_depth=2)
    fk_categorias_id: Mapped[int] = mapped_column(ForeignKey("financeiro_categorias.id", ondelete="CASCADE"),
                                                  nullable=False)
    relacao_categorias: Mapped["FinanceiroCategoria"] = relationship(back_populates="relacao_conta", lazy="selectin",
                                                                     join_depth=2)
    fk_centros_custo_id: Mapped[int] = mapped_column(ForeignKey("financeiro_centros_custo.id", ondelete="CASCADE"),
                                                     nullable=False)
    relacao_centros_custo: Mapped["FinanceiroCentro_Custo"] = relationship(back_populates="relacao_conta",
                                                                           lazy="selectin",
                                                                           join_depth=2)
    relacao_parcelas: Mapped[List["FinanceiroParcela"]] = relationship(back_populates="relacao_conta",
                                                                       passive_deletes=True,
                                                                       lazy="selectin", cascade="all, delete-orphan",
                                                                       join_depth=1)


class FinanceiroConta_Corrente(Base, IdMixin):
    __tablename__ = "financeiro_contas_corrente"
    log_auditoria_habilitado = True

    contas_corrente_nome_conta: Mapped[str50]
    contas_corrente_saldo_inicial: Mapped[valor_monetario]
    contas_corrente_data_criacao: Mapped[data_idx]
    contas_corrente_descricao: Mapped[str100]
    relacao_movimentacoes_conta: Mapped[List["FinanceiroMovimentacao_Conta"]] = relationship(
        back_populates="relacao_contas_corrente",
        passive_deletes=True, lazy="selectin",
        cascade="all, delete-orphan", join_depth=1)
    relacao_pagamentos: Mapped[List["FinanceiroPagamento"]] = relationship(back_populates="relacao_contas_corrente",
                                                                           passive_deletes=True, lazy="selectin",
                                                                           cascade="all, delete-orphan", join_depth=1)


class FinanceiroMovimentacao_Conta(Base, IdMixin):
    __tablename__ = "financeiro_movimentacoes_conta"
    log_auditoria_habilitado = True

    movimentacoes_conta_tipo_movimentacao: Mapped[FinanceiroTipoMovimentacaoEnum] = mapped_column(
        Enum(FinanceiroTipoMovimentacaoEnum,
             #     Multi Tennat
             inherit_schema=True
             #     /Multi Tennat
             ),
        nullable=False,

    )
    movimentacoes_conta_valor_movimentacao: Mapped[valor_monetario]
    movimentacoes_conta_data_movimentacao: Mapped[data_idx]
    movimentacoes_conta_descricao: Mapped[str200]
    fk_contas_corrente_id: Mapped[int] = mapped_column(ForeignKey("financeiro_contas_corrente.id", ondelete="CASCADE"),
                                                       nullable=False)
    relacao_contas_corrente: Mapped[
        "FinanceiroConta_Corrente"] = relationship(back_populates="relacao_movimentacoes_conta",
                                                   lazy="selectin", join_depth=2)
    fk_pagamentos_id: Mapped[int] = mapped_column(ForeignKey("financeiro_pagamentos.id", ondelete="CASCADE"),
                                                  nullable=False)
    relacao_pagamentos: Mapped["FinanceiroPagamento"] = relationship(back_populates="relacao_movimentacoes_conta",
                                                                     lazy="selectin", join_depth=2)


financeiro_conta_manutencao_equipamentos = Table('financeiro_conta_manutencao_equipamentos', Base.metadata,
                                                 Column('manutencao_uuid', UUID(as_uuid=True),
                                                        ForeignKey('estoque_manutencoes_equipamentos.uuid'),
                                                        primary_key=True),
                                                 Column('conta_id', Integer,
                                                        ForeignKey('financeiro_contas.id'), primary_key=True)
                                                 )




class HistoricoAlteracoes(Base, UuidMixin):
    __tablename__ = 'historico_alteracoes'

    tabela: Mapped[str100]
    data_modificacao: Mapped[datetime] = mapped_column(DateTime, nullable=False)
    action: Mapped[str10]  # 'update', 'delete'
    usuario_id: Mapped[str36_uuid_null]  # Assumindo que o "ID" do usuário é uma "string"
    registro_id: Mapped[str36_uuid]  # "ID" do registro que está sendo alterado

    
    updates: Mapped[List["HistoricoUpdate"]] = relationship(back_populates="alteracao", passive_deletes=True,
                                                            lazy="selectin", cascade="all, delete-orphan",
                                                            join_depth=1)
    deletes: Mapped["HistoricoDelete"] = relationship(back_populates="alteracao", passive_deletes=True,
                                                      lazy="selectin", cascade="all, delete-orphan",
                                                      join_depth=1)


class HistoricoUpdate(Base, UuidMixin):
    __tablename__ = 'historico_update'

    fk_historico_alteracoes_uuid: Mapped[UuidType] = mapped_column(ForeignKey("historico_alteracoes.uuid",
                                                                              ondelete="CASCADE"), nullable=False)
    coluna: Mapped[str100]
    valor_antigo: Mapped[str200]
    valor_novo: Mapped[str200]
   
    alteracao: Mapped["HistoricoAlteracoes"] = relationship(back_populates="updates", lazy="selectin", join_depth=2)


class HistoricoDelete(Base, UuidMixin):
    __tablename__ = 'historico_delete'

    fk_historico_alteracoes_uuid: Mapped[UuidType] = mapped_column(ForeignKey("historico_alteracoes.uuid",
                                                                              ondelete="CASCADE"), nullable=False)
    registro_deletado: Mapped[text]  
    
    alteracao: Mapped["HistoricoAlteracoes"] = relationship(back_populates="deletes", lazy="selectin", join_depth=2)



PESSOA_POLY = with_polymorphic(
    ComercialPessoa,  # Modelo base
    [ComercialFisica, ComercialJuridica]  # Subclasses
)

env.py

import asyncio
import logging
from logging.config import fileConfig
from alembic import context
from sqlalchemy import text, pool
from sqlalchemy.ext.asyncio import async_engine_from_config
from sqlalchemy.ext.asyncio import AsyncEngine
from app.database.models import Base
from app.config import URL_BD

config = context.config
config.set_main_option("sqlalchemy.url", URL_BD)

if config.config_file_name is not None:
    fileConfig(config.config_file_name)

target_metadata = Base.metadata

logging.basicConfig()
# logging.getLogger("sqlalchemy.engine").setLevel(logging.INFO)


logging.getLogger("sqlalchemy.engine").setLevel(logging.DEBUG)


def run_migrations_offline() -> None:
    raise NotImplementedError("Modo offline não implementado.")


async def run_async_migrations() -> None:
    connectable: AsyncEngine = async_engine_from_config(
        config.get_section(config.config_ini_section, {}),
        prefix="sqlalchemy.",
        poolclass=pool.NullPool,
    )

    args = context.get_x_argument(as_dictionary=True)
    special_schema = args.get("special_schema")
    current_tenant = args.get("tenant")

    if current_tenant is None and special_schema is None:
        raise Exception("Você deve fornecer 'tenant' ou 'special_schema' como argumento.")
    elif current_tenant is not None and special_schema is not None:
        raise Exception("'tenant' e 'special_schema' não podem ser usados simultaneamente.")

    async with connectable.connect() as async_connection:
        await async_connection.run_sync(
            lambda connection: run_migrations_online_internal(connection, current_tenant, special_schema)
        )

    await connectable.dispose()


def run_migrations_online_internal(connection, current_tenant: str, special_schema: str) -> None:
    if special_schema == "shared":
        script_location = "alembic/versions/shared"
        schema_name = "shared"
        """
        Esquema da Tabela definido como o mesmo valor do esquema a serem criadas as Tabelas
        Como a tabelas comuns já tem o esquema definido nelas essa configuração garante que a tabela versão será 
            criada no mesmo esquma das tabelas compartilhadas
        """
        schema_table = special_schema

    else:
        script_location = "alembic/versions/tenants"
        schema_name = current_tenant
        """
        Esquema da Tabela definido como None
        Como a tabelas dos inquilinos serão cadastradas cada um em um esquema diferente elas saõ configuradas como None
        Se nesse ponto já definirmos o esquema como o do inquilino a migração junto como o  search_path exclui a tablea
            de versão no script de migração por isso é necessáiro configurar o esquema como None no Upgrade junto com 
            o search_path a tabela de versão vai ser criada no mesmo esquema do inquilino 
        """
        schema_table = None

    context.script.version_locations = [script_location]

    create_schema_if_not_exists(connection, schema_name)

    if current_tenant:
        connection.execute(text(f'SET search_path TO "{current_tenant}"'))
        connection.commit()
    else:
        print("set schema")
        connection.execute(text(f'SET search_path TO "shared"'))
        connection.commit()

    # Verificar o search_path configurado
    result = connection.execute(text("SHOW search_path"))
    current_search_path = result.scalar()
    print(f"Current search_path: {current_search_path}")

    def include_object(object, name, type_, reflected, compare_to):

        schema = getattr(object, "schema", None)

        if special_schema == "shared":
            # Sobrescreve o schema para None apenas se for 'shared'
            object.schema = None
            # Inclusçaõ na Migração apenas as tabelas compartilhadas
            if schema == "shared":
                return True
            else:
                return False

        if special_schema is None:
            # Inclusão na Migração apenas as tabelas dos inquilinos
            if schema is None:
                return True
            else:
                return False

        # Exclui por padrão se não atender aos critérios
        return False

    

    context.configure(
        connection=connection,
        target_metadata=target_metadata,
        include_object=include_object,
        version_table_schema=schema_table,
        



    )

    with context.begin_transaction():
        context.run_migrations()


def create_schema_if_not_exists(connection, schema_name: str):
    query = text(f'CREATE SCHEMA IF NOT EXISTS "{schema_name}"')
    connection.execute(query)
    connection.commit()


def run_migrations_online() -> None:
    asyncio.run(run_async_migrations())


if context.is_offline_mode():
    run_migrations_offline()
else:
    run_migrations_online()

The configuration is to use multi-tenant where common tables are configured for the shared schema and the exclusive tenant tables do not have a declared schema and the correct schema is dynamically informed during migration.
When Autogenerate is for adding columns to tenant tables to work correctly
How long does it take to include a column in the shared schema tables even if the tables already exist? The generated script creates all the tables again.
I have already tried configuring include_schemas and include_name without success.
I imagine that this behavior may be related to the schema declaration explicitly in the model since the error only occurs in these tables.

[zzzeek]

your config assuming it's copied from the recipe here: https://alembic.sqlalchemy.org/en/latest/cookbook.html#rudimental-schema-level-multi-tenancy-for-postgresql-mysql-other-databases

is missing setting up the default_schema_name in your dialect that is otherwise cached:

you otherwise want to look at your models and the tables that autogenerate is proposing to see if the "schema" attribute matches up. if they don't, then alembic is seeing things differently than your model does.