How to convert a sqlmodel class to pydantic class

[PaleNeutron]

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 List, Optional

from pydantic import ConfigDict
from sqlmodel import Field, Relationship, Session, SQLModel, create_engine


class HeroTeamLink(SQLModel, table=True):
    team_id: Optional[int] = Field(
        default=None, foreign_key="team.id", primary_key=True
    )
    hero_id: Optional[int] = Field(
        default=None, foreign_key="hero.id", primary_key=True
    )


class Team(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str = Field(index=True)
    headquarters: str

    heroes: List["Hero"] = Relationship(back_populates="teams", link_model=HeroTeamLink)


class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str = Field(index=True)
    secret_name: str
    age: Optional[int] = Field(default=None, index=True)

    teams: List[Team] = Relationship(back_populates="heroes", link_model=HeroTeamLink)

class HeroPlus(Hero, table=False):
    model_config = ConfigDict(arbitrary_types_allowed=True)
    
    fans: List[str]  # property from other sources


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)


def create_db_and_tables():
    SQLModel.metadata.create_all(engine)


def create_heroes():
    with Session(engine) as session:
        team_preventers = Team(name="Preventers", headquarters="Sharp Tower")
        team_z_force = Team(name="Z-Force", headquarters="Sister Margaret's Bar")

        hero_deadpond = Hero(
            name="Deadpond",
            secret_name="Dive Wilson",
            teams=[team_z_force, team_preventers],
        )
        hero_rusty_man = Hero(
            name="Rusty-Man",
            secret_name="Tommy Sharp",
            age=48,
            teams=[team_preventers],
        )
        hero_spider_boy = Hero(
            name="Spider-Boy", secret_name="Pedro Parqueador", teams=[team_preventers]
        )
        session.add(hero_deadpond)
        session.add(hero_rusty_man)
        session.add(hero_spider_boy)
        session.commit()

        session.refresh(hero_deadpond)
        session.refresh(hero_rusty_man)
        session.refresh(hero_spider_boy)

        print("Deadpond:", hero_deadpond)
        print("Deadpond teams:", hero_deadpond.teams)
        print("Rusty-Man:", hero_rusty_man)
        print("Rusty-Man Teams:", hero_rusty_man.teams)
        print("Spider-Boy:", hero_spider_boy)
        print("Spider-Boy Teams:", hero_spider_boy.teams)


def main():
    create_db_and_tables()
    create_heroes()


if __name__ == "__main__":
    main()

Description

I plan to use HeroPlus schema to add some information from other sources to hero , e.g. a request.

But I can not find a way to create a pydantic model from sqlmodel.

Operating System

Linux, Windows

Operating System Details

No response

SQLModel Version

0.0.16

Python Version

Python 3.10.12

Additional Context

No response

[antont]

To just create:

heroplus = HeroPlus.model_validate(hero_deadpond.model_dump())

And to add something:

deadpond_dump = hero_deadpond.model_dump()
deadpond_dump['fans'] = fans_from_other_source
heroplus = HeroPlus.model_validate(deadpond_dump)

I've been doing things like this, not related to SQLModel though but otherwise with Pydantic 2. Am curious to know if there's a better way but I guess that's ok.

Oh there's also this way that I'm using in some places, which is a tad nicer, forgot about it first:

heroplus = HeroPlus(
    fans = fans_from_other_source
    **hero_deadpond.model_dump()
)

I made a replit where this works with a simplified version, https://replit.com/@antont3/Pydantic-object-from-another#main.py

The code there is:

from pydantic import BaseModel

class Hero(BaseModel):
  name: str
  age: int

class HeroPlus(Hero):
  fans: list[str]  # property from other sources

hero = Hero(name="Batman", age=42)
fans_from_other_source = ["Superman", "Wonder Woman"]
hero_plus = HeroPlus(
  fans=fans_from_other_source,
  **hero.model_dump()
)

print(hero_plus)

Outputs:

name='Batman' age=42 fans=['Superman', 'Wonder Woman']

[PaleNeutron]

It works in very simple cases, but the wired problem is I have to create a model in sqlmodel with table=True if I want to use database related options such as pk, sa_column_kwargs

So I can not create a pydantic base model and inherit it.

[PaleNeutron]

I create a stupid function to transfer sqlmodel to pydantic

class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str = Field(index=True)
    secret_name: str
    age: Optional[int] = Field(default=None, index=True)

    teams: List[Team] = Relationship(back_populates="heroes", link_model=HeroTeamLink)

def sqlmodel2pydantic(name: str, models: Iterable[BaseModel]) -> BaseModel:
    """merge Pydantic or sqlmodel models"""
    fields = {}
    for model in models:
        f = {k: (v.annotation, v) for k, v in model.model_fields.items()}
        fields.update(f)
    return pydantic.create_model(name, **fields)

HeroPydantic = sqlmodel2pydantic("HeroPydantic ", [Hero])

There should be some better inherit method

[Yangeok]

HeroPydantic is BaseModel type, but it cannot be extended with a class, and property access is not possible. How can it be used?

[lionyu-idah]

I need to extend some fields for my inherited SQLModel class, and I've also encountered the "property access is not possible" issue. Here's my inelegant temporary solution:

from typing import TYPE_CHECKING

class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str = Field(index=True)
    secret_name: str
    age: Optional[int] = Field(default=None, index=True)

    teams: List[Team] = Relationship(back_populates="heroes", link_model=HeroTeamLink)

def sqlmodel2pydantic(name: str, models: Iterable[BaseModel]) -> BaseModel:
    """merge Pydantic or sqlmodel models"""
    fields = {}
    for model in models:
        f = {k: (v.annotation, v) for k, v in model.model_fields.items()}
        fields.update(f)
    return pydantic.create_model(name, **fields)


if TYPE_CHECKING:
    class HeroExtend(Hero):
        rating: int
else:
    class HeroExtend(
        sqlmodel2pydantic("HeroExtend", [Hero])
    ):
        rating: int