[PYTHON] Die Geschichte, dass FastAPI die Vormachtstellung übernehmen könnte

Hallo, guten Abend, guten Morgen. Dies ist Shimabukuro von K.S. Rogers.

Ich schrieb einen Artikel wie Bisher war dies die nächste Vormachtstellung von Pythons Webframework, aber danach verbrachte ich eine Weile als Ingenieur außerhalb von Python. Übrigens ist ein Framework namens FastAPI erschienen!

Um ehrlich zu sein, bin ich zu spät, weil ich nicht weiß, welche Nummer ich brauen soll, aber ich möchte sie vorstellen.

Funktionen von FastAPI

Laut der offiziellen Top-Seite,

1. Hohe Geschwindigkeit - so schnell wie NodeJS und Go
2. Schnelles Schreiben von Code - doppelt und dreifach!
3. Reduzierte Fehler um ca. 40% reduziert!
4. Intuitiv-einfach zu debuggen
5. Einfach-einfach zu bedienen. Einfach das Dokument zu lesen!
6. Kurzlose Vervielfältigung. Durch Parameterdeklaration können mehrere Funktionen aufgerufen werden
7. Robust - Es ist wirklich einfach, weil es automatisch generiert wird
8. Standardkompatibel mit OpenAPI Standard (kompatibel mit Swagger)

Es heißt, aber es ist kompatibel, weil es unten der OpenAPI-Standard ist (es ist kompatibel mit Swagger). Das ist zu groß. FastAPI, in der Tat kann Swagger (Dokument) automatisch generiert werden!

Automatische Generierung dokumentieren

Nachdem ich fastapi und uvicorn mit pip installiert habe, werde ich es sofort anfassen. Standard-Pip hat übrigens keine Umgebungsisolation, daher wird empfohlen, pipenv zu verwenden.

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hello World"}

Nachdem Sie das Obige mit main.py erstellt haben, starten Sie es mit uvicorn main: app --reload. Wenn Sie "http: //127.0.0.1: 8000 / docs" überprüfen ...

Ja! Nett! !! Wenn Sie versuchen, "Pfadparameter" einzustellen ...

Path parameters

@app.get("/{name}")
async def root():
    return {"message": "Hello " + name}

Es wird automatisch wiedergegeben. Es ist am stärksten, dass Dokumente automatisch erstellt werden. Dies ist eine Funktion, die für uns zu bequem ist, da wir Dokumenten besondere Bedeutung beimessen.

Query Parameters

@app.get("/")
async def read_item(name: str = ""):
    return {"message": "Hello " + name}

Requests Modell verwenden.

from fastapi import FastAPI
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str = None

app = FastAPI()


@app.post("/items/")
async def create_item(item: Item):
    return item

Darüber hinaus kann die Validierung für Eigenschaften in der Modellklasse angegeben werden, sodass die Handhabung sehr gut ist. Dies ist eine ähnliche Struktur wie das Django-Modell.

class Item(BaseModel):
    name: str = Field(None, min_length=2, max_length=5)
    description: str = Field(None, max_length=100)

CRUD (Crate, Read, Update, Delete) Lassen Sie uns grob das grundlegende CRUD schreiben. Da es sich um einen Teilauszug handelt, lesen Sie bitte den Link zum Schreiben.

https://github.com/shuto-S/sample-fast-api

DB Connection & Migration Verwenden Sie "Datenbanken" und "SQLalchemie", um eine Verbindung zur Datenbank herzustellen und auf diese zu migrieren. Dieses Mal verwenden wir für die Datenbank "SQLite", das einfach zu handhaben ist.

Schreiben Sie schnell um die Verbindung,

import databases
import sqlalchemy

DATABASE_URL = "sqlite:///./db.sqlite3"

database = databases.Database(DATABASE_URL)
engine = sqlalchemy.create_engine(DATABASE_URL, echo=False)
metadata = sqlalchemy.MetaData()

Schemas Beschreiben Sie die Tabellendefinition und führen Sie dieselbe Datei aus.

import sqlalchemy
from db import metadata, engine


items = sqlalchemy.Table(
    "items",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("name", sqlalchemy.String),
    sqlalchemy.Column("description", sqlalchemy.String),
)

metadata.create_all(engine)

Main main.py wurde ebenfalls repariert

from fastapi import FastAPI
from db import database
from starlette.requests import Request
from routers import items

app = FastAPI()

@app.on_event("startup")
async def startup():
    #DB-Verbindungsstart
    await database.connect()

@app.on_event("shutdown")
async def shutdown():
    #Trennung der DB-Verbindung
    await database.disconnect()

#Router registrieren
app.include_router(items.router)

#Betten Sie eine DB-Verbindung in Middleware ein (damit diese mit dem Router abgerufen werden kann).
@app.middleware("http")
async def db_session_middleware(request: Request, call_next):
    request.state.connection = database
    response = await call_next(request)
    return response

Routers "Router" ist auch in Dateien unterteilt, so dass es für jeden Endpunkt beschrieben werden kann.

from fastapi import APIRouter, Depends, HTTPException
from typing import List
from databases import Database
from starlette.status import HTTP_204_NO_CONTENT

from utils import get_db_connection
from schemas import items
from models.item import ItemModel


router = APIRouter()

@router.get("/items", tags=["items"], response_model=List[ItemModel])
async def list_item(database: Database = Depends(get_db_connection)):
    query = items.select()
    return await database.fetch_all(query)

@router.post("/items", tags=["items"], response_model=ItemModel)
async def create_item(data: ItemModel, database: Database = Depends(get_db_connection)):
    query = items.insert()
    await database.execute(query, data.dict())
    return {**data.dict()}

@router.patch("/items/{item_id}", tags=["items"], response_model=ItemModel)
async def update_item(item_id: int, data: ItemModel, database: Database = Depends(get_db_connection)):
    query = items.update().where(items.columns.id==item_id)
    ret = await database.execute(query, data.dict())
    if not ret:
        raise HTTPException(status_code=404, detail="Not Found")
    return {**data.dict()}

@router.delete("/items/{item_id}", tags=["items"], status_code=HTTP_204_NO_CONTENT)
async def delete_item(item_id: int, database: Database = Depends(get_db_connection)):
    query = items.delete().where(items.columns.id==item_id)
    ret = await database.execute(query)
    if not ret:
        raise HTTPException(status_code=404, detail="Not Found")

Zusammenfassung

Wie ist das? Ist die automatische Dokumentenerstellung nicht eine ziemlich attraktive Funktion? Ich denke, Responder ist auch ein ziemlich gutes Framework, aber ich fand, dass FastAPI weniger eigenartig und einfacher zu schreiben ist.

Nachtrag

Übrigens veröffentlichen wir neben unserem Unternehmen und unserer Technologie auch Unternehmensblogs. Wenn Sie also interessiert sind, tun Sie dies bitte. https://www.wantedly.com/companies/ks-rogers