FastAPI: Cara menggunakan Pydantic untuk mengisytiharkan Parameter Pertanyaan

Ia keluar kira-kira tiga minggu lalu salah satu ciri FastAPI yang paling dijangka. Sekurang-kurangnya apabila kita bercakap tentang Pydantic Models FastAPI.

Ya, saya bercakap tentang keupayaan untuk menggunakan Model Pydantic untuk memetakan parameter pertanyaan anda.

Jadi dalam siaran ini, saya akan cuba tunjukkan kepada anda semua? boleh dan ? tak boleh buat pasal subjek ni ?:

? Memetakan Parameter Pertanyaan

Perkara pertama yang anda perlu lakukan untuk mula memetakan parameter pertanyaan anda dengan Pydantic ialah memastikan anda menggunakan FastAPI versi 0.115.0.

Selepas ini, anda sentiasa boleh pergi ke dokumen FastAPI untuk menyemak perkara yang sudah tersedia. Sebastián dan ahli pasukan melakukan kerja yang sangat baik untuk memastikan dokumen kerja dikemas kini dan bermaklumat ✨.

? Sedikit Sejarah

Mari kita mulakan dengan beberapa contoh tentang cara kita pernah memetakan Parameter Pertanyaan dalam FastAPI. ?

Cara paling mudah untuk melakukannya ialah:

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
    }

Dan kini anda boleh menghubungi:

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

Tetapi jika kami mengenal pasti bahawa Parameter Pertanyaan ini akan digunakan dalam laluan lain, kami akan mengasingkannya dengan sesuatu seperti:

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

Atau kerana kami menggunakan Pydantic untuk memetakan model kami, dengan hanya sedikit pemfaktoran semula kami akan mendapat:

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

⌨️ Menggunakan Pydantic untuk memetakan Rentetan Pertanyaan

Sekarang, jika kami ingin mendapatkan rentetan pertanyaan kami, kami tidak perlu mencipta fungsi dan kemudian menambahkannya sebagai kebergantungan. Kami hanya boleh memberitahu FastAPI bahawa kami mahukan objek jenis PaginationQueryString dan ia adalah rentetan pertanyaan:

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

Mudah, bukan? ?

⚠️ Apakah hadnya?

Sekurang-kurangnya pada versi 0.115.0, ia tidak berfungsi dengan baik dengan model bersarang.

Jom cuba sesuatu seperti:

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

Kalau kita panggil macam dulu:

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

Kami akan mendapat ralat memberitahu kami bahawa penapis ialah objek:

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

Sekurang-kurangnya sekarang, ia betul-betul betul! Kami menukar penapis kami menjadi model Pydantic, bukan rentetan. Tetapi jika kita cuba menukarnya kepada kamus:

http://localhost:8000/?limit=42&skip=12&filter={%22name%22:%20%22Rafael%22,%20%22age%22:%2038,%20%22nickname%22:%20%22ceb10n%22}

FastAPI akan memberitahu kami bahawa penapis perlu menjadi kamus yang sah ?:

{
    "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\"}"
        }
    ]
}

Ini berlaku kerana FastAPI akan bergantung pada QueryParams Starlette, yang akan memberikan rentetan kepada FastAPI, bukan dict. Dan sekurang-kurangnya dalam versi 0.115.0, ini akan memberi anda ralat.

⁉️ Jadi, bilakah saya menggunakan model Pydantic dengan Parameter Pertanyaan saya?

Ia agak mudah:

✅ Anda mempunyai rentetan pertanyaan mudah yang tidak memerlukan objek bersarang mewah yang rumit? Gunakannya! ?

❌ Anda mencipta rentetan pertanyaan bersarang yang kompleks? Belum guna lagi?. (Dan mungkin anda perlu cuba memikirkan semula rentetan pertanyaan anda. ? Lebih mudah, lebih baik ?)

Atas ialah kandungan terperinci FastAPI: Cara menggunakan Pydantic untuk mengisytiharkan Parameter Pertanyaan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!