def create_testing_router() -> None: router = fastapi.APIRouter() @router.get("/testing-endpoint-with-explicit-dep", response_model=ResponseTest) async def test_explicit_deps( installation: github_types.GitHubInstallation = fastapi. Depends( # noqa: B008 security.get_installation), ) -> ResponseTest: async with github.aget_client(installation) as client: org = await client.item(f"/user/{installation['account']['id']}") return ResponseTest(org["login"]) @router.get( "/testing-endpoint-with-owner/{owner}", # noqa: FS003 response_model=ResponseTest, ) async def test_owner( installation: github_types.GitHubInstallation = fastapi. Depends( # noqa: B008 security.get_installation), ) -> ResponseTest: async with github.aget_client(installation) as client: org = await client.item(f"/user/{installation['account']['id']}") return ResponseTest(org["login"]) api_root.app.include_router(router)
def create_testing_router() -> None: router = fastapi.APIRouter() @router.get("/testing-endpoint-exception-rate-limited", response_model=ResponseTest) async def test_exception_rate_limited() -> Type[RateLimited]: raise RateLimited(datetime.timedelta(seconds=622, microseconds=280475), 0) api_root.app.include_router(router) web_root.app.include_router(router)
def get_api_router(self): def transform_response_to_fastapi_response(response: entities.ServerResponse): return fastapi.Response( content=response.raw_body, headers=response.headers, status_code=response.status_code, ) api_router = fastapi.APIRouter() @api_router.get('/_mat') async def get_config(): mat_config = self._get_config_use_case.execute() return mat_config.serialize() available_proxy_methods = [ 'GET', 'POST', 'DELETE', 'PUT', 'PATCH', ] @api_router.api_route('/{path:path}', methods=available_proxy_methods) async def proxy(path, request: fastapi.Request): client_request = entities.ClientRequest( method=request.method, path=path, query_string=str(request.query_params), headers=dict(request.headers), raw_body=await request.body() ) # 檢查是否需要 mock response existed = self._check_if_mock_response_exists_use_case.execute(client_request) # 如果需要 mock if existed: mock_response = self._get_mock_response_use_case.execute(client_request) return transform_response_to_fastapi_response(mock_response) # 檢查是否有 Proxy Server existed = self._check_if_proxy_server_exists_use_case.execute() if not existed: raise fastapi.HTTPException(status_code=404) # 如果不需要 mock,直接轉給 proxy server else: proxy_server_response = self._get_proxy_server_response_use_case.execute(client_request) return transform_response_to_fastapi_response(proxy_server_response) return api_router
def test_get_server_api_router(): generate_default_config_use_case = mock.MagicMock(spec=use_cases.GenerateDefaultConfigUseCase) check_config_use_case = mock.MagicMock(spec=use_cases.CheckConfigUseCase) api_router = fastapi.APIRouter() server = mock.MagicMock(spec=Server) server.get_api_router.return_value = api_router manager = Manager( generate_default_config_use_case=generate_default_config_use_case, check_config_use_case=check_config_use_case, server=server, ) assert manager.get_server_api_router() == api_router server.get_api_router.assert_called()
def add_app_routes(appcfg): """add api routes.""" api_router = fastapi.APIRouter() routepaths, routenames = get_mods('routes') print("routepaths: {}".format(routepaths)) print("routenames: {}".format(routenames)) ## Todo: raise exception if routepaths is None or len(routepaths) < 1: sys.exit() for rfn, rname in get_route_registry(routepaths): if rfn and rname: entity_prefix = os.path.join(appcfg.API_BASE_URL, rname.split('.')[-1]) api_router.include_router(rfn(appcfg), prefix=entity_prefix, tags=[entity_prefix]) return api_router
from nestedtext import loads, dumps, NestedTextError from starlette import status from starlette.requests import Request from sqldoc import config from sqldoc.helpers import convert, get_by_path, set_by_path from sqldoc.schemata import ValidationError from sqldoc.views.view_helpers import helpers from markdown import markdown sqldoc = config.sqldoc sg = config.sg reg = config.r router = fastapi.APIRouter( default_response_class=fastapi.responses.HTMLResponse) #config.register_view(router,['content']) @router.get('/edit/{_docid}', name='content') @template(template_file='content.pt') def edit_get(_docid: str): doc: dict = sqldoc.read_doc(_docid) converters = {'text/markdown': markdown} converted = converters.get(doc['content_type'], str)(doc['content_data']) return dict(_docid=_docid, doc=doc, helpers=helpers, converted=converted) @router.post('/edit/{_docid}', name='content') @template(template_file='content.pt') def edit_post(_docid: str,
from __future__ import annotations import io import celery.exceptions import fastapi as f import starlette.responses from .. import dependencies from .. import models from .. import responses from ...database import tables from ...taskbus import tasks router_files = f.APIRouter() @router_files.post("/layer", summary="Upload an audio track.", response_model=models.LayerOutput, status_code=201, responses={ **responses.celery_timeout, **responses.login_error, }) def upload_layer( ls: dependencies.LoginSession = f.Depends( dependencies.dependency_login_session), file: f.UploadFile = f.File(..., description="The file to be uploaded."), generate_entries: bool = f.Query(
from typing import Dict import fastapi from recruiter.utils.service_config import get_info resource_router = fastapi.APIRouter() @resource_router.get("/") async def get_root() -> Dict[str, str]: return {"message": "OK"} @resource_router.get("/health") async def get_health() -> Dict[str, str]: return {"message": "OK"} @resource_router.get("/version") async def get_version() -> Dict[str, str]: return get_info()
from typing import Optional, List import fastapi from fastapi import Depends, Security from forsguiden.dependencies import on_database from forsguiden.model import * from forsguiden.db import Db from forsguiden.security import behorighet router = fastapi.APIRouter(tags=["Vattendrag"]) # Vattendrag _redigera = dependencies = [Security(behorighet("redigera:vattendrag"))] @router.get("/vattendrag") async def lista_vattendrag(db: Db = Depends( on_database)) -> VattendragCollection: return VattendragCollection(vattendrag=db.lista_vattendrag()) @router.get("/vattendrag/{id}") async def hamta_vattendrag_med_id( id: int, db: Db = Depends(on_database)) -> Vattendrag: vattendrag = db.hamta_vattendrag(id) if vattendrag is None: raise fastapi.HTTPException(status_code=404) return vattendrag
import fastapi from fastapi import Depends, Request, status from fastapi.responses import HTMLResponse, RedirectResponse from app.auth.base import get_current_user from app.db.crud import ( get_potential_friends, write_friend, get_users_by_name_surname ) from app.db.schemas import UserReturnSchema from app.db.utils import prepare_users_to_form from app.models.base import UserAddFriendForm, NameSurnameForm from . import templates router = fastapi.APIRouter(prefix='/friends') @router.get('/find-friends', response_class=HTMLResponse) async def find_friends( request: Request, current_user: UserReturnSchema = Depends(get_current_user) ): current_user_id = current_user.id database = request.app.state.db entries = await get_potential_friends(db=database, user_id=current_user_id) potential_friends = prepare_users_to_form(entries) return templates.TemplateResponse( 'find-friends.html', {
@APP.exception_handler(pydantic.error_wrappers.ValidationError) async def handle_validation_error( request: fastapi.Request, exc: pydantic.error_wrappers.ValidationError): """ Handles validation errors. """ return fastapi.responses.JSONResponse({'message': exc.errors()}, status_code=422) # ################ # Routes # ################ V2 = fastapi.APIRouter() @V2.get('/latest', response_model=models.LatestResponse) def get_latest(request: fastapi.Request, source: Sources = 'jhu'): """ Getting latest amount of total confirmed cases, deaths, and recoveries. """ locations = request.state.source.get_all() return { 'latest': { 'confirmed': sum(map(lambda location: location.confirmed, locations)), 'deaths': sum(map(lambda location: location.deaths, locations)), 'recovered': sum(map(lambda location: location.recovered, locations)),
from __future__ import annotations import fastapi as f import sqlalchemy.orm from royalnet.typing import * from .. import dependencies from .. import models from .. import responses from ...database import tables router_songs = f.APIRouter() @router_songs.get( "/", summary="Get all songs.", responses={ **responses.login_error, }, response_model=List[models.Song] ) def get_all( ls: dependencies.LoginSession = f.Depends(dependencies.dependency_login_session), limit: int = f.Query(500, description="The number of objects that will be returned.", ge=0, le=500), offset: int = f.Query(0, description="The starting object from which the others will be returned.", ge=0), ): """ Get an array of all the songs currently in the database, in pages of `limit` elements and starting at the element number `offset`.
from typing import Optional, List from urllib.request import urlopen import fastapi from fastapi import Depends from six.moves import urllib from forsguiden.dependencies import on_database from forsguiden.model import * from forsguiden.db import Db from forsguiden.db.postgres import DbInfo, PostgresDb from forsguiden.security import behorighet, inloggad from forsguiden.smhi import Smhipunkt, sok_smhipunkt from forsguiden.hojd import hamta_hojd, Hojd router = fastapi.APIRouter(tags=["Övrigt"]) # Övrigt @router.get("/") async def root(): return { "meddelande": "Välkommen till Forsguiden API", "swagger": "/docs", "resurser": ["/lan", "/vattendrag", "/forsstracka", "/datadump"], } @router.get("/hojd/") async def hojd(east: float, north: float) -> Hojd:
def get_router(): """ Get the router for module :return: """ return fastapi.APIRouter(get_routes())
from starlette.datastructures import MutableHeaders import starlette.responses import starlette.types from .. import byteranges from .. import concurrency from .. import ltmodels from .. import ltpy from .. import services from .. import swarm from .. import torrent_info from .. import util from ..services import atp as atp_services from ..services import util as services_util ROUTER = fastapi.APIRouter(prefix="/d", tags=["data access"]) _LOG = logging.getLogger(__name__) # from starlette.staticfiles, which requires aiofiles to even import class NotModifiedResponse(starlette.responses.Response): NOT_MODIFIED_HEADERS = ( "cache-control", "content-location", "date", "etag", "expires", "vary", )
def patch_app(self, app: fastapi.FastAPI, enable_environ: bool = True, enable_health: bool = True, enable_heartbeat: bool = True, enable_version: bool = True) -> None: # # register plugins for name, state in app.state._state.items(): if isinstance(state, ControlHealthMixin): self.plugins.append((name, state)) # # register endpoints if not (enable_environ or enable_health or enable_heartbeat or enable_version): # noqa E501 return router_control = fastapi.APIRouter() if enable_version: @router_control.get('/version', summary='Version', description='Get the version', response_model=ControlVersion) async def version_get() -> ControlVersion: return ControlVersion(version=await self.get_version()) if enable_environ: @router_control.get('/environ', summary='Environment', description='Get the environment', response_model=ControlEnviron) async def environ_get() -> ControlEnviron: return ControlEnviron(environ=dict( **(await self.get_environ()))) if enable_heartbeat: @router_control.get('/heartbeat', summary='Heart beat', description='Get the alive signal', response_model=ControlHeartBeat) async def heartbeat_get() -> ControlHeartBeat: return ControlHeartBeat(is_alive=await self.get_heart_beat()) if enable_health: @router_control.get( '/health', summary='Health', description='Get the health', response_model=ControlHealth, responses={ starlette.status.HTTP_200_OK: dict(description='UP and healthy', model=ControlHealth), starlette.status.HTTP_417_EXPECTATION_FAILED: dict(description='NOT healthy', model=ControlHealthError) }) async def health_get() -> ControlHealth: health = await self.get_health() if health.status: return health else: raise fastapi.HTTPException( status_code=starlette.status. HTTP_417_EXPECTATION_FAILED, # noqa E501 detail=health.dict()) # # register router app.include_router( router_control, prefix='/' + self.router_prefix, tags=[self.router_tag], )
import fastapi from fastapi import Depends, status from sqlalchemy.orm import Session from ..models import schemas, models from ..database import get_db from ..crud import user router = fastapi.APIRouter(prefix="/user", tags=['Users']) # creating a user @router.post('/', name="create_user", status_code=status.HTTP_201_CREATED, response_model=schemas.ShowUser) async def create_user( request: schemas.User, db: Session = Depends(get_db)) -> models.User: return await user.create(request, db) @router.get('/{id}', name="show_user_id", response_model=schemas.ShowUser) async def get_user(id: int, db: Session = Depends(get_db)): return await user.show_user(id, db)
def ijik_app_setup(self): router = fastapi.APIRouter() self.editor.setup(router) self.api.include_router(router)
from app.models.client import Client from app.models.personal_record import PersonalRecord from app.models.update_client import UpdateClientModel from bson.objectid import ObjectId from ..config import MONGODB_URL CLIENTS_PATH = "/clients" SPECIFIC_CLIENT_PATH = CLIENTS_PATH + "/{id}" CLIENTS_COLLECTION = "clients" DB_NAME = "by_your_side" motor_client = motor.motor_asyncio.AsyncIOMotorClient(MONGODB_URL) my_db = motor_client[DB_NAME] router = fastapi.APIRouter(tags=["clients"]) @router.get(CLIENTS_PATH, response_description="Get clients", response_model=List[Client]) async def get_clients(): cursor = my_db[CLIENTS_COLLECTION].find() return [item async for item in cursor] # PEP 530 -- Asynchronous Comprehensions # return await my_db[CLIENTS_COLLECTION].find().to_list(1000) # <- before @router.get( SPECIFIC_CLIENT_PATH + "/personal_records", response_description="Get personal record of specific client by id",
import fastapi as f from .. import dependencies from .. import models from .. import responses from ...config import lazy_config router_auth = f.APIRouter() @router_auth.get("/token", summary="Validate the current access token.", responses={ **responses.login_error, }, response_model=dict) def access_token(payload: dict = f.Depends( dependencies.dependency_access_token)): """ Returns the payload obtained by getting the `/userinfo` endpoint of the authentication provider with the passed bearer token. Can be used to debug the authentication process. """ return payload @router_auth.get("/user", summary="Get info about the logged in user.", responses={**responses.login_error}, response_model=models.UserOutput)
import pendulum import pandas as pd import fastapi from fastapi import status import spotifycharts as sc from spotifycharts import exceptions downloader = fastapi.APIRouter() @downloader.get('/regions/{name}', status_code=status.HTTP_200_OK) def download_regions(name): try: regions = sc.download_regions(name=name) regions = {'name': name, 'region_names': [*regions]} return regions except exceptions.ArgumentTypeError as exception: raise fastapi.HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exception)) @downloader.get('/dates/{name}/{periodicity}/{region_name}', status_code=status.HTTP_200_OK) def download_regions(name, periodicity, region_name): try:
from typing import Optional, List import fastapi from fastapi import Depends, Security from forsguiden.dependencies import on_database from forsguiden.model import * from forsguiden.db import Db from forsguiden.security import behorighet router = fastapi.APIRouter(tags=["Forssträcka"]) # Forssträcka _redigera = dependencies = [Security(behorighet("redigera:forsstracka"))] @router.get("/forsstracka") async def lista_forsstrackor(db: Db = Depends( on_database)) -> ForsstrackaCollection: return ForsstrackaCollection(forsstracka=db.lista_forsstracka()) @router.get("/forsstracka/{id}") async def hamta_forsstracka_med_id( id: int, db: Db = Depends(on_database)) -> Forsstracka: forsstracka = db.hamta_forsstracka(id) if forsstracka is None: raise fastapi.HTTPException(status_code=404) return forsstracka
import fastapi from fastapi import Depends, status from typing import List, Dict from sqlalchemy.orm import Session from ..models import schemas, models from ..database import get_db from ..crud import blog from ..oauth2 import get_current_user router = fastapi.APIRouter(prefix="/blog", tags=['Blogs']) # get all blogs in db @router.get('/', name='all_blogs', response_model=List[schemas.ShowBlog]) async def blogs_all(db: Session = Depends(get_db), current_user: schemas.User = Depends( get_current_user)) -> List: return blog.get_all(db) # create a blog @router.post('/', name='create_blog', status_code=status.HTTP_201_CREATED) async def create( request: schemas.BlogBase, db: Session = Depends(get_db), current_user: schemas.User = Depends(get_current_user) ) -> models.Blog: return blog.create(request, db)
# IMPORT THIRD PARTY LIBRARIES import fastapi from fastapi_cache.decorator import cache # IMPORT LOCAL LIBRARIES from lorgs import data from lorgs.logger import logger from lorgs.models import warcraftlogs_ranking from lorgs.models.wow_spec import WowSpec from lorgs.routes import api_tasks router = fastapi.APIRouter(tags=["spec_rankings"]) @router.get("/spec_ranking/{spec_slug}/{boss_slug}") @cache() async def get_spec_ranking(spec_slug, boss_slug, difficulty: str = "mythic", metric: str = "", limit: int = 0): if not metric: spec = WowSpec.get(full_name_slug=spec_slug) metric = spec.role.metric spec_ranking = warcraftlogs_ranking.SpecRanking.get_or_create( boss_slug=boss_slug, spec_slug=spec_slug, difficulty=difficulty, metric=metric, )
from mergify_engine import rules from mergify_engine import utils from mergify_engine.dashboard import application as application_mod from mergify_engine.queue import freeze from mergify_engine.queue import merge_train from mergify_engine.rules import get_mergify_config from mergify_engine.web import api from mergify_engine.web import redis from mergify_engine.web.api import security LOG = daiquiri.getLogger(__name__) router = fastapi.APIRouter( tags=["queues"], dependencies=[ fastapi.Depends(security.require_authentication), ], ) @pydantic.dataclasses.dataclass class Branch: name: github_types.GitHubRefType = dataclasses.field( metadata={"description": "The name of the branch"} ) @pydantic.dataclasses.dataclass class SpeculativeCheckPullRequest: in_place: bool = dataclasses.field( metadata={"description": "Whether the pull request has been checked in-place"}
from typing import Optional, List import fastapi from fastapi import Depends, Header from fastapi.param_functions import Security from forsguiden.dependencies import on_database from forsguiden.model import * from forsguiden.db import Db from forsguiden.security import behorighet router = fastapi.APIRouter(tags=["Län"]) _redigera = dependencies=[Security(behorighet("redigera:lan"))] @router.get("/lan") async def lista_alla_lan(db: Db = Depends(on_database)) -> LanCollection: return LanCollection(lan=db.lista_lan()) @router.get("/lan/{id}") async def hamta_lan_med_id(id: int, db: Db = Depends(on_database)) -> Lan: lan = db.hamta_lan(id) if lan is None: raise fastapi.HTTPException(status_code=404) return lan @router.post("/lan", dependencies=_redigera) async def skapa_nytt_lan(lan: Lan, db: Db = Depends(on_database)) -> Lan: x: Optional[Lan] = db.hamta_lan(lan.id)
import fastapi from fastapi import Depends, status from fastapi.responses import HTMLResponse, RedirectResponse from jose import jwt from starlette.requests import Request from app.auth.base import check_encrypted_password from app.db.crud import get_user_by_login from app.db.schemas import UserReturnSchema from app.config import settings from app.models.base import LoginForm from . import templates router = fastapi.APIRouter(prefix='/login') @router.get('/') async def login_get(request: Request): return templates.TemplateResponse('login.html', {'request': request}) @router.post('/', response_class=HTMLResponse) async def login_post( request: Request, user_login: LoginForm = Depends(LoginForm.as_form) ): database = request.app.state.db user = await get_user_by_login(database, user_login.login) if not user: return templates.TemplateResponse(
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import fastapi from starlette import responses from mergify_engine import github_types from mergify_engine.web import api router = fastapi.APIRouter( tags=["badges"], ) def _get_badge_url( owner: github_types.GitHubLogin, repo: github_types.GitHubRepositoryName, ext: str, style: str, ) -> responses.RedirectResponse: return responses.RedirectResponse( url=f"https://img.shields.io/endpoint.{ext}?url=https://dashboard.mergify.com/badges/{owner}/{repo}&style={style}", status_code=302, )
from typing import Optional import fastapi import httpx from models.location import Location from models.umbrella_status import UmbrellaStatus from services import live_weather_service router = fastapi.APIRouter() @router.get('/api/umbrella', response_model=UmbrellaStatus) async def do_i_need_an_umbrella(location: Location = fastapi.Depends()): data = await live_weather_service.get_live_report(location) weather = data.get('weather', {}) category = weather.get('category', 'UNKNOWN') forecast = data.get('forecast', {}) temp = forecast.get('temp', 0.0) bring = category.lower().strip() in {'rain', 'mist'} return UmbrellaStatus(bring_umbrella=bring, temp=temp, weather=category)
from fastapi.responses import JSONResponse from fastapi.encoders import jsonable_encoder import motor.motor_asyncio import fastapi from app.models.personal_record import PersonalRecord from ..config import MONGODB_URL PERSONAL_RECORDS_PATH = "/personal_records" SPECIFIC_PERSONAL_RECORD_PATH = PERSONAL_RECORDS_PATH + "/{id}" PERSONAL_RECORD_COLLECTION = "personal_records" DB_NAME = "by_your_side" motor_client = motor.motor_asyncio.AsyncIOMotorClient(MONGODB_URL) my_db = motor_client[DB_NAME] router = fastapi.APIRouter(tags=[PERSONAL_RECORD_COLLECTION]) @router.get(PERSONAL_RECORDS_PATH, response_description="Get " + PERSONAL_RECORD_COLLECTION, response_model=List[PersonalRecord]) async def get_personal_records(): cursor = my_db[PERSONAL_RECORD_COLLECTION].find() return [item async for item in cursor] # PEP 530 -- Asynchronous Comprehensions # return await my_db[PERSONAL_RECORD_COLLECTION].find().to_list(1000) # <- before @router.post(PERSONAL_RECORDS_PATH, response_description="Add new personal record", response_model=PersonalRecord)