Vor etwa drei Wochen kam eine der am meisten erwarteten Funktionen von FastAPI heraus. Zumindest wenn es um Pydantic Models FastAPI geht.

Ja, ich spreche von der Möglichkeit, Pydantic-Modelle zum Zuordnen Ihrer Abfrageparameter zu verwenden.

Also werde ich in diesem Beitrag versuchen, Ihnen alles zu zeigen, was Sie tun? kann und ? Kann ich zu diesem Thema nichts tun?:

? Abfrageparameter zuordnen

Um mit der Zuordnung Ihrer Abfrageparameter mit Pydantic zu beginnen, müssen Sie zunächst sicherstellen, dass Sie FastAPI Version 0.115.0 verwenden.

Danach können Sie jederzeit in den FastAPI-Dokumenten nachsehen, was bereits verfügbar ist. Sebastián und die Teammitglieder leisten wirklich sehr gute Arbeit, um die Dokumentation aktuell und informativ zu halten ✨.

? Ein bisschen Geschichte

Beginnen wir mit einigen Beispielen, wie wir Abfrageparameter in FastAPI zugeordnet haben. ?

Der einfachste Weg wäre:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def search(
    limit: int | None = 10,
    skip: int | None = 1,
    filter: str | None = None
):
    return {
        "limit": limit,
        "skip": skip,
        "filter": filter
    }

Und jetzt können Sie einfach anrufen:

GET http://localhost:8000/?limit=42&skip=12&filter=banana

Aber wenn wir feststellen würden, dass diese Abfrageparameter in anderen Routen verwendet würden, würden wir sie mit etwas wie Folgendem isolieren:

from typing import Any
from fastapi import Depends, FastAPI, Query

app = FastAPI()

async def pagination_query_string(
    limit: int | None = Query(10, ge=5, le=100),
    skip: int | None = Query(1, ge=1),
    filter: str | None = Query(None)
) -> dict[str, Any]:
    return {
        "limit": limit,
        "skip": skip,
        "filter": filter
    }

@app.get("/")
async def search(q: dict[str, Any] = Depends(pagination_query_string)):
    return q

Oder da wir Pydantic verwenden, um unsere Modelle abzubilden, würden wir mit nur einer kleinen Umgestaltung Folgendes erhalten:

from fastapi import Depends, FastAPI, Query
from pydantic import BaseModel

app = FastAPI()

class PaginationQueryString(BaseModel):
    limit: int | None = 10
    skip: int | None = 1
    filter: str | None = None

async def pagination_query_string(
    limit: int | None = Query(10, ge=5, le=100),
    skip: int | None = Query(1, ge=1),
    filter: str | None = Query(None)
) -> PaginationQueryString:
    return PaginationQueryString(
        limit=limit,
        skip=skip,
        filter=filter
    )

@app.get("/")
async def search(q: PaginationQueryString = Depends(pagination_query_string)):
    return q

⌨️ Verwenden von Pydantic zum Zuordnen der Abfragezeichenfolgen

Wenn wir nun unsere Abfragezeichenfolge erhalten möchten, müssen wir keine Funktion erstellen und sie dann als Abhängigkeit hinzufügen. Wir können FastAPI einfach mitteilen, dass wir ein Objekt vom Typ PaginationQueryString wollen und dass es sich um eine Abfragezeichenfolge handelt:

from typing import Annotated
from fastapi import FastAPI, Query
from pydantic import BaseModel

app = FastAPI()

class PaginationQueryString(BaseModel):
    limit: int | None = 10
    skip: int | None = 1
    filter: str | None = None

@app.get("/")
async def search(q: Annotated[PaginationQueryString, Query()]):
    return q

Einfach, oder? ?

⚠️ Welche Einschränkungen gibt es?

Zumindest in Version 0.115.0 funktioniert es nicht sehr gut mit verschachtelten Modellen.

Lass uns etwas versuchen wie:

from typing import Annotated
from fastapi import FastAPI, Query
from pydantic import BaseModel

app = FastAPI()

class Filter(BaseModel):
    name: str | None = None
    age: int | None = None
    nickname: str | None = None

class PaginationQueryString(BaseModel):
    limit: int | None = 10
    skip: int | None = 1
    filter: Filter | None = None

@app.get("/")
async def search(q: Annotated[PaginationQueryString, Query()]):
    return q

Wenn wir es wie zuvor nennen:

GET http://localhost:8000/?limit=42&skip=12&filter=chocolate

Wir erhalten eine Fehlermeldung, die uns mitteilt, dass der Filter ein Objekt ist:

{
    "detail": [
        {
            "type": "model_attributes_type",
            "loc": [
                "query",
                "filter"
            ],
            "msg": "Input should be a valid dictionary or object to extract fields from",
            "input": "chocolate"
        }
    ]
}

Zumindest im Moment ist es absolut richtig! Wir haben unseren Filter so geändert, dass er ein Pydantic-Modell und kein String ist. Aber wenn wir versuchen, es in ein Wörterbuch umzuwandeln:

http://localhost:8000/?limit=42&skip=12&filter={"name": "Rafael", "age": 38, "nickname": "ceb10n"}

FastAPI teilt uns mit, dass der Filter ein gültiges Wörterbuch sein muss?:

{
    "detail": [
        {
            "type": "model_attributes_type",
            "loc": [
                "query",
                "filter"
            ],
            "msg": "Input should be a valid dictionary or object to extract fields from",
            "input": "{\"name\": \"Rafael\", \"age\": 38, \"nickname\": \"ceb10n\"}"
        }
    ]
}

Dies geschieht, weil FastAPI auf Starlettes QueryParams angewiesen ist, das FastAPI einen String und kein Diktat übergibt. Und zumindest in Version 0.115.0 erhalten Sie eine Fehlermeldung.

⁉️ Wann verwende ich also Pydantic-Modelle mit meinen Abfrageparametern?

Es ist ganz einfach:

✅ Sie haben einfache Abfragezeichenfolgen, die keine aufwändigen, ausgefallenen verschachtelten Objekte benötigen? Benutze es! ?

❌ Sie haben eine komplexe verschachtelte Abfragezeichenfolge erstellt? Benutzen Sie es noch nicht? (Und vielleicht sollten Sie versuchen, Ihre Abfragezeichenfolgen zu überdenken. ? Je einfacher, desto besser?)