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 |
Subsets and Splits