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)
