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")