async def app_init():
# Dependency injection
container = Container()
container.config.connection_string.from_value(
"mongodb://*****:*****@localhost:27020/ark?authSource=admin&readPreference=primary&ssl=false"
)
container.init_resources()
container.wire(modules=[sys.modules[__name__], audit_router_module])
app.container = container
# Database configuration
await configure_beanie()
# Routes config
app.include_router(api_router)
# Middlewares
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
add_pagination(app)
def test_add_pagination():
app = FastAPI()
@app.get("/first")
async def route():
pass
@app.get(
"/second",
response_model=Page[int],
)
async def route():
pass
*_, r1, r2 = app.routes
assert len(r1.dependencies) == 0
assert len(r2.dependencies) == 0
add_pagination(app)
assert len(r1.dependencies) == 0
assert len(r2.dependencies) == 4
add_pagination(app)
assert len(r1.dependencies) == 0
assert len(r2.dependencies) == 4
def app(pool):
app = FastAPI()
@app.on_event("startup")
async def on_startup() -> None:
await pool
await pool.acquire()
async with pool.acquire() as conn:
await conn.fetch("DROP TABLE IF EXISTS users CASCADE;")
await conn.fetch(
"CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT NOT NULL);"
)
@app.on_event("shutdown")
async def on_shutdown() -> None:
await pool.terminate()
@app.get("/default", response_model=Page[UserOut])
@app.get("/limit-offset", response_model=LimitOffsetPage[UserOut])
async def route():
async with pool.acquire() as conn:
return await paginate(conn, "SELECT id, name FROM users")
add_pagination(app)
return app
def app(Base, User, SessionLocal):
app = FastAPI()
@app.on_event("startup")
def on_startup():
Base.metadata.create_all()
session = SessionLocal()
session.add_all([User(name=faker.name()) for _ in range(100)])
session.flush()
session.close()
def get_db() -> Iterator[Session]:
db = SessionLocal()
try:
yield db
finally:
db.close()
@app.get("/default", response_model=Page[UserOut])
@app.get("/limit-offset", response_model=LimitOffsetPage[UserOut])
def route(db: Session = Depends(get_db)):
return paginate(db.query(User))
add_pagination(app)
return app
def app(db, metadata, User):
app = FastAPI()
@app.on_event("startup")
async def on_startup() -> None:
engine = sqlalchemy.create_engine(str(db.url))
metadata.drop_all(engine)
metadata.create_all(engine)
await db.connect()
for _ in range(100):
await User.objects.create(name=faker.name())
@app.on_event("shutdown")
async def on_shutdown() -> None:
await db.disconnect()
@app.get("/default", response_model=Page[UserOut])
@app.get("/limit-offset", response_model=LimitOffsetPage[UserOut])
async def route():
return await paginate(User.objects)
add_pagination(app)
return app
def custom_test_server():
container = ServerContainer()
container.wire(modules=[emissions])
app = FastAPI()
app.container = container
app.include_router(emissions.router)
add_pagination(app)
yield app
async def start_app(app: FastAPI) -> None:
"""Services to start upon app launch"""
app.state.model = AitaPredictor(classifier=DummyClassifier())
app.state.reddit = await get_reddit_connection(settings.reddit)
app.state.user = await get_reddit_user(app.state.reddit)
app.include_router(api_router, prefix=settings.api_version)
add_pagination(app)
def test_default_page_with_limit_offset():
app = FastAPI()
client = TestClient(app)
@app.get("/")
def route(params: Params = Depends()):
return paginate([], params)
add_pagination(app)
with raises(ValueError, match="Page should be used with Params"):
client.get("/")
def init_server(container):
server = FastAPI(dependencies=[Depends(get_query_token)])
server.container = container
server.include_router(users.router)
server.include_router(authenticate.router)
server.include_router(organizations.router)
server.include_router(teams.router)
server.include_router(projects.router)
server.include_router(experiments.router)
server.include_router(experiments.router)
server.include_router(runs.router)
server.include_router(emissions.router)
add_pagination(server)
return server
def test_set_response():
app = FastAPI()
client = TestClient(app)
@app.get(
"/",
response_model=Page[int],
)
async def route(res: Response):
assert res is response()
return paginate([])
add_pagination(app)
client.get("/")
def get_application():
app = FastAPI(title=config.PROJECT_NAME, version=config.VERSION)
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
bind_event_handlers(app)
app.include_router(api_router, prefix=config.API_PREFIX)
add_pagination(app)
return app
def get_app() -> FastAPI:
"""Generate instance of FastAPI app"""
app = FastAPI(
debug=settings.debug,
title="MyChef",
description="Recipe recommender app",
docs_url=None,
redoc_url=None,
openapi_url=None,
)
app.include_router(router, prefix=settings.api_version)
app.state.extractor = IngredientExtractor()
add_pagination(app)
return app
def test_add_pagination_include_router():
router1 = APIRouter()
@router1.get(
"/first",
response_model=Page[int],
)
async def route():
pass
(r1, ) = router1.routes
assert len(r1.dependencies) == 0
add_pagination(router1)
assert len(r1.dependencies) == 4
router2 = APIRouter()
@router2.get(
"/second",
response_model=Page[int],
)
async def route():
pass
(r2, ) = router2.routes
assert len(r2.dependencies) == 0
app = FastAPI()
app.include_router(router1)
app.include_router(router2)
*_, r1, r2 = app.routes
assert len(r1.dependencies) == 4
assert len(r2.dependencies) == 0
add_pagination(app)
assert len(r1.dependencies) == 4
assert len(r2.dependencies) == 4
def app(db, User, query):
app = FastAPI()
db.init_app(app)
@app.on_event("startup")
async def on_startup() -> None:
await db.gino.drop_all()
await db.gino.create_all()
await User.delete.gino.status()
for _ in range(100):
await User.create(name=faker.name())
@app.get("/default", response_model=Page[UserOut])
@app.get("/limit-offset", response_model=LimitOffsetPage[UserOut])
async def route():
return await paginate(query)
add_pagination(app)
return app
def test_add_pagination_additional_dependencies():
app = FastAPI()
async def dep():
pass
@app.get(
"/",
response_model=Page[int],
dependencies=[Depends(dep)],
)
async def route(_: Any = Depends(dep)):
pass
*_, r = app.routes
assert len(r.dependencies) == 1
assert len(r.dependant.dependencies) == 2
add_pagination(app)
assert len(r.dependencies) == 5
assert len(r.dependant.dependencies) == 6
def http(self):
"""load FastAPI to instance"""
self._app = FastAPI(**self.base_settings)
self._app.router.route_class = GzipRoute
# routers
for router in self.kwargs.get('routers', []):
self._app.include_router(**router)
# cors
backend_cors_origins = self.kwargs.get('backend_cors_origins')
if backend_cors_origins:
self._app.add_middleware(GZipMiddleware)
self._app.add_middleware(
CORSMiddleware,
allow_origins=[str(origin) for origin in backend_cors_origins],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
self._app.middleware('http')(process_middleware)
add_pagination(self._app)
def app(query, database_url):
app = FastAPI()
if database_url.startswith("postgresql://"):
database_url = database_url.replace("postgresql://", "postgres://")
if database_url.startswith("sqlite"):
database_url = "sqlite://:memory:"
EXECUTOR_CACHE.clear()
register_tortoise(
app,
modules={"models": [__name__]},
db_url=database_url,
generate_schemas=True,
)
@app.get("/default", response_model=Page[UserOut])
@app.get("/limit-offset", response_model=LimitOffsetPage[UserOut])
async def route():
return await paginate(query)
add_pagination(app)
return app
from tinychronicler.database import database
from .files import create_uploads_dir
from .router import router
# Use FastAPIOffline as we don't want to load OpenAPI static files from CDNs
server = FastAPIOffline()
# Add static files for webpage
server.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
# Serve uploaded user files
create_uploads_dir()
server.mount("/uploads", StaticFiles(directory=UPLOADS_DIR), name="uploads")
# Mount routes
server.include_router(router)
# Install FastAPI pagination extension after mounting routes
add_pagination(server)
@server.on_event("startup")
async def startup():
await database.connect()
@server.on_event("shutdown")
async def shutdown():
await database.disconnect()
from pytest import fixture
from fastapi_pagination import LimitOffsetPage, Page, add_pagination, paginate
from .base import BasePaginationTestCase, SafeTestClient, UserOut
from .utils import faker
app = FastAPI()
entities = [UserOut(name=faker.name()) for _ in range(100)]
@app.get("/default", response_model=Page[UserOut])
@app.get("/limit-offset", response_model=LimitOffsetPage[UserOut])
async def route():
return paginate(entities)
add_pagination(app)
class TestPaginationParams(BasePaginationTestCase):
@fixture(scope="session")
def entities(self):
return entities
@fixture(scope="session")
def client(self):
with SafeTestClient(app) as c:
yield c
from fastapi import FastAPI, Depends
from fastapi_pagination import add_pagination
from . import routes as rt
app = FastAPI()
for r in rt.__routes__:
app.include_router(r.get("route"), tags=r.get("tags"), dependencies=r.get("dependencies"))
app=add_pagination(app)
# @app.get("/")
# # def home(token: str = Depends(oauth2_scheme)):
# def home():
# jobs.insert({"job_desc": "xxx"})
# jobs.update({"job_cde": "JD0000000002", "job_desc": "yyy"})
# # jobs.upsert({"job_desc": "xxx"})
# rtn = jobs.to_dict()
# return {"data": rtn}
# # @app.get("/jobs", response_model=Page[jobs._model])
# # def get_job():
# # rtn = jobs.to_dict()
# # return paginate(rtn)
# @app.post("/jobs", response_model=Page[jobs._model])
# def post_job(job: jobs._model):
# updcols = jobs.cols(attr="updcol")
# keycols = jobs.cols(attr="key")
