def app(User):
from fastapi_sqla import Session, setup
try:
from fastapi_sqla import AsyncSession
except ImportError:
AsyncSession = False
app = FastAPI()
setup(app)
class UserIn(BaseModel):
id: int
first_name: str
last_name: str
@app.post("/users")
def create_user(user: UserIn, session: Session = Depends()):
session.add(User(**user.dict()))
if AsyncSession:
@app.post("/async/users")
def create_user_with_async_session(user: UserIn,
session: AsyncSession = Depends()):
session.add(User(**user.dict()))
return app
def app(User):
from fastapi_sqla import Session, setup
try:
from fastapi_sqla import AsyncSession
except ImportError:
AsyncSession = False
app = FastAPI()
setup(app)
class UserIn(BaseModel):
id: int
first_name: str
last_name: str
@app.post("/users")
def create_user(user: UserIn, session: Session = Depends()):
session.add(User(**user.dict()))
if AsyncSession:
@app.post("/async/users")
def create_user_with_async_session(user: UserIn,
session: AsyncSession = Depends()):
session.add(User(**user.dict()))
@app.get("/404")
def get_users(session: Session = Depends(Session)):
raise HTTPException(status_code=404, detail="YOLO")
return app
def app(user_cls, note_cls):
from fastapi_sqla import (
Page,
Paginate,
PaginateSignature,
Pagination,
Session,
setup,
)
app = FastAPI()
setup(app)
class Note(BaseModel):
id: int
content: str
class Config:
orm_mode = True
class User(BaseModel):
id: int
name: str
notes: List[Note]
class Config:
orm_mode = True
@app.get("/v1/users", response_model=Page[User])
def sqla_13_all_users(session: Session = Depends(),
paginate: Paginate = Depends()):
query = (session.query(user_cls).options(joinedload("notes")).order_by(
user_cls.id))
return paginate(query)
@app.get("/v2/users", response_model=Page[User])
def sqla_14_all_users(paginate: Paginate = Depends()):
query = select(user_cls).options(joinedload("notes")).order_by(
user_cls.id)
return paginate(query)
def query_count(session: Session, query: Select) -> int:
return session.execute(select(
func.count()).select_from(user_cls)).scalar()
CustomPaginate: PaginateSignature = Pagination(query_count=query_count)
@app.get("/v2/custom/users", response_model=Page[User])
def sqla_14_all_users_custom_pagination(
paginate: CustomPaginate = Depends()):
query = select(user_cls).options(joinedload("notes")).order_by(
user_cls.id)
return paginate(query)
return app
async def test_fastapi_integration():
from fastapi_sqla import _Session, setup
app = FastAPI()
setup(app)
@app.get("/one")
def now():
session = _Session()
result = session.execute(text("SELECT 1")).scalar()
session.close()
return result
async with LifespanManager(app):
async with httpx.AsyncClient(
app=app, base_url="http://example.local"
) as client:
res = await client.get("/one")
assert res.json() == 1
def app(user_cls, note_cls):
from fastapi_sqla import (
Page,
Paginate,
PaginateSignature,
Pagination,
Session,
setup,
)
app = FastAPI()
setup(app)
class Note(BaseModel):
id: int
content: str
class Config:
orm_mode = True
class User(BaseModel):
id: int
name: str
notes: List[Note]
class Config:
orm_mode = True
class UserWithNotesCount(BaseModel):
id: int
name: str
notes_count: int
@app.get("/v1/users", response_model=Page[User])
def sqla_13_all_users(session: Session = Depends(),
paginate: Paginate = Depends()):
query = (session.query(user_cls).options(joinedload("notes")).order_by(
user_cls.id))
return paginate(query)
@app.get("/v2/users", response_model=Page[User])
def sqla_14_all_users(paginate: Paginate = Depends()):
query = select(user_cls).options(joinedload("notes")).order_by(
user_cls.id)
return paginate(query)
@app.get("/v2/users-with-notes-count",
response_model=Page[UserWithNotesCount])
def sqla_14_all_users_with_notes_count(paginate: Paginate = Depends()):
query = (select(
user_cls.id, user_cls.name,
func.count(
note_cls.id).label("notes_count")).join(note_cls).order_by(
user_cls.id).group_by(user_cls))
return paginate(query, scalars=False)
def count_user_notes(user_id: int, session: Session = Depends()) -> int:
return session.execute(
select(func.count(
note_cls.id)).where(note_cls.user_id == user_id)).scalar()
CustomPaginate: PaginateSignature = Pagination(
query_count=count_user_notes)
@app.get("/v2/users/{user_id}/notes", response_model=Page[Note])
def list_user_notes_with_custom_pagination(
user_id: int, paginate: CustomPaginate = Depends()):
return paginate(select(note_cls).where(note_cls.user_id == user_id))
return app