Sie können den Typ der Response deklarieren, indem Sie den Rückgabetyp der Pfadoperation annotieren.
Hierbei können Sie Typannotationen genauso verwenden, wie Sie es bei Werten von Funktions-Parametern machen; verwenden Sie Pydantic-Modelle, Listen, Dicts und skalare Werte wie Nummern, Booleans, usw.
Wenn die Daten ungültig sind (Sie haben z. B. ein Feld vergessen), bedeutet das, Ihr Anwendungscode ist fehlerhaft, er gibt nicht zurück, was er sollte, und daher wird ein Server-Error ausgegeben, statt falscher Daten. So können Sie und ihre Clients sicher sein, dass diese die erwarteten Daten, in der richtigen Form erhalten.
In der OpenAPI Pfadoperation ein JSON-Schema für die Response hinzuzufügen.
Dieses wird von der automatischen Dokumentation verwendet.
Es wird auch von automatisch Client-Code-generierenden Tools verwendet.
Aber am wichtigsten:
Es wird die Ausgabedaten auf das limitieren und filtern, was im Rückgabetyp definiert ist.
Das ist insbesondere für die Sicherheit wichtig, mehr dazu unten.
Es gibt Fälle, da möchten oder müssen Sie Daten zurückgeben, die nicht genau dem entsprechen, was der Typ deklariert.
Zum Beispiel könnten Sie ein Dict zurückgeben wollen, oder ein Datenbank-Objekt, aber es als Pydantic-Modell deklarieren. Auf diese Weise übernimmt das Pydantic-Modell alle Datendokumentation, -validierung, usw. für das Objekt, welches Sie zurückgeben (z. B. ein Dict oder ein Datenbank-Objekt).
Würden Sie eine hierfür eine Rückgabetyp-Annotation verwenden, dann würden Tools und Editoren (korrekterweise) Fehler ausgeben, die Ihnen sagen, dass Ihre Funktion einen Typ zurückgibt (z. B. ein Dict), der sich unterscheidet von dem, was Sie deklariert haben (z. B. ein Pydantic-Modell).
In solchen Fällen können Sie statt des Rückgabetyps den Pfadoperation-Dekorator-Parameter response_model verwenden.
Sie können response_model in jeder möglichen Pfadoperation verwenden:
Beachten Sie, dass response_model ein Parameter der „Dekorator“-Methode ist (get, post, usw.). Nicht der Pfadoperation-Funktion, so wie die anderen Parameter.
response_model nimmt denselben Typ entgegen, den Sie auch für ein Pydantic-Modellfeld deklarieren würden, also etwa ein Pydantic-Modell, aber es kann auch z. B. eine liste von Pydantic-Modellen sein, wie etwa List[Item].
FastAPI wird dieses response_model nehmen, um die Daten zu dokumentieren, validieren, usw. und auch, um die Ausgabedaten entsprechend der Typdeklaration zu konvertieren und filtern.
Tipp
Wenn Sie in Ihrem Editor strikte Typchecks haben, mypy, usw., können Sie den Funktions-Rückgabetyp als Any deklarieren.
So sagen Sie dem Editor, dass Sie absichtlich irgendetwas zurückgeben. Aber FastAPI wird trotzdem die Dokumentation, Validierung, Filterung, usw. der Daten übernehmen, via response_model.
Wenn sowohl Rückgabetyp als auch response_model deklariert sind, hat response_model die Priorität und wird von FastAPI bevorzugt verwendet.
So können Sie korrekte Typannotationen zu ihrer Funktion hinzufügen, die von ihrem Editor und Tools wie mypy verwendet werden. Und dennoch übernimmt FastAPI die Validierung und Dokumentation, usw., der Daten anhand von response_model.
Sie können auch response_model=None verwenden, um das Erstellen eines Responsemodells für diese Pfadoperation zu unterbinden. Sie könnten das tun wollen, wenn sie Dinge annotieren, die nicht gültige Pydantic-Felder sind. Ein Beispiel dazu werden Sie in einer der Abschnitte unten sehen.
Im Folgenden deklarieren wir ein UserIn-Modell; es enthält ein Klartext-Passwort:
fromfastapiimportFastAPIfrompydanticimportBaseModel,EmailStrapp=FastAPI()classUserIn(BaseModel):username:strpassword:stremail:EmailStrfull_name:str|None=None# Don't do this in production!@app.post("/user/")asyncdefcreate_user(user:UserIn)->UserIn:returnuser
fromtypingimportUnionfromfastapiimportFastAPIfrompydanticimportBaseModel,EmailStrapp=FastAPI()classUserIn(BaseModel):username:strpassword:stremail:EmailStrfull_name:Union[str,None]=None# Don't do this in production!@app.post("/user/")asyncdefcreate_user(user:UserIn)->UserIn:returnuser
Info
Um EmailStr zu verwenden, installieren Sie zuerst email_validator.
Z. B. pip install email-validator
oder pip install pydantic[email].
Wir verwenden dieses Modell, um sowohl unsere Eingabe- als auch Ausgabedaten zu deklarieren:
fromfastapiimportFastAPIfrompydanticimportBaseModel,EmailStrapp=FastAPI()classUserIn(BaseModel):username:strpassword:stremail:EmailStrfull_name:str|None=None# Don't do this in production!@app.post("/user/")asyncdefcreate_user(user:UserIn)->UserIn:returnuser
fromtypingimportUnionfromfastapiimportFastAPIfrompydanticimportBaseModel,EmailStrapp=FastAPI()classUserIn(BaseModel):username:strpassword:stremail:EmailStrfull_name:Union[str,None]=None# Don't do this in production!@app.post("/user/")asyncdefcreate_user(user:UserIn)->UserIn:returnuser
Immer wenn jetzt ein Browser einen Benutzer mit Passwort erzeugt, gibt die API dasselbe Passwort in der Response zurück.
Hier ist das möglicherweise kein Problem, da es derselbe Benutzer ist, der das Passwort sendet.
Aber wenn wir dasselbe Modell für eine andere Pfadoperation verwenden, könnten wir das Passwort dieses Benutzers zu jedem Client schicken.
Gefahr
Speichern Sie niemals das Klartext-Passwort eines Benutzers, oder versenden Sie es in einer Response wie dieser, wenn Sie sich nicht der resultierenden Gefahren bewusst sind und nicht wissen, was Sie tun.
Da unsere zwei Modelle in diesem Fall unterschiedlich sind, würde, wenn wir den Rückgabewert der Funktion als UserOut deklarieren, der Editor sich beschweren, dass wir einen ungültigen Typ zurückgeben, weil das unterschiedliche Klassen sind.
Darum müssen wir es in diesem Fall im response_model-Parameter deklarieren.
... aber lesen Sie weiter, um zu sehen, wie man das anders lösen kann.
Führen wir unser vorheriges Beispiel fort. Wir wollten die Funktion mit einem Typ annotieren, aber etwas zurückgeben, das weniger Daten enthält.
Wir möchten auch, dass FastAPI die Daten weiterhin, dem Responsemodell entsprechend, filtert.
Im vorherigen Beispiel mussten wir den response_model-Parameter verwenden, weil die Klassen unterschiedlich waren. Das bedeutet aber auch, wir bekommen keine Unterstützung vom Editor und anderen Tools, die den Funktions-Rückgabewert überprüfen.
Aber in den meisten Fällen, wenn wir so etwas machen, wollen wir nur, dass das Modell einige der Daten filtert/entfernt, so wie in diesem Beispiel.
Und in solchen Fällen können wir Klassen und Vererbung verwenden, um Vorteil aus den Typannotationen in der Funktion zu ziehen, was vom Editor und von Tools besser unterstützt wird, während wir gleichzeitig FastAPIs Datenfilterung behalten.
Damit erhalten wir Tool-Unterstützung, vom Editor und mypy, da dieser Code hinsichtlich der Typen korrekt ist, aber wir erhalten auch die Datenfilterung von FastAPI.
Wie funktioniert das? Schauen wir uns das mal an. 🤓
Sehen wir uns zunächst an, wie Editor, mypy und andere Tools dies sehen würden.
BaseUser verfügt über die Basis-Felder. Dann erbt UserIn von BaseUser und fügt das Feld Passwort hinzu, sodass dass es nun alle Felder beider Modelle hat.
Wir annotieren den Funktionsrückgabetyp als BaseUser, geben aber tatsächlich eine UserIn-Instanz zurück.
Für den Editor, mypy und andere Tools ist das kein Problem, da UserIn eine Unterklasse von BaseUser ist (Salopp: UserIn ist ein BaseUser). Es handelt sich um einen gültigen Typ, solange irgendetwas überreicht wird, das ein BaseUser ist.
FastAPI seinerseits wird den Rückgabetyp sehen und sicherstellen, dass das, was zurückgegeben wird, nur diejenigen Felder enthält, welche im Typ deklariert sind.
FastAPI macht intern mehrere Dinge mit Pydantic, um sicherzustellen, dass obige Ähnlichkeitsregeln der Klassenvererbung nicht auf die Filterung der zurückgegebenen Daten angewendet werden, sonst könnten Sie am Ende mehr Daten zurückgeben als gewollt.
Auf diese Weise erhalten Sie das beste beider Welten: Sowohl Typannotationen mit Tool-Unterstützung als auch Datenfilterung.
Es kann Fälle geben, bei denen Sie etwas zurückgeben, das kein gültiges Pydantic-Feld ist, und Sie annotieren es in der Funktion nur, um Unterstützung von Tools zu erhalten (Editor, mypy, usw.).
fromfastapiimportFastAPI,Responsefromfastapi.responsesimportJSONResponse,RedirectResponseapp=FastAPI()@app.get("/portal")asyncdefget_portal(teleport:bool=False)->Response:ifteleport:returnRedirectResponse(url="https://www.youtube.com/watch?v=dQw4w9WgXcQ")returnJSONResponse(content={"message":"Here's your interdimensional portal."})
Dieser einfache Anwendungsfall wird automatisch von FastAPI gehandhabt, weil die Annotation des Rückgabetyps die Klasse (oder eine Unterklasse von) Response ist.
Und Tools werden auch glücklich sein, weil sowohl RedirectResponse als auch JSONResponse Unterklassen von Response sind, die Typannotation ist daher korrekt.
Das wird ebenfalls funktionieren, weil RedirectResponse eine Unterklasse von Response ist, und FastAPI sich um diesen einfachen Anwendungsfall automatisch kümmert.
Aber wenn Sie ein beliebiges anderes Objekt zurückgeben, das kein gültiger Pydantic-Typ ist (z. B. ein Datenbank-Objekt), und Sie annotieren es so in der Funktion, wird FastAPI versuchen, ein Pydantic-Responsemodell von dieser Typannotation zu erstellen, und scheitern.
Das gleiche wird passieren, wenn Sie eine Union mehrerer Typen haben, und einer oder mehrere sind nicht gültige Pydantic-Typen. Zum Beispiel funktioniert folgendes nicht 💥:
fromfastapiimportFastAPI,Responsefromfastapi.responsesimportRedirectResponseapp=FastAPI()@app.get("/portal")asyncdefget_portal(teleport:bool=False)->Response|dict:ifteleport:returnRedirectResponse(url="https://www.youtube.com/watch?v=dQw4w9WgXcQ")return{"message":"Here's your interdimensional portal."}
fromtypingimportUnionfromfastapiimportFastAPI,Responsefromfastapi.responsesimportRedirectResponseapp=FastAPI()@app.get("/portal")asyncdefget_portal(teleport:bool=False)->Union[Response,dict]:ifteleport:returnRedirectResponse(url="https://www.youtube.com/watch?v=dQw4w9WgXcQ")return{"message":"Here's your interdimensional portal."}
... das scheitert, da die Typannotation kein Pydantic-Typ ist, und auch keine einzelne Response-Klasse, oder -Unterklasse, es ist eine Union (eines von beiden) von Response und dict.
Beim Beispiel oben fortsetzend, mögen Sie vielleicht die standardmäßige Datenvalidierung, -Dokumentation, -Filterung, usw., die von FastAPI durchgeführt wird, nicht haben.
Aber Sie möchten dennoch den Rückgabetyp in der Funktion annotieren, um Unterstützung von Editoren und Typcheckern (z. B. mypy) zu erhalten.
In diesem Fall können Sie die Generierung des Responsemodells abschalten, indem Sie response_model=None setzen:
fromfastapiimportFastAPI,Responsefromfastapi.responsesimportRedirectResponseapp=FastAPI()@app.get("/portal",response_model=None)asyncdefget_portal(teleport:bool=False)->Response|dict:ifteleport:returnRedirectResponse(url="https://www.youtube.com/watch?v=dQw4w9WgXcQ")return{"message":"Here's your interdimensional portal."}
fromtypingimportUnionfromfastapiimportFastAPI,Responsefromfastapi.responsesimportRedirectResponseapp=FastAPI()@app.get("/portal",response_model=None)asyncdefget_portal(teleport:bool=False)->Union[Response,dict]:ifteleport:returnRedirectResponse(url="https://www.youtube.com/watch?v=dQw4w9WgXcQ")return{"message":"Here's your interdimensional portal."}
Das bewirkt, dass FastAPI die Generierung des Responsemodells unterlässt, und damit können Sie jede gewünschte Rückgabetyp-Annotation haben, ohne dass es Ihre FastAPI-Anwendung beeinflusst. 🤓
Parameter für die Enkodierung des Responsemodells¶
Ihr Responsemodell könnte Defaultwerte haben, wie:
description: Union[str, None] = None (oder str | None = None in Python 3.10) hat einen Defaultwert None.
tax: float = 10.5 hat einen Defaultwert 10.5.
tags: List[str] = [] hat eine leere Liste als Defaultwert: [].
Aber Sie möchten diese vielleicht vom Resultat ausschließen, wenn Sie gar nicht gesetzt wurden.
Wenn Sie zum Beispiel Modelle mit vielen optionalen Attributen in einer NoSQL-Datenbank haben, und Sie möchten nicht ellenlange JSON-Responses voller Defaultwerte senden.
Den response_model_exclude_unset-Parameter verwenden¶
Sie können den Pfadoperation-Dekorator-Parameter response_model_exclude_unset=True setzen:
Die Defaultwerte werden dann nicht in der Response enthalten sein, sondern nur die tatsächlich gesetzten Werte.
Wenn Sie also den Artikel mit der ID foo bei der Pfadoperation anfragen, wird (ohne die Defaultwerte) die Response sein:
{"name":"Foo","price":50.2}
Info
In Pydantic v1 hieß diese Methode .dict(), in Pydantic v2 wurde sie deprecated (aber immer noch unterstützt) und in .model_dump() umbenannt.
Die Beispiele hier verwenden .dict() für die Kompatibilität mit Pydantic v1, Sie sollten jedoch stattdessen .model_dump() verwenden, wenn Sie Pydantic v2 verwenden können.
dann ist FastAPI klug genug (tatsächlich ist Pydantic klug genug) zu erkennen, dass, obwohl description, tax, und tags die gleichen Werte haben wie ihre Defaultwerte, sie explizit gesetzt wurden (statt dass sie von den Defaultwerten genommen wurden).
Diese Felder werden also in der JSON-Response enthalten sein.
Tipp
Beachten Sie, dass Defaultwerte alles Mögliche sein können, nicht nur None.
Sie können eine Liste ([]), ein float10.5, usw. sein.
response_model_include und response_model_exclude¶
Sie können auch die Parameter response_model_include und response_model_exclude im Pfadoperation-Dekorator verwenden.
Diese nehmen ein set von strs entgegen, welches Namen von Attributen sind, die eingeschlossen (ohne die Anderen) oder ausgeschlossen (nur die Anderen) werden sollen.
Das kann als schnelle Abkürzung verwendet werden, wenn Sie nur ein Pydantic-Modell haben und ein paar Daten von der Ausgabe ausschließen wollen.
Tipp
Es wird dennoch empfohlen, dass Sie die Ideen von oben verwenden, also mehrere Klassen statt dieser Parameter.
Der Grund ist, dass das das generierte JSON-Schema in der OpenAPI ihrer Anwendung (und deren Dokumentation) dennoch das komplette Modell abbildet, selbst wenn Sie response_model_include oder response_model_exclude verwenden, um einige Attribute auszuschließen.
Das trifft auch auf response_model_by_alias zu, welches ähnlich funktioniert.
fromfastapiimportFastAPIfrompydanticimportBaseModelapp=FastAPI()classItem(BaseModel):name:strdescription:str|None=Noneprice:floattax:float=10.5items={"foo":{"name":"Foo","price":50.2},"bar":{"name":"Bar","description":"The Bar fighters","price":62,"tax":20.2},"baz":{"name":"Baz","description":"There goes my baz","price":50.2,"tax":10.5,},}@app.get("/items/{item_id}/name",response_model=Item,response_model_include={"name","description"},)asyncdefread_item_name(item_id:str):returnitems[item_id]@app.get("/items/{item_id}/public",response_model=Item,response_model_exclude={"tax"})asyncdefread_item_public_data(item_id:str):returnitems[item_id]
fromtypingimportUnionfromfastapiimportFastAPIfrompydanticimportBaseModelapp=FastAPI()classItem(BaseModel):name:strdescription:Union[str,None]=Noneprice:floattax:float=10.5items={"foo":{"name":"Foo","price":50.2},"bar":{"name":"Bar","description":"The Bar fighters","price":62,"tax":20.2},"baz":{"name":"Baz","description":"There goes my baz","price":50.2,"tax":10.5,},}@app.get("/items/{item_id}/name",response_model=Item,response_model_include={"name","description"},)asyncdefread_item_name(item_id:str):returnitems[item_id]@app.get("/items/{item_id}/public",response_model=Item,response_model_exclude={"tax"})asyncdefread_item_public_data(item_id:str):returnitems[item_id]
Tipp
Die Syntax {"name", "description"} erzeugt ein set mit diesen zwei Werten.
Wenn Sie vergessen, ein set zu verwenden, und stattdessen eine liste oder ein tuple übergeben, wird FastAPI die dennoch in ein set konvertieren, und es wird korrekt funktionieren:
fromfastapiimportFastAPIfrompydanticimportBaseModelapp=FastAPI()classItem(BaseModel):name:strdescription:str|None=Noneprice:floattax:float=10.5items={"foo":{"name":"Foo","price":50.2},"bar":{"name":"Bar","description":"The Bar fighters","price":62,"tax":20.2},"baz":{"name":"Baz","description":"There goes my baz","price":50.2,"tax":10.5,},}@app.get("/items/{item_id}/name",response_model=Item,response_model_include=["name","description"],)asyncdefread_item_name(item_id:str):returnitems[item_id]@app.get("/items/{item_id}/public",response_model=Item,response_model_exclude=["tax"])asyncdefread_item_public_data(item_id:str):returnitems[item_id]
fromtypingimportUnionfromfastapiimportFastAPIfrompydanticimportBaseModelapp=FastAPI()classItem(BaseModel):name:strdescription:Union[str,None]=Noneprice:floattax:float=10.5items={"foo":{"name":"Foo","price":50.2},"bar":{"name":"Bar","description":"The Bar fighters","price":62,"tax":20.2},"baz":{"name":"Baz","description":"There goes my baz","price":50.2,"tax":10.5,},}@app.get("/items/{item_id}/name",response_model=Item,response_model_include=["name","description"],)asyncdefread_item_name(item_id:str):returnitems[item_id]@app.get("/items/{item_id}/public",response_model=Item,response_model_exclude=["tax"])asyncdefread_item_public_data(item_id:str):returnitems[item_id]
Verwenden Sie den Parameter response_model im Pfadoperation-Dekorator, um Responsemodelle zu definieren, und besonders, um private Daten herauszufiltern.
Verwenden Sie response_model_exclude_unset, um nur explizit gesetzte Werte zurückzugeben.