prompt
stringlengths
45
17.8k
completion
stringlengths
6
107
api
stringlengths
12
42
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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) team_id: Optional[int] = Field(default=None, foreign_key="team.id") team: Optional[Team] = Relationship() sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" engine =
create_engine(sqlite_url, echo=True)
sqlmodel.create_engine
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select class Team(SQLModel, table=True): id: Optional[int] =
Field(default=None, primary_key=True)
sqlmodel.Field
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select class Team(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str =
Field(index=True)
sqlmodel.Field
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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()
sqlmodel.Relationship
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() class Hero(SQLModel, table=True): id: Optional[int] =
Field(default=None, primary_key=True)
sqlmodel.Field
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() class Hero(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str =
Field(index=True)
sqlmodel.Field
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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)
sqlmodel.Field
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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) team_id: Optional[int] =
Field(default=None, foreign_key="team.id")
sqlmodel.Field
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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) team_id: Optional[int] = Field(default=None, foreign_key="team.id") team: Optional[Team] =
Relationship()
sqlmodel.Relationship
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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) team_id: Optional[int] = Field(default=None, foreign_key="team.id") team: Optional[Team] = Relationship() 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)
sqlmodel.SQLModel.metadata.create_all
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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) team_id: Optional[int] = Field(default=None, foreign_key="team.id") team: Optional[Team] = Relationship() 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)
sqlmodel.Session
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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) team_id: Optional[int] = Field(default=None, foreign_key="team.id") team: Optional[Team] = Relationship() 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="<NAME>", team=team_z_force ) hero_rusty_man = Hero( name="Rusty-Man", secret_name="<NAME>", age=48, team=team_preventers ) hero_spider_boy = Hero(name="Spider-Boy", secret_name="<NAME>") 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("Created hero:", hero_deadpond) print("Created hero:", hero_rusty_man) print("Created hero:", hero_spider_boy) hero_spider_boy.team = team_preventers session.add(hero_spider_boy) session.commit() session.refresh(hero_spider_boy) print("Updated hero:", hero_spider_boy) hero_black_lion = Hero(name="<NAME>", secret_name="<NAME>", age=35) hero_sure_e = Hero(name="<NAME>", secret_name="Sure-E") team_wakaland = Team( name="Wakaland", headquarters="Wakaland Capital City", heroes=[hero_black_lion, hero_sure_e], ) session.add(team_wakaland) session.commit() session.refresh(team_wakaland) print("Team Wakaland:", team_wakaland) hero_tarantula = Hero(name="Tarantula", secret_name="<NAME>", age=32) hero_dr_weird = Hero(name="<NAME>", secret_name="<NAME>", age=36) hero_cap = Hero( name="Captain North America", secret_name="<NAME>", age=93 ) team_preventers.heroes.append(hero_tarantula) team_preventers.heroes.append(hero_dr_weird) team_preventers.heroes.append(hero_cap) session.add(team_preventers) session.commit() session.refresh(hero_tarantula) session.refresh(hero_dr_weird) session.refresh(hero_cap) print("Preventers new hero:", hero_tarantula) print("Preventers new hero:", hero_dr_weird) print("Preventers new hero:", hero_cap) def select_heroes(): with
Session(engine)
sqlmodel.Session
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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) team_id: Optional[int] = Field(default=None, foreign_key="team.id") team: Optional[Team] = Relationship() 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="<NAME>", team=team_z_force ) hero_rusty_man = Hero( name="Rusty-Man", secret_name="<NAME>", age=48, team=team_preventers ) hero_spider_boy = Hero(name="Spider-Boy", secret_name="<NAME>") 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("Created hero:", hero_deadpond) print("Created hero:", hero_rusty_man) print("Created hero:", hero_spider_boy) hero_spider_boy.team = team_preventers session.add(hero_spider_boy) session.commit() session.refresh(hero_spider_boy) print("Updated hero:", hero_spider_boy) hero_black_lion = Hero(name="<NAME>", secret_name="<NAME>", age=35) hero_sure_e = Hero(name="<NAME>", secret_name="Sure-E") team_wakaland = Team( name="Wakaland", headquarters="Wakaland Capital City", heroes=[hero_black_lion, hero_sure_e], ) session.add(team_wakaland) session.commit() session.refresh(team_wakaland) print("Team Wakaland:", team_wakaland) hero_tarantula = Hero(name="Tarantula", secret_name="<NAME>", age=32) hero_dr_weird = Hero(name="<NAME>", secret_name="<NAME>", age=36) hero_cap = Hero( name="Captain North America", secret_name="<NAME>", age=93 ) team_preventers.heroes.append(hero_tarantula) team_preventers.heroes.append(hero_dr_weird) team_preventers.heroes.append(hero_cap) session.add(team_preventers) session.commit() session.refresh(hero_tarantula) session.refresh(hero_dr_weird) session.refresh(hero_cap) print("Preventers new hero:", hero_tarantula) print("Preventers new hero:", hero_dr_weird) print("Preventers new hero:", hero_cap) def select_heroes(): with Session(engine) as session: statement = select(Team).where(Team.name == "Preventers") result = session.exec(statement) team_preventers = result.one() print("Preventers heroes:", team_preventers.heroes) def update_heroes(): with
Session(engine)
sqlmodel.Session
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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) team_id: Optional[int] = Field(default=None, foreign_key="team.id") team: Optional[Team] = Relationship() 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="<NAME>", team=team_z_force ) hero_rusty_man = Hero( name="Rusty-Man", secret_name="<NAME>", age=48, team=team_preventers ) hero_spider_boy = Hero(name="Spider-Boy", secret_name="<NAME>") 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("Created hero:", hero_deadpond) print("Created hero:", hero_rusty_man) print("Created hero:", hero_spider_boy) hero_spider_boy.team = team_preventers session.add(hero_spider_boy) session.commit() session.refresh(hero_spider_boy) print("Updated hero:", hero_spider_boy) hero_black_lion = Hero(name="<NAME>", secret_name="<NAME>", age=35) hero_sure_e = Hero(name="<NAME>", secret_name="Sure-E") team_wakaland = Team( name="Wakaland", headquarters="Wakaland Capital City", heroes=[hero_black_lion, hero_sure_e], ) session.add(team_wakaland) session.commit() session.refresh(team_wakaland) print("Team Wakaland:", team_wakaland) hero_tarantula = Hero(name="Tarantula", secret_name="<NAME>", age=32) hero_dr_weird = Hero(name="<NAME>", secret_name="<NAME>", age=36) hero_cap = Hero( name="Captain North America", secret_name="<NAME>", age=93 ) team_preventers.heroes.append(hero_tarantula) team_preventers.heroes.append(hero_dr_weird) team_preventers.heroes.append(hero_cap) session.add(team_preventers) session.commit() session.refresh(hero_tarantula) session.refresh(hero_dr_weird) session.refresh(hero_cap) print("Preventers new hero:", hero_tarantula) print("Preventers new hero:", hero_dr_weird) print("Preventers new hero:", hero_cap) def select_heroes(): with Session(engine) as session: statement =
select(Team)
sqlmodel.select
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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) team_id: Optional[int] = Field(default=None, foreign_key="team.id") team: Optional[Team] = Relationship() 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="<NAME>", team=team_z_force ) hero_rusty_man = Hero( name="Rusty-Man", secret_name="<NAME>", age=48, team=team_preventers ) hero_spider_boy = Hero(name="Spider-Boy", secret_name="<NAME>") 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("Created hero:", hero_deadpond) print("Created hero:", hero_rusty_man) print("Created hero:", hero_spider_boy) hero_spider_boy.team = team_preventers session.add(hero_spider_boy) session.commit() session.refresh(hero_spider_boy) print("Updated hero:", hero_spider_boy) hero_black_lion = Hero(name="<NAME>", secret_name="<NAME>", age=35) hero_sure_e = Hero(name="<NAME>", secret_name="Sure-E") team_wakaland = Team( name="Wakaland", headquarters="Wakaland Capital City", heroes=[hero_black_lion, hero_sure_e], ) session.add(team_wakaland) session.commit() session.refresh(team_wakaland) print("Team Wakaland:", team_wakaland) hero_tarantula = Hero(name="Tarantula", secret_name="<NAME>", age=32) hero_dr_weird = Hero(name="<NAME>", secret_name="<NAME>", age=36) hero_cap = Hero( name="Captain North America", secret_name="<NAME>", age=93 ) team_preventers.heroes.append(hero_tarantula) team_preventers.heroes.append(hero_dr_weird) team_preventers.heroes.append(hero_cap) session.add(team_preventers) session.commit() session.refresh(hero_tarantula) session.refresh(hero_dr_weird) session.refresh(hero_cap) print("Preventers new hero:", hero_tarantula) print("Preventers new hero:", hero_dr_weird) print("Preventers new hero:", hero_cap) def select_heroes(): with Session(engine) as session: statement = select(Team).where(Team.name == "Preventers") result = session.exec(statement) team_preventers = result.one() print("Preventers heroes:", team_preventers.heroes) def update_heroes(): with Session(engine) as session: hero_spider_boy = session.exec(
select(Hero)
sqlmodel.select
from typing import List, Optional from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select 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() 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) team_id: Optional[int] = Field(default=None, foreign_key="team.id") team: Optional[Team] = Relationship() 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="<NAME>", team=team_z_force ) hero_rusty_man = Hero( name="Rusty-Man", secret_name="<NAME>", age=48, team=team_preventers ) hero_spider_boy = Hero(name="Spider-Boy", secret_name="<NAME>") 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("Created hero:", hero_deadpond) print("Created hero:", hero_rusty_man) print("Created hero:", hero_spider_boy) hero_spider_boy.team = team_preventers session.add(hero_spider_boy) session.commit() session.refresh(hero_spider_boy) print("Updated hero:", hero_spider_boy) hero_black_lion = Hero(name="<NAME>", secret_name="<NAME>", age=35) hero_sure_e = Hero(name="<NAME>", secret_name="Sure-E") team_wakaland = Team( name="Wakaland", headquarters="Wakaland Capital City", heroes=[hero_black_lion, hero_sure_e], ) session.add(team_wakaland) session.commit() session.refresh(team_wakaland) print("Team Wakaland:", team_wakaland) hero_tarantula = Hero(name="Tarantula", secret_name="<NAME>", age=32) hero_dr_weird = Hero(name="<NAME>", secret_name="<NAME>", age=36) hero_cap = Hero( name="Captain North America", secret_name="<NAME>", age=93 ) team_preventers.heroes.append(hero_tarantula) team_preventers.heroes.append(hero_dr_weird) team_preventers.heroes.append(hero_cap) session.add(team_preventers) session.commit() session.refresh(hero_tarantula) session.refresh(hero_dr_weird) session.refresh(hero_cap) print("Preventers new hero:", hero_tarantula) print("Preventers new hero:", hero_dr_weird) print("Preventers new hero:", hero_cap) def select_heroes(): with Session(engine) as session: statement = select(Team).where(Team.name == "Preventers") result = session.exec(statement) team_preventers = result.one() print("Preventers heroes:", team_preventers.heroes) def update_heroes(): with Session(engine) as session: hero_spider_boy = session.exec( select(Hero).where(Hero.name == "Spider-Boy") ).one() preventers_team = session.exec(
select(Team)
sqlmodel.select
from typing import Union from uuid import uuid4 import inject from sqlmodel import Session, select from src.core.events import EventDescription from src.core.models import Context, File from src.core.services import Storage, Streamer from src.utils.miscellaneous import get_file_hash @inject.params(streamer=Streamer, storage=Storage) def get_or_create_file( session: Session, preffix: str, filename: str, file: Union[str, bytes], context: Context, streamer: Streamer, storage: Storage, ) -> File: file_hash = get_file_hash(file) file_obj = session.exec(
select(File)
sqlmodel.select
from datetime import datetime from typing import TYPE_CHECKING, Optional from models.base import BaseModel, BaseTableFields from sqlmodel import Field, Relationship, Column, String if TYPE_CHECKING: from models.user import User class Session(BaseModel, BaseTableFields, table=True): __tablename__ = "sessions" access_token: str = Field( sa_column=Column( String, unique=True, nullable=False ) ) ip_address: Optional[str] = Field( sa_column=Column( String(100), nullable=True ) ) user_agent: Optional[str] = Field( sa_column=Column( String(100), nullable=True ) ) user_id: int =
Field(foreign_key="users.id")
sqlmodel.Field
from datetime import datetime from typing import TYPE_CHECKING, Optional from models.base import BaseModel, BaseTableFields from sqlmodel import Field, Relationship, Column, String if TYPE_CHECKING: from models.user import User class Session(BaseModel, BaseTableFields, table=True): __tablename__ = "sessions" access_token: str = Field( sa_column=Column( String, unique=True, nullable=False ) ) ip_address: Optional[str] = Field( sa_column=Column( String(100), nullable=True ) ) user_agent: Optional[str] = Field( sa_column=Column( String(100), nullable=True ) ) user_id: int = Field(foreign_key="users.id") user: "User" =
Relationship(back_populates="sessions")
sqlmodel.Relationship
from datetime import datetime from typing import TYPE_CHECKING, Optional from models.base import BaseModel, BaseTableFields from sqlmodel import Field, Relationship, Column, String if TYPE_CHECKING: from models.user import User class Session(BaseModel, BaseTableFields, table=True): __tablename__ = "sessions" access_token: str = Field( sa_column=Column( String, unique=True, nullable=False ) ) ip_address: Optional[str] = Field( sa_column=Column(
String(100)
sqlmodel.String
from datetime import datetime from typing import TYPE_CHECKING, Optional from models.base import BaseModel, BaseTableFields from sqlmodel import Field, Relationship, Column, String if TYPE_CHECKING: from models.user import User class Session(BaseModel, BaseTableFields, table=True): __tablename__ = "sessions" access_token: str = Field( sa_column=Column( String, unique=True, nullable=False ) ) ip_address: Optional[str] = Field( sa_column=Column( String(100), nullable=True ) ) user_agent: Optional[str] = Field( sa_column=Column(
String(100)
sqlmodel.String
from typing import Optional from fastapi import FastAPI from sqlmodel import Session, SQLModel, create_engine from .abstractions import MultipleModels, register_endpoints class HeroBase(SQLModel): name: str secret_name: str age: Optional[int] = None class HeroRead(HeroBase): id: int hero_models = MultipleModels(path="/heroes/", base=HeroBase, response=HeroRead) Hero = hero_models.table # Shim to avoid changing tests. sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" connect_args = {"check_same_thread": False} engine =
create_engine(sqlite_url, echo=True, connect_args=connect_args)
sqlmodel.create_engine
from typing import Optional from fastapi import FastAPI from sqlmodel import Session, SQLModel, create_engine from .abstractions import MultipleModels, register_endpoints class HeroBase(SQLModel): name: str secret_name: str age: Optional[int] = None class HeroRead(HeroBase): id: int hero_models = MultipleModels(path="/heroes/", base=HeroBase, response=HeroRead) Hero = hero_models.table # Shim to avoid changing tests. sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" connect_args = {"check_same_thread": False} engine = create_engine(sqlite_url, echo=True, connect_args=connect_args) def create_db_and_tables():
SQLModel.metadata.create_all(engine)
sqlmodel.SQLModel.metadata.create_all
from typing import Optional from fastapi import FastAPI from sqlmodel import Session, SQLModel, create_engine from .abstractions import MultipleModels, register_endpoints class HeroBase(SQLModel): name: str secret_name: str age: Optional[int] = None class HeroRead(HeroBase): id: int hero_models = MultipleModels(path="/heroes/", base=HeroBase, response=HeroRead) Hero = hero_models.table # Shim to avoid changing tests. sqlite_file_name = "database.db" sqlite_url = f"sqlite:///{sqlite_file_name}" connect_args = {"check_same_thread": False} engine = create_engine(sqlite_url, echo=True, connect_args=connect_args) def create_db_and_tables(): SQLModel.metadata.create_all(engine) def get_session(): with
Session(engine)
sqlmodel.Session
from popol.db.sqlmodel import models from sqlmodel import Field class Account(models.Model, table=True): username: str =
Field(max_length=255, nullable=False)
sqlmodel.Field
from popol.db.sqlmodel import models from sqlmodel import Field class Account(models.Model, table=True): username: str = Field(max_length=255, nullable=False) password: str =
Field(max_length=255, nullable=False)
sqlmodel.Field
import requests import logging import us from pydantic import validator from sqlmodel import Field, SQLModel, Session, create_engine import json from os.path import exists # Define the Store model # The model is a SQLModel so it gets Pydantic and SQLAlchemy methods # It will be a SQL table with the name 'store' class Store(SQLModel, table=True): id: str =
Field(default=None, primary_key=True)
sqlmodel.Field
import requests import logging import us from pydantic import validator from sqlmodel import Field, SQLModel, Session, create_engine import json from os.path import exists # Define the Store model # The model is a SQLModel so it gets Pydantic and SQLAlchemy methods # It will be a SQL table with the name 'store' class Store(SQLModel, table=True): id: str = Field(default=None, primary_key=True) name: str state: str latitude: float longitude: float # Grab the needed fields from the data from the API def __init__(self, source_data): self.id = source_data['key']['id'] self.name = source_data['name']['label'] self.state = source_data['location']['address']['administrativeArea'] self.latitude = source_data['location']['geo']['latitude'] self.longitude = source_data['location']['geo']['longitude'] # Verify that the State is a valid US state or territory @validator('state') def validate_state(cls, v): v = us.states.lookup(v) if v not in us.states.STATES_AND_TERRITORIES: raise ValueError(f'{v} is not a valid state') return v # Verify that the latitude is a float and between -90 and 90 @validator('latitude') def validate_latitude(cls, v): v = float(v) if v < -90 or v > 90: raise ValueError(f'{v} is not a valid latitude') return v # Verify that the longitude is a float and between -180 and 180 @validator('longitude') def validate_longitude(cls, v): v = float(v) if v < -180 or v > 180: raise ValueError(f'{v} is not a valid longitude') return v # Verify that the name is a string and not empty @validator('name') def validate_name(cls, v): if len(v) < 1: raise ValueError(f'{v} is not a valid name') return v # read the store data from the provided filepath or if the file does not exist pull the store data from the API def extract(filepath: str, url: str) -> dict: # try filepath if exists(filepath): with open(filepath, 'r') as f: return json.load(f) # try API try: r = requests.get(url) r.raise_for_status() logging.info('Successfully retrieved stores data') return r.json() except Exception as e: logging.warning(f'Error getting stores data: {e}') return None # transform the data into a list of Store objects def transform(data: dict) -> dict: stores = [] if 'store' in data: for s in data['store']: try: stores.append(Store(s)) except Exception as e: logging.warning(f'Error transforming store: {e}') return stores return None # load the data into the database def load(stores: list, engine) -> None: if not stores: logging.warning('No stores to load') return try: # Create a session to connect to the database with
Session(engine)
sqlmodel.Session
from datetime import datetime from typing import TYPE_CHECKING, Dict, List, Optional from pydantic import root_validator from sqlalchemy import Column from sqlmodel import Field, Relationship, SQLModel from .event_attendance import EventAttendance from .types import TimeStamp if TYPE_CHECKING: from .feedback import Feedback, FeedbackList from .participant import Participant, ParticipantList class EventBase(SQLModel): name: str code: str valid_from: datetime = Field( sa_column=Column( TimeStamp(timezone=True), default=datetime.now, nullable=False, ) ) valid_until: datetime = Field( sa_column=Column( TimeStamp(timezone=True), default=datetime.now, nullable=False, ) ) enabled: bool =
Field(default=True, nullable=False)
sqlmodel.Field
from datetime import datetime from typing import TYPE_CHECKING, Dict, List, Optional from pydantic import root_validator from sqlalchemy import Column from sqlmodel import Field, Relationship, SQLModel from .event_attendance import EventAttendance from .types import TimeStamp if TYPE_CHECKING: from .feedback import Feedback, FeedbackList from .participant import Participant, ParticipantList class EventBase(SQLModel): name: str code: str valid_from: datetime = Field( sa_column=Column( TimeStamp(timezone=True), default=datetime.now, nullable=False, ) ) valid_until: datetime = Field( sa_column=Column( TimeStamp(timezone=True), default=datetime.now, nullable=False, ) ) enabled: bool = Field(default=True, nullable=False) @root_validator() def range_is_positive(cls, values: Dict[str, datetime]): start, end = values.get("valid_from"), values.get("valid_until") if start is None or end is None: return values elif end < start: raise ValueError("validity range cannot be negative") return values class Event(EventBase, table=True): __tablename__ = "events" id: Optional[int] =
Field(default=None, primary_key=True, nullable=False)
sqlmodel.Field
from sqlmodel import create_engine from config import settings engine =
create_engine(settings.database_url)
sqlmodel.create_engine
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None sqlite_file_name = 'database.db' sqlite_url = f"sqlite:///{sqlite_file_name}" engine =
create_engine(sqlite_url, echo=True)
sqlmodel.create_engine
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] =
Field(default=None, primary_key=True)
sqlmodel.Field
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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)
sqlmodel.SQLModel.metadata.create_all
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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(): hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26) hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33) with
Session(engine)
sqlmodel.Session
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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(): hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26) hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.commit() def get_db_size(): with
Session(engine)
sqlmodel.Session
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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(): hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26) hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.commit() def get_db_size(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() return len(heroes) def select_heros(): with
Session(engine)
sqlmodel.Session
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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(): hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26) hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.commit() def get_db_size(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() return len(heroes) def select_heros(): with Session(engine) as session: statement = select(Hero).where(Hero.age <= 35) results = session.exec(statement) for hero in results: st.text(hero) #st.text(len(results)) def show_table(): with
Session(engine)
sqlmodel.Session
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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(): hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26) hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.commit() def get_db_size(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() return len(heroes) def select_heros(): with Session(engine) as session: statement = select(Hero).where(Hero.age <= 35) results = session.exec(statement) for hero in results: st.text(hero) #st.text(len(results)) def show_table(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() st.table(pd.DataFrame([s.dict() for s in heroes[-5:]])) def delete_db(): with
Session(engine)
sqlmodel.Session
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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(): hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26) hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.commit() def get_db_size(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() return len(heroes) def select_heros(): with Session(engine) as session: statement =
select(Hero)
sqlmodel.select
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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(): hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26) hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.commit() def get_db_size(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() return len(heroes) def select_heros(): with Session(engine) as session: statement = select(Hero).where(Hero.age <= 35) results = session.exec(statement) for hero in results: st.text(hero) #st.text(len(results)) def show_table(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() st.table(pd.DataFrame([s.dict() for s in heroes[-5:]])) def delete_db(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() for hero in heroes: session.delete(hero) session.commit() st.text("Deleted all rows") def write_new_row(): with st.form('new_row'): name_input = st.text_input('Name', value="<NAME>") secret_name = st.text_input('Secret alias', value="Dr. Jon") submitted = st.form_submit_button("Submit") if submitted: hero = Hero(name=name_input, secret_name=secret_name, age=23) st.write('submitted') hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) with
Session(engine)
sqlmodel.Session
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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(): hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26) hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.commit() def get_db_size(): with Session(engine) as session: heroes = session.exec(
select(Hero)
sqlmodel.select
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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(): hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26) hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.commit() def get_db_size(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() return len(heroes) def select_heros(): with Session(engine) as session: statement = select(Hero).where(Hero.age <= 35) results = session.exec(statement) for hero in results: st.text(hero) #st.text(len(results)) def show_table(): with Session(engine) as session: heroes = session.exec(
select(Hero)
sqlmodel.select
from typing import Optional import pandas as pd import streamlit as st import os from sqlmodel import Field, Session, SQLModel, create_engine, select class Hero(SQLModel, table=True): __table_args__ = {'extend_existing': True} # required for streamlit refreshing id: Optional[int] = Field(default=None, primary_key=True) name: str secret_name: str age: Optional[int] = None 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(): hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36) hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26) hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33) with Session(engine) as session: session.add(hero_1) session.add(hero_2) session.add(hero_3) session.commit() def get_db_size(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() return len(heroes) def select_heros(): with Session(engine) as session: statement = select(Hero).where(Hero.age <= 35) results = session.exec(statement) for hero in results: st.text(hero) #st.text(len(results)) def show_table(): with Session(engine) as session: heroes = session.exec(select(Hero)).all() st.table(pd.DataFrame([s.dict() for s in heroes[-5:]])) def delete_db(): with Session(engine) as session: heroes = session.exec(
select(Hero)
sqlmodel.select
""" dayong.models ~~~~~~~~~~~~~ A model maps to a single database table. It contains fields and behaviors of the data stored in the database. """ from typing import Optional from sqlmodel import Field, SQLModel class Message(SQLModel): """Base model class for message table models.""" message_id: str class AnonMessage(Message, table=True): """Table model for anonymized guild messages.""" # pyright cannot recognize the type of SQLModel.__tablename__ # See: https://github.com/tiangolo/sqlmodel/issues/98 __tablename__ = "anon_messages" # type: ignore id: Optional[int] =
Field(default=None, primary_key=True)
sqlmodel.Field
import typing as t from sqlmodel import SQLModel, Field, Relationship from datetime import datetime from .discussions import DB_Discussion class DB_Post(SQLModel, table=True): __tablename__ = 'posts' id: t.Optional[int] =
Field(default=None, primary_key=True)
sqlmodel.Field
import typing as t from sqlmodel import SQLModel, Field, Relationship from datetime import datetime from .discussions import DB_Discussion class DB_Post(SQLModel, table=True): __tablename__ = 'posts' id: t.Optional[int] = Field(default=None, primary_key=True) """The ID of the post. This is handled by the database.""" discussion_id: int =
Field(foreign_key='discussions.id')
sqlmodel.Field
import typing as t from sqlmodel import SQLModel, Field, Relationship from datetime import datetime from .discussions import DB_Discussion class DB_Post(SQLModel, table=True): __tablename__ = 'posts' id: t.Optional[int] = Field(default=None, primary_key=True) """The ID of the post. This is handled by the database.""" discussion_id: int = Field(foreign_key='discussions.id') discussion: t.Optional[DB_Discussion] =
Relationship(back_populates='posts')
sqlmodel.Relationship
import typing as t from sqlmodel import SQLModel, Field, Relationship from datetime import datetime from .discussions import DB_Discussion class DB_Post(SQLModel, table=True): __tablename__ = 'posts' id: t.Optional[int] = Field(default=None, primary_key=True) """The ID of the post. This is handled by the database.""" discussion_id: int = Field(foreign_key='discussions.id') discussion: t.Optional[DB_Discussion] = Relationship(back_populates='posts') """Discussion that this post belongs to.""" number: int =
Field(default=1)
sqlmodel.Field
import typing as t from sqlmodel import SQLModel, Field, Relationship from datetime import datetime from .discussions import DB_Discussion class DB_Post(SQLModel, table=True): __tablename__ = 'posts' id: t.Optional[int] = Field(default=None, primary_key=True) """The ID of the post. This is handled by the database.""" discussion_id: int = Field(foreign_key='discussions.id') discussion: t.Optional[DB_Discussion] = Relationship(back_populates='posts') """Discussion that this post belongs to.""" number: int = Field(default=1) """The number/order of the post in the discussion.""" created_at: datetime = Field(default=datetime.utcnow()) """When was this post created. Default is now.""" type: str =
Field(max_length=100, default='comment')
sqlmodel.Field
import typing as t from sqlmodel import SQLModel, Field, Relationship from datetime import datetime from .discussions import DB_Discussion class DB_Post(SQLModel, table=True): __tablename__ = 'posts' id: t.Optional[int] = Field(default=None, primary_key=True) """The ID of the post. This is handled by the database.""" discussion_id: int = Field(foreign_key='discussions.id') discussion: t.Optional[DB_Discussion] = Relationship(back_populates='posts') """Discussion that this post belongs to.""" number: int = Field(default=1) """The number/order of the post in the discussion.""" created_at: datetime = Field(default=datetime.utcnow()) """When was this post created. Default is now.""" type: str = Field(max_length=100, default='comment') """The type of the post. Can be `'comment'` for standard post.""" content: t.Text """The post's content, in HTML.""" edited_at: t.Optional[datetime] """When was the post edited at?""" hidden_at: t.Optional[datetime] """When was the post hidden at?""" ip_address: t.Optional[str] =
Field(max_length=45)
sqlmodel.Field
import typing as t from sqlmodel import SQLModel, Field, Relationship from datetime import datetime from .discussions import DB_Discussion class DB_Post(SQLModel, table=True): __tablename__ = 'posts' id: t.Optional[int] = Field(default=None, primary_key=True) """The ID of the post. This is handled by the database.""" discussion_id: int = Field(foreign_key='discussions.id') discussion: t.Optional[DB_Discussion] = Relationship(back_populates='posts') """Discussion that this post belongs to.""" number: int = Field(default=1) """The number/order of the post in the discussion.""" created_at: datetime = Field(default=datetime.utcnow()) """When was this post created. Default is now.""" type: str = Field(max_length=100, default='comment') """The type of the post. Can be `'comment'` for standard post.""" content: t.Text """The post's content, in HTML.""" edited_at: t.Optional[datetime] """When was the post edited at?""" hidden_at: t.Optional[datetime] """When was the post hidden at?""" ip_address: t.Optional[str] = Field(max_length=45) """The IP address of the user that created the post.""" is_private: bool =
Field(default=False)
sqlmodel.Field
import typing as t from sqlmodel import SQLModel, Field, Relationship from datetime import datetime from .discussions import DB_Discussion class DB_Post(SQLModel, table=True): __tablename__ = 'posts' id: t.Optional[int] = Field(default=None, primary_key=True) """The ID of the post. This is handled by the database.""" discussion_id: int = Field(foreign_key='discussions.id') discussion: t.Optional[DB_Discussion] = Relationship(back_populates='posts') """Discussion that this post belongs to.""" number: int = Field(default=1) """The number/order of the post in the discussion.""" created_at: datetime = Field(default=datetime.utcnow()) """When was this post created. Default is now.""" type: str = Field(max_length=100, default='comment') """The type of the post. Can be `'comment'` for standard post.""" content: t.Text """The post's content, in HTML.""" edited_at: t.Optional[datetime] """When was the post edited at?""" hidden_at: t.Optional[datetime] """When was the post hidden at?""" ip_address: t.Optional[str] = Field(max_length=45) """The IP address of the user that created the post.""" is_private: bool = Field(default=False) """Whether or not the post is private.""" is_approved: bool =
Field(default=True)
sqlmodel.Field
import datetime import typing from sqlmodel import SQLModel, Field, Relationship import typing as tp import ipaddress from sqlalchemy import UniqueConstraint if tp.TYPE_CHECKING: from .user import User class LoginToken(SQLModel, table=True): __tablename__:str = "login_tokens" # type: ignore __table_args__ = (UniqueConstraint("token"),) id: int =
Field(primary_key=True)
sqlmodel.Field
import datetime import typing from sqlmodel import SQLModel, Field, Relationship import typing as tp import ipaddress from sqlalchemy import UniqueConstraint if tp.TYPE_CHECKING: from .user import User class LoginToken(SQLModel, table=True): __tablename__:str = "login_tokens" # type: ignore __table_args__ = (UniqueConstraint("token"),) id: int = Field(primary_key=True) token: str # 校验token expired_in: typing.Optional[datetime.datetime] # 过期时间 user_id: int =
Field(foreign_key="user.id")
sqlmodel.Field
import datetime import typing from sqlmodel import SQLModel, Field, Relationship import typing as tp import ipaddress from sqlalchemy import UniqueConstraint if tp.TYPE_CHECKING: from .user import User class LoginToken(SQLModel, table=True): __tablename__:str = "login_tokens" # type: ignore __table_args__ = (UniqueConstraint("token"),) id: int = Field(primary_key=True) token: str # 校验token expired_in: typing.Optional[datetime.datetime] # 过期时间 user_id: int = Field(foreign_key="user.id") # 关联用户 user: User =
Relationship(back_populates="tokens")
sqlmodel.Relationship
import datetime import typing from sqlmodel import SQLModel, Field, Relationship import typing as tp import ipaddress from sqlalchemy import UniqueConstraint if tp.TYPE_CHECKING: from .user import User class LoginToken(SQLModel, table=True): __tablename__:str = "login_tokens" # type: ignore __table_args__ = (UniqueConstraint("token"),) id: int = Field(primary_key=True) token: str # 校验token expired_in: typing.Optional[datetime.datetime] # 过期时间 user_id: int = Field(foreign_key="user.id") # 关联用户 user: User = Relationship(back_populates="tokens") class LoginLog(SQLModel, table=True): __tablename__:str = "login_logs" # type: ignore id: int =
Field(primary_key=True)
sqlmodel.Field
import datetime import typing from sqlmodel import SQLModel, Field, Relationship import typing as tp import ipaddress from sqlalchemy import UniqueConstraint if tp.TYPE_CHECKING: from .user import User class LoginToken(SQLModel, table=True): __tablename__:str = "login_tokens" # type: ignore __table_args__ = (UniqueConstraint("token"),) id: int = Field(primary_key=True) token: str # 校验token expired_in: typing.Optional[datetime.datetime] # 过期时间 user_id: int = Field(foreign_key="user.id") # 关联用户 user: User = Relationship(back_populates="tokens") class LoginLog(SQLModel, table=True): __tablename__:str = "login_logs" # type: ignore id: int = Field(primary_key=True) user_id: int =
Field(foreign_key="users.id", index=True)
sqlmodel.Field
import datetime import typing from sqlmodel import SQLModel, Field, Relationship import typing as tp import ipaddress from sqlalchemy import UniqueConstraint if tp.TYPE_CHECKING: from .user import User class LoginToken(SQLModel, table=True): __tablename__:str = "login_tokens" # type: ignore __table_args__ = (UniqueConstraint("token"),) id: int = Field(primary_key=True) token: str # 校验token expired_in: typing.Optional[datetime.datetime] # 过期时间 user_id: int = Field(foreign_key="user.id") # 关联用户 user: User = Relationship(back_populates="tokens") class LoginLog(SQLModel, table=True): __tablename__:str = "login_logs" # type: ignore id: int = Field(primary_key=True) user_id: int = Field(foreign_key="users.id", index=True) # 关联用户 user: User =
Relationship(back_populates="login_logs", link_model="User")
sqlmodel.Relationship
from fastapi.encoders import jsonable_encoder from fastapi.testclient import TestClient from sqlmodel import Session, select from model.item import Item TEST_ITEM = { "name": "aasif126", "sku": "AASI126", "metric": "m", "cost": 2200 } def test_get_items_returns_no_item_when_table_is_empty(client: TestClient): response = client.get("/item/get_all/") assert response.status_code == 200 assert len(response.json()) == 0 def test_get_items_returns_existing_items(client: TestClient, session: Session, item: Item): item_2 = Item(**TEST_ITEM) session.add(item_2) session.commit() session.refresh(item_2) item_ids = [item.id, item_2.id] response = client.get("/item/get_all/") response_ids = list(map(lambda _item: _item['id'], response.json())) assert response.status_code == 200 assert item_ids == response_ids def test_get_items_csv_returns_csv(client: TestClient, session: Session, item: Item): response = client.get("/item/get_all.csv") assert response.status_code == 200 def test_get_items_csv_raises_error_for_when_no_items_present( client: TestClient, session: Session): response = client.get("/item/get_all.csv") assert response.status_code == 404 def test_add_item_returns_inserted_row(client: TestClient, session: Session): response = client.post("/item/", json=TEST_ITEM) assert response.status_code == 200 item = Item(**response.json()) row = session.exec(
select(Item)
sqlmodel.select
from typing import List from uuid import UUID import inject from sqlalchemy.sql.expression import desc from sqlmodel import Session, between, select from src.core.events import EventDescription from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError from src.core.models import ( Client, Context, CreateBalance, CreateOrder, Item, Order, OrderDetail, QueryOrder, UpdateOrder, UpdateOrderStatus, ) from src.core.services import Streamer from . import balance def get_all(session: Session, query_schema: QueryOrder, context: Context) -> List[Order]: args = [] if query_schema.status is not None: args.append(Order.status == query_schema.status) if not context.user_is_super_user: args.append(Order.owner_id == context.user_id) if query_schema.start_date is not None and query_schema.end_date is not None: args.append(
between(Order.date, query_schema.start_date, query_schema.end_date)
sqlmodel.between
from typing import List from uuid import UUID import inject from sqlalchemy.sql.expression import desc from sqlmodel import Session, between, select from src.core.events import EventDescription from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError from src.core.models import ( Client, Context, CreateBalance, CreateOrder, Item, Order, OrderDetail, QueryOrder, UpdateOrder, UpdateOrderStatus, ) from src.core.services import Streamer from . import balance def get_all(session: Session, query_schema: QueryOrder, context: Context) -> List[Order]: args = [] if query_schema.status is not None: args.append(Order.status == query_schema.status) if not context.user_is_super_user: args.append(Order.owner_id == context.user_id) if query_schema.start_date is not None and query_schema.end_date is not None: args.append(between(Order.date, query_schema.start_date, query_schema.end_date)) return session.exec(select(Order).where(*args).order_by(desc(Order.date))).all() def get_by_id(session: Session, order_id: UUID, context: Context) -> Order: order = session.exec(
select(Order)
sqlmodel.select
from typing import List from uuid import UUID import inject from sqlalchemy.sql.expression import desc from sqlmodel import Session, between, select from src.core.events import EventDescription from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError from src.core.models import ( Client, Context, CreateBalance, CreateOrder, Item, Order, OrderDetail, QueryOrder, UpdateOrder, UpdateOrderStatus, ) from src.core.services import Streamer from . import balance def get_all(session: Session, query_schema: QueryOrder, context: Context) -> List[Order]: args = [] if query_schema.status is not None: args.append(Order.status == query_schema.status) if not context.user_is_super_user: args.append(Order.owner_id == context.user_id) if query_schema.start_date is not None and query_schema.end_date is not None: args.append(between(Order.date, query_schema.start_date, query_schema.end_date)) return session.exec(select(Order).where(*args).order_by(desc(Order.date))).all() def get_by_id(session: Session, order_id: UUID, context: Context) -> Order: order = session.exec(select(Order).where(Order.id == order_id)).first() if not order: raise NotFoundError("Não foi possível localizar a venda com ID: %s" % order_id) if not context.user_is_super_user and order.owner_id != context.user_id: raise NotAuthorizedError(f"Você não possui permissão para consultar a Venda {order_id}") return order @inject.params(streamer=Streamer) def register_sale(session: Session, schema: CreateOrder, context: Context, streamer: Streamer) -> Order: if not session.exec(select(Client).where(Client.id == schema.client_id)).first(): raise NotFoundError(f"Não foi possível localizar o cliente com ID: {schema.client_id}") checked_ids = [] for detail in schema.items: if detail.item_id in checked_ids: continue checked_ids.append(detail.item_id) item = session.exec(select(Item).where(Item.id == detail.item_id)).first() if not item: raise NotFoundError(f"Não foi possível salvar a venda, item com o ID {detail.item_id} não existe") if not item.avaliable: raise DataValidationError(f"O item {item.name} de ID {item.id} não está disponível!") total_required = sum(x.item_amount for x in schema.items if x.item_id == item.id) if item.amount < total_required: raise DataValidationError( "O item %(name)s não possui estoque suficiente, disponível: %(amount)s, solicitado: %(required)s" % {"name": item.name, "amount": item.amount, "required": total_required} ) item.amount -= total_required session.add(item) order = Order(**schema.dict(exclude={"details": ...}), owner_id=context.user_id) session.add(order) for detail in schema.items: detail_obj = OrderDetail(**detail.dict(), order_id=order.id) session.add(detail_obj) balance_schema = CreateBalance( value=sum(detail.value for detail in schema.items), operation=schema.sale_type.value, description=schema.description, ) balance_obj = balance.create(session, balance_schema, context=context) session.add(balance_obj) session.commit() streamer.send_event(description=EventDescription.CREATE_ORDER, context=context, order=order.dict()) return order @inject.params(streamer=Streamer) def delete_by_id(session: Session, order_id: UUID, context: Context, streamer: Streamer) -> Order: order = session.exec(
select(Order)
sqlmodel.select
from typing import List from uuid import UUID import inject from sqlalchemy.sql.expression import desc from sqlmodel import Session, between, select from src.core.events import EventDescription from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError from src.core.models import ( Client, Context, CreateBalance, CreateOrder, Item, Order, OrderDetail, QueryOrder, UpdateOrder, UpdateOrderStatus, ) from src.core.services import Streamer from . import balance def get_all(session: Session, query_schema: QueryOrder, context: Context) -> List[Order]: args = [] if query_schema.status is not None: args.append(Order.status == query_schema.status) if not context.user_is_super_user: args.append(Order.owner_id == context.user_id) if query_schema.start_date is not None and query_schema.end_date is not None: args.append(between(Order.date, query_schema.start_date, query_schema.end_date)) return session.exec(select(Order).where(*args).order_by(desc(Order.date))).all() def get_by_id(session: Session, order_id: UUID, context: Context) -> Order: order = session.exec(select(Order).where(Order.id == order_id)).first() if not order: raise NotFoundError("Não foi possível localizar a venda com ID: %s" % order_id) if not context.user_is_super_user and order.owner_id != context.user_id: raise NotAuthorizedError(f"Você não possui permissão para consultar a Venda {order_id}") return order @inject.params(streamer=Streamer) def register_sale(session: Session, schema: CreateOrder, context: Context, streamer: Streamer) -> Order: if not session.exec(select(Client).where(Client.id == schema.client_id)).first(): raise NotFoundError(f"Não foi possível localizar o cliente com ID: {schema.client_id}") checked_ids = [] for detail in schema.items: if detail.item_id in checked_ids: continue checked_ids.append(detail.item_id) item = session.exec(select(Item).where(Item.id == detail.item_id)).first() if not item: raise NotFoundError(f"Não foi possível salvar a venda, item com o ID {detail.item_id} não existe") if not item.avaliable: raise DataValidationError(f"O item {item.name} de ID {item.id} não está disponível!") total_required = sum(x.item_amount for x in schema.items if x.item_id == item.id) if item.amount < total_required: raise DataValidationError( "O item %(name)s não possui estoque suficiente, disponível: %(amount)s, solicitado: %(required)s" % {"name": item.name, "amount": item.amount, "required": total_required} ) item.amount -= total_required session.add(item) order = Order(**schema.dict(exclude={"details": ...}), owner_id=context.user_id) session.add(order) for detail in schema.items: detail_obj = OrderDetail(**detail.dict(), order_id=order.id) session.add(detail_obj) balance_schema = CreateBalance( value=sum(detail.value for detail in schema.items), operation=schema.sale_type.value, description=schema.description, ) balance_obj = balance.create(session, balance_schema, context=context) session.add(balance_obj) session.commit() streamer.send_event(description=EventDescription.CREATE_ORDER, context=context, order=order.dict()) return order @inject.params(streamer=Streamer) def delete_by_id(session: Session, order_id: UUID, context: Context, streamer: Streamer) -> Order: order = session.exec(select(Order).where(Order.id == order_id)).first() if not order: raise NotFoundError(f"Não foi possível localizar a venda com o ID: {order_id}") if not context.user_is_super_user and order.owner_id != context.user_id: raise NotAuthorizedError(f"Você não possui permissão para excluir a Venda {order_id}") for detail in [detail for detail in order.items]: item = detail.item item.amount += detail.item_amount session.add(item) session.delete(order) session.commit() streamer.send_event(EventDescription.DELETE_ORDER, context=context, order=order.dict()) return order @inject.params(streamer=Streamer) def update(session: Session, data: UpdateOrder, context: Context, streamer: Streamer) -> Client: order = session.exec(
select(Order)
sqlmodel.select
from typing import List from uuid import UUID import inject from sqlalchemy.sql.expression import desc from sqlmodel import Session, between, select from src.core.events import EventDescription from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError from src.core.models import ( Client, Context, CreateBalance, CreateOrder, Item, Order, OrderDetail, QueryOrder, UpdateOrder, UpdateOrderStatus, ) from src.core.services import Streamer from . import balance def get_all(session: Session, query_schema: QueryOrder, context: Context) -> List[Order]: args = [] if query_schema.status is not None: args.append(Order.status == query_schema.status) if not context.user_is_super_user: args.append(Order.owner_id == context.user_id) if query_schema.start_date is not None and query_schema.end_date is not None: args.append(between(Order.date, query_schema.start_date, query_schema.end_date)) return session.exec(select(Order).where(*args).order_by(desc(Order.date))).all() def get_by_id(session: Session, order_id: UUID, context: Context) -> Order: order = session.exec(select(Order).where(Order.id == order_id)).first() if not order: raise NotFoundError("Não foi possível localizar a venda com ID: %s" % order_id) if not context.user_is_super_user and order.owner_id != context.user_id: raise NotAuthorizedError(f"Você não possui permissão para consultar a Venda {order_id}") return order @inject.params(streamer=Streamer) def register_sale(session: Session, schema: CreateOrder, context: Context, streamer: Streamer) -> Order: if not session.exec(select(Client).where(Client.id == schema.client_id)).first(): raise NotFoundError(f"Não foi possível localizar o cliente com ID: {schema.client_id}") checked_ids = [] for detail in schema.items: if detail.item_id in checked_ids: continue checked_ids.append(detail.item_id) item = session.exec(select(Item).where(Item.id == detail.item_id)).first() if not item: raise NotFoundError(f"Não foi possível salvar a venda, item com o ID {detail.item_id} não existe") if not item.avaliable: raise DataValidationError(f"O item {item.name} de ID {item.id} não está disponível!") total_required = sum(x.item_amount for x in schema.items if x.item_id == item.id) if item.amount < total_required: raise DataValidationError( "O item %(name)s não possui estoque suficiente, disponível: %(amount)s, solicitado: %(required)s" % {"name": item.name, "amount": item.amount, "required": total_required} ) item.amount -= total_required session.add(item) order = Order(**schema.dict(exclude={"details": ...}), owner_id=context.user_id) session.add(order) for detail in schema.items: detail_obj = OrderDetail(**detail.dict(), order_id=order.id) session.add(detail_obj) balance_schema = CreateBalance( value=sum(detail.value for detail in schema.items), operation=schema.sale_type.value, description=schema.description, ) balance_obj = balance.create(session, balance_schema, context=context) session.add(balance_obj) session.commit() streamer.send_event(description=EventDescription.CREATE_ORDER, context=context, order=order.dict()) return order @inject.params(streamer=Streamer) def delete_by_id(session: Session, order_id: UUID, context: Context, streamer: Streamer) -> Order: order = session.exec(select(Order).where(Order.id == order_id)).first() if not order: raise NotFoundError(f"Não foi possível localizar a venda com o ID: {order_id}") if not context.user_is_super_user and order.owner_id != context.user_id: raise NotAuthorizedError(f"Você não possui permissão para excluir a Venda {order_id}") for detail in [detail for detail in order.items]: item = detail.item item.amount += detail.item_amount session.add(item) session.delete(order) session.commit() streamer.send_event(EventDescription.DELETE_ORDER, context=context, order=order.dict()) return order @inject.params(streamer=Streamer) def update(session: Session, data: UpdateOrder, context: Context, streamer: Streamer) -> Client: order = session.exec(select(Order).where(Order.id == data.id)).first() if not order: raise NotFoundError(f"Não foi possível localizar a venda com ID: {data.id}") if not context.user_is_super_user and order.owner_id != context.user_id: raise NotAuthorizedError(f"Você não possui permissão para excluir a venda com ID: {data.id}") columns = order.__table__.columns.keys() for key, value in data.dict(exclude_defaults=True).items(): if key not in columns: continue setattr(order, key, value) session.add(order) session.commit() streamer.send_event( description=EventDescription.UPDATE_ORDER, context=context, data={"order_data": order.dict(), "update_schema": data.dict()}, ) return order @inject.params(streamer=Streamer) def update_status(session: Session, schema: UpdateOrderStatus, context: Context, streamer: Streamer) -> None: order = session.exec(
select(Order)
sqlmodel.select
from typing import List from uuid import UUID import inject from sqlalchemy.sql.expression import desc from sqlmodel import Session, between, select from src.core.events import EventDescription from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError from src.core.models import ( Client, Context, CreateBalance, CreateOrder, Item, Order, OrderDetail, QueryOrder, UpdateOrder, UpdateOrderStatus, ) from src.core.services import Streamer from . import balance def get_all(session: Session, query_schema: QueryOrder, context: Context) -> List[Order]: args = [] if query_schema.status is not None: args.append(Order.status == query_schema.status) if not context.user_is_super_user: args.append(Order.owner_id == context.user_id) if query_schema.start_date is not None and query_schema.end_date is not None: args.append(between(Order.date, query_schema.start_date, query_schema.end_date)) return session.exec(select(Order).where(*args).order_by(desc(Order.date))).all() def get_by_id(session: Session, order_id: UUID, context: Context) -> Order: order = session.exec(select(Order).where(Order.id == order_id)).first() if not order: raise NotFoundError("Não foi possível localizar a venda com ID: %s" % order_id) if not context.user_is_super_user and order.owner_id != context.user_id: raise NotAuthorizedError(f"Você não possui permissão para consultar a Venda {order_id}") return order @inject.params(streamer=Streamer) def register_sale(session: Session, schema: CreateOrder, context: Context, streamer: Streamer) -> Order: if not session.exec(
select(Client)
sqlmodel.select
from typing import List from uuid import UUID import inject from sqlalchemy.sql.expression import desc from sqlmodel import Session, between, select from src.core.events import EventDescription from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError from src.core.models import ( Client, Context, CreateBalance, CreateOrder, Item, Order, OrderDetail, QueryOrder, UpdateOrder, UpdateOrderStatus, ) from src.core.services import Streamer from . import balance def get_all(session: Session, query_schema: QueryOrder, context: Context) -> List[Order]: args = [] if query_schema.status is not None: args.append(Order.status == query_schema.status) if not context.user_is_super_user: args.append(Order.owner_id == context.user_id) if query_schema.start_date is not None and query_schema.end_date is not None: args.append(between(Order.date, query_schema.start_date, query_schema.end_date)) return session.exec(select(Order).where(*args).order_by(desc(Order.date))).all() def get_by_id(session: Session, order_id: UUID, context: Context) -> Order: order = session.exec(select(Order).where(Order.id == order_id)).first() if not order: raise NotFoundError("Não foi possível localizar a venda com ID: %s" % order_id) if not context.user_is_super_user and order.owner_id != context.user_id: raise NotAuthorizedError(f"Você não possui permissão para consultar a Venda {order_id}") return order @inject.params(streamer=Streamer) def register_sale(session: Session, schema: CreateOrder, context: Context, streamer: Streamer) -> Order: if not session.exec(select(Client).where(Client.id == schema.client_id)).first(): raise NotFoundError(f"Não foi possível localizar o cliente com ID: {schema.client_id}") checked_ids = [] for detail in schema.items: if detail.item_id in checked_ids: continue checked_ids.append(detail.item_id) item = session.exec(
select(Item)
sqlmodel.select
from typing import List from uuid import UUID import inject from sqlalchemy.sql.expression import desc from sqlmodel import Session, between, select from src.core.events import EventDescription from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError from src.core.models import ( Client, Context, CreateBalance, CreateOrder, Item, Order, OrderDetail, QueryOrder, UpdateOrder, UpdateOrderStatus, ) from src.core.services import Streamer from . import balance def get_all(session: Session, query_schema: QueryOrder, context: Context) -> List[Order]: args = [] if query_schema.status is not None: args.append(Order.status == query_schema.status) if not context.user_is_super_user: args.append(Order.owner_id == context.user_id) if query_schema.start_date is not None and query_schema.end_date is not None: args.append(between(Order.date, query_schema.start_date, query_schema.end_date)) return session.exec(
select(Order)
sqlmodel.select
from fastapi import FastAPI from api import router from settings.datastore import dbengine from sqlmodel import SQLModel app = FastAPI() #include app api routers router.add_routers(app)
SQLModel.metadata.create_all(dbengine)
sqlmodel.SQLModel.metadata.create_all
import importlib import pytest from fastapi.testclient import TestClient from sqlalchemy import inspect from sqlalchemy.engine.reflection import Inspector from sqlmodel import Session, create_engine from docs_src.tutorial.fastapi.app_testing.tutorial001 import main as app_mod from docs_src.tutorial.fastapi.app_testing.tutorial001 import test_main as test_mod from docs_src.tutorial.fastapi.app_testing.tutorial001.test_main import ( client_fixture, session_fixture, ) assert session_fixture, "This keeps the session fixture used below" assert client_fixture, "This keeps the client fixture used below" @pytest.fixture(name="prepare", autouse=True) def prepare_fixture(clear_sqlmodel): # Trigger side effects of registering table models in SQLModel # This has to be called after clear_sqlmodel, but before the session_fixture # That's why the extra custom fixture here importlib.reload(app_mod) importlib.reload(test_mod) def test_create_hero(session: Session, client: TestClient): test_mod.test_create_hero(client) def test_create_hero_incomplete(session: Session, client: TestClient): test_mod.test_create_hero_incomplete(client) def test_create_hero_invalid(session: Session, client: TestClient): test_mod.test_create_hero_invalid(client) def test_read_heroes(session: Session, client: TestClient): test_mod.test_read_heroes(session=session, client=client) def test_read_hero(session: Session, client: TestClient): test_mod.test_read_hero(session=session, client=client) def test_update_hero(session: Session, client: TestClient): test_mod.test_update_hero(session=session, client=client) def test_delete_hero(session: Session, client: TestClient): test_mod.test_delete_hero(session=session, client=client) def test_startup(): app_mod.engine =
create_engine("sqlite://")
sqlmodel.create_engine
import importlib import pytest from fastapi.testclient import TestClient from sqlalchemy import inspect from sqlalchemy.engine.reflection import Inspector from sqlmodel import Session, create_engine from docs_src.tutorial.fastapi.app_testing.tutorial001 import main as app_mod from docs_src.tutorial.fastapi.app_testing.tutorial001 import test_main as test_mod from docs_src.tutorial.fastapi.app_testing.tutorial001.test_main import ( client_fixture, session_fixture, ) assert session_fixture, "This keeps the session fixture used below" assert client_fixture, "This keeps the client fixture used below" @pytest.fixture(name="prepare", autouse=True) def prepare_fixture(clear_sqlmodel): # Trigger side effects of registering table models in SQLModel # This has to be called after clear_sqlmodel, but before the session_fixture # That's why the extra custom fixture here importlib.reload(app_mod) importlib.reload(test_mod) def test_create_hero(session: Session, client: TestClient): test_mod.test_create_hero(client) def test_create_hero_incomplete(session: Session, client: TestClient): test_mod.test_create_hero_incomplete(client) def test_create_hero_invalid(session: Session, client: TestClient): test_mod.test_create_hero_invalid(client) def test_read_heroes(session: Session, client: TestClient): test_mod.test_read_heroes(session=session, client=client) def test_read_hero(session: Session, client: TestClient): test_mod.test_read_hero(session=session, client=client) def test_update_hero(session: Session, client: TestClient): test_mod.test_update_hero(session=session, client=client) def test_delete_hero(session: Session, client: TestClient): test_mod.test_delete_hero(session=session, client=client) def test_startup(): app_mod.engine = create_engine("sqlite://") app_mod.on_startup() insp: Inspector = inspect(app_mod.engine) assert insp.has_table(str(app_mod.Hero.__tablename__)) def test_get_session(): app_mod.engine =
create_engine("sqlite://")
sqlmodel.create_engine
from pydantic import BaseModel from sqlmodel import Field, SQLModel, Relationship from typing import Optional, List class UserBase(SQLModel): username: str desc: str class User(UserBase, table=True): id: Optional[int] =
Field(index=True, default=None, primary_key=True)
sqlmodel.Field
from pydantic import BaseModel from sqlmodel import Field, SQLModel, Relationship from typing import Optional, List class UserBase(SQLModel): username: str desc: str class User(UserBase, table=True): id: Optional[int] = Field(index=True, default=None, primary_key=True) password: str tasks: List["Task"] =
Relationship(back_populates="owner")
sqlmodel.Relationship
from pydantic import BaseModel from sqlmodel import Field, SQLModel, Relationship from typing import Optional, List class UserBase(SQLModel): username: str desc: str class User(UserBase, table=True): id: Optional[int] = Field(index=True, default=None, primary_key=True) password: str tasks: List["Task"] = Relationship(back_populates="owner") class UserQuery(SQLModel): id: int class UserCreate(UserBase): pass class UserRead(UserBase, UserQuery): pass class TaskBase(SQLModel): title: str desc: str owner_id: Optional[int] =
Field(default=None, foreign_key="user.id")
sqlmodel.Field
from pydantic import BaseModel from sqlmodel import Field, SQLModel, Relationship from typing import Optional, List class UserBase(SQLModel): username: str desc: str class User(UserBase, table=True): id: Optional[int] = Field(index=True, default=None, primary_key=True) password: str tasks: List["Task"] = Relationship(back_populates="owner") class UserQuery(SQLModel): id: int class UserCreate(UserBase): pass class UserRead(UserBase, UserQuery): pass class TaskBase(SQLModel): title: str desc: str owner_id: Optional[int] = Field(default=None, foreign_key="user.id") class Task(TaskBase, table=True): id: Optional[int] =
Field(default=None, primary_key=True)
sqlmodel.Field
from pydantic import BaseModel from sqlmodel import Field, SQLModel, Relationship from typing import Optional, List class UserBase(SQLModel): username: str desc: str class User(UserBase, table=True): id: Optional[int] = Field(index=True, default=None, primary_key=True) password: str tasks: List["Task"] = Relationship(back_populates="owner") class UserQuery(SQLModel): id: int class UserCreate(UserBase): pass class UserRead(UserBase, UserQuery): pass class TaskBase(SQLModel): title: str desc: str owner_id: Optional[int] = Field(default=None, foreign_key="user.id") class Task(TaskBase, table=True): id: Optional[int] = Field(default=None, primary_key=True) owner: Optional[User] =
Relationship(back_populates="tasks")
sqlmodel.Relationship
from fastapi import APIRouter, Depends, HTTPException, Path from sqlmodel import Session, select from sqlalchemy.exc import IntegrityError from typing import List import datetime as dt from app.src.common.security import get_current_user from app.src.common.utils import profiling_api from app.src.models.app_user import AppUser from app.src.models.tag import Tag, TagRead, TagCreate, TagUpdate from app.src.db.engine import get_session router = APIRouter() async def get_tag_or_404( *, session: Session = Depends(get_session), tag_id: int = Path(..., ge=1), current_user: AppUser = Depends(get_current_user), ): start_time = dt.datetime.now() try: db_tag = session.get(Tag, tag_id) if db_tag: return { "db_tag": db_tag, "username": current_user.username, "start_time": start_time, } else: raise HTTPException(status_code=404, detail="Tag not found") except KeyError: raise HTTPException(status_code=400, detail="Tag not found") async def get_tag_by_name_or_404( *, session: Session = Depends(get_session), tag_name: str, current_user: AppUser = Depends(get_current_user), ): start_time = dt.datetime.now() try: db_tag = session.exec(select(Tag).where(Tag.name == tag_name)).one() if db_tag: return { "db_tag": db_tag, "username": current_user.username, "start_time": start_time, } else: raise HTTPException(status_code=404, detail="Tag not found by name") except KeyError: raise HTTPException(status_code=400, detail="Tag not found by name") @router.get("/", response_model=List[TagRead]) async def read_tags( *, session: Session = Depends(get_session), current_user: AppUser = Depends(get_current_user), ): """ Get all the existing tags """ start_time = dt.datetime.now() tags = session.exec(
select(Tag)
sqlmodel.select
from fastapi import APIRouter, Depends, HTTPException, Path from sqlmodel import Session, select from sqlalchemy.exc import IntegrityError from typing import List import datetime as dt from app.src.common.security import get_current_user from app.src.common.utils import profiling_api from app.src.models.app_user import AppUser from app.src.models.tag import Tag, TagRead, TagCreate, TagUpdate from app.src.db.engine import get_session router = APIRouter() async def get_tag_or_404( *, session: Session = Depends(get_session), tag_id: int = Path(..., ge=1), current_user: AppUser = Depends(get_current_user), ): start_time = dt.datetime.now() try: db_tag = session.get(Tag, tag_id) if db_tag: return { "db_tag": db_tag, "username": current_user.username, "start_time": start_time, } else: raise HTTPException(status_code=404, detail="Tag not found") except KeyError: raise HTTPException(status_code=400, detail="Tag not found") async def get_tag_by_name_or_404( *, session: Session = Depends(get_session), tag_name: str, current_user: AppUser = Depends(get_current_user), ): start_time = dt.datetime.now() try: db_tag = session.exec(
select(Tag)
sqlmodel.select
from typing import Optional from pydantic import condecimal from sqlalchemy.orm import declared_attr from sqlmodel import Field, SQLModel class Reward(SQLModel, table=True): tx_hash: Optional[str] =
Field(primary_key=True)
sqlmodel.Field
"""Initial model generation Revision ID: a2ced875a244 Revises: Create Date: 2021-10-28 09:24:53.225445 """ from alembic import op import sqlalchemy as sa import sqlmodel # revision identifiers, used by Alembic. revision = 'a2ced875a244' down_revision = None branch_labels = None depends_on = None def upgrade(): # ### commands auto generated by Alembic - please adjust! ### op.create_table('category', sa.Column('name',
sqlmodel.sql.sqltypes.AutoString()
sqlmodel.sql.sqltypes.AutoString
"""Initial model generation Revision ID: a2ced875a244 Revises: Create Date: 2021-10-28 09:24:53.225445 """ from alembic import op import sqlalchemy as sa import sqlmodel # revision identifiers, used by Alembic. revision = 'a2ced875a244' down_revision = None branch_labels = None depends_on = None def upgrade(): # ### commands auto generated by Alembic - please adjust! ### op.create_table('category', sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column('playlists',
sqlmodel.sql.sqltypes.AutoString()
sqlmodel.sql.sqltypes.AutoString
"""Initial model generation Revision ID: a2ced875a244 Revises: Create Date: 2021-10-28 09:24:53.225445 """ from alembic import op import sqlalchemy as sa import sqlmodel # revision identifiers, used by Alembic. revision = 'a2ced875a244' down_revision = None branch_labels = None depends_on = None def upgrade(): # ### commands auto generated by Alembic - please adjust! ### op.create_table('category', sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column('playlists', sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column('id', sa.Integer(), nullable=True), sa.PrimaryKeyConstraint('id') ) op.create_index(op.f('ix_category_id'), 'category', ['id'], unique=False) op.create_index(op.f('ix_category_name'), 'category', ['name'], unique=False) op.create_index(op.f('ix_category_playlists'), 'category', ['playlists'], unique=False) op.create_table('user', sa.Column('entity_id',
sqlmodel.sql.sqltypes.AutoString()
sqlmodel.sql.sqltypes.AutoString
"""Initial model generation Revision ID: a2ced875a244 Revises: Create Date: 2021-10-28 09:24:53.225445 """ from alembic import op import sqlalchemy as sa import sqlmodel # revision identifiers, used by Alembic. revision = 'a2ced875a244' down_revision = None branch_labels = None depends_on = None def upgrade(): # ### commands auto generated by Alembic - please adjust! ### op.create_table('category', sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column('playlists', sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column('id', sa.Integer(), nullable=True), sa.PrimaryKeyConstraint('id') ) op.create_index(op.f('ix_category_id'), 'category', ['id'], unique=False) op.create_index(op.f('ix_category_name'), 'category', ['name'], unique=False) op.create_index(op.f('ix_category_playlists'), 'category', ['playlists'], unique=False) op.create_table('user', sa.Column('entity_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column('name',
sqlmodel.sql.sqltypes.AutoString()
sqlmodel.sql.sqltypes.AutoString
"""Initial model generation Revision ID: a2ced875a244 Revises: Create Date: 2021-10-28 09:24:53.225445 """ from alembic import op import sqlalchemy as sa import sqlmodel # revision identifiers, used by Alembic. revision = 'a2ced875a244' down_revision = None branch_labels = None depends_on = None def upgrade(): # ### commands auto generated by Alembic - please adjust! ### op.create_table('category', sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column('playlists', sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column('id', sa.Integer(), nullable=True), sa.PrimaryKeyConstraint('id') ) op.create_index(op.f('ix_category_id'), 'category', ['id'], unique=False) op.create_index(op.f('ix_category_name'), 'category', ['name'], unique=False) op.create_index(op.f('ix_category_playlists'), 'category', ['playlists'], unique=False) op.create_table('user', sa.Column('entity_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column('created_at', sa.DateTime(), nullable=False), sa.Column('last_login', sa.DateTime(), nullable=True), sa.Column('admin', sa.Boolean(), nullable=False), sa.Column('id', sa.Integer(), nullable=True), sa.Column('password',
sqlmodel.sql.sqltypes.AutoString()
sqlmodel.sql.sqltypes.AutoString
import streamlit as st import pandas as pd import argparse import datetime as dt from sqlmodel import create_engine, Session parser = argparse.ArgumentParser(description="A steamlit dashboard for visualising news analytics.") parser.add_argument("--database", type=str, default="sqlite:///database.db") class Dasboard: def __init__(self, database) -> None: self.engine =
create_engine(database)
sqlmodel.create_engine
import streamlit as st import pandas as pd import argparse import datetime as dt from sqlmodel import create_engine, Session parser = argparse.ArgumentParser(description="A steamlit dashboard for visualising news analytics.") parser.add_argument("--database", type=str, default="sqlite:///database.db") class Dasboard: def __init__(self, database) -> None: self.engine = create_engine(database) self.attr = { "date_range": self.get_date_range(), } self.state = st.session_state self.build() def build(self): # ~~~ Build Sidebar ~~~~~~~~~ st.sidebar.header("Newsreader") with st.form(key="date_picker"): st.sidebar.date_input( "Period From", key="period_from", min_value=self.attr["date_range"][0], max_value=self.attr["date_range"][1], value=self.attr["date_range"][0] ) st.sidebar.date_input( "Period To", key="period_to", min_value=self.attr["date_range"][0], max_value=self.attr["date_range"][1], value=self.attr["date_range"][1] ) # ~~~ Build Main UI ~~~~~~~~~~ st.text_input("Search", key="search_text") st.write(self.state.search_text) st.write([self.state.period_from, self.state.period_to]) st.write(self.get_total_sentiment("00375cd420e37d4084c6668975f91648")) # ~~~ Callbacks ~~~~~~~~~~~ # ~~~ Analytics Operations ~~~~~~ def exec(self, stmt: str, params = {}): with
Session(self.engine)
sqlmodel.Session
import os import asyncio import subprocess import contextlib import contextvars from typing import * import wait4it import sqlmodel from sqlmodel import Session from aioify import aioify from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric from twitterscraper.utils import Singleton class Repository(Singleton): # https://sqlmodel.tiangolo.com/ get: Callable[..., "Repository"] _session_contextvar: contextvars.ContextVar[Optional[Session]] def __init__(self, uri: str): self._engine =
sqlmodel.create_engine(uri)
sqlmodel.create_engine
import os import asyncio import subprocess import contextlib import contextvars from typing import * import wait4it import sqlmodel from sqlmodel import Session from aioify import aioify from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric from twitterscraper.utils import Singleton class Repository(Singleton): # https://sqlmodel.tiangolo.com/ get: Callable[..., "Repository"] _session_contextvar: contextvars.ContextVar[Optional[Session]] def __init__(self, uri: str): self._engine = sqlmodel.create_engine(uri) self._session_contextvar = contextvars.ContextVar("session", default=None) # TODO implement pool_pre_ping & pool_recycle_time # Fix for https://github.com/tiangolo/sqlmodel/issues/189#issuecomment-1025190094 from sqlmodel.sql.expression import Select, SelectOfScalar SelectOfScalar.inherit_cache = True # type: ignore Select.inherit_cache = True # type: ignore def _new_session(self) -> Session: session =
Session(bind=self._engine)
sqlmodel.Session
import os import asyncio import subprocess import contextlib import contextvars from typing import * import wait4it import sqlmodel from sqlmodel import Session from aioify import aioify from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric from twitterscraper.utils import Singleton class Repository(Singleton): # https://sqlmodel.tiangolo.com/ get: Callable[..., "Repository"] _session_contextvar: contextvars.ContextVar[Optional[Session]] def __init__(self, uri: str): self._engine = sqlmodel.create_engine(uri) self._session_contextvar = contextvars.ContextVar("session", default=None) # TODO implement pool_pre_ping & pool_recycle_time # Fix for https://github.com/tiangolo/sqlmodel/issues/189#issuecomment-1025190094 from sqlmodel.sql.expression import Select, SelectOfScalar SelectOfScalar.inherit_cache = True # type: ignore Select.inherit_cache = True # type: ignore def _new_session(self) -> Session: session = Session(bind=self._engine) self._session_contextvar.set(session) return session def _get_context_session(self) -> Optional[Session]: return self._session_contextvar.get() def _clear_context_session(self): self._session_contextvar.set(None) @contextlib.contextmanager def session(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") session.commit() except Exception as ex: print("Session Rollback") session.rollback() raise ex finally: print("Session Close") session.close() self._clear_context_session() @contextlib.asynccontextmanager async def session_async(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") await aioify(session.commit)() except Exception as ex: print("Session Rollback") await aioify(session.rollback)() raise ex finally: print("Session Close") await aioify(session.close)() self._clear_context_session() def save_object(self, obj: sqlmodel.SQLModel, flush: bool = False): """Save or update any SQLModel object instance""" with self.session() as session: session.add(obj) if flush: session.flush([obj]) async def save_object_async(self, *obj: sqlmodel.SQLModel, flush: bool = False): # return await aioify(self.save_object)(obj, flush) async with self.session_async() as session: await asyncio.gather(*[aioify(session.add)(_obj) for _obj in obj]) if flush: await aioify(session.flush)(obj) def delete_object(self, obj: sqlmodel.SQLModel, flush: bool = False): with self.session() as session: session.delete(obj) if flush: session.flush([obj]) async def delete_object_async(self, obj: sqlmodel.SQLModel, flush: bool = False): async with self.session_async() as session: await aioify(session.delete)(obj) if flush: await aioify(session.flush)([obj]) def list_profiles(self) -> List[TwitterProfile]: with self.session() as session: query =
sqlmodel.select(TwitterProfile)
sqlmodel.select
import os import asyncio import subprocess import contextlib import contextvars from typing import * import wait4it import sqlmodel from sqlmodel import Session from aioify import aioify from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric from twitterscraper.utils import Singleton class Repository(Singleton): # https://sqlmodel.tiangolo.com/ get: Callable[..., "Repository"] _session_contextvar: contextvars.ContextVar[Optional[Session]] def __init__(self, uri: str): self._engine = sqlmodel.create_engine(uri) self._session_contextvar = contextvars.ContextVar("session", default=None) # TODO implement pool_pre_ping & pool_recycle_time # Fix for https://github.com/tiangolo/sqlmodel/issues/189#issuecomment-1025190094 from sqlmodel.sql.expression import Select, SelectOfScalar SelectOfScalar.inherit_cache = True # type: ignore Select.inherit_cache = True # type: ignore def _new_session(self) -> Session: session = Session(bind=self._engine) self._session_contextvar.set(session) return session def _get_context_session(self) -> Optional[Session]: return self._session_contextvar.get() def _clear_context_session(self): self._session_contextvar.set(None) @contextlib.contextmanager def session(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") session.commit() except Exception as ex: print("Session Rollback") session.rollback() raise ex finally: print("Session Close") session.close() self._clear_context_session() @contextlib.asynccontextmanager async def session_async(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") await aioify(session.commit)() except Exception as ex: print("Session Rollback") await aioify(session.rollback)() raise ex finally: print("Session Close") await aioify(session.close)() self._clear_context_session() def save_object(self, obj: sqlmodel.SQLModel, flush: bool = False): """Save or update any SQLModel object instance""" with self.session() as session: session.add(obj) if flush: session.flush([obj]) async def save_object_async(self, *obj: sqlmodel.SQLModel, flush: bool = False): # return await aioify(self.save_object)(obj, flush) async with self.session_async() as session: await asyncio.gather(*[aioify(session.add)(_obj) for _obj in obj]) if flush: await aioify(session.flush)(obj) def delete_object(self, obj: sqlmodel.SQLModel, flush: bool = False): with self.session() as session: session.delete(obj) if flush: session.flush([obj]) async def delete_object_async(self, obj: sqlmodel.SQLModel, flush: bool = False): async with self.session_async() as session: await aioify(session.delete)(obj) if flush: await aioify(session.flush)([obj]) def list_profiles(self) -> List[TwitterProfile]: with self.session() as session: query = sqlmodel.select(TwitterProfile) return session.exec(query).all() async def list_profiles_async(self, filter_active_profiles: Optional[bool] = None) -> List[TwitterProfile]: async with self.session_async() as session: query =
sqlmodel.select(TwitterProfile)
sqlmodel.select
import os import asyncio import subprocess import contextlib import contextvars from typing import * import wait4it import sqlmodel from sqlmodel import Session from aioify import aioify from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric from twitterscraper.utils import Singleton class Repository(Singleton): # https://sqlmodel.tiangolo.com/ get: Callable[..., "Repository"] _session_contextvar: contextvars.ContextVar[Optional[Session]] def __init__(self, uri: str): self._engine = sqlmodel.create_engine(uri) self._session_contextvar = contextvars.ContextVar("session", default=None) # TODO implement pool_pre_ping & pool_recycle_time # Fix for https://github.com/tiangolo/sqlmodel/issues/189#issuecomment-1025190094 from sqlmodel.sql.expression import Select, SelectOfScalar SelectOfScalar.inherit_cache = True # type: ignore Select.inherit_cache = True # type: ignore def _new_session(self) -> Session: session = Session(bind=self._engine) self._session_contextvar.set(session) return session def _get_context_session(self) -> Optional[Session]: return self._session_contextvar.get() def _clear_context_session(self): self._session_contextvar.set(None) @contextlib.contextmanager def session(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") session.commit() except Exception as ex: print("Session Rollback") session.rollback() raise ex finally: print("Session Close") session.close() self._clear_context_session() @contextlib.asynccontextmanager async def session_async(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") await aioify(session.commit)() except Exception as ex: print("Session Rollback") await aioify(session.rollback)() raise ex finally: print("Session Close") await aioify(session.close)() self._clear_context_session() def save_object(self, obj: sqlmodel.SQLModel, flush: bool = False): """Save or update any SQLModel object instance""" with self.session() as session: session.add(obj) if flush: session.flush([obj]) async def save_object_async(self, *obj: sqlmodel.SQLModel, flush: bool = False): # return await aioify(self.save_object)(obj, flush) async with self.session_async() as session: await asyncio.gather(*[aioify(session.add)(_obj) for _obj in obj]) if flush: await aioify(session.flush)(obj) def delete_object(self, obj: sqlmodel.SQLModel, flush: bool = False): with self.session() as session: session.delete(obj) if flush: session.flush([obj]) async def delete_object_async(self, obj: sqlmodel.SQLModel, flush: bool = False): async with self.session_async() as session: await aioify(session.delete)(obj) if flush: await aioify(session.flush)([obj]) def list_profiles(self) -> List[TwitterProfile]: with self.session() as session: query = sqlmodel.select(TwitterProfile) return session.exec(query).all() async def list_profiles_async(self, filter_active_profiles: Optional[bool] = None) -> List[TwitterProfile]: async with self.session_async() as session: query = sqlmodel.select(TwitterProfile) if filter_active_profiles is not None: query = query.where(TwitterProfile.active == filter_active_profiles) result = await aioify(session.exec)(query) return await aioify(result.all)() def get_profile_by_userid(self, userid: str) -> TwitterProfile: # TODO Deprecate with self.session() as session: query = sqlmodel.select(TwitterProfile).where(TwitterProfile.userid == userid) return session.exec(query).one() async def get_profile_by_userid_async(self, userid: str) -> TwitterProfile: # TODO Deprecate async with self.session_async() as session: query = sqlmodel.select(TwitterProfile).where(TwitterProfile.userid == userid) result = await aioify(session.exec)(query) return await aioify(result.one)() async def get_profile_by(self, userid: Optional[str] = None, username: Optional[str] = None) -> TwitterProfile: async with self.session_async() as session: query =
sqlmodel.select(TwitterProfile)
sqlmodel.select
import os import asyncio import subprocess import contextlib import contextvars from typing import * import wait4it import sqlmodel from sqlmodel import Session from aioify import aioify from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric from twitterscraper.utils import Singleton class Repository(Singleton): # https://sqlmodel.tiangolo.com/ get: Callable[..., "Repository"] _session_contextvar: contextvars.ContextVar[Optional[Session]] def __init__(self, uri: str): self._engine = sqlmodel.create_engine(uri) self._session_contextvar = contextvars.ContextVar("session", default=None) # TODO implement pool_pre_ping & pool_recycle_time # Fix for https://github.com/tiangolo/sqlmodel/issues/189#issuecomment-1025190094 from sqlmodel.sql.expression import Select, SelectOfScalar SelectOfScalar.inherit_cache = True # type: ignore Select.inherit_cache = True # type: ignore def _new_session(self) -> Session: session = Session(bind=self._engine) self._session_contextvar.set(session) return session def _get_context_session(self) -> Optional[Session]: return self._session_contextvar.get() def _clear_context_session(self): self._session_contextvar.set(None) @contextlib.contextmanager def session(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") session.commit() except Exception as ex: print("Session Rollback") session.rollback() raise ex finally: print("Session Close") session.close() self._clear_context_session() @contextlib.asynccontextmanager async def session_async(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") await aioify(session.commit)() except Exception as ex: print("Session Rollback") await aioify(session.rollback)() raise ex finally: print("Session Close") await aioify(session.close)() self._clear_context_session() def save_object(self, obj: sqlmodel.SQLModel, flush: bool = False): """Save or update any SQLModel object instance""" with self.session() as session: session.add(obj) if flush: session.flush([obj]) async def save_object_async(self, *obj: sqlmodel.SQLModel, flush: bool = False): # return await aioify(self.save_object)(obj, flush) async with self.session_async() as session: await asyncio.gather(*[aioify(session.add)(_obj) for _obj in obj]) if flush: await aioify(session.flush)(obj) def delete_object(self, obj: sqlmodel.SQLModel, flush: bool = False): with self.session() as session: session.delete(obj) if flush: session.flush([obj]) async def delete_object_async(self, obj: sqlmodel.SQLModel, flush: bool = False): async with self.session_async() as session: await aioify(session.delete)(obj) if flush: await aioify(session.flush)([obj]) def list_profiles(self) -> List[TwitterProfile]: with self.session() as session: query = sqlmodel.select(TwitterProfile) return session.exec(query).all() async def list_profiles_async(self, filter_active_profiles: Optional[bool] = None) -> List[TwitterProfile]: async with self.session_async() as session: query = sqlmodel.select(TwitterProfile) if filter_active_profiles is not None: query = query.where(TwitterProfile.active == filter_active_profiles) result = await aioify(session.exec)(query) return await aioify(result.all)() def get_profile_by_userid(self, userid: str) -> TwitterProfile: # TODO Deprecate with self.session() as session: query =
sqlmodel.select(TwitterProfile)
sqlmodel.select
import os import asyncio import subprocess import contextlib import contextvars from typing import * import wait4it import sqlmodel from sqlmodel import Session from aioify import aioify from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric from twitterscraper.utils import Singleton class Repository(Singleton): # https://sqlmodel.tiangolo.com/ get: Callable[..., "Repository"] _session_contextvar: contextvars.ContextVar[Optional[Session]] def __init__(self, uri: str): self._engine = sqlmodel.create_engine(uri) self._session_contextvar = contextvars.ContextVar("session", default=None) # TODO implement pool_pre_ping & pool_recycle_time # Fix for https://github.com/tiangolo/sqlmodel/issues/189#issuecomment-1025190094 from sqlmodel.sql.expression import Select, SelectOfScalar SelectOfScalar.inherit_cache = True # type: ignore Select.inherit_cache = True # type: ignore def _new_session(self) -> Session: session = Session(bind=self._engine) self._session_contextvar.set(session) return session def _get_context_session(self) -> Optional[Session]: return self._session_contextvar.get() def _clear_context_session(self): self._session_contextvar.set(None) @contextlib.contextmanager def session(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") session.commit() except Exception as ex: print("Session Rollback") session.rollback() raise ex finally: print("Session Close") session.close() self._clear_context_session() @contextlib.asynccontextmanager async def session_async(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") await aioify(session.commit)() except Exception as ex: print("Session Rollback") await aioify(session.rollback)() raise ex finally: print("Session Close") await aioify(session.close)() self._clear_context_session() def save_object(self, obj: sqlmodel.SQLModel, flush: bool = False): """Save or update any SQLModel object instance""" with self.session() as session: session.add(obj) if flush: session.flush([obj]) async def save_object_async(self, *obj: sqlmodel.SQLModel, flush: bool = False): # return await aioify(self.save_object)(obj, flush) async with self.session_async() as session: await asyncio.gather(*[aioify(session.add)(_obj) for _obj in obj]) if flush: await aioify(session.flush)(obj) def delete_object(self, obj: sqlmodel.SQLModel, flush: bool = False): with self.session() as session: session.delete(obj) if flush: session.flush([obj]) async def delete_object_async(self, obj: sqlmodel.SQLModel, flush: bool = False): async with self.session_async() as session: await aioify(session.delete)(obj) if flush: await aioify(session.flush)([obj]) def list_profiles(self) -> List[TwitterProfile]: with self.session() as session: query = sqlmodel.select(TwitterProfile) return session.exec(query).all() async def list_profiles_async(self, filter_active_profiles: Optional[bool] = None) -> List[TwitterProfile]: async with self.session_async() as session: query = sqlmodel.select(TwitterProfile) if filter_active_profiles is not None: query = query.where(TwitterProfile.active == filter_active_profiles) result = await aioify(session.exec)(query) return await aioify(result.all)() def get_profile_by_userid(self, userid: str) -> TwitterProfile: # TODO Deprecate with self.session() as session: query = sqlmodel.select(TwitterProfile).where(TwitterProfile.userid == userid) return session.exec(query).one() async def get_profile_by_userid_async(self, userid: str) -> TwitterProfile: # TODO Deprecate async with self.session_async() as session: query =
sqlmodel.select(TwitterProfile)
sqlmodel.select
import os import asyncio import subprocess import contextlib import contextvars from typing import * import wait4it import sqlmodel from sqlmodel import Session from aioify import aioify from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric from twitterscraper.utils import Singleton class Repository(Singleton): # https://sqlmodel.tiangolo.com/ get: Callable[..., "Repository"] _session_contextvar: contextvars.ContextVar[Optional[Session]] def __init__(self, uri: str): self._engine = sqlmodel.create_engine(uri) self._session_contextvar = contextvars.ContextVar("session", default=None) # TODO implement pool_pre_ping & pool_recycle_time # Fix for https://github.com/tiangolo/sqlmodel/issues/189#issuecomment-1025190094 from sqlmodel.sql.expression import Select, SelectOfScalar SelectOfScalar.inherit_cache = True # type: ignore Select.inherit_cache = True # type: ignore def _new_session(self) -> Session: session = Session(bind=self._engine) self._session_contextvar.set(session) return session def _get_context_session(self) -> Optional[Session]: return self._session_contextvar.get() def _clear_context_session(self): self._session_contextvar.set(None) @contextlib.contextmanager def session(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") session.commit() except Exception as ex: print("Session Rollback") session.rollback() raise ex finally: print("Session Close") session.close() self._clear_context_session() @contextlib.asynccontextmanager async def session_async(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") await aioify(session.commit)() except Exception as ex: print("Session Rollback") await aioify(session.rollback)() raise ex finally: print("Session Close") await aioify(session.close)() self._clear_context_session() def save_object(self, obj: sqlmodel.SQLModel, flush: bool = False): """Save or update any SQLModel object instance""" with self.session() as session: session.add(obj) if flush: session.flush([obj]) async def save_object_async(self, *obj: sqlmodel.SQLModel, flush: bool = False): # return await aioify(self.save_object)(obj, flush) async with self.session_async() as session: await asyncio.gather(*[aioify(session.add)(_obj) for _obj in obj]) if flush: await aioify(session.flush)(obj) def delete_object(self, obj: sqlmodel.SQLModel, flush: bool = False): with self.session() as session: session.delete(obj) if flush: session.flush([obj]) async def delete_object_async(self, obj: sqlmodel.SQLModel, flush: bool = False): async with self.session_async() as session: await aioify(session.delete)(obj) if flush: await aioify(session.flush)([obj]) def list_profiles(self) -> List[TwitterProfile]: with self.session() as session: query = sqlmodel.select(TwitterProfile) return session.exec(query).all() async def list_profiles_async(self, filter_active_profiles: Optional[bool] = None) -> List[TwitterProfile]: async with self.session_async() as session: query = sqlmodel.select(TwitterProfile) if filter_active_profiles is not None: query = query.where(TwitterProfile.active == filter_active_profiles) result = await aioify(session.exec)(query) return await aioify(result.all)() def get_profile_by_userid(self, userid: str) -> TwitterProfile: # TODO Deprecate with self.session() as session: query = sqlmodel.select(TwitterProfile).where(TwitterProfile.userid == userid) return session.exec(query).one() async def get_profile_by_userid_async(self, userid: str) -> TwitterProfile: # TODO Deprecate async with self.session_async() as session: query = sqlmodel.select(TwitterProfile).where(TwitterProfile.userid == userid) result = await aioify(session.exec)(query) return await aioify(result.one)() async def get_profile_by(self, userid: Optional[str] = None, username: Optional[str] = None) -> TwitterProfile: async with self.session_async() as session: query = sqlmodel.select(TwitterProfile) if userid: query = query.where(TwitterProfile.userid == userid) if username: query = query.where(TwitterProfile.username == username) result = await aioify(session.exec)(query) return await aioify(result.one)() # noinspection PyComparisonWithNone async def tweets_iterator( self, batch_size: int, userid: Optional[str] = None, username: Optional[str] = None, from_ts: Optional[int] = None, to_ts: Optional[int] = None, filter_active_profiles: Optional[bool] = None, filter_active_tweets: Optional[bool] = None, tweets_ids: Optional[List[str]] = None, ) -> AsyncIterable[List[TwitterTweet]]: # TODO Deprecate, iterator seems like no longer needed # TODO Any way for making the generator async? async with self.session_async() as session: query =
sqlmodel.select(TwitterTweet)
sqlmodel.select
import os import asyncio import subprocess import contextlib import contextvars from typing import * import wait4it import sqlmodel from sqlmodel import Session from aioify import aioify from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric from twitterscraper.utils import Singleton class Repository(Singleton): # https://sqlmodel.tiangolo.com/ get: Callable[..., "Repository"] _session_contextvar: contextvars.ContextVar[Optional[Session]] def __init__(self, uri: str): self._engine = sqlmodel.create_engine(uri) self._session_contextvar = contextvars.ContextVar("session", default=None) # TODO implement pool_pre_ping & pool_recycle_time # Fix for https://github.com/tiangolo/sqlmodel/issues/189#issuecomment-1025190094 from sqlmodel.sql.expression import Select, SelectOfScalar SelectOfScalar.inherit_cache = True # type: ignore Select.inherit_cache = True # type: ignore def _new_session(self) -> Session: session = Session(bind=self._engine) self._session_contextvar.set(session) return session def _get_context_session(self) -> Optional[Session]: return self._session_contextvar.get() def _clear_context_session(self): self._session_contextvar.set(None) @contextlib.contextmanager def session(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") session.commit() except Exception as ex: print("Session Rollback") session.rollback() raise ex finally: print("Session Close") session.close() self._clear_context_session() @contextlib.asynccontextmanager async def session_async(self) -> Session: """Contextmanager that wraps code behind a database transaction (session). Any error during the execution rolls back the transaction, so any data saved is not persisted.""" session = self._get_context_session() if session is not None: # Another session() contextmanager is already running; let it handle the commit/rollback yield session return session = self._new_session() print("New session") try: yield session print("Session Commit") await aioify(session.commit)() except Exception as ex: print("Session Rollback") await aioify(session.rollback)() raise ex finally: print("Session Close") await aioify(session.close)() self._clear_context_session() def save_object(self, obj: sqlmodel.SQLModel, flush: bool = False): """Save or update any SQLModel object instance""" with self.session() as session: session.add(obj) if flush: session.flush([obj]) async def save_object_async(self, *obj: sqlmodel.SQLModel, flush: bool = False): # return await aioify(self.save_object)(obj, flush) async with self.session_async() as session: await asyncio.gather(*[aioify(session.add)(_obj) for _obj in obj]) if flush: await aioify(session.flush)(obj) def delete_object(self, obj: sqlmodel.SQLModel, flush: bool = False): with self.session() as session: session.delete(obj) if flush: session.flush([obj]) async def delete_object_async(self, obj: sqlmodel.SQLModel, flush: bool = False): async with self.session_async() as session: await aioify(session.delete)(obj) if flush: await aioify(session.flush)([obj]) def list_profiles(self) -> List[TwitterProfile]: with self.session() as session: query = sqlmodel.select(TwitterProfile) return session.exec(query).all() async def list_profiles_async(self, filter_active_profiles: Optional[bool] = None) -> List[TwitterProfile]: async with self.session_async() as session: query = sqlmodel.select(TwitterProfile) if filter_active_profiles is not None: query = query.where(TwitterProfile.active == filter_active_profiles) result = await aioify(session.exec)(query) return await aioify(result.all)() def get_profile_by_userid(self, userid: str) -> TwitterProfile: # TODO Deprecate with self.session() as session: query = sqlmodel.select(TwitterProfile).where(TwitterProfile.userid == userid) return session.exec(query).one() async def get_profile_by_userid_async(self, userid: str) -> TwitterProfile: # TODO Deprecate async with self.session_async() as session: query = sqlmodel.select(TwitterProfile).where(TwitterProfile.userid == userid) result = await aioify(session.exec)(query) return await aioify(result.one)() async def get_profile_by(self, userid: Optional[str] = None, username: Optional[str] = None) -> TwitterProfile: async with self.session_async() as session: query = sqlmodel.select(TwitterProfile) if userid: query = query.where(TwitterProfile.userid == userid) if username: query = query.where(TwitterProfile.username == username) result = await aioify(session.exec)(query) return await aioify(result.one)() # noinspection PyComparisonWithNone async def tweets_iterator( self, batch_size: int, userid: Optional[str] = None, username: Optional[str] = None, from_ts: Optional[int] = None, to_ts: Optional[int] = None, filter_active_profiles: Optional[bool] = None, filter_active_tweets: Optional[bool] = None, tweets_ids: Optional[List[str]] = None, ) -> AsyncIterable[List[TwitterTweet]]: # TODO Deprecate, iterator seems like no longer needed # TODO Any way for making the generator async? async with self.session_async() as session: query = sqlmodel.select(TwitterTweet).join(TwitterProfile) if filter_active_profiles is not None: query = query.where(TwitterProfile.active == filter_active_profiles) if filter_active_tweets is True: query = query.where(TwitterTweet.deletion_detected_timestamp == None) elif filter_active_tweets is False: query = query.where(TwitterTweet.deletion_detected_timestamp != None) if userid is not None: query = query.where(TwitterProfile.userid == userid) if username is not None: query = query.where(TwitterProfile.username == username) if from_ts is not None: query = query.where(TwitterTweet.timestamp >= from_ts) if to_ts is not None: query = query.where(TwitterTweet.timestamp < to_ts) if tweets_ids is not None: # noinspection PyUnresolvedReferences query = query.filter(TwitterTweet.tweet_id.in_(tweets_ids)) query = query.execution_options(stream_results=True) result = session.exec(query) for partition in result.partitions(batch_size): yield partition async def get_tweets( self, **kwargs ) -> List[TwitterTweet]: tweets = list() async for tweets_batch in self.tweets_iterator(batch_size=50, **kwargs): tweets.extend(tweets_batch) return tweets async def get_job_historic(self, job_id: str) -> Optional[JobHistoric]: async with self.session_async() as session: query =
sqlmodel.select(JobHistoric)
sqlmodel.select
import typer import uvicorn from sqlmodel import Session, select from .app import app from .config import settings from .db import create_db_and_tables, engine from .models.content import Content from .security import User cli = typer.Typer(name="pythontasks API") @cli.command() def run( port: int = settings.server.port, host: str = settings.server.host, log_level: str = settings.server.log_level, reload: bool = settings.server.reload, ): # pragma: no cover """Run the API server.""" uvicorn.run( "pythontasks.app:app", host=host, port=port, log_level=log_level, reload=reload, ) @cli.command() def create_user(username: str, password: str, superuser: bool = False): """Create user""" create_db_and_tables(engine) with
Session(engine)
sqlmodel.Session
import typer import uvicorn from sqlmodel import Session, select from .app import app from .config import settings from .db import create_db_and_tables, engine from .models.content import Content from .security import User cli = typer.Typer(name="pythontasks API") @cli.command() def run( port: int = settings.server.port, host: str = settings.server.host, log_level: str = settings.server.log_level, reload: bool = settings.server.reload, ): # pragma: no cover """Run the API server.""" uvicorn.run( "pythontasks.app:app", host=host, port=port, log_level=log_level, reload=reload, ) @cli.command() def create_user(username: str, password: str, superuser: bool = False): """Create user""" create_db_and_tables(engine) with Session(engine) as session: user = User(username=username, password=password, superuser=superuser) session.add(user) session.commit() session.refresh(user) typer.echo(f"created {username} user") return user @cli.command() def shell(): # pragma: no cover """Opens an interactive shell with objects auto imported""" _vars = { "app": app, "settings": settings, "User": User, "engine": engine, "cli": cli, "create_user": create_user, "select": select, "session":
Session(engine)
sqlmodel.Session
from datetime import datetime, timezone from typing import List, Optional from sqlmodel import Field, Relationship, SQLModel, Session, select from sqlalchemy.engine import Engine class Post(SQLModel, table=True): __tablename__ = "ig_posts" id: Optional[int] =
Field(default=None, primary_key=True)
sqlmodel.Field
from datetime import datetime, timezone from typing import List, Optional from sqlmodel import Field, Relationship, SQLModel, Session, select from sqlalchemy.engine import Engine class Post(SQLModel, table=True): __tablename__ = "ig_posts" id: Optional[int] = Field(default=None, primary_key=True) ig_account_id: int =
Field(foreign_key="ig_accounts.id")
sqlmodel.Field
from datetime import datetime, timezone from typing import List, Optional from sqlmodel import Field, Relationship, SQLModel, Session, select from sqlalchemy.engine import Engine class Post(SQLModel, table=True): __tablename__ = "ig_posts" id: Optional[int] = Field(default=None, primary_key=True) ig_account_id: int = Field(foreign_key="ig_accounts.id") ig_pk: int webhook_message_id: Optional[int] = None ig_account: "IGAccount" =
Relationship(back_populates="ig_posts")
sqlmodel.Relationship