Wie werden Datei und JSON-Text gleichzeitig in einer FastAPI-POST-Anfrage verarbeitet?

Wie füge ich einer FastAPI-POST-Anfrage sowohl eine Datei als auch einen JSON-Text hinzu?

FastAPI ist ein modernes, schnelles (leistungsstarkes) Web-Framework zum Erstellen von APIs. Es basiert auf Python 3.6 und bietet leistungsstarke Tools und Funktionen, um die Entwicklung von APIs einfacher und effizienter zu gestalten. Eines der Hauptmerkmale von FastAPI ist die Unterstützung für die Verarbeitung einer Vielzahl von Anforderungstypen, einschließlich POST-Anfragen mit Dateien und JSON-Bodys.

In diesem Artikel erfahren Sie, wie Sie sowohl Dateien als auch JSON-Bodys verarbeiten eine FastAPI POST-Anfrage. Wir werden verschiedene Methoden behandeln und Codebeispiele bereitstellen, um das Verständnis und die Implementierung zu vereinfachen. Fangen wir an!

Verarbeiten von Dateien und JSON-Body in einer FastAPI-POST-Anfrage

Um Dateien und JSON-Body in einer FastAPI-POST-Anfrage zu verarbeiten, können Sie die folgenden Methoden verwenden:

Verwendung von Formular und Datei: Mit dieser Methode können Sie mehrere Formularparameter in einer Pfadoperation deklarieren. Sie können jedoch nicht auch Body-Felder deklarieren, die Sie als JSON erwarten, da der Body der Anfrage mit application/x-www-form-urlencoded statt mit application/json codiert wird (wenn das Formular Dateien enthält, wird es als Multipart codiert). /form-data).

Verwendung von Pydantic-Modellen und Abhängigkeiten: Sie können Pydantic-Modelle verwenden, um den Endpunkt darüber zu informieren, dass die parametrisierte Variable von der Basisklasse abhängt. Sie können Abfrageparameter direkt im Endpunkt definieren, wie in dieser Antwort gezeigt.

Übergabe von Körperdaten als einzelner Parameter: Eine andere Möglichkeit besteht darin, die Körperdaten als einzelnen Parameter (vom Typ Form) in der Form zu übergeben eine JSON-Zeichenfolge. Zu diesem Zweck müssten Sie auf der Serverseite eine Abhängigkeitsfunktion erstellen.

Verwenden einer benutzerdefinierten Klasse mit Klassenmethode: Sie können auch eine benutzerdefinierte Klasse mit einer Klassenmethode integrieren, die zum Umwandeln einer bestimmten JSON-Zeichenfolge in eine verwendet wird Python-Wörterbuch, das dann zur Validierung anhand des Pydantic-Modells verwendet wird.

Verwendung von Base64-codierten Dateien: Bei dieser Methode werden die Dateibytes in a konvertiert Erstellen Sie eine Zeichenfolge im Base64-Format und fügen Sie sie dem JSON-Objekt hinzu, zusammen mit anderen Daten, die Sie möglicherweise an den Server senden möchten. Dieser Ansatz wird jedoch aufgrund der größeren Dateigröße und der zusätzlichen Ressourcen, die für die Kodierung und Dekodierung erforderlich sind, nicht unbedingt empfohlen.

Codebeispiele

Lassen Sie uns einige Codebeispiele untersuchen, um die Handhabung zu veranschaulichen Datei und JSON-Body in einer FastAPI-POST-Anfrage mit verschiedenen Methoden:

Methode unter Verwendung von Formular und Datei:

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})

Methode unter Verwendung pydantischer Modelle und Abhängigkeiten:

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})

Methode unter Verwendung einer benutzerdefinierten Klasse mit 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})

Mit diesen Methoden haben Sie die Flexibilität, Dateien und JSON-Body in einer FastAPI-POST-Anfrage entsprechend Ihren spezifischen Anforderungen zu verarbeiten. Unabhängig davon, ob Sie Daten mithilfe eines Pydantic-Modells validieren oder einfach einen JSON-String erhalten müssen, gibt es eine geeignete Lösung.

Fazit

In diesem Artikel haben wir verschiedene Methoden zur Verarbeitung beider Dateien untersucht und JSON-Body in einer FastAPI-POST-Anfrage. Durch die Bereitstellung von Codebeispielen und detaillierten Erklärungen haben wir uns zum Ziel gesetzt, das Verständnis und die Implementierung dieser Methoden so einfach wie möglich zu gestalten. Während Sie Ihre APIs entwickeln, können Sie basierend auf Ihren Anforderungen und Vorlieben die am besten geeignete Methode auswählen.

Wenn

Das obige ist der detaillierte Inhalt vonWie werden Datei und JSON-Text gleichzeitig in einer FastAPI-POST-Anfrage verarbeitet?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!