How to minimize type declarations?

[waldner]

Let's assume I have a "user" type (for example), which should used both to exchange data between certain services and also as schema to create the corresponding database table.
My goal is to be able to declare class User once, with all its constraints and validations, then include that declaration anywhere necessary (eg fastapi methods, pydantic checks etc).
However when it comes to piccolo, it seems that you are more or less forced to redeclare the schema in a piccolo.table.Table-compatible format, which (AFAIK) forces you to basically write the class definition another time, which introduces duplication.
Is there a way to reuse existing classes to create piccolo table schemas?

[dantownsend]

If you're dealing with Pydantic classes, you could do something like:

from piccolo.columns import Varchar
from piccolo.tables import Table
from piccolo.utils.pydantic import create_pydantic_model

class User(Table):
    name = Varchar()


class UserModel(create_pydantic_model(User)):
    def my_custom_method(self):
        ...

So starting from the Piccolo table, and then creating the Pydantic model for exchanging data with other services.

You can then add the validation to the Pydantic model. Creating Piccolo table instances from the Pydantic model should then be as simple as:

piccolo_user_object = User(**UserModel.model_dump())

Likewise you can go from Piccolo table instances to Pydantic model instances:

user = await User.objects().first()
user_model = UserModel(**user.to_dict())

Other than that, if you want the exact same methods on the Piccolo table and Pydantic model, you could use a mixin.

[waldner]

Ok right, although that would introduce piccolo dependencies right where the data structure is defined, which isn't what I wanted since that would be included from lots of places, including from where piccolo isn't used. But if the end result is a pydantic class that can be included anywhere, it might be worth it. I'll see what I can do.
Thanks!