Comment gérer simultanément le fichier et le corps JSON dans une requête FastAPI POST ?

Comment ajouter à la fois un fichier et un corps JSON dans une requête FastAPI POST ?

FastAPI est un framework Web moderne et rapide (hautes performances) pour créer des API. Il est basé sur Python 3.6 et fournit un ensemble puissant d'outils et de fonctionnalités pour rendre le développement d'API plus facile et plus efficace. L'une des fonctionnalités clés de FastAPI est sa prise en charge de la gestion d'un large éventail de types de requêtes, y compris les requêtes POST avec des fichiers et des corps JSON.

Dans cet article, nous explorerons comment gérer à la fois les fichiers et les corps JSON dans une requête FastAPI POST. Nous couvrirons différentes méthodes et fournirons des exemples de code pour simplifier la compréhension et la mise en œuvre. Commençons !

Gestion du fichier et du corps JSON dans une requête POST FastAPI

Pour gérer le fichier et le corps JSON dans une requête POST FastAPI, vous pouvez utiliser les méthodes suivantes :

Utilisation de Form et File : Cette méthode vous permet de déclarer plusieurs paramètres Form dans une opération de chemin. Cependant, vous ne pouvez pas également déclarer les champs Body que vous comptez recevoir au format JSON, car le corps de la requête sera codé à l'aide de application/x-www-form-urlencoded au lieu de application/json (lorsque le formulaire inclut des fichiers, il est codé en plusieurs parties). /form-data).

Utilisation de modèles et de dépendances Pydantic : vous pouvez utiliser des modèles Pydantic pour informer le point de terminaison que la variable paramétrée dépend de la classe de base. Vous pouvez définir des paramètres de requête directement dans le point de terminaison, comme démontré dans cette réponse.

Transmission des données corporelles en tant que paramètre unique : une autre option consiste à transmettre les données corporelles en tant que paramètre unique (de type Form) sous la forme de une chaîne JSON. À cette fin, vous devrez créer une fonction de dépendance côté serveur.

Utiliser une classe personnalisée avec Classmethod : vous pouvez également incorporer une classe personnalisée avec une méthode de classe utilisée pour transformer une chaîne JSON donnée en une Dictionnaire Python, qui est ensuite utilisé pour la validation par rapport au modèle Pydantic.

Utilisation de fichiers codés en Base64 : cette méthode consiste à convertir les octets du fichier en un chaîne au format base64 et en l'ajoutant à l'objet JSON, ainsi que d'autres données que vous souhaiterez peut-être envoyer au serveur. Cependant, cette approche n'est pas fortement recommandée en raison de la taille accrue du fichier et des ressources supplémentaires requises pour l'encodage et le décodage.

Exemples de code

Explorons quelques exemples de code pour montrer comment gérer fichier et corps JSON dans une requête FastAPI POST en utilisant différentes méthodes :

Méthode utilisant le formulaire et Fichier :

from fastapi import Form, File, UploadFile, FastAPI
from typing import List
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates

app = FastAPI()
templates = Jinja2Templates(directory="templates")

@app.post("/submit")
def submit(
    name: str = Form(...),
    point: float = Form(...),
    is_accepted: bool = Form(...),
    files: List[UploadFile] = File(...),
):
    return {
        "JSON Payload": {"name": name, "point": point, "is_accepted": is_accepted},
        "Filenames": [file.filename for file in files],
    }

@app.get("/", response_class=HTMLResponse)
def main(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})

Méthode utilisant des modèles et des dépendances Pydantic :

from fastapi import Form, File, UploadFile, Request, FastAPI, Depends
from typing import List, Optional
from fastapi.responses import HTMLResponse
from pydantic import BaseModel
from fastapi.templating import Jinja2Templates

app = FastAPI()
templates = Jinja2Templates(directory="templates")

class Base(BaseModel):
    name: str
    point: Optional[float] = None
    is_accepted: Optional[bool] = False


def checker(data: str = Form(...)):
    try:
        return Base.model_validate_json(data)
    except ValidationError as e:
        raise HTTPException(
            detail=jsonable_encoder(e.errors()),
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
        )


@app.post("/submit")
def submit(base: Base = Depends(checker), files: List[UploadFile] = File(...)):
    return {
        "JSON Payload": base,
        "Filenames": [file.filename for file in files],
    }

@app.get("/", response_class=HTMLResponse)
def main(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})

Méthode utilisant une classe personnalisée avec Classmethod :

from fastapi import Form, File, UploadFile, FastAPI
from typing import List
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates

app = FastAPI()
templates = Jinja2Templates(directory="templates")

@app.post("/submit")
def submit(
    name: str = Form(...),
    point: float = Form(...),
    is_accepted: bool = Form(...),
    files: List[UploadFile] = File(...),
):
    return {
        "JSON Payload": {"name": name, "point": point, "is_accepted": is_accepted},
        "Filenames": [file.filename for file in files],
    }

@app.get("/", response_class=HTMLResponse)
def main(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})

Avec ces méthodes, vous avez la flexibilité de gérer le fichier et le corps JSON dans une requête FastAPI POST en fonction de vos besoins spécifiques. Que vous ayez besoin de valider des données à l'aide d'un modèle Pydantic ou simplement de recevoir une chaîne JSON, il existe une solution adaptée disponible.

Conclusion

Dans cet article, nous avons exploré différentes méthodes pour gérer à la fois les fichiers et le corps JSON dans une requête FastAPI POST. En fournissant des exemples de code et des explications détaillées, nous avons cherché à rendre la compréhension et la mise en œuvre de ces méthodes aussi simples que possible. Au fur et à mesure que vous développez vos API, vous pouvez choisir la méthode la plus appropriée en fonction de vos exigences et préférences.

If

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!