def _add_route(router: APIRouter, obj, route: dict, fn_name: str): fn = getattr(obj, fn_name) @wraps(fn, injected=['self']) def wrapper(*args, **kwargs): ret = fn(*args, **kwargs) return ret router.api_route(*route['args'], **route['kwargs'])(wrapper)
def build_router(deps: Dependencies) -> APIRouter: router = APIRouter(default_response_class=JSONResponse) database, user_repo = attrgetter("database", "user_repo")(deps) @router.post( "", status_code=201, response_model=UserRegistry, responses={ 201: {"description": "User registered", "model": UserRegistry}, 409: { "description": "User already registered", "model": EmailNotUniqueResponse, }, }, ) @database.transaction() async def post(credentials: Credentials,) -> UserRegistry: try: result = await user_service.register(user_repo, credentials) except EmailNotUniqueError as err: raise HTTPException(409, detail=err.as_dict()) return result return router
def build_router(deps: Dependencies) -> APIRouter: router: APIRouter = pipe( APIRouter(default_response_class=JSONResponse), partial(_register_create_actions, deps), partial(_register_delete_actions, deps), partial(_register_read_actions, deps), partial(_register_update_actions, deps), ) return router
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 __new__(cls): from application.main.routers.health_checks import router as router_health_check from application.main.routers.hello_world import router as router_hello_world from application.main.routers.api_response import router as response_manager_test from application.main.routers.question_classifier import router as router_question_classification from fastapi.routing import APIRouter router = APIRouter() router.include_router(router_health_check, prefix='/api/v1', tags=['Health']) router.include_router(router_hello_world, prefix='/api/v1', tags=['Hello World']) router.include_router(response_manager_test, prefix='/api/v1', tags=['Response Manager']) router.include_router(router_question_classification, prefix='/api/v1', tags=['Classification']) return router
def build_router(setts: Settings, deps: Dependencies) -> APIRouter: rt = APIRouter() rt.include_router(auth.build_router(setts, deps), prefix="/oauth2", tags=["Auth"]) rt.include_router(user.build_router(deps), prefix="/user", tags=["User"]) return rt
def __call__(self, cls: TypeVar) -> APIRouter: if not hasattr(cls, ROUTER_KEY): raise ValueError('Unexcepted Error') router = APIRouter() setattr(router, ROUTER_KEY, getattr(cls, ROUTER_KEY)) members = inspect.getmembers( cls, lambda member: inspect.isfunction(member) and hasattr( member, ROUTE_KEY)) # members.sort(key=InspectUtils.linenumber_of_member, reverse=True) for (fn_name, fn) in members: for route_meta in fn.__route__: route_inst = self.injector.get(cls) _add_route(router, route_inst, route_meta, fn_name) return router
def app() -> FastAPI: api_router = APIRouter() @api_router.get("/") def _get_root(): return {"name": __name__, "timestamp": datetime.utcnow().isoformat()} @api_router.get("/data") def _get_data(x: PositiveFloat, y: int = Query(..., gt=3, lt=4)): pass _app = FastAPI() _app.include_router(api_router) return _app
class Tags: routes = APIRouter(prefix="/projects/{project_uuid}", tags=["project"]) @staticmethod @routes.put("/tags/{tag_id}") def replace(tag_id: int, project_uuid: UUID = Depends(get_valid_project)): """Assigns a tag to a project""" ... @staticmethod @routes.delete( "/tags/{tag_id}", status_code=status.HTTP_204_NO_CONTENT, ) def delete(tag_id: int, project_uuid: UUID = Depends(get_valid_project)): """Un-assigns tag to a project""" ...
def __init__( self, debug: bool = False, routes: List[BaseRoute] = None, template_directory: str = None, title: str = "Fast API", description: str = "", version: str = "0.1.0", openapi_url: Optional[str] = "/openapi.json", openapi_prefix: str = "", docs_url: Optional[str] = "/docs", redoc_url: Optional[str] = "/redoc", swagger_ui_oauth2_redirect_url: Optional[ str] = "/docs/oauth2-redirect", **extra: Dict[str, Any], ) -> None: self._debug = debug self.router: APIRouter = APIRouter(routes, dependency_overrides_provider=self) self.exception_middleware = ExceptionMiddleware(self.router, debug=debug) self.error_middleware = ServerErrorMiddleware( self.exception_middleware, debug=debug) self.title = title self.description = description self.version = version self.openapi_url = openapi_url self.openapi_prefix = openapi_prefix.rstrip("/") self.docs_url = docs_url self.redoc_url = redoc_url self.swagger_ui_oauth2_redirect_url = swagger_ui_oauth2_redirect_url self.extra = extra self.dependency_overrides: Dict[Callable, Callable] = {} self.openapi_version = "3.0.2" if self.openapi_url: assert self.title, "A title must be provided for OpenAPI, e.g.: 'My API'" assert self.version, "A version must be provided for OpenAPI, e.g.: '2.1.0'" if self.docs_url or self.redoc_url: assert self.openapi_url, "The openapi_url is required for the docs" self.openapi_schema: Optional[Dict[str, Any]] = None self.setup()
def build_router(setts: Settings, deps: Dependencies) -> APIRouter: router = APIRouter(default_response_class=JSONResponse) access_expire = attrgetter("JWT_ACCESS_TOKEN_EXPIRE_MINUTES")(setts) auth, repo = attrgetter("auth_module", "user_repo")(deps) @router.post( "/token", response_model=Token, responses={ 200: {"description": "User authenticated"}, 401: {"description": "User unauthenticated"}, }, ) async def token(form_data: OAuth2PasswordRequestForm = Depends()): username, password = attrgetter("username", "password")(form_data) credentials = Credentials(email=username, password=password) user = await user_service.get_by_credentials(repo, credentials) if not user: raise HTTPException( status_code=401, detail="invalid authentication credentials", ) at, exp_at = auth.encode_token( data={"sub": f"userid:{user.id}", "grant_type": "access"}, expires_delta=timedelta(minutes=access_expire), ) return Token(access_token=at, expire=exp_at) @router.get( "/introspect", response_model=UserRegistry, responses={ 200: {"description": "User registry"}, 401: {"description": "User unauthorized"}, }, ) def introspect(user: UserRegistry = Depends(auth.get_current_user)): return user return router
def build_router(settings: Settings) -> APIRouter: router = APIRouter() @router.get( "/status", response_model=HealthCheck, status_code=status.HTTP_200_OK, summary="Performs health check", description=""" Performs health check and returns information about running service. """, ) def health_check(): return { "title": settings.WEB_APP_TITLE, "description": settings.WEB_APP_DESCRIPTION, "version": settings.WEB_APP_VERSION, "status": StatusEnum.OK, } return router
import json import time from dataclasses import dataclass from typing import Dict, List from dataclasses_json import DataClassJsonMixin from fastapi import WebSocket from fastapi.routing import APIRouter from loguru import logger from starlette.websockets import WebSocketDisconnect chat_router = APIRouter() @dataclass class ChatMessage(DataClassJsonMixin): timestamp: float author: str message: str class WebsocketChatManager: def __init__(self): self.active_connections: List[WebSocket] = [] self.usernames: Dict[str, WebSocket] = {} self.messages_history: List[ChatMessage] = [] async def connect(self, websocket: WebSocket): await websocket.accept() self.active_connections.append(websocket)
# -*- coding: utf-8 -*- from fastapi.routing import APIRouter from apps.health_check.urls import router as router_health_check from apps.people.urls import router as router_people from apps.places.urls import router as router_places router = APIRouter() router.include_router(router_health_check, prefix='/api/v1', tags=['health_check']) router.include_router(router_people, prefix='/api/v1', tags=['people']) router.include_router(router_places, prefix='/api/v1', tags=['places'])
# This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. from logging import Logger from fastapi.routing import APIRouter from fastapi.logger import logger as fastapi_logger from pydantic import BaseModel, Field from gravel.controllers.bootstrap \ import Bootstrap, BootstrapStage logger: Logger = fastapi_logger router: APIRouter = APIRouter(prefix="/bootstrap", tags=["bootstrap"]) bootstrap = Bootstrap() class StartReplyModel(BaseModel): success: bool = Field(title="Operation started successfully") class StatusReplyModel(BaseModel): stage: BootstrapStage = Field(title="Current bootstrapping stage") @router.post("/start", response_model=StartReplyModel) async def start_bootstrap() -> StartReplyModel: res: bool = await bootstrap.bootstrap()
import logging import time from http import HTTPStatus from cassandra.cqlengine import ValidationError from cassandra.cqlengine.query import DoesNotExist from CassandraModels import * from fastapi.exceptions import HTTPException from fastapi.routing import APIRouter from models import Detail # from cassandra.cqlengine.models import DoesNotExist ApiKeyRouter: APIRouter = APIRouter(tags=["API Keys"]) _apiLogger: logging.Logger = logging.getLogger("api") # Create API Key @ApiKeyRouter.post( path="/key/", status_code=HTTPStatus.CREATED, summary="Create a API Key", responses={ HTTPStatus.CREATED.value: { "description": "201 response is sent on a successful creation of a API Key.", "model": Detail, "content": { "application/json": { "example": { "detail": "b24aj62cb-1625-4ab5-212b-aah08cxc9a"
# -*- coding: utf-8 -*- from fastapi.routing import APIRouter from apps.health_check.urls import router as router_health_check from apps.places.urls import router as router_places router = APIRouter() router.include_router(router_health_check, prefix='/api/v1', tags=['health-check']) router.include_router(router_places, prefix='/api/v1', tags=['places'])
from typing import Any, List, Optional from fastapi.params import Path, Query from fastapi.routing import APIRouter from starlette import status from starlette.responses import JSONResponse from app.config import get_base_service_url, get_services from app.uniprot.schema import Result, Structure, UniProtEntry from app.utils import send_async_requests uniprot_route = APIRouter() @uniprot_route.get( "/{qualifier}.json", status_code=status.HTTP_200_OK, response_model=Result ) async def get_uniprot( qualifier: Any = Path( ..., description="UniProtKB accession number (AC) or entry name (ID)" ), provider: Optional[Any] = Query( None, enum=["swissmodel", "genome3d", "foldx", "pdb"] ), template: Optional[Any] = Query( None, description="Template is 4 letter PDB code, or 4 letter code with " "assembly ID and chain for SMTL entries", ), res_range: Optional[Any] = Query( None,
from fastapi.routing import APIRouter from fastbroker.components import api_version, Catalog router = APIRouter() @router.get( "/catalog", tags=["Catalog"], summary="get the catalog of services that the service broker offers", response_model=Catalog, ) def catalog(x_broker_api_version=api_version): pass
from fastapi.routing import APIRouter from manatee.api.endpoints import sessions, organizations router = APIRouter() router.include_router(sessions.router, prefix="/sessions") router.include_router(organizations.router, prefix="/organizations")
from fastapi.routing import APIRouter from . import bot_webhook, info router = APIRouter() router.include_router(bot_webhook.router) router.include_router(info.router)
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. from logging import Logger from typing import Any, List from fastapi import Depends, HTTPException, Request, status from fastapi.logger import logger as fastapi_logger from fastapi.routing import APIRouter from gravel.api import install_gate, jwt_auth_scheme from gravel.controllers.auth import JWT, UserMgr, UserModel logger: Logger = fastapi_logger router: APIRouter = APIRouter(prefix="/users", tags=["users"]) @router.get("/", name="Get list of users", response_model=List[UserModel]) async def enumerate_users( request: Request, jwt: Any = Depends(jwt_auth_scheme), gate: Any = Depends(install_gate), ) -> List[UserModel]: user_mgr = UserMgr(request.app.state.gstate.store) return await user_mgr.enumerate() @router.post("/create", name="Create a new user") async def create_user( user: UserModel,
from fastapi.param_functions import Depends from fastapi.routing import APIRouter from fastapi.security.oauth2 import OAuth2PasswordRequestForm from starlette import status from ..exceptions import FailureSignInException from ..models.domain.tokens import TokenType from ..models.schemas.tokens import TokenResponse from ..repository import UserRepository from ..repository.mysql import UserMysqlRepository from ..services import authenticate_user, create_access_token from ....core.database import get_database_session from sqlalchemy.orm import Session token = APIRouter() @token.post( path="", name="액세스 토큰 발급", status_code=status.HTTP_201_CREATED, response_model=TokenResponse, ) async def sign_in( form_data: OAuth2PasswordRequestForm = Depends(), session: Session = Depends(get_database_session), ) -> Dict[str, Any]: repository: UserRepository = UserMysqlRepository(session) user = await authenticate_user( repository=repository,
# -*- coding: utf-8 -*- from json import JSONDecodeError from fastapi import HTTPException from fastapi.routing import APIRouter from starlette import status from starlette.requests import Request from core.services.proxy import proxy, make_request from core.config import PEOPLE_MICROSERVICES, PLACES_MICROSERVICES router = APIRouter() router.get('/')(proxy(PEOPLE_MICROSERVICES)) router.get('/{people_id}')(proxy(PEOPLE_MICROSERVICES)) router.delete('/{people_id}')(proxy(PEOPLE_MICROSERVICES)) @router.post('/') async def create_people(request: Request): await validate_place_id(request) return await proxy(PEOPLE_MICROSERVICES)(request) @router.put('/{people_id}') async def update_people(request: Request): await validate_place_id(request) return await proxy(PEOPLE_MICROSERVICES)(request) async def validate_place_id(request): try:
# Use self-hosted files USE_LOCAL_DOCS_FILES = decouple_config('USE_LOCAL_DOCS_FILES', cast=bool, default=False) DOCS_URL = decouple_config('DOCS_URL') REDOC_URL = decouple_config('REDOC_URL') OPENAPI_URL = decouple_config('OPENAPI_URL') DOCS_AUTH_URL = decouple_config('DOCS_AUTH_URL') APP_TITLE = decouple_config('APP_TITLE', default='FastAPI') if USE_LOCAL_DOCS_FILES: DOCS_URL = None REDOC_URL = None # Locaal docs urls local_docs_router = APIRouter(include_in_schema=False) @local_docs_router.get("/docs") async def custom_swagger_ui_html(): return get_swagger_ui_html( openapi_url=OPENAPI_URL, title=APP_TITLE + " - Swagger UI", oauth2_redirect_url=DOCS_AUTH_URL, swagger_js_url="/static/swagger-ui-bundle.js", swagger_css_url="/static/swagger-ui.css", ) @local_docs_router.get(DOCS_AUTH_URL) async def swagger_ui_redirect():
from typing import List from app.domains.music import Music from app.repositories.initialization import lookup from fastapi.routing import APIRouter, HTTPException router = APIRouter(prefix='/musics') @router.get('', response_model=List[Music]) def get_music_list(): return [file.json() for file in lookup.files] @router.get('/{music_id}', response_model=Music) def get_music(music_id: int): music = lookup.lookup(music_id) if music is None: raise HTTPException(404) return music.json()
from logging import Logger from typing import List from fastapi.logger import logger as fastapi_logger from fastapi.routing import APIRouter from fastapi import HTTPException, status from pydantic import BaseModel from pydantic.fields import Field from gravel.controllers.services import \ NotEnoughSpaceError, ServiceError, ServiceModel, \ ServiceRequirementsModel, ServiceTypeEnum, Services from gravel.controllers.resources import storage logger: Logger = fastapi_logger router: APIRouter = APIRouter(prefix="/services", tags=["services"]) class ReservationsReply(BaseModel): reserved: int = Field(0, title="Total reserved storage space (bytes)") available: int = Field(0, title="Available storage space (bytes)") class RequirementsRequest(BaseModel): size: int = Field(0, title="Expected storage space (bytes)", gt=0) replicas: int = Field(0, title="Number of replicas", gt=0) class RequirementsReply(BaseModel): feasible: bool = Field(False, title="Requested requirements are feasible") requirements: ServiceRequirementsModel
from ... import auth, config, schema from ...api import api_tasks as api_tasks from ...api import api_users as api_users from ...api.admin import admin_tasks as api_admin_tasks from ...api.admin import admin_users as api_admin_users from ...api.admin import admin_checker logger = logging.getLogger("yatb.view") from .. import templ # noqa router = APIRouter( prefix="/admin", tags=["admin_view"], ) @router.get("/") async def admin_index(request: Request, user: schema.User = Depends(admin_checker)): return templ.TemplateResponse( "admin/index.jhtml", { "request": request, "curr_user": user, }, )
full_path: str, stat_result: os.stat_result, scope: Scope, status_code: int = 200, ) -> Response: return FileResponse( full_path, status_code=status_code, headers={"Cache-Control": "public, max-age=86400"}, stat_result=stat_result, method=scope["method"], ) STATIC_FILES_APP = StaticFilesLocal(directory="frontend/build/static") STATIC_FILES_PATH = "/static" STATIC_FILES_NAME = "frontend_static" ROUTER = APIRouter() @ROUTER.get("/") async def frontend_index(request: Request): """ Return the entrypoint for the frontend SPA. Never cache this """ return FileResponse( "frontend/build/index.html", headers={"Cache-Control": "no-store"} )
# -*- coding: utf-8 -*- from fastapi.routing import APIRouter from apps.places.views.places import router as router_places router = APIRouter() router.include_router(router_places, prefix='/places')