Skip to content

Commit 72d19f8

Browse files
author
Nils Lindemann
committed
docs/de/
🌐 Add German translation for `docs/de/docs/alternatives.md` * Full translation * In sync with current docs/en/docs/alternatives.md * Google Translate used * Manually checked * Checked for errors using LanguageTool
1 parent 57fe07d commit 72d19f8

128 files changed

Lines changed: 20515 additions & 76 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎docs/de/docs/about/index.md‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
# Über
2+
3+
Über FastAPI, sein Design, seine Inspiration und mehr. 🤓

‎docs/de/docs/advanced/additional-responses.md‎

Lines changed: 240 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,240 @@
1+
# Zusätzliche Responses in OpenAPI
2+
3+
!!! warning "Achtung"
4+
Dies ist ein eher fortgeschrittenes Thema.
5+
6+
Wenn Sie mit **FastAPI** beginnen, benötigen Sie dies möglicherweise nicht.
7+
8+
Sie können zusätzliche Responses mit zusätzlichen Statuscodes, Medientypen, Beschreibungen, usw. deklarieren.
9+
10+
Diese zusätzlichen Responses werden in das OpenAPI-Schema aufgenommen, sodass sie auch in der API-Dokumentation erscheinen.
11+
12+
Für diese zusätzlichen Responses müssen Sie jedoch sicherstellen, dass Sie eine `Response`, wie etwa `JSONResponse`, direkt zurückgeben, mit Ihrem Statuscode und Inhalt.
13+
14+
## Zusätzliche Response mit `model`
15+
16+
Sie können Ihren *Pfadoperation-Dekoratoren* einen Parameter `responses` übergeben.
17+
18+
Der nimmt ein `dict` entgegen, die Schlüssel sind Statuscodes für jede Response, wie etwa `200`, und die Werte sind andere `dict`s mit den Informationen für jede Response.
19+
20+
Jedes dieser Response-`dict`s kann einen Schlüssel `model` haben, welcher ein Pydantic-Modell enthält, genau wie `response_model`.
21+
22+
**FastAPI** nimmt dieses Modell, generiert dessen JSON-Schema und fügt es an der richtigen Stelle in OpenAPI ein.
23+
24+
Um beispielsweise eine weitere Response mit dem Statuscode `404` und einem Pydantic-Modell `Message` zu deklarieren, können Sie schreiben:
25+
26+
```Python hl_lines="18 22"
27+
{!../../../docs_src/additional_responses/tutorial001.py!}
28+
```
29+
30+
!!! note "Hinweis"
31+
Beachten Sie, dass Sie die `JSONResponse` direkt zurückgeben müssen.
32+
33+
!!! info
34+
Der `model`-Schlüssel ist nicht Teil von OpenAPI.
35+
36+
**FastAPI** nimmt das Pydantic-Modell von dort, generiert das JSON-Schema und fügt es an der richtigen Stelle ein.
37+
38+
Die richtige Stelle ist:
39+
40+
* Im Schlüssel `content`, der als Wert ein weiteres JSON-Objekt (`dict`) hat, welches Folgendes enthält:
41+
* Ein Schlüssel mit dem Medientyp, z. B. `application/json`, der als Wert ein weiteres JSON-Objekt hat, welches Folgendes enthält:
42+
* Ein Schlüssel `schema`, der als Wert das JSON-Schema aus dem Modell hat, hier ist die richtige Stelle.
43+
* **FastAPI** fügt hier eine Referenz auf die globalen JSON-Schemas an einer anderen Stelle in Ihrer OpenAPI hinzu, anstatt es direkt einzubinden. Auf diese Weise können andere Anwendungen und Clients diese JSON-Schemas direkt verwenden, bessere Tools zur Codegenerierung bereitstellen, usw.
44+
45+
Die generierten Responses in der OpenAPI für diese *Pfadoperation* lauten:
46+
47+
```JSON hl_lines="3-12"
48+
{
49+
"responses": {
50+
"404": {
51+
"description": "Additional Response",
52+
"content": {
53+
"application/json": {
54+
"schema": {
55+
"$ref": "#/components/schemas/Message"
56+
}
57+
}
58+
}
59+
},
60+
"200": {
61+
"description": "Successful Response",
62+
"content": {
63+
"application/json": {
64+
"schema": {
65+
"$ref": "#/components/schemas/Item"
66+
}
67+
}
68+
}
69+
},
70+
"422": {
71+
"description": "Validation Error",
72+
"content": {
73+
"application/json": {
74+
"schema": {
75+
"$ref": "#/components/schemas/HTTPValidationError"
76+
}
77+
}
78+
}
79+
}
80+
}
81+
}
82+
```
83+
84+
Die Schemas werden von einer anderen Stelle innerhalb des OpenAPI-Schemas referenziert:
85+
86+
```JSON hl_lines="4-16"
87+
{
88+
"components": {
89+
"schemas": {
90+
"Message": {
91+
"title": "Message",
92+
"required": [
93+
"message"
94+
],
95+
"type": "object",
96+
"properties": {
97+
"message": {
98+
"title": "Message",
99+
"type": "string"
100+
}
101+
}
102+
},
103+
"Item": {
104+
"title": "Item",
105+
"required": [
106+
"id",
107+
"value"
108+
],
109+
"type": "object",
110+
"properties": {
111+
"id": {
112+
"title": "Id",
113+
"type": "string"
114+
},
115+
"value": {
116+
"title": "Value",
117+
"type": "string"
118+
}
119+
}
120+
},
121+
"ValidationError": {
122+
"title": "ValidationError",
123+
"required": [
124+
"loc",
125+
"msg",
126+
"type"
127+
],
128+
"type": "object",
129+
"properties": {
130+
"loc": {
131+
"title": "Location",
132+
"type": "array",
133+
"items": {
134+
"type": "string"
135+
}
136+
},
137+
"msg": {
138+
"title": "Message",
139+
"type": "string"
140+
},
141+
"type": {
142+
"title": "Error Type",
143+
"type": "string"
144+
}
145+
}
146+
},
147+
"HTTPValidationError": {
148+
"title": "HTTPValidationError",
149+
"type": "object",
150+
"properties": {
151+
"detail": {
152+
"title": "Detail",
153+
"type": "array",
154+
"items": {
155+
"$ref": "#/components/schemas/ValidationError"
156+
}
157+
}
158+
}
159+
}
160+
}
161+
}
162+
}
163+
```
164+
165+
## Zusätzliche Medientypen für die Haupt-Response
166+
167+
Sie können denselben `responses`-Parameter verwenden, um verschiedene Medientypen für dieselbe Haupt-Response hinzuzufügen.
168+
169+
Sie können beispielsweise einen zusätzlichen Medientyp `image/png` hinzufügen und damit deklarieren, dass Ihre *Pfadoperation* ein JSON-Objekt (mit dem Medientyp `application/json`) oder ein PNG-Bild zurückgeben kann:
170+
171+
```Python hl_lines="19-24 28"
172+
{!../../../docs_src/additional_responses/tutorial002.py!}
173+
```
174+
175+
!!! note "Hinweis"
176+
Beachten Sie, dass Sie das Bild direkt mit einer `FileResponse` zurückgeben müssen.
177+
178+
!!! info
179+
Sofern Sie in Ihrem Parameter `responses` nicht explizit einen anderen Medientyp angeben, geht FastAPI davon aus, dass die Response denselben Medientyp wie die Haupt-Response-Klasse hat (Standardmäßig `application/json`).
180+
181+
Wenn Sie jedoch eine benutzerdefinierte Response-Klasse mit `None` als Medientyp angegeben haben, verwendet FastAPI `application/json` für jede zusätzliche Response, die über ein zugehöriges Modell verfügt.
182+
183+
## Informationen kombinieren
184+
185+
Sie können auch Response-Informationen von mehreren Stellen kombinieren, einschließlich der Parameter `response_model`, `status_code` und `responses`.
186+
187+
Sie können ein `response_model` deklarieren, indem Sie den Standardstatuscode `200` (oder bei Bedarf einen benutzerdefinierten) verwenden und dann zusätzliche Informationen für dieselbe Response in `responses` direkt im OpenAPI-Schema deklarieren.
188+
189+
**FastAPI** behält die zusätzlichen Informationen aus `responses` und kombiniert sie mit dem JSON-Schema aus Ihrem Modell.
190+
191+
Sie können beispielsweise eine Response mit dem Statuscode `404` deklarieren, die ein Pydantic-Modell verwendet und über eine benutzerdefinierte Beschreibung (`description`) verfügt.
192+
193+
Und eine Response mit dem Statuscode `200`, die Ihr `response_model` verwendet, aber ein benutzerdefiniertes Beispiel (`example`) enthält:
194+
195+
```Python hl_lines="20-31"
196+
{!../../../docs_src/additional_responses/tutorial003.py!}
197+
```
198+
199+
Es wird alles kombiniert und in Ihre OpenAPI eingebunden und in der API-Dokumentation angezeigt:
200+
201+
<img src="/img/tutorial/additional-responses/image01.png">
202+
203+
## Vordefinierte und benutzerdefinierte Responses kombinieren
204+
205+
Möglicherweise möchten Sie einige vordefinierte Responses haben, die für viele *Pfadoperationen* gelten, Sie möchten diese jedoch mit benutzerdefinierten Responses kombinieren, die für jede *Pfadoperation* erforderlich sind.
206+
207+
In diesen Fällen können Sie die Python-Technik zum „Entpacken“ eines `dict`s mit `**dict_to_unpack` verwenden:
208+
209+
```Python
210+
old_dict = {
211+
"old key": "old value",
212+
"second old key": "second old value",
213+
}
214+
new_dict = {**old_dict, "new key": "new value"}
215+
```
216+
217+
Hier wird `new_dict` alle Schlüssel-Wert-Paare von `old_dict` plus das neue Schlüssel-Wert-Paar enthalten:
218+
219+
```Python
220+
{
221+
"old key": "old value",
222+
"second old key": "second old value",
223+
"new key": "new value",
224+
}
225+
```
226+
227+
Mit dieser Technik können Sie einige vordefinierte Responses in Ihren *Pfadoperationen* wiederverwenden und sie mit zusätzlichen benutzerdefinierten Responses kombinieren.
228+
229+
Zum Beispiel:
230+
231+
```Python hl_lines="13-17 26"
232+
{!../../../docs_src/additional_responses/tutorial004.py!}
233+
```
234+
235+
## Weitere Informationen zu OpenAPI-Responses
236+
237+
Um zu sehen, was genau Sie in die Responses aufnehmen können, können Sie die folgenden Abschnitte in der OpenAPI-Spezifikation überprüfen:
238+
239+
* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responsesObject" class="external-link" target="_blank">OpenAPI Responses Object</a>, enthält das `Response Object`.
240+
* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responseObject" class="external-link" target="_blank">OpenAPI Response Object</a>, Sie können alles davon direkt in jede Response innerhalb Ihres `responses`-Parameter einfügen. Einschließlich `description`, `headers`, `content` (darin deklarieren Sie verschiedene Medientypen und JSON-Schemas) und `links`.

‎docs/de/docs/advanced/additional-status-codes.md‎

Lines changed: 69 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
# Zusätzliche Statuscodes
2+
3+
Standardmäßig gibt **FastAPI** die Responses als `JSONResponse` zurück und fügt den Inhalt, den Sie von Ihrer *Pfadoperation* zurückgeben, in diese `JSONResponse` ein.
4+
5+
Es wird der Default-Statuscode oder derjenige verwendet, den Sie in Ihrer *Pfadoperation* festgelegt haben.
6+
7+
## Zusätzliche Statuscodes
8+
9+
Wenn Sie neben dem Hauptstatuscode weitere Statuscodes zurückgeben möchten, können Sie dies tun, indem Sie direkt eine `Response` zurückgeben, wie etwa eine `JSONResponse`, und den zusätzlichen Statuscode direkt festlegen.
10+
11+
Angenommen, Sie möchten eine *Pfadoperation* haben, die das Aktualisieren von Artikeln ermöglicht und bei Erfolg den HTTP-Statuscode 200 „OK“ zurückgibt.
12+
13+
Sie möchten aber auch, dass sie neue Artikel akzeptiert. Und wenn die Elemente vorher nicht vorhanden waren, werden sie erstellt und der HTTP-Statuscode 201 „Created“ zurückgegeben.
14+
15+
Um dies zu erreichen, importieren Sie `JSONResponse` und geben Sie Ihren Inhalt damit direkt zurück, den gewünschten `status_code` setzend:
16+
17+
=== "Python 3.10+"
18+
19+
```Python hl_lines="4 25"
20+
{!> ../../../docs_src/additional_status_codes/tutorial001_an_py310.py!}
21+
```
22+
23+
=== "Python 3.9+"
24+
25+
```Python hl_lines="4 25"
26+
{!> ../../../docs_src/additional_status_codes/tutorial001_an_py39.py!}
27+
```
28+
29+
=== "Python 3.8+"
30+
31+
```Python hl_lines="4 26"
32+
{!> ../../../docs_src/additional_status_codes/tutorial001_an.py!}
33+
```
34+
35+
=== "Python 3.10+ nicht annotiert"
36+
37+
!!! tip "Tipp"
38+
Bevorzugen Sie die `Annotated`-Version, falls möglich.
39+
40+
```Python hl_lines="2 23"
41+
{!> ../../../docs_src/additional_status_codes/tutorial001_py310.py!}
42+
```
43+
44+
=== "Python 3.8+ nicht annotiert"
45+
46+
!!! tip "Tipp"
47+
Bevorzugen Sie die `Annotated`-Version, falls möglich.
48+
49+
```Python hl_lines="4 25"
50+
{!> ../../../docs_src/additional_status_codes/tutorial001.py!}
51+
```
52+
53+
!!! warning "Achtung"
54+
Wenn Sie eine `Response` direkt zurückgeben, wie im obigen Beispiel, wird sie direkt zurückgegeben.
55+
56+
Sie wird nicht mit einem Modell usw. serialisiert.
57+
58+
Stellen Sie sicher, dass sie die gewünschten Daten enthält und dass die Werte gültiges JSON sind (wenn Sie `JSONResponse` verwenden).
59+
60+
!!! note "Technische Details"
61+
Sie können auch `from starlette.responses import JSONResponse` verwenden.
62+
63+
**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit für Sie, den Entwickler. Die meisten verfügbaren Responses kommen aber direkt von Starlette. Das Gleiche gilt für `status`.
64+
65+
## OpenAPI- und API-Dokumentation
66+
67+
Wenn Sie zusätzliche Statuscodes und Responses direkt zurückgeben, werden diese nicht in das OpenAPI-Schema (die API-Dokumentation) aufgenommen, da FastAPI keine Möglichkeit hat, im Voraus zu wissen, was Sie zurückgeben werden.
68+
69+
Sie können das jedoch in Ihrem Code dokumentieren, indem Sie Folgendes verwenden: [Zusätzliche Responses](additional-responses.md){.internal-link target=_blank}.

0 commit comments

Comments
 (0)