Présentation de FastAPI

Qui est FastAPI?

FastAPI est un cadre pour créer des serveurs d'API HTTP concis et assez rapides avec validation, sérialisation et asynchronie intégrées,
comme on dit, prêts à l'emploi . Il se tient sur les épaules des deux autres frameworks: le travail avec le web dans FastAPI a engagé Starlette , et est responsable de la validation Pydantic .

La moissonneuse s'est avérée être légère, pas surchargée et plus que suffisante en fonctionnalité.

Minimum requis

FastAPI nécessite un serveur ASGI pour fonctionner, par défaut la documentation propose uvcorn , basé sur uvloop , cependant FastAPI peut également fonctionner avec d'autres serveurs, par exemple, c hypercorn

Voici mes dépendances:

[packages]
fastapi = "*"
uvicorn = "*"

Et c'est plus que suffisant.

Pour les lecteurs plus approfondis, à la fin de l'article, il y a un lien vers le référentiel avec un bot, où vous pouvez consulter les dépendances pour le développement et les tests.

Eh bien, nous avons pipenv install -dcommencé!

Construisez l'API

Il convient de noter que l'approche de conception des gestionnaires dans FastAPI est extrêmement similaire à celle de Flask, Bottle et des milliers d'entre eux. Apparemment, des millions de mouches ne peuvent pas se tromper.

Dans la toute première approximation, mon itinéraire de traitement des versions ressemblait à ceci:

from fastapi import FastAPI
from starlette import status
from starlette.responses import Response

from models import Body

app = FastAPI()  # noqa: pylint=invalid-name

@app.post("/release/")
async def release(*,
                  body: Body,
                  chat_id: str = None):
    await proceed_release(body, chat_id)
    return Response(status_code=status.HTTP_200_OK)

, , , FastAPI Body, chat_id URL params

models.py:

from datetime import datetime
from enum import Enum

from pydantic import BaseModel, HttpUrl

class Author(BaseModel):
    login: str
    avatar_url: HttpUrl

class Release(BaseModel):
    name: str
    draft: bool = False
    tag_name: str
    html_url: HttpUrl
    author: Author
    created_at: datetime
    published_at: datetime = None
    body: str

class Body(BaseModel):
    action: str
    release: Release

, Pydantic. , , , :

class Body(BaseModel):
    action: str
    releases: List[Release]

FastAPI . . , - — .

Pydantic , HttpUrl, URL , FastAPI . Pydantic

.

FastAPI , , , ,
— !

FastAPI , :

from fastapi import FastAPI, HTTPException, Depends
from starlette import status
from starlette.requests import Request

import settings
from router import api_router
from utils import check_auth

docs_kwargs = {}  # noqa: pylint=invalid-name
if settings.ENVIRONMENT == 'production':
    docs_kwargs = dict(docs_url=None, redoc_url=None)  # noqa: pylint=invalid-name

app = FastAPI(**docs_kwargs)  # noqa: pylint=invalid-name

async def check_auth_middleware(request: Request):
    if settings.ENVIRONMENT in ('production', 'test'):
        body = await request.body()
        if not check_auth(body, request.headers.get('X-Hub-Signature', '')):
            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)

app.include_router(api_router, dependencies=[Depends(check_auth_middleware)])

, request.body — , . FastAPI( Starlette) , .

, FastAPI — OpenAPI Swagger/ReDoc , _/docs _/redoc .

. .

, :

from fastapi import APIRouter
from starlette import status
from starlette.responses import Response

from bot import proceed_release
from models import Body, Actions

api_router = APIRouter()  # noqa: pylint=invalid-name

@api_router.post("/release/")
async def release(*,
                  body: Body,
                  chat_id: str = None,
                  release_only: bool = False):

    if (body.release.draft and not release_only) \
            or body.action == Actions.released:
        res = await proceed_release(body, chat_id)
        return Response(status_code=res.status_code)
    return Response(status_code=status.HTTP_200_OK)

, HTTP API- , .

FastAPI — , , , . , (, , 2020- ?
), .

, , , , , FastAPI.

, , . — , , , , .

, , github actions

Le rapport est terminé, merci à tous!