Memperkenalkan FastAPI

Siapakah FastAPI?

FastAPI adalah kerangka kerja untuk membuat server HTTP API yang ringkas dan cukup cepat dengan validasi, serialisasi, dan asinkronasi bawaan,
seperti yang mereka katakan, di luar kotak. Dia berdiri di pundak dua kerangka kerja lainnya: pekerjaan dengan web di FastAPI melibatkan Starlette , dan bertanggung jawab atas validasi Pydantic .

Mesin pemanennya ternyata ringan, tidak kelebihan beban, dan fungsionalitasnya lebih dari cukup.

Persyaratan minimum

FastAPI membutuhkan server ASGI untuk bekerja, secara default dokumentasi menawarkan uvcorn , berdasarkan uvloop , namun FastAPI juga dapat bekerja dengan server lain, misalnya, c hypercorn

Inilah dependensi saya:

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

Dan ini lebih dari cukup.

Untuk pembaca yang lebih teliti, di akhir artikel ada tautan ke repositori dengan bot, tempat Anda bisa melihat dependensi untuk pengembangan dan pengujian.

Yah, kita pipenv install -dmulai!

Bangun API

Perlu dicatat bahwa pendekatan untuk merancang penangan di FastAPI sangat mirip dengan yang ada di Flask, Bottle, dan ribuan dari mereka. Rupanya, jutaan lalat tidak mungkin salah.

Pada perkiraan pertama, rute pemrosesan rilis saya terlihat seperti ini:

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

Laporan selesai, terima kasih semuanya!