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