Creating grouped SQLAlchemyDTO return object

[ste-pool]

Hello,

I'm finally upgrading some code from starlite -> litestar and I'm having an issue with a "grouped" object from old starlite code with the new SQLAlchemyDTO:

class Foo(Base):
    __tablename__ = "foo"
    id: Mapped[String] = mapped_column(String, primary_key=True)

FooDTO = SQLAlchemyDTO[Foo]

class Bar(BaseModel):
    class Config:
        arbitrary_types_allowed = True
    foos: list[Foo]
    blah: str

@get("/get_bar", dto=FooDTO)
async def get_bar(db_session: AsyncSession) -> Bar:
    foos = await db_session.scalars(select(Foo))
    return Bar(foos=foos.all(), blah="hello")

This complains that the response cannot be serialised because Foo isn't serlializable, which makes sense as that's what the DTO is for. If I swap the type to be foos: list[FooDTO] it then fails pydantic validation because it is obviously the wrong type.

I also had to add an arbitrary_types_allowed which makes me believe I'm on the wrong track...

How would I achieve this in litestar? Before it would just magically convert using the dto_factory.

Tested on a clean env

app.txt
pip_freeze.txt

Edit: Is there a way to convert in the route to get an instance of FooDTO from an instance of Foo so I can directly create a Bar?

[thomastu]

I think you're looking for the pattern documented here: https://docs.litestar.dev/2/usage/dto/1-abstract-dto.html#wrapping-return-data

from typing import Generic

class Foo(Base):
    __tablename__ = "foo"
    id: Mapped[String] = mapped_column(String, primary_key=True)

FooDTO = SQLAlchemyDTO[Foo]

T = TypeVar("T")

@dataclass
class Bar(Generic[T]):

    foos: list[T]
    blah: str

@get("/get_bar", dto=FooDTO)
async def get_bar(db_session: AsyncSession) -> Bar[Foo]:
    foos = await db_session.scalars(select(Foo))
    return Bar(foos=foos.all(), blah="hello")

[ste-pool]

Well, I definitely missed that bit 🤦 That works for me! Thanks 😄

[ste-pool]

Sorry, one more question. That actually doesn't perform any validation ("hello" can be 2). Before, it used to be a pydantic model. Is there something similar we can do here to still keep Bar as a pyndantic model rather than just a dataclass so that validation is performed?

[thomastu]

One approach to keep pydantic validation could be to use a pydantic dataclass instead -

from pydantic.dataclasses import dataclass

@dataclass
class Bar(Generic[T]):

    foos: list[T]
    blah: str

Based on this line in the docs:

The DTO Factory type will find the attribute on the wrapper type that holds the data and perform its serialization operations upon it.

I would have expected Pydantic generics to work but it looks like litestar sees a pydantic basemodel and pydantic crashes without a way to serialize the orm object to json. I haven't tried it, but I wonder if Tiangolo's SQLModel library would happen to work here since that would generate the pydantic schema for pydantic serialization.

# This cannot be used to wrap return data 

class Bar(BaseModel, Generic[T]):

    foos: list[T] 
    blah: str

[ste-pool]

Amazing, thanks so much!