From 298323188c62a5d3add54eff4a12c05ca7e4b9f9 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 17 Aug 2025 16:38:25 +0200 Subject: [PATCH 001/160] Apply branch `update-translations-prompt` --- scripts/translate.py | 115 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 110 insertions(+), 5 deletions(-) diff --git a/scripts/translate.py b/scripts/translate.py index 2fdc18ca0..1a47481f2 100644 --- a/scripts/translate.py +++ b/scripts/translate.py @@ -34,6 +34,36 @@ The content is written in markdown, write the translation in markdown as well. D When there's an example of code, the console or a terminal, normally surrounded by triple backticks and a keyword like "console" or "bash" (e.g. ```console), do not translate the content, keep the original in English. +For example, if the original (English) content is: + +```bash +# Print greeting +echo "Hello, World!" +``` + +It should be exacly the same in the output document: + +```bash +# Print greeting +echo "Hello, World!" +``` + +If the original (English) content is: + +```console +$ fastapi run main.py + FastAPI Starting server + Searching for package file structure +``` + +It should be exacly the same in the output document: + +```console +$ fastapi run main.py + FastAPI Starting server + Searching for package file structure +``` + The original content will be surrounded by triple percentage signs (%) and you should translate it to the target language. Do not include the triple percentage signs in the translation. There are special blocks of notes, tips and others that look like: @@ -63,6 +93,81 @@ Source: Result: /// details | Vista previa + +Every Markdown heading in the English text (all levels) ends with a part inside curly brackets. This part denotes the hash of this heading, which is used in links to this heading. In translations, translate the heading, but do not translate this hash part, so that links do not break. + +Examples of how to translate a heading: + +Source (English): + +## Alternative API docs { #alternative-api-docs } + +Result (Spanish): + +## Documentación de la API alternativa { #alternative-api-docs } + +Source (English): + +### Example { #example } + +Result (German): + +### Beispiel { #example } + + +Use the following rules for links (apply both to Markdown-style links ([text](url)) and to HTML-style tags): + +1) For relative URLs only translate link text. Do not translate the URL or its parts + +Example: + +Source (English): + +[One of the fastest Python frameworks available](#performance) + +Result (German): + +[Eines der schnellsten verfügbaren Python-Frameworks](#performance) + +2) For absolute URLs pointing to https://fastapi.tiangolo.com, only translate link text and change the URL by adding language code (https://fastapi.tiangolo.com/{language_code}[rest part of the url]). + +Example: + +Source (English): + +Documentation + +Result (Spanish): + +Documentación + +2.1) Do not add language codes for URLs that point to static assets (e.g., images, CSS, JavaScript). + +Example: + +Source (English): + +Something + +Result (Spanish): + +Algo + + +3) For internal links, only translate link text. + +Example: + +Source (English): + +[Create Pull Requests](help-fastapi.md#create-a-pull-request){.internal-link target=_blank} + +Result (German): + +[Pull Requests erzeugen](help-fastapi.md#create-a-pull-request){.internal-link target=_blank} + +4) Do not translate anchor fragments in links (the part after #), as they must remain the same to work correctly. + """ app = typer.Typer() @@ -70,7 +175,7 @@ app = typer.Typer() @lru_cache def get_langs() -> dict[str, str]: - return yaml.safe_load(Path("docs/language_names.yml").read_text()) + return yaml.safe_load(Path("docs/language_names.yml").read_text(encoding="utf-8")) def generate_lang_path(*, lang: str, path: Path) -> Path: @@ -105,7 +210,7 @@ def translate_page( lang_path.mkdir(exist_ok=True) lang_prompt_path = lang_path / "llm-prompt.md" assert lang_prompt_path.exists(), f"Prompt file not found: {lang_prompt_path}" - lang_prompt_content = lang_prompt_path.read_text() + lang_prompt_content = lang_prompt_path.read_text(encoding="utf-8") en_docs_path = Path("docs/en/docs") assert str(en_path).startswith(str(en_docs_path)), ( @@ -113,11 +218,11 @@ def translate_page( ) out_path = generate_lang_path(lang=language, path=en_path) out_path.parent.mkdir(parents=True, exist_ok=True) - original_content = en_path.read_text() + original_content = en_path.read_text(encoding="utf-8") old_translation: str | None = None if out_path.exists(): print(f"Found existing translation: {out_path}") - old_translation = out_path.read_text() + old_translation = out_path.read_text(encoding="utf-8") print(f"Translating {en_path} to {language} ({language_name})") agent = Agent("openai:gpt-4o") @@ -154,7 +259,7 @@ def translate_page( result = agent.run_sync(prompt) out_content = f"{result.data.strip()}\n" print(f"Saving translation to {out_path}") - out_path.write_text(out_content) + out_path.write_text(out_content, encoding="utf-8", newline="\n") def iter_all_en_paths() -> Iterable[Path]: From 24d599530320af822dcbc43fc94bec905ba3920a Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 17 Aug 2025 16:43:38 +0200 Subject: [PATCH 002/160] Apply branch `de-prompt` --- docs/de/llm-prompt.md | 82 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 docs/de/llm-prompt.md diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md new file mode 100644 index 000000000..0f5e4fdba --- /dev/null +++ b/docs/de/llm-prompt.md @@ -0,0 +1,82 @@ +Translate to German (Deutsch). + +Language code: de. + +Use the formal grammar (use "Sie" instead of "Du"). + +Translate quotation marks ("") in the Englisch text with typographic quotation marks („“) in the German translation. For example, translate "word" with „Wort“. But don't do that when the quotation marks are inside backticks (`). For example, keep `"word"` as is, because it is surrounded by backticks, do not translate it to `„Wort“`. Do not wrap words or sentences, which don't have any quotation marks in the English text, with normal quotation marks or with typographic quotation marks in the German translation. + +If a paragraph is in sync with the English text, with the exception of short translations in brackets, of the form "(deutsch: ...)" or "(englisch: ...)" then keep these short translations. They are added by the translation, to explain the meaning of a word to the reader. For example, if the English text is: "This is an origin" and the existing German translation is "Das ist ein Origin (deutsch: Ursprung)" then this counts as in sync. The addition " (deutsch: Ursprung)" is useful. It is not outdated. + +If possible, translate headings using the infinite form. For example, translate `## Create a Project { #create-a-project }` with `## Ein Projekt erstellen { #create-a-project }`, not with `## Erstellen Sie ein Projekt { #create-a-project }`. Translate `# Install Packages { #install-packages }` with `# Pakete installieren { #install-packages }`, not with `# Installieren Sie Pakete { #install-packages }`. Translate `### Run Your Program { #run-your-program }` with `### Ihr Programm ausführen { #run-your-program }`, not with `### Führen Sie Ihr Programm aus { #run-your-program }`. + +Preserve indentation. Do not translate link targets. Keep emoticons. Encode in utf-8. Use Linux linebreaks (LF) + +--- + +Follow these instructions (they are in German): + +In der Regel versuche ich so weit wie möglich Worte zusammenzuschreiben, also ohne Bindestrich, es sei denn, es ist Konkretesding-Klassevondingen, etwa `Pydantic-Modell` (aber: `Datenbankmodell`), `Python-Modul` (aber: `Standardmodul`). Ich setze auch einen Bindestrich, wenn er die gleichen Buchstaben verbindet, etwa `Enum-Member`, `Cloud-Dienst`, `Template-Engine`. Oder wenn das Wort sonst einfach zu lang wird, etwa, `Performance-Optimierung`. Oder um etwas visuell besser zu dokumentieren, etwa `Pfadoperation-Dekorator`, `Pfadoperation-Funktion`. + +Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriffe aus dem Bereich der Programmierung. Ich wandele zwar korrekt in Großschreibung um und setze Bindestriche, wo notwendig, aber ansonsten lasse ich solch ein Wort unverändert. Beispielsweise wird aus dem englischen Wort `string` in der deutschen Übersetzung `String`, aber nicht `Zeichenkette`. Oder aus dem englischen Wort `request body` wird in der deutschen Übersetzung `Requestbody`, aber nicht `Anfragekörper`. Oder aus dem englischen `response` wird im Deutschen `Response`, aber nicht `Antwort`. + +--- + +Below is a list of English terms and their German translations. Use these translations, do not use your own. Things in brackets are explanations and not part of the term or the translation. If a line starts with "NOT", that means: do NOT use this translation. + +* /// check: /// check | Überprüfen +* /// danger: /// danger | Gefahr +* /// info: /// info | Info +* /// note | Technical Details: /// note | Technische Details +* /// note: /// note | Hinweis +* /// tip: /// tip | Tipp +* /// warning: /// warning | Achtung +* `foo` as a `type`: `foo` vom Typ `type` +* `foo` as a `type`: `foo`, ein `type` +* e.g: z.B. +* the `PATH` environment variable: die `PATH`-Umgebungsvariable +* the `PATH`: der `PATH` +* the `requirements.txt`: die `requirements.txt` +* the app: die App +* the application: die Anwendung +* the Advanced User Guide: das Handbuch für fortgeschrittene Benutzer +* the Authorization-Header: der Autorisierungsheader +* the background task: der Hintergrundtask +* the cloud provider: der Cloudanbieter +* the docs: die Dokumentation (singular case) +* the default value: der Defaultwert +* the engine: die Engine +* the env var: die Umgebungsvariable +* the error response: die Error-Response +* the exception: die Exception +* the form model: das Formularmodell +* the form body: der Formularbody +* the header: der Header +* (plural) the headers: die Header +* the interactive API docs: die interaktive API-Dokumentation (singular case) +* the lifespan event: das Lifespan-Event +* the locking: das Locking +* the mobile application: die Mobile-Anwendung +* the origin: das Origin +* the recap: die Zusammenfassung +* the request: der Request +* the response: die Response +* the return type: der Rückgabetyp +* the return value: der Rückgabewert +* the SQLModel docs: die SQLModel-Dokumentation +* the Tutorial - User guide: das Tutorial – Benutzerhandbuch +* the type annotation: die Typ-Annotation +* the type hint: der Typ-Hinweis +* the wildcard: die Wildcard +* the worker class: die Workerklasse +* NOT the worker class: die Arbeiterklasse +* the worker process: der Workerprozess +* NOT the worker process: der Arbeiterprozess +* to commit: committen +* to modify: ändern +* (the server serves an application) to serve: bereitstellen +* (the server serves a response) to serve: ausliefern +* to upgrade: aktualisieren +* to wrap: wrappen +* you: Sie +* your: Ihr From 3b9b39ed65f47eb65afe06d96829eb21fcaa3559 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 17 Aug 2025 16:59:27 +0200 Subject: [PATCH 003/160] Apply branch `translations-de` --- docs/de/docs/environment-variables.md | 298 +++++++ docs/de/docs/fastapi-cli.md | 75 ++ docs/de/docs/how-to/testing-database.md | 7 + docs/de/docs/tutorial/cookie-param-models.md | 76 ++ docs/de/docs/tutorial/cors.md | 88 ++ docs/de/docs/tutorial/debugging.md | 113 +++ docs/de/docs/tutorial/header-param-models.md | 72 ++ docs/de/docs/tutorial/query-param-models.md | 68 ++ docs/de/docs/tutorial/request-form-models.md | 78 ++ docs/de/docs/tutorial/sql-databases.md | 357 ++++++++ docs/de/docs/virtual-environments.md | 842 +++++++++++++++++++ 11 files changed, 2074 insertions(+) create mode 100644 docs/de/docs/environment-variables.md create mode 100644 docs/de/docs/fastapi-cli.md create mode 100644 docs/de/docs/how-to/testing-database.md create mode 100644 docs/de/docs/tutorial/cookie-param-models.md create mode 100644 docs/de/docs/tutorial/cors.md create mode 100644 docs/de/docs/tutorial/debugging.md create mode 100644 docs/de/docs/tutorial/header-param-models.md create mode 100644 docs/de/docs/tutorial/query-param-models.md create mode 100644 docs/de/docs/tutorial/request-form-models.md create mode 100644 docs/de/docs/tutorial/sql-databases.md create mode 100644 docs/de/docs/virtual-environments.md diff --git a/docs/de/docs/environment-variables.md b/docs/de/docs/environment-variables.md new file mode 100644 index 000000000..187753837 --- /dev/null +++ b/docs/de/docs/environment-variables.md @@ -0,0 +1,298 @@ +# Umgebungsvariablen + +/// tip | Tipp + +Wenn Sie bereits wissen, was „Umgebungsvariablen“ sind und wie man sie verwendet, können Sie dies überspringen. + +/// + +Eine Umgebungsvariable (auch bekannt als „**env var**“) ist eine Variable, die **außerhalb** des Python-Codes im **Betriebssystem** lebt und von Ihrem Python-Code (oder auch von anderen Programmen) gelesen werden kann. + +Umgebungsvariablen können nützlich sein, um **Einstellungen** der Anwendung zu handhaben, als Teil der **Installation** von Python usw. + +## Erstellen und Verwenden von Umgebungsvariablen + +Sie können Umgebungsvariablen in der **Shell (Terminal)** erstellen und verwenden, ohne Python zu benötigen: + +//// tab | Linux, macOS, Windows Bash + +
+ +```console +// Sie können eine Umgebungsvariable MY_NAME erstellen mit +$ export MY_NAME="Wade Wilson" + +// Dann können Sie sie mit anderen Programmen verwenden, etwa +$ echo "Hello $MY_NAME" + +Hello Wade Wilson +``` + +
+ +//// + +//// tab | Windows PowerShell + +
+ +```console +// Erstellen Sie eine Umgebungsvariable MY_NAME +$ $Env:MY_NAME = "Wade Wilson" + +// Verwenden Sie sie mit anderen Programmen, etwa +$ echo "Hello $Env:MY_NAME" + +Hello Wade Wilson +``` + +
+ +//// + +## Umgebungsvariablen in Python lesen + +Sie können auch Umgebungsvariablen **außerhalb** von Python erstellen, im Terminal (oder mit jeder anderen Methode) und sie dann **in Python** lesen. + +Zum Beispiel könnten Sie eine Datei `main.py` haben mit: + +```Python hl_lines="3" +import os + +name = os.getenv("MY_NAME", "World") +print(f"Hello {name} from Python") +``` + +/// tip | Tipp + +Das zweite Argument von `os.getenv()` ist der Defaultwert, der zurückgegeben wird. + +Wenn er nicht angegeben wird, ist er standardmäßig `None`. Hier geben wir `"World"` als den zu verwendenden Defaultwert an. + +/// + +Dann könnten Sie das Python-Programm aufrufen: + +//// tab | Linux, macOS, Windows Bash + +
+ +```console +// Hier setzen wir die Umgebungsvariable noch nicht +$ python main.py + +// Da wir die Umgebungsvariable nicht gesetzt haben, erhalten wir den Defaultwert + +Hello World from Python + +// Aber wenn wir zuerst eine Umgebungsvariable erstellen +$ export MY_NAME="Wade Wilson" + +// Und dann das Programm erneut aufrufen +$ python main.py + +// Jetzt kann es die Umgebungsvariable lesen + +Hello Wade Wilson from Python +``` + +
+ +//// + +//// tab | Windows PowerShell + +
+ +```console +// Hier setzen wir die Umgebungsvariable noch nicht +$ python main.py + +// Da wir die Umgebungsvariable nicht gesetzt haben, erhalten wir den Defaultwert + +Hello World from Python + +// Aber wenn wir zuerst eine Umgebungsvariable erstellen +$ $Env:MY_NAME = "Wade Wilson" + +// Und dann das Programm erneut aufrufen +$ python main.py + +// Jetzt kann es die Umgebungsvariable lesen + +Hello Wade Wilson from Python +``` + +
+ +//// + +Da Umgebungsvariablen außerhalb des Codes gesetzt werden können, aber vom Code gelesen werden können und nicht mit den restlichen Dateien gespeichert (in `git` committet) werden müssen, werden sie häufig für Konfigurationen oder **Einstellungen** verwendet. + +Sie können auch eine Umgebungsvariable nur für einen **spezifischen Programmauruf** erstellen, die nur für dieses Programm und nur für dessen Dauer verfügbar ist. + +Um dies zu tun, erstellen Sie sie direkt vor dem Programmaufruf, in derselben Zeile: + +
+ +```console +// Erstellen Sie eine Umgebungsvariable MY_NAME in der Zeile für diesen Programmauruf +$ MY_NAME="Wade Wilson" python main.py + +// Jetzt kann es die Umgebungsvariable lesen + +Hello Wade Wilson from Python + +// Die Umgebungsvariable existiert danach nicht mehr +$ python main.py + +Hello World from Python +``` + +
+ +/// tip | Tipp + +Sie können mehr darüber lesen auf The Twelve-Factor App: Config. + +/// + +## Typen und Validierung + +Diese Umgebungsvariablen können nur **Textstrings** handhaben, da sie extern zu Python sind und kompatibel mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen, wie Linux, Windows, macOS) sein müssen. + +Das bedeutet, dass **jeder Wert**, der in Python von einer Umgebungsvariable gelesen wird, **ein `str` sein wird**, und jede Konvertierung in einen anderen Typ oder jede Validierung muss im Code vorgenommen werden. + +Sie werden mehr darüber lernen, wie man Umgebungsvariablen zur Handhabung von **Anwendungseinstellungen** verwendet, im [Handbuch für fortgeschrittene Benutzer – Einstellungen und Umgebungsvariablen](./advanced/settings.md){.internal-link target=_blank}. + +## `PATH` Umgebungsvariable + +Es gibt eine **spezielle** Umgebungsvariable namens **`PATH`**, die von den Betriebssystemen (Linux, macOS, Windows) verwendet wird, um Programme zu finden, die ausgeführt werden sollen. + +Der Wert der Variable `PATH` ist ein langer String, der aus Verzeichnissen besteht, die auf Linux und macOS durch einen Doppelpunkt `:` und auf Windows durch ein Semikolon `;` getrennt sind. + +Zum Beispiel könnte die `PATH`-Umgebungsvariable so aussehen: + +//// tab | Linux, macOS + +```plaintext +/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin +``` + +Das bedeutet, dass das System nach Programmen in den Verzeichnissen suchen sollte: + +* `/usr/local/bin` +* `/usr/bin` +* `/bin` +* `/usr/sbin` +* `/sbin` + +//// + +//// tab | Windows + +```plaintext +C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32 +``` + +Das bedeutet, dass das System nach Programmen in den Verzeichnissen suchen sollte: + +* `C:\Program Files\Python312\Scripts` +* `C:\Program Files\Python312` +* `C:\Windows\System32` + +//// + +Wenn Sie einen **Befehl** im Terminal eingeben, **sucht** das Betriebssystem nach dem Programm in **jedem dieser Verzeichnisse**, die in der `PATH`-Umgebungsvariable aufgeführt sind. + +Zum Beispiel, wenn Sie `python` im Terminal eingeben, sucht das Betriebssystem nach einem Programm namens `python` im **ersten Verzeichnis** in dieser Liste. + +Wenn es es findet, wird es **benutzt**. Andernfalls sucht es weiter in den **anderen Verzeichnissen**. + +### Installation von Python und Aktualisierung des `PATH` + +Wenn Sie Python installieren, könnten Sie gefragt werden, ob Sie die `PATH`-Umgebungsvariable aktualisieren möchten. + +//// tab | Linux, macOS + +Angenommen, Sie installieren Python und es landet in einem Verzeichnis `/opt/custompython/bin`. + +Wenn Sie erlauben, die `PATH` Umgebungsvariable zu aktualisieren, fügt der Installer `/opt/custompython/bin` zur `PATH` Umgebungsvariable hinzu. + +Das könnte so aussehen: + +```plaintext +/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin +``` + +Auf diese Weise, wenn Sie `python` im Terminal eingeben, findet das System das Python-Programm in `/opt/custompython/bin` (das letzte Verzeichnis) und verwendet dieses. + +//// + +//// tab | Windows + +Angenommen, Sie installieren Python und es landet in einem Verzeichnis `C:\opt\custompython\bin`. + +Wenn Sie erlauben, die `PATH` Umgebungsvariable zu aktualisieren, fügt der Installer `C:\opt\custompython\bin` zur `PATH` Umgebungsvariable hinzu. + +```plaintext +C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin +``` + +Auf diese Weise, wenn Sie `python` im Terminal eingeben, findet das System das Python-Programm in `C:\opt\custompython\bin` (das letzte Verzeichnis) und verwendet dieses. + +//// + +Also, wenn Sie tippen: + +
+ +```console +$ python +``` + +
+ +//// tab | Linux, macOS + +Das System wird das `python` Programm in `/opt/custompython/bin` **finden** und es ausführen. + +Es wäre ungefähr gleichbedeutend mit der Eingabe von: + +
+ +```console +$ /opt/custompython/bin/python +``` + +
+ +//// + +//// tab | Windows + +Das System wird das `python` Programm in `C:\opt\custompython\bin\python` **finden** und es ausführen. + +Es wäre ungefähr gleichbedeutend mit der Eingabe von: + +
+ +```console +$ C:\opt\custompython\bin\python +``` + +
+ +//// + +Diese Informationen werden nützlich sein, wenn Sie über [Virtuelle Umgebungen](virtual-environments.md){.internal-link target=_blank} lernen. + +## Fazit + +Mit diesem Wissen sollten Sie ein grundlegendes Verständnis davon haben, was **Umgebungsvariablen** sind und wie man sie in Python verwendet. + +Sie können auch mehr darüber in der Wikipedia zu Umgebungsvariablen lesen. + +In vielen Fällen ist es nicht sehr offensichtlich, wie Umgebungsvariablen nützlich und sofort anwendbar sein könnten. Aber sie tauchen immer wieder in vielen verschiedenen Szenarien auf, wenn Sie entwickeln, deshalb ist es gut, darüber Bescheid zu wissen. + +Zum Beispiel werden Sie diese Informationen im nächsten Abschnitt über [Virtuelle Umgebungen](virtual-environments.md) benötigen. diff --git a/docs/de/docs/fastapi-cli.md b/docs/de/docs/fastapi-cli.md new file mode 100644 index 000000000..5e333965c --- /dev/null +++ b/docs/de/docs/fastapi-cli.md @@ -0,0 +1,75 @@ +# FastAPI CLI + +**FastAPI CLI** ist ein Kommandozeilenprogramm, mit dem Sie Ihre FastAPI-App ausliefern, Ihr FastAPI-Projekt verwalten und mehr. + +Wenn Sie FastAPI installieren (z. B. mit `pip install "fastapi[standard]"`), wird ein Package namens `fastapi-cli` mitgeliefert, das den Befehl `fastapi` im Terminal bereitstellt. + +Um Ihre FastAPI-App für die Entwicklung auszuführen, können Sie den Befehl `fastapi dev` verwenden: + +
+ +```console +$ fastapi dev main.py + + FastAPI Starting development server 🚀 + + Searching for package file structure from directories with + __init__.py files + Importing from /home/user/code/awesomeapp + + module 🐍 main.py + + code Importing the FastAPI app object from the module with the + following code: + + from main import app + + app Using import string: main:app + + server Server started at http://127.0.0.1:8000 + server Documentation at http://127.0.0.1:8000/docs + + tip Running in development mode, for production use: + fastapi run + + Logs: + + INFO Will watch for changes in these directories: + ['/home/user/code/awesomeapp'] + INFO Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to + quit) + INFO Started reloader process [383138] using WatchFiles + INFO Started server process [383153] + INFO Waiting for application startup. + INFO Application startup complete. +``` + +
+ +Das Kommandozeilenprogramm namens `fastapi` ist die **FastAPI-CLI**. + +FastAPI-CLI nimmt den Pfad zu Ihrem Python-Programm (z. B. `main.py`), erkennt automatisch die `FastAPI`-Instanz (häufig `app` genannt), bestimmt den korrekten Importprozess und liefert diese dann aus. + +Für die Produktion würden Sie stattdessen `fastapi run` verwenden. 🚀 + +Intern verwendet die **FastAPI CLI** Uvicorn, einen leistungsstarken, produktionsreifen, ASGI-Server. 😎 + +## `fastapi dev` + +Das Ausführen von `fastapi dev` startet den Entwicklermodus. + +Standardmäßig ist **Autoreload** aktiviert, das den Server automatisch neu lädt, wenn Sie Änderungen an Ihrem Code vornehmen. Dies ist ressourcenintensiv und könnte weniger stabil sein als wenn es deaktiviert ist. Sie sollten es nur für die Entwicklung verwenden. Es horcht auch auf der IP-Adresse `127.0.0.1`, die die IP für Ihre Maschine ist, um nur mit sich selbst zu kommunizieren (`localhost`). + +## `fastapi run` + +Das Ausführen von `fastapi run` startet FastAPI standardmäßig im Produktionsmodus. + +Standardmäßig ist **Autoreload** deaktiviert. Es horcht auch auf der IP-Adresse `0.0.0.0`, was alle verfügbaren IP-Adressen bedeutet, so wird es öffentlich zugänglich für jeden, der mit der Maschine kommunizieren kann. So würden Sie es normalerweise in der Produktion ausführen, beispielsweise in einem Container. + +In den meisten Fällen würden (und sollten) Sie einen „Terminierungsproxy“ haben, der HTTPS für Sie verwaltet. Dies hängt davon ab, wie Sie Ihre Anwendung bereitstellen. Ihr Anbieter könnte dies für Sie erledigen, oder Sie müssen es selbst einrichten. + +/// tip | Tipp + +Sie können mehr darüber in der [Deployment-Dokumentation](deployment/index.md){.internal-link target=_blank} erfahren. + +/// diff --git a/docs/de/docs/how-to/testing-database.md b/docs/de/docs/how-to/testing-database.md new file mode 100644 index 000000000..feead66b5 --- /dev/null +++ b/docs/de/docs/how-to/testing-database.md @@ -0,0 +1,7 @@ +# Testen einer Datenbank + +Sie können sich über Datenbanken, SQL und SQLModel in der SQLModel-Dokumentation informieren. 🤓 + +Es gibt ein kurzes Tutorial zur Verwendung von SQLModel mit FastAPI. ✨ + +Dieses Tutorial enthält einen Abschnitt über das Testen von SQL-Datenbanken. 😎 diff --git a/docs/de/docs/tutorial/cookie-param-models.md b/docs/de/docs/tutorial/cookie-param-models.md new file mode 100644 index 000000000..5807b1ace --- /dev/null +++ b/docs/de/docs/tutorial/cookie-param-models.md @@ -0,0 +1,76 @@ +# Cookie-Parameter-Modelle + +Wenn Sie eine Gruppe von **Cookies** haben, die zusammengehören, können Sie ein **Pydantic-Modell** erstellen, um diese zu deklarieren. 🍪 + +Damit können Sie das Modell an **mehreren Stellen wiederverwenden** und auch Validierungen und Metadaten für alle Parameter gleichzeitig deklarieren. 😎 + +/// note | Hinweis + +Dies wird seit FastAPI Version `0.115.0` unterstützt. 🤓 + +/// + +/// tip | Tipp + +Diese gleiche Technik gilt für `Query`, `Cookie` und `Header`. 😎 + +/// + +## Cookies mit einem Pydantic-Modell + +Deklarieren Sie die **Cookie**-Parameter, die Sie benötigen, in einem **Pydantic-Modell**, und deklarieren Sie dann den Parameter als `Cookie`: + +{* ../../docs_src/cookie_param_models/tutorial001_an_py310.py hl[9:12,16] *} + +**FastAPI** wird die Daten für **jedes Feld** aus den im Request empfangenen **Cookies** **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell bereitstellen. + +## Die Dokumentation überprüfen + +Sie können die definierten Cookies in der Dokumentationsoberfläche unter `/docs` sehen: + +
+ +
+ +/// info | Info + +Bitte beachten Sie, dass Browser Cookies auf spezielle Weise und im Hintergrund bearbeiten, sodass sie **nicht** leicht **JavaScript** erlauben, diese zu berühren. + +Wenn Sie zur **API-Dokumentationsoberfläche** unter `/docs` gehen, können Sie die **Dokumentation** für Cookies für Ihre *Pfadoperationen* sehen. + +Aber selbst wenn Sie die **Daten ausfüllen** und auf „Ausführen“ klicken, werden aufgrund der Tatsache, dass die Dokumentationsoberfläche mit **JavaScript** arbeitet, die Cookies nicht gesendet, und Sie werden eine **Fehlermeldung** sehen, als ob Sie keine Werte eingegeben hätten. + +/// + +## Zusätzliche Cookies verbieten + +In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Cookies, die Sie empfangen möchten, **einschränken**. + +Ihre API hat jetzt die Macht, ihre eigene Cookie-Einwilligung zu kontrollieren. 🤪🍪 + +Sie können die Modellkonfiguration von Pydantic verwenden, um `extra` Felder zu verbieten (`forbid`): + +{* ../../docs_src/cookie_param_models/tutorial002_an_py39.py hl[10] *} + +Wenn ein Client versucht, einige **zusätzliche Cookies** zu senden, erhält er eine **Error-Response**. + +Arme Cookie-Banner, wie sie sich mühen, Ihre Einwilligung zu erhalten, dass die API sie ablehnen darf. 🍪 + +Wenn der Client beispielsweise versucht, ein `santa_tracker`-Cookie mit einem Wert von `good-list-please` zu senden, erhält der Client eine **Error-Response**, die ihm mitteilt, dass das `santa_tracker` Cookie nicht erlaubt ist: + +```json +{ + "detail": [ + { + "type": "extra_forbidden", + "loc": ["cookie", "santa_tracker"], + "msg": "Extra inputs are not permitted", + "input": "good-list-please", + } + ] +} +``` + +## Zusammenfassung + +Sie können **Pydantic-Modelle** verwenden, um **Cookies** in **FastAPI** zu deklarieren. 😎 diff --git a/docs/de/docs/tutorial/cors.md b/docs/de/docs/tutorial/cors.md new file mode 100644 index 000000000..57f97e98d --- /dev/null +++ b/docs/de/docs/tutorial/cors.md @@ -0,0 +1,88 @@ +# CORS (Cross-Origin Resource Sharing) + +CORS oder „Cross-Origin Resource Sharing“ (deutsch: Ursprungsübergreifende Ressourcenfreigabe) bezieht sich auf Situationen, in denen ein Frontend, das in einem Browser läuft, JavaScript-Code enthält, der mit einem Backend kommuniziert, und das Backend sich in einem anderen „Origin“ als das Frontend befindet. + +## Origin + +Ein Origin (deutsch: Ursprung) ist die Kombination aus Protokoll (`http`, `https`), Domain (`myapp.com`, `localhost`, `localhost.tiangolo.com`) und Port (`80`, `443`, `8080`). + +Alle folgenden sind also unterschiedliche Origins: + +* `http://localhost` +* `https://localhost` +* `http://localhost:8080` + +Auch wenn sie alle in `localhost` sind, verwenden sie unterschiedliche Protokolle oder Ports, daher sind sie unterschiedliche „Origins“. + +## Schritte + +Angenommen, Sie haben ein Frontend, das in Ihrem Browser unter `http://localhost:8080` läuft, und dessen JavaScript versucht, mit einem Backend zu kommunizieren, das unter `http://localhost` läuft (da wir keinen Port angegeben haben, geht der Browser vom Default-Port `80` aus). + +Dann wird der Browser ein HTTP-`OPTIONS`-Request an das `:80`-Backend senden, und wenn das Backend die entsprechenden Header sendet, die die Kommunikation von diesem anderen Origin (`http://localhost:8080`) autorisieren, lässt der `:8080`-Browser das JavaScript im Frontend seinen Request an das `:80`-Backend senden. + +Um dies zu erreichen, muss das `:80`-Backend eine Liste von „erlaubten Origins“ haben. + +In diesem Fall müsste die Liste `http://localhost:8080` enthalten, damit das `:8080`-Frontend korrekt funktioniert. + +## Wildcards + +Es ist auch möglich, die Liste als `"*"` (ein „Wildcard“) zu deklarieren, um anzuzeigen, dass alle erlaubt sind. + +Aber das erlaubt nur bestimmte Arten der Kommunikation und schließt alles aus, was Anmeldeinformationen beinhaltet: Cookies, Autorisierungsheader wie die, die mit Bearer Tokens verwendet werden, usw. + +Um sicherzustellen, dass alles korrekt funktioniert, ist es besser, die erlaubten Origins explizit anzugeben. + +## `CORSMiddleware` verwenden + +Sie können das in Ihrer **FastAPI**-Anwendung mit der `CORSMiddleware` konfigurieren. + +* Importieren Sie `CORSMiddleware`. +* Erstellen Sie eine Liste der erlaubten Origins (als Strings). +* Fügen Sie es als „Middleware“ zu Ihrer **FastAPI**-Anwendung hinzu. + +Sie können auch angeben, ob Ihr Backend erlaubt: + +* Anmeldeinformationen (Autorisierungsheader, Cookies, usw.). +* Bestimmte HTTP-Methoden (`POST`, `PUT`) oder alle mit der Wildcard `"*"`. +* Bestimmte HTTP-Header oder alle mit der Wildcard `"*"`. + +{* ../../docs_src/cors/tutorial001.py hl[2,6:11,13:19] *} + +Die von der `CORSMiddleware`-Implementierung verwendeten Defaultparameter sind standardmäßig restriktiv, daher müssen Sie bestimmte Origins, Methoden oder Header ausdrücklich aktivieren, damit Browser sie in einem Cross-Domain-Kontext verwenden dürfen. + +Die folgenden Argumente werden unterstützt: + +* `allow_origins` - Eine Liste von Origins, die Cross-Origin-Requests machen dürfen. z.B. `['https://example.org', 'https://www.example.org']`. Sie können `['*']` verwenden, um jedes Origin zuzulassen. +* `allow_origin_regex` - Ein Regex-String zum Abgleichen gegen Origins, die Cross-Origin-Requests machen dürfen. z.B. `'https://.*\.example\.org'`. +* `allow_methods` - Eine Liste von HTTP-Methoden, die für Cross-Origin-Requests erlaubt sein sollen. Standardmäßig `['GET']`. Sie können `['*']` verwenden, um alle Standardmethoden zu erlauben. +* `allow_headers` - Eine Liste von HTTP-Requestheadern, die für Cross-Origin-Requests unterstützt werden sollten. Standardmäßig `[]`. Sie können `['*']` verwenden, um alle Header zu erlauben. Die Header `Accept`, `Accept-Language`, `Content-Language` und `Content-Type` sind immer für einfache CORS-Requests erlaubt. +* `allow_credentials` - Anzeigen, dass Cookies für Cross-Origin-Requests unterstützt werden sollten. Standardmäßig `False`. + + Keines der `allow_origins`, `allow_methods` und `allow_headers` kann auf `['*']` gesetzt werden, wenn `allow_credentials` auf `True` gesetzt ist. Alle müssen explizit angegeben werden. + +* `expose_headers` - Angabe der Responseheader, auf die der Browser zugreifen können soll. Standardmäßig `[]`. +* `max_age` - Legt eine maximale Zeit in Sekunden fest, die Browser CORS-Responses zwischenspeichern dürfen. Standardmäßig `600`. + +Die Middleware antwortet auf zwei besondere Arten von HTTP-Requests... + +### CORS-Preflight-Requests + +Dies sind alle `OPTIONS`-Requests mit `Origin`- und `Access-Control-Request-Method`-Headern. + +In diesem Fall wird die Middleware den eingehenden Request abfangen und mit entsprechenden CORS-Headern, und entweder einer `200`- oder `400`-Response zu Informationszwecken antworten. + +### Einfache Requests + +Jeder Request mit einem `Origin`-Header. In diesem Fall wird die Middleware den Request wie gewohnt durchlassen, aber entsprechende CORS-Header in die Response aufnehmen. + +## Weitere Informationen + +Weitere Informationen zu CORS finden Sie in der Mozilla CORS-Dokumentation. + +/// note | Technische Details + +Sie könnten auch `from starlette.middleware.cors import CORSMiddleware` verwenden. + +**FastAPI** bietet mehrere Middlewares in `fastapi.middleware` nur als Komfort für Sie, den Entwickler. Aber die meisten der verfügbaren Middlewares stammen direkt von Starlette. + +/// diff --git a/docs/de/docs/tutorial/debugging.md b/docs/de/docs/tutorial/debugging.md new file mode 100644 index 000000000..8ce676bae --- /dev/null +++ b/docs/de/docs/tutorial/debugging.md @@ -0,0 +1,113 @@ +# Debugging + +Sie können den Debugger in Ihrem Editor verbinden, zum Beispiel mit Visual Studio Code oder PyCharm. + +## `uvicorn` aufrufen + +Importieren und führen Sie `uvicorn` direkt in Ihrer FastAPI-Anwendung aus: + +{* ../../docs_src/debugging/tutorial001.py hl[1,15] *} + +### Über `__name__ == "__main__"` + +Der Hauptzweck von `__name__ == "__main__"` ist, dass Code ausgeführt wird, wenn Ihre Datei mit folgendem Befehl aufgerufen wird: + +
+ +```console +$ python myapp.py +``` + +
+ +aber nicht ausgeführt wird, wenn eine andere Datei sie importiert, wie in diesem Fall: + +```Python +from myapp import app +``` + +#### Weitere Details + +Angenommen, Ihre Datei heißt `myapp.py`. + +Wenn Sie sie mit folgendem Befehl ausführen: + +
+ +```console +$ python myapp.py +``` + +
+ +dann hat in Ihrer Datei die interne Variable `__name__`, die automatisch von Python erstellt wird, den Wert des Strings `"__main__"`. + +Daher wird der Abschnitt: + +```Python + uvicorn.run(app, host="0.0.0.0", port=8000) +``` + +ausgeführt. + +--- + +Dies wird nicht passieren, wenn Sie das Modul (die Datei) importieren. + +Wenn Sie also eine weitere Datei `importer.py` mit folgendem Inhalt haben: + +```Python +from myapp import app + +# Hier mehr Code +``` + +wird in diesem Fall in `myapp.py` die automatisch erstellte Variable `__name__` nicht den Wert `"__main__"` haben. + +Daher wird die Zeile: + +```Python + uvicorn.run(app, host="0.0.0.0", port=8000) +``` + +nicht ausgeführt. + +/// info | Info + +Für weitere Informationen besuchen Sie bitte die offizielle Python-Dokumentation. + +/// + +## Ihren Code mit Ihrem Debugger ausführen + +Da Sie den Uvicorn-Server direkt aus Ihrem Code ausführen, können Sie Ihr Python-Programm (Ihre FastAPI-Anwendung) direkt aus dem Debugger aufrufen. + +--- + +Zum Beispiel können Sie in Visual Studio Code: + +* Zum "Debug"-Panel gehen. +* "Konfiguration hinzufügen..." auswählen. +* "Python" auswählen. +* Den Debugger mit der Option "`Python: Current File (Integrated Terminal)`" ausführen. + +Der Server wird dann mit Ihrem **FastAPI**-Code gestartet, an Ihren Haltepunkten angehalten, usw. + +So könnte es aussehen: + + + +--- + +Wenn Sie Pycharm verwenden, können Sie: + +* Das Menü "Run" öffnen. +* Die Option "Debug..." auswählen. +* Ein Kontextmenü wird angezeigt. +* Die zu debuggende Datei auswählen (in diesem Fall `main.py`). + +Der Server wird dann mit Ihrem **FastAPI**-Code gestartet, an Ihren Haltepunkten angehalten, usw. + +So könnte es aussehen: + + diff --git a/docs/de/docs/tutorial/header-param-models.md b/docs/de/docs/tutorial/header-param-models.md new file mode 100644 index 000000000..91454503e --- /dev/null +++ b/docs/de/docs/tutorial/header-param-models.md @@ -0,0 +1,72 @@ +# Header-Parameter-Modelle + +Wenn Sie eine Gruppe verwandter **Header-Parameter** haben, können Sie ein **Pydantic-Modell** erstellen, um diese zu deklarieren. + +Dadurch können Sie das **Modell an mehreren Stellen wiederverwenden** und auch Validierungen und Metadaten für alle Parameter gleichzeitig deklarieren. 😎 + +/// note | Hinweis + +Dies wird seit FastAPI Version `0.115.0` unterstützt. 🤓 + +/// + +## Header-Parameter mit einem Pydantic-Modell + +Deklarieren Sie die erforderlichen **Header-Parameter** in einem **Pydantic-Modell** und dann den Parameter als `Header`: + +{* ../../docs_src/header_param_models/tutorial001_an_py310.py hl[9:14,18] *} + +**FastAPI** wird die Daten für **jedes Feld** aus den **Headern** des Requests extrahieren und Ihnen das von Ihnen definierte Pydantic-Modell geben. + +## Die Dokumentation überprüfen + +Sie können die erforderlichen Header in der Dokumentationsoberfläche unter `/docs` sehen: + +
+ +
+ +## Zusätzliche Header verbieten + +In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die **Header einschränken**, die Sie erhalten möchten. + +Sie können Pydantics Modellkonfiguration verwenden, um `extra` Felder zu verbieten (`forbid`): + +{* ../../docs_src/header_param_models/tutorial002_an_py310.py hl[10] *} + +Wenn ein Client versucht, einige **zusätzliche Header** zu senden, erhält er eine **Error-Response**. + +Zum Beispiel, wenn der Client versucht, einen `tool`-Header mit einem Wert von `plumbus` zu senden, erhält er eine **Error-Response**, die ihm mitteilt, dass der Header-Parameter `tool` nicht erlaubt ist: + +```json +{ + "detail": [ + { + "type": "extra_forbidden", + "loc": ["header", "tool"], + "msg": "Extra inputs are not permitted", + "input": "plumbus", + } + ] +} +``` + +## Automatische Umwandlung von Unterstrichen deaktivieren + +Ähnlich wie bei regulären Header-Parametern werden bei der Verwendung von Unterstrichen in den Parameternamen diese **automatisch in Bindestriche umgewandelt**. + +Wenn Sie beispielsweise einen Header-Parameter `save_data` im Code haben, wird der erwartete HTTP-Header `save-data` sein, und er wird auch so in der Dokumentation angezeigt. + +Falls Sie aus irgendeinem Grund diese automatische Umwandlung deaktivieren müssen, können Sie dies auch für Pydantic-Modelle für Header-Parameter tun. + +{* ../../docs_src/header_param_models/tutorial003_an_py310.py hl[19] *} + +/// warning | Achtung + +Bevor Sie `convert_underscores` auf `False` setzen, bedenken Sie, dass einige HTTP-Proxies und -Server die Verwendung von Headers mit Unterstrichen nicht zulassen. + +/// + +## Zusammenfassung + +Sie können **Pydantic-Modelle** verwenden, um **Header** in **FastAPI** zu deklarieren. 😎 diff --git a/docs/de/docs/tutorial/query-param-models.md b/docs/de/docs/tutorial/query-param-models.md new file mode 100644 index 000000000..e3924da0c --- /dev/null +++ b/docs/de/docs/tutorial/query-param-models.md @@ -0,0 +1,68 @@ +# Query-Parameter-Modelle + +Wenn Sie eine Gruppe von **Query-Parametern** haben, die miteinander in Beziehung stehen, können Sie ein **Pydantic-Modell** erstellen, um diese zu deklarieren. + +Dadurch können Sie das **Modell an mehreren Stellen wiederverwenden** und gleichzeitig Validierungen und Metadaten für alle Parameter auf einmal deklarieren. 😎 + +/// note | Hinweis + +Dies wird seit FastAPI Version `0.115.0` unterstützt. 🤓 + +/// + +## Query-Parameter mit einem Pydantic-Modell + +Deklarieren Sie die benötigten **Query-Parameter** in einem **Pydantic-Modell** und dann den Parameter als `Query`: + +{* ../../docs_src/query_param_models/tutorial001_an_py310.py hl[9:13,17] *} + +**FastAPI** wird die Daten für **jedes Feld** aus den **Query-Parametern** der Anfrage extrahieren und Ihnen das definierte Pydantic-Modell bereitstellen. + +## Die Dokumentation überprüfen + +Sie können die Query-Parameter in der Dokumentations-Oberfläche unter `/docs` einsehen: + +
+ +
+ +## Zusätzliche Query-Parameter verbieten + +In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Query-Parameter, die Sie empfangen möchten, **beschränken**. + +Sie können die Modellkonfiguration von Pydantic verwenden, um jegliche `extra` Felder zu `verbieten`: + +{* ../../docs_src/query_param_models/tutorial002_an_py310.py hl[10] *} + +Wenn ein Client versucht, einige **zusätzliche** Daten in den **Query-Parametern** zu senden, erhält er eine **Error-Response**. + +Wenn der Client beispielsweise versucht, einen `tool` Query-Parameter mit dem Wert `plumbus` zu senden, wie: + +```http +https://example.com/items/?limit=10&tool=plumbus +``` + +erhält er eine **Error-Response**, die ihm mitteilt, dass der Query-Parameter `tool` nicht erlaubt ist: + +```json +{ + "detail": [ + { + "type": "extra_forbidden", + "loc": ["query", "tool"], + "msg": "Extra inputs are not permitted", + "input": "plumbus" + } + ] +} +``` + +## Zusammenfassung + +Sie können **Pydantic-Modelle** verwenden, um **Query-Parameter** in **FastAPI** zu deklarieren. 😎 + +/// tip | Tipp + +Spoiler-Alarm: Sie können auch Pydantic-Modelle verwenden, um Cookies und Header zu deklarieren, aber darüber werden Sie später im Tutorial lesen. 🤫 + +/// diff --git a/docs/de/docs/tutorial/request-form-models.md b/docs/de/docs/tutorial/request-form-models.md new file mode 100644 index 000000000..65c54494f --- /dev/null +++ b/docs/de/docs/tutorial/request-form-models.md @@ -0,0 +1,78 @@ +# Formularmodelle + +Sie können **Pydantic-Modelle** verwenden, um **Formularfelder** in FastAPI zu deklarieren. + +/// info | Info + +Um Formulare zu verwenden, installieren Sie zuerst `python-multipart`. + +Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und es dann installieren, zum Beispiel: + +```console +$ pip install python-multipart +``` + +/// + +/// note | Hinweis + +Dies wird seit FastAPI Version `0.113.0` unterstützt. 🤓 + +/// + +## Pydantic-Modelle für Formulare + +Sie müssen nur ein **Pydantic-Modell** mit den Feldern deklarieren, die Sie als **Formularfelder** erhalten möchten, und dann den Parameter als `Form` deklarieren: + +{* ../../docs_src/request_form_models/tutorial001_an_py39.py hl[9:11,15] *} + +**FastAPI** wird die Daten für **jedes Feld** aus den **Formulardaten** in der Anfrage **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell übergeben. + +## Die Dokumentation überprüfen + +Sie können dies in der Dokumentations-UI unter `/docs` überprüfen: + +
+ +
+ +## Zusätzliche Formularfelder verbieten + +In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Formularfelder auf nur diejenigen beschränken, die im Pydantic-Modell deklariert sind, und jegliche **zusätzlichen** Felder **verbieten**. + +/// note | Hinweis + +Dies wird seit FastAPI Version `0.114.0` unterstützt. 🤓 + +/// + +Sie können die Modellkonfiguration von Pydantic verwenden, um jegliche `extra` Felder zu `verbieten`: + +{* ../../docs_src/request_form_models/tutorial002_an_py39.py hl[12] *} + +Wenn ein Client versucht, einige zusätzliche Daten zu senden, erhält er eine **Error-Response**. + +Zum Beispiel, wenn der Client versucht, folgende Formularfelder zu senden: + +* `username`: `Rick` +* `password`: `Portal Gun` +* `extra`: `Mr. Poopybutthole` + +erhält er eine Error-Response, die ihm mitteilt, dass das Feld `extra` nicht erlaubt ist: + +```json +{ + "detail": [ + { + "type": "extra_forbidden", + "loc": ["body", "extra"], + "msg": "Extra inputs are not permitted", + "input": "Mr. Poopybutthole" + } + ] +} +``` + +## Zusammenfassung + +Sie können Pydantic-Modelle verwenden, um Formularfelder in FastAPI zu deklarieren. 😎 diff --git a/docs/de/docs/tutorial/sql-databases.md b/docs/de/docs/tutorial/sql-databases.md new file mode 100644 index 000000000..6bd24e2d4 --- /dev/null +++ b/docs/de/docs/tutorial/sql-databases.md @@ -0,0 +1,357 @@ +# SQL (Relationale) Datenbanken + +**FastAPI** erfordert nicht, dass Sie eine SQL (relationale) Datenbank verwenden. Sondern Sie können **jede beliebige Datenbank** verwenden, die Sie möchten. + +Hier werden wir ein Beispiel mit SQLModel sehen. + +**SQLModel** basiert auf SQLAlchemy und Pydantic. Es wurde vom selben Autor wie **FastAPI** entwickelt, um die perfekte Ergänzung für FastAPI-Anwendungen zu sein, die **SQL-Datenbanken** verwenden müssen. + +/// tip | Tipp + +Sie könnten jede andere SQL- oder NoSQL-Datenbankbibliothek verwenden, die Sie möchten (in einigen Fällen als „ORMs“ bezeichnet), FastAPI zwingt Sie nicht, irgendetwas zu verwenden. 😎 + +/// + +Da SQLModel auf SQLAlchemy basiert, können Sie problemlos **jede von SQLAlchemy unterstützte Datenbank** verwenden (was auch bedeutet, dass sie von SQLModel unterstützt werden), wie: + +* PostgreSQL +* MySQL +* SQLite +* Oracle +* Microsoft SQL Server, usw. + +In diesem Beispiel verwenden wir **SQLite**, da es eine einzelne Datei verwendet und Python integrierte Unterstützung bietet. Sie können also dieses Beispiel kopieren und direkt ausführen. + +Später, für Ihre Produktionsanwendung, möchten Sie möglicherweise einen Datenbankserver wie **PostgreSQL** verwenden. + +/// tip | Tipp + +Es gibt einen offiziellen Projektgenerator mit **FastAPI** und **PostgreSQL**, einschließlich eines Frontends und weiterer Tools: https://github.com/fastapi/full-stack-fastapi-template + +/// + +Dies ist ein sehr einfaches und kurzes Tutorial. Wenn Sie mehr über Datenbanken im Allgemeinen, über SQL oder fortgeschrittenere Funktionen erfahren möchten, besuchen Sie die SQLModel-Dokumentation. + +## `SQLModel` installieren + +Stellen Sie zunächst sicher, dass Sie Ihre [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und dann `sqlmodel` installieren: + +
+ +```console +$ pip install sqlmodel +---> 100% +``` + +
+ +## Die App mit einem einzelnen Modell erstellen + +Wir erstellen zuerst die einfachste erste Version der App mit einem einzigen **SQLModel**-Modell. + +Später werden wir sie verbessern, indem wir unter der Haube **mehrere Modelle** verwenden, um Sicherheit und Vielseitigkeit zu erhöhen. 🤓 + +### Modelle erstellen + +Importieren Sie `SQLModel` und erstellen Sie ein Datenbankmodell: + +{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[1:11] hl[7:11] *} + +Die `Hero`-Klasse ist einem Pydantic-Modell sehr ähnlich (faktisch ist sie darunter tatsächlich *ein Pydantic-Modell*). + +Es gibt ein paar Unterschiede: + +* `table=True` sagt SQLModel, dass dies ein *Tabellenmodell* ist, es soll eine **Tabelle** in der SQL-Datenbank darstellen, es ist nicht nur ein *Datenmodell* (wie es jede andere reguläre Pydantic-Klasse wäre). + +* `Field(primary_key=True)` sagt SQLModel, dass die `id` der **Primärschlüssel** in der SQL-Datenbank ist (Sie können mehr über SQL-Primärschlüssel in der SQLModel-Dokumentation erfahren). + + Durch das Festlegen des Typs als `int | None` wird SQLModel wissen, dass diese Spalte ein `INTEGER` in der SQL-Datenbank sein sollte und dass sie `NULLABLE` sein sollte. + +* `Field(index=True)` sagt SQLModel, dass es einen **SQL-Index** für diese Spalte erstellen soll, was schnelleres Suchen in der Datenbank ermöglicht, wenn Daten mittels dieser Spalte gefiltert werden. + + SQLModel wird verstehen, dass etwas, das als `str` deklariert ist, eine SQL-Spalte des Typs `TEXT` (oder `VARCHAR`, abhängig von der Datenbank) sein wird. + +### Eine Engine erstellen + +Eine SQLModel-`engine` (darunter ist es tatsächlich eine SQLAlchemy-`engine`) ist das, was die **Verbindungen** zur Datenbank hält. + +Sie hätten **ein einziges `engine`-Objekt** für Ihren gesamten Code, um sich mit derselben Datenbank zu verbinden. + +{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[14:18] hl[14:15,17:18] *} + +Die Verwendung von `check_same_thread=False` erlaubt FastAPI, dieselbe SQLite-Datenbank in verschiedenen Threads zu verwenden. Dies ist notwendig, da **eine einzelne Anfrage** **mehr als einen Thread** verwenden könnte (zum Beispiel in Abhängigkeiten). + +Keine Sorge, so wie der Code strukturiert ist, werden wir später sicherstellen, dass wir **eine einzige SQLModel-*Session* pro Anfrage** verwenden, das ist eigentlich das, was `check_same_thread` erreichen möchte. + +### Die Tabellen erstellen + +Dann fügen wir eine Funktion hinzu, die `SQLModel.metadata.create_all(engine)` verwendet, um die **Tabellen für alle *Tabellenmodelle* zu erstellen**. + +{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[21:22] hl[21:22] *} + +### Eine Session-Abhängigkeit erstellen + +Eine **`Session`** (deutsch: Sitzung) speichert die **Objekte im Speicher** und verfolgt alle Änderungen, die an den Daten vorgenommen werden müssen, dann **verwendet sie die `engine`**, um mit der Datenbank zu kommunizieren. + +Wir werden eine FastAPI **Abhängigkeit** mit `yield` erstellen, die eine neue `Session` für jede Anfrage bereitstellt. Das ist es, was sicherstellt, dass wir eine einzige Session pro Anfrage verwenden. 🤓 + +Dann erstellen wir eine `Annotated`-Abhängigkeit `SessionDep`, um den Rest des Codes zu vereinfachen, der diese Abhängigkeit nutzen wird. + +{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[25:30] hl[25:27,30] *} + +### Erstellen Sie die Datenbanktabellen beim Start + +Wir werden die Datenbanktabellen erstellen, wenn die Anwendung startet. + +{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[32:37] hl[35:37] *} + +Hier erstellen wir die Tabellen bei einem Anwendungsstart-Event. + +Für die Produktion würden Sie wahrscheinlich ein Migrationsskript verwenden, das ausgeführt wird, bevor Sie Ihre App starten. 🤓 + +/// tip | Tipp + +SQLModel wird Migrationstools haben, die Alembic wrappen, aber im Moment können Sie Alembic direkt verwenden. + +/// + +### Einen Helden erstellen + +Da jedes SQLModel-Modell auch ein Pydantic-Modell ist, können Sie es in denselben **Typ-Annotationen** verwenden, die Sie für Pydantic-Modelle verwenden könnten. + +Wenn Sie beispielsweise einen Parameter vom Typ `Hero` deklarieren, wird er aus dem **JSON-Body** gelesen. + +Auf die gleiche Weise können Sie es als **Rückgabetyp** der Funktion deklarieren, und dann wird die Form der Daten in der automatischen API-Dokumentation angezeigt. + +{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[40:45] hl[40:45] *} + +Hier verwenden wir die `SessionDep`-Abhängigkeit (eine `Session`), um den neuen `Hero` zur `Session`-Instanz hinzuzufügen, die Änderungen an der Datenbank zu committen, die Daten im `hero` zu aktualisieren und ihn anschließend zurückzugeben. + +### Helden lesen + +Wir können `Hero`s aus der Datenbank mit einem `select()` **lesen**. Wir können ein `limit` und `offset` hinzufügen, um die Ergebnisse zu paginieren. + +{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[48:55] hl[51:52,54] *} + +### Einen Helden lesen + +Wir können einen einzelnen `Hero` **lesen**. + +{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[58:63] hl[60] *} + +### Einen Helden löschen + +Wir können auch einen `Hero` **löschen**. + +{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[66:73] hl[71] *} + +### Die App ausführen + +Sie können die App ausführen: + +
+ +```console +$ fastapi dev main.py + +INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) +``` + +
+ +Gehen Sie dann zur `/docs`-UI, Sie werden sehen, dass **FastAPI** diese **Modelle** verwendet, um die API zu **dokumentieren**, und es wird sie auch verwenden, um die Daten zu **serialisieren** und zu **validieren**. + +
+ +
+ +## Die App mit mehreren Modellen aktualisieren + +Jetzt lassen Sie uns diese App ein wenig **refaktorisieren**, um die **Sicherheit** und **Vielseitigkeit** zu erhöhen. + +Wenn Sie die vorherige App überprüfen, können Sie in der UI sehen, dass sie bis jetzt dem Client erlaubt, die `id` des zu erstellenden `Hero` zu bestimmen. 😱 + +Das sollten wir nicht zulassen, sie könnten eine `id` überschreiben, die wir bereits in der DB zugewiesen haben. Die Entscheidung über die `id` sollte vom **Backend** oder der **Datenbank** getroffen werden, **nicht vom Client**. + +Außerdem erstellen wir einen `secret_name` für den Helden, aber bisher geben wir ihn überall zurück, das ist nicht sehr **geheim**... 😅 + +Wir werden diese Dinge beheben, indem wir ein paar **zusätzliche Modelle** hinzufügen. Hier wird SQLModel glänzen. ✨ + +### Mehrere Modelle erstellen + +In **SQLModel** ist jede Modellklasse, die `table=True` hat, ein **Tabellenmodell**. + +Und jede Modellklasse, die `table=True` nicht hat, ist ein **Datenmodell**, diese sind tatsächlich nur Pydantic-Modelle (mit ein paar kleinen zusätzlichen Funktionen). 🤓 + +Mit SQLModel können wir **Vererbung** verwenden, um **doppelte Felder** in allen Fällen zu **vermeiden**. + +#### `HeroBase` - die Basisklasse + +Fangen wir mit einem `HeroBase`-Modell an, das alle **Felder hat, die von allen Modellen geteilt werden**: + +* `name` +* `age` + +{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:9] hl[7:9] *} + +#### `Hero` - das *Tabellenmodell* + +Dann erstellen wir `Hero`, das tatsächliche *Tabellenmodell*, mit den **zusätzlichen Feldern**, die nicht immer in den anderen Modellen enthalten sind: + +* `id` +* `secret_name` + +Da `Hero` von `HeroBase` erbt, hat es **auch** die **Felder**, die in `HeroBase` deklariert sind, also sind alle Felder von `Hero`: + +* `id` +* `name` +* `age` +* `secret_name` + +{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:14] hl[12:14] *} + +#### `HeroPublic` - das öffentliche *Datenmodell* + +Als nächstes erstellen wir ein `HeroPublic`-Modell, das an die API-Clients **zurückgegeben** wird. + +Es hat dieselben Felder wie `HeroBase`, sodass es `secret_name` nicht enthält. + +Endlich ist die Identität unserer Helden geschützt! 🥷 + +Es deklariert auch `id: int` erneut. Indem wir dies tun, machen wir einen **Vertrag** mit den API-Clients, damit sie immer damit rechnen können, dass die `id` vorhanden ist und ein `int` ist (sie wird niemals `None` sein). + +/// tip | Tipp + +Es ist sehr nützlich für die API-Clients, wenn das Rückgabemodell sicherstellt, dass ein Wert immer verfügbar und immer `int` (nicht `None`) ist, sie können viel einfacheren Code schreiben, wenn sie diese Sicherheit haben. + +Auch **automatisch generierte Clients** werden einfachere Schnittstellen haben, damit die Entwickler, die mit Ihrer API kommunizieren, viel mehr Freude an der Arbeit mit Ihrer API haben können. 😎 + +/// + +Alle Felder in `HeroPublic` sind dieselben wie in `HeroBase`, mit `id`, das als `int` (nicht `None`) deklariert ist: + +* `id` +* `name` +* `age` + +{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:18] hl[17:18] *} + +#### `HeroCreate` - das *Datenmodell* zum Erstellen eines Helden + +Nun erstellen wir ein `HeroCreate`-Modell, das die Daten der Clients **validiert**. + +Es hat dieselben Felder wie `HeroBase`, und es hat auch `secret_name`. + +Wenn die Clients **einen neuen Helden erstellen**, senden sie jetzt den `secret_name`, er wird in der Datenbank gespeichert, aber diese geheimen Namen werden den API-Clients nicht zurückgegeben. + +/// tip | Tipp + +So würden Sie **Passwörter** handhaben. Empfangen Sie sie, aber geben Sie sie nicht in der API zurück. + +Sie würden auch die Werte der Passwörter **hashen**, bevor Sie sie speichern, und sie **niemals im Klartext** speichern. + +/// + +Die Felder von `HeroCreate` sind: + +* `name` +* `age` +* `secret_name` + +{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:22] hl[21:22] *} + +#### `HeroUpdate` - das *Datenmodell* zum Aktualisieren eines Helden + +In der vorherigen Version der App hatten wir keine Möglichkeit, einen Helden **zu aktualisieren**, aber jetzt mit **mehreren Modellen** können wir es. 🎉 + +Das `HeroUpdate`-*Datenmodell* ist etwas Besonderes, es hat **die selben Felder**, die benötigt werden, um einen neuen Helden zu erstellen, aber alle Felder sind **optional** (sie haben alle einen Defaultwert). Auf diese Weise, wenn Sie einen Helden aktualisieren, können Sie nur die Felder senden, die Sie aktualisieren möchten. + +Da sich tatsächlich **alle Felder ändern** (der Typ enthält jetzt `None` und sie haben jetzt einen Standardwert von `None`), müssen wir sie erneut **deklarieren**. + +Wir müssen wirklich nicht von `HeroBase` erben, weil wir alle Felder neu deklarieren. Ich lasse es aus Konsistenzgründen erben, aber das ist nicht notwendig. Es ist mehr eine Frage des persönlichen Geschmacks. 🤷 + +Die Felder von `HeroUpdate` sind: + +* `name` +* `age` +* `secret_name` + +{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:28] hl[25:28] *} + +### Mit `HeroCreate` erstellen und ein `HeroPublic` zurückgeben + +Nun, da wir **mehrere Modelle** haben, können wir die Teile der App aktualisieren, die sie verwenden. + +Wir empfangen im Request ein `HeroCreate`-*Datenmodell* und daraus erstellen wir ein `Hero`-*Tabellenmodell*. + +Dieses neue *Tabellenmodell* `Hero` wird die vom Client gesendeten Felder haben und zusätzlich eine `id`, die von der Datenbank generiert wird. + +Dann geben wir das gleiche *Tabellenmodell* `Hero` von der Funktion zurück. Aber da wir das `response_model` mit dem `HeroPublic`-*Datenmodell* deklarieren, wird **FastAPI** `HeroPublic` verwenden, um die Daten zu validieren und zu serialisieren. + +{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[56:62] hl[56:58] *} + +/// tip | Tipp + +Jetzt verwenden wir `response_model=HeroPublic` anstelle der **Rückgabetyp-Annotation** `-> HeroPublic`, weil der Wert, den wir zurückgeben, tatsächlich *kein* `HeroPublic` ist. + +Wenn wir `-> HeroPublic` deklariert hätten, würden Ihr Editor und Linter (zu Recht) reklamieren, dass Sie ein `Hero` anstelle eines `HeroPublic` zurückgeben. + +Durch die Deklaration in `response_model` sagen wir **FastAPI**, dass es seine Aufgabe erledigen soll, ohne die Typannotationen und die Hilfe von Ihrem Editor und anderen Tools zu beeinträchtigen. + +/// + +### Helden mit `HeroPublic` lesen + +Wir können dasselbe wie zuvor tun, um `Hero`s zu **lesen**, und erneut verwenden wir `response_model=list[HeroPublic]`, um sicherzustellen, dass die Daten ordnungsgemäß validiert und serialisiert werden. + +{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[65:72] hl[65] *} + +### Einen einzelnen Helden mit `HeroPublic` lesen + +Wir können einen einzelnen Helden **lesen**: + +{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[75:80] hl[77] *} + +### Einen Helden mit `HeroUpdate` aktualisieren + +Wir können einen Helden **aktualisieren**. Dafür verwenden wir eine HTTP-`PATCH`-Operation. + +Und im Code erhalten wir ein `dict` mit allen Daten, die vom Client gesendet wurden, **nur die Daten, die vom Client gesendet wurden**, unter Ausschluss von Werten, die dort nur als Defaultwerte vorhanden wären. Um dies zu tun, verwenden wir `exclude_unset=True`. Das ist der Haupttrick. 🪄 + +Dann verwenden wir `hero_db.sqlmodel_update(hero_data)`, um die `hero_db` mit den Daten aus `hero_data` zu aktualisieren. + +{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[83:93] hl[83:84,88:89] *} + +### Einen Helden wieder löschen + +Das **Löschen** eines Helden bleibt ziemlich gleich. + +Wir werden dieses Mal nicht dem Wunsch nachgeben, alles zu refaktorisieren. 😅 + +{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[96:103] hl[101] *} + +### Führen Sie die App erneut aus + +Sie können die App erneut ausführen: + +
+ +```console +$ fastapi dev main.py + +INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) +``` + +
+ +Wenn Sie zur `/docs`-API-UI gehen, werden Sie sehen, dass sie jetzt aktualisiert ist und nicht mehr erwarten wird, die `id` vom Client beim Erstellen eines Helden zu erhalten, usw. + +
+ +
+ +## Zusammenfassung + +Sie können **SQLModel** verwenden, um mit einer SQL-Datenbank zu interagieren und den Code mit *Datenmodellen* und *Tabellenmodellen* zu vereinfachen. + +Sie können viel mehr in der **SQLModel**-Dokumentation lernen, es gibt ein längeres Mini-Tutorial zur Verwendung von SQLModel mit **FastAPI**. 🚀 diff --git a/docs/de/docs/virtual-environments.md b/docs/de/docs/virtual-environments.md new file mode 100644 index 000000000..b30278322 --- /dev/null +++ b/docs/de/docs/virtual-environments.md @@ -0,0 +1,842 @@ +# Virtuelle Umgebungen + +Wenn Sie an Python-Projekten arbeiten, sollten Sie wahrscheinlich eine **virtuelle Umgebung** (oder einen ähnlichen Mechanismus) verwenden, um die Pakete(englisch: Packages), die Sie für jedes Projekt installieren, zu isolieren. + +/// info | Info + +Wenn Sie bereits über virtuelle Umgebungen Bescheid wissen, wie man sie erstellt und verwendet, möchten Sie diesen Abschnitt vielleicht überspringen. 🤓 + +/// + +/// tip | Tipp + +Eine **virtuelle Umgebung** unterscheidet sich von einer **Umgebungsvariable**. + +Eine **Umgebungsvariable** ist eine Variable im System, die von Programmen verwendet werden kann. + +Eine **virtuelle Umgebung** ist ein Verzeichnis mit einigen Dateien darin. + +/// + +/// info | Info + +Diese Seite wird Ihnen beibringen, wie Sie **virtuelle Umgebungen** verwenden und wie sie funktionieren. + +Wenn Sie bereit sind, ein **Tool zu verwenden, das alles für Sie verwaltet** (einschließlich der Installation von Python), probieren Sie uv. + +/// + +## Ein Projekt erstellen + +Erstellen Sie zuerst ein Verzeichnis für Ihr Projekt. + +Was ich normalerweise mache, ist, dass ich ein Verzeichnis namens `code` in meinem Home/Benutzerverzeichnis erstelle. + +Und darin erstelle ich ein Verzeichnis pro Projekt. + +
+ +```console +// Zum Home-Verzeichnis wechseln +$ cd +// Ein Verzeichnis für alle Ihre Codeprojekte erstellen +$ mkdir code +// In dieses Codeverzeichnis gehen +$ cd code +// Ein Verzeichnis für dieses Projekt erstellen +$ mkdir awesome-project +// In dieses Projektverzeichnis gehen +$ cd awesome-project +``` + +
+ +## Eine virtuelle Umgebung erstellen + +Wenn Sie zum **ersten Mal** an einem Python-Projekt arbeiten, erstellen Sie eine virtuelle Umgebung **innerhalb Ihres Projekts**. + +/// tip | Tipp + +Sie müssen dies nur **einmal pro Projekt** tun, nicht jedes Mal, wenn Sie daran arbeiten. + +/// + +//// tab | `venv` + +Um eine virtuelle Umgebung zu erstellen, können Sie das `venv`-Modul verwenden, das mit Python geliefert wird. + +
+ +```console +$ python -m venv .venv +``` + +
+ +/// details | Was dieser Befehl bedeutet + +* `python`: das Programm namens `python` verwenden +* `-m`: ein Modul als Skript aufrufen, wir geben als nächstes an, welches Modul +* `venv`: das Modul namens `venv` verwenden, das normalerweise mit Python installiert wird +* `.venv`: die virtuelle Umgebung im neuen Verzeichnis `.venv` erstellen + +/// + +//// + +//// tab | `uv` + +Wenn Sie `uv` installiert haben, können Sie es verwenden, um eine virtuelle Umgebung zu erstellen. + +
+ +```console +$ uv venv +``` + +
+ +/// tip | Tipp + +Standardmäßig erstellt `uv` eine virtuelle Umgebung in einem Verzeichnis namens `.venv`. + +Aber Sie könnten es anpassen, indem Sie ein zusätzliches Argument mit dem Verzeichnisnamen übergeben. + +/// + +//// + +Dieser Befehl erstellt eine neue virtuelle Umgebung in einem Verzeichnis namens `.venv`. + +/// details | `.venv` oder ein anderer Name + +Sie könnten die virtuelle Umgebung in einem anderen Verzeichnis erstellen, aber es ist eine Konvention, sie `.venv` zu nennen. + +/// + +## Die virtuelle Umgebung aktivieren + +Aktivieren Sie die neue virtuelle Umgebung, damit jeder Python-Befehl, den Sie ausführen oder jedes Paket, das Sie installieren, diese Umgebung verwendet. + +/// tip | Tipp + +Tun Sie dies **jedes Mal**, wenn Sie eine **neue Terminalsitzung** starten, um an dem Projekt zu arbeiten. + +/// + +//// tab | Linux, macOS + +
+ +```console +$ source .venv/bin/activate +``` + +
+ +//// + +//// tab | Windows PowerShell + +
+ +```console +$ .venv\Scripts\Activate.ps1 +``` + +
+ +//// + +//// tab | Windows Bash + +Oder wenn Sie Bash für Windows verwenden (z.B. Git Bash): + +
+ +```console +$ source .venv/Scripts/activate +``` + +
+ +//// + +/// tip | Tipp + +Jedes Mal, wenn Sie ein **neues Paket** in dieser Umgebung installieren, aktivieren Sie die Umgebung erneut. + +So stellen Sie sicher, dass, wenn Sie ein **Terminalprogramm (CLI)** verwenden, das durch dieses Paket installiert wurde, Sie das aus Ihrer virtuellen Umgebung verwenden und nicht eines, das global installiert ist, wahrscheinlich mit einer anderen Version als der, die Sie benötigen. + +/// + +## Überprüfen, ob die virtuelle Umgebung aktiv ist + +Überprüfen Sie, dass die virtuelle Umgebung aktiv ist (der vorherige Befehl funktioniert hat). + +/// tip | Tipp + +Dies ist **optional**, aber es ist eine gute Möglichkeit, **zu überprüfen**, ob alles wie erwartet funktioniert und Sie die beabsichtigte virtuelle Umgebung verwenden. + +/// + +//// tab | Linux, macOS, Windows Bash + +
+ +```console +$ which python + +/home/user/code/awesome-project/.venv/bin/python +``` + +
+ +Wenn es das `python`-Binary in `.venv/bin/python` anzeigt, innerhalb Ihres Projekts (in diesem Fall `awesome-project`), dann hat es funktioniert. 🎉 + +//// + +//// tab | Windows PowerShell + +
+ +```console +$ Get-Command python + +C:\Users\user\code\awesome-project\.venv\Scripts\python +``` + +
+ +Wenn es das `python`-Binary in `.venv\Scripts\python` anzeigt, innerhalb Ihres Projekts (in diesem Fall `awesome-project`), dann hat es funktioniert. 🎉 + +//// + +## `pip` aktualisieren + +/// tip | Tipp + +Wenn Sie `uv` verwenden, würden Sie das verwenden, um Dinge zu installieren anstelle von `pip`, sodass Sie `pip` nicht aktualisieren müssen. 😎 + +/// + +Wenn Sie `pip` verwenden, um Pakete zu installieren (es wird standardmäßig mit Python geliefert), sollten Sie es auf die neueste Version **aktualisieren**. + +Viele exotische Fehler beim Installieren eines Pakets werden einfach dadurch gelöst, dass zuerst `pip` aktualisiert wird. + +/// tip | Tipp + +Normalerweise würden Sie dies **einmal** tun, unmittelbar nachdem Sie die virtuelle Umgebung erstellt haben. + +/// + +Stellen Sie sicher, dass die virtuelle Umgebung aktiv ist (mit dem obigen Befehl) und führen Sie dann aus: + +
+ +```console +$ python -m pip install --upgrade pip + +---> 100% +``` + +
+ +## `.gitignore` hinzufügen + +Wenn Sie **Git** verwenden (was Sie sollten), fügen Sie eine `.gitignore`-Datei hinzu, um alles in Ihrem `.venv` von Git auszuschließen. + +/// tip | Tipp + +Wenn Sie `uv` verwendet haben, um die virtuelle Umgebung zu erstellen, hat es dies bereits für Sie getan, Sie können diesen Schritt überspringen. 😎 + +/// + +/// tip | Tipp + +Tun Sie dies **einmal**, unmittelbar nachdem Sie die virtuelle Umgebung erstellt haben. + +/// + +
+ +```console +$ echo "*" > .venv/.gitignore +``` + +
+ +/// details | Was dieser Befehl bedeutet + +* `echo "*"`: wird den Text `*` im Terminal „drucken“ (der nächste Teil ändert das ein wenig) +* `>`: alles, was durch den Befehl links von `>` im Terminal ausgegeben wird, sollte nicht gedruckt, sondern stattdessen in die Datei geschrieben werden, die rechts von `>` kommt +* `.gitignore`: der Name der Datei, in die der Text geschrieben werden soll + +Und `*` bedeutet für Git „alles“. Also wird alles im `.venv`-Verzeichnis ignoriert. + +Dieser Befehl erstellt eine Datei `.gitignore` mit dem Inhalt: + +```gitignore +* +``` + +/// + +## Pakete installieren + +Nachdem Sie die Umgebung aktiviert haben, können Sie Pakete darin installieren. + +/// tip | Tipp + +Tun Sie dies **einmal**, wenn Sie die Pakete installieren oder aktualisieren, die Ihr Projekt benötigt. + +Wenn Sie eine Version aktualisieren oder ein neues Paket hinzufügen müssen, würden Sie **dies erneut tun**. + +/// + +### Pakete direkt installieren + +Wenn Sie es eilig haben und keine Datei verwenden möchten, um die Paketanforderungen Ihres Projekts zu deklarieren, können Sie sie direkt installieren. + +/// tip | Tipp + +Es ist eine (sehr) gute Idee, die Pakete und Versionen, die Ihr Programm benötigt, in einer Datei zu speichern (zum Beispiel `requirements.txt` oder `pyproject.toml`). + +/// + +//// tab | `pip` + +
+ +```console +$ pip install "fastapi[standard]" + +---> 100% +``` + +
+ +//// + +//// tab | `uv` + +Wenn Sie `uv` haben: + +
+ +```console +$ uv pip install "fastapi[standard]" +---> 100% +``` + +
+ +//// + +### Installation von `requirements.txt` + +Wenn Sie eine `requirements.txt` haben, können Sie diese nun verwenden, um deren Pakete zu installieren. + +//// tab | `pip` + +
+ +```console +$ pip install -r requirements.txt +---> 100% +``` + +
+ +//// + +//// tab | `uv` + +Wenn Sie `uv` haben: + +
+ +```console +$ uv pip install -r requirements.txt +---> 100% +``` + +
+ +//// + +/// details | `requirements.txt` + +Eine `requirements.txt` mit einigen Paketen könnte folgendermaßen aussehen: + +```requirements.txt +fastapi[standard]==0.113.0 +pydantic==2.8.0 +``` + +/// + +## Ihr Programm ausführen + +Nachdem Sie die virtuelle Umgebung aktiviert haben, können Sie Ihr Programm ausführen, und es wird das Python innerhalb Ihrer virtuellen Umgebung mit den Paketen verwenden, die Sie dort installiert haben. + +
+ +```console +$ python main.py + +Hello World +``` + +
+ +## Ihren Editor konfigurieren + +Sie würden wahrscheinlich einen Editor verwenden, stellen Sie sicher, dass Sie ihn so konfigurieren, dass er die gleiche virtuelle Umgebung verwendet, die Sie erstellt haben (er wird sie wahrscheinlich automatisch erkennen), sodass Sie Autovervollständigungen und Inline-Fehler erhalten können. + +Zum Beispiel: + +* VS Code +* PyCharm + +/// tip | Tipp + +Normalerweise müssen Sie dies nur **einmal** tun, wenn Sie die virtuelle Umgebung erstellen. + +/// + +## Die virtuelle Umgebung deaktivieren + +Sobald Sie mit der Arbeit an Ihrem Projekt fertig sind, können Sie die virtuelle Umgebung **deaktivieren**. + +
+ +```console +$ deactivate +``` + +
+ +Auf diese Weise, wenn Sie `python` ausführen, wird nicht versucht, es aus dieser virtuellen Umgebung mit den dort installierten Paketen auszuführen. + +## Bereit zu arbeit + +Jetzt sind Sie bereit, mit Ihrem Projekt zu arbeiten. + +/// tip | Tipp + +Möchten Sie verstehen, was das alles oben bedeutet? + +Lesen Sie weiter. 👇🤓 + +/// + +## Warum virtuelle Umgebungen + +Um mit FastAPI zu arbeiten, müssen Sie Python installieren. + +Danach müssen Sie FastAPI und alle anderen Pakete, die Sie verwenden möchten, **installieren**. + +Um Pakete zu installieren, würden Sie normalerweise den `pip` Befehl verwenden, der mit Python geliefert wird (oder ähnliche Alternativen). + +Wenn Sie jedoch `pip` direkt verwenden, werden die Pakete in Ihrer **globalen Python-Umgebung** (der globalen Installation von Python) installiert. + +### Das Problem + +Was ist also das Problem beim Installieren von Paketen in der globalen Python-Umgebung? + +Irgendwann werden Sie wahrscheinlich viele verschiedene Programme schreiben, die von **verschiedenen Paketen** abhängen. Und einige dieser Projekte, an denen Sie arbeiten, werden von **verschiedenen Versionen** desselben Pakets abhängen. 😱 + +Zum Beispiel könnten Sie ein Projekt namens `philosophers-stone` erstellen, dieses Programm hängt von einem anderen Paket namens **`harry`, Version `1`** ab. Also müssen Sie `harry` installieren. + +```mermaid +flowchart LR + stone(philosophers-stone) -->|benötigt| harry-1[harry v1] +``` + +Dann erstellen Sie zu einem späteren Zeitpunkt ein weiteres Projekt namens `prisoner-of-azkaban`, und dieses Projekt hängt ebenfalls von `harry` ab, aber dieses Projekt benötigt **`harry` Version `3`**. + +```mermaid +flowchart LR + azkaban(prisoner-of-azkaban) --> |benötigt| harry-3[harry v3] +``` + +Aber jetzt ist das Problem, wenn Sie die Pakete global (in der globalen Umgebung) installieren anstatt in einer lokalen **virtuellen Umgebung**, müssen Sie wählen, welche Version von `harry` zu installieren ist. + +Wenn Sie `philosophers-stone` ausführen möchten, müssen Sie zuerst `harry` Version `1` installieren, zum Beispiel mit: + +
+ +```console +$ pip install "harry==1" +``` + +
+ +Und dann hätten Sie `harry` Version `1` in Ihrer globalen Python-Umgebung installiert. + +```mermaid +flowchart LR + subgraph global[globale Umgebung] + harry-1[harry v1] + end + subgraph stone-project[philosophers-stone Projekt] + stone(philosophers-stone) -->|benötigt| harry-1 + end +``` + +Aber dann, wenn Sie `prisoner-of-azkaban` ausführen möchten, müssen Sie `harry` Version `1` deinstallieren und `harry` Version `3` installieren (oder einfach die Version `3` installieren, was die Version `1` automatisch deinstallieren würde). + +
+ +```console +$ pip install "harry==3" +``` + +
+ +Und dann hätten Sie `harry` Version `3` in Ihrer globalen Python-Umgebung installiert. + +Und wenn Sie versuchen, `philosophers-stone` erneut auszuführen, besteht die Möglichkeit, dass es **nicht funktioniert**, weil es `harry` Version `1` benötigt. + +```mermaid +flowchart LR + subgraph global[globale Umgebung] + harry-1[harry v1] + style harry-1 fill:#ccc,stroke-dasharray: 5 5 + harry-3[harry v3] + end + subgraph stone-project[philosophers-stone Projekt] + stone(philosophers-stone) -.-x|⛔️| harry-1 + end + subgraph azkaban-project[prisoner-of-azkaban Projekt] + azkaban(prisoner-of-azkaban) --> |benötigt| harry-3 + end +``` + +/// tip | Tipp + +Es ist sehr üblich in Python-Paketen, alles zu versuchen, **Breaking Changes** in **neuen Versionen** zu vermeiden, aber es ist besser, auf Nummer sicher zu gehen und neue Versionen absichtlich zu installieren und wenn Sie die Tests ausführen können, sicherzustellen, dass alles korrekt funktioniert. + +/// + +Stellen Sie sich das jetzt mit **vielen** anderen **Paketen** vor, von denen alle Ihre **Projekte abhängen**. Das ist sehr schwierig zu verwalten. Und Sie würden wahrscheinlich einige Projekte mit einigen **inkompatiblen Versionen** der Pakete ausführen und nicht wissen, warum etwas nicht funktioniert. + +Darüber hinaus könnte es je nach Ihrem Betriebssystem (z.B. Linux, Windows, macOS) bereits mit installiertem Python geliefert worden sein. Und in diesem Fall hatte es wahrscheinlich einige Pakete mit bestimmten Versionen **installiert**, die von Ihrem System benötigt werden. Wenn Sie Pakete in der globalen Python-Umgebung installieren, könnten Sie einige der Programme, die mit Ihrem Betriebssystem geliefert wurden, **kaputtmachen**. + +## Wo werden Pakete installiert + +Wenn Sie Python installieren, werden einige Verzeichnisse mit einigen Dateien auf Ihrem Rechner erstellt. + +Einige dieser Verzeichnisse sind dafür zuständig, alle Pakete, die Sie installieren, aufzunehmen. + +Wenn Sie ausführen: + +
+ +```console +// Führen Sie dies jetzt nicht aus, es ist nur ein Beispiel 🤓 +$ pip install "fastapi[standard]" +---> 100% +``` + +
+ +Das lädt eine komprimierte Datei mit dem FastAPI-Code herunter, normalerweise von PyPI. + +Es wird auch Dateien für andere Pakete **herunterladen**, von denen FastAPI abhängt. + +Dann wird es all diese Dateien **extrahieren** und sie in ein Verzeichnis auf Ihrem Rechner legen. + +Standardmäßig werden diese heruntergeladenen und extrahierten Dateien in das Verzeichnis gelegt, das mit Ihrer Python-Installation kommt, das ist die **globale Umgebung**. + +## Was sind virtuelle Umgebungen + +Die Lösung für die Probleme, alle Pakete in der globalen Umgebung zu haben, besteht darin, eine **virtuelle Umgebung für jedes Projekt** zu verwenden, an dem Sie arbeiten. + +Eine virtuelle Umgebung ist ein **Verzeichnis**, sehr ähnlich zu dem globalen, in dem Sie die Pakete für ein Projekt installieren können. + +Auf diese Weise hat jedes Projekt seine eigene virtuelle Umgebung (`.venv`-Verzeichnis) mit seinen eigenen Paketen. + +```mermaid +flowchart TB + subgraph stone-project[philosophers-stone Projekt] + stone(philosophers-stone) --->|benötigt| harry-1 + subgraph venv1[.venv] + harry-1[harry v1] + end + end + subgraph azkaban-project[prisoner-of-azkaban Projekt] + azkaban(prisoner-of-azkaban) --->|benötigt| harry-3 + subgraph venv2[.venv] + harry-3[harry v3] + end + end + stone-project ~~~ azkaban-project +``` + +## Was bedeutet das Aktivieren einer virtuellen Umgebung + +Wenn Sie eine virtuelle Umgebung aktivieren, zum Beispiel mit: + +//// tab | Linux, macOS + +
+ +```console +$ source .venv/bin/activate +``` + +
+ +//// + +//// tab | Windows PowerShell + +
+ +```console +$ .venv\Scripts\Activate.ps1 +``` + +
+ +//// + +//// tab | Windows Bash + +Oder wenn Sie Bash für Windows verwenden (z.B. Git Bash): + +
+ +```console +$ source .venv/Scripts/activate +``` + +
+ +//// + +Dieser Befehl erstellt oder ändert einige [Umgebungsvariablen](environment-variables.md){.internal-link target=_blank}, die für die nächsten Befehle verfügbar sein werden. + +Eine dieser Variablen ist die `PATH`-Variable. + +/// tip | Tipp + +Sie können mehr über die `PATH`-Umgebungsvariable im Abschnitt [Umgebungsvariablen](environment-variables.md#path-environment-variable){.internal-link target=_blank} erfahren. + +/// + +Das Aktivieren einer virtuellen Umgebung fügt deren Pfad `.venv/bin` (auf Linux und macOS) oder `.venv\Scripts` (auf Windows) zur `PATH`-Umgebungsvariable hinzu. + +Angenommen, die `PATH`-Variable sah vor dem Aktivieren der Umgebung so aus: + +//// tab | Linux, macOS + +```plaintext +/usr/bin:/bin:/usr/sbin:/sbin +``` + +Das bedeutet, dass das System nach Programmen sucht in: + +* `/usr/bin` +* `/bin` +* `/usr/sbin` +* `/sbin` + +//// + +//// tab | Windows + +```plaintext +C:\Windows\System32 +``` + +Das bedeutet, dass das System nach Programmen sucht in: + +* `C:\Windows\System32` + +//// + +Nach dem Aktivieren der virtuellen Umgebung würde die `PATH`-Variable folgendermaßen aussehen: + +//// tab | Linux, macOS + +```plaintext +/home/user/code/awesome-project/.venv/bin:/usr/bin:/bin:/usr/sbin:/sbin +``` + +Das bedeutet, dass das System nun zuerst nach Programmen sucht in: + +```plaintext +/home/user/code/awesome-project/.venv/bin +``` + +bevor es in den anderen Verzeichnissen sucht. + +Wenn Sie also `python` im Terminal eingeben, wird das System das Python-Programm in + +```plaintext +/home/user/code/awesome-project/.venv/bin/python +``` + +finden und dieses verwenden. + +//// + +//// tab | Windows + +```plaintext +C:\Users\user\code\awesome-project\.venv\Scripts;C:\Windows\System32 +``` + +Das bedeutet, dass das System nun zuerst nach Programmen sucht in: + +```plaintext +C:\Users\user\code\awesome-project\.venv\Scripts +``` + +bevor es in den anderen Verzeichnissen sucht. + +Wenn Sie also `python` im Terminal eingeben, wird das System das Python-Programm in + +```plaintext +C:\Users\user\code\awesome-project\.venv\Scripts\python +``` + +finden und dieses verwenden. + +//// + +Ein wichtiger Punkt ist, dass es den Pfad der virtuellen Umgebung am **Anfang** der `PATH`-Variable platziert. Das System wird es **vor** allen anderen verfügbaren Pythons finden. Auf diese Weise, wenn Sie `python` ausführen, wird das Python **aus der virtuellen Umgebung** verwendet anstelle eines anderen `python` (zum Beispiel, einem `python` aus einer globalen Umgebung). + +Das Aktivieren einer virtuellen Umgebung ändert auch ein paar andere Dinge, aber dies ist eines der wichtigsten Dinge, die es tut. + +## Überprüfen einer virtuellen Umgebung + +Wenn Sie überprüfen, ob eine virtuelle Umgebung aktiv ist, zum Beispiel mit: + +//// tab | Linux, macOS, Windows Bash + +
+ +```console +$ which python + +/home/user/code/awesome-project/.venv/bin/python +``` + +
+ +//// + +//// tab | Windows PowerShell + +
+ +```console +$ Get-Command python + +C:\Users\user\code\awesome-project\.venv\Scripts\python +``` + +
+ +//// + +Das bedeutet, dass das `python`-Programm, das verwendet wird, das in der **virtuellen Umgebung** ist. + +Sie verwenden `which` auf Linux und macOS und `Get-Command` in Windows PowerShell. + +So funktioniert dieser Befehl: Er wird in der `PATH`-Umgebungsvariable nachsehen und **jeden Pfad in der Reihenfolge durchgehen**, um das Programm namens `python` zu finden. Sobald er es findet, wird er Ihnen **den Pfad** zu diesem Programm anzeigen. + +Der wichtigste Punkt ist, dass, wenn Sie `python` aufrufen, genau dieses "`python`" ausgeführt wird. + +So können Sie überprüfen, ob Sie sich in der richtigen virtuellen Umgebung befinden. + +/// tip | Tipp + +Es ist einfach, eine virtuelle Umgebung zu aktivieren, ein Python zu bekommen und dann **zu einem anderen Projekt zu wechseln**. + +Und das zweite Projekt **würde nicht funktionieren**, weil Sie das **falsche Python** verwenden, aus einer virtuellen Umgebung für ein anderes Projekt. + +Es ist nützlich, überprüfen zu können, welches `python` verwendet wird. 🤓 + +/// + +## Warum eine virtuelle Umgebung deaktivieren + +Zum Beispiel könnten Sie an einem Projekt `philosophers-stone` arbeiten, diese virtuelle Umgebung **aktivieren**, Pakete installieren und mit dieser Umgebung arbeiten. + +Und dann möchten Sie an **einem anderen Projekt** `prisoner-of-azkaban` arbeiten. + +Sie gehen zu diesem Projekt: + +
+ +```console +$ cd ~/code/prisoner-of-azkaban +``` + +
+ +Wenn Sie die virtuelle Umgebung für `philosophers-stone` nicht deaktivieren, wird beim Ausführen von `python` im Terminal versucht, das Python von `philosophers-stone` zu verwenden. + +
+ +```console +$ cd ~/code/prisoner-of-azkaban + +$ python main.py + +// Fehler beim Importieren von sirius, es ist nicht installiert 😱 +Traceback (most recent call last): + File "main.py", line 1, in + import sirius +``` + +
+ +Wenn Sie jedoch die virtuelle Umgebung deaktivieren und die neue für `prisoner-of-azkaban` aktivieren, wird beim Ausführen von `python` das Python aus der virtuellen Umgebung in `prisoner-of-azkaban` verwendet. + +
+ +```console +$ cd ~/code/prisoner-of-azkaban + +// Sie müssen nicht im alten Verzeichnis sein, um zu deaktivieren, Sie können dies überall tun, sogar nachdem Sie zum anderen Projekt gewechselt haben 😎 +$ deactivate + +// Die virtuelle Umgebung in prisoner-of-azkaban/.venv 🚀 aktivieren +$ source .venv/bin/activate + +// Jetzt, wenn Sie python ausführen, wird das Paket sirius in dieser virtuellen Umgebung gefunden ✨ +$ python main.py + +I solemnly swear 🐺 +``` + +
+ +## Alternativen + +Dies ist ein einfacher Leitfaden, um Ihnen den Einstieg zu erleichtern und Ihnen beizubringen, wie alles **unter der Haube** funktioniert. + +Es gibt viele **Alternativen** zur Verwaltung von virtuellen Umgebungen, Paketabhängigkeiten (Anforderungen), Projekten. + +Sobald Sie bereit sind und ein Tool verwenden möchten, das **das gesamte Projekt verwaltet**, Paketabhängigkeiten, virtuelle Umgebungen usw., würde ich Ihnen vorschlagen, uv auszuprobieren. + +`uv` kann viele Dinge tun, es kann: + +* **Python für Sie installieren**, einschließlich verschiedener Versionen +* Die **virtuelle Umgebung** für Ihre Projekte verwalten +* **Pakete installieren** +* Paket**abhängigkeiten und Versionen** für Ihr Projekt verwalten +* Sicherstellen, dass Sie eine **exakte** Menge an Paketen und Versionen zur Installation haben, einschließlich ihrer Abhängigkeiten, damit Sie sicher sein können, dass Sie Ihr Projekt in der Produktionsumgebung genauso ausführen können wie auf Ihrem Rechner während der Entwicklung, dies wird **Locking** genannt +* Und viele andere Dinge + +## Fazit + +Wenn Sie das alles gelesen und verstanden haben, wissen Sie jetzt **viel mehr** über virtuelle Umgebungen als viele Entwickler da draußen. 🤓 + +Das Wissen über diese Details wird in Zukunft wahrscheinlich nützlich sein, wenn Sie etwas debuggen, das komplex erscheint, aber Sie werden wissen, **wie alles unter der Haube funktioniert**. 😎 From c096a7a2624f76782506ca7c3f6c5aa18d2cf384 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 17 Aug 2025 17:01:10 +0200 Subject: [PATCH 004/160] Apply branch `update-translations-de-ai` --- docs/de/docs/advanced/index.md | 17 +- docs/de/docs/advanced/response-directly.md | 6 +- docs/de/docs/async.md | 40 ++- docs/de/docs/benchmarks.md | 26 +- docs/de/docs/deployment/cloud.md | 15 +- docs/de/docs/deployment/manually.md | 160 ++++----- docs/de/docs/deployment/server-workers.md | 144 +++----- docs/de/docs/help-fastapi.md | 136 ++++--- docs/de/docs/how-to/graphql.md | 14 +- docs/de/docs/index.md | 173 +++++---- docs/de/docs/project-generation.md | 112 ++---- docs/de/docs/tutorial/body-multiple-params.md | 34 +- docs/de/docs/tutorial/extra-models.md | 102 +++--- docs/de/docs/tutorial/first-steps.md | 106 +++--- docs/de/docs/tutorial/handling-errors.md | 132 +++---- docs/de/docs/tutorial/index.md | 84 +++-- docs/de/docs/tutorial/middleware.md | 39 +- .../tutorial/query-params-str-validations.md | 338 +++++++++--------- docs/de/docs/tutorial/response-status-code.md | 56 +-- 19 files changed, 829 insertions(+), 905 deletions(-) diff --git a/docs/de/docs/advanced/index.md b/docs/de/docs/advanced/index.md index d93cd5fe8..0b7af2b5e 100644 --- a/docs/de/docs/advanced/index.md +++ b/docs/de/docs/advanced/index.md @@ -18,19 +18,4 @@ Und es ist möglich, dass für Ihren Anwendungsfall die Lösung in einem davon l Sie können immer noch die meisten Funktionen in **FastAPI** mit den Kenntnissen aus dem Haupt-[Tutorial – Benutzerhandbuch](../tutorial/index.md){.internal-link target=_blank} nutzen. -Und in den nächsten Abschnitten wird davon ausgegangen, dass Sie es bereits gelesen haben und dass Sie diese Haupt-Ideen kennen. - -## Externe Kurse - -Obwohl das [Tutorial – Benutzerhandbuch](../tutorial/index.md){.internal-link target=_blank} und dieses **Handbuch für fortgeschrittene Benutzer** als geführtes Tutorial (wie ein Buch) geschrieben sind und für Sie ausreichen sollten, um **FastAPI zu lernen**, möchten Sie sie vielleicht durch zusätzliche Kurse ergänzen. - -Oder Sie belegen einfach lieber andere Kurse, weil diese besser zu Ihrem Lernstil passen. - -Einige Kursanbieter ✨ [**sponsern FastAPI**](../help-fastapi.md#den-autor-sponsern){.internal-link target=_blank} ✨, dies gewährleistet die kontinuierliche und gesunde **Entwicklung** von FastAPI und seinem **Ökosystem**. - -Und es zeigt deren wahres Engagement für FastAPI und seine **Gemeinschaft** (Sie), da diese Ihnen nicht nur eine **gute Lernerfahrung** bieten möchten, sondern auch sicherstellen möchten, dass Sie über ein **gutes und gesundes Framework verfügen **, FastAPI. 🙇 - -Vielleicht möchten Sie ihre Kurse ausprobieren: - -* Talk Python Training -* Test-Driven Development +Und die nächsten Abschnitte setzen voraus, dass Sie es bereits gelesen haben und dass Sie diese Hauptideen kennen. diff --git a/docs/de/docs/advanced/response-directly.md b/docs/de/docs/advanced/response-directly.md index b84aa8ab9..729f0bcda 100644 --- a/docs/de/docs/advanced/response-directly.md +++ b/docs/de/docs/advanced/response-directly.md @@ -1,10 +1,10 @@ # Eine Response direkt zurückgeben -Wenn Sie eine **FastAPI** *Pfadoperation* erstellen, können Sie normalerweise beliebige Daten davon zurückgeben: ein `dict`, eine `list`e, ein Pydantic-Modell, ein Datenbankmodell, usw. +Wenn Sie eine **FastAPI** *Pfadoperation* erstellen, können Sie normalerweise beliebige Daten davon zurückgeben: ein `dict`, eine `list`, ein Pydantic-Modell, ein Datenbankmodell, usw. Standardmäßig konvertiert **FastAPI** diesen Rückgabewert automatisch nach JSON, mithilfe des `jsonable_encoder`, der in [JSON-kompatibler Encoder](../tutorial/encoder.md){.internal-link target=_blank} erläutert wird. -Dann würde es hinter den Kulissen diese JSON-kompatiblen Daten (z. B. ein `dict`) in eine `JSONResponse` einfügen, die zum Senden der Response an den Client verwendet würde. +Dann würde es hinter den Kulissen diese JSON-kompatiblen Daten (z. B. ein `dict`) in eine `JSONResponse` einfügen, die zum Senden der Response an den Client verwendet wird. Sie können jedoch direkt eine `JSONResponse` von Ihren *Pfadoperationen* zurückgeben. @@ -38,7 +38,7 @@ In diesen Fällen können Sie den `jsonable_encoder` verwenden, um Ihre Daten zu /// note | Technische Details -Sie können auch `from starlette.responses import JSONResponse` verwenden. +Sie könnten auch `from starlette.responses import JSONResponse` verwenden. **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. diff --git a/docs/de/docs/async.md b/docs/de/docs/async.md index b5b3a4c52..a493b31e8 100644 --- a/docs/de/docs/async.md +++ b/docs/de/docs/async.md @@ -21,7 +21,7 @@ async def read_results(): return results ``` -/// note +/// note | Hinweis Sie können `await` nur innerhalb von Funktionen verwenden, die mit `async def` erstellt wurden. @@ -40,7 +40,7 @@ def results(): --- -Wenn Ihre Anwendung (irgendwie) mit nichts anderem kommunizieren und auf dessen Antwort warten muss, verwenden Sie `async def`. +Wenn Ihre Anwendung (irgendwie) mit nichts anderem kommunizieren und auf dessen Antwort warten muss, verwenden Sie `async def`, auch wenn Sie `await` im Inneren nicht verwenden müssen. --- @@ -56,7 +56,7 @@ Wenn Sie jedoch den oben genannten Schritten folgen, können einige Performance- ## Technische Details -Moderne Versionen von Python unterstützen **„asynchronen Code“** unter Verwendung sogenannter **„Coroutinen“** mithilfe der Syntax **`async`** und **`await`**. +Moderne Versionen von Python unterstützen **„asynchronen Code“** unter Verwendung sogenannter **„Coroutinen“** mithilfe der Syntax **`async` und `await`**. Nehmen wir obigen Satz in den folgenden Abschnitten Schritt für Schritt unter die Lupe: @@ -66,11 +66,11 @@ Nehmen wir obigen Satz in den folgenden Abschnitten Schritt für Schritt unter d ## Asynchroner Code -Asynchroner Code bedeutet lediglich, dass die Sprache 💬 eine Möglichkeit hat, dem Computersystem / Programm 🤖 mitzuteilen, dass es 🤖 an einem bestimmten Punkt im Code darauf warten muss, dass *etwas anderes* irgendwo anders fertig wird. Nehmen wir an, *etwas anderes* ist hier „Langsam-Datei“ 📝. +Asynchroner Code bedeutet lediglich, dass die Sprache 💬 eine Möglichkeit hat, dem Computer / Programm 🤖 mitzuteilen, dass es 🤖 an einem bestimmten Punkt im Code darauf warten muss, dass *etwas anderes* irgendwo anders fertig wird. Nehmen wir an, *etwas anderes* ist hier „Langsam-Datei“ 📝. Während der Zeit, die „Langsam-Datei“ 📝 benötigt, kann das System also andere Aufgaben erledigen. -Dann kommt das System / Programm 🤖 bei jeder Gelegenheit zurück, wenn es entweder wieder wartet, oder wann immer es 🤖 die ganze Arbeit erledigt hat, die zu diesem Zeitpunkt zu tun war. Und es 🤖 wird nachschauen, ob eine der Aufgaben, auf die es gewartet hat, fertig damit ist, zu tun, was sie tun sollte. +Dann kommt der Computer / das Programm 🤖 bei jeder Gelegenheit zurück, weil es entweder wieder wartet, oder wann immer es 🤖 die ganze Arbeit erledigt hat, die zu diesem Zeitpunkt zu tun war. Und es 🤖 wird nachschauen, ob eine der Aufgaben, auf die es gewartet hat, fertig damit ist, zu tun, was sie tun sollte. Dann nimmt es 🤖 die erste erledigte Aufgabe (sagen wir, unsere „Langsam-Datei“ 📝) und bearbeitet sie weiter. @@ -87,11 +87,11 @@ Das „Warten auf etwas anderes“ bezieht sich normalerweise auf I/O-Operationen verbraucht wird, nennt man dies auch „I/O-lastige“ („I/O bound“) Operationen. -„Asynchron“, sagt man, weil das Computersystem / Programm nicht mit einer langsamen Aufgabe „synchronisiert“ werden muss und nicht auf den genauen Moment warten muss, in dem die Aufgabe beendet ist, ohne dabei etwas zu tun, um schließlich das Ergebnis der Aufgabe zu übernehmen und die Arbeit fortsetzen zu können. +„Asynchron“, sagt man, weil der Computer / das Programm nicht mit einer langsamen Aufgabe „synchronisiert“ werden muss und nicht auf den genauen Moment warten muss, in dem die Aufgabe beendet ist, ohne dabei etwas zu tun, um schließlich das Ergebnis der Aufgabe zu übernehmen und die Arbeit fortsetzen zu können. -Da es sich stattdessen um ein „asynchrones“ System handelt, kann die Aufgabe nach Abschluss ein wenig (einige Mikrosekunden) in der Schlange warten, bis das System / Programm seine anderen Dinge erledigt hat und zurückkommt, um die Ergebnisse entgegenzunehmen und mit ihnen weiterzuarbeiten. +Da es sich stattdessen um ein „asynchrones“ System handelt, kann die Aufgabe nach Abschluss ein wenig (einige Mikrosekunden) in der Schlange warten, bis der Computer / das Programm seine anderen Dinge erledigt hat und zurückkommt, um die Ergebnisse entgegenzunehmen und mit ihnen weiterzuarbeiten. -Für „synchron“ (im Gegensatz zu „asynchron“) wird auch oft der Begriff „sequentiell“ verwendet, da das System / Programm alle Schritte in einer Sequenz („der Reihe nach“) ausführt, bevor es zu einer anderen Aufgabe wechselt, auch wenn diese Schritte mit Warten verbunden sind. +Für „synchron“ (im Gegensatz zu „asynchron“) wird auch oft der Begriff „sequentiell“ verwendet, da der Computer / das Programm alle Schritte in einer Sequenz („der Reihe nach“) ausführt, bevor es zu einer anderen Aufgabe wechselt, auch wenn diese Schritte mit Warten verbunden sind. ### Nebenläufigkeit und Hamburger @@ -139,7 +139,7 @@ Sie und Ihr Schwarm essen die Burger und haben eine schöne Zeit. ✨ -/// info +/// info | Info Die wunderschönen Illustrationen stammen von Ketrina Thompson. 🎨 @@ -147,7 +147,7 @@ Die wunderschönen Illustrationen stammen von Ketrina Thompson. 🎨 @@ -235,7 +235,7 @@ Sie würden Ihren Schwarm 😍 wahrscheinlich nicht mitnehmen wollen, um Besorgu ### Hamburger Schlussfolgerung -In diesem Szenario „Fast Food Burger mit Ihrem Schwarm“ ist es viel sinnvoller, ein nebenläufiges System zu haben ⏸🔀⏯, da viel gewartet wird 🕙. +In diesem Szenario „Fastfood-Burger mit Ihrem Schwarm“ ist es viel sinnvoller, ein nebenläufiges System zu haben ⏸🔀⏯, da viel gewartet wird 🕙. Das ist auch bei den meisten Webanwendungen der Fall. @@ -294,13 +294,13 @@ Zum Beispiel: Mit **FastAPI** können Sie die Vorteile der Nebenläufigkeit nutzen, die in der Webentwicklung weit verbreitet ist (derselbe Hauptvorteil von NodeJS). -Sie können aber auch die Vorteile von Parallelität und Multiprocessing (Mehrere Prozesse werden parallel ausgeführt) für **CPU-lastige** Workloads wie in Systemen für maschinelles Lernen nutzen. +Sie können aber auch die Vorteile von Parallelität und Multiprocessing (mehrere Prozesse werden parallel ausgeführt) für **CPU-lastige** Workloads wie in Systemen für maschinelles Lernen nutzen. Dies und die einfache Tatsache, dass Python die Hauptsprache für **Data Science**, maschinelles Lernen und insbesondere Deep Learning ist, machen FastAPI zu einem sehr passenden Werkzeug für Web-APIs und Anwendungen für Data Science / maschinelles Lernen (neben vielen anderen). Wie Sie diese Parallelität in der Produktion erreichen, erfahren Sie im Abschnitt über [Deployment](deployment/index.md){.internal-link target=_blank}. -## `async` und `await`. +## `async` und `await` Moderne Versionen von Python verfügen über eine sehr intuitive Möglichkeit, asynchronen Code zu schreiben. Dadurch sieht es wie normaler „sequentieller“ Code aus und übernimmt im richtigen Moment das „Warten“ für Sie. @@ -367,7 +367,9 @@ Starlette (und **FastAPI**) basiert auf AnyIO direkt verwenden für Ihre fortgeschritten nebenläufigen und parallelen Anwendungsfälle, die fortgeschrittenere Muster in Ihrem eigenen Code erfordern. -Und selbst wenn Sie FastAPI nicht verwenden würden, könnten Sie auch Ihre eigenen asynchronen Anwendungen mit AnyIO so schreiben, dass sie hoch kompatibel sind und Sie dessen Vorteile nutzen können (z. B. *strukturierte Nebenläufigkeit*). +Und auch wenn Sie FastAPI nicht verwenden würden, könnten Sie Ihre eigenen asynchronen Anwendungen mit AnyIO schreiben, um hochkompatibel zu sein und dessen Vorteile zu nutzen (z. B. *strukturierte Nebenläufigkeit*). + +Ich habe eine weitere Bibliothek auf Basis von AnyIO erstellt, als dünne Schicht obendrauf, um die Typ-Annotationen etwas zu verbessern und bessere **Autovervollständigung**, **Inline-Fehler** usw. zu erhalten. Sie hat auch eine freundliche Einführung und ein Tutorial, um Ihnen zu helfen, **Ihren eigenen asynchronen Code zu verstehen** und zu schreiben: Asyncer. Sie ist insbesondere nützlich, wenn Sie **asynchronen Code mit regulärem** (blockierendem/synchronem) Code kombinieren müssen. ### Andere Formen von asynchronem Code @@ -381,7 +383,7 @@ Davor war der Umgang mit asynchronem Code jedoch deutlich komplexer und schwieri In früheren Versionen von Python hätten Sie Threads oder Gevent verwenden können. Der Code ist jedoch viel komplexer zu verstehen, zu debuggen und nachzuvollziehen. -In früheren Versionen von NodeJS / Browser JavaScript hätten Sie „Callbacks“ verwendet. Was zur Callback-Hölle führt. +In früheren Versionen von NodeJS / Browser JavaScript hätten Sie „Callbacks“ verwendet, was zur Callback-Hölle führt. ## Coroutinen @@ -393,7 +395,7 @@ Aber all diese Funktionalität der Verwendung von asynchronem Code mit `async` u Sehen wir uns den gleichen Satz von oben noch mal an: -> Moderne Versionen von Python unterstützen **„asynchronen Code“** unter Verwendung sogenannter **„Coroutinen“** mithilfe der Syntax **`async`** und **`await`**. +> Moderne Versionen von Python unterstützen **„asynchronen Code“** unter Verwendung sogenannter **„Coroutinen“** mithilfe der Syntax **`async` und `await`**. Das sollte jetzt mehr Sinn ergeben. ✨ @@ -421,11 +423,11 @@ Dennoch besteht in beiden Fällen eine gute Chance, dass **FastAPI** [immer noch ### Abhängigkeiten -Das Gleiche gilt für [Abhängigkeiten](tutorial/dependencies/index.md){.internal-link target=_blank}. Wenn eine Abhängigkeit eine normale `def`-Funktion ist, anstelle einer `async def`-Funktion, dann wird sie im externen Threadpool ausgeführt. +Das Gleiche gilt für [Abhängigkeiten](tutorial/dependencies/index.md){.internal-link target=_blank}. Wenn eine Abhängigkeit eine normale `def`-Funktion anstelle einer `async def` ist, wird sie im externen Threadpool ausgeführt. ### Unterabhängigkeiten -Sie können mehrere Abhängigkeiten und [Unterabhängigkeiten](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank} haben, die einander bedingen (als Parameter der Funktionsdefinitionen), einige davon könnten erstellt werden mit `async def` und einige mit normalem `def`. Es würde immer noch funktionieren und diejenigen, die mit normalem `def` erstellt wurden, würden in einem externen Thread (vom Threadpool stammend) aufgerufen werden, anstatt `await`et zu werden. +Sie können mehrere Abhängigkeiten und [Unterabhängigkeiten](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank} haben, die einander bedingen (als Parameter der Funktionsdefinitionen), einige davon könnten erstellt werden mit `async def` und einige mit normalem `def`. Es würde immer noch funktionieren, und diejenigen, die mit normalem `def` erstellt wurden, würden in einem externen Thread (vom Threadpool stammend) aufgerufen werden, anstatt `await`et zu werden. ### Andere Hilfsfunktionen diff --git a/docs/de/docs/benchmarks.md b/docs/de/docs/benchmarks.md index 6efd56e83..f72b0745a 100644 --- a/docs/de/docs/benchmarks.md +++ b/docs/de/docs/benchmarks.md @@ -1,16 +1,16 @@ # Benchmarks -Unabhängige TechEmpower-Benchmarks zeigen, **FastAPI**-Anwendungen, die unter Uvicorn ausgeführt werden, gehören zu den schnellsten existierenden Python-Frameworks, nur Starlette und Uvicorn selbst (intern von FastAPI verwendet) sind schneller. +Unabhängige TechEmpower-Benchmarks zeigen **FastAPI**-Anwendungen, die unter Uvicorn ausgeführt werden, als eines der schnellsten verfügbaren Python-Frameworks, nur unterhalb von Starlette und Uvicorn selbst (die intern von FastAPI verwendet werden). -Beim Ansehen von Benchmarks und Vergleichen sollten Sie jedoch Folgende Punkte beachten. +Aber bei der Betrachtung von Benchmarks und Vergleichen sollten Sie Folgendes beachten. ## Benchmarks und Geschwindigkeit -Wenn Sie sich die Benchmarks ansehen, werden häufig mehrere Tools mit unterschiedlichen Eigenschaften als gleichwertig verglichen. +Wenn Sie die Benchmarks ansehen, ist es üblich, dass mehrere Tools unterschiedlichen Typs als gleichwertig verglichen werden. -Konkret geht es darum, Uvicorn, Starlette und FastAPI miteinander zu vergleichen (neben vielen anderen Tools). +Insbesondere dass Uvicorn, Starlette und FastAPI zusammen verglichen werden (neben vielen anderen Tools). -Je einfacher das Problem, welches durch das Tool gelöst wird, desto besser ist die Performanz. Und die meisten Benchmarks testen nicht die zusätzlichen Funktionen, welche das Tool bietet. +Je einfacher das Problem, das durch das Tool gelöst wird, desto besser wird die Performanz sein. Und die meisten Benchmarks testen nicht die zusätzlichen Funktionen, die das Tool bietet. Die Hierarchie ist wie folgt: @@ -19,16 +19,16 @@ Die Hierarchie ist wie folgt: * **FastAPI**: (verwendet Starlette) ein API-Mikroframework mit mehreren zusätzlichen Funktionen zum Erstellen von APIs, mit Datenvalidierung, usw. * **Uvicorn**: - * Bietet die beste Leistung, da außer dem Server selbst nicht viel zusätzlicher Code vorhanden ist. - * Sie würden eine Anwendung nicht direkt in Uvicorn schreiben. Das würde bedeuten, dass Ihr Code zumindest mehr oder weniger den gesamten von Starlette (oder **FastAPI**) bereitgestellten Code enthalten müsste. Und wenn Sie das täten, hätte Ihre endgültige Anwendung den gleichen Overhead wie die Verwendung eines Frameworks nebst Minimierung Ihres Anwendungscodes und der Fehler. + * Wird die beste Performanz haben, da außer dem Server selbst nicht viel zusätzlicher Code vorhanden ist. + * Sie würden eine Anwendung nicht direkt in Uvicorn schreiben. Das würde bedeuten, dass Ihr Code zumindest mehr oder weniger den gesamten von Starlette (oder **FastAPI**) bereitgestellten Code enthalten müsste. Und wenn Sie das täten, hätte Ihre endgültige Anwendung den gleichen Overhead wie bei der Verwendung eines Frameworks und der Minimierung Ihres Anwendungscodes und der Fehler. * Wenn Sie Uvicorn vergleichen, vergleichen Sie es mit Anwendungsservern wie Daphne, Hypercorn, uWSGI, usw. * **Starlette**: - * Wird nach Uvicorn die nächstbeste Performanz erbringen. Tatsächlich nutzt Starlette intern Uvicorn. Daher kann es wahrscheinlich nur „langsamer“ als Uvicorn sein, weil mehr Code ausgeführt wird. - * Aber es bietet Ihnen die Tools zum Erstellen einfacher Webanwendungen, mit Routing basierend auf Pfaden, usw. + * Wird nach Uvicorn die nächstbeste Performanz erbringen. Tatsächlich verwendet Starlette intern Uvicorn, um zu laufen. Daher kann es wahrscheinlich nur „langsamer“ als Uvicorn werden, weil mehr Code ausgeführt werden muss. + * Aber es bietet Ihnen die Werkzeuge, um einfache Webanwendungen zu erstellen, mit Routing basierend auf Pfaden, usw. * Wenn Sie Starlette vergleichen, vergleichen Sie es mit Webframeworks (oder Mikroframeworks) wie Sanic, Flask, Django, usw. * **FastAPI**: * So wie Starlette Uvicorn verwendet und nicht schneller als dieses sein kann, verwendet **FastAPI** Starlette, sodass es nicht schneller als dieses sein kann. - * FastAPI bietet zusätzlich zu Starlette weitere Funktionen. Funktionen, die Sie beim Erstellen von APIs fast immer benötigen, wie Datenvalidierung und Serialisierung. Und wenn Sie es verwenden, erhalten Sie kostenlos automatische Dokumentation (die automatische Dokumentation verursacht nicht einmal zusätzlichen Aufwand für laufende Anwendungen, sie wird beim Start generiert). - * Wenn Sie FastAPI nicht, und direkt Starlette (oder ein anderes Tool wie Sanic, Flask, Responder, usw.) verwenden würden, müssten Sie die gesamte Datenvalidierung und Serialisierung selbst implementieren. Ihre finale Anwendung hätte also immer noch den gleichen Overhead, als ob sie mit FastAPI erstellt worden wäre. Und in vielen Fällen ist diese Datenvalidierung und Serialisierung der größte Teil des in Anwendungen geschriebenen Codes. - * Durch die Verwendung von FastAPI sparen Sie also Entwicklungszeit, Fehler und Codezeilen und würden wahrscheinlich die gleiche Leistung (oder eine bessere) erzielen, die Sie hätten, wenn Sie es nicht verwenden würden (da Sie alles in Ihrem Code implementieren müssten). - * Wenn Sie FastAPI vergleichen, vergleichen Sie es mit einem Webanwendung-Framework (oder einer Reihe von Tools), welche Datenvalidierung, Serialisierung und Dokumentation bereitstellen, wie Flask-apispec, NestJS, Molten, usw. – Frameworks mit integrierter automatischer Datenvalidierung, Serialisierung und Dokumentation. + * FastAPI bietet zusätzliche Funktionen auf Basis von Starlette. Funktionen, die Sie beim Erstellen von APIs fast immer benötigen, wie Datenvalidierung und Serialisierung. Und wenn Sie es verwenden, erhalten Sie kostenlose automatische Dokumentation (die automatische Dokumentation verursacht nicht einmal zusätzlichen Overhead für laufende Anwendungen, sie wird beim Starten generiert). + * Wenn Sie FastAPI nicht verwenden und stattdessen Starlette direkt (oder ein anderes Tool wie Sanic, Flask, Responder, usw.) verwenden würden, müssten Sie die gesamte Datenvalidierung und Serialisierung selbst implementieren. Ihre finale Anwendung hätte also immer noch den gleichen Overhead, als ob sie mit FastAPI erstellt worden wäre. Und in vielen Fällen ist diese Datenvalidierung und Serialisierung der größte Teil des in Anwendungen geschriebenen Codes. + * Durch die Verwendung von FastAPI sparen Sie also Entwicklungszeit, Fehler und Codezeilen und würden wahrscheinlich die gleiche Performanz (oder eine bessere) erzielen, die Sie hätten, wenn Sie es nicht verwenden würden (da Sie alles in Ihrem Code implementieren müssten). + * Wenn Sie FastAPI vergleichen, vergleichen Sie es mit einem Webanwendungs-Framework (oder einer Reihe von Tools), das Datenvalidierung, Serialisierung und Dokumentation bereitstellt, wie Flask-apispec, NestJS, Molten, usw. – Frameworks mit integrierter automatischer Datenvalidierung, Serialisierung und Dokumentation. diff --git a/docs/de/docs/deployment/cloud.md b/docs/de/docs/deployment/cloud.md index 2d70fe4e5..09f207812 100644 --- a/docs/de/docs/deployment/cloud.md +++ b/docs/de/docs/deployment/cloud.md @@ -1,17 +1,18 @@ -# FastAPI-Deployment bei Cloud-Anbietern +# FastAPI bei Cloudanbietern bereitstellen -Sie können praktisch **jeden Cloud-Anbieter** für das Deployment Ihrer FastAPI-Anwendung verwenden. +Sie können praktisch **jeden Cloudanbieter** verwenden, um Ihre FastAPI-Anwendung bereitzustellen. -In den meisten Fällen verfügen die Haupt-Cloud-Anbieter über Anleitungen zum Deployment von FastAPI. +In den meisten Fällen bieten die großen Cloudanbieter Anleitungen zum Bereitstellen von FastAPI an. -## Cloud-Anbieter – Sponsoren +## Cloudanbieter - Sponsoren -Einige Cloud-Anbieter ✨ [**sponsern FastAPI**](../help-fastapi.md#den-autor-sponsern){.internal-link target=_blank} ✨, dies gewährleistet die kontinuierliche und gesunde **Entwicklung** von FastAPI und seinem **Ökosystem**. +Einige Cloudanbieter ✨ [**sponsern FastAPI**](../help-fastapi.md#den-autor-sponsern){.internal-link target=_blank} ✨, dies stellt die kontinuierliche und gesunde **Entwicklung** von FastAPI und seinem **Ökosystem** sicher. -Und es zeigt deren wahres Engagement für FastAPI und seine **Community** (Sie), da diese Ihnen nicht nur einen **guten Service** bieten möchten, sondern auch sicherstellen möchten, dass Sie über ein **gutes und gesundes Framework** verfügen, FastAPI. 🙇 +Und es zeigt ihr wahres Engagement für FastAPI und seine **Community** (Sie), da sie Ihnen nicht nur einen **guten Service** bieten möchten, sondern auch sicherstellen möchten, dass Sie ein **gutes und gesundes Framework**, FastAPI, haben. 🙇 Vielleicht möchten Sie deren Dienste ausprobieren und deren Anleitungen folgen: * Platform.sh * Porter -* Coherence +* Render +* Railway diff --git a/docs/de/docs/deployment/manually.md b/docs/de/docs/deployment/manually.md index fdb33f7fe..127bb5b6a 100644 --- a/docs/de/docs/deployment/manually.md +++ b/docs/de/docs/deployment/manually.md @@ -1,151 +1,149 @@ -# Einen Server manuell ausführen – Uvicorn +# Einen Server manuell ausführen -Das Wichtigste, was Sie zum Ausführen einer **FastAPI**-Anwendung auf einer entfernten Servermaschine benötigen, ist ein ASGI-Serverprogramm, wie **Uvicorn**. +## Den `fastapi run` Befehl verwenden -Es gibt 3 Hauptalternativen: +Kurz gesagt, nutzen Sie `fastapi run`, um Ihre FastAPI-Anwendung bereitzustellen: -* Uvicorn: ein hochperformanter ASGI-Server. -* Hypercorn: ein ASGI-Server, der unter anderem mit HTTP/2 und Trio kompatibel ist. -* Daphne: Der für Django Channels entwickelte ASGI-Server. - -## Servermaschine und Serverprogramm +
-Bei den Benennungen gibt es ein kleines Detail, das Sie beachten sollten. 💡 +```console +$ fastapi run main.py -Das Wort „**Server**“ bezieht sich häufig sowohl auf den entfernten-/Cloud-Computer (die physische oder virtuelle Maschine) als auch auf das Programm, das auf dieser Maschine ausgeführt wird (z. B. Uvicorn). + FastAPI Starting production server 🚀 -Denken Sie einfach daran, wenn Sie „Server“ im Allgemeinen lesen, dass es sich auf eines dieser beiden Dinge beziehen kann. + Searching for package file structure from directories + with __init__.py files + Importing from /home/user/code/awesomeapp -Wenn man sich auf die entfernte Maschine bezieht, wird sie üblicherweise als **Server**, aber auch als **Maschine**, **VM** (virtuelle Maschine) oder **Knoten** bezeichnet. Diese Begriffe beziehen sich auf irgendeine Art von entfernten Rechner, normalerweise unter Linux, auf dem Sie Programme ausführen. + module 🐍 main.py -## Das Serverprogramm installieren + code Importing the FastAPI app object from the module with + the following code: -Sie können einen ASGI-kompatiblen Server installieren mit: + from main import app -//// tab | Uvicorn + app Using import string: main:app -* Uvicorn, ein blitzschneller ASGI-Server, basierend auf uvloop und httptools. + server Server started at http://0.0.0.0:8000 + server Documentation at http://0.0.0.0:8000/docs -
+ Logs: -```console -$ pip install "uvicorn[standard]" - ----> 100% + INFO Started server process [2306215] + INFO Waiting for application startup. + INFO Application startup complete. + INFO Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C + to quit) ```
-/// tip | Tipp - -Durch das Hinzufügen von `standard` installiert und verwendet Uvicorn einige empfohlene zusätzliche Abhängigkeiten. - -Inklusive `uvloop`, einen hochperformanten Drop-in-Ersatz für `asyncio`, welcher für einen großen Leistungsschub bei der Nebenläufigkeit sorgt. - -/// +Das würde in den meisten Fällen funktionieren. 😎 -//// +Sie könnten diesen Befehl beispielsweise verwenden, um Ihre **FastAPI**-App in einem Container, auf einem Server usw. zu starten. -//// tab | Hypercorn +## ASGI-Server -* Hypercorn, ein ASGI-Server, der auch mit HTTP/2 kompatibel ist. +Lassen Sie uns ein wenig tiefer in die Details eintauchen. -
+FastAPI verwendet einen Standard zum Erstellen von Python-Webframeworks und -Servern, der als ASGI bekannt ist. FastAPI ist ein ASGI-Webframework. -```console -$ pip install hypercorn +Das Wichtigste, was Sie benötigen, um eine **FastAPI**-Anwendung (oder eine andere ASGI-Anwendung) auf einer entfernten Servermaschine auszuführen, ist ein ASGI-Serverprogramm wie **Uvicorn**, der standardmäßig im `fastapi`-Kommando enthalten ist. ----> 100% -``` +Es gibt mehrere Alternativen, einschließlich: -
- -... oder jeden anderen ASGI-Server. +* Uvicorn: ein hochperformanter ASGI-Server. +* Hypercorn: ein ASGI-Server, der unter anderem kompatibel mit HTTP/2 und Trio ist. +* Daphne: der für Django Channels entwickelte ASGI-Server. +* Granian: Ein Rust HTTP-Server für Python-Anwendungen. +* NGINX Unit: NGINX Unit ist eine leichte und vielseitige Laufzeitumgebung für Webanwendungen. -//// +## Servermaschine und Serverprogramm -## Das Serverprogramm ausführen +Es gibt ein kleines Detail bei den Namen, das Sie beachten sollten. 💡 -Anschließend können Sie Ihre Anwendung auf die gleiche Weise ausführen, wie Sie es in den Tutorials getan haben, jedoch ohne die Option `--reload`, z. B.: +Das Wort „**Server**“ wird häufig verwendet, um sowohl den entfernten/Cloud-Computer (die physische oder virtuelle Maschine) als auch das Programm zu bezeichnen, das auf dieser Maschine läuft (z.B. Uvicorn). -//// tab | Uvicorn +Denken Sie einfach daran, dass sich "Server" im Allgemeinen auf eines dieser beiden Dinge beziehen kann. -
+Wenn man sich auf die entfernte Maschine bezieht, wird sie üblicherweise als **Server**, aber auch als **Maschine**, **VM** (virtuelle Maschine) oder **Knoten** bezeichnet. Diese Begriffe beziehen sich auf irgendeine Art von entfernten Rechner, normalerweise unter Linux, auf dem Sie Programme ausführen. -```console -$ uvicorn main:app --host 0.0.0.0 --port 80 +## Das Serverprogramm installieren -INFO: Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit) -``` +Wenn Sie FastAPI installieren, wird es mit einem Produktionsserver, Uvicorn, geliefert, und Sie können ihn mit dem `fastapi run` Befehl starten. -
+Aber Sie können auch ein ASGI-Serverprogramm manuell installieren. -//// +Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und dann die Serveranwendung installieren. -//// tab | Hypercorn +Zum Beispiel, um Uvicorn zu installieren:
```console -$ hypercorn main:app --bind 0.0.0.0:80 +$ pip install "uvicorn[standard]" -Running on 0.0.0.0:8080 over http (CTRL + C to quit) +---> 100% ```
-//// +Ein ähnlicher Prozess würde für jedes andere ASGI-Serverprogramm gelten. -/// warning | Achtung +/// tip | Tipp -Denken Sie daran, die Option `--reload` zu entfernen, wenn Sie diese verwendet haben. +Durch das Hinzufügen von `standard` installiert und verwendet Uvicorn einige empfohlene zusätzliche Abhängigkeiten. -Die Option `--reload` verbraucht viel mehr Ressourcen, ist instabiler, usw. +Dazu gehört `uvloop`, der hochperformante Drop-in-Ersatz für `asyncio`, der den großen Nebenläufigkeits-Performance-Schub bietet. -Sie hilft sehr während der **Entwicklung**, aber Sie sollten sie **nicht** in der **Produktion** verwenden. +Wenn Sie FastAPI mit etwas wie `pip install "fastapi[standard]"` installieren, erhalten Sie auch `uvicorn[standard]`. /// -## Hypercorn mit Trio - -Starlette und **FastAPI** basieren auf AnyIO, welches diese sowohl mit der Python-Standardbibliothek asyncio, als auch mit Trio kompatibel macht. - -Dennoch ist Uvicorn derzeit nur mit asyncio kompatibel und verwendet normalerweise `uvloop`, den leistungsstarken Drop-in-Ersatz für `asyncio`. - -Wenn Sie jedoch **Trio** direkt verwenden möchten, können Sie **Hypercorn** verwenden, da dieses es unterstützt. ✨ - -### Hypercorn mit Trio installieren +## Das Serverprogramm ausführen -Zuerst müssen Sie Hypercorn mit Trio-Unterstützung installieren: +Wenn Sie einen ASGI-Server manuell installiert haben, müssen Sie normalerweise einen Importstring in einem speziellen Format übergeben, damit er Ihre FastAPI-Anwendung importiert:
```console -$ pip install "hypercorn[trio]" ----> 100% +$ uvicorn main:app --host 0.0.0.0 --port 80 + +INFO: Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit) ```
-### Mit Trio ausführen +/// note | Hinweis -Dann können Sie die Befehlszeilenoption `--worker-class` mit dem Wert `trio` übergeben: +Der Befehl `uvicorn main:app` bezieht sich auf: -
+* `main`: die Datei `main.py` (das Python-„Modul“). +* `app`: das Objekt, das innerhalb von `main.py` mit der Zeile `app = FastAPI()` erstellt wurde. -```console -$ hypercorn main:app --worker-class trio +Es ist äquivalent zu: + +```Python +from main import app ``` -
+/// + +Jedes alternative ASGI-Serverprogramm hätte einen ähnlichen Befehl, Sie können in deren jeweiligen Dokumentationen mehr lesen. + +/// warning | Achtung -Und das startet Hypercorn mit Ihrer Anwendung und verwendet Trio als Backend. +Uvicorn und andere Server unterstützen eine `--reload`-Option, die während der Entwicklung nützlich ist. -Jetzt können Sie Trio intern in Ihrer Anwendung verwenden. Oder noch besser: Sie können AnyIO verwenden, sodass Ihr Code sowohl mit Trio als auch asyncio kompatibel ist. 🎉 +Die `--reload`-Option verbraucht viel mehr Ressourcen, ist instabiler, usw. + +Sie hilft während der **Entwicklung**, Sie sollten sie jedoch **nicht** in der **Produktion** verwenden. + +/// -## Konzepte des Deployments +## Deployment-Konzepte -Obige Beispiele führen das Serverprogramm (z. B. Uvicorn) aus, starten **einen einzelnen Prozess** und überwachen alle IPs (`0.0.0.0`) an einem vordefinierten Port (z. B. `80`). +Diese Beispiele führen das Serverprogramm (z.B. Uvicorn) aus, starten **einen einzelnen Prozess** und überwachen alle IPs (`0.0.0.0`) an einem vordefinierten Port (z. B. `80`). Das ist die Grundidee. Aber Sie möchten sich wahrscheinlich um einige zusätzliche Dinge kümmern, wie zum Beispiel: @@ -153,7 +151,7 @@ Das ist die Grundidee. Aber Sie möchten sich wahrscheinlich um einige zusätzli * Beim Hochfahren ausführen * Neustarts * Replikation (die Anzahl der laufenden Prozesse) -* Arbeitsspeicher +* Speicher * Schritte vor dem Start In den nächsten Kapiteln erzähle ich Ihnen mehr über jedes dieser Konzepte, wie Sie über diese nachdenken, und gebe Ihnen einige konkrete Beispiele mit Strategien für den Umgang damit. 🚀 diff --git a/docs/de/docs/deployment/server-workers.md b/docs/de/docs/deployment/server-workers.md index 5cd282b4b..b8449d899 100644 --- a/docs/de/docs/deployment/server-workers.md +++ b/docs/de/docs/deployment/server-workers.md @@ -1,4 +1,4 @@ -# Serverworker – Gunicorn mit Uvicorn +# Serverworker – Uvicorn mit Workern Schauen wir uns die Deployment-Konzepte von früher noch einmal an: @@ -9,123 +9,79 @@ Schauen wir uns die Deployment-Konzepte von früher noch einmal an: * Arbeitsspeicher * Schritte vor dem Start -Bis zu diesem Punkt, in allen Tutorials in der Dokumentation, haben Sie wahrscheinlich ein **Serverprogramm** wie Uvicorn ausgeführt, in einem **einzelnen Prozess**. +Bis zu diesem Punkt, in allen Tutorials in der Dokumentation, haben Sie wahrscheinlich ein **Serverprogramm** ausgeführt, zum Beispiel mit dem `fastapi`-Befehl, der Uvicorn startet, und einen **einzelnen Prozess** ausführt. -Wenn Sie Anwendungen bereitstellen, möchten Sie wahrscheinlich eine gewisse **Replikation von Prozessen**, um **mehrere CPU-Kerne** zu nutzen und mehr Requests bearbeiten zu können. +Wenn Sie Anwendungen bereitstellen, möchten Sie wahrscheinlich eine gewisse **Replikation von Prozessen**, um **mehrere Kerne** zu nutzen und mehr Requests bearbeiten zu können. Wie Sie im vorherigen Kapitel über [Deployment-Konzepte](concepts.md){.internal-link target=_blank} gesehen haben, gibt es mehrere Strategien, die Sie anwenden können. -Hier zeige ich Ihnen, wie Sie **Gunicorn** mit **Uvicorn Workerprozessen** verwenden. +Hier zeige ich Ihnen, wie Sie **Uvicorn** mit **Workerprozessen** verwenden, indem Sie den `fastapi`-Befehl oder den `uvicorn`-Befehl direkt verwenden. -/// info +/// info | Info Wenn Sie Container verwenden, beispielsweise mit Docker oder Kubernetes, erzähle ich Ihnen mehr darüber im nächsten Kapitel: [FastAPI in Containern – Docker](docker.md){.internal-link target=_blank}. -Insbesondere wenn die Anwendung auf **Kubernetes** läuft, werden Sie Gunicorn wahrscheinlich **nicht** verwenden wollen und stattdessen **einen einzelnen Uvicorn-Prozess pro Container** ausführen wollen, aber ich werde Ihnen später in diesem Kapitel mehr darüber erzählen. +Insbesondere wenn die Anwendung auf **Kubernetes** läuft, werden Sie wahrscheinlich **keine** Worker verwenden wollen, und stattdessen **einen einzelnen Uvicorn-Prozess pro Container** ausführen wollen, aber ich werde Ihnen später in diesem Kapitel mehr darüber erzählen. /// -## Gunicorn mit Uvicorn-Workern +## Mehrere Worker -**Gunicorn** ist hauptsächlich ein Anwendungsserver, der den **WSGI-Standard** verwendet. Das bedeutet, dass Gunicorn Anwendungen wie Flask und Django ausliefern kann. Gunicorn selbst ist nicht mit **FastAPI** kompatibel, da FastAPI den neuesten **ASGI-Standard** verwendet. +Sie können mehrere Worker mit der `--workers`-Befehlszeilenoption starten: -Aber Gunicorn kann als **Prozessmanager** arbeiten und Benutzer können ihm mitteilen, welche bestimmte **Workerprozessklasse** verwendet werden soll. Dann würde Gunicorn einen oder mehrere **Workerprozesse** starten, diese Klasse verwendend. +//// tab | `fastapi` -Und **Uvicorn** hat eine **Gunicorn-kompatible Workerklasse**. - -Mit dieser Kombination würde Gunicorn als **Prozessmanager** fungieren und den **Port** und die **IP** abhören. Und er würde die Kommunikation an die Workerprozesse **weiterleiten**, welche die **Uvicorn-Klasse** ausführen. - -Und dann wäre die Gunicorn-kompatible **Uvicorn-Worker**-Klasse dafür verantwortlich, die von Gunicorn gesendeten Daten in den ASGI-Standard zu konvertieren, damit FastAPI diese verwenden kann. - -## Gunicorn und Uvicorn installieren +Wenn Sie den `fastapi`-Befehl verwenden:
```console -$ pip install "uvicorn[standard]" gunicorn - ----> 100% -``` - -
+$ fastapi run --workers 4 main.py -Dadurch wird sowohl Uvicorn mit zusätzlichen `standard`-Packages (um eine hohe Leistung zu erzielen) als auch Gunicorn installiert. + FastAPI Starting production server 🚀 -## Gunicorn mit Uvicorn-Workern ausführen + Searching for package file structure from directories with + __init__.py files + Importing from /home/user/code/awesomeapp -Dann können Sie Gunicorn ausführen mit: + module 🐍 main.py -
- -```console -$ gunicorn main:app --workers 4 --worker-class uvicorn.workers.UvicornWorker --bind 0.0.0.0:80 - -[19499] [INFO] Starting gunicorn 20.1.0 -[19499] [INFO] Listening at: http://0.0.0.0:80 (19499) -[19499] [INFO] Using worker: uvicorn.workers.UvicornWorker -[19511] [INFO] Booting worker with pid: 19511 -[19513] [INFO] Booting worker with pid: 19513 -[19514] [INFO] Booting worker with pid: 19514 -[19515] [INFO] Booting worker with pid: 19515 -[19511] [INFO] Started server process [19511] -[19511] [INFO] Waiting for application startup. -[19511] [INFO] Application startup complete. -[19513] [INFO] Started server process [19513] -[19513] [INFO] Waiting for application startup. -[19513] [INFO] Application startup complete. -[19514] [INFO] Started server process [19514] -[19514] [INFO] Waiting for application startup. -[19514] [INFO] Application startup complete. -[19515] [INFO] Started server process [19515] -[19515] [INFO] Waiting for application startup. -[19515] [INFO] Application startup complete. -``` - -
+ code Importing the FastAPI app object from the module with the + following code: -Sehen wir uns an, was jede dieser Optionen bedeutet: + from main import app -* `main:app`: Das ist die gleiche Syntax, die auch von Uvicorn verwendet wird. `main` bedeutet das Python-Modul mit dem Namen `main`, also eine Datei `main.py`. Und `app` ist der Name der Variable, welche die **FastAPI**-Anwendung ist. - * Stellen Sie sich einfach vor, dass `main:app` einer Python-`import`-Anweisung wie der folgenden entspricht: + app Using import string: main:app - ```Python - from main import app - ``` + server Server started at http://0.0.0.0:8000 + server Documentation at http://0.0.0.0:8000/docs - * Der Doppelpunkt in `main:app` entspricht also dem Python-`import`-Teil in `from main import app`. + Logs: -* `--workers`: Die Anzahl der zu verwendenden Workerprozesse, jeder führt einen Uvicorn-Worker aus, in diesem Fall 4 Worker. - -* `--worker-class`: Die Gunicorn-kompatible Workerklasse zur Verwendung in den Workerprozessen. - * Hier übergeben wir die Klasse, die Gunicorn etwa so importiert und verwendet: - - ```Python - import uvicorn.workers.UvicornWorker - ``` - -* `--bind`: Das teilt Gunicorn die IP und den Port mit, welche abgehört werden sollen, wobei ein Doppelpunkt (`:`) verwendet wird, um die IP und den Port zu trennen. - * Wenn Sie Uvicorn direkt ausführen würden, würden Sie anstelle von `--bind 0.0.0.0:80` (die Gunicorn-Option) stattdessen `--host 0.0.0.0` und `--port 80` verwenden. - -In der Ausgabe können Sie sehen, dass die **PID** (Prozess-ID) jedes Prozesses angezeigt wird (es ist nur eine Zahl). - -Sie können sehen, dass: - -* Der Gunicorn **Prozessmanager** beginnt, mit der PID `19499` (in Ihrem Fall ist es eine andere Nummer). -* Dann beginnt er zu lauschen: `Listening at: http://0.0.0.0:80`. -* Dann erkennt er, dass er die Workerklasse `uvicorn.workers.UvicornWorker` verwenden muss. -* Und dann werden **4 Worker** gestartet, jeder mit seiner eigenen PID: `19511`, `19513`, `19514` und `19515`. - -Gunicorn würde sich bei Bedarf auch um die Verwaltung **beendeter Prozesse** und den **Neustart** von Prozessen kümmern, um die Anzahl der Worker aufrechtzuerhalten. Das hilft also teilweise beim **Neustarts**-Konzept aus der obigen Liste. - -Dennoch möchten Sie wahrscheinlich auch etwas außerhalb haben, um sicherzustellen, dass Gunicorn bei Bedarf **neu gestartet wird**, und er auch **beim Hochfahren ausgeführt wird**, usw. + INFO Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to + quit) + INFO Started parent process [27365] + INFO Started server process [27368] + INFO Started server process [27369] + INFO Started server process [27370] + INFO Started server process [27367] + INFO Waiting for application startup. + INFO Waiting for application startup. + INFO Waiting for application startup. + INFO Waiting for application startup. + INFO Application startup complete. + INFO Application startup complete. + INFO Application startup complete. + INFO Application startup complete. +``` -## Uvicorn mit Workern +
-Uvicorn bietet ebenfalls die Möglichkeit, mehrere **Workerprozesse** zu starten und auszuführen. +//// -Dennoch sind die Fähigkeiten von Uvicorn zur Abwicklung von Workerprozessen derzeit eingeschränkter als die von Gunicorn. Wenn Sie also einen Prozessmanager auf dieser Ebene (auf der Python-Ebene) haben möchten, ist es vermutlich besser, es mit Gunicorn als Prozessmanager zu versuchen. +//// tab | `uvicorn` -Wie auch immer, Sie würden es so ausführen: +Wenn Sie den `uvicorn`-Befehl direkt verwenden möchten:
@@ -149,19 +105,21 @@ $ uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
+//// + Die einzige neue Option hier ist `--workers`, die Uvicorn anweist, 4 Workerprozesse zu starten. Sie können auch sehen, dass die **PID** jedes Prozesses angezeigt wird, `27365` für den übergeordneten Prozess (dies ist der **Prozessmanager**) und eine für jeden Workerprozess: `27368`, `27369`, `27370` und `27367`. ## Deployment-Konzepte -Hier haben Sie gesehen, wie Sie mit **Gunicorn** (oder Uvicorn) **Uvicorn-Workerprozesse** verwalten, um die Ausführung der Anwendung zu **parallelisieren**, **mehrere Kerne** der CPU zu nutzen und in der Lage zu sein, **mehr Requests** zu bedienen. +Hier haben Sie gesehen, wie Sie mehrere **Worker** verwenden, um die Ausführung der Anwendung zu **parallelisieren**, **mehrere Kerne** der CPU zu nutzen und in der Lage zu sein, **mehr Requests** zu bedienen. In der Liste der Deployment-Konzepte von oben würde die Verwendung von Workern hauptsächlich beim **Replikation**-Teil und ein wenig bei **Neustarts** helfen, aber Sie müssen sich trotzdem um die anderen kümmern: * **Sicherheit – HTTPS** * **Beim Hochfahren ausführen** -* **Neustarts** +* ***Neustarts*** * Replikation (die Anzahl der laufenden Prozesse) * **Arbeitsspeicher** * **Schritte vor dem Start** @@ -170,14 +128,12 @@ In der Liste der Deployment-Konzepte von oben würde die Verwendung von Workern Im nächsten Kapitel über [FastAPI in Containern – Docker](docker.md){.internal-link target=_blank} werde ich einige Strategien erläutern, die Sie für den Umgang mit den anderen **Deployment-Konzepten** verwenden können. -Ich zeige Ihnen auch das **offizielle Docker-Image**, welches **Gunicorn mit Uvicorn-Workern** und einige Standardkonfigurationen enthält, die für einfache Fälle nützlich sein können. - -Dort zeige ich Ihnen auch, wie Sie **Ihr eigenes Image von Grund auf erstellen**, um einen einzelnen Uvicorn-Prozess (ohne Gunicorn) auszuführen. Es ist ein einfacher Vorgang und wahrscheinlich das, was Sie tun möchten, wenn Sie ein verteiltes Containerverwaltungssystem wie **Kubernetes** verwenden. +Ich zeige Ihnen, wie Sie **Ihr eigenes Image von Grund auf erstellen**, um einen einzelnen Uvicorn-Prozess auszuführen. Es ist ein einfacher Vorgang und wahrscheinlich das, was Sie tun möchten, wenn Sie ein verteiltes Containerverwaltungssystem wie **Kubernetes** verwenden. ## Zusammenfassung -Sie können **Gunicorn** (oder auch Uvicorn) als Prozessmanager mit Uvicorn-Workern verwenden, um **Multikern-CPUs** zu nutzen und **mehrere Prozesse parallel** auszuführen. +Sie können mehrere Workerprozesse mit der `--workers`-CLI-Option über die `fastapi`- oder `uvicorn`-Befehle nutzen, um **Multikern-CPUs** auszunutzen und **mehrere Prozesse parallel** auszuführen. -Sie können diese Tools und Ideen nutzen, wenn Sie **Ihr eigenes Deployment-System** einrichten und sich dabei selbst um die anderen Deployment-Konzepte kümmern. +Sie könnten diese Tools und Ideen nutzen, wenn Sie **Ihr eigenes Deployment-System** einrichten und sich dabei selbst um die anderen Deployment-Konzepte kümmern. Schauen Sie sich das nächste Kapitel an, um mehr über **FastAPI** mit Containern (z. B. Docker und Kubernetes) zu erfahren. Sie werden sehen, dass diese Tools auch einfache Möglichkeiten bieten, die anderen **Deployment-Konzepte** zu lösen. ✨ diff --git a/docs/de/docs/help-fastapi.md b/docs/de/docs/help-fastapi.md index 0b9c52316..c0283c1ff 100644 --- a/docs/de/docs/help-fastapi.md +++ b/docs/de/docs/help-fastapi.md @@ -1,72 +1,73 @@ # FastAPI helfen – Hilfe erhalten -Gefällt Ihnen **FastAPI**? +Mögen Sie **FastAPI**? Möchten Sie FastAPI, anderen Benutzern und dem Autor helfen? Oder möchten Sie Hilfe zu **FastAPI** erhalten? -Es gibt sehr einfache Möglichkeiten zu helfen (manche erfordern nur ein oder zwei Klicks). +Es gibt sehr einfache Möglichkeiten zu helfen (einige erfordern nur ein oder zwei Klicks). -Und es gibt auch viele Möglichkeiten, Hilfe zu bekommen. +Und es gibt auch mehrere Möglichkeiten, Hilfe zu bekommen. ## Newsletter abonnieren -Sie können den (unregelmäßig erscheinenden) [**FastAPI and Friends**-Newsletter](newsletter.md){.internal-link target=_blank} abonnieren, um auf dem Laufenden zu bleiben: +Sie können den (unregelmäßigen) [**FastAPI and friends**-Newsletter](newsletter.md){.internal-link target=_blank} abonnieren, um über folgende Themen informiert zu bleiben: -* Neuigkeiten über FastAPI and Friends 🚀 +* Neuigkeiten über FastAPI und Freunde 🚀 * Anleitungen 📝 * Funktionen ✨ * Breaking Changes 🚨 * Tipps und Tricks ✅ + ## FastAPI auf Twitter folgen Folgen Sie @fastapi auf **Twitter**, um die neuesten Nachrichten über **FastAPI** zu erhalten. 🐦 ## **FastAPI** auf GitHub einen Stern geben -Sie können FastAPI auf GitHub „starren“ (durch Klicken auf den Stern-Button oben rechts): https://github.com/fastapi/fastapi. ⭐️ +Sie können FastAPI auf GitHub „starren“ (klicken Sie auf den Stern-Button oben rechts): https://github.com/fastapi/fastapi. ⭐️ Durch das Hinzufügen eines Sterns können andere Benutzer es leichter finden und sehen, dass es für andere bereits nützlich war. -## Das GitHub-Repository auf Releases beobachten +## Das GitHub-Repository auf Releases überwachen -Sie können FastAPI in GitHub beobachten (Klicken Sie oben rechts auf den Button „watch“): https://github.com/fastapi/fastapi. 👀 +Sie können FastAPI auf GitHub „beobachten“ (klicken Sie auf den „watch“-Button oben rechts): https://github.com/fastapi/fastapi. 👀 Dort können Sie „Releases only“ auswählen. -Auf diese Weise erhalten Sie Benachrichtigungen (per E-Mail), wenn es einen neuen Release (eine neue Version) von **FastAPI** mit Fehlerbehebungen und neuen Funktionen gibt. +Auf diese Weise erhalten Sie Benachrichtigungen (per E-Mail), wenn es ein neues Release (eine neue Version) von **FastAPI** mit Bugfixes und neuen Funktionen gibt. ## Mit dem Autor vernetzen Sie können sich mit mir (Sebastián Ramírez / `tiangolo`), dem Autor, verbinden. -Insbesondere: +Sie können: -* Folgen Sie mir auf **GitHub**. - * Finden Sie andere Open-Source-Projekte, die ich erstellt habe und die Ihnen helfen könnten. - * Folgen Sie mir, um mitzubekommen, wenn ich ein neues Open-Source-Projekt erstelle. -* Folgen Sie mir auf **Twitter** oder Mastodon. - * Berichten Sie mir, wie Sie FastAPI verwenden (das höre ich gerne). - * Bekommen Sie mit, wenn ich Ankündigungen mache oder neue Tools veröffentliche. +* Mir auf **GitHub** folgen. + * Andere Open-Source-Projekte sehen, die ich erstellt habe und die Ihnen helfen könnten. + * Mir folgen, um zu sehen, wenn ich ein neues Open-Source-Projekt erstelle. +* Mir auf **Twitter** folgen oder Mastodon. + * Mir mitteilen, wie Sie FastAPI verwenden (ich höre das gerne). + * Mitbekommen, wenn ich Ankündigungen mache oder neue Tools veröffentliche. * Sie können auch @fastapi auf Twitter folgen (ein separates Konto). -* Folgen Sie mir auf **LinkedIn**. - * Bekommen Sie mit, wenn ich Ankündigungen mache oder neue Tools veröffentliche (obwohl ich Twitter häufiger verwende 🤷‍♂). -* Lesen Sie, was ich schreibe (oder folgen Sie mir) auf **Dev.to** oder **Medium**. - * Lesen Sie andere Ideen, Artikel, und erfahren Sie mehr über die von mir erstellten Tools. - * Folgen Sie mir, um zu lesen, wenn ich etwas Neues veröffentliche. +* Mir auf **LinkedIn** folgen. + * Mitbekommen, wenn ich Ankündigungen mache oder neue Tools veröffentliche (obwohl ich Twitter häufiger verwende 🤷‍♂). +* Lesen, was ich schreibe (oder mir folgen) auf **Dev.to** oder **Medium**. + * Andere Ideen, Artikel lesen und mehr über die von mir erstellten Tools erfahren. + * Mir folgen, um zu lesen, wenn ich etwas Neues veröffentliche. ## Über **FastAPI** tweeten -Tweeten Sie über **FastAPI** und teilen Sie mir und anderen mit, warum es Ihnen gefällt. 🎉 +Tweeten Sie über **FastAPI** und teilen Sie mir und anderen mit, warum es Ihnen gefällt. 🎉 Ich höre gerne, wie **FastAPI** verwendet wird, was Ihnen daran gefallen hat, in welchem Projekt/Unternehmen Sie es verwenden, usw. ## Für FastAPI abstimmen -* Stimmen Sie für **FastAPI** auf Slant. +* Stimmen Sie für **FastAPI** auf Slant. * Stimmen Sie für **FastAPI** auf AlternativeTo. -* Berichten Sie auf StackShare, dass Sie **FastAPI** verwenden. +* Sagen Sie auf StackShare, dass Sie **FastAPI** verwenden. ## Anderen bei Fragen auf GitHub helfen @@ -77,19 +78,19 @@ Sie können versuchen, anderen bei ihren Fragen zu helfen: In vielen Fällen kennen Sie möglicherweise bereits die Antwort auf diese Fragen. 🤓 -Wenn Sie vielen Menschen bei ihren Fragen helfen, werden Sie offizieller [FastAPI-Experte](fastapi-people.md#experten){.internal-link target=_blank}. 🎉 +Wenn Sie vielen Menschen bei ihren Fragen helfen, werden Sie offizieller [FastAPI-Experte](fastapi-people.md#fastapi-experts){.internal-link target=_blank}. 🎉 -Denken Sie aber daran, der wichtigste Punkt ist: Versuchen Sie, freundlich zu sein. Die Leute bringen ihre Frustrationen mit und fragen in vielen Fällen nicht auf die beste Art und Weise, aber versuchen Sie dennoch so gut wie möglich, freundlich zu sein. 🤗 +Denken Sie daran, der wichtigste Punkt ist: Versuchen Sie, freundlich zu sein. Die Leute bringen ihre Frustrationen mit und fragen in vielen Fällen nicht auf die beste Art und Weise, aber versuchen Sie dennoch so gut wie möglich, freundlich zu sein. 🤗 -Die **FastAPI**-Community soll freundlich und einladend sein. Und auch kein Mobbing oder respektloses Verhalten gegenüber anderen akzeptieren. Wir müssen uns umeinander kümmern. +Die **FastAPI**-Community soll freundlich und einladend sein. Akzeptieren Sie gleichzeitig kein Mobbing oder respektloses Verhalten gegenüber anderen. Wir müssen uns umeinander kümmern. --- -So helfen Sie anderen bei Fragen (in Diskussionen oder Problemen): +So helfen Sie anderen bei Fragen (in Diskussionen oder Issues): ### Die Frage verstehen -* Fragen Sie sich, ob Sie verstehen, was das **Ziel** und der Anwendungsfall der fragenden Person ist. +* Prüfen Sie, ob Sie verstehen können, was der **Zweck** und der Anwendungsfall der fragenden Person ist. * Überprüfen Sie dann, ob die Frage (die überwiegende Mehrheit sind Fragen) **klar** ist. @@ -99,13 +100,13 @@ So helfen Sie anderen bei Fragen (in Diskussionen oder Problemen): ### Das Problem reproduzieren -In den meisten Fällen und bei den meisten Fragen ist etwas mit dem von der Person erstellten **eigenen Quellcode** los. +In den meisten Fällen und bei den meisten Fragen gibt es etwas in Bezug auf den **Originalcode** der Person. In vielen Fällen wird nur ein Fragment des Codes gepostet, aber das reicht nicht aus, um **das Problem zu reproduzieren**. -* Sie können die Person darum bitten, ein minimales, reproduzierbares Beispiel bereitzustellen, welches Sie **kopieren, einfügen** und lokal ausführen können, um den gleichen Fehler oder das gleiche Verhalten zu sehen, das die Person sieht, oder um ihren Anwendungsfall besser zu verstehen. +* Sie können die Person bitten, ein minimales, reproduzierbares Beispiel bereitzustellen, welches Sie **kopieren, einfügen** und lokal ausführen können, um den gleichen Fehler oder das gleiche Verhalten zu sehen, das die Person sieht, oder um ihren Anwendungsfall besser zu verstehen. -* Wenn Sie in Geberlaune sind, können Sie versuchen, selbst ein solches Beispiel zu erstellen, nur basierend auf der Beschreibung des Problems. Denken Sie jedoch daran, dass dies viel Zeit in Anspruch nehmen kann und dass es besser sein kann, zunächst um eine Klärung des Problems zu bitten. +* Wenn Sie in Geberlaune sind, können Sie ein solches Beispiel selbst erstellen, nur basierend auf der Beschreibung des Problems. Denken Sie jedoch daran, dass dies viel Zeit in Anspruch nehmen kann und dass es besser sein kann, zunächst um eine Klärung des Problems zu bitten. ### Lösungen vorschlagen @@ -115,7 +116,7 @@ In vielen Fällen wird nur ein Fragment des Codes gepostet, aber das reicht nich ### Um Schließung bitten -Wenn die Person antwortet, besteht eine hohe Chance, dass Sie ihr Problem gelöst haben. Herzlichen Glückwunsch, **Sie sind ein Held**! 🦸 +Wenn sie antworten, besteht eine hohe Chance, dass Sie ihr Problem gelöst haben. Herzlichen Glückwunsch, **Sie sind ein Held**! 🦸 * Wenn es tatsächlich das Problem gelöst hat, können Sie sie darum bitten: @@ -124,9 +125,9 @@ Wenn die Person antwortet, besteht eine hohe Chance, dass Sie ihr Problem gelös ## Das GitHub-Repository beobachten -Sie können FastAPI auf GitHub „beobachten“ (Klicken Sie oben rechts auf die Schaltfläche „watch“): https://github.com/fastapi/fastapi. 👀 +Sie können FastAPI auf GitHub „beobachten“ (klicken Sie auf den „watch“-Button oben rechts): https://github.com/fastapi/fastapi. 👀 -Wenn Sie dann „Watching“ statt „Releases only“ auswählen, erhalten Sie Benachrichtigungen, wenn jemand ein neues Issue eröffnet oder eine neue Frage stellt. Sie können auch spezifizieren, dass Sie nur über neue Issues, Diskussionen, PRs, usw. benachrichtigt werden möchten. +Wenn Sie dann „Watching“ statt „Releases only“ auswählen, erhalten Sie Benachrichtigungen, wenn jemand ein neues Issue eröffnet oder eine neue Frage stellt. Sie können auch spezifizieren, dass Sie nur über neue Issues, Diskussionen, PRs usw. benachrichtigt werden möchten. Dann können Sie versuchen, bei der Lösung solcher Fragen zu helfen. @@ -141,7 +142,7 @@ Sie können im GitHub-Repository diese Datei bearbeiten. * Stellen Sie sicher, dass Sie Ihren Link am Anfang des entsprechenden Abschnitts einfügen. -* Um zu helfen, [die Dokumentation in Ihre Sprache zu übersetzen](contributing.md#ubersetzungen){.internal-link target=_blank}. +* Um zu helfen, [die Dokumentation in Ihre Sprache zu übersetzen](contributing.md#translations){.internal-link target=_blank}. * Sie können auch dabei helfen, die von anderen erstellten Übersetzungen zu überprüfen (Review). * Um neue Dokumentationsabschnitte vorzuschlagen. -* Um ein bestehendes Problem / einen bestehenden Bug zu beheben. +* Um ein bestehendes Problem/Bug zu beheben. * Stellen Sie sicher, dass Sie Tests hinzufügen. * Um eine neue Funktionalität hinzuzufügen. * Stellen Sie sicher, dass Sie Tests hinzufügen. @@ -211,26 +212,26 @@ Sie können zum Quellcode mit Pull Requests [beitragen](contributing.md){.intern ## FastAPI pflegen -Helfen Sie mir, **FastAPI** instand zu halten! 🤓 +Helfen Sie mir, **FastAPI** zu pflegen! 🤓 Es gibt viel zu tun, und das meiste davon können **SIE** tun. Die Hauptaufgaben, die Sie jetzt erledigen können, sind: -* [Helfen Sie anderen bei Fragen auf GitHub](#anderen-bei-fragen-auf-github-helfen){.internal-link target=_blank} (siehe Abschnitt oben). -* [Prüfen Sie Pull Requests](#pull-requests-prufen){.internal-link target=_blank} (siehe Abschnitt oben). +* [Anderen bei Fragen auf GitHub helfen](#andere-bei-fragen-auf-github-helfen){.internal-link target=_blank} (siehe Abschnitt oben). +* [Pull Requests prüfen](#pull-requests-prufen){.internal-link target=_blank} (siehe Abschnitt oben). -Diese beiden Dinge sind es, die **die meiste Zeit in Anspruch nehmen**. Das ist die Hauptarbeit bei der Wartung von FastAPI. +Diese beiden Aufgaben sind die Dinge, die **am meisten Zeit verbrauchen**. Das ist die Hauptarbeit bei der Wartung von FastAPI. -Wenn Sie mir dabei helfen können, **helfen Sie mir, FastAPI am Laufen zu erhalten** und sorgen dafür, dass es weiterhin **schneller und besser voranschreitet**. 🚀 +Wenn Sie mir dabei helfen können, **helfen Sie mir, FastAPI zu pflegen** und stellen sicher, dass es weiterhin **schneller und besser voranschreitet**. 🚀 -## Beim Chat mitmachen +## Am Chat teilnehmen -Treten Sie dem 👥 Discord-Chatserver 👥 bei und treffen Sie sich mit anderen Mitgliedern der FastAPI-Community. +Treten Sie dem 👥 Discord-Chat-Server 👥 bei und treffen Sie sich mit anderen Mitgliedern der FastAPI-Community. /// tip | Tipp -Wenn Sie Fragen haben, stellen Sie sie bei GitHub Diskussionen, es besteht eine viel bessere Chance, dass Sie hier Hilfe von den [FastAPI-Experten](fastapi-people.md#experten){.internal-link target=_blank} erhalten. +Bei Fragen stellen Sie sie in GitHub-Diskussionen, dort besteht eine viel größere Chance, dass Sie Hilfe von den [FastAPI-Experten](fastapi-people.md#fastapi-experts){.internal-link target=_blank} erhalten. Nutzen Sie den Chat nur für andere allgemeine Gespräche. @@ -238,30 +239,17 @@ Nutzen Sie den Chat nur für andere allgemeine Gespräche. ### Den Chat nicht für Fragen verwenden -Bedenken Sie, da Chats mehr „freie Konversation“ ermöglichen, dass es verlockend ist, Fragen zu stellen, die zu allgemein und schwierig zu beantworten sind, sodass Sie möglicherweise keine Antworten erhalten. +Bedenken Sie, dass Sie in Chats, die „freie Konversation“ erlauben, leicht Fragen stellen können, die zu allgemein und schwer zu beantworten sind, sodass Sie möglicherweise keine Antworten erhalten. -Auf GitHub hilft Ihnen die Vorlage dabei, die richtige Frage zu schreiben, sodass Sie leichter eine gute Antwort erhalten oder das Problem sogar selbst lösen können, noch bevor Sie fragen. Und auf GitHub kann ich sicherstellen, dass ich immer alles beantworte, auch wenn es einige Zeit dauert. Ich persönlich kann das mit den Chat-Systemen nicht machen. 😅 +Auf GitHub hilft Ihnen die Vorlage dabei, die richtige Frage zu stellen, sodass Sie leichter eine gute Antwort erhalten können, oder sogar das Problem selbst lösen, bevor Sie überhaupt fragen. Und auf GitHub kann ich sicherstellen, dass ich immer alles beantworte, auch wenn es einige Zeit dauert. Persönlich kann ich das mit den Chat-Systemen nicht machen. 😅 -Unterhaltungen in den Chat-Systemen sind außerdem nicht so leicht durchsuchbar wie auf GitHub, sodass Fragen und Antworten möglicherweise im Gespräch verloren gehen. Und nur die auf GitHub machen einen [FastAPI-Experten](fastapi-people.md#experten){.internal-link target=_blank}, Sie werden also höchstwahrscheinlich mehr Aufmerksamkeit auf GitHub erhalten. +Unterhaltungen in den Chat-Systemen sind auch nicht so leicht durchsuchbar wie auf GitHub, sodass Fragen und Antworten möglicherweise im Gespräch verloren gehen. Und nur die auf GitHub machen einen [FastAPI-Experten](fastapi-people.md#fastapi-experts){.internal-link target=_blank}, Sie werden also höchstwahrscheinlich mehr Aufmerksamkeit auf GitHub erhalten. Auf der anderen Seite gibt es Tausende von Benutzern in den Chat-Systemen, sodass die Wahrscheinlichkeit hoch ist, dass Sie dort fast immer jemanden zum Reden finden. 😄 ## Den Autor sponsern -Sie können den Autor (mich) auch über GitHub-Sponsoren finanziell unterstützen. - -Dort könnten Sie mir als Dankeschön einen Kaffee spendieren ☕️. 😄 - -Und Sie können auch Silber- oder Gold-Sponsor für FastAPI werden. 🏅🎉 - -## Die Tools sponsern, die FastAPI unterstützen - -Wie Sie in der Dokumentation gesehen haben, steht FastAPI auf den Schultern von Giganten, Starlette und Pydantic. - -Sie können auch sponsern: - -* Samuel Colvin (Pydantic) -* Encode (Starlette, Uvicorn) +Wenn Ihr **Produkt/Firma** auf **FastAPI** angewiesen ist oder in Zusammenhang steht und Sie seine Benutzer erreichen möchten, können Sie den Autor (mich) über GitHub-Sponsoren unterstützen. Je nach Stufe können Sie einige zusätzliche Vorteile erhalten, wie z.B. ein Abzeichen in den Docs. 🎁 --- diff --git a/docs/de/docs/how-to/graphql.md b/docs/de/docs/how-to/graphql.md index 4083e66ae..b472e59cc 100644 --- a/docs/de/docs/how-to/graphql.md +++ b/docs/de/docs/how-to/graphql.md @@ -10,20 +10,20 @@ Sie können normale FastAPI-*Pfadoperationen* mit GraphQL in derselben Anwendung Es hat **Vorteile** und **Nachteile** im Vergleich zu gängigen **Web-APIs**. -Wiegen Sie ab, ob die **Vorteile** für Ihren Anwendungsfall die **Nachteile** ausgleichen. 🤓 +Stellen Sie sicher, dass Sie prüfen, ob die **Vorteile** für Ihren Anwendungsfall die **Nachteile** ausgleichen. 🤓 /// ## GraphQL-Bibliotheken -Hier sind einige der **GraphQL**-Bibliotheken, welche **ASGI** unterstützen. Diese könnten Sie mit **FastAPI** verwenden: +Hier sind einige der **GraphQL**-Bibliotheken, die **ASGI**-Unterstützung haben. Sie könnten sie mit **FastAPI** verwenden: * Strawberry 🍓 * Mit Dokumentation für FastAPI * Ariadne * Mit Dokumentation für FastAPI * Tartiflette - * Mit Tartiflette ASGI, für ASGI-Integration + * Mit Tartiflette ASGI zur Bereitstellung der ASGI-Integration * Graphene * Mit starlette-graphene3 @@ -31,21 +31,21 @@ Hier sind einige der **GraphQL**-Bibliotheken, welche **ASGI** unterstützen. Di Wenn Sie mit **GraphQL** arbeiten möchten oder müssen, ist **Strawberry** die **empfohlene** Bibliothek, da deren Design dem Design von **FastAPI** am nächsten kommt und alles auf **Typannotationen** basiert. -Abhängig von Ihrem Anwendungsfall bevorzugen Sie vielleicht eine andere Bibliothek, aber wenn Sie mich fragen würden, würde ich Ihnen wahrscheinlich empfehlen, **Strawberry** auszuprobieren. +Abhängig von Ihrem Anwendungsfall könnten Sie eine andere Bibliothek vorziehen, aber wenn Sie mich fragen würden, würde ich Ihnen wahrscheinlich empfehlen, **Strawberry** auszuprobieren. Hier ist eine kleine Vorschau, wie Sie Strawberry mit FastAPI integrieren können: -{* ../../docs_src/graphql/tutorial001.py hl[3,22,25:26] *} +{* ../../docs_src/graphql/tutorial001.py hl[3,22,25] *} Weitere Informationen zu Strawberry finden Sie in der Strawberry-Dokumentation. -Und auch die Dokumentation zu Strawberry mit FastAPI. +Und auch in der Dokumentation zu Strawberry mit FastAPI. ## Ältere `GraphQLApp` von Starlette Frühere Versionen von Starlette enthielten eine `GraphQLApp`-Klasse zur Integration mit Graphene. -Das wurde von Starlette deprecated, aber wenn Sie Code haben, der das verwendet, können Sie einfach zu starlette-graphene3 **migrieren**, welches denselben Anwendungsfall abdeckt und über eine **fast identische Schnittstelle** verfügt. +Das wurde von Starlette deprecated, aber wenn Sie Code haben, der das verwendet, können Sie einfach zu starlette-graphene3 **migrieren**, das denselben Anwendungsfall abdeckt und eine **fast identische Schnittstelle** hat. /// tip | Tipp diff --git a/docs/de/docs/index.md b/docs/de/docs/index.md index d239f0815..435e5f14a 100644 --- a/docs/de/docs/index.md +++ b/docs/de/docs/index.md @@ -8,7 +8,7 @@ FastAPI

- FastAPI Framework, hochperformant, leicht zu erlernen, schnell zu programmieren, einsatzbereit + FastAPI-Framework, hochperformant, leicht zu erlernen, schnell zu programmieren, einsatzbereit

@@ -33,12 +33,11 @@ --- -FastAPI ist ein modernes, schnelles (hoch performantes) Webframework zur Erstellung von APIs mit Python auf Basis von Standard-Python-Typhinweisen. +FastAPI ist ein modernes, schnelles (hoch performantes) Webframework zur Erstellung von APIs mit Python auf Basis von Standard-Python-Type-Hinweisen. Seine Schlüssel-Merkmale sind: -* **Schnell**: Sehr hohe Leistung, auf Augenhöhe mit **NodeJS** und **Go** (Dank Starlette und Pydantic). [Eines der schnellsten verfügbaren Python-Frameworks](#performanz). - +* **Schnell**: Sehr hohe Leistung, auf Augenhöhe mit **NodeJS** und **Go** (dank Starlette und Pydantic). [Eines der schnellsten verfügbaren Python-Frameworks](#performance). * **Schnell zu programmieren**: Erhöhen Sie die Geschwindigkeit bei der Entwicklung von Funktionen um etwa 200 % bis 300 %. * * **Weniger Bugs**: Verringern Sie die von Menschen (Entwicklern) verursachten Fehler um etwa 40 %. * * **Intuitiv**: Exzellente Editor-Unterstützung. Code-Vervollständigung überall. Weniger Debuggen. @@ -47,9 +46,9 @@ Seine Schlüssel-Merkmale sind: * **Robust**: Erhalten Sie produktionsreifen Code. Mit automatischer, interaktiver Dokumentation. * **Standards-basiert**: Basierend auf (und vollständig kompatibel mit) den offenen Standards für APIs: OpenAPI (früher bekannt als Swagger) und JSON Schema. -* Schätzung auf Basis von Tests in einem internen Entwicklungsteam, das Produktionsanwendungen erstellt. +* Schätzung basierend auf Tests in einem internen Entwicklungsteam, das Produktionsanwendungen erstellt. -## Sponsoren +## Sponsoren @@ -64,9 +63,9 @@ Seine Schlüssel-Merkmale sind: -Andere Sponsoren +Andere Sponsoren -## Meinungen +## Meinungen „_[...] Ich verwende **FastAPI** heutzutage sehr oft. [...] Ich habe tatsächlich vor, es für alle **ML-Dienste meines Teams bei Microsoft** zu verwenden. Einige davon werden in das Kernprodukt **Windows** und einige **Office**-Produkte integriert._“ @@ -74,7 +73,7 @@ Seine Schlüssel-Merkmale sind: --- -„_Wir haben die **FastAPI**-Bibliothek genommen, um einen **REST**-Server zu erstellen, der abgefragt werden kann, um **Vorhersagen** zu erhalten. [für Ludwig]_“ +„_Wir haben die **FastAPI**-Bibliothek übernommen, um einen **REST**-Server zu erstellen, der für **Vorhersagen** abgefragt werden kann. [für Ludwig]_“

Piero Molino, Yaroslav Dudin, und Sai Sumanth Miryala - Uber (Ref)
@@ -88,13 +87,13 @@ Seine Schlüssel-Merkmale sind: „_Ich bin überglücklich mit **FastAPI**. Es macht so viel Spaß!_“ -
Brian Okken - Host des Python Bytes Podcast (Ref)
+
Brian Okken - Python Bytes Podcast-Host (Ref)
--- -„_Ehrlich, was Du gebaut hast, sieht super solide und poliert aus. In vielerlei Hinsicht ist es so, wie ich **Hug** haben wollte – es ist wirklich inspirierend, jemanden so etwas bauen zu sehen._“ +„_Ehrlich, was Sie gebaut haben, sieht super solide und poliert aus. In vielerlei Hinsicht ist es so, wie ich **Hug** haben wollte – es ist wirklich inspirierend, jemanden so etwas bauen zu sehen._“ -
Timothy Crosley - Autor von Hug (Ref)
+
Timothy Crosley - Hug-Autor (Ref)
--- @@ -102,7 +101,7 @@ Seine Schlüssel-Merkmale sind: „_Wir haben zu **FastAPI** für unsere **APIs** gewechselt [...] Ich denke, es wird Ihnen gefallen [...]_“ -
Ines Montani - Matthew Honnibal - Gründer von Explosion AI - Autoren von spaCy (Ref) - (Ref)
+
Ines Montani - Matthew Honnibal - Explosion AI-Gründer - spaCy-Autoren (Ref) - (Ref)
--- @@ -112,7 +111,7 @@ Seine Schlüssel-Merkmale sind: --- -## **Typer**, das FastAPI der CLIs +## **Typer**, das FastAPI der CLIs @@ -120,42 +119,34 @@ Wenn Sie eine Anforderungen FastAPI steht auf den Schultern von Giganten: * Starlette für die Webanteile. -* Pydantic für die Datenanteile. - -## Installation - -
- -```console -$ pip install fastapi - ----> 100% -``` +* Pydantic für die Datenanteile. -
+## Installation -Sie benötigen außerdem einen ASGI-Server. Für die Produktumgebung beispielsweise Uvicorn oder Hypercorn. +Erstellen und aktivieren Sie eine virtuelle Umgebung und installieren Sie dann FastAPI:
```console -$ pip install "uvicorn[standard]" +$ pip install "fastapi[standard]" ---> 100% ```
-## Beispiel +**Hinweis**: Stellen Sie sicher, dass Sie `"fastapi[standard]"` in Anführungszeichen setzen, damit es in allen Terminals funktioniert. -### Erstellung +## Beispiel -* Erstellen Sie eine Datei `main.py` mit: +### Erstellung + +Erstellen Sie eine Datei `main.py` mit dem folgenden Inhalt: ```Python from typing import Union @@ -198,23 +189,37 @@ async def read_item(item_id: int, q: Union[str, None] = None): return {"item_id": item_id, "q": q} ``` -**Anmerkung**: +**Hinweis**: + +Wenn Sie das nicht kennen, schauen Sie sich den Abschnitt _„In Eile?“_ über `async` und `await` in der Dokumentation an. -Wenn Sie das nicht kennen, schauen Sie sich den Abschnitt _„In Eile?“_ über `async` und `await` in der Dokumentation an. -### Starten +### Starten -Führen Sie den Server aus: +Starten Sie den Server mit:
```console -$ uvicorn main:app --reload - +$ fastapi dev main.py + + ╭────────── FastAPI CLI - Development mode ───────────╮ + │ │ + │ Serving at: http://127.0.0.1:8000 │ + │ │ + │ API docs: http://127.0.0.1:8000/docs │ + │ │ + │ Running in development mode, for production use: │ + │ │ + │ fastapi run │ + │ │ + ╰─────────────────────────────────────────────────────╯ + +INFO: Will watch for changes in these directories: ['/home/user/code/awesomeapp'] INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) -INFO: Started reloader process [28720] -INFO: Started server process [28722] +INFO: Started reloader process [2248755] using WatchFiles +INFO: Started server process [2248757] INFO: Waiting for application startup. INFO: Application startup complete. ``` @@ -222,34 +227,34 @@ INFO: Application startup complete.
-Was macht der Befehl uvicorn main:app --reload ... +Was der Befehl fastapi dev main.py macht... + +Der Befehl `fastapi dev` liest Ihre `main.py`-Datei, erkennt die **FastAPI**-App darin und startet einen Server mit Uvicorn. -Der Befehl `uvicorn main:app` bezieht sich auf: +Standardmäßig wird `fastapi dev` mit aktiviertem Auto-Reload für die lokale Entwicklung gestartet. -* `main`: die Datei `main.py` (das Python-„Modul“). -* `app`: das Objekt, das innerhalb von `main.py` mit der Zeile `app = FastAPI()` erzeugt wurde. -* `--reload`: lässt den Server nach Codeänderungen neu starten. Tun Sie das nur während der Entwicklung. +Sie können mehr darüber in der FastAPI CLI-Dokumentation lesen.
-### Testen +### Überprüfen Öffnen Sie Ihren Browser unter http://127.0.0.1:8000/items/5?q=somequery. -Sie erhalten die JSON-Response: +Sie sehen die JSON-Antwort als: ```JSON {"item_id": 5, "q": "somequery"} ``` -Damit haben Sie bereits eine API erstellt, welche: +Sie haben bereits eine API erstellt, welche: * HTTP-Anfragen auf den _Pfaden_ `/` und `/items/{item_id}` entgegennimmt. * Beide _Pfade_ erhalten `GET` Operationen (auch bekannt als HTTP _Methoden_). * Der _Pfad_ `/items/{item_id}` hat einen _Pfadparameter_ `item_id`, der ein `int` sein sollte. * Der _Pfad_ `/items/{item_id}` hat einen optionalen `str` _Query Parameter_ `q`. -### Interaktive API-Dokumentation +### Interaktive API-Dokumentation Gehen Sie nun auf http://127.0.0.1:8000/docs. @@ -257,15 +262,15 @@ Sie sehen die automatische interaktive API-Dokumentation (bereitgestellt von Alternative API-Dokumentation -Gehen Sie jetzt auf http://127.0.0.1:8000/redoc. +Und jetzt gehen Sie auf http://127.0.0.1:8000/redoc. Sie sehen die alternative automatische Dokumentation (bereitgestellt von ReDoc): ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png) -## Beispiel Aktualisierung +## Beispiel Aktualisierung Ändern Sie jetzt die Datei `main.py`, um den Body einer `PUT`-Anfrage zu empfangen. @@ -301,9 +306,9 @@ def update_item(item_id: int, item: Item): return {"item_name": item.name, "item_id": item_id} ``` -Der Server sollte automatisch neu geladen werden (weil Sie oben `--reload` zum Befehl `uvicorn` hinzugefügt haben). +Der `fastapi dev` Server sollte automatisch neu laden. -### Aktualisierung der interaktiven API-Dokumentation +### Aktualisierung der interaktiven API-Dokumentation Gehen Sie jetzt auf http://127.0.0.1:8000/docs. @@ -319,7 +324,7 @@ Gehen Sie jetzt auf Aktualisierung der alternativen API-Dokumentation Und nun gehen Sie auf http://127.0.0.1:8000/redoc. @@ -327,7 +332,7 @@ Und nun gehen Sie auf Zusammenfassung Zusammengefasst deklarieren Sie **einmal** die Typen von Parametern, Body, etc. als Funktionsparameter. @@ -335,7 +340,7 @@ Das machen Sie mit modernen Standard-Python-Typen. Sie müssen keine neue Syntax, Methoden oder Klassen einer bestimmten Bibliothek usw. lernen. -Nur Standard-**Python+**. +Nur Standard-**Python**. Zum Beispiel für ein `int`: @@ -422,9 +427,9 @@ Versuchen Sie, diese Zeile zu ändern: ![Editor Unterstützung](https://fastapi.tiangolo.com/img/vscode-completion.png) -Für ein vollständigeres Beispiel, mit weiteren Funktionen, siehe das Tutorial - Benutzerhandbuch. +Für ein vollständigeres Beispiel, mit weiteren Funktionen, siehe das Tutorial – Benutzerhandbuch. -**Spoiler-Alarm**: Das Tutorial - Benutzerhandbuch enthält: +**Spoiler-Alarm**: Das Tutorial – Benutzerhandbuch enthält: * Deklaration von **Parametern** von anderen verschiedenen Stellen wie: **Header-Felder**, **Cookies**, **Formularfelder** und **Dateien**. * Wie man **Validierungseinschränkungen** wie `maximum_length` oder `regex` setzt. @@ -434,41 +439,63 @@ Für ein vollständigeres Beispiel, mit weiteren Funktionen, siehe das Strawberry und anderen Bibliotheken. * Viele zusätzliche Funktionen (dank Starlette) wie: * **WebSockets** - * extrem einfache Tests auf Basis von `httpx` und `pytest` + * extrem einfache Tests auf Basis von HTTPX und `pytest` * **CORS** * **Cookie Sessions** * ... und mehr. -## Performanz +## Performanz { #performance } -Unabhängige TechEmpower-Benchmarks zeigen **FastAPI**-Anwendungen, die unter Uvicorn laufen, als eines der schnellsten verfügbaren Python-Frameworks, nur noch hinter Starlette und Uvicorn selbst (intern von FastAPI verwendet). +Unabhängige TechEmpower-Benchmarks zeigen **FastAPI**-Anwendungen, die unter Uvicorn laufen, als eines der schnellsten verfügbaren Python-Frameworks, nur hinter Starlette und Uvicorn selbst (intern von FastAPI verwendet). (*) Um mehr darüber zu erfahren, siehe den Abschnitt Benchmarks. -## Optionale Abhängigkeiten +## Abhängigkeiten + +FastAPI hängt von Pydantic und Starlette ab. + +### `standard` Abhängigkeiten + +Wenn Sie FastAPI mit `pip install "fastapi[standard]"` installieren, kommt es mit der `standard` Gruppe von optionalen Abhängigkeiten: Wird von Pydantic verwendet: * email-validator - für E-Mail-Validierung. -* pydantic-settings - für die Verwaltung von Einstellungen. -* pydantic-extra-types - für zusätzliche Typen, mit Pydantic zu verwenden. Wird von Starlette verwendet: * httpx - erforderlich, wenn Sie den `TestClient` verwenden möchten. * jinja2 - erforderlich, wenn Sie die Standardkonfiguration für Templates verwenden möchten. * python-multipart - erforderlich, wenn Sie Formulare mittels `request.form()` „parsen“ möchten. -* itsdangerous - erforderlich für `SessionMiddleware` Unterstützung. -* pyyaml - erforderlich für Starlette's `SchemaGenerator` Unterstützung (Sie brauchen das wahrscheinlich nicht mit FastAPI). -* ujson - erforderlich, wenn Sie `UJSONResponse` verwenden möchten. -Wird von FastAPI / Starlette verwendet: +Wird von FastAPI verwendet: -* uvicorn - für den Server, der Ihre Anwendung lädt und serviert. -* orjson - erforderlich, wenn Sie `ORJSONResponse` verwenden möchten. +* uvicorn - für den Server, der Ihre Anwendung lädt und bereitstellt. Dies beinhaltet `uvicorn[standard]`, das einige Abhängigkeiten (z. B. `uvloop`) enthält, die für hoch performantes Bereitstellen benötigt werden. +* `fastapi-cli[standard]` - um den `fastapi` Befehl bereitzustellen. + * Dies beinhaltet `fastapi-cloud-cli`, das es Ihnen ermöglicht, Ihre FastAPI-Anwendung auf FastAPI Cloud bereitzustellen. + +### Ohne `standard` Abhängigkeiten + +Wenn Sie die `standard` optionalen Abhängigkeiten nicht einschließen möchten, können Sie mit `pip install fastapi` statt `pip install "fastapi[standard]"` installieren. + +### Ohne `fastapi-cloud-cli` + +Wenn Sie FastAPI mit den Standardabhängigkeiten, aber ohne das `fastapi-cloud-cli` installieren möchten, können Sie mit `pip install "fastapi[standard-no-fastapi-cloud-cli]"` installieren. -Sie können diese alle mit `pip install "fastapi[all]"` installieren. +### Zusätzliche optionale Abhängigkeiten + +Es gibt einige zusätzliche Abhängigkeiten, die Sie installieren möchten. + +Zusätzliche optionale Pydantic-Abhängigkeiten: + +* pydantic-settings - für die Verwaltung von Einstellungen. +* pydantic-extra-types - für zusätzliche Typen, die mit Pydantic verwendet werden sollen. + +Zusätzliche optionale FastAPI-Abhängigkeiten: + +* orjson - erforderlich, wenn Sie `ORJSONResponse` verwenden möchten. +* ujson - erforderlich, wenn Sie `UJSONResponse` verwenden möchten. -## Lizenz +## Lizenz Dieses Projekt ist unter den Bedingungen der MIT-Lizenz lizenziert. diff --git a/docs/de/docs/project-generation.md b/docs/de/docs/project-generation.md index c47bcb6d3..b6dabfeeb 100644 --- a/docs/de/docs/project-generation.md +++ b/docs/de/docs/project-generation.md @@ -1,84 +1,28 @@ -# Projektgenerierung – Vorlage - -Sie können einen Projektgenerator für den Einstieg verwenden, welcher einen Großteil der Ersteinrichtung, Sicherheit, Datenbank und einige API-Endpunkte bereits für Sie erstellt. - -Ein Projektgenerator verfügt immer über ein sehr spezifisches Setup, das Sie aktualisieren und an Ihre eigenen Bedürfnisse anpassen sollten, aber es könnte ein guter Ausgangspunkt für Ihr Projekt sein. - -## Full Stack FastAPI PostgreSQL - -GitHub: https://github.com/tiangolo/full-stack-fastapi-postgresql - -### Full Stack FastAPI PostgreSQL – Funktionen - -* Vollständige **Docker**-Integration (Docker-basiert). -* Docker-Schwarmmodus-Deployment. -* **Docker Compose**-Integration und Optimierung für die lokale Entwicklung. -* **Produktionsbereit** Python-Webserver, verwendet Uvicorn und Gunicorn. -* Python **FastAPI**-Backend: - * **Schnell**: Sehr hohe Leistung, auf Augenhöhe mit **NodeJS** und **Go** (dank Starlette und Pydantic). - * **Intuitiv**: Hervorragende Editor-Unterstützung. Codevervollständigung überall. Weniger Zeitaufwand für das Debuggen. - * **Einfach**: Einfach zu bedienen und zu erlernen. Weniger Zeit für das Lesen von Dokumentationen. - * **Kurz**: Codeverdoppelung minimieren. Mehrere Funktionalitäten aus jeder Parameterdeklaration. - * **Robust**: Erhalten Sie produktionsbereiten Code. Mit automatischer, interaktiver Dokumentation. - * **Standards-basiert**: Basierend auf (und vollständig kompatibel mit) den offenen Standards für APIs: OpenAPI und JSON Schema. - * **Viele weitere Funktionen**, einschließlich automatischer Validierung, Serialisierung, interaktiver Dokumentation, Authentifizierung mit OAuth2-JWT-Tokens, usw. -* **Sicheres Passwort**-Hashing standardmäßig. -* **JWT-Token**-Authentifizierung. -* **SQLAlchemy**-Modelle (unabhängig von Flask-Erweiterungen, sodass sie direkt mit Celery-Workern verwendet werden können). -* Grundlegende Startmodelle für Benutzer (ändern und entfernen Sie nach Bedarf). -* **Alembic**-Migrationen. -* **CORS** (Cross Origin Resource Sharing). -* **Celery**-Worker, welche Modelle und Code aus dem Rest des Backends selektiv importieren und verwenden können. -* REST-Backend-Tests basierend auf **Pytest**, integriert in Docker, sodass Sie die vollständige API-Interaktion unabhängig von der Datenbank testen können. Da es in Docker ausgeführt wird, kann jedes Mal ein neuer Datenspeicher von Grund auf erstellt werden (Sie können also ElasticSearch, MongoDB, CouchDB oder was auch immer Sie möchten verwenden und einfach testen, ob die API funktioniert). -* Einfache Python-Integration mit **Jupyter-Kerneln** für Remote- oder In-Docker-Entwicklung mit Erweiterungen wie Atom Hydrogen oder Visual Studio Code Jupyter. -* **Vue**-Frontend: - * Mit Vue CLI generiert. - * Handhabung der **JWT-Authentifizierung**. - * Login-View. - * Nach der Anmeldung Hauptansicht des Dashboards. - * Haupt-Dashboard mit Benutzererstellung und -bearbeitung. - * Bearbeitung des eigenen Benutzers. - * **Vuex**. - * **Vue-Router**. - * **Vuetify** für schöne Material-Designkomponenten. - * **TypeScript**. - * Docker-Server basierend auf **Nginx** (konfiguriert, um gut mit Vue-Router zu funktionieren). - * Mehrstufigen Docker-Erstellung, sodass Sie kompilierten Code nicht speichern oder committen müssen. - * Frontend-Tests, welche zur Erstellungszeit ausgeführt werden (können auch deaktiviert werden). - * So modular wie möglich gestaltet, sodass es sofort einsatzbereit ist. Sie können es aber mit Vue CLI neu generieren oder es so wie Sie möchten erstellen und wiederverwenden, was Sie möchten. -* **PGAdmin** für die PostgreSQL-Datenbank, können Sie problemlos ändern, sodass PHPMyAdmin und MySQL verwendet wird. -* **Flower** für die Überwachung von Celery-Jobs. -* Load Balancing zwischen Frontend und Backend mit **Traefik**, sodass Sie beide unter derselben Domain haben können, getrennt durch den Pfad, aber von unterschiedlichen Containern ausgeliefert. -* Traefik-Integration, einschließlich automatischer Generierung von Let's Encrypt-**HTTPS**-Zertifikaten. -* GitLab **CI** (kontinuierliche Integration), einschließlich Frontend- und Backend-Testen. - -## Full Stack FastAPI Couchbase - -GitHub: https://github.com/tiangolo/full-stack-fastapi-couchbase - -⚠️ **WARNUNG** ⚠️ - -Wenn Sie ein neues Projekt von Grund auf starten, prüfen Sie die Alternativen hier. - -Zum Beispiel könnte der Projektgenerator Full Stack FastAPI PostgreSQL eine bessere Alternative sein, da er aktiv gepflegt und genutzt wird. Und er enthält alle neuen Funktionen und Verbesserungen. - -Es steht Ihnen weiterhin frei, den Couchbase-basierten Generator zu verwenden, wenn Sie möchten. Er sollte wahrscheinlich immer noch gut funktionieren, und wenn Sie bereits ein Projekt damit erstellt haben, ist das auch in Ordnung (und Sie haben es wahrscheinlich bereits an Ihre Bedürfnisse angepasst). - -Weitere Informationen hierzu finden Sie in der Dokumentation des Repos. - -## Full Stack FastAPI MongoDB - -... könnte später kommen, abhängig von meiner verfügbaren Zeit und anderen Faktoren. 😅 🎉 - -## Modelle für maschinelles Lernen mit spaCy und FastAPI - -GitHub: https://github.com/microsoft/cookiecutter-spacy-fastapi - -### Modelle für maschinelles Lernen mit spaCy und FastAPI – Funktionen - -* **spaCy** NER-Modellintegration. -* **Azure Cognitive Search**-Anforderungsformat integriert. -* **Produktionsbereit** Python-Webserver, verwendet Uvicorn und Gunicorn. -* **Azure DevOps** Kubernetes (AKS) CI/CD-Deployment integriert. -* **Mehrsprachig** Wählen Sie bei der Projekteinrichtung ganz einfach eine der integrierten Sprachen von spaCy aus. -* **Einfach erweiterbar** auf andere Modellframeworks (Pytorch, Tensorflow), nicht nur auf SpaCy. +# Full Stack FastAPI Template + +Vorlagen, die normalerweise mit einem bestimmten Setup geliefert werden, sind so konzipiert, dass sie flexibel und anpassbar sind. Dies ermöglicht es Ihnen, sie zu modifizieren und an die Anforderungen Ihres Projekts anzupassen und sie somit zu einem hervorragenden Ausgangspunkt zu machen. 🏁 + +Sie können folgende Vorlage verwenden, um loszulegen, da sie bereits vieles der anfänglichen Einrichtung, Sicherheit, Datenbank und einige API-Endpunkte für Sie eingerichtet hat. + +GitHub-Repository: Full Stack FastAPI Template + +## Full Stack FastAPI Template - Technologiestack und Funktionen + +- ⚡ [**FastAPI**](https://fastapi.tiangolo.com) für die Python-Backend-API. + - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) für die Interaktion mit der Python-SQL-Datenbank (ORM). + - 🔍 [Pydantic](https://docs.pydantic.dev), verwendet von FastAPI, für die Datenvalidierung und das Einstellungsmanagement. + - 💾 [PostgreSQL](https://www.postgresql.org) als SQL-Datenbank. +- 🚀 [React](https://react.dev) für das Frontend. + - 💃 Verwendung von TypeScript, Hooks, [Vite](https://vitejs.dev) und anderen Teilen eines modernen Frontend-Stacks. + - 🎨 [Chakra UI](https://chakra-ui.com) für die Frontend-Komponenten. + - 🤖 Ein automatisch generierter Frontend-Client. + - 🧪 [Playwright](https://playwright.dev) für End-to-End-Tests. + - 🦇 Unterstützung des Dunkelmodus. +- 🐋 [Docker Compose](https://www.docker.com) für Entwicklung und Produktion. +- 🔒 Sicheres Passwort-Hashing standardmäßig. +- 🔑 JWT-Token-Authentifizierung. +- 📫 E-Mail-basierte Passwortwiederherstellung. +- ✅ Tests mit [Pytest](https://pytest.org). +- 📞 [Traefik](https://traefik.io) als Reverse-Proxy / Load Balancer. +- 🚢 Deployment-Anleitungen unter Verwendung von Docker Compose, einschließlich der Einrichtung eines Frontend-Traefik-Proxys zur Handhabung automatischer HTTPS-Zertifikate. +- 🏭 CI (kontinuierliche Integration) und CD (kontinuierliche Bereitstellung) basierend auf GitHub Actions. diff --git a/docs/de/docs/tutorial/body-multiple-params.md b/docs/de/docs/tutorial/body-multiple-params.md index 8a9978d34..970957adc 100644 --- a/docs/de/docs/tutorial/body-multiple-params.md +++ b/docs/de/docs/tutorial/body-multiple-params.md @@ -1,6 +1,6 @@ # Body – Mehrere Parameter -Jetzt, da wir gesehen haben, wie `Path` und `Query` verwendet werden, schauen wir uns fortgeschrittenere Verwendungsmöglichkeiten von Requestbody-Deklarationen an. +Nun, da wir gesehen haben, wie `Path` und `Query` verwendet werden, schauen wir uns fortgeschrittenere Verwendungsmöglichkeiten von Requestbody-Deklarationen an. ## `Path`-, `Query`- und Body-Parameter vermischen @@ -18,7 +18,7 @@ Beachten Sie, dass in diesem Fall das `item`, welches vom Body genommen wird, op ## Mehrere Body-Parameter -Im vorherigen Beispiel erwartete die *Pfadoperation* einen JSON-Body mit den Attributen eines `Item`s, etwa: +Im vorherigen Beispiel erwarteten die *Pfadoperationen* einen JSON-Body mit den Attributen eines `Item`s, etwa: ```JSON { @@ -35,7 +35,7 @@ Aber Sie können auch mehrere Body-Parameter deklarieren, z. B. `item` und `user In diesem Fall wird **FastAPI** bemerken, dass es mehr als einen Body-Parameter in der Funktion gibt (zwei Parameter, die Pydantic-Modelle sind). -Es wird deshalb die Parameternamen als Schlüssel (Feldnamen) im Body verwenden, und erwartet einen Body wie folgt: +Es wird deshalb die Parameternamen als Schlüssel (Feldnamen) im Body verwenden und erwartet einen Body wie folgt: ```JSON { @@ -58,17 +58,17 @@ Beachten Sie, dass, obwohl `item` wie zuvor deklariert wurde, es nun unter einem /// -**FastAPI** wird die automatische Konvertierung des Requests übernehmen, sodass der Parameter `item` seinen spezifischen Inhalt bekommt, genau so wie der Parameter `user`. +**FastAPI** wird die automatische Konvertierung des Requests übernehmen, sodass der Parameter `item` seinen spezifischen Inhalt bekommt, und das Gleiche gilt für den Parameter `user`. -Es wird die Validierung dieser zusammengesetzten Daten übernehmen, und sie im OpenAPI-Schema und der automatischen Dokumentation dokumentieren. +Es wird die Validierung dieser zusammengesetzten Daten übernehmen, und diese im OpenAPI-Schema und der automatischen Dokumentation dokumentieren. ## Einzelne Werte im Body -So wie `Query` und `Path` für Query- und Pfad-Parameter, hat **FastAPI** auch das Äquivalent `Body`, um Extra-Daten für Body-Parameter zu definieren. +So wie `Query` und `Path` für Query- und Pfad-Parameter, stellt **FastAPI** das Äquivalent `Body` zur Verfügung, um Extra-Daten für Body-Parameter zu definieren. -Zum Beispiel, das vorherige Modell erweiternd, könnten Sie entscheiden, dass Sie einen weiteren Schlüssel `importance` haben möchten, im selben Body, Seite an Seite mit `item` und `user`. +Zum Beispiel, das vorherige Modell erweiternd, könnten Sie entscheiden, dass Sie einen weiteren Schlüssel `importance` im selben Body haben möchten, neben `item` und `user`. -Wenn Sie diesen Parameter einfach so hinzufügen, wird **FastAPI** annehmen, dass es ein Query-Parameter ist. +Wenn Sie diesen Parameter einfach so hinzufügen, wird **FastAPI** annehmen, dass es ein Query-Parameter ist, da er ein einzelner Wert ist. Aber Sie können **FastAPI** instruieren, ihn als weiteren Body-Schlüssel zu erkennen, indem Sie `Body` verwenden: @@ -92,7 +92,7 @@ In diesem Fall erwartet **FastAPI** einen Body wie: } ``` -Wiederum wird es die Daten konvertieren, validieren, dokumentieren, usw. +Wiederum wird es die Datentypen konvertieren, validieren, dokumentieren, usw. ## Mehrere Body-Parameter und Query-Parameter @@ -112,21 +112,21 @@ q: str | None = None Zum Beispiel: -{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[27] *} +{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *} -/// info +/// info | Info -`Body` hat die gleichen zusätzlichen Validierungs- und Metadaten-Parameter wie `Query` und `Path` und andere, die Sie später kennenlernen. +`Body` hat die gleichen zusätzlichen Validierungs- und Metadaten-Parameter wie `Query`, `Path` und andere, die Sie später kennenlernen werden. /// ## Einen einzelnen Body-Parameter einbetten -Nehmen wir an, Sie haben nur einen einzelnen `item`-Body-Parameter, ein Pydantic-Modell `Item`. +Nehmen wir an, Sie haben nur einen einzelnen `item`-Body-Parameter von einem Pydantic-Modell `Item`. -Normalerweise wird **FastAPI** dann seinen JSON-Body direkt erwarten. +Standardmäßig wird **FastAPI** dann seinen Body direkt erwarten. -Aber wenn Sie möchten, dass es einen JSON-Body erwartet, mit einem Schlüssel `item` und darin den Inhalt des Modells, so wie es das tut, wenn Sie mehrere Body-Parameter deklarieren, dann können Sie den speziellen `Body`-Parameter `embed` setzen: +Aber wenn Sie möchten, dass es einen JSON-Body mit einem Schlüssel `item` erwartet, und darin den Inhalt des Modells, so wie es das tut, wenn Sie mehrere Body-Parameter deklarieren, dann können Sie den speziellen `Body`-Parameter `embed` setzen: ```Python item: Item = Body(embed=True) @@ -162,9 +162,9 @@ statt: ## Zusammenfassung -Sie können mehrere Body-Parameter zu ihrer *Pfadoperation-Funktion* hinzufügen, obwohl ein Request nur einen einzigen Body enthalten kann. +Sie können mehrere Body-Parameter zu Ihrer *Pfadoperation-Funktion* hinzufügen, obwohl ein Request nur einen einzigen Body enthalten kann. -**FastAPI** wird sich darum kümmern, Ihnen korrekte Daten in Ihrer Funktion zu überreichen, und das korrekte Schema in der *Pfadoperation* zu validieren und zu dokumentieren. +Aber **FastAPI** wird sich darum kümmern, Ihnen korrekte Daten in Ihrer Funktion zu überreichen, und das korrekte Schema in der *Pfadoperation* zu validieren und zu dokumentieren. Sie können auch einzelne Werte deklarieren, die als Teil des Bodys empfangen werden. diff --git a/docs/de/docs/tutorial/extra-models.md b/docs/de/docs/tutorial/extra-models.md index 6aad1c0f4..c7ae4ba36 100644 --- a/docs/de/docs/tutorial/extra-models.md +++ b/docs/de/docs/tutorial/extra-models.md @@ -1,38 +1,38 @@ # Extramodelle -Fahren wir beim letzten Beispiel fort. Es gibt normalerweise mehrere zusammengehörende Modelle. +Im Anschluss an das vorherige Beispiel ist es üblich, mehr als ein zusammenhängendes Modell zu haben. -Insbesondere Benutzermodelle, denn: +Dies gilt insbesondere für Benutzermodelle, denn: -* Das **hereinkommende Modell** sollte ein Passwort haben können. -* Das **herausgehende Modell** sollte kein Passwort haben. -* Das **Datenbankmodell** sollte wahrscheinlich ein gehashtes Passwort haben. +* Das **Eingabemodell** muss ein Passwort enthalten können. +* Das **Ausgabemodell** sollte kein Passwort haben. +* Das **Datenbankmodell** müsste wahrscheinlich ein gehashtes Passwort haben. /// danger | Gefahr -Speichern Sie niemals das Klartext-Passwort eines Benutzers. Speichern Sie immer den „sicheren Hash“, den Sie verifizieren können. +Speichern Sie niemals das Klartextpasswort eines Benutzers. Speichern Sie immer einen „sicheren Hash“, den Sie dann verifizieren können. -Falls Ihnen das nichts sagt, in den [Sicherheits-Kapiteln](security/simple-oauth2.md#passwort-hashing){.internal-link target=_blank} werden Sie lernen, was ein „Passwort-Hash“ ist. +Wenn Sie nicht wissen, was das ist, werden Sie in den [Sicherheitskapiteln](security/simple-oauth2.md#password-hashing){.internal-link target=_blank} lernen, was ein „Passworthash“ ist. /// ## Mehrere Modelle -Hier der generelle Weg, wie die Modelle mit ihren Passwort-Feldern aussehen könnten, und an welchen Orten sie verwendet werden würden. +Hier ist eine allgemeine Idee, wie die Modelle mit ihren Passwortfeldern aussehen könnten und an welchen Stellen sie verwendet werden: {* ../../docs_src/extra_models/tutorial001_py310.py hl[7,9,14,20,22,27:28,31:33,38:39] *} -/// info +/// info | Info -In Pydantic v1 hieß diese Methode `.dict()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstützt) und in `.model_dump()` umbenannt. +In Pydantic v1 hieß die Methode `.dict()`, in Pydantic v2 wurde sie als veraltet markiert (aber weiterhin 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. +Die Beispiele hier verwenden `.dict()` für die Kompatibilität mit Pydantic v1, aber Sie sollten `.model_dump()` verwenden, wenn Sie Pydantic v2 verwenden können. /// ### Über `**user_in.dict()` -#### Pydantic's `.dict()` +#### Die `.dict()` Methode von Pydantic `user_in` ist ein Pydantic-Modell der Klasse `UserIn`. @@ -44,21 +44,21 @@ Wenn wir also ein Pydantic-Objekt `user_in` erstellen, etwa so: user_in = UserIn(username="john", password="secret", email="john.doe@example.com") ``` -und wir rufen seine `.dict()`-Methode auf: +und dann aufrufen: ```Python user_dict = user_in.dict() ``` -dann haben wir jetzt in der Variable `user_dict` ein `dict` mit den gleichen Daten (es ist ein `dict` statt eines Pydantic-Modellobjekts). +haben wir jetzt ein `dict` mit den Daten in der Variablen `user_dict` (es ist ein `dict` statt eines Pydantic-Modellobjekts). -Wenn wir es ausgeben: +Und wenn wir aufrufen: ```Python print(user_dict) ``` -bekommen wir ein Python-`dict`: +würden wir ein Python-`dict` erhalten mit: ```Python { @@ -71,15 +71,15 @@ bekommen wir ein Python-`dict`: #### Ein `dict` entpacken -Wenn wir ein `dict` wie `user_dict` nehmen, und es einer Funktion (oder Klassenmethode) mittels `**user_dict` übergeben, wird Python es „entpacken“. Es wird die Schlüssel und Werte von `user_dict` direkt als Schlüsselwort-Argumente übergeben. +Wenn wir ein `dict` wie `user_dict` nehmen und es einer Funktion (oder Klasse) mit `**user_dict` übergeben, wird Python es „entpacken“. Es wird die Schlüssel und Werte von `user_dict` direkt als Schlüsselwort-Argumente übergeben. -Wenn wir also das `user_dict` von oben nehmen und schreiben: +Setzen wir also das `user_dict` von oben ein: ```Python UserInDB(**user_dict) ``` -dann ist das ungefähr äquivalent zu: +so ist das äquivalent zu: ```Python UserInDB( @@ -90,7 +90,7 @@ UserInDB( ) ``` -Oder, präziser, `user_dict` wird direkt verwendet, welche Werte es auch immer haben mag: +Oder genauer gesagt, dazu, `user_dict` direkt zu verwenden, mit welchen Inhalten es auch immer in der Zukunft haben mag: ```Python UserInDB( @@ -101,34 +101,34 @@ UserInDB( ) ``` -#### Ein Pydantic-Modell aus den Inhalten eines anderen erstellen. +#### Ein Pydantic-Modell aus dem Inhalt eines anderen -Da wir in obigem Beispiel `user_dict` mittels `user_in.dict()` erzeugt haben, ist dieser Code: +Da wir im obigen Beispiel `user_dict` von `user_in.dict()` bekommen haben, wäre dieser Code: ```Python user_dict = user_in.dict() UserInDB(**user_dict) ``` -äquivalent zu: +gleichwertig zu: ```Python UserInDB(**user_in.dict()) ``` -... weil `user_in.dict()` ein `dict` ist, und dann lassen wir Python es „entpacken“, indem wir es `UserInDB` übergeben, mit vorangestelltem `**`. +...weil `user_in.dict()` ein `dict` ist, und dann lassen wir Python es „entpacken“, indem wir es an `UserInDB` mit vorangestelltem `**` übergeben. -Wir erhalten also ein Pydantic-Modell aus den Daten eines anderen Pydantic-Modells. +Auf diese Weise erhalten wir ein Pydantic-Modell aus den Daten eines anderen Pydantic-Modells. #### Ein `dict` entpacken und zusätzliche Schlüsselwort-Argumente -Und dann fügen wir ein noch weiteres Schlüsselwort-Argument hinzu, `hashed_password=hashed_password`: +Und dann fügen wir das zusätzliche Schlüsselwort-Argument `hashed_password=hashed_password` hinzu, wie in: ```Python UserInDB(**user_in.dict(), hashed_password=hashed_password) ``` -... was am Ende ergibt: +...was so ist wie: ```Python UserInDB( @@ -142,39 +142,39 @@ UserInDB( /// warning | Achtung -Die Hilfsfunktionen `fake_password_hasher` und `fake_save_user` demonstrieren nur den möglichen Fluss der Daten und bieten natürlich keine echte Sicherheit. +Die unterstützenden zusätzlichen Funktionen `fake_password_hasher` und `fake_save_user` dienen nur zur Demo eines möglichen Datenflussses, bieten jedoch natürlich keine echte Sicherheit. /// ## Verdopplung vermeiden -Reduzierung von Code-Verdoppelung ist eine der Kern-Ideen von **FastAPI**. +Die Reduzierung von Code-Verdoppelung ist eine der Kernideen von **FastAPI**. -Weil Verdoppelung von Code die Wahrscheinlichkeit von Fehlern, Sicherheitsproblemen, Desynchronisation (Code wird nur an einer Stelle verändert, aber nicht an einer anderen), usw. erhöht. +Da die Verdopplung von Code die Wahrscheinlichkeit von Fehlern, Sicherheitsproblemen, Problemen mit der Desynchronisation des Codes (wenn Sie an einer Stelle, aber nicht an der anderen aktualisieren) usw. erhöht. -Unsere Modelle teilen alle eine Menge der Daten und verdoppeln Attribut-Namen und -Typen. +Und diese Modelle teilen alle eine Menge der Daten und verdoppeln Attributnamen und -typen. -Das können wir besser machen. +Wir könnten es besser machen. -Wir deklarieren ein `UserBase`-Modell, das als Basis für unsere anderen Modelle dient. Dann können wir Unterklassen erstellen, die seine Attribute (Typdeklarationen, Validierungen, usw.) erben. +Wir können ein `UserBase`-Modell deklarieren, das als Basis für unsere anderen Modelle dient. Und dann können wir Unterklassen dieses Modells erstellen, die seine Attribute (Typdeklarationen, Validierung usw.) erben. -Die ganze Datenkonvertierung, -validierung, -dokumentation, usw. wird immer noch wie gehabt funktionieren. +Die ganze Datenkonvertierung, Validierung, Dokumentation usw. wird immer noch wie gewohnt funktionieren. -Auf diese Weise beschreiben wir nur noch die Unterschiede zwischen den Modellen (mit Klartext-`password`, mit `hashed_password`, und ohne Passwort): +Auf diese Weise können wir nur die Unterschiede zwischen den Modellen (mit Klartext-`password`, mit `hashed_password` und ohne Passwort) deklarieren: {* ../../docs_src/extra_models/tutorial002_py310.py hl[7,13:14,17:18,21:22] *} -## `Union`, oder `anyOf` +## `Union` oder `anyOf` -Sie können deklarieren, dass eine Response eine `Union` mehrerer Typen ist, sprich, einer dieser Typen. +Sie können deklarieren, dass eine Response eine `Union` mehrerer Typen ist, das bedeutet, dass die Response einer von ihnen ist. -Das wird in OpenAPI mit `anyOf` angezeigt. +Dies wird in OpenAPI mit `anyOf` definiert. -Um das zu tun, verwenden Sie Pythons Standard-Typhinweis `typing.Union`: +Um das zu tun, verwenden Sie den Standard-Python-Typhinweis `typing.Union`: /// note | Hinweis -Listen Sie, wenn Sie eine `Union` definieren, denjenigen Typ zuerst, der am spezifischsten ist, gefolgt von den weniger spezifischen Typen. Im Beispiel oben, in `Union[PlaneItem, CarItem]` also den spezifischeren `PlaneItem` vor dem weniger spezifischen `CarItem`. +Wenn Sie eine `Union` definieren, listen Sie den spezifischeren Typ zuerst auf, gefolgt vom weniger spezifischen Typ. Im Beispiel unten steht `PlaneItem` vor `CarItem` in `Union[PlaneItem, CarItem]`. /// @@ -182,33 +182,33 @@ Listen Sie, wenn Sie eine ```console -$ uvicorn main:app --reload +$ fastapi dev main.py -INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) -INFO: Started reloader process [28720] -INFO: Started server process [28722] -INFO: Waiting for application startup. -INFO: Application startup complete. -``` + FastAPI Starting development server 🚀 - + Searching for package file structure from directories + with __init__.py files + Importing from /home/user/code/awesomeapp -/// note | Hinweis + module 🐍 main.py -Der Befehl `uvicorn main:app` bezieht sich auf: + code Importing the FastAPI app object from the module with + the following code: -* `main`: die Datei `main.py` (das sogenannte Python-„Modul“). -* `app`: das Objekt, welches in der Datei `main.py` mit der Zeile `app = FastAPI()` erzeugt wurde. -* `--reload`: lässt den Server nach Codeänderungen neu starten. Verwenden Sie das nur während der Entwicklung. + from main import app -/// + app Using import string: main:app + + server Server started at http://127.0.0.1:8000 + server Documentation at http://127.0.0.1:8000/docs + + tip Running in development mode, for production use: + fastapi run + + Logs: + + INFO Will watch for changes in these directories: + ['/home/user/code/awesomeapp'] + INFO Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C + to quit) + INFO Started reloader process [383138] using WatchFiles + INFO Started server process [383153] + INFO Waiting for application startup. + INFO Application startup complete. +``` + + In der Konsolenausgabe sollte es eine Zeile geben, die ungefähr so aussieht: @@ -38,13 +54,13 @@ In der Konsolenausgabe sollte es eine Zeile geben, die ungefähr so aussieht: INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) ``` -Diese Zeile zeigt die URL, unter der Ihre Anwendung auf Ihrem lokalen Computer bereitgestellt wird. +Diese Zeile zeigt die URL, unter der Ihre App auf Ihrem lokalen Computer bereitgestellt wird. -### Testen Sie es +### Überprüfen -Öffnen Sie Ihren Browser unter http://127.0.0.1:8000. +Öffnen Sie Ihren Browser unter http://127.0.0.1:8000. -Sie werden folgende JSON-Response sehen: +Sie werden die JSON-Response sehen: ```JSON {"message": "Hello World"} @@ -52,7 +68,7 @@ Sie werden folgende JSON-Response sehen: ### Interaktive API-Dokumentation -Gehen Sie als Nächstes auf http://127.0.0.1:8000/docs . +Gehen Sie als Nächstes auf http://127.0.0.1:8000/docs. Sie werden die automatisch erzeugte, interaktive API-Dokumentation sehen (bereitgestellt durch Swagger UI): @@ -76,7 +92,7 @@ Ein „Schema“ ist eine Definition oder Beschreibung von etwas. Nicht der eige #### API-„Schema“ -In diesem Fall ist OpenAPI eine Spezifikation, die vorschreibt, wie ein Schema für Ihre API zu definieren ist. +In diesem Fall ist OpenAPI eine Spezifikation, die vorschreibt, wie ein Schema für Ihre API zu definieren ist. Diese Schemadefinition enthält Ihre API-Pfade, die möglichen Parameter, welche diese entgegennehmen, usw. @@ -127,9 +143,9 @@ Es gibt dutzende Alternativen, die alle auf OpenAPI basieren. Sie können jede d Ebenfalls können Sie es verwenden, um automatisch Code für Clients zu generieren, die mit Ihrer API kommunizieren. Zum Beispiel für Frontend-, Mobile- oder IoT-Anwendungen. -## Rückblick, Schritt für Schritt +## Zusammenfassung, Schritt für Schritt -### Schritt 1: Importieren von `FastAPI` +### Schritt 1: `FastAPI` importieren {* ../../docs_src/first_steps/tutorial001.py hl[1] *} @@ -137,7 +153,7 @@ Ebenfalls können Sie es verwenden, um automatisch Code für Clients zu generier /// note | Technische Details -`FastAPI` ist eine Klasse, die direkt von `Starlette` erbt. +`FastAPI` ist eine Klasse, die direkt von `Starlette` erbt. Sie können alle Starlette-Funktionalitäten auch mit `FastAPI` nutzen. @@ -151,34 +167,6 @@ In diesem Beispiel ist die Variable `app` eine „Instanz“ der Klasse `FastAPI Dies wird der Hauptinteraktionspunkt für die Erstellung all Ihrer APIs sein. -Die Variable `app` ist dieselbe, auf die sich der Befehl `uvicorn` bezieht: - -
- -```console -$ uvicorn main:app --reload - -INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) -``` - -
- -Wenn Sie Ihre Anwendung wie folgt erstellen: - -{* ../../docs_src/first_steps/tutorial002.py hl[3] *} - -Und in eine Datei `main.py` einfügen, dann würden Sie `uvicorn` wie folgt aufrufen: - -
- -```console -$ uvicorn main:my_awesome_api --reload - -INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) -``` - -
- ### Schritt 3: Erstellen einer *Pfadoperation* #### Pfad @@ -246,8 +234,8 @@ Wir werden sie auch „**Operationen**“ nennen. Das `@app.get("/")` sagt **FastAPI**, dass die Funktion direkt darunter für die Bearbeitung von Anfragen zuständig ist, die an: - * den Pfad `/` - * unter der Verwendung der get-Operation gehen +* den Pfad `/` +* unter der Verwendung der get-Operation gehen /// info | `@decorator` Information @@ -269,7 +257,7 @@ Sie können auch die anderen Operationen verwenden: * `@app.put()` * `@app.delete()` -Oder die exotischeren: +Und die exotischeren: * `@app.options()` * `@app.head()` @@ -324,12 +312,12 @@ Sie können ein `dict`, eine `list`, einzelne Werte wie `str`, `int`, usw. zurü Sie können auch Pydantic-Modelle zurückgeben (dazu später mehr). -Es gibt viele andere Objekte und Modelle, die automatisch zu JSON konvertiert werden (einschließlich ORMs usw.). Versuchen Sie, Ihre Lieblingsobjekte zu verwenden. Es ist sehr wahrscheinlich, dass sie bereits unterstützt werden. +Es gibt viele andere Objekte und Modelle, die automatisch zu JSON konvertiert werden (einschließlich ORMs, usw.). Versuchen Sie, Ihre Lieblingsobjekte zu verwenden. Es ist sehr wahrscheinlich, dass sie bereits unterstützt werden. ## Zusammenfassung * Importieren Sie `FastAPI`. * Erstellen Sie eine `app` Instanz. -* Schreiben Sie einen **Pfadoperation-Dekorator** (wie z. B. `@app.get("/")`). -* Schreiben Sie eine **Pfadoperation-Funktion** (wie z. B. oben `def root(): ...`). -* Starten Sie den Entwicklungsserver (z. B. `uvicorn main:app --reload`). +* Schreiben Sie einen **Pfadoperation-Dekorator** unter Verwendung von Dekoratoren wie `@app.get("/")`. +* Definieren Sie eine **Pfadoperation-Funktion**, zum Beispiel `def root(): ...`. +* Starten Sie den Entwicklungsserver mit dem Befehl `fastapi dev`. diff --git a/docs/de/docs/tutorial/handling-errors.md b/docs/de/docs/tutorial/handling-errors.md index 31bc6d328..7aa4e94d7 100644 --- a/docs/de/docs/tutorial/handling-errors.md +++ b/docs/de/docs/tutorial/handling-errors.md @@ -1,27 +1,27 @@ -# Fehlerbehandlung +# Fehler behandeln -Es gibt viele Situationen, in denen Sie einem Client, der Ihre API benutzt, einen Fehler zurückgeben müssen. +Es gibt viele Situationen, in denen Sie einem Client, der Ihre API nutzt, einen Fehler mitteilen müssen. -Dieser Client könnte ein Browser mit einem Frontend, Code von jemand anderem, ein IoT-Gerät, usw., sein. +Dieser Client könnte ein Browser mit einem Frontend sein, ein Code von jemand anderem, ein IoT-Gerät usw. -Sie müssten beispielsweise einem Client sagen: +Sie könnten dem Client mitteilen müssen, dass: -* Dass er nicht die notwendigen Berechtigungen hat, eine Aktion auszuführen. -* Dass er zu einer Ressource keinen Zugriff hat. -* Dass die Ressource, auf die er zugreifen möchte, nicht existiert. +* Der Client nicht genügend Berechtigungen für diese Operation hat. +* Der Client keinen Zugriff auf diese Ressource hat. +* Der Artikel, auf den der Client zugreifen wollte, nicht existiert. * usw. -In diesen Fällen geben Sie normalerweise einen **HTTP-Statuscode** im Bereich **400** (400 bis 499) zurück. +In diesen Fällen würden Sie normalerweise einen **HTTP-Statuscode** im Bereich **400** (von 400 bis 499) zurückgeben. -Das ist vergleichbar mit den HTTP-Statuscodes im Bereich 200 (von 200 bis 299). Diese „200“er Statuscodes bedeuten, dass der Request in einem bestimmten Aspekt ein „Success“ („Erfolg“) war. +Dies ist vergleichbar mit den HTTP-Statuscodes im Bereich 200 (von 200 bis 299). Diese „200“-Statuscodes bedeuten, dass die Anfrage in irgendeiner Weise erfolgreich war. -Die Statuscodes im 400er-Bereich bedeuten hingegen, dass es einen Fehler gab. +Die Statuscodes im Bereich 400 bedeuten hingegen, dass es einen Fehler seitens des Clients gab. -Erinnern Sie sich an all diese **404 Not Found** Fehler (und Witze)? +Erinnern Sie sich an all diese **"404 Not Found"** Fehler (und Witze)? ## `HTTPException` verwenden -Um HTTP-Responses mit Fehlern zum Client zurückzugeben, verwenden Sie `HTTPException`. +Um HTTP-Responses mit Fehlern an den Client zurückzugeben, verwenden Sie `HTTPException`. ### `HTTPException` importieren @@ -29,21 +29,21 @@ Um HTTP-Responses mit Fehlern zum Client zurückzugeben, verwenden Sie `HTTPExce ### Eine `HTTPException` in Ihrem Code auslösen -`HTTPException` ist eine normale Python-Exception mit einigen zusätzlichen Daten, die für APIs relevant sind. +`HTTPException` ist eine normale Python-Exception mit zusätzlichen Daten, die für APIs relevant sind. -Weil es eine Python-Exception ist, geben Sie sie nicht zurück, (`return`), sondern Sie lösen sie aus (`raise`). +Weil es eine Python-Exception ist, geben Sie sie nicht zurück (`return`), sondern lösen sie aus (`raise`). -Das bedeutet auch, wenn Sie in einer Hilfsfunktion sind, die Sie von ihrer *Pfadoperation-Funktion* aus aufrufen, und Sie lösen eine `HTTPException` von innerhalb dieser Hilfsfunktion aus, dann wird der Rest der *Pfadoperation-Funktion* nicht ausgeführt, sondern der Request wird sofort abgebrochen und der HTTP-Error der `HTTP-Exception` wird zum Client gesendet. +Das bedeutet auch, wenn Sie sich innerhalb einer Hilfsfunktion befinden, die Sie innerhalb Ihrer *Pfadoperation-Funktion* aufrufen, und Sie die `HTTPException` aus dieser Hilfsfunktion heraus auslösen, wird der restliche Code in der *Pfadoperation-Funktion* nicht ausgeführt. Die Anfrage wird sofort abgebrochen und der HTTP-Error der `HTTPException` wird an den Client gesendet. -Der Vorteil, eine Exception auszulösen (`raise`), statt sie zurückzugeben (`return`) wird im Abschnitt über Abhängigkeiten und Sicherheit klarer werden. +Der Vorteil des Auslösens einer Exception gegenüber dem Zurückgeben eines Wertes wird im Abschnitt über Abhängigkeiten und Sicherheit deutlicher werden. -Im folgenden Beispiel lösen wir, wenn der Client eine ID anfragt, die nicht existiert, eine Exception mit dem Statuscode `404` aus. +In diesem Beispiel lösen wir eine Exception mit einem Statuscode von `404` aus, wenn der Client einen Artikel mit einer nicht existierenden ID anfordert: {* ../../docs_src/handling_errors/tutorial001.py hl[11] *} ### Die resultierende Response -Wenn der Client `http://example.com/items/foo` anfragt (ein `item_id` `"foo"`), erhält dieser Client einen HTTP-Statuscode 200 und folgende JSON-Response: +Wenn der Client `http://example.com/items/foo` anfordert (ein `item_id` `"foo"`), erhält dieser Client einen HTTP-Statuscode 200 und diese JSON-Response: ```JSON { @@ -51,7 +51,7 @@ Wenn der Client `http://example.com/items/foo` anfragt (ein `item_id` `"foo"`), } ``` -Aber wenn der Client `http://example.com/items/bar` anfragt (ein nicht-existierendes `item_id` `"bar"`), erhält er einen HTTP-Statuscode 404 (der „Not Found“-Fehler), und eine JSON-Response wie folgt: +Aber wenn der Client `http://example.com/items/bar` anfordert (ein nicht-existierendes `item_id` `"bar"`), erhält er einen HTTP-Statuscode 404 (der „not found“ Error) und eine JSON-Response wie: ```JSON { @@ -61,41 +61,41 @@ Aber wenn der Client `http://example.com/items/bar` anfragt (ein nicht-existiere /// tip | Tipp -Wenn Sie eine `HTTPException` auslösen, können Sie dem Parameter `detail` jeden Wert übergeben, der nach JSON konvertiert werden kann, nicht nur `str`. +Wenn Sie eine `HTTPException` auslösen, können Sie dem Parameter `detail` jeden Wert übergeben, der in JSON konvertiert werden kann, nicht nur `str`. -Zum Beispiel ein `dict`, eine `list`, usw. +Sie könnten ein `dict`, eine `list`, usw. übergeben. -Das wird automatisch von **FastAPI** gehandhabt und der Wert nach JSON konvertiert. +Diese werden von **FastAPI** automatisch gehandhabt und in JSON konvertiert. /// ## Benutzerdefinierte Header hinzufügen -Es gibt Situationen, da ist es nützlich, dem HTTP-Error benutzerdefinierte Header hinzufügen zu können, etwa in einigen Sicherheitsszenarien. +Es gibt Situationen, in denen es nützlich ist, dem HTTP-Error benutzerdefinierte Header hinzuzufügen. Zum Beispiel für einige Arten der Sicherheit. -Sie müssen das wahrscheinlich nicht direkt in ihrem Code verwenden. +Sie werden es wahrscheinlich nicht direkt in Ihrem Code verwenden müssen. -Aber falls es in einem fortgeschrittenen Szenario notwendig ist, können Sie benutzerdefinierte Header wie folgt hinzufügen: +Aber falls Sie es für ein fortgeschrittenes Szenario benötigen, können Sie benutzerdefinierte Header hinzufügen: {* ../../docs_src/handling_errors/tutorial002.py hl[14] *} -## Benutzerdefinierte Exceptionhandler definieren +## Benutzerdefinierte Exception-Handler installieren -Sie können benutzerdefinierte Exceptionhandler hinzufügen, mithilfe derselben Werkzeuge für Exceptions von Starlette. +Sie können benutzerdefinierte Exception-Handler mit den gleichen Exception-Werkzeugen von Starlette hinzufügen. -Nehmen wir an, Sie haben eine benutzerdefinierte Exception `UnicornException`, die Sie (oder eine Bibliothek, die Sie verwenden) `raise`n könnten. +Angenommen, Sie haben eine benutzerdefinierte Exception `UnicornException`, die Sie (oder eine Bibliothek, die Sie verwenden) `raise` könnte. Und Sie möchten diese Exception global mit FastAPI handhaben. -Sie könnten einen benutzerdefinierten Exceptionhandler mittels `@app.exception_handler()` hinzufügen: +Sie könnten einen benutzerdefinierten Exception-Handler mit `@app.exception_handler()` hinzufügen: {* ../../docs_src/handling_errors/tutorial003.py hl[5:7,13:18,24] *} -Wenn Sie nun `/unicorns/yolo` anfragen, `raise`d die *Pfadoperation* eine `UnicornException`. +Wenn Sie nun `/unicorns/yolo` anfordern, wird die *Pfadoperation* eine `UnicornException` `raise`n. Aber diese wird von `unicorn_exception_handler` gehandhabt. -Sie erhalten also einen sauberen Error mit einem Statuscode `418` und dem JSON-Inhalt: +Sie erhalten also einen sauberen Fehler mit einem HTTP-Statuscode von `418` und einem JSON-Inhalt von: ```JSON {"message": "Oops! yolo did something. There goes a rainbow..."} @@ -103,33 +103,33 @@ Sie erhalten also einen sauberen Error mit einem Statuscode `418` und dem JSON-I /// note | Technische Details -Sie können auch `from starlette.requests import Request` und `from starlette.responses import JSONResponse` verwenden. +Sie könnten auch `from starlette.requests import Request` und `from starlette.responses import JSONResponse` verwenden. -**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 `Request`. +**FastAPI** bietet dieselben `starlette.responses` auch als `fastapi.responses` an, nur als Annehmlichkeit für Sie, den Entwickler. Aber die meisten verfügbaren Responses kommen direkt von Starlette. Dasselbe gilt für `Request`. /// -## Die Default-Exceptionhandler überschreiben +## Die Default-Exception-Handler überschreiben -**FastAPI** hat einige Default-Exceptionhandler. +**FastAPI** hat einige Default-Exception-Handler. -Diese Handler kümmern sich darum, Default-JSON-Responses zurückzugeben, wenn Sie eine `HTTPException` `raise`n, und wenn der Request ungültige Daten enthält. +Diese Handler sind dafür verantwortlich, die standardmäßigen JSON-Responses zurückzugeben, wenn Sie eine `HTTPException` `raise`n und wenn die Anfrage ungültige Daten enthält. -Sie können diese Exceptionhandler mit ihren eigenen überschreiben. +Sie können diese Exception-Handler mit Ihren eigenen überschreiben. -### Requestvalidierung-Exceptions überschreiben +### Überschreiben von Request-Validierungs-Exceptions Wenn ein Request ungültige Daten enthält, löst **FastAPI** intern einen `RequestValidationError` aus. -Und bietet auch einen Default-Exceptionhandler dafür. +Und es enthält auch einen Default-Exception-Handler für diesen. -Um diesen zu überschreiben, importieren Sie den `RequestValidationError` und verwenden Sie ihn in `@app.exception_handler(RequestValidationError)`, um Ihren Exceptionhandler zu dekorieren. +Um diesen zu überschreiben, importieren Sie den `RequestValidationError` und verwenden Sie ihn mit `@app.exception_handler(RequestValidationError)`, um den Exception-Handler zu dekorieren. -Der Exceptionhandler wird einen `Request` und die Exception entgegennehmen. +Der Exception-Handler erhält einen `Request` und die Exception. {* ../../docs_src/handling_errors/tutorial004.py hl[2,14:16] *} -Wenn Sie nun `/items/foo` besuchen, erhalten Sie statt des Default-JSON-Errors: +Wenn Sie nun zu `/items/foo` gehen, erhalten Sie anstelle des standardmäßigen JSON-Fehlers mit: ```JSON { @@ -146,7 +146,7 @@ Wenn Sie nun `/items/foo` besuchen, erhalten Sie statt des Default-JSON-Errors: } ``` -eine Textversion: +eine Textversion mit: ``` 1 validation error @@ -158,23 +158,23 @@ path -> item_id /// warning | Achtung -Das folgende sind technische Details, die Sie überspringen können, wenn sie für Sie nicht wichtig sind. +Dies sind technische Details, die Sie überspringen können, wenn sie für Sie jetzt nicht wichtig sind. /// -`RequestValidationError` ist eine Unterklasse von Pydantics `ValidationError`. +`RequestValidationError` ist eine Unterklasse von Pydantics `ValidationError`. -**FastAPI** verwendet diesen, sodass Sie, wenn Sie ein Pydantic-Modell für `response_model` verwenden, und ihre Daten fehlerhaft sind, einen Fehler in ihrem Log sehen. +**FastAPI** verwendet diesen so, dass, wenn Sie ein Pydantic-Modell in `response_model` verwenden und Ihre Daten einen Fehler haben, Sie den Fehler in Ihrem Log sehen. -Aber der Client/Benutzer sieht ihn nicht. Stattdessen erhält der Client einen „Internal Server Error“ mit einem HTTP-Statuscode `500`. +Aber der Client/Benutzer wird ihn nicht sehen. Stattdessen erhält der Client einen „Internal Server Error“ mit einem HTTP-Statuscode `500`. -Das ist, wie es sein sollte, denn wenn Sie einen Pydantic-`ValidationError` in Ihrer *Response* oder irgendwo sonst in ihrem Code haben (es sei denn, im *Request* des Clients), ist das tatsächlich ein Bug in ihrem Code. +Es sollte so sein, denn wenn Sie einen Pydantic `ValidationError` in Ihrer *Response* oder irgendwo anders in Ihrem Code haben (nicht im *Request* des Clients), ist es tatsächlich ein Fehler in Ihrem Code. -Und während Sie den Fehler beheben, sollten ihre Clients/Benutzer keinen Zugriff auf interne Informationen über den Fehler haben, da das eine Sicherheitslücke aufdecken könnte. +Und während Sie den Fehler beheben, sollten Ihre Clients/Benutzer keinen Zugriff auf interne Informationen über den Fehler haben, da das eine Sicherheitslücke aufdecken könnte. -### den `HTTPException`-Handler überschreiben +### Überschreiben des `HTTPException`-Fehlerhandlers -Genauso können Sie den `HTTPException`-Handler überschreiben. +Auf die gleiche Weise können Sie den `HTTPException`-Handler überschreiben. Zum Beispiel könnten Sie eine Klartext-Response statt JSON für diese Fehler zurückgeben wollen: @@ -182,21 +182,21 @@ Zum Beispiel könnten Sie eine Klartext-Response statt JSON für diese Fehler zu /// note | Technische Details -Sie können auch `from starlette.responses import PlainTextResponse` verwenden. +Sie könnten auch `from starlette.responses import PlainTextResponse` verwenden. -**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. +**FastAPI** bietet dieselben `starlette.responses` auch als `fastapi.responses` an, nur als Annehmlichkeit für Sie, den Entwickler. Aber die meisten verfügbaren Responses kommen direkt von Starlette. /// -### Den `RequestValidationError`-Body verwenden +### Verwenden des `RequestValidationError`-Bodys Der `RequestValidationError` enthält den empfangenen `body` mit den ungültigen Daten. -Sie könnten diesen verwenden, während Sie Ihre Anwendung entwickeln, um den Body zu loggen und zu debuggen, ihn zum Benutzer zurückzugeben, usw. +Sie könnten diesen während der Entwicklung Ihrer Anwendung verwenden, um den Body zu loggen und zu debuggen, ihn an den Benutzer zurückzugeben usw. {* ../../docs_src/handling_errors/tutorial005.py hl[14] *} -Jetzt versuchen Sie, einen ungültigen Artikel zu senden: +Versuchen Sie nun, einen ungültigen Artikel zu senden: ```JSON { @@ -205,7 +205,7 @@ Jetzt versuchen Sie, einen ungültigen Artikel zu senden: } ``` -Sie erhalten eine Response, die Ihnen sagt, dass die Daten ungültig sind, und welche den empfangenen Body enthält. +Sie erhalten eine Response, die Ihnen sagt, dass die Daten ungültig sind und die den empfangenen Body enthält: ```JSON hl_lines="12-15" { @@ -230,26 +230,26 @@ Sie erhalten eine Response, die Ihnen sagt, dass die Daten ungültig sind, und w **FastAPI** hat seine eigene `HTTPException`. -Und **FastAPI**s `HTTPException`-Fehlerklasse erbt von Starlettes `HTTPException`-Fehlerklasse. +Und die `HTTPException`-Fehlerklasse von **FastAPI** erbt von der `HTTPException`-Fehlerklasse von Starlette. -Der einzige Unterschied besteht darin, dass **FastAPIs** `HTTPException` alles für das Feld `detail` akzeptiert, was nach JSON konvertiert werden kann, während Starlettes `HTTPException` nur Strings zulässt. +Der einzige Unterschied besteht darin, dass die `HTTPException` von **FastAPI** beliebige JSON-konvertierbare Daten für das `detail`-Feld akzeptiert, während die `HTTPException` von Starlette nur Strings dafür akzeptiert. -Sie können also weiterhin **FastAPI**s `HTTPException` wie üblich in Ihrem Code auslösen. +Sie können also weiterhin die `HTTPException` von **FastAPI** wie üblich in Ihrem Code auslösen. -Aber wenn Sie einen Exceptionhandler registrieren, registrieren Sie ihn für Starlettes `HTTPException`. +Aber wenn Sie einen Exception-Handler registrieren, sollten Sie ihn für die `HTTPException` von Starlette registrieren. -Auf diese Weise wird Ihr Handler, wenn irgendein Teil von Starlettes internem Code, oder eine Starlette-Erweiterung, oder -Plugin eine Starlette-`HTTPException` auslöst, in der Lage sein, diese zu fangen und zu handhaben. +Auf diese Weise, wenn irgendein Teil des internen Codes von Starlette, oder eine Starlette-Erweiterung oder ein Plug-in, eine Starlette `HTTPException` auslöst, wird Ihr Handler in der Lage sein, diese abzufangen und zu handhaben. -Damit wir in diesem Beispiel beide `HTTPException`s im selben Code haben können, benennen wir Starlettes Exception um zu `StarletteHTTPException`: +Um in diesem Beispiel beide `HTTPException`s im selben Code zu haben, wird die Exception von Starlette als `StarletteHTTPException` umbenannt: ```Python from starlette.exceptions import HTTPException as StarletteHTTPException ``` -### **FastAPI**s Exceptionhandler wiederverwenden +### Die Exceptionhandler von **FastAPI** wiederverwenden -Wenn Sie die Exception zusammen mit denselben Default-Exceptionhandlern von **FastAPI** verwenden möchten, können Sie die Default-Exceptionhandler von `fastapi.Exception_handlers` importieren und wiederverwenden: +Wenn Sie die Exception zusammen mit den gleichen Default-Exceptionhandlern von **FastAPI** verwenden möchten, können Sie die Default-Exceptionhandler aus `fastapi.exception_handlers` importieren und wiederverwenden: {* ../../docs_src/handling_errors/tutorial006.py hl[2:5,15,21] *} -In diesem Beispiel `print`en Sie nur den Fehler mit einer sehr ausdrucksstarken Nachricht, aber Sie sehen, worauf wir hinauswollen. Sie können mit der Exception etwas machen und dann einfach die Default-Exceptionhandler wiederverwenden. +In diesem Beispiel drucken Sie nur den Fehler mit einer sehr ausdrucksstarken Nachricht aus, aber Sie verstehen das Prinzip. Sie können die Exception verwenden und dann einfach die Default-Exceptionhandler wiederverwenden. diff --git a/docs/de/docs/tutorial/index.md b/docs/de/docs/tutorial/index.md index 3cbfe37f4..0cf451e0a 100644 --- a/docs/de/docs/tutorial/index.md +++ b/docs/de/docs/tutorial/index.md @@ -1,34 +1,58 @@ # Tutorial – Benutzerhandbuch -Dieses Tutorial zeigt Ihnen Schritt für Schritt, wie Sie **FastAPI** und die meisten seiner Funktionen verwenden können. +Dieses Tutorial zeigt Ihnen Schritt für Schritt, wie Sie **FastAPI** mit den meisten seiner Funktionen verwenden können. -Jeder Abschnitt baut schrittweise auf den vorhergehenden auf. Diese Abschnitte sind aber nach einzelnen Themen gegliedert, sodass Sie direkt zu einem bestimmten Thema übergehen können, um Ihre speziellen API-Anforderungen zu lösen. +Jeder Abschnitt baut schrittweise auf den vorhergehenden auf, ist jedoch in einzelne Themen gegliedert, sodass Sie direkt zu einem bestimmten Thema übergehen können, um Ihre spezifischen API-Anforderungen zu lösen. -Außerdem dienen diese als zukünftige Referenz. - -Dadurch können Sie jederzeit zurückkommen und sehen genau das, was Sie benötigen. +Es ist auch so gestaltet, dass es als zukünftige Referenz dient, sodass Sie jederzeit zurückkommen und genau das sehen, was Sie benötigen. ## Den Code ausführen -Alle Codeblöcke können kopiert und direkt verwendet werden (da es sich um getestete Python-Dateien handelt). +Alle Codeblöcke können kopiert und direkt verwendet werden (es sind tatsächlich getestete Python-Dateien). -Um eines der Beispiele auszuführen, kopieren Sie den Code in eine Datei `main.py`, und starten Sie `uvicorn` mit: +Um eines der Beispiele auszuführen, kopieren Sie den Code in eine Datei `main.py` und starten Sie `fastapi dev` mit:
```console -$ uvicorn main:app --reload +$ fastapi dev main.py + + FastAPI Starting development server 🚀 + + Searching for package file structure from directories + with __init__.py files + Importing from /home/user/code/awesomeapp + + module 🐍 main.py + + code Importing the FastAPI app object from the module with + the following code: + + from main import app + + app Using import string: main:app + + server Server started at http://127.0.0.1:8000 + server Documentation at http://127.0.0.1:8000/docs + + tip Running in development mode, for production use: + fastapi run -INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) -INFO: Started reloader process [28720] -INFO: Started server process [28722] -INFO: Waiting for application startup. -INFO: Application startup complete. + Logs: + + INFO Will watch for changes in these directories: + ['/home/user/code/awesomeapp'] + INFO Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C + to quit) + INFO Started reloader process [383138] using WatchFiles + INFO Started server process [383153] + INFO Waiting for application startup. + INFO Application startup complete. ```
-Es wird **ausdrücklich empfohlen**, dass Sie den Code schreiben oder kopieren, ihn bearbeiten und lokal ausführen. +Es wird **dringend empfohlen**, den Code zu schreiben oder zu kopieren, ihn zu bearbeiten und lokal auszuführen. Die Verwendung in Ihrem eigenen Editor zeigt Ihnen die Vorteile von FastAPI am besten, wenn Sie sehen, wie wenig Code Sie schreiben müssen, all die Typprüfungen, die automatische Vervollständigung usw. @@ -36,48 +60,36 @@ Die Verwendung in Ihrem eigenen Editor zeigt Ihnen die Vorteile von FastAPI am b ## FastAPI installieren -Der erste Schritt besteht aus der Installation von FastAPI. +Der erste Schritt besteht darin, FastAPI zu installieren. -Für dieses Tutorial empfiehlt es sich, FastAPI mit allen optionalen Abhängigkeiten und Funktionen zu installieren: +Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und dann **FastAPI installieren**:
```console -$ pip install "fastapi[all]" +$ pip install "fastapi[standard]" ---> 100% ```
-... das beinhaltet auch `uvicorn`, welchen Sie als Server verwenden können, der ihren Code ausführt. - /// note | Hinweis -Sie können die einzelnen Teile auch separat installieren. - -Das folgende würden Sie wahrscheinlich tun, wenn Sie Ihre Anwendung in der Produktion einsetzen: +Wenn Sie mit `pip install "fastapi[standard]"` installieren, werden einige optionale Standard-Abhängigkeiten mit installiert, einschließlich `fastapi-cloud-cli`, welches Ihnen das Deployment in der FastAPI Cloud ermöglicht. -``` -pip install fastapi -``` - -Installieren Sie auch `uvicorn` als Server: - -``` -pip install "uvicorn[standard]" -``` +Wenn Sie diese optionalen Abhängigkeiten nicht haben möchten, können Sie stattdessen `pip install fastapi` installieren. -Das gleiche gilt für jede der optionalen Abhängigkeiten, die Sie verwenden möchten. +Wenn Sie die Standard-Abhängigkeiten, aber ohne das `fastapi-cloud-cli` installieren möchten, können Sie mit `pip install "fastapi[standard-no-fastapi-cloud-cli]"` installieren. /// ## Handbuch für fortgeschrittene Benutzer -Es gibt auch ein **Handbuch für fortgeschrittene Benutzer**, welches Sie später nach diesem **Tutorial – Benutzerhandbuch** lesen können. +Es gibt auch ein **Handbuch für fortgeschrittene Benutzer**, das Sie nach diesem **Tutorial – Benutzerhandbuch** lesen können. -Das **Handbuch für fortgeschrittene Benutzer** baut auf diesem Tutorial auf, verwendet dieselben Konzepte und bringt Ihnen einige zusätzliche Funktionen bei. +Das **Handbuch für fortgeschrittene Benutzer** baut hierauf auf, verwendet dieselben Konzepte und bringt Ihnen einige zusätzliche Funktionen bei. -Allerdings sollten Sie zuerst das **Tutorial – Benutzerhandbuch** lesen (was Sie hier gerade tun). +Sie sollten jedoch zuerst das **Tutorial – Benutzerhandbuch** lesen (was Sie gerade tun). -Die Dokumentation ist so konzipiert, dass Sie mit dem **Tutorial – Benutzerhandbuch** eine vollständige Anwendung erstellen können und diese dann je nach Bedarf mit einigen der zusätzlichen Ideen aus dem **Handbuch für fortgeschrittene Benutzer** vervollständigen können. +Es ist so konzipiert, dass Sie mit dem **Tutorial – Benutzerhandbuch** eine vollständige Anwendung erstellen können und diese dann je nach Bedarf mit einigen der zusätzlichen Ideen aus dem **Handbuch für fortgeschrittene Benutzer** erweitern können. diff --git a/docs/de/docs/tutorial/middleware.md b/docs/de/docs/tutorial/middleware.md index d3699be1b..2a161d106 100644 --- a/docs/de/docs/tutorial/middleware.md +++ b/docs/de/docs/tutorial/middleware.md @@ -15,11 +15,11 @@ Eine „Middleware“ ist eine Funktion, die mit jedem **Request** arbeitet, bev Wenn Sie Abhängigkeiten mit `yield` haben, wird der Exit-Code *nach* der Middleware ausgeführt. -Wenn es Hintergrundaufgaben gab (später dokumentiert), werden sie *nach* allen Middlewares ausgeführt. +Wenn es Hintergrundtasks gab (dies wird später im [Hintergrundtasks](background-tasks.md){.internal-link target=_blank}-Abschnitt behandelt), werden sie *nach* allen Middlewares ausgeführt. /// -## Erstellung einer Middleware +## Eine Middleware erstellen Um eine Middleware zu erstellen, verwenden Sie den Dekorator `@app.middleware("http")` über einer Funktion. @@ -35,9 +35,9 @@ Die Middleware-Funktion erhält: /// tip | Tipp -Beachten Sie, dass benutzerdefinierte proprietäre Header hinzugefügt werden können. Verwenden Sie dafür das Präfix 'X-'. +Beachten Sie, dass benutzerdefinierte proprietäre Header hinzugefügt werden können unter Verwendung des 'X-' Präfixes. -Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen soll, müssen Sie sie zu Ihrer CORS-Konfigurationen ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) hinzufügen, indem Sie den Parameter `expose_headers` verwenden, der in der Starlette-CORS-Dokumentation dokumentiert ist. +Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen soll, müssen Sie sie zu Ihren CORS-Konfigurationen ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) hinzufügen, indem Sie den Parameter `expose_headers` verwenden, der in der Starlette-CORS-Dokumentation dokumentiert ist. /// @@ -59,8 +59,37 @@ Sie könnten beispielsweise einen benutzerdefinierten Header `X-Process-Time` hi {* ../../docs_src/middleware/tutorial001.py hl[10,12:13] *} +/// tip | Tipp + +Hier verwenden wir `time.perf_counter()` anstelle von `time.time()`, da es für diese Anwendungsfälle präziser sein kann. 🤓 + +/// + +## Ausführungsreihenfolge bei mehreren Middlewares + +Wenn Sie mehrere Middlewares hinzufügen, entweder mit dem `@app.middleware()` Dekorator oder der Methode `app.add_middleware()`, umschließt jede neue Middleware die Anwendung und bildet einen Stapel. Die zuletzt hinzugefügte Middleware ist die *äußerste*, und die erste ist die *innerste*. + +Auf dem Anfragepfad läuft die *äußerste* Middleware zuerst. + +Auf dem Antwortpfad läuft sie zuletzt. + +Zum Beispiel: + +```Python +app.add_middleware(MiddlewareA) +app.add_middleware(MiddlewareB) +``` + +Dies führt zu folgender Ausführungsreihenfolge: + +* **Request**: MiddlewareB → MiddlewareA → Route + +* **Response**: Route → MiddlewareA → MiddlewareB + +Dieses Stapelverhalten stellt sicher, dass Middlewares in einer vorhersehbaren und kontrollierbaren Reihenfolge ausgeführt werden. + ## Andere Middlewares -Sie können später mehr über andere Middlewares in [Handbuch für fortgeschrittene Benutzer: Fortgeschrittene Middleware](../advanced/middleware.md){.internal-link target=_blank} lesen. +Sie können später mehr über andere Middlewares im [Handbuch für fortgeschrittene Benutzer: Fortgeschrittene Middleware](../advanced/middleware.md){.internal-link target=_blank} lesen. In der nächsten Sektion erfahren Sie, wie Sie CORS mit einer Middleware behandeln können. diff --git a/docs/de/docs/tutorial/query-params-str-validations.md b/docs/de/docs/tutorial/query-params-str-validations.md index de8879ce8..bd77030ac 100644 --- a/docs/de/docs/tutorial/query-params-str-validations.md +++ b/docs/de/docs/tutorial/query-params-str-validations.md @@ -1,69 +1,49 @@ -# Query-Parameter und Stringvalidierung +# Query-Parameter und String-Validierungen -**FastAPI** erlaubt es Ihnen, Ihre Parameter zusätzlich zu validieren, und zusätzliche Informationen hinzuzufügen. +**FastAPI** ermöglicht es Ihnen, zusätzliche Informationen und Validierungen für Ihre Parameter zu deklarieren. -Nehmen wir als Beispiel die folgende Anwendung: +Nehmen wir diese Anwendung als Beispiel: {* ../../docs_src/query_params_str_validations/tutorial001_py310.py hl[7] *} -Der Query-Parameter `q` hat den Typ `Union[str, None]` (oder `str | None` in Python 3.10), was bedeutet, er ist entweder ein `str` oder `None`. Der Defaultwert ist `None`, also weiß FastAPI, der Parameter ist nicht erforderlich. +Der Query-Parameter `q` hat den Typ `str | None`, das bedeutet, dass er vom Typ `str` sein kann, aber auch `None`, und tatsächlich ist der Defaultwert `None`, sodass FastAPI weiß, dass er nicht erforderlich ist. /// note | Hinweis -FastAPI weiß nur dank des definierten Defaultwertes `=None`, dass der Wert von `q` nicht erforderlich ist +FastAPI erkennt, dass der Wert von `q` nicht erforderlich ist, aufgrund des Defaultwertes `= None`. -`Union[str, None]` hingegen erlaubt ihren Editor, Sie besser zu unterstützen und Fehler zu erkennen. +Die Verwendung von `str | None` ermöglicht es Ihrem Editor, Ihnen bessere Unterstützung zu bieten und Fehler zu erkennen. /// ## Zusätzliche Validierung -Wir werden bewirken, dass, obwohl `q` optional ist, wenn es gegeben ist, **seine Länge 50 Zeichen nicht überschreitet**. +Wir werden sicherstellen, dass, obwohl `q` optional ist, wann immer es bereitgestellt wird, **seine Länge 50 Zeichen nicht überschreitet**. ### `Query` und `Annotated` importieren -Importieren Sie zuerst: +Um dies zu erreichen, importieren Sie zuerst: * `Query` von `fastapi` -* `Annotated` von `typing` (oder von `typing_extensions` in Python unter 3.9) +* `Annotated` von `typing` -//// tab | Python 3.10+ - -In Python 3.9 oder darüber, ist `Annotated` Teil der Standardbibliothek, also können Sie es von `typing` importieren. - -```Python hl_lines="1 3" -{!> ../../docs_src/query_params_str_validations/tutorial002_an_py310.py!} -``` +{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[1,3] *} -//// - -//// tab | Python 3.8+ - -In Versionen unter Python 3.9 importieren Sie `Annotated` von `typing_extensions`. - -Es wird bereits mit FastAPI installiert sein. - -```Python hl_lines="3-4" -{!> ../../docs_src/query_params_str_validations/tutorial002_an.py!} -``` - -//// +/// info | Info -/// info +FastAPI hat Unterstützung für `Annotated` hinzugefügt (und begonnen, es zu empfehlen) in der Version 0.95.0. -FastAPI unterstützt (und empfiehlt die Verwendung von) `Annotated` seit Version 0.95.0. +Wenn Sie eine ältere Version haben, würden Sie Fehler erhalten, beim Versuch, `Annotated` zu verwenden. -Wenn Sie eine ältere Version haben, werden Sie Fehler angezeigt bekommen, wenn Sie versuchen, `Annotated` zu verwenden. - -Bitte [aktualisieren Sie FastAPI](../deployment/versions.md#upgrade-der-fastapi-versionen){.internal-link target=_blank} daher mindestens zu Version 0.95.1, bevor Sie `Annotated` verwenden. +Stellen Sie sicher, dass Sie [die FastAPI-Version aktualisieren](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank}, auf mindestens Version 0.95.1, bevor Sie `Annotated` verwenden. /// -## `Annotated` im Typ des `q`-Parameters verwenden +## Verwenden von `Annotated` im Typ für den `q`-Parameter -Erinnern Sie sich, wie ich in [Einführung in Python-Typen](../python-types.md#typhinweise-mit-metadaten-annotationen){.internal-link target=_blank} sagte, dass Sie mittels `Annotated` Metadaten zu Ihren Parametern hinzufügen können? +Erinnern Sie sich, dass ich Ihnen zuvor in [Python-Typen-Intro](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank} gesagt habe, dass `Annotated` verwendet werden kann, um Metadaten zu Ihren Parametern hinzuzufügen? -Jetzt ist es an der Zeit, das mit FastAPI auszuprobieren. 🚀 +Jetzt ist es soweit, dies mit FastAPI zu verwenden. 🚀 Wir hatten diese Typannotation: @@ -83,7 +63,7 @@ q: Union[str, None] = None //// -Wir wrappen das nun in `Annotated`, sodass daraus wird: +Was wir tun werden, ist, dies mit `Annotated` zu wrappen, sodass es zu: //// tab | Python 3.10+ @@ -101,101 +81,75 @@ q: Annotated[Union[str, None]] = None //// -Beide Versionen bedeuten dasselbe: `q` ist ein Parameter, der `str` oder `None` sein kann. Standardmäßig ist er `None`. +Beide dieser Versionen bedeuten dasselbe: `q` ist ein Parameter, der ein `str` oder `None` sein kann, und standardmäßig ist er `None`. -Wenden wir uns jetzt den spannenden Dingen zu. 🎉 +Jetzt springen wir zu den spannenden Dingen. 🎉 ## `Query` zu `Annotated` im `q`-Parameter hinzufügen -Jetzt, da wir `Annotated` für unsere Metadaten deklariert haben, fügen Sie `Query` hinzu, und setzen Sie den Parameter `max_length` auf `50`: +Da wir nun `Annotated` haben, in das wir mehr Informationen (in diesem Fall einige zusätzliche Validierungen) einfügen können, fügen Sie `Query` innerhalb von `Annotated` hinzu und setzen Sie den Parameter `max_length` auf `50`: {* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[9] *} -Beachten Sie, dass der Defaultwert immer noch `None` ist, sodass der Parameter immer noch optional ist. +Beachten Sie, dass der Defaultwert weiterhin `None` ist, so dass der Parameter weiterhin optional ist. + +Aber jetzt, mit `Query(max_length=50)` innerhalb von `Annotated`, sagen wir FastAPI, dass wir eine **zusätzliche Validierung** für diesen Wert wünschen, wir wollen, dass er maximal 50 Zeichen hat. 😎 + +/// tip | Tipp + +Hier verwenden wir `Query()`, weil dies ein **Query-Parameter** ist. Später werden wir andere wie `Path()`, `Body()`, `Header()`, und `Cookie()` sehen, die auch dieselben Argumente wie `Query()` akzeptieren. -Aber jetzt, mit `Query(max_length=50)` innerhalb von `Annotated`, sagen wir FastAPI, dass es diesen Wert aus den Query-Parametern extrahieren soll (das hätte es sowieso gemacht 🤷) und dass wir eine **zusätzliche Validierung** für diesen Wert haben wollen (darum machen wir das, um die zusätzliche Validierung zu bekommen). 😎 +/// FastAPI wird nun: -* Die Daten **validieren** und sicherstellen, dass sie nicht länger als 50 Zeichen sind -* Dem Client einen **verständlichen Fehler** anzeigen, wenn die Daten ungültig sind +* Die Daten **validieren**, um sicherzustellen, dass die Länge maximal 50 Zeichen beträgt +* Einen **klaren Fehler** für den Client anzeigen, wenn die Daten ungültig sind * Den Parameter in der OpenAPI-Schema-*Pfadoperation* **dokumentieren** (sodass er in der **automatischen Dokumentation** angezeigt wird) -## Alternativ (alt): `Query` als Defaultwert +## Alternative (alt): `Query` als Defaultwert -Frühere Versionen von FastAPI (vor 0.95.0) benötigten `Query` als Defaultwert des Parameters, statt es innerhalb von `Annotated` unterzubringen. Die Chance ist groß, dass Sie Quellcode sehen, der das immer noch so macht, darum erkläre ich es Ihnen. +Frühere Versionen von FastAPI (vor 0.95.0) erforderten, dass Sie `Query` als den Defaultwert Ihres Parameters verwendeten, anstatt es innerhalb von `Annotated` zu platzieren. Es besteht eine hohe Wahrscheinlichkeit, dass Sie Code sehen, der es so verwendet, also werde ich es Ihnen erklären. /// tip | Tipp -Verwenden Sie für neuen Code, und wann immer möglich, `Annotated`, wie oben erklärt. Es gibt mehrere Vorteile (unten erläutert) und keine Nachteile. 🍰 +Für neuen Code und wann immer es möglich ist, verwenden Sie `Annotated` wie oben erklärt. Es gibt mehrere Vorteile (unten erläutert) und keine Nachteile. 🍰 /// -So würden Sie `Query()` als Defaultwert Ihres Funktionsparameters verwenden, den Parameter `max_length` auf 50 gesetzt: +So würden Sie `Query()` als den Defaultwert Ihres Funktionsparameters verwenden und den Parameter `max_length` auf 50 setzen: {* ../../docs_src/query_params_str_validations/tutorial002_py310.py hl[7] *} -Da wir in diesem Fall (ohne die Verwendung von `Annotated`) den Parameter-Defaultwert `None` mit `Query()` ersetzen, müssen wir nun dessen Defaultwert mit dem Parameter `Query(default=None)` deklarieren. Das dient demselben Zweck, `None` als Defaultwert für den Funktionsparameter zu setzen (zumindest für FastAPI). - -Sprich: - -```Python -q: Union[str, None] = Query(default=None) -``` - -... macht den Parameter optional, mit dem Defaultwert `None`, genauso wie: - -```Python -q: Union[str, None] = None -``` +Da wir in diesem Fall (ohne die Verwendung von `Annotated`) den Defaultwert `None` in der Funktion durch `Query()` ersetzen müssen, müssen wir nun den Defaultwert mit dem Parameter `Query(default=None)` setzen, er erfüllt den gleichen Zweck, diesen Defaultwert zu definieren (zumindest für FastAPI). -Und in Python 3.10 und darüber macht: +Also: ```Python q: str | None = Query(default=None) ``` -... den Parameter optional, mit dem Defaultwert `None`, genauso wie: +...macht den Parameter optional mit einem Defaultwert von `None`, genauso wie: ```Python q: str | None = None ``` -Nur, dass die `Query`-Versionen den Parameter explizit als Query-Parameter deklarieren. - -/// info +Aber die `Query`-Version deklariert ihn explizit als Query-Parameter. -Bedenken Sie, dass: +Dann können wir mehr Parameter an `Query` übergeben. In diesem Fall den `max_length`-Parameter, der auf Strings angewendet wird: ```Python -= None +q: str | None = Query(default=None, max_length=50) ``` -oder: - -```Python -= Query(default=None) -``` - -der wichtigste Teil ist, um einen Parameter optional zu machen, da dieses `None` der Defaultwert ist, und das ist es, was diesen Parameter **nicht erforderlich** macht. - -Der Teil mit `Union[str, None]` erlaubt es Ihrem Editor, Sie besser zu unterstützen, aber er sagt FastAPI nicht, dass dieser Parameter optional ist. - -/// - -Jetzt können wir `Query` weitere Parameter übergeben. Fangen wir mit dem `max_length` Parameter an, der auf Strings angewendet wird: - -```Python -q: Union[str, None] = Query(default=None, max_length=50) -``` - -Das wird die Daten validieren, einen verständlichen Fehler ausgeben, wenn die Daten nicht gültig sind, und den Parameter in der OpenAPI-Schema-*Pfadoperation* dokumentieren. +Dies wird die Daten validieren, einen klaren Fehler anzeigen, wenn die Daten nicht gültig sind, und den Parameter in der OpenAPI-Schema-*Pfadoperation* dokumentieren. ### `Query` als Defaultwert oder in `Annotated` -Bedenken Sie, dass wenn Sie `Query` innerhalb von `Annotated` benutzen, Sie den `default`-Parameter für `Query` nicht verwenden dürfen. +Beachten Sie, dass wenn Sie `Query` innerhalb von `Annotated` verwenden, Sie den `default`-Parameter für `Query` nicht verwenden dürfen. -Setzen Sie stattdessen den Defaultwert des Funktionsparameters, sonst wäre es inkonsistent. +Setzen Sie stattdessen den tatsächlichen Defaultwert des Funktionsparameters. Andernfalls wäre es inkonsistent. Zum Beispiel ist das nicht erlaubt: @@ -203,7 +157,7 @@ Zum Beispiel ist das nicht erlaubt: q: Annotated[str, Query(default="rick")] = "morty" ``` -... denn es wird nicht klar, ob der Defaultwert `"rick"` oder `"morty"` sein soll. +...denn es ist nicht klar, ob der Defaultwert `"rick"` oder `"morty"` sein soll. Sie würden also (bevorzugt) schreiben: @@ -211,7 +165,7 @@ Sie würden also (bevorzugt) schreiben: q: Annotated[str, Query()] = "rick" ``` -In älterem Code werden Sie auch finden: +...oder in älteren Codebasen finden Sie: ```Python q: str = Query(default="rick") @@ -219,41 +173,41 @@ q: str = Query(default="rick") ### Vorzüge von `Annotated` -**Es wird empfohlen, `Annotated` zu verwenden**, statt des Defaultwertes im Funktionsparameter, das ist aus mehreren Gründen **besser**: 🤓 +**Es wird empfohlen, `Annotated` zu verwenden**, anstelle des Defaultwertes in Funktionsparametern, es ist aus mehreren Gründen **besser**. 🤓 -Der **Default**wert des **Funktionsparameters** ist der **tatsächliche Default**wert, das spielt generell intuitiver mit Python zusammen. 😌 +Der **Default**wert des **Funktionsparameters** ist der **tatsächliche Default**wert, das ist in der Regel intuitiver mit Python. 😌 -Sie können die Funktion ohne FastAPI an **anderen Stellen aufrufen**, und es wird **wie erwartet funktionieren**. Wenn es einen **erforderlichen** Parameter gibt (ohne Defaultwert), und Sie führen die Funktion ohne den benötigten Parameter aus, dann wird Ihr **Editor** Sie das mit einem Fehler wissen lassen, und **Python** wird sich auch beschweren. +Sie könnten **diese gleiche Funktion** in **anderen Stellen** ohne FastAPI **aufrufen**, und es würde **wie erwartet funktionieren**. Wenn es einen **erforderlichen** Parameter gibt (ohne Defaultwert), wird Ihr **Editor** Ihnen dies mit einem Fehler mitteilen, außerdem wird **Python** sich beschweren, wenn Sie es ausführen, ohne den erforderlichen Parameter zu übergeben. -Wenn Sie aber nicht `Annotated` benutzen und stattdessen die **(alte) Variante mit einem Defaultwert**, dann müssen Sie, wenn Sie die Funktion ohne FastAPI an **anderen Stellen** aufrufen, sich daran **erinnern**, die Argumente der Funktion zu übergeben, damit es richtig funktioniert. Ansonsten erhalten Sie unerwartete Werte (z. B. `QueryInfo` oder etwas Ähnliches, statt `str`). Ihr Editor kann ihnen nicht helfen, und Python wird die Funktion ohne Beschwerden ausführen, es sei denn, die Operationen innerhalb lösen einen Fehler aus. +Wenn Sie `Annotated` nicht verwenden und stattdessen die **(alte) Defaultwert-Stilform** verwenden, müssen Sie sich daran **erinnern**, die Argumente der Funktion zu übergeben, wenn Sie diese Funktion ohne FastAPI in **anderen Stellen** aufrufen. Ansonsten sind die Werte anders als erwartet (z. B. `QueryInfo` oder etwas Ähnliches statt `str`). Ihr Editor kann Ihnen nicht helfen, und Python wird die Funktion ohne Klagen ausführen und sich nur beschweren wenn die Operationen innerhalb auf einen Fehler stoßen. -Da `Annotated` mehrere Metadaten haben kann, können Sie dieselbe Funktion auch mit anderen Tools verwenden, wie etwa Typer. 🚀 +Da `Annotated` mehr als eine Metadaten-Annotation haben kann, könnten Sie dieselbe Funktion sogar mit anderen Tools verwenden, wie z. B. Typer. 🚀 ## Mehr Validierungen hinzufügen -Sie können auch einen Parameter `min_length` hinzufügen: +Sie können auch einen `min_length`-Parameter hinzufügen: {* ../../docs_src/query_params_str_validations/tutorial003_an_py310.py hl[10] *} ## Reguläre Ausdrücke hinzufügen -Sie können einen Regulären Ausdruck `pattern` definieren, mit dem der Parameter übereinstimmen muss: +Sie können einen regulären Ausdruck `pattern` definieren, mit dem der Parameter übereinstimmen muss: {* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *} -Dieses bestimmte reguläre Suchmuster prüft, ob der erhaltene Parameter-Wert: +Dieses spezielle Suchmuster im regulären Ausdruck überprüft, dass der erhaltene Parameterwert: -* `^`: mit den nachfolgenden Zeichen startet, keine Zeichen davor hat. +* `^`: mit den nachfolgenden Zeichen beginnt, keine Zeichen davor hat. * `fixedquery`: den exakten Text `fixedquery` hat. -* `$`: danach endet, keine weiteren Zeichen hat als `fixedquery`. +* `$`: dort endet, keine weiteren Zeichen nach `fixedquery` hat. -Wenn Sie sich verloren fühlen bei all diesen **„Regulärer Ausdruck“**-Konzepten, keine Sorge. Reguläre Ausdrücke sind für viele Menschen ein schwieriges Thema. Sie können auch ohne reguläre Ausdrücke eine ganze Menge machen. +Wenn Sie sich mit all diesen **„regulärer Ausdruck“**-Ideen verloren fühlen, keine Sorge. Sie sind ein schwieriges Thema für viele Menschen. Sie können noch viele Dinge tun, ohne reguläre Ausdrücke direkt zu benötigen. -Aber wenn Sie sie brauchen und sie lernen, wissen Sie, dass Sie sie bereits direkt in **FastAPI** verwenden können. +Aber nun wissen Sie, dass Sie sie in **FastAPI** immer dann verwenden können, wenn Sie sie brauchen. ### Pydantic v1 `regex` statt `pattern` -Vor Pydantic Version 2 und vor FastAPI Version 0.100.0, war der Name des Parameters `regex` statt `pattern`, aber das ist jetzt deprecated. +Vor Pydantic Version 2 und FastAPI 0.100.0, hieß der Parameter `regex` statt `pattern`, aber das ist jetzt obsolet. Sie könnten immer noch Code sehen, der den alten Namen verwendet: @@ -263,25 +217,25 @@ Sie könnten immer noch Code sehen, der den alten Namen verwendet: //// -Beachten Sie aber, dass das deprecated ist, und zum neuen Namen `pattern` geändert werden sollte. 🤓 +Beachten Sie aber, dass das obsolet ist und auf den neuen Parameter `pattern` aktualisiert werden sollte. 🤓 ## Defaultwerte -Sie können natürlich andere Defaultwerte als `None` verwenden. +Natürlich können Sie Defaultwerte verwenden, die nicht `None` sind. -Beispielsweise könnten Sie den `q` Query-Parameter so deklarieren, dass er eine `min_length` von `3` hat, und den Defaultwert `"fixedquery"`: +Nehmen wir an, Sie möchten, dass der `q` Query-Parameter eine `min_length` von `3` hat und einen Defaultwert von `"fixedquery"`: {* ../../docs_src/query_params_str_validations/tutorial005_an_py39.py hl[9] *} /// note | Hinweis -Ein Parameter ist optional (nicht erforderlich), wenn er irgendeinen Defaultwert, auch `None`, hat. +Ein Defaultwert irgendeines Typs, einschließlich `None`, macht den Parameter optional (nicht erforderlich). /// ## Erforderliche Parameter -Wenn wir keine Validierungen oder Metadaten haben, können wir den `q` Query-Parameter erforderlich machen, indem wir einfach keinen Defaultwert deklarieren, wie in: +Wenn wir keine weiteren Validierungen oder Metadaten deklarieren müssen, können wir den `q` Query-Parameter erforderlich machen, indem wir einfach keinen Defaultwert deklarieren, wie: ```Python q: str @@ -290,56 +244,32 @@ q: str statt: ```Python -q: Union[str, None] = None +q: str | None = None ``` -Aber jetzt deklarieren wir den Parameter mit `Query`, wie in: - -//// tab | Annotiert +Aber jetzt deklarieren wir es mit `Query`, zum Beispiel so: ```Python -q: Annotated[Union[str, None], Query(min_length=3)] = None +q: Annotated[str | None, Query(min_length=3)] = None ``` -//// - -//// tab | Nicht annotiert - -```Python -q: Union[str, None] = Query(default=None, min_length=3) -``` - -//// - -Wenn Sie einen Parameter erforderlich machen wollen, während Sie `Query` verwenden, deklarieren Sie ebenfalls einfach keinen Defaultwert: +Wenn Sie einen Wert als erforderlich deklarieren müssen, während Sie `Query` verwenden, deklarieren Sie einfach keinen Defaultwert: {* ../../docs_src/query_params_str_validations/tutorial006_an_py39.py hl[9] *} ### Erforderlich, kann `None` sein -Sie können deklarieren, dass ein Parameter `None` akzeptiert, aber dennoch erforderlich ist. Das zwingt Clients, den Wert zu senden, selbst wenn er `None` ist. +Sie können deklarieren, dass ein Parameter `None` akzeptieren kann, aber trotzdem erforderlich ist. Dadurch müssten Clients den Wert senden, selbst wenn der Wert `None` ist. -Um das zu machen, deklarieren Sie, dass `None` ein gültiger Typ ist, aber verwenden Sie dennoch `...` als Default: +Um das zu tun, können Sie deklarieren, dass `None` ein gültiger Typ ist, einfach indem Sie keinen Defaultwert deklarieren: {* ../../docs_src/query_params_str_validations/tutorial006c_an_py310.py hl[9] *} -/// tip | Tipp - -Pydantic, welches die gesamte Datenvalidierung und Serialisierung in FastAPI antreibt, hat ein spezielles Verhalten, wenn Sie `Optional` oder `Union[Something, None]` ohne Defaultwert verwenden, Sie können mehr darüber in der Pydantic-Dokumentation unter Required fields erfahren. - -/// - -/// tip | Tipp - -Denken Sie daran, dass Sie in den meisten Fällen, wenn etwas erforderlich ist, einfach den Defaultwert weglassen können. Sie müssen also normalerweise `...` nicht verwenden. - -/// - ## Query-Parameter-Liste / Mehrere Werte -Wenn Sie einen Query-Parameter explizit mit `Query` auszeichnen, können Sie ihn auch eine Liste von Werten empfangen lassen, oder anders gesagt, mehrere Werte. +Wenn Sie einen Query-Parameter explizit mit `Query` definieren, können Sie ihn auch so deklarieren, dass er eine Liste von Werten empfängt, oder anders gesagt, dass er mehrere Werte empfangen kann. -Um zum Beispiel einen Query-Parameter `q` zu deklarieren, der mehrere Male in der URL vorkommen kann, schreiben Sie: +Um zum Beispiel einen Query-Parameter `q` zu deklarieren, der mehrmals in der URL vorkommen kann, schreiben Sie: {* ../../docs_src/query_params_str_validations/tutorial011_an_py310.py hl[9] *} @@ -349,9 +279,9 @@ Dann, mit einer URL wie: http://localhost:8000/items/?q=foo&q=bar ``` -bekommen Sie alle `q`-*Query-Parameter*-Werte (`foo` und `bar`) in einer Python-Liste – `list` – in ihrer *Pfadoperation-Funktion*, im Funktionsparameter `q`, überreicht. +würden Sie die mehreren `q`-*Query-Parameter*-Werte (`foo` und `bar`) in einer Python-`list` in Ihrer *Pfadoperation-Funktion* im *Funktionsparameter* `q` erhalten. -Die Response für diese URL wäre also: +So wäre die Response zu dieser URL: ```JSON { @@ -364,27 +294,27 @@ Die Response für diese URL wäre also: /// tip | Tipp -Um einen Query-Parameter vom Typ `list` zu deklarieren, wie im Beispiel oben, müssen Sie explizit `Query` verwenden, sonst würde der Parameter als Requestbody interpretiert werden. +Um einen Query-Parameter mit einem Typ `list` zu deklarieren, wie im obigen Beispiel, müssen Sie explizit `Query` verwenden, da er andernfalls als Requestbody interpretiert würde. /// -Die interaktive API-Dokumentation wird entsprechend aktualisiert und erlaubt jetzt mehrere Werte. +Die interaktive API-Dokumentation wird entsprechend aktualisiert, um mehrere Werte zu erlauben: ### Query-Parameter-Liste / Mehrere Werte mit Defaults -Und Sie können auch eine Default-`list`e von Werten definieren, wenn keine übergeben werden: +Sie können auch eine Default-`list` von Werten definieren, wenn keine bereitgestellt werden: {* ../../docs_src/query_params_str_validations/tutorial012_an_py39.py hl[9] *} -Wenn Sie auf: +Wenn Sie zu: ``` http://localhost:8000/items/ ``` -gehen, wird der Default für `q` verwendet: `["foo", "bar"]`, und als Response erhalten Sie: +gehen, wird der Default für `q` sein: `["foo", "bar"]`, und Ihre Antwort wird sein: ```JSON { @@ -395,9 +325,9 @@ gehen, wird der Default für `q` verwendet: `["foo", "bar"]`, und als Response e } ``` -#### `list` alleine verwenden +#### Nur `list` verwenden -Sie können auch `list` direkt verwenden, anstelle von `List[str]` (oder `list[str]` in Python 3.9+): +Sie können auch `list` direkt verwenden, anstelle von `list[str]`: {* ../../docs_src/query_params_str_validations/tutorial013_an_py39.py hl[9] *} @@ -405,35 +335,35 @@ Sie können auch `list` direkt verwenden, anstelle von `List[str]` (oder `list[s Beachten Sie, dass FastAPI in diesem Fall den Inhalt der Liste nicht überprüft. -Zum Beispiel würde `List[int]` überprüfen (und dokumentieren) dass die Liste Ganzzahlen enthält. `list` alleine macht das nicht. +Zum Beispiel würde `list[int]` überprüfen (und dokumentieren), dass der Inhalt der Liste Ganzzahlen sind. Aber `list` alleine würde das nicht. /// -## Deklarieren von mehr Metadaten +## Mehr Metadaten deklarieren -Sie können mehr Informationen zum Parameter hinzufügen. +Sie können mehr Informationen über den Parameter hinzufügen. -Diese Informationen werden zur generierten OpenAPI hinzugefügt, und von den Dokumentations-Oberflächen und von externen Tools verwendet. +Diese Informationen werden in das generierte OpenAPI aufgenommen und von den Dokumentationsoberflächen und externen Tools verwendet. /// note | Hinweis -Beachten Sie, dass verschiedene Tools OpenAPI möglicherweise unterschiedlich gut unterstützen. +Beachten Sie, dass verschiedene Tools möglicherweise unterschiedliche Unterstützungslevels für OpenAPI haben. -Einige könnten noch nicht alle zusätzlichen Informationen anzeigen, die Sie deklariert haben, obwohl in den meisten Fällen geplant ist, das fehlende Feature zu implementieren. +Einige davon könnten noch nicht alle zusätzlichen Informationen anzuzeigen, die Sie erklärten, obwohl in den meisten Fällen die fehlende Funktionalität bereits in der Entwicklung geplant ist. /// -Sie können einen Titel hinzufügen – `title`: +Sie können einen `title` hinzufügen: {* ../../docs_src/query_params_str_validations/tutorial007_an_py310.py hl[10] *} -Und eine Beschreibung – `description`: +Und eine `description`: {* ../../docs_src/query_params_str_validations/tutorial008_an_py310.py hl[14] *} ## Alias-Parameter -Stellen Sie sich vor, der Parameter soll `item-query` sein. +Stellen Sie sich vor, Sie möchten, dass der Parameter `item-query` ist. Wie in: @@ -443,37 +373,99 @@ http://127.0.0.1:8000/items/?item-query=foobaritems Aber `item-query` ist kein gültiger Name für eine Variable in Python. -Am ähnlichsten wäre `item_query`. +Der am ähnlichsten wäre `item_query`. -Aber Sie möchten dennoch exakt `item-query` verwenden. +Aber Sie benötigen dennoch, dass er genau `item-query` ist... -Dann können Sie einen `alias` deklarieren, und dieser Alias wird verwendet, um den Parameter-Wert zu finden: +Dann können Sie ein `alias` deklarieren, und dieser Alias wird verwendet, um den Parameterwert zu finden: {* ../../docs_src/query_params_str_validations/tutorial009_an_py310.py hl[9] *} ## Parameter als deprecated ausweisen -Nehmen wir an, Sie mögen diesen Parameter nicht mehr. +Nehmen wir an, Ihnen gefällt dieser Parameter nicht mehr. -Sie müssen ihn eine Weile dort belassen, weil Clients ihn benutzen, aber Sie möchten, dass die Dokumentation klar anzeigt, dass er deprecated ist. +Sie müssen ihn eine Weile dort belassen, da es Clients gibt, die ihn verwenden, aber Sie möchten, dass die Dokumentation ihn klar als deprecated anzeigt. -In diesem Fall fügen Sie den Parameter `deprecated=True` zu `Query` hinzu. +Dann übergeben Sie den Parameter `deprecated=True` an `Query`: {* ../../docs_src/query_params_str_validations/tutorial010_an_py310.py hl[19] *} -Die Dokumentation wird das so anzeigen: +Die Dokumentation wird es so anzeigen: ## Parameter von OpenAPI ausschließen -Um einen Query-Parameter vom generierten OpenAPI-Schema auszuschließen (und daher von automatischen Dokumentations-Systemen), setzen Sie den Parameter `include_in_schema` in `Query` auf `False`. +Um einen Query-Parameter aus dem generierten OpenAPI-Schema auszuschließen (und somit aus den automatischen Dokumentationssystemen), setzen Sie den Parameter `include_in_schema` von `Query` auf `False`: {* ../../docs_src/query_params_str_validations/tutorial014_an_py310.py hl[10] *} +## Benutzerdefinierte Validierung + +Es kann Fälle geben, in denen Sie eine **benutzerdefinierte Validierung** durchführen müssen, die nicht mit den oben gezeigten Parametern durchgeführt werden kann. + +In diesen Fällen können Sie eine **benutzerdefinierte Validierungsfunktion** verwenden, die nach der normalen Validierung angewendet wird (z. B. nach der Validierung, dass der Wert ein `str` ist). + +Sie können dies mit Pydantic's `AfterValidator` innerhalb von `Annotated` erreichen. + +/// tip | Tipp + +Pydantic unterstützt auch `BeforeValidator` und andere. 🤓 + +/// + +Zum Beispiel überprüft dieser benutzerdefinierte Validator, ob die Artikel-ID mit `isbn-` für eine ISBN-Buchnummer oder mit `imdb-` für eine IMDB-Film-URL-ID beginnt: + +{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *} + +/// info | Info + +Dies ist verfügbar seit Pydantic Version 2 oder höher. 😎 + +/// + +/// tip | Tipp + +Wenn Sie irgendeine Art von Validierung durchführen müssen, die eine Kommunikation mit einer **externen Komponente** erfordert, wie z. B. einer Datenbank oder einer anderen API, sollten Sie stattdessen **FastAPI-Abhängigkeiten** verwenden. Sie werden diese später kennenlernen. + +Diese benutzerdefinierten Validatoren sind für Dinge gedacht, die einfach mit denselben **Daten** überprüft werden können, die in der Anfrage bereitgestellt werden. + +/// + +### Verstehen Sie dieses Codebeispiel + +Der wichtige Punkt ist einfach die Verwendung von **`AfterValidator` mit einer Funktion innerhalb von `Annotated`**. Fühlen Sie sich frei, diesen Teil zu überspringen. 🤸 + +--- + +Aber wenn Sie neugierig auf dieses spezielle Codebeispiel sind und immer noch Spaß haben, hier sind einige zusätzliche Details. + +#### Zeichenkette mit `value.startswith()` + +Haben Sie bemerkt? Eine Zeichenkette mit `value.startswith()` kann ein Tuple übernehmen, und es wird jeden Wert im Tuple überprüfen: + +{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *} + +#### Ein zufälliges Item + +Mit `data.items()` erhalten wir ein iterierbares Objekt mit Tupeln, die Schlüssel und Wert für jedes Dictionary-Element enthalten. + +Wir konvertieren dieses iterierbare Objekt mit `list(data.items())` in eine richtige `list`. + +Dann können wir mit `random.choice()` einen **zufälligen Wert** aus der Liste erhalten, also bekommen wir ein Tuple mit `(id, name)`. Es wird etwas wie `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")` sein. + +Dann **weisen wir diese beiden Werte** des Tupels den Variablen `id` und `name` zu. + +Wenn der Benutzer also keine Artikel-ID bereitgestellt hat, erhält er trotzdem einen zufälligen Vorschlag. + +...wir tun all dies in einer **einzelnen einfachen Zeile**. 🤯 Lieben Sie nicht auch Python? 🐍 + +{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *} + ## Zusammenfassung -Sie können zusätzliche Validierungen und Metadaten zu ihren Parametern hinzufügen. +Sie können zusätzliche Validierungen und Metadaten für Ihre Parameter deklarieren. Allgemeine Validierungen und Metadaten: @@ -482,12 +474,14 @@ Allgemeine Validierungen und Metadaten: * `description` * `deprecated` -Validierungen spezifisch für Strings: +Validierungen, die spezifisch für Strings sind: * `min_length` * `max_length` * `pattern` -In diesen Beispielen haben Sie gesehen, wie Sie Validierungen für Strings hinzufügen. +Benutzerdefinierte Validierungen mit `AfterValidator`. + +In diesen Beispielen haben Sie gesehen, wie Sie Validierungen für `str`-Werte deklarieren. -In den nächsten Kapiteln sehen wir, wie man Validierungen für andere Typen hinzufügt, etwa für Zahlen. +Sehen Sie sich die nächsten Kapitel an, um zu erfahren, wie Sie Validierungen für andere Typen, wie z. B. Zahlen, deklarieren. diff --git a/docs/de/docs/tutorial/response-status-code.md b/docs/de/docs/tutorial/response-status-code.md index a1b388a0a..c08c5895c 100644 --- a/docs/de/docs/tutorial/response-status-code.md +++ b/docs/de/docs/tutorial/response-status-code.md @@ -1,6 +1,6 @@ # Response-Statuscode -So wie ein Responsemodell, können Sie auch einen HTTP-Statuscode für die Response deklarieren, mithilfe des Parameters `status_code`, und zwar in jeder der *Pfadoperationen*: +Genauso wie Sie ein Responsemodell angeben können, können Sie auch den HTTP-Statuscode für die Response mit dem Parameter `status_code` in jeder der *Pfadoperationen* deklarieren: * `@app.get()` * `@app.post()` @@ -12,22 +12,22 @@ So wie ein Responsemodell, können Sie auch einen HTTP-Statuscode für die Respo /// note | Hinweis -Beachten Sie, dass `status_code` ein Parameter der „Dekorator“-Methode ist (`get`, `post`, usw.). Nicht der *Pfadoperation-Funktion*, so wie die anderen Parameter und der Body. +Beachten Sie, dass `status_code` ein Parameter der „Dekorator“-Methode ist (`get`, `post`, usw.). Nicht der *Pfadoperation-Funktion*, wie alle anderen Parameter und der Body. /// Dem `status_code`-Parameter wird eine Zahl mit dem HTTP-Statuscode übergeben. -/// info +/// info | Info -Alternativ kann `status_code` auch ein `IntEnum` erhalten, so wie Pythons `http.HTTPStatus`. +Alternativ kann `status_code` auch ein `IntEnum` erhalten, wie etwa Pythons `http.HTTPStatus`. /// -Das wird: +Dies wird: * Diesen Statuscode mit der Response zurücksenden. -* Ihn als solchen im OpenAPI-Schema dokumentieren (und somit in den Benutzeroberflächen): +* Diesen im OpenAPI-Schema dokumentieren (und somit in den Benutzeroberflächen): @@ -35,7 +35,7 @@ Das wird: Einige Responsecodes (siehe nächster Abschnitt) kennzeichnen, dass die Response keinen Body hat. -FastAPI versteht das und wird in der OpenAPI-Dokumentation anzeigen, dass es keinen Responsebody gibt. +FastAPI erkennt dies und erstellt eine OpenAPI-Dokumentation, die zeigt, dass es keinen Responsebody gibt. /// @@ -43,59 +43,59 @@ FastAPI versteht das und wird in der OpenAPI-Dokumentation anzeigen, dass es kei /// note | Hinweis -Wenn Sie bereits wissen, was HTTP-Statuscodes sind, überspringen Sie dieses Kapitel und fahren Sie mit dem nächsten fort. +Wenn Sie bereits wissen, was HTTP-Statuscodes sind, können Sie diesen Abschnitt überspringen und mit dem nächsten fortfahren. /// -In HTTP senden Sie als Teil der Response einen aus drei Ziffern bestehenden numerischen Statuscode. +In HTTP senden Sie einen numerischen Statuscode mit 3 Ziffern als Teil der Response. -Diese Statuscodes haben einen Namen zugeordnet, um sie besser zu erkennen, aber der wichtige Teil ist die Zahl. +Diese Statuscodes haben einen zugeordneten Namen, um sie leichter zu erkennen, aber der wichtige Teil ist die Zahl. -Kurz: +Kurz gefasst: -* `100` und darüber stehen für „Information“. Diese verwenden Sie selten direkt. Responses mit diesen Statuscodes können keinen Body haben. -* **`200`** und darüber stehen für Responses, die „Successful“ („Erfolgreich“) waren. Diese verwenden Sie am häufigsten. - * `200` ist der Default-Statuscode, welcher bedeutet, alles ist „OK“. - * Ein anderes Beispiel ist `201`, „Created“ („Erzeugt“). Wird in der Regel verwendet, wenn ein neuer Datensatz in der Datenbank erzeugt wurde. - * Ein spezieller Fall ist `204`, „No Content“ („Kein Inhalt“). Diese Response wird verwendet, wenn es keinen Inhalt gibt, der zum Client zurückgeschickt wird, diese Response hat also keinen Body. -* **`300`** und darüber steht für „Redirection“ („Umleitung“). Responses mit diesen Statuscodes können einen oder keinen Body haben, mit Ausnahme von `304`, „Not Modified“ („Nicht verändert“), welche keinen haben darf. -* **`400`** und darüber stehen für „Client error“-Responses („Client-Fehler“). Auch diese verwenden Sie am häufigsten. +* `100 - 199` stehen für „Information“. Sie verwenden diese selten direkt. Responses mit diesen Statuscodes dürfen keinen Body haben. +* **`200 - 299`** stehen für „Successful“-Responses („Erfolgreich“). Diese werden Sie am häufigsten verwenden. + * `200` ist der Default-Statuscode, was bedeutet, alles ist „OK“. + * Ein weiteres Beispiel wäre `201`, „Created“ („Erzeugt“). Dieser wird üblicherweise verwendet, nachdem ein neuer Datensatz in der Datenbank erstellt wurde. + * Ein spezieller Fall ist `204`, „No Content“ („Kein Inhalt“). Diese Response wird verwendet, wenn es keinen Inhalt gibt, der an den Client zurückgeschickt werden soll, und diese Response darf daher keinen Body haben. +* **`300 - 399`** stehen für „Redirection“ („Umleitung“). Responses mit diesen Statuscodes können einen Body haben oder nicht, außer bei `304`, „Not Modified“ („Nicht verändert“), die keinen haben darf. +* **`400 - 499`** stehen für „Client error“-Responses („Client-Fehler“). Diese sind die zweithäufigsten, die Sie vermutlich verwenden werden. * Ein Beispiel ist `404`, für eine „Not Found“-Response („Nicht gefunden“). * Für allgemeine Fehler beim Client können Sie einfach `400` verwenden. -* `500` und darüber stehen für Server-Fehler. Diese verwenden Sie fast nie direkt. Wenn etwas an irgendeiner Stelle in Ihrem Anwendungscode oder im Server schiefläuft, wird automatisch einer dieser Fehler-Statuscodes zurückgegeben. +* `500 - 599` stehen für Server-Fehler. Diese verwenden Sie fast nie direkt. Wenn in Ihrem Anwendungscode oder Server etwas schiefgeht, wird automatisch einer dieser Fehler-Statuscodes zurückgegeben. /// tip | Tipp -Um mehr über Statuscodes zu lernen, und welcher wofür verwendet wird, lesen Sie die MDN Dokumentation über HTTP-Statuscodes. +Um mehr über die einzelnen Statuscodes zu erfahren und welcher wofür verwendet wird, sehen Sie sich die MDN Dokumentation über HTTP-Statuscodes an. /// -## Abkürzung, um die Namen zu erinnern +## Abkürzung zur Erinnerung an die Namen -Schauen wir uns das vorherige Beispiel noch einmal an: +Lassen Sie uns das vorherige Beispiel noch einmal anschauen: {* ../../docs_src/response_status_code/tutorial001.py hl[6] *} `201` ist der Statuscode für „Created“ („Erzeugt“). -Aber Sie müssen sich nicht daran erinnern, welcher dieser Codes was bedeutet. +Aber Sie müssen sich nicht merken, was jeder dieser Codes bedeutet. -Sie können die Hilfsvariablen von `fastapi.status` verwenden. +Sie können die Annehmlichkeit von Variablen aus `fastapi.status` nutzen. {* ../../docs_src/response_status_code/tutorial002.py hl[1,6] *} -Diese sind nur eine Annehmlichkeit und enthalten dieselbe Nummer, aber auf diese Weise können Sie die Autovervollständigung Ihres Editors verwenden, um sie zu finden: +Diese sind nur eine Annehmlichkeit, sie enthalten dieselbe Zahl, aber so können Sie die Autovervollständigung Ihres Editors verwenden, um sie zu finden: /// note | Technische Details -Sie können auch `from starlette import status` verwenden. +Sie könnten auch `from starlette import status` verwenden. -**FastAPI** bietet dieselben `starlette.status`-Codes auch via `fastapi.status` an, als Annehmlichkeit für Sie, den Entwickler. Sie kommen aber direkt von Starlette. +**FastAPI** bietet dieselben `starlette.status`-Codes auch über `fastapi.status` an, rein zu Ihrer Annehmlichkeit als Entwickler. Aber sie stammen direkt von Starlette. /// ## Den Defaultwert ändern -Später sehen Sie, im [Handbuch für fortgeschrittene Benutzer](../advanced/response-change-status-code.md){.internal-link target=_blank}, wie Sie einen anderen Statuscode zurückgeben können, als den Default, den Sie hier deklarieren. +Später im [Handbuch für fortgeschrittene Benutzer](../advanced/response-change-status-code.md){.internal-link target=_blank} werden Sie sehen, wie Sie einen anderen Statuscode zurückgeben können, als den Default, den Sie hier deklarieren. From 70b8058c836b41b56abe731aab381642f3cf1efd Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 17 Aug 2025 17:08:32 +0200 Subject: [PATCH 005/160] Apply branch `add-permalinks-to-en-docs` --- README.md | 44 +++++------ docs/en/docs/about/index.md | 2 +- docs/en/docs/advanced/additional-responses.md | 12 +-- .../docs/advanced/additional-status-codes.md | 6 +- .../en/docs/advanced/advanced-dependencies.md | 12 +-- docs/en/docs/advanced/async-tests.md | 14 ++-- docs/en/docs/advanced/behind-a-proxy.md | 26 +++---- docs/en/docs/advanced/custom-response.md | 40 +++++----- docs/en/docs/advanced/dataclasses.md | 10 +-- docs/en/docs/advanced/events.md | 22 +++--- docs/en/docs/advanced/generate-clients.md | 32 ++++---- docs/en/docs/advanced/index.md | 6 +- docs/en/docs/advanced/middleware.md | 14 ++-- docs/en/docs/advanced/openapi-callbacks.md | 20 ++--- docs/en/docs/advanced/openapi-webhooks.md | 10 +-- .../path-operation-advanced-configuration.md | 20 ++--- .../advanced/response-change-status-code.md | 6 +- docs/en/docs/advanced/response-cookies.md | 8 +- docs/en/docs/advanced/response-directly.md | 10 +-- docs/en/docs/advanced/response-headers.md | 8 +- .../docs/advanced/security/http-basic-auth.md | 16 ++-- docs/en/docs/advanced/security/index.md | 6 +- .../docs/advanced/security/oauth2-scopes.md | 30 ++++---- docs/en/docs/advanced/settings.md | 36 ++++----- docs/en/docs/advanced/sub-applications.md | 14 ++-- docs/en/docs/advanced/templates.md | 16 ++-- docs/en/docs/advanced/testing-dependencies.md | 8 +- docs/en/docs/advanced/testing-events.md | 2 +- docs/en/docs/advanced/testing-websockets.md | 2 +- .../docs/advanced/using-request-directly.md | 8 +- docs/en/docs/advanced/websockets.md | 22 +++--- docs/en/docs/advanced/wsgi.md | 6 +- docs/en/docs/alternatives.md | 48 ++++++------ docs/en/docs/async.md | 42 +++++------ docs/en/docs/benchmarks.md | 4 +- docs/en/docs/deployment/cloud.md | 4 +- docs/en/docs/deployment/concepts.md | 56 +++++++------- docs/en/docs/deployment/docker.md | 74 +++++++++---------- docs/en/docs/deployment/https.md | 28 +++---- docs/en/docs/deployment/index.md | 6 +- docs/en/docs/deployment/manually.md | 14 ++-- docs/en/docs/deployment/server-workers.md | 10 +-- docs/en/docs/deployment/versions.md | 14 ++-- docs/en/docs/environment-variables.md | 14 ++-- docs/en/docs/fastapi-cli.md | 6 +- docs/en/docs/features.md | 28 +++---- docs/en/docs/help-fastapi.md | 50 ++++++------- docs/en/docs/history-design-future.md | 14 ++-- docs/en/docs/how-to/conditional-openapi.md | 6 +- docs/en/docs/how-to/configure-swagger-ui.md | 12 +-- docs/en/docs/how-to/custom-docs-ui-assets.md | 30 ++++---- .../docs/how-to/custom-request-and-route.md | 14 ++-- docs/en/docs/how-to/extending-openapi.md | 18 ++--- docs/en/docs/how-to/general.md | 20 ++--- docs/en/docs/how-to/graphql.md | 10 +-- docs/en/docs/how-to/index.md | 2 +- .../docs/how-to/separate-openapi-schemas.md | 20 ++--- docs/en/docs/how-to/testing-database.md | 2 +- docs/en/docs/index.md | 46 ++++++------ docs/en/docs/learn/index.md | 2 +- docs/en/docs/project-generation.md | 4 +- docs/en/docs/python-types.md | 40 +++++----- docs/en/docs/resources/index.md | 2 +- docs/en/docs/tutorial/background-tasks.md | 16 ++-- docs/en/docs/tutorial/bigger-applications.md | 42 +++++------ docs/en/docs/tutorial/body-fields.md | 10 +-- docs/en/docs/tutorial/body-multiple-params.md | 14 ++-- docs/en/docs/tutorial/body-nested-models.md | 32 ++++---- docs/en/docs/tutorial/body-updates.md | 14 ++-- docs/en/docs/tutorial/body.md | 22 +++--- docs/en/docs/tutorial/cookie-param-models.md | 10 +-- docs/en/docs/tutorial/cookie-params.md | 8 +- docs/en/docs/tutorial/cors.md | 16 ++-- docs/en/docs/tutorial/debugging.md | 10 +-- .../dependencies/classes-as-dependencies.md | 14 ++-- ...pendencies-in-path-operation-decorators.md | 16 ++-- .../dependencies/dependencies-with-yield.md | 28 +++---- .../dependencies/global-dependencies.md | 4 +- docs/en/docs/tutorial/dependencies/index.md | 28 +++---- .../tutorial/dependencies/sub-dependencies.md | 12 +-- docs/en/docs/tutorial/encoder.md | 4 +- docs/en/docs/tutorial/extra-data-types.md | 6 +- docs/en/docs/tutorial/extra-models.md | 26 +++---- docs/en/docs/tutorial/first-steps.md | 42 +++++------ docs/en/docs/tutorial/handling-errors.md | 28 +++---- docs/en/docs/tutorial/header-param-models.md | 12 +-- docs/en/docs/tutorial/header-params.md | 12 +-- docs/en/docs/tutorial/index.md | 8 +- docs/en/docs/tutorial/metadata.md | 20 ++--- docs/en/docs/tutorial/middleware.md | 10 +-- .../tutorial/path-operation-configuration.md | 18 ++--- .../path-params-numeric-validations.md | 20 ++--- docs/en/docs/tutorial/path-params.md | 40 +++++----- docs/en/docs/tutorial/query-param-models.md | 10 +-- .../tutorial/query-params-str-validations.md | 52 ++++++------- docs/en/docs/tutorial/query-params.md | 12 +-- docs/en/docs/tutorial/request-files.md | 22 +++--- docs/en/docs/tutorial/request-form-models.md | 10 +-- .../docs/tutorial/request-forms-and-files.md | 8 +- docs/en/docs/tutorial/request-forms.md | 10 +-- docs/en/docs/tutorial/response-model.md | 44 +++++------ docs/en/docs/tutorial/response-status-code.md | 8 +- docs/en/docs/tutorial/schema-extra-example.md | 30 ++++---- docs/en/docs/tutorial/security/first-steps.md | 20 ++--- .../tutorial/security/get-current-user.md | 16 ++-- docs/en/docs/tutorial/security/index.md | 16 ++-- docs/en/docs/tutorial/security/oauth2-jwt.md | 28 +++---- .../docs/tutorial/security/simple-oauth2.md | 36 ++++----- docs/en/docs/tutorial/sql-databases.md | 54 +++++++------- docs/en/docs/tutorial/static-files.md | 10 +-- docs/en/docs/tutorial/testing.md | 18 ++--- docs/en/docs/virtual-environments.md | 46 ++++++------ requirements-docs.txt | 2 +- scripts/mkdocs_hooks.py | 2 +- 114 files changed, 1062 insertions(+), 1062 deletions(-) diff --git a/README.md b/README.md index 0e421c347..95d123819 100644 --- a/README.md +++ b/README.md @@ -42,7 +42,7 @@ The key features are: * estimation based on tests on an internal development team, building production applications. -## Sponsors +## Sponsors { #sponsors } @@ -69,7 +69,7 @@ The key features are: Other sponsors -## Opinions +## Opinions { #opinions } "_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._" @@ -115,7 +115,7 @@ The key features are: --- -## **Typer**, the FastAPI of CLIs +## **Typer**, the FastAPI of CLIs { #typer-the-fastapi-of-clis } @@ -123,14 +123,14 @@ If you are building a CLI app to be **Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀 -## Requirements +## Requirements { #requirements } FastAPI stands on the shoulders of giants: * Starlette for the web parts. * Pydantic for the data parts. -## Installation +## Installation { #installation } Create and activate a virtual environment and then install FastAPI: @@ -146,9 +146,9 @@ $ pip install "fastapi[standard]" **Note**: Make sure you put `"fastapi[standard]"` in quotes to ensure it works in all terminals. -## Example +## Example { #example } -### Create it +### Create it { #create-it } Create a file `main.py` with: @@ -199,7 +199,7 @@ If you don't know, check the _"In a hurry?"_ section about -### Check it +### Check it { #check-it } Open your browser at http://127.0.0.1:8000/items/5?q=somequery. @@ -258,7 +258,7 @@ You already created an API that: * The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`. * The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`. -### Interactive API docs +### Interactive API docs { #interactive-api-docs } Now go to http://127.0.0.1:8000/docs. @@ -266,7 +266,7 @@ You will see the automatic interactive API documentation (provided by http://127.0.0.1:8000/redoc. @@ -274,7 +274,7 @@ You will see the alternative automatic documentation (provided by http://127.0.0.1:8000/docs. @@ -328,7 +328,7 @@ Now go to http://127.0.0.1:8000/redoc. @@ -336,7 +336,7 @@ And now, go to one of the fastest Python frameworks available, only below Starlette and Uvicorn themselves (used internally by FastAPI). (*) To understand more about it, see the section Benchmarks. -## Dependencies +## Dependencies { #dependencies } FastAPI depends on Pydantic and Starlette. -### `standard` Dependencies +### `standard` Dependencies { #standard-dependencies } When you install FastAPI with `pip install "fastapi[standard]"` it comes with the `standard` group of optional dependencies: @@ -478,15 +478,15 @@ Used by FastAPI: * `fastapi-cli[standard]` - to provide the `fastapi` command. * This includes `fastapi-cloud-cli`, which allows you to deploy your FastAPI application to FastAPI Cloud. -### Without `standard` Dependencies +### Without `standard` Dependencies { #without-standard-dependencies } If you don't want to include the `standard` optional dependencies, you can install with `pip install fastapi` instead of `pip install "fastapi[standard]"`. -### Without `fastapi-cloud-cli` +### Without `fastapi-cloud-cli` { #without-fastapi-cloud-cli } If you want to install FastAPI with the standard dependencies but without the `fastapi-cloud-cli`, you can install with `pip install "fastapi[standard-no-fastapi-cloud-cli]"`. -### Additional Optional Dependencies +### Additional Optional Dependencies { #additional-optional-dependencies } There are some additional dependencies you might want to install. @@ -500,6 +500,6 @@ Additional optional FastAPI dependencies: * orjson - Required if you want to use `ORJSONResponse`. * ujson - Required if you want to use `UJSONResponse`. -## License +## License { #license } This project is licensed under the terms of the MIT license. diff --git a/docs/en/docs/about/index.md b/docs/en/docs/about/index.md index 27b78696b..d178dfec7 100644 --- a/docs/en/docs/about/index.md +++ b/docs/en/docs/about/index.md @@ -1,3 +1,3 @@ -# About +# About { #about } About FastAPI, its design, inspiration and more. 🤓 diff --git a/docs/en/docs/advanced/additional-responses.md b/docs/en/docs/advanced/additional-responses.md index 03d48c2a7..799532c5b 100644 --- a/docs/en/docs/advanced/additional-responses.md +++ b/docs/en/docs/advanced/additional-responses.md @@ -1,4 +1,4 @@ -# Additional Responses in OpenAPI +# Additional Responses in OpenAPI { #additional-responses-in-openapi } /// warning @@ -14,7 +14,7 @@ Those additional responses will be included in the OpenAPI schema, so they will But for those additional responses you have to make sure you return a `Response` like `JSONResponse` directly, with your status code and content. -## Additional Response with `model` +## Additional Response with `model` { #additional-response-with-model } You can pass to your *path operation decorators* a parameter `responses`. @@ -169,7 +169,7 @@ The schemas are referenced to another place inside the OpenAPI schema: } ``` -## Additional media types for the main response +## Additional media types for the main response { #additional-media-types-for-the-main-response } You can use this same `responses` parameter to add different media types for the same main response. @@ -191,7 +191,7 @@ But if you have specified a custom response class with `None` as its media type, /// -## Combining information +## Combining information { #combining-information } You can also combine response information from multiple places, including the `response_model`, `status_code`, and `responses` parameters. @@ -209,7 +209,7 @@ It will all be combined and included in your OpenAPI, and shown in the API docs: -## Combine predefined responses and custom ones +## Combine predefined responses and custom ones { #combine-predefined-responses-and-custom-ones } You might want to have some predefined responses that apply to many *path operations*, but you want to combine them with custom responses needed by each *path operation*. @@ -239,7 +239,7 @@ For example: {* ../../docs_src/additional_responses/tutorial004.py hl[13:17,26] *} -## More information about OpenAPI responses +## More information about OpenAPI responses { #more-information-about-openapi-responses } To see what exactly you can include in the responses, you can check these sections in the OpenAPI specification: diff --git a/docs/en/docs/advanced/additional-status-codes.md b/docs/en/docs/advanced/additional-status-codes.md index 077a00488..2c02e41b4 100644 --- a/docs/en/docs/advanced/additional-status-codes.md +++ b/docs/en/docs/advanced/additional-status-codes.md @@ -1,10 +1,10 @@ -# Additional Status Codes +# Additional Status Codes { #additional-status-codes } By default, **FastAPI** will return the responses using a `JSONResponse`, putting the content you return from your *path operation* inside of that `JSONResponse`. It will use the default status code or the one you set in your *path operation*. -## Additional status codes +## Additional status codes { #additional-status-codes } If you want to return additional status codes apart from the main one, you can do that by returning a `Response` directly, like a `JSONResponse`, and set the additional status code directly. @@ -34,7 +34,7 @@ You could also use `from starlette.responses import JSONResponse`. /// -## OpenAPI and API docs +## OpenAPI and API docs { #openapi-and-api-docs } If you return additional status codes and responses directly, they won't be included in the OpenAPI schema (the API docs), because FastAPI doesn't have a way to know beforehand what you are going to return. diff --git a/docs/en/docs/advanced/advanced-dependencies.md b/docs/en/docs/advanced/advanced-dependencies.md index f933fd264..c71c11404 100644 --- a/docs/en/docs/advanced/advanced-dependencies.md +++ b/docs/en/docs/advanced/advanced-dependencies.md @@ -1,6 +1,6 @@ -# Advanced Dependencies +# Advanced Dependencies { #advanced-dependencies } -## Parameterized dependencies +## Parameterized dependencies { #parameterized-dependencies } All the dependencies we have seen are a fixed function or class. @@ -10,7 +10,7 @@ Let's imagine that we want to have a dependency that checks if the query paramet But we want to be able to parameterize that fixed content. -## A "callable" instance +## A "callable" instance { #a-callable-instance } In Python there's a way to make an instance of a class a "callable". @@ -22,7 +22,7 @@ To do that, we declare a method `__call__`: In this case, this `__call__` is what **FastAPI** will use to check for additional parameters and sub-dependencies, and this is what will be called to pass a value to the parameter in your *path operation function* later. -## Parameterize the instance +## Parameterize the instance { #parameterize-the-instance } And now, we can use `__init__` to declare the parameters of the instance that we can use to "parameterize" the dependency: @@ -30,7 +30,7 @@ And now, we can use `__init__` to declare the parameters of the instance that we In this case, **FastAPI** won't ever touch or care about `__init__`, we will use it directly in our code. -## Create an instance +## Create an instance { #create-an-instance } We could create an instance of this class with: @@ -38,7 +38,7 @@ We could create an instance of this class with: And that way we are able to "parameterize" our dependency, that now has `"bar"` inside of it, as the attribute `checker.fixed_content`. -## Use the instance as a dependency +## Use the instance as a dependency { #use-the-instance-as-a-dependency } Then, we could use this `checker` in a `Depends(checker)`, instead of `Depends(FixedContentQueryChecker)`, because the dependency is the instance, `checker`, not the class itself. diff --git a/docs/en/docs/advanced/async-tests.md b/docs/en/docs/advanced/async-tests.md index 8d6929222..7b6f08371 100644 --- a/docs/en/docs/advanced/async-tests.md +++ b/docs/en/docs/advanced/async-tests.md @@ -1,4 +1,4 @@ -# Async Tests +# Async Tests { #async-tests } You have already seen how to test your **FastAPI** applications using the provided `TestClient`. Up to now, you have only seen how to write synchronous tests, without using `async` functions. @@ -6,11 +6,11 @@ Being able to use asynchronous functions in your tests could be useful, for exam Let's look at how we can make that work. -## pytest.mark.anyio +## pytest.mark.anyio { #pytest-mark-anyio } If we want to call asynchronous functions in our tests, our test functions have to be asynchronous. AnyIO provides a neat plugin for this, that allows us to specify that some test functions are to be called asynchronously. -## HTTPX +## HTTPX { #httpx } Even if your **FastAPI** application uses normal `def` functions instead of `async def`, it is still an `async` application underneath. @@ -18,7 +18,7 @@ The `TestClient` does some magic inside to call the asynchronous FastAPI applica The `TestClient` is based on HTTPX, and luckily, we can use it directly to test the API. -## Example +## Example { #example } For a simple example, let's consider a file structure similar to the one described in [Bigger Applications](../tutorial/bigger-applications.md){.internal-link target=_blank} and [Testing](../tutorial/testing.md){.internal-link target=_blank}: @@ -38,7 +38,7 @@ The file `test_main.py` would have the tests for `main.py`, it could look like t {* ../../docs_src/async_tests/test_main.py *} -## Run it +## Run it { #run-it } You can run your tests as usual via: @@ -52,7 +52,7 @@ $ pytest -## In Detail +## In Detail { #in-detail } The marker `@pytest.mark.anyio` tells pytest that this test function should be called asynchronously: @@ -88,7 +88,7 @@ If your application relies on lifespan events, the `AsyncClient` won't trigger t /// -## Other Asynchronous Function Calls +## Other Asynchronous Function Calls { #other-asynchronous-function-calls } As the testing function is now asynchronous, you can now also call (and `await`) other `async` functions apart from sending requests to your FastAPI application in your tests, exactly as you would call them anywhere else in your code. diff --git a/docs/en/docs/advanced/behind-a-proxy.md b/docs/en/docs/advanced/behind-a-proxy.md index 1f0d0fd9f..0f100306a 100644 --- a/docs/en/docs/advanced/behind-a-proxy.md +++ b/docs/en/docs/advanced/behind-a-proxy.md @@ -1,4 +1,4 @@ -# Behind a Proxy +# Behind a Proxy { #behind-a-proxy } In some situations, you might need to use a **proxy** server like Traefik or Nginx with a configuration that adds an extra path prefix that is not seen by your application. @@ -10,7 +10,7 @@ The `root_path` is used to handle these specific cases. And it's also used internally when mounting sub-applications. -## Proxy with a stripped path prefix +## Proxy with a stripped path prefix { #proxy-with-a-stripped-path-prefix } Having a proxy with a stripped path prefix, in this case, means that you could declare a path at `/app` in your code, but then, you add a layer on top (the proxy) that would put your **FastAPI** application under a path like `/api/v1`. @@ -66,7 +66,7 @@ The docs UI would also need the OpenAPI schema to declare that this API `server` In this example, the "Proxy" could be something like **Traefik**. And the server would be something like FastAPI CLI with **Uvicorn**, running your FastAPI application. -### Providing the `root_path` +### Providing the `root_path` { #providing-the-root-path } To achieve this, you can use the command line option `--root-path` like: @@ -90,7 +90,7 @@ And the `--root-path` command line option provides that `root_path`. /// -### Checking the current `root_path` +### Checking the current `root_path` { #checking-the-current-root-path } You can get the current `root_path` used by your application for each request, it is part of the `scope` dictionary (that's part of the ASGI spec). @@ -119,7 +119,7 @@ The response would be something like: } ``` -### Setting the `root_path` in the FastAPI app +### Setting the `root_path` in the FastAPI app { #setting-the-root-path-in-the-fastapi-app } Alternatively, if you don't have a way to provide a command line option like `--root-path` or equivalent, you can set the `root_path` parameter when creating your FastAPI app: @@ -127,7 +127,7 @@ Alternatively, if you don't have a way to provide a command line option like `-- Passing the `root_path` to `FastAPI` would be the equivalent of passing the `--root-path` command line option to Uvicorn or Hypercorn. -### About `root_path` +### About `root_path` { #about-root-path } Keep in mind that the server (Uvicorn) won't use that `root_path` for anything else than passing it to the app. @@ -144,7 +144,7 @@ So, it won't expect to be accessed at `http://127.0.0.1:8000/api/v1/app`. Uvicorn will expect the proxy to access Uvicorn at `http://127.0.0.1:8000/app`, and then it would be the proxy's responsibility to add the extra `/api/v1` prefix on top. -## About proxies with a stripped path prefix +## About proxies with a stripped path prefix { #about-proxies-with-a-stripped-path-prefix } Keep in mind that a proxy with stripped path prefix is only one of the ways to configure it. @@ -152,7 +152,7 @@ Probably in many cases the default will be that the proxy doesn't have a strippe In a case like that (without a stripped path prefix), the proxy would listen on something like `https://myawesomeapp.com`, and then if the browser goes to `https://myawesomeapp.com/api/v1/app` and your server (e.g. Uvicorn) listens on `http://127.0.0.1:8000` the proxy (without a stripped path prefix) would access Uvicorn at the same path: `http://127.0.0.1:8000/api/v1/app`. -## Testing locally with Traefik +## Testing locally with Traefik { #testing-locally-with-traefik } You can easily run the experiment locally with a stripped path prefix using Traefik. @@ -231,7 +231,7 @@ $ fastapi run main.py --root-path /api/v1 -### Check the responses +### Check the responses { #check-the-responses } Now, if you go to the URL with the port for Uvicorn: http://127.0.0.1:8000/app, you will see the normal response: @@ -267,7 +267,7 @@ And the version without the path prefix (`http://127.0.0.1:8000/app`), provided That demonstrates how the Proxy (Traefik) uses the path prefix and how the server (Uvicorn) uses the `root_path` from the option `--root-path`. -### Check the docs UI +### Check the docs UI { #check-the-docs-ui } But here's the fun part. ✨ @@ -287,7 +287,7 @@ Right as we wanted it. ✔️ This is because FastAPI uses this `root_path` to create the default `server` in OpenAPI with the URL provided by `root_path`. -## Additional servers +## Additional servers { #additional-servers } /// warning @@ -346,7 +346,7 @@ The docs UI will interact with the server that you select. /// -### Disable automatic server from `root_path` +### Disable automatic server from `root_path` { #disable-automatic-server-from-root-path } If you don't want **FastAPI** to include an automatic server using the `root_path`, you can use the parameter `root_path_in_servers=False`: @@ -354,7 +354,7 @@ If you don't want **FastAPI** to include an automatic server using the `root_pat and then it won't include it in the OpenAPI schema. -## Mounting a sub-application +## Mounting a sub-application { #mounting-a-sub-application } If you need to mount a sub-application (as described in [Sub Applications - Mounts](sub-applications.md){.internal-link target=_blank}) while also using a proxy with `root_path`, you can do it normally, as you would expect. diff --git a/docs/en/docs/advanced/custom-response.md b/docs/en/docs/advanced/custom-response.md index 8268dd81a..5473d939c 100644 --- a/docs/en/docs/advanced/custom-response.md +++ b/docs/en/docs/advanced/custom-response.md @@ -1,4 +1,4 @@ -# Custom Response - HTML, Stream, File, others +# Custom Response - HTML, Stream, File, others { #custom-response-html-stream-file-others } By default, **FastAPI** will return the responses using `JSONResponse`. @@ -18,7 +18,7 @@ If you use a response class with no media type, FastAPI will expect your respons /// -## Use `ORJSONResponse` +## Use `ORJSONResponse` { #use-orjsonresponse } For example, if you are squeezing performance, you can install and use `orjson` and set the response to be `ORJSONResponse`. @@ -48,7 +48,7 @@ The `ORJSONResponse` is only available in FastAPI, not in Starlette. /// -## HTML Response +## HTML Response { #html-response } To return a response with HTML directly from **FastAPI**, use `HTMLResponse`. @@ -67,7 +67,7 @@ And it will be documented as such in OpenAPI. /// -### Return a `Response` +### Return a `Response` { #return-a-response } As seen in [Return a Response directly](response-directly.md){.internal-link target=_blank}, you can also override the response directly in your *path operation*, by returning it. @@ -87,13 +87,13 @@ Of course, the actual `Content-Type` header, status code, etc, will come from th /// -### Document in OpenAPI and override `Response` +### Document in OpenAPI and override `Response` { #document-in-openapi-and-override-response } If you want to override the response from inside of the function but at the same time document the "media type" in OpenAPI, you can use the `response_class` parameter AND return a `Response` object. The `response_class` will then be used only to document the OpenAPI *path operation*, but your `Response` will be used as is. -#### Return an `HTMLResponse` directly +#### Return an `HTMLResponse` directly { #return-an-htmlresponse-directly } For example, it could be something like: @@ -107,7 +107,7 @@ But as you passed the `HTMLResponse` in the `response_class` too, **FastAPI** wi -## Available responses +## Available responses { #available-responses } Here are some of the available responses. @@ -121,7 +121,7 @@ You could also use `from starlette.responses import HTMLResponse`. /// -### `Response` +### `Response` { #response } The main `Response` class, all the other responses inherit from it. @@ -138,23 +138,23 @@ FastAPI (actually Starlette) will automatically include a Content-Length header. {* ../../docs_src/response_directly/tutorial002.py hl[1,18] *} -### `HTMLResponse` +### `HTMLResponse` { #htmlresponse } Takes some text or bytes and returns an HTML response, as you read above. -### `PlainTextResponse` +### `PlainTextResponse` { #plaintextresponse } Takes some text or bytes and returns a plain text response. {* ../../docs_src/custom_response/tutorial005.py hl[2,7,9] *} -### `JSONResponse` +### `JSONResponse` { #jsonresponse } Takes some data and returns an `application/json` encoded response. This is the default response used in **FastAPI**, as you read above. -### `ORJSONResponse` +### `ORJSONResponse` { #orjsonresponse } A fast alternative JSON response using `orjson`, as you read above. @@ -164,7 +164,7 @@ This requires installing `orjson` for example with `pip install orjson`. /// -### `UJSONResponse` +### `UJSONResponse` { #ujsonresponse } An alternative JSON response using `ujson`. @@ -188,7 +188,7 @@ It's possible that `ORJSONResponse` might be a faster alternative. /// -### `RedirectResponse` +### `RedirectResponse` { #redirectresponse } Returns an HTTP redirect. Uses a 307 status code (Temporary Redirect) by default. @@ -213,13 +213,13 @@ You can also use the `status_code` parameter combined with the `response_class` {* ../../docs_src/custom_response/tutorial006c.py hl[2,7,9] *} -### `StreamingResponse` +### `StreamingResponse` { #streamingresponse } Takes an async generator or a normal generator/iterator and streams the response body. {* ../../docs_src/custom_response/tutorial007.py hl[2,14] *} -#### Using `StreamingResponse` with file-like objects +#### Using `StreamingResponse` with file-like objects { #using-streamingresponse-with-file-like-objects } If you have a file-like object (e.g. the object returned by `open()`), you can create a generator function to iterate over that file-like object. @@ -243,7 +243,7 @@ Notice that here as we are using standard `open()` that doesn't support `async` /// -### `FileResponse` +### `FileResponse` { #fileresponse } Asynchronously streams a file as the response. @@ -264,7 +264,7 @@ You can also use the `response_class` parameter: In this case, you can return the file path directly from your *path operation* function. -## Custom response class +## Custom response class { #custom-response-class } You can create your own custom response class, inheriting from `Response` and using it. @@ -292,7 +292,7 @@ Now instead of returning: Of course, you will probably find much better ways to take advantage of this than formatting JSON. 😉 -## Default response class +## Default response class { #default-response-class } When creating a **FastAPI** class instance or an `APIRouter` you can specify which response class to use by default. @@ -308,6 +308,6 @@ You can still override `response_class` in *path operations* as before. /// -## Additional documentation +## Additional documentation { #additional-documentation } You can also declare the media type and many other details in OpenAPI using `responses`: [Additional Responses in OpenAPI](additional-responses.md){.internal-link target=_blank}. diff --git a/docs/en/docs/advanced/dataclasses.md b/docs/en/docs/advanced/dataclasses.md index 2936c6d5d..b7b9b65c5 100644 --- a/docs/en/docs/advanced/dataclasses.md +++ b/docs/en/docs/advanced/dataclasses.md @@ -1,4 +1,4 @@ -# Using Dataclasses +# Using Dataclasses { #using-dataclasses } FastAPI is built on top of **Pydantic**, and I have been showing you how to use Pydantic models to declare requests and responses. @@ -28,7 +28,7 @@ But if you have a bunch of dataclasses laying around, this is a nice trick to us /// -## Dataclasses in `response_model` +## Dataclasses in `response_model` { #dataclasses-in-response-model } You can also use `dataclasses` in the `response_model` parameter: @@ -40,7 +40,7 @@ This way, its schema will show up in the API docs user interface: -## Dataclasses in Nested Data Structures +## Dataclasses in Nested Data Structures { #dataclasses-in-nested-data-structures } You can also combine `dataclasses` with other type annotations to make nested data structures. @@ -84,12 +84,12 @@ You can combine `dataclasses` with other type annotations in many different comb Check the in-code annotation tips above to see more specific details. -## Learn More +## Learn More { #learn-more } You can also combine `dataclasses` with other Pydantic models, inherit from them, include them in your own models, etc. To learn more, check the Pydantic docs about dataclasses. -## Version +## Version { #version } This is available since FastAPI version `0.67.0`. 🔖 diff --git a/docs/en/docs/advanced/events.md b/docs/en/docs/advanced/events.md index 19465d891..c805e81ee 100644 --- a/docs/en/docs/advanced/events.md +++ b/docs/en/docs/advanced/events.md @@ -1,4 +1,4 @@ -# Lifespan Events +# Lifespan Events { #lifespan-events } You can define logic (code) that should be executed before the application **starts up**. This means that this code will be executed **once**, **before** the application **starts receiving requests**. @@ -8,7 +8,7 @@ Because this code is executed before the application **starts** taking requests, This can be very useful for setting up **resources** that you need to use for the whole app, and that are **shared** among requests, and/or that you need to **clean up** afterwards. For example, a database connection pool, or loading a shared machine learning model. -## Use Case +## Use Case { #use-case } Let's start with an example **use case** and then see how to solve it with this. @@ -22,7 +22,7 @@ You could load it at the top level of the module/file, but that would also mean That's what we'll solve, let's load the model before the requests are handled, but only right before the application starts receiving requests, not while the code is being loaded. -## Lifespan +## Lifespan { #lifespan } You can define this *startup* and *shutdown* logic using the `lifespan` parameter of the `FastAPI` app, and a "context manager" (I'll show you what that is in a second). @@ -44,7 +44,7 @@ Maybe you need to start a new version, or you just got tired of running it. 🤷 /// -### Lifespan function +### Lifespan function { #lifespan-function } The first thing to notice, is that we are defining an async function with `yield`. This is very similar to Dependencies with `yield`. @@ -54,7 +54,7 @@ The first part of the function, before the `yield`, will be executed **before** And the part after the `yield` will be executed **after** the application has finished. -### Async Context Manager +### Async Context Manager { #async-context-manager } If you check, the function is decorated with an `@asynccontextmanager`. @@ -84,7 +84,7 @@ The `lifespan` parameter of the `FastAPI` app takes an **async context manager** {* ../../docs_src/events/tutorial003.py hl[22] *} -## Alternative Events (deprecated) +## Alternative Events (deprecated) { #alternative-events-deprecated } /// warning @@ -100,7 +100,7 @@ You can define event handlers (functions) that need to be executed before the ap These functions can be declared with `async def` or normal `def`. -### `startup` event +### `startup` event { #startup-event } To add a function that should be run before the application starts, declare it with the event `"startup"`: @@ -112,7 +112,7 @@ You can add more than one event handler function. And your application won't start receiving requests until all the `startup` event handlers have completed. -### `shutdown` event +### `shutdown` event { #shutdown-event } To add a function that should be run when the application is shutting down, declare it with the event `"shutdown"`: @@ -138,7 +138,7 @@ So, we declare the event handler function with standard `def` instead of `async /// -### `startup` and `shutdown` together +### `startup` and `shutdown` together { #startup-and-shutdown-together } There's a high chance that the logic for your *startup* and *shutdown* is connected, you might want to start something and then finish it, acquire a resource and then release it, etc. @@ -146,7 +146,7 @@ Doing that in separated functions that don't share logic or variables together i Because of that, it's now recommended to instead use the `lifespan` as explained above. -## Technical Details +## Technical Details { #technical-details } Just a technical detail for the curious nerds. 🤓 @@ -160,6 +160,6 @@ Including how to handle lifespan state that can be used in other areas of your c /// -## Sub Applications +## Sub Applications { #sub-applications } 🚨 Keep in mind that these lifespan events (startup and shutdown) will only be executed for the main application, not for [Sub Applications - Mounts](sub-applications.md){.internal-link target=_blank}. diff --git a/docs/en/docs/advanced/generate-clients.md b/docs/en/docs/advanced/generate-clients.md index e8b2fefbd..897c30808 100644 --- a/docs/en/docs/advanced/generate-clients.md +++ b/docs/en/docs/advanced/generate-clients.md @@ -1,4 +1,4 @@ -# Generating SDKs +# Generating SDKs { #generating-sdks } Because **FastAPI** is based on the **OpenAPI** specification, its APIs can be described in a standard format that many tools understand. @@ -6,7 +6,7 @@ This makes it easy to generate up-to-date **documentation**, client libraries (< In this guide, you'll learn how to generate a **TypeScript SDK** for your FastAPI backend. -## Open Source SDK Generators +## Open Source SDK Generators { #open-source-sdk-generators } A versatile option is the OpenAPI Generator, which supports **many programming languages** and can generate SDKs from your OpenAPI specification. @@ -20,7 +20,7 @@ FastAPI automatically generates **OpenAPI 3.1** specifications, so any tool you /// -## SDK Generators from FastAPI Sponsors +## SDK Generators from FastAPI Sponsors { #sdk-generators-from-fastapi-sponsors } This section highlights **venture-backed** and **company-supported** solutions from companies that sponsor FastAPI. These products provide **additional features** and **integrations** on top of high-quality generated SDKs. @@ -36,7 +36,7 @@ For example, you might want to try: Some of these solutions may also be open source or offer free tiers, so you can try them without a financial commitment. Other commercial SDK generators are available and can be found online. 🤓 -## Create a TypeScript SDK +## Create a TypeScript SDK { #create-a-typescript-sdk } Let's start with a simple FastAPI application: @@ -44,7 +44,7 @@ Let's start with a simple FastAPI application: Notice that the *path operations* define the models they use for request payload and response payload, using the models `Item` and `ResponseMessage`. -### API Docs +### API Docs { #api-docs } If you go to `/docs`, you will see that it has the **schemas** for the data to be sent in requests and received in responses: @@ -56,7 +56,7 @@ That information is available in the app's **OpenAPI schema**, and then shown in That same information from the models that is included in OpenAPI is what can be used to **generate the client code**. -### Hey API +### Hey API { #hey-api } Once we have a FastAPI app with the models, we can use Hey API to generate a TypeScript client. The fastest way to do that is via npx. @@ -68,7 +68,7 @@ This will generate a TypeScript SDK in `./src/client`. You can learn how to install `@hey-api/openapi-ts` and read about the generated output on their website. -### Using the SDK +### Using the SDK { #using-the-sdk } Now you can import and use the client code. It could look like this, notice that you get autocompletion for the methods: @@ -92,7 +92,7 @@ The response object will also have autocompletion: -## FastAPI App with Tags +## FastAPI App with Tags { #fastapi-app-with-tags } In many cases, your FastAPI app will be bigger, and you will probably use tags to separate different groups of *path operations*. @@ -100,7 +100,7 @@ For example, you could have a section for **items** and another section for **us {* ../../docs_src/generate_clients/tutorial002_py39.py hl[21,26,34] *} -### Generate a TypeScript Client with Tags +### Generate a TypeScript Client with Tags { #generate-a-typescript-client-with-tags } If you generate a client for a FastAPI app using tags, it will normally also separate the client code based on the tags. @@ -113,7 +113,7 @@ In this case, you have: * `ItemsService` * `UsersService` -### Client Method Names +### Client Method Names { #client-method-names } Right now, the generated method names like `createItemItemsPost` don't look very clean: @@ -127,7 +127,7 @@ OpenAPI requires that each operation ID is unique across all the *path operation But I'll show you how to improve that next. 🤓 -## Custom Operation IDs and Better Method Names +## Custom Operation IDs and Better Method Names { #custom-operation-ids-and-better-method-names } You can **modify** the way these operation IDs are **generated** to make them simpler and have **simpler method names** in the clients. @@ -135,7 +135,7 @@ In this case, you will have to ensure that each operation ID is **unique** in so For example, you could make sure that each *path operation* has a tag, and then generate the operation ID based on the **tag** and the *path operation* **name** (the function name). -### Custom Generate Unique ID Function +### Custom Generate Unique ID Function { #custom-generate-unique-id-function } FastAPI uses a **unique ID** for each *path operation*, which is used for the **operation ID** and also for the names of any needed custom models, for requests or responses. @@ -147,7 +147,7 @@ You can then pass that custom function to **FastAPI** as the `generate_unique_id {* ../../docs_src/generate_clients/tutorial003_py39.py hl[6:7,10] *} -### Generate a TypeScript Client with Custom Operation IDs +### Generate a TypeScript Client with Custom Operation IDs { #generate-a-typescript-client-with-custom-operation-ids } Now, if you generate the client again, you will see that it has the improved method names: @@ -155,7 +155,7 @@ Now, if you generate the client again, you will see that it has the improved met As you see, the method names now have the tag and then the function name, now they don't include information from the URL path and the HTTP operation. -### Preprocess the OpenAPI Specification for the Client Generator +### Preprocess the OpenAPI Specification for the Client Generator { #preprocess-the-openapi-specification-for-the-client-generator } The generated code still has some **duplicated information**. @@ -179,7 +179,7 @@ We could download the OpenAPI JSON to a file `openapi.json` and then we could ** With that, the operation IDs would be renamed from things like `items-get_items` to just `get_items`, that way the client generator can generate simpler method names. -### Generate a TypeScript Client with the Preprocessed OpenAPI +### Generate a TypeScript Client with the Preprocessed OpenAPI { #generate-a-typescript-client-with-the-preprocessed-openapi } Since the end result is now in an `openapi.json` file, you need to update your input location: @@ -191,7 +191,7 @@ After generating the new client, you would now have **clean method names**, with -## Benefits +## Benefits { #benefits } When using the automatically generated clients, you would get **autocompletion** for: diff --git a/docs/en/docs/advanced/index.md b/docs/en/docs/advanced/index.md index 47385e2c6..9355516fb 100644 --- a/docs/en/docs/advanced/index.md +++ b/docs/en/docs/advanced/index.md @@ -1,6 +1,6 @@ -# Advanced User Guide +# Advanced User Guide { #advanced-user-guide } -## Additional Features +## Additional Features { #additional-features } The main [Tutorial - User Guide](../tutorial/index.md){.internal-link target=_blank} should be enough to give you a tour through all the main features of **FastAPI**. @@ -14,7 +14,7 @@ And it's possible that for your use case, the solution is in one of them. /// -## Read the Tutorial first +## Read the Tutorial first { #read-the-tutorial-first } You could still use most of the features in **FastAPI** with the knowledge from the main [Tutorial - User Guide](../tutorial/index.md){.internal-link target=_blank}. diff --git a/docs/en/docs/advanced/middleware.md b/docs/en/docs/advanced/middleware.md index 1d40b1c8f..4ca07676b 100644 --- a/docs/en/docs/advanced/middleware.md +++ b/docs/en/docs/advanced/middleware.md @@ -1,4 +1,4 @@ -# Advanced Middleware +# Advanced Middleware { #advanced-middleware } In the main tutorial you read how to add [Custom Middleware](../tutorial/middleware.md){.internal-link target=_blank} to your application. @@ -6,7 +6,7 @@ And then you also read how to handle [CORS with the `CORSMiddleware`](../tutoria In this section we'll see how to use other middlewares. -## Adding ASGI middlewares +## Adding ASGI middlewares { #adding-asgi-middlewares } As **FastAPI** is based on Starlette and implements the ASGI specification, you can use any ASGI middleware. @@ -39,7 +39,7 @@ app.add_middleware(UnicornMiddleware, some_config="rainbow") `app.add_middleware()` receives a middleware class as the first argument and any additional arguments to be passed to the middleware. -## Integrated middlewares +## Integrated middlewares { #integrated-middlewares } **FastAPI** includes several middlewares for common use cases, we'll see next how to use them. @@ -51,7 +51,7 @@ For the next examples, you could also use `from starlette.middleware.something i /// -## `HTTPSRedirectMiddleware` +## `HTTPSRedirectMiddleware` { #httpsredirectmiddleware } Enforces that all incoming requests must either be `https` or `wss`. @@ -59,7 +59,7 @@ Any incoming request to `http` or `ws` will be redirected to the secure scheme i {* ../../docs_src/advanced_middleware/tutorial001.py hl[2,6] *} -## `TrustedHostMiddleware` +## `TrustedHostMiddleware` { #trustedhostmiddleware } Enforces that all incoming requests have a correctly set `Host` header, in order to guard against HTTP Host Header attacks. @@ -71,7 +71,7 @@ The following arguments are supported: If an incoming request does not validate correctly then a `400` response will be sent. -## `GZipMiddleware` +## `GZipMiddleware` { #gzipmiddleware } Handles GZip responses for any request that includes `"gzip"` in the `Accept-Encoding` header. @@ -84,7 +84,7 @@ The following arguments are supported: * `minimum_size` - Do not GZip responses that are smaller than this minimum size in bytes. Defaults to `500`. * `compresslevel` - Used during GZip compression. It is an integer ranging from 1 to 9. Defaults to `9`. Lower value results in faster compression but larger file sizes, while higher value results in slower compression but smaller file sizes. -## Other middlewares +## Other middlewares { #other-middlewares } There are many other ASGI middlewares. diff --git a/docs/en/docs/advanced/openapi-callbacks.md b/docs/en/docs/advanced/openapi-callbacks.md index ca9065a89..059d893c2 100644 --- a/docs/en/docs/advanced/openapi-callbacks.md +++ b/docs/en/docs/advanced/openapi-callbacks.md @@ -1,4 +1,4 @@ -# OpenAPI Callbacks +# OpenAPI Callbacks { #openapi-callbacks } You could create an API with a *path operation* that could trigger a request to an *external API* created by someone else (probably the same developer that would be *using* your API). @@ -6,7 +6,7 @@ The process that happens when your API app calls the *external API* is named a " In this case, you could want to document how that external API *should* look like. What *path operation* it should have, what body it should expect, what response it should return, etc. -## An app with callbacks +## An app with callbacks { #an-app-with-callbacks } Let's see all this with an example. @@ -23,7 +23,7 @@ Then your API will (let's imagine): * Send a notification back to the API user (the external developer). * This will be done by sending a POST request (from *your API*) to some *external API* provided by that external developer (this is the "callback"). -## The normal **FastAPI** app +## The normal **FastAPI** app { #the-normal-fastapi-app } Let's first see how the normal API app would look like before adding the callback. @@ -41,7 +41,7 @@ The `callback_url` query parameter uses a Pydantic OpenAPI 3 expression (see more below) where it can use variables with parameters and parts of the original request sent to *your API*. -### The callback path expression +### The callback path expression { #the-callback-path-expression } The callback *path* can have an OpenAPI 3 expression that can contain parts of the original request sent to *your API*. @@ -163,7 +163,7 @@ Notice how the callback URL used contains the URL received as a query parameter /// -### Add the callback router +### Add the callback router { #add-the-callback-router } At this point you have the *callback path operation(s)* needed (the one(s) that the *external developer* should implement in the *external API*) in the callback router you created above. @@ -177,7 +177,7 @@ Notice that you are not passing the router itself (`invoices_callback_router`) t /// -### Check the docs +### Check the docs { #check-the-docs } Now you can start your app and go to http://127.0.0.1:8000/docs. diff --git a/docs/en/docs/advanced/openapi-webhooks.md b/docs/en/docs/advanced/openapi-webhooks.md index 97aaa41af..416cf4b75 100644 --- a/docs/en/docs/advanced/openapi-webhooks.md +++ b/docs/en/docs/advanced/openapi-webhooks.md @@ -1,4 +1,4 @@ -# OpenAPI Webhooks +# OpenAPI Webhooks { #openapi-webhooks } There are cases where you want to tell your API **users** that your app could call *their* app (sending a request) with some data, normally to **notify** of some type of **event**. @@ -6,7 +6,7 @@ This means that instead of the normal process of your users sending requests to This is normally called a **webhook**. -## Webhooks steps +## Webhooks steps { #webhooks-steps } The process normally is that **you define** in your code what is the message that you will send, the **body of the request**. @@ -16,7 +16,7 @@ And **your users** define in some way (for example in a web dashboard somewhere) All the **logic** about how to register the URLs for webhooks and the code to actually send those requests is up to you. You write it however you want to in **your own code**. -## Documenting webhooks with **FastAPI** and OpenAPI +## Documenting webhooks with **FastAPI** and OpenAPI { #documenting-webhooks-with-fastapi-and-openapi } With **FastAPI**, using OpenAPI, you can define the names of these webhooks, the types of HTTP operations that your app can send (e.g. `POST`, `PUT`, etc.) and the request **bodies** that your app would send. @@ -28,7 +28,7 @@ Webhooks are available in OpenAPI 3.1.0 and above, supported by FastAPI `0.99.0` /// -## An app with webhooks +## An app with webhooks { #an-app-with-webhooks } When you create a **FastAPI** application, there is a `webhooks` attribute that you can use to define *webhooks*, the same way you would define *path operations*, for example with `@app.webhooks.post()`. @@ -46,7 +46,7 @@ Notice that with webhooks you are actually not declaring a *path* (like `/items/ This is because it is expected that **your users** would define the actual **URL path** where they want to receive the webhook request in some other way (e.g. a web dashboard). -### Check the docs +### Check the docs { #check-the-docs } Now you can start your app and go to http://127.0.0.1:8000/docs. diff --git a/docs/en/docs/advanced/path-operation-advanced-configuration.md b/docs/en/docs/advanced/path-operation-advanced-configuration.md index c4814ebd2..b9961f9f3 100644 --- a/docs/en/docs/advanced/path-operation-advanced-configuration.md +++ b/docs/en/docs/advanced/path-operation-advanced-configuration.md @@ -1,6 +1,6 @@ -# Path Operation Advanced Configuration +# Path Operation Advanced Configuration { #path-operation-advanced-configuration } -## OpenAPI operationId +## OpenAPI operationId { #openapi-operationid } /// warning @@ -14,7 +14,7 @@ You would have to make sure that it is unique for each operation. {* ../../docs_src/path_operation_advanced_configuration/tutorial001.py hl[6] *} -### Using the *path operation function* name as the operationId +### Using the *path operation function* name as the operationId { #using-the-path-operation-function-name-as-the-operationid } If you want to use your APIs' function names as `operationId`s, you can iterate over all of them and override each *path operation's* `operation_id` using their `APIRoute.name`. @@ -36,13 +36,13 @@ Even if they are in different modules (Python files). /// -## Exclude from OpenAPI +## Exclude from OpenAPI { #exclude-from-openapi } To exclude a *path operation* from the generated OpenAPI schema (and thus, from the automatic documentation systems), use the parameter `include_in_schema` and set it to `False`: {* ../../docs_src/path_operation_advanced_configuration/tutorial003.py hl[6] *} -## Advanced description from docstring +## Advanced description from docstring { #advanced-description-from-docstring } You can limit the lines used from the docstring of a *path operation function* for OpenAPI. @@ -52,7 +52,7 @@ It won't show up in the documentation, but other tools (such as Sphinx) will be {* ../../docs_src/path_operation_advanced_configuration/tutorial004.py hl[19:29] *} -## Additional Responses +## Additional Responses { #additional-responses } You probably have seen how to declare the `response_model` and `status_code` for a *path operation*. @@ -62,7 +62,7 @@ You can also declare additional responses with their models, status codes, etc. There's a whole chapter here in the documentation about it, you can read it at [Additional Responses in OpenAPI](additional-responses.md){.internal-link target=_blank}. -## OpenAPI Extra +## OpenAPI Extra { #openapi-extra } When you declare a *path operation* in your application, **FastAPI** automatically generates the relevant metadata about that *path operation* to be included in the OpenAPI schema. @@ -88,7 +88,7 @@ If you only need to declare additional responses, a more convenient way to do it You can extend the OpenAPI schema for a *path operation* using the parameter `openapi_extra`. -### OpenAPI Extensions +### OpenAPI Extensions { #openapi-extensions } This `openapi_extra` can be helpful, for example, to declare [OpenAPI Extensions](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions): @@ -129,7 +129,7 @@ And if you see the resulting OpenAPI (at `/openapi.json` in your API), you will } ``` -### Custom OpenAPI *path operation* schema +### Custom OpenAPI *path operation* schema { #custom-openapi-path-operation-schema } The dictionary in `openapi_extra` will be deeply merged with the automatically generated OpenAPI schema for the *path operation*. @@ -145,7 +145,7 @@ In this example, we didn't declare any Pydantic model. In fact, the request body Nevertheless, we can declare the expected schema for the request body. -### Custom OpenAPI content type +### Custom OpenAPI content type { #custom-openapi-content-type } Using this same trick, you could use a Pydantic model to define the JSON Schema that is then included in the custom OpenAPI schema section for the *path operation*. diff --git a/docs/en/docs/advanced/response-change-status-code.md b/docs/en/docs/advanced/response-change-status-code.md index 6d3f9f3e8..912ed0f1a 100644 --- a/docs/en/docs/advanced/response-change-status-code.md +++ b/docs/en/docs/advanced/response-change-status-code.md @@ -1,10 +1,10 @@ -# Response - Change Status Code +# Response - Change Status Code { #response-change-status-code } You probably read before that you can set a default [Response Status Code](../tutorial/response-status-code.md){.internal-link target=_blank}. But in some cases you need to return a different status code than the default. -## Use case +## Use case { #use-case } For example, imagine that you want to return an HTTP status code of "OK" `200` by default. @@ -14,7 +14,7 @@ But you still want to be able to filter and convert the data you return with a ` For those cases, you can use a `Response` parameter. -## Use a `Response` parameter +## Use a `Response` parameter { #use-a-response-parameter } You can declare a parameter of type `Response` in your *path operation function* (as you can do for cookies and headers). diff --git a/docs/en/docs/advanced/response-cookies.md b/docs/en/docs/advanced/response-cookies.md index f6d17f35d..d8f77b56a 100644 --- a/docs/en/docs/advanced/response-cookies.md +++ b/docs/en/docs/advanced/response-cookies.md @@ -1,6 +1,6 @@ -# Response Cookies +# Response Cookies { #response-cookies } -## Use a `Response` parameter +## Use a `Response` parameter { #use-a-response-parameter } You can declare a parameter of type `Response` in your *path operation function*. @@ -16,7 +16,7 @@ And if you declared a `response_model`, it will still be used to filter and conv You can also declare the `Response` parameter in dependencies, and set cookies (and headers) in them. -## Return a `Response` directly +## Return a `Response` directly { #return-a-response-directly } You can also create cookies when returning a `Response` directly in your code. @@ -36,7 +36,7 @@ And also that you are not sending any data that should have been filtered by a ` /// -### More info +### More info { #more-info } /// note | Technical Details diff --git a/docs/en/docs/advanced/response-directly.md b/docs/en/docs/advanced/response-directly.md index 759b762b5..3197e1bd4 100644 --- a/docs/en/docs/advanced/response-directly.md +++ b/docs/en/docs/advanced/response-directly.md @@ -1,4 +1,4 @@ -# Return a Response Directly +# Return a Response Directly { #return-a-response-directly } When you create a **FastAPI** *path operation* you can normally return any data from it: a `dict`, a `list`, a Pydantic model, a database model, etc. @@ -10,7 +10,7 @@ But you can return a `JSONResponse` directly from your *path operations*. It might be useful, for example, to return custom headers or cookies. -## Return a `Response` +## Return a `Response` { #return-a-response } In fact, you can return any `Response` or any sub-class of it. @@ -26,7 +26,7 @@ It won't do any data conversion with Pydantic models, it won't convert the conte This gives you a lot of flexibility. You can return any data type, override any data declaration or validation, etc. -## Using the `jsonable_encoder` in a `Response` +## Using the `jsonable_encoder` in a `Response` { #using-the-jsonable-encoder-in-a-response } Because **FastAPI** doesn't make any changes to a `Response` you return, you have to make sure its contents are ready for it. @@ -44,7 +44,7 @@ You could also use `from starlette.responses import JSONResponse`. /// -## Returning a custom `Response` +## Returning a custom `Response` { #returning-a-custom-response } The example above shows all the parts you need, but it's not very useful yet, as you could have just returned the `item` directly, and **FastAPI** would put it in a `JSONResponse` for you, converting it to a `dict`, etc. All that by default. @@ -56,7 +56,7 @@ You could put your XML content in a string, put that in a `Response`, and return {* ../../docs_src/response_directly/tutorial002.py hl[1,18] *} -## Notes +## Notes { #notes } When you return a `Response` directly its data is not validated, converted (serialized), or documented automatically. diff --git a/docs/en/docs/advanced/response-headers.md b/docs/en/docs/advanced/response-headers.md index 97e888983..98747eabd 100644 --- a/docs/en/docs/advanced/response-headers.md +++ b/docs/en/docs/advanced/response-headers.md @@ -1,6 +1,6 @@ -# Response Headers +# Response Headers { #response-headers } -## Use a `Response` parameter +## Use a `Response` parameter { #use-a-response-parameter } You can declare a parameter of type `Response` in your *path operation function* (as you can do for cookies). @@ -16,7 +16,7 @@ And if you declared a `response_model`, it will still be used to filter and conv You can also declare the `Response` parameter in dependencies, and set headers (and cookies) in them. -## Return a `Response` directly +## Return a `Response` directly { #return-a-response-directly } You can also add headers when you return a `Response` directly. @@ -34,7 +34,7 @@ And as the `Response` can be used frequently to set headers and cookies, **FastA /// -## Custom Headers +## Custom Headers { #custom-headers } Keep in mind that custom proprietary headers can be added using the 'X-' prefix. diff --git a/docs/en/docs/advanced/security/http-basic-auth.md b/docs/en/docs/advanced/security/http-basic-auth.md index 234e2f940..01b98eeff 100644 --- a/docs/en/docs/advanced/security/http-basic-auth.md +++ b/docs/en/docs/advanced/security/http-basic-auth.md @@ -1,4 +1,4 @@ -# HTTP Basic Auth +# HTTP Basic Auth { #http-basic-auth } For the simplest cases, you can use HTTP Basic Auth. @@ -12,7 +12,7 @@ That tells the browser to show the integrated prompt for a username and password Then, when you type that username and password, the browser sends them in the header automatically. -## Simple HTTP Basic Auth +## Simple HTTP Basic Auth { #simple-http-basic-auth } * Import `HTTPBasic` and `HTTPBasicCredentials`. * Create a "`security` scheme" using `HTTPBasic`. @@ -26,7 +26,7 @@ When you try to open the URL for the first time (or click the "Execute" button i -## Check the username +## Check the username { #check-the-username } Here's a more complete example. @@ -52,7 +52,7 @@ if not (credentials.username == "stanleyjobson") or not (credentials.password == But by using the `secrets.compare_digest()` it will be secure against a type of attacks called "timing attacks". -### Timing Attacks +### Timing Attacks { #timing-attacks } But what's a "timing attack"? @@ -80,19 +80,19 @@ if "stanleyjobsox" == "stanleyjobson" and "love123" == "swordfish": Python will have to compare the whole `stanleyjobso` in both `stanleyjobsox` and `stanleyjobson` before realizing that both strings are not the same. So it will take some extra microseconds to reply back "Incorrect username or password". -#### The time to answer helps the attackers +#### The time to answer helps the attackers { #the-time-to-answer-helps-the-attackers } At that point, by noticing that the server took some microseconds longer to send the "Incorrect username or password" response, the attackers will know that they got _something_ right, some of the initial letters were right. And then they can try again knowing that it's probably something more similar to `stanleyjobsox` than to `johndoe`. -#### A "professional" attack +#### A "professional" attack { #a-professional-attack } Of course, the attackers would not try all this by hand, they would write a program to do it, possibly with thousands or millions of tests per second. And they would get just one extra correct letter at a time. But doing that, in some minutes or hours the attackers would have guessed the correct username and password, with the "help" of our application, just using the time taken to answer. -#### Fix it with `secrets.compare_digest()` +#### Fix it with `secrets.compare_digest()` { #fix-it-with-secrets-compare-digest } But in our code we are actually using `secrets.compare_digest()`. @@ -100,7 +100,7 @@ In short, it will take the same time to compare `stanleyjobsox` to `stanleyjobso That way, using `secrets.compare_digest()` in your application code, it will be safe against this whole range of security attacks. -### Return the error +### Return the error { #return-the-error } After detecting that the credentials are incorrect, return an `HTTPException` with a status code 401 (the same returned when no credentials are provided) and add the header `WWW-Authenticate` to make the browser show the login prompt again: diff --git a/docs/en/docs/advanced/security/index.md b/docs/en/docs/advanced/security/index.md index edb42132e..996d716b4 100644 --- a/docs/en/docs/advanced/security/index.md +++ b/docs/en/docs/advanced/security/index.md @@ -1,6 +1,6 @@ -# Advanced Security +# Advanced Security { #advanced-security } -## Additional Features +## Additional Features { #additional-features } There are some extra features to handle security apart from the ones covered in the [Tutorial - User Guide: Security](../../tutorial/security/index.md){.internal-link target=_blank}. @@ -12,7 +12,7 @@ And it's possible that for your use case, the solution is in one of them. /// -## Read the Tutorial first +## Read the Tutorial first { #read-the-tutorial-first } The next sections assume you already read the main [Tutorial - User Guide: Security](../../tutorial/security/index.md){.internal-link target=_blank}. diff --git a/docs/en/docs/advanced/security/oauth2-scopes.md b/docs/en/docs/advanced/security/oauth2-scopes.md index 4cb0b39bc..0a84435e6 100644 --- a/docs/en/docs/advanced/security/oauth2-scopes.md +++ b/docs/en/docs/advanced/security/oauth2-scopes.md @@ -1,4 +1,4 @@ -# OAuth2 scopes +# OAuth2 scopes { #oauth2-scopes } You can use OAuth2 scopes directly with **FastAPI**, they are integrated to work seamlessly. @@ -26,7 +26,7 @@ But if you know you need it, or you are curious, keep reading. /// -## OAuth2 scopes and OpenAPI +## OAuth2 scopes and OpenAPI { #oauth2-scopes-and-openapi } The OAuth2 specification defines "scopes" as a list of strings separated by spaces. @@ -58,7 +58,7 @@ For OAuth2 they are just strings. /// -## Global view +## Global view { #global-view } First, let's quickly see the parts that change from the examples in the main **Tutorial - User Guide** for [OAuth2 with Password (and hashing), Bearer with JWT tokens](../../tutorial/security/oauth2-jwt.md){.internal-link target=_blank}. Now using OAuth2 scopes: @@ -66,7 +66,7 @@ First, let's quickly see the parts that change from the examples in the main **T Now let's review those changes step by step. -## OAuth2 Security scheme +## OAuth2 Security scheme { #oauth2-security-scheme } The first change is that now we are declaring the OAuth2 security scheme with two available scopes, `me` and `items`. @@ -82,7 +82,7 @@ This is the same mechanism used when you give permissions while logging in with -## JWT token with scopes +## JWT token with scopes { #jwt-token-with-scopes } Now, modify the token *path operation* to return the scopes requested. @@ -100,7 +100,7 @@ But in your application, for security, you should make sure you only add the sco {* ../../docs_src/security/tutorial005_an_py310.py hl[156] *} -## Declare scopes in *path operations* and dependencies +## Declare scopes in *path operations* and dependencies { #declare-scopes-in-path-operations-and-dependencies } Now we declare that the *path operation* for `/users/me/items/` requires the scope `items`. @@ -136,7 +136,7 @@ But when you import `Query`, `Path`, `Depends`, `Security` and others from `fast /// -## Use `SecurityScopes` +## Use `SecurityScopes` { #use-securityscopes } Now update the dependency `get_current_user`. @@ -152,7 +152,7 @@ This `SecurityScopes` class is similar to `Request` (`Request` was used to get t {* ../../docs_src/security/tutorial005_an_py310.py hl[9,106] *} -## Use the `scopes` +## Use the `scopes` { #use-the-scopes } The parameter `security_scopes` will be of type `SecurityScopes`. @@ -166,7 +166,7 @@ In this exception, we include the scopes required (if any) as a string separated {* ../../docs_src/security/tutorial005_an_py310.py hl[106,108:116] *} -## Verify the `username` and data shape +## Verify the `username` and data shape { #verify-the-username-and-data-shape } We verify that we get a `username`, and extract the scopes. @@ -182,7 +182,7 @@ We also verify that we have a user with that username, and if not, we raise that {* ../../docs_src/security/tutorial005_an_py310.py hl[47,117:128] *} -## Verify the `scopes` +## Verify the `scopes` { #verify-the-scopes } We now verify that all the scopes required, by this dependency and all the dependants (including *path operations*), are included in the scopes provided in the token received, otherwise raise an `HTTPException`. @@ -190,7 +190,7 @@ For this, we use `security_scopes.scopes`, that contains a `list` with all these {* ../../docs_src/security/tutorial005_an_py310.py hl[129:135] *} -## Dependency tree and scopes +## Dependency tree and scopes { #dependency-tree-and-scopes } Let's review again this dependency tree and the scopes. @@ -223,7 +223,7 @@ All depending on the `scopes` declared in each *path operation* and each depende /// -## More details about `SecurityScopes` +## More details about `SecurityScopes` { #more-details-about-securityscopes } You can use `SecurityScopes` at any point, and in multiple places, it doesn't have to be at the "root" dependency. @@ -233,7 +233,7 @@ Because the `SecurityScopes` will have all the scopes declared by dependants, yo They will be checked independently for each *path operation*. -## Check it +## Check it { #check-it } If you open the API docs, you can authenticate and specify which scopes you want to authorize. @@ -245,7 +245,7 @@ And if you select the scope `me` but not the scope `items`, you will be able to That's what would happen to a third party application that tried to access one of these *path operations* with a token provided by a user, depending on how many permissions the user gave the application. -## About third party integrations +## About third party integrations { #about-third-party-integrations } In this example we are using the OAuth2 "password" flow. @@ -269,6 +269,6 @@ But in the end, they are implementing the same OAuth2 standard. **FastAPI** includes utilities for all these OAuth2 authentication flows in `fastapi.security.oauth2`. -## `Security` in decorator `dependencies` +## `Security` in decorator `dependencies` { #security-in-decorator-dependencies } The same way you can define a `list` of `Depends` in the decorator's `dependencies` parameter (as explained in [Dependencies in path operation decorators](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}), you could also use `Security` with `scopes` there. diff --git a/docs/en/docs/advanced/settings.md b/docs/en/docs/advanced/settings.md index 1af19a045..a218c3d01 100644 --- a/docs/en/docs/advanced/settings.md +++ b/docs/en/docs/advanced/settings.md @@ -1,4 +1,4 @@ -# Settings and Environment Variables +# Settings and Environment Variables { #settings-and-environment-variables } In many cases your application could need some external settings or configurations, for example secret keys, database credentials, credentials for email services, etc. @@ -12,17 +12,17 @@ To understand environment variables you can read [Environment Variables](../envi /// -## Types and validation +## Types and validation { #types-and-validation } These environment variables can only handle text strings, as they are external to Python and have to be compatible with other programs and the rest of the system (and even with different operating systems, as Linux, Windows, macOS). That means that any value read in Python from an environment variable will be a `str`, and any conversion to a different type or any validation has to be done in code. -## Pydantic `Settings` +## Pydantic `Settings` { #pydantic-settings } Fortunately, Pydantic provides a great utility to handle these settings coming from environment variables with Pydantic: Settings management. -### Install `pydantic-settings` +### Install `pydantic-settings` { #install-pydantic-settings } First, make sure you create your [virtual environment](../virtual-environments.md){.internal-link target=_blank}, activate it, and then install the `pydantic-settings` package: @@ -52,7 +52,7 @@ In Pydantic v1 it came included with the main package. Now it is distributed as /// -### Create the `Settings` object +### Create the `Settings` object { #create-the-settings-object } Import `BaseSettings` from Pydantic and create a sub-class, very much like with a Pydantic model. @@ -88,13 +88,13 @@ Then, when you create an instance of that `Settings` class (in this case, in the Next it will convert and validate the data. So, when you use that `settings` object, you will have data of the types you declared (e.g. `items_per_user` will be an `int`). -### Use the `settings` +### Use the `settings` { #use-the-settings } Then you can use the new `settings` object in your application: {* ../../docs_src/settings/tutorial001.py hl[18:20] *} -### Run the server +### Run the server { #run-the-server } Next, you would run the server passing the configurations as environment variables, for example you could set an `ADMIN_EMAIL` and `APP_NAME` with: @@ -120,7 +120,7 @@ The `app_name` would be `"ChimichangApp"`. And the `items_per_user` would keep its default value of `50`. -## Settings in another module +## Settings in another module { #settings-in-another-module } You could put those settings in another module file as you saw in [Bigger Applications - Multiple Files](../tutorial/bigger-applications.md){.internal-link target=_blank}. @@ -138,13 +138,13 @@ You would also need a file `__init__.py` as you saw in [Bigger Applications - Mu /// -## Settings in a dependency +## Settings in a dependency { #settings-in-a-dependency } In some occasions it might be useful to provide the settings from a dependency, instead of having a global object with `settings` that is used everywhere. This could be especially useful during testing, as it's very easy to override a dependency with your own custom settings. -### The config file +### The config file { #the-config-file } Coming from the previous example, your `config.py` file could look like: @@ -152,7 +152,7 @@ Coming from the previous example, your `config.py` file could look like: Notice that now we don't create a default instance `settings = Settings()`. -### The main app file +### The main app file { #the-main-app-file } Now we create a dependency that returns a new `config.Settings()`. @@ -170,7 +170,7 @@ And then we can require it from the *path operation function* as a dependency an {* ../../docs_src/settings/app02_an_py39/main.py hl[17,19:21] *} -### Settings and testing +### Settings and testing { #settings-and-testing } Then it would be very easy to provide a different settings object during testing by creating a dependency override for `get_settings`: @@ -180,7 +180,7 @@ In the dependency override we set a new value for the `admin_email` when creatin Then we can test that it is used. -## Reading a `.env` file +## Reading a `.env` file { #reading-a-env-file } If you have many settings that possibly change a lot, maybe in different environments, it might be useful to put them on a file and then read them from it as if they were environment variables. @@ -202,7 +202,7 @@ For this to work, you need to `pip install python-dotenv`. /// -### The `.env` file +### The `.env` file { #the-env-file } You could have a `.env` file with: @@ -211,7 +211,7 @@ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" ``` -### Read settings from `.env` +### Read settings from `.env` { #read-settings-from-env } And then update your `config.py` with: @@ -247,7 +247,7 @@ In Pydantic version 1 the configuration was done in an internal class `Config`, Here we define the config `env_file` inside of your Pydantic `Settings` class, and set the value to the filename with the dotenv file we want to use. -### Creating the `Settings` only once with `lru_cache` +### Creating the `Settings` only once with `lru_cache` { #creating-the-settings-only-once-with-lru-cache } Reading a file from disk is normally a costly (slow) operation, so you probably want to do it only once and then reuse the same settings object, instead of reading it for each request. @@ -274,7 +274,7 @@ But as we are using the `@lru_cache` decorator on top, the `Settings` object wil Then for any subsequent call of `get_settings()` in the dependencies for the next requests, instead of executing the internal code of `get_settings()` and creating a new `Settings` object, it will return the same object that was returned on the first call, again and again. -#### `lru_cache` Technical Details +#### `lru_cache` Technical Details { #lru-cache-technical-details } `@lru_cache` modifies the function it decorates to return the same value that was returned the first time, instead of computing it again, executing the code of the function every time. @@ -337,7 +337,7 @@ That way, it behaves almost as if it was just a global variable. But as it uses `@lru_cache` is part of `functools` which is part of Python's standard library, you can read more about it in the Python docs for `@lru_cache`. -## Recap +## Recap { #recap } You can use Pydantic Settings to handle the settings or configurations for your application, with all the power of Pydantic models. diff --git a/docs/en/docs/advanced/sub-applications.md b/docs/en/docs/advanced/sub-applications.md index 48e329fc1..fbd0e1af3 100644 --- a/docs/en/docs/advanced/sub-applications.md +++ b/docs/en/docs/advanced/sub-applications.md @@ -1,18 +1,18 @@ -# Sub Applications - Mounts +# Sub Applications - Mounts { #sub-applications-mounts } If you need to have two independent FastAPI applications, with their own independent OpenAPI and their own docs UIs, you can have a main app and "mount" one (or more) sub-application(s). -## Mounting a **FastAPI** application +## Mounting a **FastAPI** application { #mounting-a-fastapi-application } "Mounting" means adding a completely "independent" application in a specific path, that then takes care of handling everything under that path, with the _path operations_ declared in that sub-application. -### Top-level application +### Top-level application { #top-level-application } First, create the main, top-level, **FastAPI** application, and its *path operations*: {* ../../docs_src/sub_applications/tutorial001.py hl[3, 6:8] *} -### Sub-application +### Sub-application { #sub-application } Then, create your sub-application, and its *path operations*. @@ -20,7 +20,7 @@ This sub-application is just another standard FastAPI application, but this is t {* ../../docs_src/sub_applications/tutorial001.py hl[11, 14:16] *} -### Mount the sub-application +### Mount the sub-application { #mount-the-sub-application } In your top-level application, `app`, mount the sub-application, `subapi`. @@ -28,7 +28,7 @@ In this case, it will be mounted at the path `/subapi`: {* ../../docs_src/sub_applications/tutorial001.py hl[11, 19] *} -### Check the automatic API docs +### Check the automatic API docs { #check-the-automatic-api-docs } Now, run the `fastapi` command with your file: @@ -56,7 +56,7 @@ You will see the automatic API docs for the sub-application, including only its If you try interacting with any of the two user interfaces, they will work correctly, because the browser will be able to talk to each specific app or sub-app. -### Technical Details: `root_path` +### Technical Details: `root_path` { #technical-details-root-path } When you mount a sub-application as described above, FastAPI will take care of communicating the mount path for the sub-application using a mechanism from the ASGI specification called a `root_path`. diff --git a/docs/en/docs/advanced/templates.md b/docs/en/docs/advanced/templates.md index d9b0ca6f1..f41c47fe8 100644 --- a/docs/en/docs/advanced/templates.md +++ b/docs/en/docs/advanced/templates.md @@ -1,4 +1,4 @@ -# Templates +# Templates { #templates } You can use any template engine you want with **FastAPI**. @@ -6,7 +6,7 @@ A common choice is Jinja2, the same one used by Flask and other tools. There are utilities to configure it easily that you can use directly in your **FastAPI** application (provided by Starlette). -## Install dependencies +## Install dependencies { #install-dependencies } Make sure you create a [virtual environment](../virtual-environments.md){.internal-link target=_blank}, activate it, and install `jinja2`: @@ -20,7 +20,7 @@ $ pip install jinja2 -## Using `Jinja2Templates` +## Using `Jinja2Templates` { #using-jinja2templates } * Import `Jinja2Templates`. * Create a `templates` object that you can reuse later. @@ -51,7 +51,7 @@ You could also use `from starlette.templating import Jinja2Templates`. /// -## Writing templates +## Writing templates { #writing-templates } Then you can write a template at `templates/item.html` with, for example: @@ -59,7 +59,7 @@ Then you can write a template at `templates/item.html` with, for example: {!../../docs_src/templates/templates/item.html!} ``` -### Template Context Values +### Template Context Values { #template-context-values } In the HTML that contains: @@ -83,7 +83,7 @@ For example, with an ID of `42`, this would render: Item ID: 42 ``` -### Template `url_for` Arguments +### Template `url_for` Arguments { #template-url-for-arguments } You can also use `url_for()` inside of the template, it takes as arguments the same arguments that would be used by your *path operation function*. @@ -105,7 +105,7 @@ For example, with an ID of `42`, this would render: ``` -## Templates and static files +## Templates and static files { #templates-and-static-files } You can also use `url_for()` inside of the template, and use it, for example, with the `StaticFiles` you mounted with the `name="static"`. @@ -121,6 +121,6 @@ In this example, it would link to a CSS file at `static/styles.css` with: And because you are using `StaticFiles`, that CSS file would be served automatically by your **FastAPI** application at the URL `/static/styles.css`. -## More details +## More details { #more-details } For more details, including how to test templates, check Starlette's docs on templates. diff --git a/docs/en/docs/advanced/testing-dependencies.md b/docs/en/docs/advanced/testing-dependencies.md index 17b4f9814..b52b47c96 100644 --- a/docs/en/docs/advanced/testing-dependencies.md +++ b/docs/en/docs/advanced/testing-dependencies.md @@ -1,6 +1,6 @@ -# Testing Dependencies with Overrides +# Testing Dependencies with Overrides { #testing-dependencies-with-overrides } -## Overriding dependencies during testing +## Overriding dependencies during testing { #overriding-dependencies-during-testing } There are some scenarios where you might want to override a dependency during testing. @@ -8,7 +8,7 @@ You don't want the original dependency to run (nor any of the sub-dependencies i Instead, you want to provide a different dependency that will be used only during tests (possibly only some specific tests), and will provide a value that can be used where the value of the original dependency was used. -### Use cases: external service +### Use cases: external service { #use-cases-external-service } An example could be that you have an external authentication provider that you need to call. @@ -20,7 +20,7 @@ You probably want to test the external provider once, but not necessarily call i In this case, you can override the dependency that calls that provider, and use a custom dependency that returns a mock user, only for your tests. -### Use the `app.dependency_overrides` attribute +### Use the `app.dependency_overrides` attribute { #use-the-app-dependency-overrides-attribute } For these cases, your **FastAPI** application has an attribute `app.dependency_overrides`, it is a simple `dict`. diff --git a/docs/en/docs/advanced/testing-events.md b/docs/en/docs/advanced/testing-events.md index 0c554c4ec..d0f2d1a79 100644 --- a/docs/en/docs/advanced/testing-events.md +++ b/docs/en/docs/advanced/testing-events.md @@ -1,4 +1,4 @@ -# Testing Events: startup - shutdown +# Testing Events: startup - shutdown { #testing-events-startup-shutdown } When you need your event handlers (`startup` and `shutdown`) to run in your tests, you can use the `TestClient` with a `with` statement: diff --git a/docs/en/docs/advanced/testing-websockets.md b/docs/en/docs/advanced/testing-websockets.md index 60dfdc343..22f9bb4a0 100644 --- a/docs/en/docs/advanced/testing-websockets.md +++ b/docs/en/docs/advanced/testing-websockets.md @@ -1,4 +1,4 @@ -# Testing WebSockets +# Testing WebSockets { #testing-websockets } You can use the same `TestClient` to test WebSockets. diff --git a/docs/en/docs/advanced/using-request-directly.md b/docs/en/docs/advanced/using-request-directly.md index 2f88c8f20..e412ad462 100644 --- a/docs/en/docs/advanced/using-request-directly.md +++ b/docs/en/docs/advanced/using-request-directly.md @@ -1,4 +1,4 @@ -# Using the Request Directly +# Using the Request Directly { #using-the-request-directly } Up to now, you have been declaring the parts of the request that you need with their types. @@ -13,7 +13,7 @@ And by doing so, **FastAPI** is validating that data, converting it and generati But there are situations where you might need to access the `Request` object directly. -## Details about the `Request` object +## Details about the `Request` object { #details-about-the-request-object } As **FastAPI** is actually **Starlette** underneath, with a layer of several tools on top, you can use Starlette's `Request` object directly when you need to. @@ -23,7 +23,7 @@ Although any other parameter declared normally (for example, the body with a Pyd But there are specific cases where it's useful to get the `Request` object. -## Use the `Request` object directly +## Use the `Request` object directly { #use-the-request-object-directly } Let's imagine you want to get the client's IP address/host inside of your *path operation function*. @@ -43,7 +43,7 @@ The same way, you can declare any other parameter as normally, and additionally, /// -## `Request` documentation +## `Request` documentation { #request-documentation } You can read more details about the `Request` object in the official Starlette documentation site. diff --git a/docs/en/docs/advanced/websockets.md b/docs/en/docs/advanced/websockets.md index ee8e901df..4ba24637f 100644 --- a/docs/en/docs/advanced/websockets.md +++ b/docs/en/docs/advanced/websockets.md @@ -1,8 +1,8 @@ -# WebSockets +# WebSockets { #websockets } You can use WebSockets with **FastAPI**. -## Install `WebSockets` +## Install `WebSockets` { #install-websockets } Make sure you create a [virtual environment](../virtual-environments.md){.internal-link target=_blank}, activate it, and install `websockets`: @@ -16,9 +16,9 @@ $ pip install websockets -## WebSockets client +## WebSockets client { #websockets-client } -### In production +### In production { #in-production } In your production system, you probably have a frontend created with a modern framework like React, Vue.js or Angular. @@ -40,7 +40,7 @@ But it's the simplest way to focus on the server-side of WebSockets and have a w {* ../../docs_src/websockets/tutorial001.py hl[2,6:38,41:43] *} -## Create a `websocket` +## Create a `websocket` { #create-a-websocket } In your **FastAPI** application, create a `websocket`: @@ -54,7 +54,7 @@ You could also use `from starlette.websockets import WebSocket`. /// -## Await for messages and send messages +## Await for messages and send messages { #await-for-messages-and-send-messages } In your WebSocket route you can `await` for messages and send messages. @@ -62,7 +62,7 @@ In your WebSocket route you can `await` for messages and send messages. You can receive and send binary, text, and JSON data. -## Try it +## Try it { #try-it } If your file is named `main.py`, run your application with: @@ -96,7 +96,7 @@ You can send (and receive) many messages: And all of them will use the same WebSocket connection. -## Using `Depends` and others +## Using `Depends` and others { #using-depends-and-others } In WebSocket endpoints you can import from `fastapi` and use: @@ -119,7 +119,7 @@ You can use a closing code from the -## Handling disconnections and multiple clients +## Handling disconnections and multiple clients { #handling-disconnections-and-multiple-clients } When a WebSocket connection is closed, the `await websocket.receive_text()` will raise a `WebSocketDisconnect` exception, which you can then catch and handle like in this example. @@ -178,7 +178,7 @@ If you need something easy to integrate with FastAPI but that is more robust, su /// -## More info +## More info { #more-info } To learn more about the options, check Starlette's documentation for: diff --git a/docs/en/docs/advanced/wsgi.md b/docs/en/docs/advanced/wsgi.md index 296eb1364..29fd2d359 100644 --- a/docs/en/docs/advanced/wsgi.md +++ b/docs/en/docs/advanced/wsgi.md @@ -1,10 +1,10 @@ -# Including WSGI - Flask, Django, others +# Including WSGI - Flask, Django, others { #including-wsgi-flask-django-others } You can mount WSGI applications as you saw with [Sub Applications - Mounts](sub-applications.md){.internal-link target=_blank}, [Behind a Proxy](behind-a-proxy.md){.internal-link target=_blank}. For that, you can use the `WSGIMiddleware` and use it to wrap your WSGI application, for example, Flask, Django, etc. -## Using `WSGIMiddleware` +## Using `WSGIMiddleware` { #using-wsgimiddleware } You need to import `WSGIMiddleware`. @@ -14,7 +14,7 @@ And then mount that under a path. {* ../../docs_src/wsgi/tutorial001.py hl[2:3,3] *} -## Check it +## Check it { #check-it } Now, every request under the path `/v1/` will be handled by the Flask application. diff --git a/docs/en/docs/alternatives.md b/docs/en/docs/alternatives.md index 326f0dbe1..f0576bc47 100644 --- a/docs/en/docs/alternatives.md +++ b/docs/en/docs/alternatives.md @@ -1,8 +1,8 @@ -# Alternatives, Inspiration and Comparisons +# Alternatives, Inspiration and Comparisons { #alternatives-inspiration-and-comparisons } What inspired **FastAPI**, how it compares to alternatives and what it learned from them. -## Intro +## Intro { #intro } **FastAPI** wouldn't exist if not for the previous work of others. @@ -12,9 +12,9 @@ I have been avoiding the creation of a new framework for several years. First I But at some point, there was no other option than creating something that provided all these features, taking the best ideas from previous tools, and combining them in the best way possible, using language features that weren't even available before (Python 3.6+ type hints). -## Previous tools +## Previous tools { #previous-tools } -### Django +### Django { #django } It's the most popular Python framework and is widely trusted. It is used to build systems like Instagram. @@ -22,7 +22,7 @@ It's relatively tightly coupled with relational databases (like MySQL or Postgre It was created to generate the HTML in the backend, not to create APIs used by a modern frontend (like React, Vue.js and Angular) or by other systems (like IoT devices) communicating with it. -### Django REST Framework +### Django REST Framework { #django-rest-framework } Django REST framework was created to be a flexible toolkit for building Web APIs using Django underneath, to improve its API capabilities. @@ -42,7 +42,7 @@ Have an automatic API documentation web user interface. /// -### Flask +### Flask { #flask } Flask is a "microframework", it doesn't include database integrations nor many of the things that come by default in Django. @@ -64,7 +64,7 @@ Have a simple and easy to use routing system. /// -### Requests +### Requests { #requests } **FastAPI** is not actually an alternative to **Requests**. Their scope is very different. @@ -106,7 +106,7 @@ See the similarities in `requests.get(...)` and `@app.get(...)`. /// -### Swagger / OpenAPI +### Swagger / OpenAPI { #swagger-openapi } The main feature I wanted from Django REST Framework was the automatic API documentation. @@ -131,11 +131,11 @@ These two were chosen for being fairly popular and stable, but doing a quick sea /// -### Flask REST frameworks +### Flask REST frameworks { #flask-rest-frameworks } There are several Flask REST frameworks, but after investing the time and work into investigating them, I found that many are discontinued or abandoned, with several standing issues that made them unfit. -### Marshmallow +### Marshmallow { #marshmallow } One of the main features needed by API systems is data "serialization" which is taking data from the code (Python) and converting it into something that can be sent through the network. For example, converting an object containing data from a database into a JSON object. Converting `datetime` objects into strings, etc. @@ -153,7 +153,7 @@ Use code to define "schemas" that provide data types and validation, automatical /// -### Webargs +### Webargs { #webargs } Another big feature required by APIs is parsing data from incoming requests. @@ -175,7 +175,7 @@ Have automatic validation of incoming request data. /// -### APISpec +### APISpec { #apispec } Marshmallow and Webargs provide validation, parsing and serialization as plug-ins. @@ -205,7 +205,7 @@ Support the open standard for APIs, OpenAPI. /// -### Flask-apispec +### Flask-apispec { #flask-apispec } It's a Flask plug-in, that ties together Webargs, Marshmallow and APISpec. @@ -237,7 +237,7 @@ Generate the OpenAPI schema automatically, from the same code that defines seria /// -### NestJS (and Angular) +### NestJS (and Angular) { #nestjs-and-angular } This isn't even Python, NestJS is a JavaScript (TypeScript) NodeJS framework inspired by Angular. @@ -259,7 +259,7 @@ Have a powerful dependency injection system. Find a way to minimize code repetit /// -### Sanic +### Sanic { #sanic } It was one of the first extremely fast Python frameworks based on `asyncio`. It was made to be very similar to Flask. @@ -279,7 +279,7 @@ That's why **FastAPI** is based on Starlette, as it is the fastest framework ava /// -### Falcon +### Falcon { #falcon } Falcon is another high performance Python framework, it is designed to be minimal, and work as the foundation of other frameworks like Hug. @@ -297,7 +297,7 @@ Although in FastAPI it's optional, and is used mainly to set headers, cookies, a /// -### Molten +### Molten { #molten } I discovered Molten in the first stages of building **FastAPI**. And it has quite similar ideas: @@ -321,7 +321,7 @@ This actually inspired updating parts of Pydantic, to support the same validatio /// -### Hug +### Hug { #hug } Hug was one of the first frameworks to implement the declaration of API parameter types using Python type hints. This was a great idea that inspired other tools to do the same. @@ -351,7 +351,7 @@ Hug inspired **FastAPI** to declare a `response` parameter in functions to set h /// -### APIStar (<= 0.5) +### APIStar (<= 0.5) { #apistar-0-5 } Right before deciding to build **FastAPI** I found **APIStar** server. It had almost everything I was looking for and had a great design. @@ -399,9 +399,9 @@ I consider **FastAPI** a "spiritual successor" to APIStar, while improving and i /// -## Used by **FastAPI** +## Used by **FastAPI** { #used-by-fastapi } -### Pydantic +### Pydantic { #pydantic } Pydantic is a library to define data validation, serialization and documentation (using JSON Schema) based on Python type hints. @@ -417,7 +417,7 @@ Handle all the data validation, data serialization and automatic model documenta /// -### Starlette +### Starlette { #starlette } Starlette is a lightweight ASGI framework/toolkit, which is ideal for building high-performance asyncio services. @@ -462,7 +462,7 @@ So, anything that you can do with Starlette, you can do it directly with **FastA /// -### Uvicorn +### Uvicorn { #uvicorn } Uvicorn is a lightning-fast ASGI server, built on uvloop and httptools. @@ -480,6 +480,6 @@ Check more details in the [Deployment](deployment/index.md){.internal-link targe /// -## Benchmarks and speed +## Benchmarks and speed { #benchmarks-and-speed } To understand, compare, and see the difference between Uvicorn, Starlette and FastAPI, check the section about [Benchmarks](benchmarks.md){.internal-link target=_blank}. diff --git a/docs/en/docs/async.md b/docs/en/docs/async.md index 8207ec480..1d2be0bb6 100644 --- a/docs/en/docs/async.md +++ b/docs/en/docs/async.md @@ -1,8 +1,8 @@ -# Concurrency and async / await +# Concurrency and async / await { #concurrency-and-async-await } Details about the `async def` syntax for *path operation functions* and some background about asynchronous code, concurrency, and parallelism. -## In a hurry? +## In a hurry? { #in-a-hurry } TL;DR: @@ -54,7 +54,7 @@ Anyway, in any of the cases above, FastAPI will still work asynchronously and be But by following the steps above, it will be able to do some performance optimizations. -## Technical Details +## Technical Details { #technical-details } Modern versions of Python have support for **"asynchronous code"** using something called **"coroutines"**, with **`async` and `await`** syntax. @@ -64,7 +64,7 @@ Let's see that phrase by parts in the sections below: * **`async` and `await`** * **Coroutines** -## Asynchronous Code +## Asynchronous Code { #asynchronous-code } Asynchronous code just means that the language 💬 has a way to tell the computer / program 🤖 that at some point in the code, it 🤖 will have to wait for *something else* to finish somewhere else. Let's say that *something else* is called "slow-file" 📝. @@ -93,7 +93,7 @@ Instead of that, by being an "asynchronous" system, once finished, the task can For "synchronous" (contrary to "asynchronous") they commonly also use the term "sequential", because the computer / program follows all the steps in sequence before switching to a different task, even if those steps involve waiting. -### Concurrency and Burgers +### Concurrency and Burgers { #concurrency-and-burgers } This idea of **asynchronous** code described above is also sometimes called **"concurrency"**. It is different from **"parallelism"**. @@ -103,7 +103,7 @@ But the details between *concurrency* and *parallelism* are quite different. To see the difference, imagine the following story about burgers: -### Concurrent Burgers +### Concurrent Burgers { #concurrent-burgers } You go with your crush to get fast food, you stand in line while the cashier takes the orders from the people in front of you. 😍 @@ -163,7 +163,7 @@ So you wait for your crush to finish the story (finish the current work ⏯ / ta Then you go to the counter 🔀, to the initial task that is now finished ⏯, pick the burgers, say thanks and take them to the table. That finishes that step / task of interaction with the counter ⏹. That in turn, creates a new task, of "eating burgers" 🔀 ⏯, but the previous one of "getting burgers" is finished ⏹. -### Parallel Burgers +### Parallel Burgers { #parallel-burgers } Now let's imagine these aren't "Concurrent Burgers", but "Parallel Burgers". @@ -233,7 +233,7 @@ And you have to wait 🕙 in the line for a long time or you lose your turn. You probably wouldn't want to take your crush 😍 with you to run errands at the bank 🏦. -### Burger Conclusion +### Burger Conclusion { #burger-conclusion } In this scenario of "fast food burgers with your crush", as there is a lot of waiting 🕙, it makes a lot more sense to have a concurrent system ⏸🔀⏯. @@ -253,7 +253,7 @@ And that's the same level of performance you get with **FastAPI**. And as you can have parallelism and asynchronicity at the same time, you get higher performance than most of the tested NodeJS frameworks and on par with Go, which is a compiled language closer to C (all thanks to Starlette). -### Is concurrency better than parallelism? +### Is concurrency better than parallelism? { #is-concurrency-better-than-parallelism } Nope! That's not the moral of the story. @@ -290,7 +290,7 @@ For example: * **Machine Learning**: it normally requires lots of "matrix" and "vector" multiplications. Think of a huge spreadsheet with numbers and multiplying all of them together at the same time. * **Deep Learning**: this is a sub-field of Machine Learning, so, the same applies. It's just that there is not a single spreadsheet of numbers to multiply, but a huge set of them, and in many cases, you use a special processor to build and / or use those models. -### Concurrency + Parallelism: Web + Machine Learning +### Concurrency + Parallelism: Web + Machine Learning { #concurrency-parallelism-web-machine-learning } With **FastAPI** you can take advantage of concurrency that is very common for web development (the same main attraction of NodeJS). @@ -300,7 +300,7 @@ That, plus the simple fact that Python is the main language for **Data Science** To see how to achieve this parallelism in production see the section about [Deployment](deployment/index.md){.internal-link target=_blank}. -## `async` and `await` +## `async` and `await` { #async-and-await } Modern versions of Python have a very intuitive way to define asynchronous code. This makes it look just like normal "sequential" code and do the "awaiting" for you at the right moments. @@ -349,7 +349,7 @@ async def read_burgers(): return burgers ``` -### More technical details +### More technical details { #more-technical-details } You might have noticed that `await` can only be used inside of functions defined with `async def`. @@ -361,7 +361,7 @@ If you are working with **FastAPI** you don't have to worry about that, because But if you want to use `async` / `await` without FastAPI, you can do it as well. -### Write your own async code +### Write your own async code { #write-your-own-async-code } Starlette (and **FastAPI**) are based on AnyIO, which makes it compatible with both Python's standard library asyncio and Trio. @@ -371,7 +371,7 @@ And even if you were not using FastAPI, you could also write your own async appl I created another library on top of AnyIO, as a thin layer on top, to improve a bit the type annotations and get better **autocompletion**, **inline errors**, etc. It also has a friendly introduction and tutorial to help you **understand** and write **your own async code**: Asyncer. It would be particularly useful if you need to **combine async code with regular** (blocking/synchronous) code. -### Other forms of asynchronous code +### Other forms of asynchronous code { #other-forms-of-asynchronous-code } This style of using `async` and `await` is relatively new in the language. @@ -385,13 +385,13 @@ In previous versions of Python, you could have used threads or callback hell. -## Coroutines +## Coroutines { #coroutines } **Coroutine** is just the very fancy term for the thing returned by an `async def` function. Python knows that it is something like a function, that it can start and that it will end at some point, but that it might be paused ⏸ internally too, whenever there is an `await` inside of it. But all this functionality of using asynchronous code with `async` and `await` is many times summarized as using "coroutines". It is comparable to the main key feature of Go, the "Goroutines". -## Conclusion +## Conclusion { #conclusion } Let's see the same phrase from above: @@ -401,7 +401,7 @@ That should make more sense now. ✨ All that is what powers FastAPI (through Starlette) and what makes it have such an impressive performance. -## Very Technical Details +## Very Technical Details { #very-technical-details } /// warning @@ -413,7 +413,7 @@ If you have quite some technical knowledge (coroutines, threads, blocking, etc.) /// -### Path operation functions +### Path operation functions { #path-operation-functions } When you declare a *path operation function* with normal `def` instead of `async def`, it is run in an external threadpool that is then awaited, instead of being called directly (as it would block the server). @@ -421,15 +421,15 @@ If you are coming from another async framework that does not work in the way des Still, in both situations, chances are that **FastAPI** will [still be faster](index.md#performance){.internal-link target=_blank} than (or at least comparable to) your previous framework. -### Dependencies +### Dependencies { #dependencies } The same applies for [dependencies](tutorial/dependencies/index.md){.internal-link target=_blank}. If a dependency is a standard `def` function instead of `async def`, it is run in the external threadpool. -### Sub-dependencies +### Sub-dependencies { #sub-dependencies } You can have multiple dependencies and [sub-dependencies](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank} requiring each other (as parameters of the function definitions), some of them might be created with `async def` and some with normal `def`. It would still work, and the ones created with normal `def` would be called on an external thread (from the threadpool) instead of being "awaited". -### Other utility functions +### Other utility functions { #other-utility-functions } Any other utility function that you call directly can be created with normal `def` or `async def` and FastAPI won't affect the way you call it. diff --git a/docs/en/docs/benchmarks.md b/docs/en/docs/benchmarks.md index 62266c449..551f6316d 100644 --- a/docs/en/docs/benchmarks.md +++ b/docs/en/docs/benchmarks.md @@ -1,10 +1,10 @@ -# Benchmarks +# Benchmarks { #benchmarks } Independent TechEmpower benchmarks show **FastAPI** applications running under Uvicorn as one of the fastest Python frameworks available, only below Starlette and Uvicorn themselves (used internally by FastAPI). But when checking benchmarks and comparisons you should keep the following in mind. -## Benchmarks and speed +## Benchmarks and speed { #benchmarks-and-speed } When you check the benchmarks, it is common to see several tools of different types compared as equivalent. diff --git a/docs/en/docs/deployment/cloud.md b/docs/en/docs/deployment/cloud.md index c6d408f8c..cb723dd13 100644 --- a/docs/en/docs/deployment/cloud.md +++ b/docs/en/docs/deployment/cloud.md @@ -1,10 +1,10 @@ -# Deploy FastAPI on Cloud Providers +# Deploy FastAPI on Cloud Providers { #deploy-fastapi-on-cloud-providers } You can use virtually **any cloud provider** to deploy your FastAPI application. In most of the cases, the main cloud providers have guides to deploy FastAPI with them. -## Cloud Providers - Sponsors +## Cloud Providers - Sponsors { #cloud-providers-sponsors } Some cloud providers ✨ [**sponsor FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, this ensures the continued and healthy **development** of FastAPI and its **ecosystem**. diff --git a/docs/en/docs/deployment/concepts.md b/docs/en/docs/deployment/concepts.md index ed635a920..2174443f0 100644 --- a/docs/en/docs/deployment/concepts.md +++ b/docs/en/docs/deployment/concepts.md @@ -1,4 +1,4 @@ -# Deployments Concepts +# Deployments Concepts { #deployments-concepts } When deploying a **FastAPI** application, or actually, any type of web API, there are several concepts that you probably care about, and using them you can find the **most appropriate** way to **deploy your application**. @@ -23,7 +23,7 @@ In the next chapters, I'll give you more **concrete recipes** to deploy FastAPI But for now, let's check these important **conceptual ideas**. These concepts also apply to any other type of web API. 💡 -## Security - HTTPS +## Security - HTTPS { #security-https } In the [previous chapter about HTTPS](https.md){.internal-link target=_blank} we learned about how HTTPS provides encryption for your API. @@ -31,7 +31,7 @@ We also saw that HTTPS is normally provided by a component **external** to your And there has to be something in charge of **renewing the HTTPS certificates**, it could be the same component or it could be something different. -### Example Tools for HTTPS +### Example Tools for HTTPS { #example-tools-for-https } Some of the tools you could use as a TLS Termination Proxy are: @@ -55,11 +55,11 @@ I'll show you some concrete examples in the next chapters. Then the next concepts to consider are all about the program running your actual API (e.g. Uvicorn). -## Program and Process +## Program and Process { #program-and-process } We will talk a lot about the running "**process**", so it's useful to have clarity about what it means, and what's the difference with the word "**program**". -### What is a Program +### What is a Program { #what-is-a-program } The word **program** is commonly used to describe many things: @@ -67,7 +67,7 @@ The word **program** is commonly used to describe many things: * The **file** that can be **executed** by the operating system, for example: `python`, `python.exe` or `uvicorn`. * A particular program while it is **running** on the operating system, using the CPU, and storing things in memory. This is also called a **process**. -### What is a Process +### What is a Process { #what-is-a-process } The word **process** is normally used in a more specific way, only referring to the thing that is running in the operating system (like in the last point above): @@ -88,11 +88,11 @@ And, for example, you will probably see that there are multiple processes runnin Now that we know the difference between the terms **process** and **program**, let's continue talking about deployments. -## Running on Startup +## Running on Startup { #running-on-startup } In most cases, when you create a web API, you want it to be **always running**, uninterrupted, so that your clients can always access it. This is of course, unless you have a specific reason why you want it to run only in certain situations, but most of the time you want it constantly running and **available**. -### In a Remote Server +### In a Remote Server { #in-a-remote-server } When you set up a remote server (a cloud server, a virtual machine, etc.) the simplest thing you can do is use `fastapi run` (which uses Uvicorn) or something similar, manually, the same way you do when developing locally. @@ -102,15 +102,15 @@ But if your connection to the server is lost, the **running process** will proba And if the server is restarted (for example after updates, or migrations from the cloud provider) you probably **won't notice it**. And because of that, you won't even know that you have to restart the process manually. So, your API will just stay dead. 😱 -### Run Automatically on Startup +### Run Automatically on Startup { #run-automatically-on-startup } In general, you will probably want the server program (e.g. Uvicorn) to be started automatically on server startup, and without needing any **human intervention**, to have a process always running with your API (e.g. Uvicorn running your FastAPI app). -### Separate Program +### Separate Program { #separate-program } To achieve this, you will normally have a **separate program** that would make sure your application is run on startup. And in many cases, it would also make sure other components or applications are also run, for example, a database. -### Example Tools to Run at Startup +### Example Tools to Run at Startup { #example-tools-to-run-at-startup } Some examples of the tools that can do this job are: @@ -125,29 +125,29 @@ Some examples of the tools that can do this job are: I'll give you more concrete examples in the next chapters. -## Restarts +## Restarts { #restarts } Similar to making sure your application is run on startup, you probably also want to make sure it is **restarted** after failures. -### We Make Mistakes +### We Make Mistakes { #we-make-mistakes } We, as humans, make **mistakes**, all the time. Software almost *always* has **bugs** hidden in different places. 🐛 And we as developers keep improving the code as we find those bugs and as we implement new features (possibly adding new bugs too 😅). -### Small Errors Automatically Handled +### Small Errors Automatically Handled { #small-errors-automatically-handled } When building web APIs with FastAPI, if there's an error in our code, FastAPI will normally contain it to the single request that triggered the error. 🛡 The client will get a **500 Internal Server Error** for that request, but the application will continue working for the next requests instead of just crashing completely. -### Bigger Errors - Crashes +### Bigger Errors - Crashes { #bigger-errors-crashes } Nevertheless, there might be cases where we write some code that **crashes the entire application** making Uvicorn and Python crash. 💥 And still, you would probably not want the application to stay dead because there was an error in one place, you probably want it to **continue running** at least for the *path operations* that are not broken. -### Restart After Crash +### Restart After Crash { #restart-after-crash } But in those cases with really bad errors that crash the running **process**, you would want an external component that is in charge of **restarting** the process, at least a couple of times... @@ -161,7 +161,7 @@ So let's focus on the main cases, where it could crash entirely in some particul You would probably want to have the thing in charge of restarting your application as an **external component**, because by that point, the same application with Uvicorn and Python already crashed, so there's nothing in the same code of the same app that could do anything about it. -### Example Tools to Restart Automatically +### Example Tools to Restart Automatically { #example-tools-to-restart-automatically } In most cases, the same tool that is used to **run the program on startup** is also used to handle automatic **restarts**. @@ -176,19 +176,19 @@ For example, this could be handled by: * Handled internally by a cloud provider as part of their services * Others... -## Replication - Processes and Memory +## Replication - Processes and Memory { #replication-processes-and-memory } With a FastAPI application, using a server program like the `fastapi` command that runs Uvicorn, running it once in **one process** can serve multiple clients concurrently. But in many cases, you will want to run several worker processes at the same time. -### Multiple Processes - Workers +### Multiple Processes - Workers { #multiple-processes-workers } If you have more clients than what a single process can handle (for example if the virtual machine is not too big) and you have **multiple cores** in the server's CPU, then you could have **multiple processes** running with the same application at the same time, and distribute all the requests among them. When you run **multiple processes** of the same API program, they are commonly called **workers**. -### Worker Processes and Ports +### Worker Processes and Ports { #worker-processes-and-ports } Remember from the docs [About HTTPS](https.md){.internal-link target=_blank} that only one process can be listening on one combination of port and IP address in a server? @@ -196,19 +196,19 @@ This is still true. So, to be able to have **multiple processes** at the same time, there has to be a **single process listening on a port** that then transmits the communication to each worker process in some way. -### Memory per Process +### Memory per Process { #memory-per-process } Now, when the program loads things in memory, for example, a machine learning model in a variable, or the contents of a large file in a variable, all that **consumes a bit of the memory (RAM)** of the server. And multiple processes normally **don't share any memory**. This means that each running process has its own things, variables, and memory. And if you are consuming a large amount of memory in your code, **each process** will consume an equivalent amount of memory. -### Server Memory +### Server Memory { #server-memory } For example, if your code loads a Machine Learning model with **1 GB in size**, when you run one process with your API, it will consume at least 1 GB of RAM. And if you start **4 processes** (4 workers), each will consume 1 GB of RAM. So in total, your API will consume **4 GB of RAM**. And if your remote server or virtual machine only has 3 GB of RAM, trying to load more than 4 GB of RAM will cause problems. 🚨 -### Multiple Processes - An Example +### Multiple Processes - An Example { #multiple-processes-an-example } In this example, there's a **Manager Process** that starts and controls two **Worker Processes**. @@ -224,7 +224,7 @@ An interesting detail is that the percentage of the **CPU used** by each process If you have an API that does a comparable amount of computations every time and you have a lot of clients, then the **CPU utilization** will probably *also be stable* (instead of constantly going up and down quickly). -### Examples of Replication Tools and Strategies +### Examples of Replication Tools and Strategies { #examples-of-replication-tools-and-strategies } There can be several approaches to achieve this, and I'll tell you more about specific strategies in the next chapters, for example when talking about Docker and containers. @@ -247,7 +247,7 @@ I'll tell you more about container images, Docker, Kubernetes, etc. in a future /// -## Previous Steps Before Starting +## Previous Steps Before Starting { #previous-steps-before-starting } There are many cases where you want to perform some steps **before starting** your application. @@ -269,7 +269,7 @@ In that case, you wouldn't have to worry about any of this. 🤷 /// -### Examples of Previous Steps Strategies +### Examples of Previous Steps Strategies { #examples-of-previous-steps-strategies } This will **depend heavily** on the way you **deploy your system**, and it would probably be connected to the way you start programs, handling restarts, etc. @@ -285,7 +285,7 @@ I'll give you more concrete examples for doing this with containers in a future /// -## Resource Utilization +## Resource Utilization { #resource-utilization } Your server(s) is (are) a **resource**, you can consume or **utilize**, with your programs, the computation time on the CPUs, and the RAM memory available. @@ -305,7 +305,7 @@ You could put an **arbitrary number** to target, for example, something **betwee You can use simple tools like `htop` to see the CPU and RAM used in your server or the amount used by each process. Or you can use more complex monitoring tools, which may be distributed across servers, etc. -## Recap +## Recap { #recap } You have been reading here some of the main concepts that you would probably need to keep in mind when deciding how to deploy your application: diff --git a/docs/en/docs/deployment/docker.md b/docs/en/docs/deployment/docker.md index b106f7ac3..a1de2dc46 100644 --- a/docs/en/docs/deployment/docker.md +++ b/docs/en/docs/deployment/docker.md @@ -1,4 +1,4 @@ -# FastAPI in Containers - Docker +# FastAPI in Containers - Docker { #fastapi-in-containers-docker } When deploying FastAPI applications a common approach is to build a **Linux container image**. It's normally done using **Docker**. You can then deploy that container image in one of a few possible ways. @@ -32,7 +32,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"] -## What is a Container +## What is a Container { #what-is-a-container } Containers (mainly Linux containers) are a very **lightweight** way to package applications including all their dependencies and necessary files while keeping them isolated from other containers (other applications or components) in the same system. @@ -42,7 +42,7 @@ This way, containers consume **little resources**, an amount comparable to runni Containers also have their own **isolated** running processes (commonly just one process), file system, and network, simplifying deployment, security, development, etc. -## What is a Container Image +## What is a Container Image { #what-is-a-container-image } A **container** is run from a **container image**. @@ -56,7 +56,7 @@ A container image is comparable to the **program** file and contents, e.g. `pyth And the **container** itself (in contrast to the **container image**) is the actual running instance of the image, comparable to a **process**. In fact, a container is running only when it has a **process running** (and normally it's only a single process). The container stops when there's no process running in it. -## Container Images +## Container Images { #container-images } Docker has been one of the main tools to create and manage **container images** and **containers**. @@ -79,7 +79,7 @@ So, you would run **multiple containers** with different things, like a database All the container management systems (like Docker or Kubernetes) have these networking features integrated into them. -## Containers and Processes +## Containers and Processes { #containers-and-processes } A **container image** normally includes in its metadata the default program or command that should be run when the **container** is started and the parameters to be passed to that program. Very similar to what would be if it was in the command line. @@ -91,7 +91,7 @@ A container normally has a **single process**, but it's also possible to start s But it's not possible to have a running container without **at least one running process**. If the main process stops, the container stops. -## Build a Docker Image for FastAPI +## Build a Docker Image for FastAPI { #build-a-docker-image-for-fastapi } Okay, let's build something now! 🚀 @@ -103,7 +103,7 @@ This is what you would want to do in **most cases**, for example: * When running on a **Raspberry Pi** * Using a cloud service that would run a container image for you, etc. -### Package Requirements +### Package Requirements { #package-requirements } You would normally have the **package requirements** for your application in some file. @@ -138,7 +138,7 @@ There are other formats and tools to define and install package dependencies. /// -### Create the **FastAPI** Code +### Create the **FastAPI** Code { #create-the-fastapi-code } * Create an `app` directory and enter it. * Create an empty file `__init__.py`. @@ -162,7 +162,7 @@ def read_item(item_id: int, q: Union[str, None] = None): return {"item_id": item_id, "q": q} ``` -### Dockerfile +### Dockerfile { #dockerfile } Now in the same project directory create a file `Dockerfile` with: @@ -238,7 +238,7 @@ Make sure to **always** use the **exec form** of the `CMD` instruction, as expla /// -#### Use `CMD` - Exec Form +#### Use `CMD` - Exec Form { #use-cmd-exec-form } The `CMD` Docker instruction can be written using two forms: @@ -262,7 +262,7 @@ You can read more about it in the Why do my services take 10 seconds to recreate or stop?. -#### Directory Structure +#### Directory Structure { #directory-structure } You should now have a directory structure like: @@ -275,7 +275,7 @@ You should now have a directory structure like: └── requirements.txt ``` -#### Behind a TLS Termination Proxy +#### Behind a TLS Termination Proxy { #behind-a-tls-termination-proxy } If you are running your container behind a TLS Termination Proxy (load balancer) like Nginx or Traefik, add the option `--proxy-headers`, this will tell Uvicorn (through the FastAPI CLI) to trust the headers sent by that proxy telling it that the application is running behind HTTPS, etc. @@ -283,7 +283,7 @@ If you are running your container behind a TLS Termination Proxy (load balancer) CMD ["fastapi", "run", "app/main.py", "--proxy-headers", "--port", "80"] ``` -#### Docker Cache +#### Docker Cache { #docker-cache } There's an important trick in this `Dockerfile`, we first copy the **file with the dependencies alone**, not the rest of the code. Let me tell you why is that. @@ -315,7 +315,7 @@ Then, near the end of the `Dockerfile`, we copy all the code. As this is what ** COPY ./app /code/app ``` -### Build the Docker Image +### Build the Docker Image { #build-the-docker-image } Now that all the files are in place, let's build the container image. @@ -340,7 +340,7 @@ In this case, it's the same current directory (`.`). /// -### Start the Docker Container +### Start the Docker Container { #start-the-docker-container } * Run a container based on your image: @@ -352,7 +352,7 @@ $ docker run -d --name mycontainer -p 80:80 myimage -## Check it +## Check it { #check-it } You should be able to check it in your Docker container's URL, for example: http://192.168.99.100/items/5?q=somequery or http://127.0.0.1/items/5?q=somequery (or equivalent, using your Docker host). @@ -362,7 +362,7 @@ You will see something like: {"item_id": 5, "q": "somequery"} ``` -## Interactive API docs +## Interactive API docs { #interactive-api-docs } Now you can go to http://192.168.99.100/docs or http://127.0.0.1/docs (or equivalent, using your Docker host). @@ -370,7 +370,7 @@ You will see the automatic interactive API documentation (provided by http://192.168.99.100/redoc or http://127.0.0.1/redoc (or equivalent, using your Docker host). @@ -378,7 +378,7 @@ You will see the alternative automatic documentation (provided by cluster of machines with **Kubernetes**, Docker Swarm Mode, Nomad, or another similar complex system to manage distributed containers on multiple machines, then you will probably want to **handle replication** at the **cluster level** instead of using a **process manager** (like Uvicorn with workers) in each container. @@ -462,7 +462,7 @@ One of those distributed container management systems like Kubernetes normally h In those cases, you would probably want to build a **Docker image from scratch** as [explained above](#dockerfile), installing your dependencies, and running **a single Uvicorn process** instead of using multiple Uvicorn workers. -### Load Balancer +### Load Balancer { #load-balancer } When using containers, you would normally have some component **listening on the main port**. It could possibly be another container that is also a **TLS Termination Proxy** to handle **HTTPS** or some similar tool. @@ -476,7 +476,7 @@ The same **TLS Termination Proxy** component used for HTTPS would probably also And when working with containers, the same system you use to start and manage them would already have internal tools to transmit the **network communication** (e.g. HTTP requests) from that **load balancer** (that could also be a **TLS Termination Proxy**) to the container(s) with your app. -### One Load Balancer - Multiple Worker Containers +### One Load Balancer - Multiple Worker Containers { #one-load-balancer-multiple-worker-containers } When working with **Kubernetes** or similar distributed container management systems, using their internal networking mechanisms would allow the single **load balancer** that is listening on the main **port** to transmit communication (requests) to possibly **multiple containers** running your app. @@ -486,7 +486,7 @@ And the distributed container system with the **load balancer** would **distribu And normally this **load balancer** would be able to handle requests that go to *other* apps in your cluster (e.g. to a different domain, or under a different URL path prefix), and would transmit that communication to the right containers for *that other* application running in your cluster. -### One Process per Container +### One Process per Container { #one-process-per-container } In this type of scenario, you probably would want to have **a single (Uvicorn) process per container**, as you would already be handling replication at the cluster level. @@ -494,7 +494,7 @@ So, in this case, you **would not** want to have a multiple workers in the conta Having another process manager inside the container (as would be with multiple workers) would only add **unnecessary complexity** that you are most probably already taking care of with your cluster system. -### Containers with Multiple Processes and Special Cases +### Containers with Multiple Processes and Special Cases { #containers-with-multiple-processes-and-special-cases } Of course, there are **special cases** where you could want to have **a container** with several **Uvicorn worker processes** inside. @@ -519,11 +519,11 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"] Here are some examples of when that could make sense: -#### A Simple App +#### A Simple App { #a-simple-app } You could want a process manager in the container if your application is **simple enough** that can run it on a **single server**, not a cluster. -#### Docker Compose +#### Docker Compose { #docker-compose } You could be deploying to a **single server** (not a cluster) with **Docker Compose**, so you wouldn't have an easy way to manage replication of containers (with Docker Compose) while preserving the shared network and **load balancing**. @@ -540,7 +540,7 @@ The main point is, **none** of these are **rules written in stone** that you hav * Memory * Previous steps before starting -## Memory +## Memory { #memory } If you run **a single process per container** you will have a more or less well-defined, stable, and limited amount of memory consumed by each of those containers (more than one if they are replicated). @@ -550,11 +550,11 @@ If your application is **simple**, this will probably **not be a problem**, and If you run **multiple processes per container** you will have to make sure that the number of processes started doesn't **consume more memory** than what is available. -## Previous Steps Before Starting and Containers +## Previous Steps Before Starting and Containers { #previous-steps-before-starting-and-containers } If you are using containers (e.g. Docker, Kubernetes), then there are two main approaches you can use. -### Multiple Containers +### Multiple Containers { #multiple-containers } If you have **multiple containers**, probably each one running a **single process** (for example, in a **Kubernetes** cluster), then you would probably want to have a **separate container** doing the work of the **previous steps** in a single container, running a single process, **before** running the replicated worker containers. @@ -566,11 +566,11 @@ If you are using Kubernetes, this would probably be an tiangolo/uvicorn-gunicorn-fastapi. But it is now deprecated. ⛔️ @@ -588,7 +588,7 @@ But now that Uvicorn (and the `fastapi` command) support using `--workers`, ther /// -## Deploy the Container Image +## Deploy the Container Image { #deploy-the-container-image } After having a Container (Docker) Image there are several ways to deploy it. @@ -600,11 +600,11 @@ For example: * With another tool like Nomad * With a cloud service that takes your container image and deploys it -## Docker Image with `uv` +## Docker Image with `uv` { #docker-image-with-uv } If you are using uv to install and manage your project, you can follow their uv Docker guide. -## Recap +## Recap { #recap } Using container systems (e.g. with **Docker** and **Kubernetes**) it becomes fairly straightforward to handle all the **deployment concepts**: diff --git a/docs/en/docs/deployment/https.md b/docs/en/docs/deployment/https.md index 8b4a08dbe..2c166c3c9 100644 --- a/docs/en/docs/deployment/https.md +++ b/docs/en/docs/deployment/https.md @@ -1,4 +1,4 @@ -# About HTTPS +# About HTTPS { #about-https } It is easy to assume that HTTPS is something that is just "enabled" or not. @@ -43,7 +43,7 @@ Some of the options you could use as a TLS Termination Proxy are: * Nginx * HAProxy -## Let's Encrypt +## Let's Encrypt { #let-s-encrypt } Before Let's Encrypt, these **HTTPS certificates** were sold by trusted third parties. @@ -57,11 +57,11 @@ The domains are securely verified and the certificates are generated automatical The idea is to automate the acquisition and renewal of these certificates so that you can have **secure HTTPS, for free, forever**. -## HTTPS for Developers +## HTTPS for Developers { #https-for-developers } Here's an example of how an HTTPS API could look like, step by step, paying attention mainly to the ideas important for developers. -### Domain Name +### Domain Name { #domain-name } It would probably all start by you **acquiring** some **domain name**. Then, you would configure it in a DNS server (possibly your same cloud provider). @@ -77,7 +77,7 @@ This Domain Name part is way before HTTPS, but as everything depends on the doma /// -### DNS +### DNS { #dns } Now let's focus on all the actual HTTPS parts. @@ -87,7 +87,7 @@ The DNS servers would tell the browser to use some specific **IP address**. That -### TLS Handshake Start +### TLS Handshake Start { #tls-handshake-start } The browser would then communicate with that IP address on **port 443** (the HTTPS port). @@ -97,7 +97,7 @@ The first part of the communication is just to establish the connection between This interaction between the client and the server to establish the TLS connection is called the **TLS handshake**. -### TLS with SNI Extension +### TLS with SNI Extension { #tls-with-sni-extension } **Only one process** in the server can be listening on a specific **port** in a specific **IP address**. There could be other processes listening on other ports in the same IP address, but only one for each combination of IP address and port. @@ -127,7 +127,7 @@ Notice that the encryption of the communication happens at the **TCP level**, no /// -### HTTPS Request +### HTTPS Request { #https-request } Now that the client and server (specifically the browser and the TLS Termination Proxy) have an **encrypted TCP connection**, they can start the **HTTP communication**. @@ -135,19 +135,19 @@ So, the client sends an **HTTPS request**. This is just an HTTP request through -### Decrypt the Request +### Decrypt the Request { #decrypt-the-request } The TLS Termination Proxy would use the encryption agreed to **decrypt the request**, and would transmit the **plain (decrypted) HTTP request** to the process running the application (for example a process with Uvicorn running the FastAPI application). -### HTTP Response +### HTTP Response { #http-response } The application would process the request and send a **plain (unencrypted) HTTP response** to the TLS Termination Proxy. -### HTTPS Response +### HTTPS Response { #https-response } The TLS Termination Proxy would then **encrypt the response** using the cryptography agreed before (that started with the certificate for `someapp.example.com`), and send it back to the browser. @@ -157,7 +157,7 @@ Next, the browser would verify that the response is valid and encrypted with the The client (browser) will know that the response comes from the correct server because it is using the cryptography they agreed using the **HTTPS certificate** before. -### Multiple Applications +### Multiple Applications { #multiple-applications } In the same server (or servers), there could be **multiple applications**, for example, other API programs or a database. @@ -167,7 +167,7 @@ Only one process can be handling the specific IP and port (the TLS Termination P That way, the TLS Termination Proxy could handle HTTPS and certificates for **multiple domains**, for multiple applications, and then transmit the requests to the right application in each case. -### Certificate Renewal +### Certificate Renewal { #certificate-renewal } At some point in the future, each certificate would **expire** (about 3 months after acquiring it). @@ -190,7 +190,7 @@ To do that, and to accommodate different application needs, there are several wa All this renewal process, while still serving the app, is one of the main reasons why you would want to have a **separate system to handle HTTPS** with a TLS Termination Proxy instead of just using the TLS certificates with the application server directly (e.g. Uvicorn). -## Recap +## Recap { #recap } Having **HTTPS** is very important, and quite **critical** in most cases. Most of the effort you as a developer have to put around HTTPS is just about **understanding these concepts** and how they work. diff --git a/docs/en/docs/deployment/index.md b/docs/en/docs/deployment/index.md index b43bd050a..2364791a7 100644 --- a/docs/en/docs/deployment/index.md +++ b/docs/en/docs/deployment/index.md @@ -1,8 +1,8 @@ -# Deployment +# Deployment { #deployment } Deploying a **FastAPI** application is relatively easy. -## What Does Deployment Mean +## What Does Deployment Mean { #what-does-deployment-mean } To **deploy** an application means to perform the necessary steps to make it **available to the users**. @@ -10,7 +10,7 @@ For a **web API**, it normally involves putting it in a **remote machine**, with This is in contrast to the **development** stages, where you are constantly changing the code, breaking it and fixing it, stopping and restarting the development server, etc. -## Deployment Strategies +## Deployment Strategies { #deployment-strategies } There are several ways to do it depending on your specific use case and the tools that you use. diff --git a/docs/en/docs/deployment/manually.md b/docs/en/docs/deployment/manually.md index 19ba98075..8bb3945bc 100644 --- a/docs/en/docs/deployment/manually.md +++ b/docs/en/docs/deployment/manually.md @@ -1,6 +1,6 @@ -# Run a Server Manually +# Run a Server Manually { #run-a-server-manually } -## Use the `fastapi run` Command +## Use the `fastapi run` Command { #use-the-fastapi-run-command } In short, use `fastapi run` to serve your FastAPI application: @@ -42,7 +42,7 @@ That would work for most of the cases. 😎 You could use that command for example to start your **FastAPI** app in a container, in a server, etc. -## ASGI Servers +## ASGI Servers { #asgi-servers } Let's go a little deeper into the details. @@ -58,7 +58,7 @@ There are several alternatives, including: * Granian: A Rust HTTP server for Python applications. * NGINX Unit: NGINX Unit is a lightweight and versatile web application runtime. -## Server Machine and Server Program +## Server Machine and Server Program { #server-machine-and-server-program } There's a small detail about names to keep in mind. 💡 @@ -68,7 +68,7 @@ Just keep in mind that when you read "server" in general, it could refer to one When referring to the remote machine, it's common to call it **server**, but also **machine**, **VM** (virtual machine), **node**. Those all refer to some type of remote machine, normally running Linux, where you run programs. -## Install the Server Program +## Install the Server Program { #install-the-server-program } When you install FastAPI, it comes with a production server, Uvicorn, and you can start it with the `fastapi run` command. @@ -100,7 +100,7 @@ When you install FastAPI with something like `pip install "fastapi[standard]"` y /// -## Run the Server Program +## Run the Server Program { #run-the-server-program } If you installed an ASGI server manually, you would normally need to pass an import string in a special format for it to import your FastAPI application: @@ -141,7 +141,7 @@ It helps a lot during **development**, but you **shouldn't** use it in **product /// -## Deployment Concepts +## Deployment Concepts { #deployment-concepts } These examples run the server program (e.g Uvicorn), starting **a single process**, listening on all the IPs (`0.0.0.0`) on a predefined port (e.g. `80`). diff --git a/docs/en/docs/deployment/server-workers.md b/docs/en/docs/deployment/server-workers.md index 5d6b0d00a..0351e8b5e 100644 --- a/docs/en/docs/deployment/server-workers.md +++ b/docs/en/docs/deployment/server-workers.md @@ -1,4 +1,4 @@ -# Server Workers - Uvicorn with Workers +# Server Workers - Uvicorn with Workers { #server-workers-uvicorn-with-workers } Let's check back those deployment concepts from before: @@ -25,7 +25,7 @@ In particular, when running on **Kubernetes** you will probably **not** want to /// -## Multiple Workers +## Multiple Workers { #multiple-workers } You can start multiple workers with the `--workers` command line option: @@ -111,7 +111,7 @@ The only new option here is `--workers` telling Uvicorn to start 4 worker proces You can also see that it shows the **PID** of each process, `27365` for the parent process (this is the **process manager**) and one for each worker process: `27368`, `27369`, `27370`, and `27367`. -## Deployment Concepts +## Deployment Concepts { #deployment-concepts } Here you saw how to use multiple **workers** to **parallelize** the execution of the application, take advantage of **multiple cores** in the CPU, and be able to serve **more requests**. @@ -124,13 +124,13 @@ From the list of deployment concepts from above, using workers would mainly help * **Memory** * **Previous steps before starting** -## Containers and Docker +## Containers and Docker { #containers-and-docker } In the next chapter about [FastAPI in Containers - Docker](docker.md){.internal-link target=_blank} I'll explain some strategies you could use to handle the other **deployment concepts**. I'll show you how to **build your own image from scratch** to run a single Uvicorn process. It is a simple process and is probably what you would want to do when using a distributed container management system like **Kubernetes**. -## Recap +## Recap { #recap } You can use multiple worker processes with the `--workers` CLI option with the `fastapi` or `uvicorn` commands to take advantage of **multi-core CPUs**, to run **multiple processes in parallel**. diff --git a/docs/en/docs/deployment/versions.md b/docs/en/docs/deployment/versions.md index 23f49cf99..15b449184 100644 --- a/docs/en/docs/deployment/versions.md +++ b/docs/en/docs/deployment/versions.md @@ -1,4 +1,4 @@ -# About FastAPI versions +# About FastAPI versions { #about-fastapi-versions } **FastAPI** is already being used in production in many applications and systems. And the test coverage is kept at 100%. But its development is still moving quickly. @@ -8,7 +8,7 @@ That's why the current versions are still `0.x.x`, this reflects that each versi You can create production applications with **FastAPI** right now (and you have probably been doing it for some time), you just have to make sure that you use a version that works correctly with the rest of your code. -## Pin your `fastapi` version +## Pin your `fastapi` version { #pin-your-fastapi-version } The first thing you should do is to "pin" the version of **FastAPI** you are using to the specific latest version that you know works correctly for your application. @@ -32,11 +32,11 @@ that would mean that you would use the versions `0.112.0` or above, but less tha If you use any other tool to manage your installations, like `uv`, Poetry, Pipenv, or others, they all have a way that you can use to define specific versions for your packages. -## Available versions +## Available versions { #available-versions } You can see the available versions (e.g. to check what is the current latest) in the [Release Notes](../release-notes.md){.internal-link target=_blank}. -## About versions +## About versions { #about-versions } Following the Semantic Versioning conventions, any version below `1.0.0` could potentially add breaking changes. @@ -62,7 +62,7 @@ The "MINOR" is the number in the middle, for example, in `0.2.3`, the MINOR vers /// -## Upgrading the FastAPI versions +## Upgrading the FastAPI versions { #upgrading-the-fastapi-versions } You should add tests for your app. @@ -72,7 +72,7 @@ After you have tests, then you can upgrade the **FastAPI** version to a more rec If everything is working, or after you make the necessary changes, and all your tests are passing, then you can pin your `fastapi` to that new recent version. -## About Starlette +## About Starlette { #about-starlette } You shouldn't pin the version of `starlette`. @@ -80,7 +80,7 @@ Different versions of **FastAPI** will use a specific newer version of Starlette So, you can just let **FastAPI** use the correct Starlette version. -## About Pydantic +## About Pydantic { #about-pydantic } Pydantic includes the tests for **FastAPI** with its own tests, so new versions of Pydantic (above `1.0.0`) are always compatible with FastAPI. diff --git a/docs/en/docs/environment-variables.md b/docs/en/docs/environment-variables.md index 43dd06add..1dbd93570 100644 --- a/docs/en/docs/environment-variables.md +++ b/docs/en/docs/environment-variables.md @@ -1,4 +1,4 @@ -# Environment Variables +# Environment Variables { #environment-variables } /// tip @@ -10,7 +10,7 @@ An environment variable (also known as "**env var**") is a variable that lives * Environment variables could be useful for handling application **settings**, as part of the **installation** of Python, etc. -## Create and Use Env Vars +## Create and Use Env Vars { #create-and-use-env-vars } You can **create** and use environment variables in the **shell (terminal)**, without needing Python: @@ -50,7 +50,7 @@ Hello Wade Wilson //// -## Read env vars in Python +## Read env vars in Python { #read-env-vars-in-python } You could also create environment variables **outside** of Python, in the terminal (or with any other method), and then **read them in Python**. @@ -157,7 +157,7 @@ You can read more about it at Uvicorn, a high-performance, production-ready, ASGI server. 😎 -## `fastapi dev` +## `fastapi dev` { #fastapi-dev } Running `fastapi dev` initiates development mode. By default, **auto-reload** is enabled, automatically reloading the server when you make changes to your code. This is resource-intensive and could be less stable than when it's disabled. You should only use it for development. It also listens on the IP address `127.0.0.1`, which is the IP for your machine to communicate with itself alone (`localhost`). -## `fastapi run` +## `fastapi run` { #fastapi-run } Executing `fastapi run` starts FastAPI in production mode by default. diff --git a/docs/en/docs/features.md b/docs/en/docs/features.md index 9c38a4bd2..681caac35 100644 --- a/docs/en/docs/features.md +++ b/docs/en/docs/features.md @@ -1,17 +1,17 @@ -# Features +# Features { #features } -## FastAPI features +## FastAPI features { #fastapi-features } **FastAPI** gives you the following: -### Based on open standards +### Based on open standards { #based-on-open-standards } * OpenAPI for API creation, including declarations of path operations, parameters, request bodies, security, etc. * Automatic data model documentation with JSON Schema (as OpenAPI itself is based on JSON Schema). * Designed around these standards, after a meticulous study. Instead of an afterthought layer on top. * This also allows using automatic **client code generation** in many languages. -### Automatic docs +### Automatic docs { #automatic-docs } Interactive API documentation and exploration web user interfaces. As the framework is based on OpenAPI, there are multiple options, 2 included by default. @@ -23,7 +23,7 @@ Interactive API documentation and exploration web user interfaces. As the framew ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png) -### Just Modern Python +### Just Modern Python { #just-modern-python } It's all based on standard **Python type** declarations (thanks to Pydantic). No new syntax to learn. Just standard modern Python. @@ -71,7 +71,7 @@ Pass the keys and values of the `second_user_data` dict directly as key-value ar /// -### Editor support +### Editor support { #editor-support } All the framework was designed to be easy and intuitive to use, all the decisions were tested on multiple editors even before starting development, to ensure the best development experience. @@ -95,13 +95,13 @@ You will get completion in code you might even consider impossible before. As fo No more typing the wrong key names, coming back and forth between docs, or scrolling up and down to find if you finally used `username` or `user_name`. -### Short +### Short { #short } It has sensible **defaults** for everything, with optional configurations everywhere. All the parameters can be fine-tuned to do what you need and to define the API you need. But by default, it all **"just works"**. -### Validation +### Validation { #validation } * Validation for most (or all?) Python **data types**, including: * JSON objects (`dict`). @@ -117,7 +117,7 @@ But by default, it all **"just works"**. All the validation is handled by the well-established and robust **Pydantic**. -### Security and authentication +### Security and authentication { #security-and-authentication } Security and authentication integrated. Without any compromise with databases or data models. @@ -134,7 +134,7 @@ Plus all the security features from Starlette (including **session cookies**). All built as reusable tools and components that are easy to integrate with your systems, data stores, relational and NoSQL databases, etc. -### Dependency Injection +### Dependency Injection { #dependency-injection } FastAPI includes an extremely easy to use, but extremely powerful Dependency Injection system. @@ -145,19 +145,19 @@ FastAPI includes an extremely easy to use, but extremely powerful Pydantic. So, any additional Pydantic code you have, will also work. diff --git a/docs/en/docs/help-fastapi.md b/docs/en/docs/help-fastapi.md index 35d2e7b84..a15e18191 100644 --- a/docs/en/docs/help-fastapi.md +++ b/docs/en/docs/help-fastapi.md @@ -1,4 +1,4 @@ -# Help FastAPI - Get Help +# Help FastAPI - Get Help { #help-fastapi-get-help } Do you like **FastAPI**? @@ -10,7 +10,7 @@ There are very simple ways to help (several involve just one or two clicks). And there are several ways to get help too. -## Subscribe to the newsletter +## Subscribe to the newsletter { #subscribe-to-the-newsletter } You can subscribe to the (infrequent) [**FastAPI and friends** newsletter](newsletter.md){.internal-link target=_blank} to stay updated about: @@ -20,17 +20,17 @@ You can subscribe to the (infrequent) [**FastAPI and friends** newsletter](newsl * Breaking changes 🚨 * Tips and tricks ✅ -## Follow FastAPI on Twitter +## Follow FastAPI on Twitter { #follow-fastapi-on-twitter } Follow @fastapi on **Twitter** to get the latest news about **FastAPI**. 🐦 -## Star **FastAPI** in GitHub +## Star **FastAPI** in GitHub { #star-fastapi-in-github } You can "star" FastAPI in GitHub (clicking the star button at the top right): https://github.com/fastapi/fastapi. ⭐️ By adding a star, other users will be able to find it more easily and see that it has been already useful for others. -## Watch the GitHub repository for releases +## Watch the GitHub repository for releases { #watch-the-github-repository-for-releases } You can "watch" FastAPI in GitHub (clicking the "watch" button at the top right): https://github.com/fastapi/fastapi. 👀 @@ -38,7 +38,7 @@ There you can select "Releases only". By doing it, you will receive notifications (in your email) whenever there's a new release (a new version) of **FastAPI** with bug fixes and new features. -## Connect with the author +## Connect with the author { #connect-with-the-author } You can connect with me (Sebastián Ramírez / `tiangolo`), the author. @@ -57,19 +57,19 @@ You can: * Read other ideas, articles, and read about tools I have created. * Follow me to read when I publish something new. -## Tweet about **FastAPI** +## Tweet about **FastAPI** { #tweet-about-fastapi } Tweet about **FastAPI** and let me and others know why you like it. 🎉 I love to hear about how **FastAPI** is being used, what you have liked in it, in which project/company are you using it, etc. -## Vote for FastAPI +## Vote for FastAPI { #vote-for-fastapi } * Vote for **FastAPI** in Slant. * Vote for **FastAPI** in AlternativeTo. * Say you use **FastAPI** on StackShare. -## Help others with questions in GitHub +## Help others with questions in GitHub { #help-others-with-questions-in-github } You can try and help others with their questions in: @@ -88,7 +88,7 @@ The idea is for the **FastAPI** community to be kind and welcoming. At the same Here's how to help others with questions (in discussions or issues): -### Understand the question +### Understand the question { #understand-the-question } * Check if you can understand what is the **purpose** and use case of the person asking. @@ -98,7 +98,7 @@ Here's how to help others with questions (in discussions or issues): * If you can't understand the question, ask for more **details**. -### Reproduce the problem +### Reproduce the problem { #reproduce-the-problem } For most of the cases and most of the questions there's something related to the person's **original code**. @@ -108,13 +108,13 @@ In many cases they will only copy a fragment of the code, but that's not enough * If you are feeling too generous, you can try to **create an example** like that yourself, just based on the description of the problem. Just keep in mind that this might take a lot of time and it might be better to ask them to clarify the problem first. -### Suggest solutions +### Suggest solutions { #suggest-solutions } * After being able to understand the question, you can give them a possible **answer**. * In many cases, it's better to understand their **underlying problem or use case**, because there might be a better way to solve it than what they are trying to do. -### Ask to close +### Ask to close { #ask-to-close } If they reply, there's a high chance you would have solved their problem, congrats, **you're a hero**! 🦸 @@ -123,7 +123,7 @@ If they reply, there's a high chance you would have solved their problem, congra * In GitHub Discussions: mark the comment as the **answer**. * In GitHub Issues: **close** the issue. -## Watch the GitHub repository +## Watch the GitHub repository { #watch-the-github-repository } You can "watch" FastAPI in GitHub (clicking the "watch" button at the top right): https://github.com/fastapi/fastapi. 👀 @@ -131,7 +131,7 @@ If you select "Watching" instead of "Releases only" you will receive notificatio Then you can try and help them solve those questions. -## Ask Questions +## Ask Questions { #ask-questions } You can create a new question in the GitHub repository, for example to: @@ -140,7 +140,7 @@ You can Discord chat server 👥 and hang out with others in the FastAPI community. @@ -237,7 +237,7 @@ Use the chat only for other general conversations. /// -### Don't use the chat for questions +### Don't use the chat for questions { #don-t-use-the-chat-for-questions } Keep in mind that as chats allow more "free conversation", it's easy to ask questions that are too general and more difficult to answer, so, you might not receive answers. @@ -247,7 +247,7 @@ Conversations in the chat systems are also not as easily searchable as in GitHub On the other side, there are thousands of users in the chat systems, so there's a high chance you'll find someone to talk to there, almost all the time. 😄 -## Sponsor the author +## Sponsor the author { #sponsor-the-author } If your **product/company** depends on or is related to **FastAPI** and you want to reach its users, you can sponsor the author (me) through GitHub sponsors. Depending on the tier, you could get some extra benefits, like a badge in the docs. 🎁 diff --git a/docs/en/docs/history-design-future.md b/docs/en/docs/history-design-future.md index b4a744d64..2182c415c 100644 --- a/docs/en/docs/history-design-future.md +++ b/docs/en/docs/history-design-future.md @@ -1,4 +1,4 @@ -# History, Design and Future +# History, Design and Future { #history-design-and-future } Some time ago, a **FastAPI** user asked: @@ -6,7 +6,7 @@ Some time ago, **Pydantic** for its advantages. @@ -60,11 +60,11 @@ Then I contributed to it, to make it fully compliant with JSON Schema, to suppor During the development, I also contributed to **Starlette**, the other key requirement. -## Development +## Development { #development } By the time I started creating **FastAPI** itself, most of the pieces were already in place, the design was defined, the requirements and tools were ready, and the knowledge about the standards and specifications was clear and fresh. -## Future +## Future { #future } By this point, it's already clear that **FastAPI** with its ideas is being useful for many people. diff --git a/docs/en/docs/how-to/conditional-openapi.md b/docs/en/docs/how-to/conditional-openapi.md index bd6cad9a8..833123e6a 100644 --- a/docs/en/docs/how-to/conditional-openapi.md +++ b/docs/en/docs/how-to/conditional-openapi.md @@ -1,8 +1,8 @@ -# Conditional OpenAPI +# Conditional OpenAPI { #conditional-openapi } If you needed to, you could use settings and environment variables to configure OpenAPI conditionally depending on the environment, and even disable it entirely. -## About security, APIs, and docs +## About security, APIs, and docs { #about-security-apis-and-docs } Hiding your documentation user interfaces in production *shouldn't* be the way to protect your API. @@ -23,7 +23,7 @@ If you want to secure your API, there are several better things you can do, for Nevertheless, you might have a very specific use case where you really need to disable the API docs for some environment (e.g. for production) or depending on configurations from environment variables. -## Conditional OpenAPI from settings and env vars +## Conditional OpenAPI from settings and env vars { #conditional-openapi-from-settings-and-env-vars } You can easily use the same Pydantic settings to configure your generated OpenAPI and the docs UIs. diff --git a/docs/en/docs/how-to/configure-swagger-ui.md b/docs/en/docs/how-to/configure-swagger-ui.md index a8a8de48f..2d7b99f8f 100644 --- a/docs/en/docs/how-to/configure-swagger-ui.md +++ b/docs/en/docs/how-to/configure-swagger-ui.md @@ -1,4 +1,4 @@ -# Configure Swagger UI +# Configure Swagger UI { #configure-swagger-ui } You can configure some extra Swagger UI parameters. @@ -8,7 +8,7 @@ To configure them, pass the `swagger_ui_parameters` argument when creating the ` FastAPI converts the configurations to **JSON** to make them compatible with JavaScript, as that's what Swagger UI needs. -## Disable Syntax Highlighting +## Disable Syntax Highlighting { #disable-syntax-highlighting } For example, you could disable syntax highlighting in Swagger UI. @@ -24,7 +24,7 @@ But you can disable it by setting `syntaxHighlight` to `False`: -## Change the Theme +## Change the Theme { #change-the-theme } The same way you could set the syntax highlighting theme with the key `"syntaxHighlight.theme"` (notice that it has a dot in the middle): @@ -34,7 +34,7 @@ That configuration would change the syntax highlighting color theme: -## Change Default Swagger UI Parameters +## Change Default Swagger UI Parameters { #change-default-swagger-ui-parameters } FastAPI includes some default configuration parameters appropriate for most of the use cases. @@ -48,11 +48,11 @@ For example, to disable `deepLinking` you could pass these settings to `swagger_ {* ../../docs_src/configure_swagger_ui/tutorial003.py hl[3] *} -## Other Swagger UI Parameters +## Other Swagger UI Parameters { #other-swagger-ui-parameters } To see all the other possible configurations you can use, read the official docs for Swagger UI parameters. -## JavaScript-only settings +## JavaScript-only settings { #javascript-only-settings } Swagger UI also allows other configurations to be **JavaScript-only** objects (for example, JavaScript functions). diff --git a/docs/en/docs/how-to/custom-docs-ui-assets.md b/docs/en/docs/how-to/custom-docs-ui-assets.md index 9d2238e4f..b38c4ec02 100644 --- a/docs/en/docs/how-to/custom-docs-ui-assets.md +++ b/docs/en/docs/how-to/custom-docs-ui-assets.md @@ -1,4 +1,4 @@ -# Custom Docs UI Static Assets (Self-Hosting) +# Custom Docs UI Static Assets (Self-Hosting) { #custom-docs-ui-static-assets-self-hosting } The API docs use **Swagger UI** and **ReDoc**, and each of those need some JavaScript and CSS files. @@ -6,13 +6,13 @@ By default, those files are served from a CDN, for example you want to use `https://unpkg.com/`. This could be useful if for example you live in a country that restricts some URLs. -### Disable the automatic docs +### Disable the automatic docs { #disable-the-automatic-docs } The first step is to disable the automatic docs, as by default, those use the default CDN. @@ -20,7 +20,7 @@ To disable them, set their URLs to `None` when creating your `FastAPI` app: {* ../../docs_src/custom_docs_ui/tutorial001.py hl[8] *} -### Include the custom docs +### Include the custom docs { #include-the-custom-docs } Now you can create the *path operations* for the custom docs. @@ -46,23 +46,23 @@ Swagger UI will handle it behind the scenes for you, but it needs this "redirect /// -### Create a *path operation* to test it +### Create a *path operation* to test it { #create-a-path-operation-to-test-it } Now, to be able to test that everything works, create a *path operation*: {* ../../docs_src/custom_docs_ui/tutorial001.py hl[36:38] *} -### Test it +### Test it { #test-it } Now, you should be able to go to your docs at http://127.0.0.1:8000/docs, and reload the page, it will load those assets from the new CDN. -## Self-hosting JavaScript and CSS for docs +## Self-hosting JavaScript and CSS for docs { #self-hosting-javascript-and-css-for-docs } Self-hosting the JavaScript and CSS could be useful if, for example, you need your app to keep working even while offline, without open Internet access, or in a local network. Here you'll see how to serve those files yourself, in the same FastAPI app, and configure the docs to use them. -### Project file structure +### Project file structure { #project-file-structure } Let's say your project file structure looks like this: @@ -85,7 +85,7 @@ Your new file structure could look like this: └── static/ ``` -### Download the files +### Download the files { #download-the-files } Download the static files needed for the docs and put them on that `static/` directory. @@ -113,14 +113,14 @@ After that, your file structure could look like: └── swagger-ui.css ``` -### Serve the static files +### Serve the static files { #serve-the-static-files } * Import `StaticFiles`. * "Mount" a `StaticFiles()` instance in a specific path. {* ../../docs_src/custom_docs_ui/tutorial002.py hl[7,11] *} -### Test the static files +### Test the static files { #test-the-static-files } Start your application and go to http://127.0.0.1:8000/static/redoc.standalone.js. @@ -138,7 +138,7 @@ That confirms that you are being able to serve static files from your app, and t Now we can configure the app to use those static files for the docs. -### Disable the automatic docs for static files +### Disable the automatic docs for static files { #disable-the-automatic-docs-for-static-files } The same as when using a custom CDN, the first step is to disable the automatic docs, as those use the CDN by default. @@ -146,7 +146,7 @@ To disable them, set their URLs to `None` when creating your `FastAPI` app: {* ../../docs_src/custom_docs_ui/tutorial002.py hl[9] *} -### Include the custom docs for static files +### Include the custom docs for static files { #include-the-custom-docs-for-static-files } And the same way as with a custom CDN, now you can create the *path operations* for the custom docs. @@ -172,13 +172,13 @@ Swagger UI will handle it behind the scenes for you, but it needs this "redirect /// -### Create a *path operation* to test static files +### Create a *path operation* to test static files { #create-a-path-operation-to-test-static-files } Now, to be able to test that everything works, create a *path operation*: {* ../../docs_src/custom_docs_ui/tutorial002.py hl[39:41] *} -### Test Static Files UI +### Test Static Files UI { #test-static-files-ui } Now, you should be able to disconnect your WiFi, go to your docs at http://127.0.0.1:8000/docs, and reload the page. diff --git a/docs/en/docs/how-to/custom-request-and-route.md b/docs/en/docs/how-to/custom-request-and-route.md index 9b4160d75..6df24a080 100644 --- a/docs/en/docs/how-to/custom-request-and-route.md +++ b/docs/en/docs/how-to/custom-request-and-route.md @@ -1,4 +1,4 @@ -# Custom Request and APIRoute class +# Custom Request and APIRoute class { #custom-request-and-apiroute-class } In some cases, you may want to override the logic used by the `Request` and `APIRoute` classes. @@ -14,7 +14,7 @@ If you are just starting with **FastAPI** you might want to skip this section. /// -## Use cases +## Use cases { #use-cases } Some use cases include: @@ -22,13 +22,13 @@ Some use cases include: * Decompressing gzip-compressed request bodies. * Automatically logging all request bodies. -## Handling custom request body encodings +## Handling custom request body encodings { #handling-custom-request-body-encodings } Let's see how to make use of a custom `Request` subclass to decompress gzip requests. And an `APIRoute` subclass to use that custom request class. -### Create a custom `GzipRequest` class +### Create a custom `GzipRequest` class { #create-a-custom-gziprequest-class } /// tip @@ -44,7 +44,7 @@ That way, the same route class can handle gzip compressed or uncompressed reques {* ../../docs_src/custom_request_and_route/tutorial001.py hl[8:15] *} -### Create a custom `GzipRoute` class +### Create a custom `GzipRoute` class { #create-a-custom-gziproute-class } Next, we create a custom subclass of `fastapi.routing.APIRoute` that will make use of the `GzipRequest`. @@ -78,7 +78,7 @@ After that, all of the processing logic is the same. But because of our changes in `GzipRequest.body`, the request body will be automatically decompressed when it is loaded by **FastAPI** when needed. -## Accessing the request body in an exception handler +## Accessing the request body in an exception handler { #accessing-the-request-body-in-an-exception-handler } /// tip @@ -98,7 +98,7 @@ If an exception occurs, the`Request` instance will still be in scope, so we can {* ../../docs_src/custom_request_and_route/tutorial002.py hl[16:18] *} -## Custom `APIRoute` class in a router +## Custom `APIRoute` class in a router { #custom-apiroute-class-in-a-router } You can also set the `route_class` parameter of an `APIRouter`: diff --git a/docs/en/docs/how-to/extending-openapi.md b/docs/en/docs/how-to/extending-openapi.md index 26c742c20..5e672665e 100644 --- a/docs/en/docs/how-to/extending-openapi.md +++ b/docs/en/docs/how-to/extending-openapi.md @@ -1,10 +1,10 @@ -# Extending OpenAPI +# Extending OpenAPI { #extending-openapi } There are some cases where you might need to modify the generated OpenAPI schema. In this section you will see how. -## The normal process +## The normal process { #the-normal-process } The normal (default) process, is as follows. @@ -33,31 +33,31 @@ The parameter `summary` is available in OpenAPI 3.1.0 and above, supported by Fa /// -## Overriding the defaults +## Overriding the defaults { #overriding-the-defaults } Using the information above, you can use the same utility function to generate the OpenAPI schema and override each part that you need. For example, let's add ReDoc's OpenAPI extension to include a custom logo. -### Normal **FastAPI** +### Normal **FastAPI** { #normal-fastapi } First, write all your **FastAPI** application as normally: {* ../../docs_src/extending_openapi/tutorial001.py hl[1,4,7:9] *} -### Generate the OpenAPI schema +### Generate the OpenAPI schema { #generate-the-openapi-schema } Then, use the same utility function to generate the OpenAPI schema, inside a `custom_openapi()` function: {* ../../docs_src/extending_openapi/tutorial001.py hl[2,15:21] *} -### Modify the OpenAPI schema +### Modify the OpenAPI schema { #modify-the-openapi-schema } Now you can add the ReDoc extension, adding a custom `x-logo` to the `info` "object" in the OpenAPI schema: {* ../../docs_src/extending_openapi/tutorial001.py hl[22:24] *} -### Cache the OpenAPI schema +### Cache the OpenAPI schema { #cache-the-openapi-schema } You can use the property `.openapi_schema` as a "cache", to store your generated schema. @@ -67,13 +67,13 @@ It will be generated only once, and then the same cached schema will be used for {* ../../docs_src/extending_openapi/tutorial001.py hl[13:14,25:26] *} -### Override the method +### Override the method { #override-the-method } Now you can replace the `.openapi()` method with your new function. {* ../../docs_src/extending_openapi/tutorial001.py hl[29] *} -### Check it +### Check it { #check-it } Once you go to http://127.0.0.1:8000/redoc you will see that you are using your custom logo (in this example, **FastAPI**'s logo): diff --git a/docs/en/docs/how-to/general.md b/docs/en/docs/how-to/general.md index 04367c6b7..934719260 100644 --- a/docs/en/docs/how-to/general.md +++ b/docs/en/docs/how-to/general.md @@ -1,39 +1,39 @@ -# General - How To - Recipes +# General - How To - Recipes { #general-how-to-recipes } Here are several pointers to other places in the docs, for general or frequent questions. -## Filter Data - Security +## Filter Data - Security { #filter-data-security } To ensure that you don't return more data than you should, read the docs for [Tutorial - Response Model - Return Type](../tutorial/response-model.md){.internal-link target=_blank}. -## Documentation Tags - OpenAPI +## Documentation Tags - OpenAPI { #documentation-tags-openapi } To add tags to your *path operations*, and group them in the docs UI, read the docs for [Tutorial - Path Operation Configurations - Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}. -## Documentation Summary and Description - OpenAPI +## Documentation Summary and Description - OpenAPI { #documentation-summary-and-description-openapi } To add a summary and description to your *path operations*, and show them in the docs UI, read the docs for [Tutorial - Path Operation Configurations - Summary and Description](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank}. -## Documentation Response description - OpenAPI +## Documentation Response description - OpenAPI { #documentation-response-description-openapi } To define the description of the response, shown in the docs UI, read the docs for [Tutorial - Path Operation Configurations - Response description](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}. -## Documentation Deprecate a *Path Operation* - OpenAPI +## Documentation Deprecate a *Path Operation* - OpenAPI { #documentation-deprecate-a-path-operation-openapi } To deprecate a *path operation*, and show it in the docs UI, read the docs for [Tutorial - Path Operation Configurations - Deprecation](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}. -## Convert any Data to JSON-compatible +## Convert any Data to JSON-compatible { #convert-any-data-to-json-compatible } To convert any data to JSON-compatible, read the docs for [Tutorial - JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank}. -## OpenAPI Metadata - Docs +## OpenAPI Metadata - Docs { #openapi-metadata-docs } To add metadata to your OpenAPI schema, including a license, version, contact, etc, read the docs for [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md){.internal-link target=_blank}. -## OpenAPI Custom URL +## OpenAPI Custom URL { #openapi-custom-url } To customize the OpenAPI URL (or remove it), read the docs for [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}. -## OpenAPI Docs URLs +## OpenAPI Docs URLs { #openapi-docs-urls } To update the URLs used for the automatically generated docs user interfaces, read the docs for [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}. diff --git a/docs/en/docs/how-to/graphql.md b/docs/en/docs/how-to/graphql.md index 361010736..99b024d39 100644 --- a/docs/en/docs/how-to/graphql.md +++ b/docs/en/docs/how-to/graphql.md @@ -1,4 +1,4 @@ -# GraphQL +# GraphQL { #graphql } As **FastAPI** is based on the **ASGI** standard, it's very easy to integrate any **GraphQL** library also compatible with ASGI. @@ -14,7 +14,7 @@ Make sure you evaluate if the **benefits** for your use case compensate the **dr /// -## GraphQL Libraries +## GraphQL Libraries { #graphql-libraries } Here are some of the **GraphQL** libraries that have **ASGI** support. You could use them with **FastAPI**: @@ -27,7 +27,7 @@ Here are some of the **GraphQL** libraries that have **ASGI** support. You could * Graphene * With starlette-graphene3 -## GraphQL with Strawberry +## GraphQL with Strawberry { #graphql-with-strawberry } If you need or want to work with **GraphQL**, **Strawberry** is the **recommended** library as it has the design closest to **FastAPI's** design, it's all based on **type annotations**. @@ -41,7 +41,7 @@ You can learn more about Strawberry in the Strawberry with FastAPI. -## Older `GraphQLApp` from Starlette +## Older `GraphQLApp` from Starlette { #older-graphqlapp-from-starlette } Previous versions of Starlette included a `GraphQLApp` class to integrate with Graphene. @@ -53,7 +53,7 @@ If you need GraphQL, I still would recommend you check out official GraphQL documentation. diff --git a/docs/en/docs/how-to/index.md b/docs/en/docs/how-to/index.md index 730dce5d5..5a8ce08de 100644 --- a/docs/en/docs/how-to/index.md +++ b/docs/en/docs/how-to/index.md @@ -1,4 +1,4 @@ -# How To - Recipes +# How To - Recipes { #how-to-recipes } Here you will see different recipes or "how to" guides for **several topics**. diff --git a/docs/en/docs/how-to/separate-openapi-schemas.md b/docs/en/docs/how-to/separate-openapi-schemas.md index 9a27638fe..3c78a56d3 100644 --- a/docs/en/docs/how-to/separate-openapi-schemas.md +++ b/docs/en/docs/how-to/separate-openapi-schemas.md @@ -1,4 +1,4 @@ -# Separate OpenAPI Schemas for Input and Output or Not +# Separate OpenAPI Schemas for Input and Output or Not { #separate-openapi-schemas-for-input-and-output-or-not } When using **Pydantic v2**, the generated OpenAPI is a bit more exact and **correct** than before. 😎 @@ -6,13 +6,13 @@ In fact, in some cases, it will even have **two JSON Schemas** in OpenAPI for th Let's see how that works and how to change it if you need to do that. -## Pydantic Models for Input and Output +## Pydantic Models for Input and Output { #pydantic-models-for-input-and-output } Let's say you have a Pydantic model with default values, like this one: {* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py ln[1:7] hl[7] *} -### Model for Input +### Model for Input { #model-for-input } If you use this model as an input like here: @@ -20,7 +20,7 @@ If you use this model as an input like here: ...then the `description` field will **not be required**. Because it has a default value of `None`. -### Input Model in Docs +### Input Model in Docs { #input-model-in-docs } You can confirm that in the docs, the `description` field doesn't have a **red asterisk**, it's not marked as required: @@ -28,7 +28,7 @@ You can confirm that in the docs, the `description` field doesn't have a **red a -### Model for Output +### Model for Output { #model-for-output } But if you use the same model as an output, like here: @@ -36,7 +36,7 @@ But if you use the same model as an output, like here: ...then because `description` has a default value, if you **don't return anything** for that field, it will still have that **default value**. -### Model for Output Response Data +### Model for Output Response Data { #model-for-output-response-data } If you interact with the docs and check the response, even though the code didn't add anything in one of the `description` fields, the JSON response contains the default value (`null`): @@ -55,7 +55,7 @@ Because of that, the JSON Schema for a model can be different depending on if it * for **input** the `description` will **not be required** * for **output** it will be **required** (and possibly `None`, or in JSON terms, `null`) -### Model for Output in Docs +### Model for Output in Docs { #model-for-output-in-docs } You can check the output model in the docs too, **both** `name` and `description` are marked as **required** with a **red asterisk**: @@ -63,7 +63,7 @@ You can check the output model in the docs too, **both** `name` and `description -### Model for Input and Output in Docs +### Model for Input and Output in Docs { #model-for-input-and-output-in-docs } And if you check all the available Schemas (JSON Schemas) in OpenAPI, you will see that there are two, one `Item-Input` and one `Item-Output`. @@ -77,7 +77,7 @@ But for `Item-Output`, `description` is **required**, it has a red asterisk. With this feature from **Pydantic v2**, your API documentation is more **precise**, and if you have autogenerated clients and SDKs, they will be more precise too, with a better **developer experience** and consistency. 🎉 -## Do not Separate Schemas +## Do not Separate Schemas { #do-not-separate-schemas } Now, there are some cases where you might want to have the **same schema for input and output**. @@ -93,7 +93,7 @@ Support for `separate_input_output_schemas` was added in FastAPI `0.102.0`. 🤓 {* ../../docs_src/separate_openapi_schemas/tutorial002_py310.py hl[10] *} -### Same Schema for Input and Output Models in Docs +### Same Schema for Input and Output Models in Docs { #same-schema-for-input-and-output-models-in-docs } And now there will be one single schema for input and output for the model, only `Item`, and it will have `description` as **not required**: diff --git a/docs/en/docs/how-to/testing-database.md b/docs/en/docs/how-to/testing-database.md index d0ed15bca..400fdcfc6 100644 --- a/docs/en/docs/how-to/testing-database.md +++ b/docs/en/docs/how-to/testing-database.md @@ -1,4 +1,4 @@ -# Testing a Database +# Testing a Database { #testing-a-database } You can study about databases, SQL, and SQLModel in the SQLModel docs. 🤓 diff --git a/docs/en/docs/index.md b/docs/en/docs/index.md index 938882d7d..db22ea0f9 100644 --- a/docs/en/docs/index.md +++ b/docs/en/docs/index.md @@ -1,4 +1,4 @@ -# FastAPI +# FastAPI { #fastapi }

- FastAPI + FastAPI

FastAPI-Framework, hochperformant, leicht zu erlernen, schnell zu programmieren, einsatzbereit @@ -27,7 +27,7 @@ --- -**Dokumentation**: https://fastapi.tiangolo.com +**Dokumentation**: https://fastapi.tiangolo.com/de **Quellcode**: https://github.com/fastapi/fastapi @@ -63,7 +63,7 @@ Seine Schlüssel-Merkmale sind: -Andere Sponsoren +Andere Sponsoren ## Meinungen { #opinions } @@ -128,7 +128,7 @@ FastAPI steht auf den Schultern von Giganten: ## Installation { #installation } -Erstellen und aktivieren Sie eine virtuelle Umgebung und installieren Sie dann FastAPI: +Erstellen und aktivieren Sie eine virtuelle Umgebung und installieren Sie dann FastAPI:

@@ -191,7 +191,7 @@ async def read_item(item_id: int, q: Union[str, None] = None): **Hinweis**: -Wenn Sie das nicht kennen, schauen Sie sich den Abschnitt _„In Eile?“_ über `async` und `await` in der Dokumentation an. +Wenn Sie das nicht kennen, schauen Sie sich den Abschnitt _„In Eile?“_ über `async` und `await` in der Dokumentation an. @@ -233,7 +233,7 @@ Der Befehl `fastapi dev` liest Ihre `main.py`-Datei, erkennt die **FastAPI**-App Standardmäßig wird `fastapi dev` mit aktiviertem Auto-Reload für die lokale Entwicklung gestartet. -Sie können mehr darüber in der FastAPI CLI-Dokumentation lesen. +Sie können mehr darüber in der FastAPI CLI-Dokumentation lesen. @@ -251,8 +251,8 @@ Sie haben bereits eine API erstellt, welche: * HTTP-Anfragen auf den _Pfaden_ `/` und `/items/{item_id}` entgegennimmt. * Beide _Pfade_ erhalten `GET` Operationen (auch bekannt als HTTP _Methoden_). -* Der _Pfad_ `/items/{item_id}` hat einen _Pfadparameter_ `item_id`, der ein `int` sein sollte. -* Der _Pfad_ `/items/{item_id}` hat einen optionalen `str` _Query Parameter_ `q`. +* Der _Pfad_ `/items/{item_id}` hat einen _Pfad-Parameter_ `item_id`, der ein `int` sein sollte. +* Der _Pfad_ `/items/{item_id}` hat einen optionalen `str` _Query-Parameter_ `q`. ### Interaktive API-Dokumentation { #interactive-api-docs } @@ -365,7 +365,7 @@ item: Item * Konvertierung von Eingabedaten: Aus dem Netzwerk kommend, zu Python-Daten und -Typen. Lesen von: * JSON. * Pfad-Parametern. - * Abfrage-Parametern. + * Query-Parametern. * Cookies. * Header-Feldern. * Formularen. @@ -427,7 +427,7 @@ Versuchen Sie, diese Zeile zu ändern: ![Editor Unterstützung](https://fastapi.tiangolo.com/img/vscode-completion.png) -Für ein vollständigeres Beispiel, mit weiteren Funktionen, siehe das Tutorial – Benutzerhandbuch. +Für ein vollständigeres Beispiel, mit weiteren Funktionen, siehe das Tutorial – Benutzerhandbuch. **Spoiler-Alarm**: Das Tutorial – Benutzerhandbuch enthält: @@ -448,7 +448,7 @@ Für ein vollständigeres Beispiel, mit weiteren Funktionen, siehe das eines der schnellsten verfügbaren Python-Frameworks, nur hinter Starlette und Uvicorn selbst (intern von FastAPI verwendet). (*) -Um mehr darüber zu erfahren, siehe den Abschnitt Benchmarks. +Um mehr darüber zu erfahren, siehe den Abschnitt Benchmarks. ## Abhängigkeiten { #dependencies } diff --git a/docs/de/docs/tutorial/background-tasks.md b/docs/de/docs/tutorial/background-tasks.md index 5bbe9da79..facd4f6f8 100644 --- a/docs/de/docs/tutorial/background-tasks.md +++ b/docs/de/docs/tutorial/background-tasks.md @@ -1,6 +1,6 @@ # Hintergrundtasks { #background-tasks } -Sie können Hintergrundtasks (deutsch: Hintergrund-Aufgaben) definieren, die *nach* der Rückgabe einer Response ausgeführt werden sollen. +Sie können Hintergrundtasks definieren, die *nach* der Rückgabe einer Response ausgeführt werden sollen. Das ist nützlich für Vorgänge, die nach einem Request ausgeführt werden müssen, bei denen der Client jedoch nicht unbedingt auf den Abschluss des Vorgangs warten muss, bevor er die Response erhält. @@ -71,7 +71,7 @@ Indem Sie nur `BackgroundTasks` (und nicht `BackgroundTask`) verwenden, ist es d Es ist immer noch möglich, `BackgroundTask` allein in FastAPI zu verwenden, aber Sie müssen das Objekt in Ihrem Code erstellen und eine Starlette-`Response` zurückgeben, die es enthält. -Weitere Details finden Sie in der offiziellen Starlette-Dokumentation für Hintergrundtasks. +Weitere Details finden Sie in Starlettes offizieller Dokumentation für Hintergrundtasks. ## Vorbehalt { #caveat } @@ -79,7 +79,7 @@ Wenn Sie umfangreiche Hintergrundberechnungen durchführen müssen und diese nic Sie erfordern in der Regel komplexere Konfigurationen und einen Nachrichten-/Job-Queue-Manager wie RabbitMQ oder Redis, ermöglichen Ihnen jedoch die Ausführung von Hintergrundtasks in mehreren Prozessen und insbesondere auf mehreren Servern. -Wenn Sie jedoch über dieselbe **FastAPI**-Anwendung auf Variablen und Objekte zugreifen oder kleine Hintergrundtasks ausführen müssen (z. B. das Senden einer E-Mail-Benachrichtigung), können Sie einfach `BackgroundTasks` verwenden. +Wenn Sie jedoch über dieselbe **FastAPI**-App auf Variablen und Objekte zugreifen oder kleine Hintergrundtasks ausführen müssen (z. B. das Senden einer E-Mail-Benachrichtigung), können Sie einfach `BackgroundTasks` verwenden. ## Zusammenfassung { #recap } diff --git a/docs/de/docs/tutorial/body.md b/docs/de/docs/tutorial/body.md index 537ebcdbb..403ed3842 100644 --- a/docs/de/docs/tutorial/body.md +++ b/docs/de/docs/tutorial/body.md @@ -1,8 +1,8 @@ # Requestbody { #request-body } -Wenn Sie Daten von einem Client (sagen wir, einem Browser) zu Ihrer API senden müssen, senden Sie sie als **Requestbody** (deutsch: Anfragekörper). +Wenn Sie Daten von einem Client (sagen wir, einem Browser) zu Ihrer API senden müssen, senden Sie sie als **Requestbody**. -Ein **Request**body sind Daten, die vom Client zu Ihrer API gesendet werden. Ein **Response**body (deutsch: Antwortkörper) sind Daten, die Ihre API zum Client sendet. +Ein **Request**body sind Daten, die vom Client zu Ihrer API gesendet werden. Ein **Response**body sind Daten, die Ihre API zum Client sendet. Ihre API muss fast immer einen **Response**body senden. Aber Clients müssen nicht unbedingt immer **Requestbodys** senden, manchmal fordern sie nur einen Pfad an, vielleicht mit einigen Query-Parametern, aber senden keinen Body. diff --git a/docs/de/docs/tutorial/cors.md b/docs/de/docs/tutorial/cors.md index eee790cbd..e7a771260 100644 --- a/docs/de/docs/tutorial/cors.md +++ b/docs/de/docs/tutorial/cors.md @@ -1,10 +1,10 @@ # CORS (Cross-Origin Resource Sharing) { #cors-cross-origin-resource-sharing } -CORS oder „Cross-Origin Resource Sharing“ (deutsch: Ursprungsübergreifende Ressourcenfreigabe) bezieht sich auf Situationen, in denen ein Frontend, das in einem Browser läuft, JavaScript-Code enthält, der mit einem Backend kommuniziert, und das Backend sich in einem anderen „Origin“ als das Frontend befindet. +CORS oder „Cross-Origin Resource Sharing“ bezieht sich auf Situationen, in denen ein Frontend, das in einem Browser läuft, JavaScript-Code enthält, der mit einem Backend kommuniziert, und das Backend sich in einem anderen „Origin“ als das Frontend befindet. ## Origin { #origin } -Ein Origin (deutsch: Ursprung) ist die Kombination aus Protokoll (`http`, `https`), Domain (`myapp.com`, `localhost`, `localhost.tiangolo.com`) und Port (`80`, `443`, `8080`). +Ein Origin ist die Kombination aus Protokoll (`http`, `https`), Domain (`myapp.com`, `localhost`, `localhost.tiangolo.com`) und Port (`80`, `443`, `8080`). Alle folgenden sind also unterschiedliche Origins: diff --git a/docs/de/docs/tutorial/path-operation-configuration.md b/docs/de/docs/tutorial/path-operation-configuration.md index 6ef2ab3dd..158abe57f 100644 --- a/docs/de/docs/tutorial/path-operation-configuration.md +++ b/docs/de/docs/tutorial/path-operation-configuration.md @@ -50,7 +50,7 @@ In diesem Fall macht es Sinn, die Tags in einem `Enum` zu speichern. ## Zusammenfassung und Beschreibung { #summary-and-description } -Sie können eine `summary` (deutsch: Zusammenfassung) und eine `description` (deutsch: Beschreibung) hinzufügen: +Sie können eine `summary` und eine `description` hinzufügen: {* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[18:19] *} diff --git a/docs/de/docs/tutorial/path-params-numeric-validations.md b/docs/de/docs/tutorial/path-params-numeric-validations.md index 75a1e548b..664a95fc1 100644 --- a/docs/de/docs/tutorial/path-params-numeric-validations.md +++ b/docs/de/docs/tutorial/path-params-numeric-validations.md @@ -4,7 +4,7 @@ So wie Sie mit `Query` für Query-Parameter zusätzliche Validierungen und Metad ## `Path` importieren { #import-path } -Importieren Sie zuerst `Path` von `fastapi`, und importieren Sie `Annotated`. +Importieren Sie zuerst `Path` von `fastapi`, und importieren Sie `Annotated`: {* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[1,3] *} @@ -32,7 +32,7 @@ Ein Pfad-Parameter ist immer erforderlich, da er Teil des Pfads sein muss. Selbs /// -## Sortieren Sie die Parameter, wie Sie möchten { #order-the-parameters-as-you-need } +## Die Parameter sortieren, wie Sie möchten { #order-the-parameters-as-you-need } /// tip | Tipp @@ -70,7 +70,7 @@ Aber bedenken Sie, dass Sie dieses Problem nicht haben, wenn Sie `Annotated` ver {* ../../docs_src/path_params_numeric_validations/tutorial002_an_py39.py *} -## Sortieren Sie die Parameter wie Sie möchten: Tricks { #order-the-parameters-as-you-need-tricks } +## Die Parameter sortieren, wie Sie möchten: Tricks { #order-the-parameters-as-you-need-tricks } /// tip | Tipp @@ -105,7 +105,7 @@ Bedenken Sie, dass Sie, wenn Sie `Annotated` verwenden, da Sie keine Funktionspa Mit `Query` und `Path` (und anderen, die Sie später sehen werden) können Sie Zahlenbeschränkungen deklarieren. -Hier, mit `ge=1`, muss `item_id` eine ganze Zahl sein, die „`g`reater than or `e`qual to“ `1` ist (deutsch: größer oder gleich). +Hier, mit `ge=1`, muss `item_id` eine ganze Zahl sein, die „`g`reater than or `e`qual to“ (größer oder gleich) `1` ist. {* ../../docs_src/path_params_numeric_validations/tutorial004_an_py39.py hl[10] *} @@ -113,14 +113,14 @@ Hier, mit `ge=1`, muss `item_id` eine ganze Zahl sein, die „`g`reater than or Das Gleiche gilt für: -* `gt`: `g`reater `t`han (deutsch: größer als) -* `le`: `l`ess than or `e`qual (deutsch: kleiner oder gleich) +* `gt`: `g`reater `t`han (größer als) +* `le`: `l`ess than or `e`qual (kleiner oder gleich) {* ../../docs_src/path_params_numeric_validations/tutorial005_an_py39.py hl[10] *} ## Validierung von Zahlen: Floats, größer und kleiner { #number-validations-floats-greater-than-and-less-than } -Zahlenvalidierung funktioniert auch für `float`-Werte (deutsch: Fließkommazahlen). +Zahlenvalidierung funktioniert auch für `float`-Werte. Hier wird es wichtig, in der Lage zu sein, gt und nicht nur ge zu deklarieren. Da Sie mit dieser Option erzwingen können, dass ein Wert größer als `0` sein muss, selbst wenn er kleiner als `1` ist. @@ -136,10 +136,10 @@ Mit `Query`, `Path` (und anderen, die Sie noch nicht gesehen haben) können Sie Und Sie können auch Zahlenvalidierungen deklarieren: -* `gt`: `g`reater `t`han (deutsch: größer als) -* `ge`: `g`reater than or `e`qual (deutsch: größer oder gleich) -* `lt`: `l`ess `t`han (deutsch: kleiner als) -* `le`: `l`ess than or `e`qual (deutsch: kleiner oder gleich) +* `gt`: `g`reater `t`han (größer als) +* `ge`: `g`reater than or `e`qual (größer oder gleich) +* `lt`: `l`ess `t`han (kleiner als) +* `le`: `l`ess than or `e`qual (kleiner oder gleich) /// info | Info diff --git a/docs/de/docs/tutorial/query-params.md b/docs/de/docs/tutorial/query-params.md index bec682b65..ae5d92603 100644 --- a/docs/de/docs/tutorial/query-params.md +++ b/docs/de/docs/tutorial/query-params.md @@ -4,7 +4,7 @@ Wenn Sie in Ihrer Funktion andere Parameter deklarieren, die nicht Teil der Pfad {* ../../docs_src/query_params/tutorial001.py hl[9] *} -Die Query (deutsch: Abfrage) ist die Menge von Schlüssel-Wert-Paaren, die nach dem `?` in einer URL folgen und durch `&`-Zeichen getrennt sind. +Die Query ist die Menge von Schlüssel-Wert-Paaren, die nach dem `?` in einer URL folgen und durch `&`-Zeichen getrennt sind. Zum Beispiel sind in der URL: diff --git a/docs/de/docs/tutorial/request-files.md b/docs/de/docs/tutorial/request-files.md index 6d128a6ac..e22bcb235 100644 --- a/docs/de/docs/tutorial/request-files.md +++ b/docs/de/docs/tutorial/request-files.md @@ -59,7 +59,7 @@ Definieren Sie einen Datei-Parameter mit dem Typ `UploadFile`: `UploadFile` zu verwenden, hat mehrere Vorzüge gegenüber `bytes`: * Sie müssen `File()` nicht als Parameter-Defaultwert verwenden. -* Es wird eine „gespoolte“ Datei (deutsch: warteschlangenartig) verwendet: +* Es wird eine „gespoolte“ Datei verwendet: * Eine Datei, die bis zu einem bestimmten Größen-Limit im Arbeitsspeicher behalten wird, und wenn das Limit überschritten wird, auf der Festplatte gespeichert wird. * Das bedeutet, es wird für große Dateien wie Bilder, Videos, große Binärdateien, usw. gut funktionieren, ohne den ganzen Arbeitsspeicher aufzubrauchen. * Sie können Metadaten aus der hochgeladenen Datei auslesen. diff --git a/docs/de/docs/tutorial/request-forms.md b/docs/de/docs/tutorial/request-forms.md index da83caa5a..1d7a7c235 100644 --- a/docs/de/docs/tutorial/request-forms.md +++ b/docs/de/docs/tutorial/request-forms.md @@ -52,7 +52,7 @@ HTML-Formulare (`
`) senden die Daten in einer „speziellen“ Kodi /// note | Technische Details -Daten aus Formularen werden normalerweise mit dem „media type“ (deutsch: Medientyp) `application/x-www-form-urlencoded` kodiert. +Daten aus Formularen werden normalerweise mit dem „media type“ `application/x-www-form-urlencoded` kodiert. Wenn das Formular stattdessen Dateien enthält, werden diese mit `multipart/form-data` kodiert. Im nächsten Kapitel erfahren Sie mehr über die Handhabung von Dateien. diff --git a/docs/de/docs/tutorial/sql-databases.md b/docs/de/docs/tutorial/sql-databases.md index 124962d2d..ab93b029c 100644 --- a/docs/de/docs/tutorial/sql-databases.md +++ b/docs/de/docs/tutorial/sql-databases.md @@ -91,7 +91,7 @@ Dann fügen wir eine Funktion hinzu, die `SQLModel.metadata.create_all(engine)` ### Eine Session-Abhängigkeit erstellen -Eine **`Session`** (deutsch: Sitzung) speichert die **Objekte im Speicher** und verfolgt alle Änderungen, die an den Daten vorgenommen werden müssen, dann **verwendet sie die `engine`**, um mit der Datenbank zu kommunizieren. +Eine **`Session`** speichert die **Objekte im Speicher** und verfolgt alle Änderungen, die an den Daten vorgenommen werden müssen, dann **verwendet sie die `engine`**, um mit der Datenbank zu kommunizieren. Wir werden eine FastAPI **Abhängigkeit** mit `yield` erstellen, die eine neue `Session` für jede Anfrage bereitstellt. Das ist es, was sicherstellt, dass wir eine einzige Session pro Anfrage verwenden. 🤓 diff --git a/docs/de/docs/virtual-environments.md b/docs/de/docs/virtual-environments.md index 3424adece..6ce687dfc 100644 --- a/docs/de/docs/virtual-environments.md +++ b/docs/de/docs/virtual-environments.md @@ -1,6 +1,6 @@ # Virtuelle Umgebungen { #virtual-environments } -Wenn Sie an Python-Projekten arbeiten, sollten Sie wahrscheinlich eine **virtuelle Umgebung** (oder einen ähnlichen Mechanismus) verwenden, um die Packages (deutsch: Pakete), die Sie für jedes Projekt installieren, zu isolieren. +Wenn Sie an Python-Projekten arbeiten, sollten Sie wahrscheinlich eine **virtuelle Umgebung** (oder einen ähnlichen Mechanismus) verwenden, um die Packages, die Sie für jedes Projekt installieren, zu isolieren. /// info | Info @@ -37,15 +37,15 @@ Und darin erstelle ich ein Verzeichnis pro Projekt.
```console -// Zum Home-Verzeichnis wechseln +// Gehe zum Home-Verzeichnis $ cd -// Ein Verzeichnis für alle Ihre Codeprojekte erstellen +// Erstelle ein Verzeichnis für alle Ihre Code-Projekte $ mkdir code -// In dieses Codeverzeichnis gehen +// Gehe in dieses Code-Verzeichnis $ cd code -// Ein Verzeichnis für dieses Projekt erstellen +// Erstelle ein Verzeichnis für dieses Projekt $ mkdir awesome-project -// In dieses Projektverzeichnis gehen +// Gehe in dieses Projektverzeichnis $ cd awesome-project ``` @@ -53,7 +53,7 @@ $ cd awesome-project ## Eine virtuelle Umgebung erstellen { #create-a-virtual-environment } -Wenn Sie zum **ersten Mal** an einem Python-Projekt arbeiten, erstellen Sie eine virtuelle Umgebung **innerhalb Ihres Projekts**. +Wenn Sie zum **ersten Mal** an einem Python-Projekt arbeiten, erstellen Sie eine virtuelle Umgebung **innerhalb Ihres Projekts**. /// tip | Tipp @@ -166,7 +166,7 @@ $ source .venv/Scripts/activate Jedes Mal, wenn Sie ein **neues Paket** in dieser Umgebung installieren, aktivieren Sie die Umgebung erneut. -So stellen Sie sicher, dass, wenn Sie ein **Terminalprogramm (CLI)** verwenden, das durch dieses Paket installiert wurde, Sie das aus Ihrer virtuellen Umgebung verwenden und nicht eines, das global installiert ist, wahrscheinlich mit einer anderen Version als der, die Sie benötigen. +So stellen Sie sicher, dass, wenn Sie ein **Terminalprogramm (CLI)** verwenden, das durch dieses Paket installiert wurde, Sie das aus Ihrer virtuellen Umgebung verwenden und nicht eines, das global installiert ist, wahrscheinlich mit einer anderen Version als der, die Sie benötigen. /// @@ -480,7 +480,7 @@ flowchart LR subgraph global[globale Umgebung] harry-1[harry v1] end - subgraph stone-project[philosophers-stone Projekt] + subgraph stone-project[philosophers-stone-Projekt] stone(philosophers-stone) -->|benötigt| harry-1 end ``` @@ -506,10 +506,10 @@ flowchart LR style harry-1 fill:#ccc,stroke-dasharray: 5 5 harry-3[harry v3] end - subgraph stone-project[philosophers-stone Projekt] + subgraph stone-project[philosophers-stone-Projekt] stone(philosophers-stone) -.-x|⛔️| harry-1 end - subgraph azkaban-project[prisoner-of-azkaban Projekt] + subgraph azkaban-project[prisoner-of-azkaban-Projekt] azkaban(prisoner-of-azkaban) --> |benötigt| harry-3 end ``` @@ -560,13 +560,13 @@ Auf diese Weise hat jedes Projekt seine eigene virtuelle Umgebung (`.venv`-Verze ```mermaid flowchart TB - subgraph stone-project[philosophers-stone Projekt] + subgraph stone-project[philosophers-stone-Projekt] stone(philosophers-stone) --->|benötigt| harry-1 subgraph venv1[.venv] harry-1[harry v1] end end - subgraph azkaban-project[prisoner-of-azkaban Projekt] + subgraph azkaban-project[prisoner-of-azkaban-Projekt] azkaban(prisoner-of-azkaban) --->|benötigt| harry-3 subgraph venv2[.venv] harry-3[harry v3] @@ -750,7 +750,7 @@ Sie verwenden `which` auf Linux und macOS und `Get-Command` in Windows PowerShel So funktioniert dieser Befehl: Er wird in der `PATH`-Umgebungsvariable nachsehen und **jeden Pfad in der Reihenfolge durchgehen**, um das Programm namens `python` zu finden. Sobald er es findet, wird er Ihnen **den Pfad** zu diesem Programm anzeigen. -Der wichtigste Punkt ist, dass, wenn Sie `python` aufrufen, genau dieses "`python`" ausgeführt wird. +Der wichtigste Punkt ist, dass, wenn Sie `python` aufrufen, genau dieses „`python`“ ausgeführt wird. So können Sie überprüfen, ob Sie sich in der richtigen virtuellen Umgebung befinden. @@ -797,7 +797,7 @@ Traceback (most recent call last):
-Wenn Sie jedoch die virtuelle Umgebung deaktivieren und die neue für `prisoner-of-azkaban` aktivieren, wird beim Ausführen von `python` das Python aus der virtuellen Umgebung in `prisoner-of-azkaban` verwendet. +Wenn Sie jedoch die virtuelle Umgebung deaktivieren und die neue für `prisoner-of-askaban` aktivieren, wird beim Ausführen von `python` das Python aus der virtuellen Umgebung in `prisoner-of-azkaban` verwendet.
diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index 25c95ccb2..548fe6f37 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -1,11 +1,12 @@ -Translate to German (Deutsch). +1) Translate to German (Deutsch). Language code: de. -Use the formal grammar (use "Sie" instead of "Du"). +2) Use the formal grammar (use "Sie" instead of "Du"). -Translate quotation marks ("") in the English text with typographic quotation marks („“) in the German translation. + +3) Translate quotation marks ("") in the English source with typographic quotation marks („“) in the German translation. Example: @@ -17,38 +18,145 @@ Result (German): „Wort“ -But don't do that when the quotation marks are themselves surrounded by backticks (`). +But do not do that when the quotation marks are surrounded by backticks (`), speak, when they are inside a code snippet, see earlier defined rule. -Example: +Three Examples: -Source (English): +Source (English) – These are three code snippets: `"word"` +`"me"` +`"items"` -Result (German) – You don't translate the word, and you don't change the quotation marks: +Result (German) – You change nothing: `"word"` +`"me"` +`"items"` + +Do not randomly add normal or typographic quotation marks into the German translation. -Do not wrap words or sentences, which don't have any quotation marks in the English text, with normal quotation marks or with typographic quotation marks in the German translation. +4) Translate HTML abbr elements as follows: -In sentences, keep translations in brackets. DO NOT REMOVE THEM. Translations in brackets start with the exact text `(deutsch: `, speak, an opening bracket (`(`), followed by the text `deutsch`, followed by a colon (`:`), followed by a space (` `). And they end with a closing bracket (`)`) For example, keep `(deutsch: Anfragekörper)`, keep `(deutsch: Arbeiter)`, keep `(deutsch: Bereitstellen der Anwendung)`. Keep them even if they are not in the English text. Keep them, even if you think they are bad translations. The only exception to this rule is when you remove the whole sentence from the translation, because the whole sentence was removed in the English text. In that case also remove that translation in brackets. The reasoning for this rule is that these are one-time translations for English words which the human editor has added to the translation, in order to explain that word to the human readers of the translation. So these additions should be kept, even though they are not part of the English text. +4.1) If the title attribute gives the full phrase for an abbrevation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase. +Examples: + +Source (English): -In `abbr` HTML-elements, translate the content of the `title` attribute. +IoT +CPU +TL;DR: -Example: +Result (German): + +IoT +CPU +TL;DR: + +Conversion scheme title attribute: + +Source (English): + +{full phrase} + +Result (German): + +{full phrase} – {translation of full phrase} + +If the phrase can not be translated or it is the same in the translation, then keep the title attribute as is. + +Examples: + +Source (English): + +JWT +`Enum` + +Result (German): + +JWT +`Enum` + +Conversion scheme title attribute: + +Source (English): + +{full phrase} + +Result (German): + +{full phrase} + +4.2) If the title attribute explains something in its own words, then translate it, if possible. + +Examples: + +Source (English): + +path +linter +"parsing" +0.95.0 +at the time of writing this + +Result (German): + +Pfad +Linter +„Parsing“ +0.95.0 +zum Zeitpunkt als das hier geschrieben wurde + +Conversion scheme title attribute: + +Source (English): + +{explanation} + +Result (German): + +{translation of explanation} + +4.3) If the title attribute gives the full phrase for an abbrevation, followed by a colon (`:`) or a comma (`,`), followed by an explanation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase, followed by a colon (`:`), followed by the translation of the explanation. + +Examples: + +Source (English): + +I/O +CDN +IDE +"ORMs" + +Result (German): + +I/O +CDN +IDE +„ORMs“ + +Conversion scheme title attribute: + +Source (English): + +{full phrase}: {explanation} + +OR Source (English): -deprecated +{full phrase}, {explanation} Result (German): -deprecated +{full phrase} – {translation of full phrase}: {translation of explanation} + +4.4) If there is an HTML abbr element in a sentence in an existing translation, but that element does not exist in the related sentence in the English text, then keep that HTML abbr element in the translation, do not change or remove it. Except when you remove the whole sentence from the translation, because the whole sentence was removed from the English text. The reasoning for this rule is, that such abbr elements are manually added by the human editor of the translation, in order to translate or explain an English word to the human readers of the translation. They would not make sense in the English text but they do make sense in the translation. So keep them in the translation, even though they are not part of the English text. This rule only applies to HTML abbr elements. -Translate headings using the infinite form. +5) Translate headings using the infinite form. Examples: @@ -89,14 +197,14 @@ Do NOT translate with (German): ### Führen Sie Ihr Programm aus { #run-your-program } -Follow these German instructions: +6) Follow these German instructions: In der Regel versuche ich so weit wie möglich Worte zusammenzuschreiben, also ohne Bindestrich, es sei denn, es ist Konkretesding-Klassevondingen, etwa `Pydantic-Modell` (aber: `Datenbankmodell`), `Python-Modul` (aber: `Standardmodul`). Ich setze auch einen Bindestrich, wenn er die gleichen Buchstaben verbindet, etwa `Enum-Member`, `Cloud-Dienst`, `Template-Engine`. Oder wenn das Wort sonst einfach zu lang wird, etwa, `Performance-Optimierung`. Oder um etwas visuell besser zu dokumentieren, etwa `Pfadoperation-Dekorator`, `Pfadoperation-Funktion`. Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriffe aus dem Bereich der Programmierung. Ich wandele zwar korrekt in Großschreibung um und setze Bindestriche, wo notwendig, aber ansonsten lasse ich solch ein Wort unverändert. Beispielsweise wird aus dem englischen Wort `string` in der deutschen Übersetzung `String`, aber nicht `Zeichenkette`. Oder aus dem englischen Wort `request body` wird in der deutschen Übersetzung `Requestbody`, aber nicht `Anfragekörper`. Oder aus dem englischen `response` wird im Deutschen `Response`, aber nicht `Antwort`. -Below is a list of English terms and their German translations, separated by a colon (`:`). Use these translations, do not use your own. Words inside brackets are explanations for you, they are not part of the term or the translation. If a list item starts with `NOT`, then that means: do NOT use this translation. Nouns, starting with the word `the`, have their German genus – `der`, `die`, `das` – included, to help you to grammatically decline them in the translation, and they are given in singular case unless they have `(plural case)` attached, which means they are given in plural case. Verbs are given in the full infinitive – starting with the word `to`. +7) Below is a list of English terms and their German translations, separated by a colon (`:`). Use these translations, do not use your own. Words inside brackets are explanations for you, they are not part of the term or the translation. If a list item starts with `NOT`, then that means: do NOT use this translation. Nouns, starting with the word `the`, have their German genus – `der`, `die`, `das` – included, to help you to grammatically decline them in the translation, and they are given in singular case unless they have `(plural case)` attached, which means they are given in plural case. Verbs are given in the full infinitive – starting with the word `to`. * /// check: /// check | Testen * /// danger: /// danger | Gefahr @@ -184,4 +292,4 @@ Below is a list of English terms and their German translations, separated by a c * X is case-insensitive: Groß-/Klein­schrei­bung ist nicht relevant in X -Preserve indentation. Keep emoticons. Encode in utf-8. Use Linux line breaks (LF) +8) Preserve indentation. Keep emoticons. Encode in utf-8. Use Linux line breaks (LF) diff --git a/scripts/translate.py b/scripts/translate.py index ad8de6591..d1fc1b288 100644 --- a/scripts/translate.py +++ b/scripts/translate.py @@ -24,32 +24,32 @@ non_translated_sections = ( general_prompt = """ -For technical terms in English that don't have a common translation term use the original term in English. - -If you have instructions to translate specific terms or phrases in a specific way, please follow those instructions instead of keeping the old and outdated content. +For technical terms in English that don't have a common translation term, use the original term in English. For code snippets or fragments, surrounded by backticks (`), don't translate the content, keep the original in English. For example, `list`, `dict`, keep them as is. -The content is written in markdown, write the translation in markdown as well. Don't add triple backticks (`) around the generated translation content. Speak, do not add "```markdown" at the very start of the translation and do not add "```" at the very end of the translation. +The content is written in Markdown, write the translation in Markdown as well. + +When there is a code block, surrounded by triple backticks, do not translate its content, except for comments in the language which the code block uses. -When there's an example of code, the console or a terminal, normally surrounded by triple backticks and a keyword like "console" or "bash" (e.g. ```console), do not translate the content, keep the original in English. +Examples: -For example, if the original (English) content is: +Source (English) – The code block is a bash code example with one comment: ```bash # Print greeting echo "Hello, World!" ``` -It should be exacly the same in the output document: +Result (German): ```bash -# Print greeting +# Gruß ausgeben echo "Hello, World!" ``` -If the original (English) content is: +Source (English) – The code block is a console example containing HTML tags. No comments, nothing to change here: ```console $ fastapi run main.py @@ -57,7 +57,7 @@ $ fastapi run fastapi run main.py @@ -65,8 +65,80 @@ $ fastapi run Algo - 4) For internal links, only translate link text. Example: @@ -213,6 +302,7 @@ Good translation (German) – URL stays like in the English source. Erstelle eine [Virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} + """ app = typer.Typer() @@ -269,7 +359,7 @@ def translate_page( print(f"Found existing translation: {out_path}") old_translation = out_path.read_text(encoding="utf-8") print(f"Translating {en_path} to {language} ({language_name})") - agent = Agent("openai:gpt-4o") + agent = Agent("openai:gpt-5") prompt_segments = [ general_prompt, @@ -302,7 +392,7 @@ def translate_page( prompt = "\n\n".join(prompt_segments) print(f"Running agent for {out_path}") result = agent.run_sync(prompt) - out_content = f"{result.data.strip()}\n" + out_content = f"{result.output.strip()}\n" print(f"Saving translation to {out_path}") out_path.write_text(out_content, encoding="utf-8", newline="\n") From 6f1102320cb650483547520c8d4f917ed571b28e Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 24 Aug 2025 04:49:00 +0200 Subject: [PATCH 114/160] Update tutorial/response-model.md I created this before with GPT-4o, twice as much changes, plus it did not understand some of my rule definitons (Though the prompt was different). So I reverted everything and tried the same with GPT-5. This diff is a joy, only the relevant changes. --- docs/de/docs/tutorial/response-model.md | 71 ++++++++++++++----------- 1 file changed, 40 insertions(+), 31 deletions(-) diff --git a/docs/de/docs/tutorial/response-model.md b/docs/de/docs/tutorial/response-model.md index faf9be516..5b3c189a6 100644 --- a/docs/de/docs/tutorial/response-model.md +++ b/docs/de/docs/tutorial/response-model.md @@ -1,4 +1,4 @@ -# Responsemodell – Rückgabetyp +# Responsemodell – Rückgabetyp { #response-model-return-type } Sie können den Typ der Response deklarieren, indem Sie den **Rückgabetyp** der *Pfadoperation* annotieren. @@ -19,7 +19,7 @@ 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. -## `response_model`-Parameter +## `response_model`-Parameter { #response-model-parameter } Es gibt Fälle, da möchten oder müssen Sie Daten zurückgeben, die nicht genau dem entsprechen, was der Typ deklariert. @@ -41,7 +41,7 @@ Sie können `response_model` in jeder möglichen *Pfadoperation* verwenden: /// note | Hinweis -Beachten Sie, dass `response_model` ein Parameter der „Dekorator“-Methode ist (`get`, `post`, usw.). Nicht der *Pfadoperation-Funktion*, so wie die anderen Parameter. +Beachten Sie, dass `response_model` ein Parameter der „Dekorator“-Methode ist (`get`, `post`, usw.). Nicht der *Pfadoperation-Funktion*, so wie die anderen Parameter und der Body. /// @@ -57,7 +57,7 @@ So sagen Sie dem Editor, dass Sie absichtlich *irgendetwas* zurückgeben. Aber F /// -### `response_model`-Priorität +### `response_model`-Priorität { #response-model-priority } Wenn sowohl Rückgabetyp als auch `response_model` deklariert sind, hat `response_model` die Priorität und wird von FastAPI bevorzugt verwendet. @@ -65,18 +65,27 @@ So können Sie korrekte Typannotationen zu ihrer Funktion hinzufügen, die von i 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. -## Dieselben Eingabedaten zurückgeben +## Dieselben Eingabedaten zurückgeben { #return-the-same-input-data } Im Folgenden deklarieren wir ein `UserIn`-Modell; es enthält ein Klartext-Passwort: {* ../../docs_src/response_model/tutorial002_py310.py hl[7,9] *} -/// info +/// info | Info Um `EmailStr` zu verwenden, installieren Sie zuerst `email-validator`. -Z. B. `pip install email-validator` -oder `pip install pydantic[email]`. +Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und es dann installieren, zum Beispiel: + +```console +$ pip install email-validator +``` + +oder mit: + +```console +$ pip install "pydantic[email]" +``` /// @@ -96,7 +105,7 @@ Speichern Sie niemals das Klartext-Passwort eines Benutzers, oder versenden Sie /// -## Ausgabemodell hinzufügen +## Ausgabemodell hinzufügen { #add-an-output-model } Wir können stattdessen ein Eingabemodell mit dem Klartext-Passwort, und ein Ausgabemodell ohne das Passwort erstellen: @@ -112,7 +121,7 @@ Obwohl unsere *Pfadoperation-Funktion* hier denselben `user` von der Eingabe zur Darum wird **FastAPI** sich darum kümmern, dass alle Daten, die nicht im Ausgabemodell deklariert sind, herausgefiltert werden (mittels Pydantic). -### `response_model` oder Rückgabewert +### `response_model` oder Rückgabewert { #response-model-or-return-type } 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. @@ -120,11 +129,11 @@ 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. -## Rückgabewert und Datenfilterung +## Rückgabewert und Datenfilterung { #return-type-and-data-filtering } -Führen wir unser vorheriges Beispiel fort. Wir wollten **die Funktion mit einem Typ annotieren**, aber etwas zurückgeben, das **weniger Daten** enthält. +Führen wir unser vorheriges Beispiel fort. Wir wollten **die Funktion mit einem Typ annotieren**, aber wir wollten in der Funktion tatsächlich etwas zurückgeben, das **mehr Daten** enthält. -Wir möchten auch, dass FastAPI die Daten weiterhin, dem Responsemodell entsprechend, **filtert**. +Wir möchten, dass FastAPI die Daten weiterhin mithilfe des Responsemodells **filtert**. Selbst wenn die Funktion mehr Daten zurückgibt, soll die Response nur die Felder enthalten, die im Responsemodell deklariert sind. 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. @@ -138,7 +147,7 @@ Damit erhalten wir Tool-Unterstützung, vom Editor und mypy, da dieser Code hins Wie funktioniert das? Schauen wir uns das mal an. 🤓 -### Typannotationen und Tooling +### Typannotationen und Tooling { #type-annotations-and-tooling } Sehen wir uns zunächst an, wie Editor, mypy und andere Tools dies sehen würden. @@ -148,7 +157,7 @@ Wir annotieren den Funktionsrückgabetyp als `BaseUser`, geben aber tatsächlich 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 Datenfilterung +### FastAPI Datenfilterung { #fastapi-data-filtering } 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. @@ -156,7 +165,7 @@ FastAPI macht intern mehrere Dinge mit Pydantic, um sicherzustellen, dass obige Auf diese Weise erhalten Sie das beste beider Welten: Sowohl Typannotationen mit **Tool-Unterstützung** als auch **Datenfilterung**. -## Anzeige in der Dokumentation +## Anzeige in der Dokumentation { #see-it-in-the-docs } Wenn Sie sich die automatische Dokumentation betrachten, können Sie sehen, dass Eingabe- und Ausgabemodell beide ihr eigenes JSON-Schema haben: @@ -166,11 +175,11 @@ Und beide Modelle werden auch in der interaktiven API-Dokumentation verwendet: -## Andere Rückgabetyp-Annotationen +## Andere Rückgabetyp-Annotationen { #other-return-type-annotations } 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.). -### Eine Response direkt zurückgeben +### Eine Response direkt zurückgeben { #return-a-response-directly } Der häufigste Anwendungsfall ist, wenn Sie [eine Response direkt zurückgeben, wie es später im Handbuch für fortgeschrittene Benutzer erläutert wird](../advanced/response-directly.md){.internal-link target=_blank}. @@ -180,7 +189,7 @@ Dieser einfache Anwendungsfall wird automatisch von FastAPI gehandhabt, weil die Und Tools werden auch glücklich sein, weil sowohl `RedirectResponse` als auch `JSONResponse` Unterklassen von `Response` sind, die Typannotation ist daher korrekt. -### Eine Unterklasse von Response annotieren +### Eine Unterklasse von Response annotieren { #annotate-a-response-subclass } Sie können auch eine Unterklasse von `Response` in der Typannotation verwenden. @@ -188,7 +197,7 @@ Sie können auch eine Unterklasse von `Response` in der Typannotation verwenden. Das wird ebenfalls funktionieren, weil `RedirectResponse` eine Unterklasse von `Response` ist, und FastAPI sich um diesen einfachen Anwendungsfall automatisch kümmert. -### Ungültige Rückgabetyp-Annotationen +### Ungültige Rückgabetyp-Annotationen { #invalid-return-type-annotations } 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. @@ -198,7 +207,7 @@ Das gleiche wird passieren, wenn Sie eine Date: Sun, 24 Aug 2025 14:57:18 +0200 Subject: [PATCH 129/160] Update security/first-steps.md --- docs/de/docs/tutorial/security/first-steps.md | 46 +++++++++++-------- 1 file changed, 27 insertions(+), 19 deletions(-) diff --git a/docs/de/docs/tutorial/security/first-steps.md b/docs/de/docs/tutorial/security/first-steps.md index 8fa33db7e..37af6a171 100644 --- a/docs/de/docs/tutorial/security/first-steps.md +++ b/docs/de/docs/tutorial/security/first-steps.md @@ -1,8 +1,8 @@ -# Sicherheit – Erste Schritte +# Sicherheit – Erste Schritte { #security-first-steps } Stellen wir uns vor, dass Sie Ihre **Backend**-API auf einer Domain haben. -Und Sie haben ein **Frontend** auf einer anderen Domain oder in einem anderen Pfad derselben Domain (oder in einer mobilen Anwendung). +Und Sie haben ein **Frontend** auf einer anderen Domain oder in einem anderen Pfad derselben Domain (oder in einer Mobile-Anwendung). Und Sie möchten eine Möglichkeit haben, dass sich das Frontend mithilfe eines **Benutzernamens** und eines **Passworts** beim Backend authentisieren kann. @@ -12,25 +12,33 @@ Aber ersparen wir Ihnen die Zeit, die gesamte lange Spezifikation zu lesen, nur Lassen Sie uns die von **FastAPI** bereitgestellten Tools verwenden, um Sicherheit zu gewährleisten. -## Wie es aussieht +## Wie es aussieht { #how-it-looks } Lassen Sie uns zunächst einfach den Code verwenden und sehen, wie er funktioniert, und dann kommen wir zurück, um zu verstehen, was passiert. -## `main.py` erstellen +## `main.py` erstellen { #create-main-py } Kopieren Sie das Beispiel in eine Datei `main.py`: {* ../../docs_src/security/tutorial001_an_py39.py *} -## Ausführen +## Ausführen { #run-it } -/// info +/// info | Info -Um hochgeladene Dateien zu empfangen, installieren Sie zuerst `python-multipart`. +Das Paket `python-multipart` wird automatisch mit **FastAPI** installiert, wenn Sie den Befehl `pip install "fastapi[standard]"` ausführen. -Z. B. `pip install python-multipart`. +Wenn Sie jedoch den Befehl `pip install fastapi` verwenden, ist das Paket `python-multipart` nicht standardmäßig enthalten. -Das, weil **OAuth2** „Formulardaten“ zum Senden von `username` und `password` verwendet. +Um es manuell zu installieren, stellen Sie sicher, dass Sie eine [Virtuelle Umgebung](../../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und es dann mit: + +```console +$ pip install python-multipart +``` + +installieren. + +Das liegt daran, dass **OAuth2** „Formulardaten“ zum Senden von `username` und `password` verwendet. /// @@ -39,14 +47,14 @@ Führen Sie das Beispiel aus mit:
```console -$ uvicorn main:app --reload +$ fastapi dev main.py INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) ```
-## Überprüfen +## Testen { #check-it } Gehen Sie zu der interaktiven Dokumentation unter: http://127.0.0.1:8000/docs. @@ -80,7 +88,7 @@ Es kann von Anwendungen und Systemen Dritter verwendet werden. Und es kann auch von Ihnen selbst verwendet werden, um dieselbe Anwendung zu debuggen, zu prüfen und zu testen. -## Der `password`-Flow +## Der `password`-Flow { #the-password-flow } Lassen Sie uns nun etwas zurückgehen und verstehen, was das alles ist. @@ -106,13 +114,13 @@ Betrachten wir es also aus dieser vereinfachten Sicht: * Um sich also bei unserer API zu authentifizieren, sendet es einen Header `Authorization` mit dem Wert `Bearer` plus dem Token. * Wenn der Token `foobar` enthielte, wäre der Inhalt des `Authorization`-Headers: `Bearer foobar`. -## **FastAPI**s `OAuth2PasswordBearer` +## **FastAPI**s `OAuth2PasswordBearer` { #fastapis-oauth2passwordbearer } **FastAPI** bietet mehrere Tools auf unterschiedlichen Abstraktionsebenen zur Implementierung dieser Sicherheitsfunktionen. In diesem Beispiel verwenden wir **OAuth2** mit dem **Password**-Flow und einem **Bearer**-Token. Wir machen das mit der Klasse `OAuth2PasswordBearer`. -/// info +/// info | Info Ein „Bearer“-Token ist nicht die einzige Option. @@ -142,7 +150,7 @@ Dieser Parameter erstellt nicht diesen Endpunkt / diese *Pfadoperation*, sondern Wir werden demnächst auch die eigentliche Pfadoperation erstellen. -/// info +/// info | Info Wenn Sie ein sehr strenger „Pythonista“ sind, missfällt Ihnen möglicherweise die Schreibweise des Parameternamens `tokenUrl` anstelle von `token_url`. @@ -160,7 +168,7 @@ oauth2_scheme(some, parameters) Es kann also mit `Depends` verwendet werden. -### Verwendung +### Verwenden { #use-it } Jetzt können Sie dieses `oauth2_scheme` als Abhängigkeit `Depends` übergeben. @@ -178,7 +186,7 @@ Alle Sicherheits-Werkzeuge, die in OpenAPI integriert sind (und die automatische /// -## Was es macht +## Was es macht { #what-it-does } FastAPI wird im Request nach diesem `Authorization`-Header suchen, prüfen, ob der Wert `Bearer` plus ein Token ist, und den Token als `str` zurückgeben. @@ -192,6 +200,6 @@ Sie können das bereits in der interaktiven Dokumentation ausprobieren: Wir überprüfen im Moment noch nicht die Gültigkeit des Tokens, aber das ist bereits ein Anfang. -## Zusammenfassung +## Zusammenfassung { #recap } -Mit nur drei oder vier zusätzlichen Zeilen haben Sie also bereits eine primitive Form der Sicherheit. +Mit nur drei oder vier zusätzlichen Zeilen haben Sie so bereits eine primitive Form der Sicherheit. From 376e580a04f200f548ccb5f7d48b83f9eabae109 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 24 Aug 2025 15:15:32 +0200 Subject: [PATCH 130/160] Intermezzo: `Es testen` --> `Testen` LLM insists on writing it like this and I am fine with it. It is also written like this in the `/// check | Testen` blocks. --- docs/de/docs/advanced/security/oauth2-scopes.md | 2 +- docs/de/docs/advanced/wsgi.md | 2 +- docs/de/docs/deployment/docker.md | 2 +- docs/de/docs/how-to/custom-docs-ui-assets.md | 2 +- docs/de/docs/how-to/extending-openapi.md | 2 +- docs/de/docs/index.md | 2 +- docs/de/docs/tutorial/security/oauth2-jwt.md | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/de/docs/advanced/security/oauth2-scopes.md b/docs/de/docs/advanced/security/oauth2-scopes.md index f85325074..cccb2cbe9 100644 --- a/docs/de/docs/advanced/security/oauth2-scopes.md +++ b/docs/de/docs/advanced/security/oauth2-scopes.md @@ -233,7 +233,7 @@ Da die `SecurityScopes` alle von den Verwendern der Abhängigkeiten deklarierten Diese werden für jede *Pfadoperation* unabhängig überprüft. -## Es testen { #check-it } +## Testen { #check-it } Wenn Sie die API-Dokumentation öffnen, können Sie sich authentisieren und angeben, welche Scopes Sie autorisieren möchten. diff --git a/docs/de/docs/advanced/wsgi.md b/docs/de/docs/advanced/wsgi.md index ff77362c8..a8e783907 100644 --- a/docs/de/docs/advanced/wsgi.md +++ b/docs/de/docs/advanced/wsgi.md @@ -14,7 +14,7 @@ Und dann mounten Sie das auf einem Pfad. {* ../../docs_src/wsgi/tutorial001.py hl[2:3,3] *} -## Es testen { #check-it } +## Testen { #check-it } Jetzt wird jede Anfrage unter dem Pfad `/v1/` von der Flask-Anwendung verarbeitet. diff --git a/docs/de/docs/deployment/docker.md b/docs/de/docs/deployment/docker.md index 27c1b02a5..96a6a9ce1 100644 --- a/docs/de/docs/deployment/docker.md +++ b/docs/de/docs/deployment/docker.md @@ -352,7 +352,7 @@ $ docker run -d --name mycontainer -p 80:80 myimage
-## Es testen { #check-it } +## Testen { #check-it } Sie sollten es in der URL Ihres Docker-Containers überprüfen können, zum Beispiel: http://192.168.99.100/items/5?q=somequery oder http://127.0.0.1/items/5?q=somequery (oder gleichwertig, unter Verwendung Ihres Docker-Hosts). diff --git a/docs/de/docs/how-to/custom-docs-ui-assets.md b/docs/de/docs/how-to/custom-docs-ui-assets.md index d25720e3f..a2601eb5d 100644 --- a/docs/de/docs/how-to/custom-docs-ui-assets.md +++ b/docs/de/docs/how-to/custom-docs-ui-assets.md @@ -52,7 +52,7 @@ Um nun testen zu können, ob alles funktioniert, erstellen Sie eine *Pfadoperati {* ../../docs_src/custom_docs_ui/tutorial001.py hl[36:38] *} -### Es testen { #test-it } +### Testen { #test-it } Jetzt sollten Sie in der Lage sein, zu Ihrer Dokumentation auf http://127.0.0.1:8000/docs zu gehen und die Seite neu zu laden. Die Assets werden nun vom neuen CDN geladen. diff --git a/docs/de/docs/how-to/extending-openapi.md b/docs/de/docs/how-to/extending-openapi.md index ffbbc338f..925eb6e2b 100644 --- a/docs/de/docs/how-to/extending-openapi.md +++ b/docs/de/docs/how-to/extending-openapi.md @@ -73,7 +73,7 @@ Jetzt können Sie die Methode `.openapi()` durch Ihre neue Funktion ersetzen. {* ../../docs_src/extending_openapi/tutorial001.py hl[29] *} -### Es testen { #check-it } +### Testen { #check-it } Sobald Sie auf http://127.0.0.1:8000/redoc gehen, werden Sie sehen, dass Ihr benutzerdefiniertes Logo verwendet wird (in diesem Beispiel das Logo von **FastAPI**): diff --git a/docs/de/docs/index.md b/docs/de/docs/index.md index 8b8042e32..bda5bc53b 100644 --- a/docs/de/docs/index.md +++ b/docs/de/docs/index.md @@ -237,7 +237,7 @@ Sie können mehr darüber in der http://127.0.0.1:8000/items/5?q=somequery. diff --git a/docs/de/docs/tutorial/security/oauth2-jwt.md b/docs/de/docs/tutorial/security/oauth2-jwt.md index 178a95d81..110cf30e5 100644 --- a/docs/de/docs/tutorial/security/oauth2-jwt.md +++ b/docs/de/docs/tutorial/security/oauth2-jwt.md @@ -196,7 +196,7 @@ Deshalb, um ID-Kollisionen zu vermeiden, könnten Sie beim Erstellen des JWT-Tok Der wesentliche Punkt ist, dass der `sub`-Schlüssel in der gesamten Anwendung eine eindeutige Kennung haben sollte, und er sollte ein String sein. -## Es testen +## Testen Führen Sie den Server aus und gehen Sie zur Dokumentation: http://127.0.0.1:8000/docs. From f31c8bda0d862a9367d44b83f640826a5af58187 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 24 Aug 2025 15:17:18 +0200 Subject: [PATCH 131/160] Update security/get-current-user.md --- .../tutorial/security/get-current-user.md | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/docs/de/docs/tutorial/security/get-current-user.md b/docs/de/docs/tutorial/security/get-current-user.md index 38f7ffcbf..5b5675c43 100644 --- a/docs/de/docs/tutorial/security/get-current-user.md +++ b/docs/de/docs/tutorial/security/get-current-user.md @@ -1,4 +1,4 @@ -# Aktuellen Benutzer abrufen +# Aktuellen Benutzer abrufen { #get-current-user } Im vorherigen Kapitel hat das Sicherheitssystem (das auf dem Dependency Injection System basiert) der *Pfadoperation-Funktion* einen `token` vom Typ `str` überreicht: @@ -8,15 +8,15 @@ Aber das ist immer noch nicht so nützlich. Lassen wir es uns den aktuellen Benutzer überreichen. -## Ein Benutzermodell erstellen +## Ein Benutzermodell erstellen { #create-a-user-model } Erstellen wir zunächst ein Pydantic-Benutzermodell. So wie wir Pydantic zum Deklarieren von Bodys verwenden, können wir es auch überall sonst verwenden: -{* ../../docs_src/security/tutorial002_an_py310.py hl[5,12:16] *} +{* ../../docs_src/security/tutorial002_an_py310.py hl[5,12:6] *} -## Eine `get_current_user`-Abhängigkeit erstellen +## Eine `get_current_user`-Abhängigkeit erstellen { #create-a-get-current-user-dependency } Erstellen wir eine Abhängigkeit `get_current_user`. @@ -28,13 +28,13 @@ So wie wir es zuvor in der *Pfadoperation* direkt gemacht haben, erhält unsere {* ../../docs_src/security/tutorial002_an_py310.py hl[25] *} -## Den Benutzer holen +## Den Benutzer abrufen { #get-the-user } `get_current_user` wird eine von uns erstellte (gefakte) Hilfsfunktion verwenden, welche einen Token vom Typ `str` entgegennimmt und unser Pydantic-`User`-Modell zurückgibt: {* ../../docs_src/security/tutorial002_an_py310.py hl[19:22,26:27] *} -## Den aktuellen Benutzer einfügen +## Den aktuellen Benutzer einfügen { #inject-the-current-user } Und jetzt können wir wiederum `Depends` mit unserem `get_current_user` in der *Pfadoperation* verwenden: @@ -52,7 +52,7 @@ Weil Sie `Depends` verwenden, wird **FastAPI** hier aber nicht verwirrt. /// -/// check +/// check | Testen Die Art und Weise, wie dieses System von Abhängigkeiten konzipiert ist, ermöglicht es uns, verschiedene Abhängigkeiten (verschiedene „Dependables“) zu haben, die alle ein `User`-Modell zurückgeben. @@ -60,7 +60,7 @@ Wir sind nicht darauf beschränkt, nur eine Abhängigkeit zu haben, die diesen T /// -## Andere Modelle +## Andere Modelle { #other-models } Sie können jetzt den aktuellen Benutzer direkt in den *Pfadoperation-Funktionen* abrufen und die Sicherheitsmechanismen auf **Dependency Injection** Ebene handhaben, mittels `Depends`. @@ -76,7 +76,7 @@ Sie haben eigentlich keine Benutzer, die sich bei Ihrer Anwendung anmelden, sond Verwenden Sie einfach jede Art von Modell, jede Art von Klasse, jede Art von Datenbank, die Sie für Ihre Anwendung benötigen. **FastAPI** deckt das alles mit seinem Dependency Injection System ab. -## Codegröße +## Codegröße { #code-size } Dieses Beispiel mag ausführlich erscheinen. Bedenken Sie, dass wir Sicherheit, Datenmodelle, Hilfsfunktionen und *Pfadoperationen* in derselben Datei vermischen. @@ -94,7 +94,7 @@ Und alle diese Tausenden von *Pfadoperationen* können nur drei Zeilen lang sein {* ../../docs_src/security/tutorial002_an_py310.py hl[30:32] *} -## Zusammenfassung +## Zusammenfassung { #recap } Sie können jetzt den aktuellen Benutzer direkt in Ihrer *Pfadoperation-Funktion* abrufen. From aac2e8c04cb69bd166270d15fb90806ddc664e54 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 24 Aug 2025 15:24:23 +0200 Subject: [PATCH 132/160] Update tutorial/security/simple-oauth2.md Forgot the `tutorial/` in the messages of the two previous `Update` commits, but it was already pushed. Sorry about that. --- .../docs/tutorial/security/simple-oauth2.md | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/docs/de/docs/tutorial/security/simple-oauth2.md b/docs/de/docs/tutorial/security/simple-oauth2.md index c0c93cd26..d77294cb1 100644 --- a/docs/de/docs/tutorial/security/simple-oauth2.md +++ b/docs/de/docs/tutorial/security/simple-oauth2.md @@ -1,8 +1,8 @@ -# Einfaches OAuth2 mit Password und Bearer +# Einfaches OAuth2 mit Password und Bearer { #simple-oauth2-with-password-and-bearer } Lassen Sie uns nun auf dem vorherigen Kapitel aufbauen und die fehlenden Teile hinzufügen, um einen vollständigen Sicherheits-Flow zu erhalten. -## `username` und `password` entgegennehmen +## `username` und `password` entgegennehmen { #get-the-username-and-password } Wir werden **FastAPIs** Sicherheits-Werkzeuge verwenden, um den `username` und das `password` entgegenzunehmen. @@ -18,7 +18,7 @@ Aber für die Login-*Pfadoperation* müssen wir diese Namen verwenden, um mit de Die Spezifikation besagt auch, dass `username` und `password` als Formulardaten gesendet werden müssen (hier also kein JSON). -### `scope` +### `scope` { #scope } Ferner sagt die Spezifikation, dass der Client ein weiteres Formularfeld "`scope`" („Geltungsbereich“) senden kann. @@ -32,7 +32,7 @@ Diese werden normalerweise verwendet, um bestimmte Sicherheitsberechtigungen zu * `instagram_basic` wird von Facebook / Instagram verwendet. * `https://www.googleapis.com/auth/drive` wird von Google verwendet. -/// info +/// info | Info In OAuth2 ist ein „Scope“ nur ein String, der eine bestimmte erforderliche Berechtigung deklariert. @@ -44,11 +44,11 @@ Für OAuth2 sind es einfach nur Strings. /// -## Code, um `username` und `password` entgegenzunehmen. +## Code, um `username` und `password` entgegenzunehmen. { #code-to-get-the-username-and-password } Lassen Sie uns nun die von **FastAPI** bereitgestellten Werkzeuge verwenden, um das zu erledigen. -### `OAuth2PasswordRequestForm` +### `OAuth2PasswordRequestForm` { #oauth2passwordrequestform } Importieren Sie zunächst `OAuth2PasswordRequestForm` und verwenden Sie es als Abhängigkeit mit `Depends` in der *Pfadoperation* für `/token`: @@ -72,7 +72,7 @@ Wenn Sie es erzwingen müssen, verwenden Sie `OAuth2PasswordRequestFormStrict` a * Eine optionale `client_id` (benötigen wir für unser Beispiel nicht). * Ein optionales `client_secret` (benötigen wir für unser Beispiel nicht). -/// info +/// info | Info `OAuth2PasswordRequestForm` ist keine spezielle Klasse für **FastAPI**, so wie `OAuth2PasswordBearer`. @@ -84,7 +84,7 @@ Da es sich jedoch um einen häufigen Anwendungsfall handelt, wird er zur Vereinf /// -### Die Formulardaten verwenden +### Die Formulardaten verwenden { #use-the-form-data } /// tip | Tipp @@ -102,7 +102,7 @@ Für den Fehler verwenden wir die Exception `HTTPException`: {* ../../docs_src/security/tutorial003_an_py310.py hl[3,79:81] *} -### Das Passwort überprüfen +### Das Passwort überprüfen { #check-the-password } Zu diesem Zeitpunkt liegen uns die Benutzerdaten aus unserer Datenbank vor, das Passwort haben wir jedoch noch nicht überprüft. @@ -112,7 +112,7 @@ Sie sollten niemals Klartext-Passwörter speichern, daher verwenden wir ein (gef Wenn die Passwörter nicht übereinstimmen, geben wir denselben Fehler zurück. -#### Passwort-Hashing +#### Passwort-Hashing { #password-hashing } „Hashing“ bedeutet: Konvertieren eines Inhalts (in diesem Fall eines Passworts) in eine Folge von Bytes (ein schlichter String), die wie Kauderwelsch aussieht. @@ -120,7 +120,7 @@ Immer wenn Sie genau den gleichen Inhalt (genau das gleiche Passwort) übergeben Sie können jedoch nicht vom Kauderwelsch zurück zum Passwort konvertieren. -##### Warum Passwort-Hashing verwenden? +##### Warum Passwort-Hashing verwenden? { #why-use-password-hashing } Wenn Ihre Datenbank gestohlen wird, hat der Dieb nicht die Klartext-Passwörter Ihrer Benutzer, sondern nur die Hashes. @@ -128,7 +128,7 @@ Der Dieb kann also nicht versuchen, die gleichen Passwörter in einem anderen Sy {* ../../docs_src/security/tutorial003_an_py310.py hl[82:85] *} -#### Über `**user_dict` +#### Über `**user_dict` { #about-user-dict } `UserInDB(**user_dict)` bedeutet: @@ -144,13 +144,13 @@ UserInDB( ) ``` -/// info +/// info | Info -Eine ausführlichere Erklärung von `**user_dict` finden Sie in [der Dokumentation für **Extra Modelle**](../extra-models.md#uber-user_indict){.internal-link target=_blank}. +Eine ausführlichere Erklärung von `**user_dict` finden Sie in [der Dokumentation für **Extra Modelle**](../extra-models.md#about-user-in-dict){.internal-link target=_blank}. /// -## Den Token zurückgeben +## Den Token zurückgeben { #return-the-token } Die Response des `token`-Endpunkts muss ein JSON-Objekt sein. @@ -182,7 +182,7 @@ Den Rest erledigt **FastAPI** für Sie. /// -## Die Abhängigkeiten aktualisieren +## Die Abhängigkeiten aktualisieren { #update-the-dependencies } Jetzt werden wir unsere Abhängigkeiten aktualisieren. @@ -196,7 +196,7 @@ In unserem Endpunkt erhalten wir also nur dann einen Benutzer, wenn der Benutzer {* ../../docs_src/security/tutorial003_an_py310.py hl[58:66,69:74,94] *} -/// info +/// info | Info Der zusätzliche Header `WWW-Authenticate` mit dem Wert `Bearer`, den wir hier zurückgeben, ist ebenfalls Teil der Spezifikation. @@ -214,11 +214,11 @@ Das ist der Vorteil von Standards ... /// -## Es in Aktion sehen +## Es in Aktion sehen { #see-it-in-action } Öffnen Sie die interaktive Dokumentation: http://127.0.0.1:8000/docs. -### Authentifizieren +### Authentifizieren { #authenticate } Klicken Sie auf den Button „Authorize“. @@ -234,7 +234,7 @@ Nach der Authentifizierung im System sehen Sie Folgendes: -### Die eigenen Benutzerdaten ansehen +### Die eigenen Benutzerdaten ansehen { #get-your-own-user-data } Verwenden Sie nun die Operation `GET` mit dem Pfad `/users/me`. @@ -260,7 +260,7 @@ Wenn Sie auf das Schlosssymbol klicken und sich abmelden und dann den gleichen V } ``` -### Inaktiver Benutzer +### Inaktiver Benutzer { #inactive-user } Versuchen Sie es nun mit einem inaktiven Benutzer und authentisieren Sie sich mit: @@ -278,7 +278,7 @@ Sie erhalten die Fehlermeldung „Inactive user“: } ``` -## Zusammenfassung +## Zusammenfassung { #recap } Sie verfügen jetzt über die Tools, um ein vollständiges Sicherheitssystem basierend auf `username` und `password` für Ihre API zu implementieren. From 0aa33f5f03d6f517366e9aa0a97ad2855873d462 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 24 Aug 2025 15:58:40 +0200 Subject: [PATCH 133/160] Update tutorial/security/oauth2-jwt.md Done with the manual walkthrough. My final temporary git ignore additions (to hide files in VSCode) may be of interest: # Temporarily ignore unrelated files /* !/docs /docs/* !/docs/en !/docs/de /docs/*/* !/docs/*/docs /docs/*/docs/css /docs/*/docs/img /docs/*/docs/js /docs/*/docs/reference /docs/*/docs/release-notes.md /docs/*/docs/fastapi-people.md /docs/*/docs/external-links.md /docs/*/docs/newsletter.md /docs/*/docs/management-tasks.md /docs/*/docs/management.md /docs/*/docs/contributing.md # Temporarily ignore done files /docs/*/docs/alternatives.md /docs/*/docs/async.md /docs/*/docs/benchmarks.md /docs/*/docs/environment-variables.md /docs/*/docs/fastapi-cli.md /docs/*/docs/features.md /docs/*/docs/help-fastapi.md /docs/*/docs/history-design-future.md /docs/*/docs/index.md /docs/*/docs/project-generation.md /docs/*/docs/python-types.md /docs/*/docs/virtual-environments.md /docs/*/docs/about/index.md /docs/*/docs/about /docs/*/docs/advanced/additional-responses.md /docs/*/docs/advanced/additional-status-codes.md /docs/*/docs/advanced/advanced-dependencies.md /docs/*/docs/advanced/async-tests.md /docs/*/docs/advanced/behind-a-proxy.md /docs/*/docs/advanced/custom-response.md /docs/*/docs/advanced/dataclasses.md /docs/*/docs/advanced/events.md /docs/*/docs/advanced/generate-clients.md /docs/*/docs/advanced/index.md /docs/*/docs/advanced/middleware.md /docs/*/docs/advanced/openapi-callbacks.md /docs/*/docs/advanced/openapi-webhooks.md /docs/*/docs/advanced/path-operation-advanced-configuration.md /docs/*/docs/advanced/response-change-status-code.md /docs/*/docs/advanced/response-cookies.md /docs/*/docs/advanced/response-directly.md /docs/*/docs/advanced/response-headers.md /docs/*/docs/advanced/settings.md /docs/*/docs/advanced/sub-applications.md /docs/*/docs/advanced/templates.md /docs/*/docs/advanced/testing-dependencies.md /docs/*/docs/advanced/testing-events.md /docs/*/docs/advanced/testing-websockets.md /docs/*/docs/advanced/using-request-directly.md /docs/*/docs/advanced/websockets.md /docs/*/docs/advanced/wsgi.md /docs/*/docs/advanced/security/http-basic-auth.md /docs/*/docs/advanced/security/index.md /docs/*/docs/advanced/security/oauth2-scopes.md /docs/*/docs/advanced/security /docs/*/docs/advanced /docs/*/docs/deployment/cloud.md /docs/*/docs/deployment/concepts.md /docs/*/docs/deployment/docker.md /docs/*/docs/deployment/https.md /docs/*/docs/deployment/index.md /docs/*/docs/deployment/manually.md /docs/*/docs/deployment/server-workers.md /docs/*/docs/deployment/versions.md /docs/*/docs/deployment /docs/*/docs/how-to/conditional-openapi.md /docs/*/docs/how-to/configure-swagger-ui.md /docs/*/docs/how-to/custom-docs-ui-assets.md /docs/*/docs/how-to/custom-request-and-route.md /docs/*/docs/how-to/extending-openapi.md /docs/*/docs/how-to/general.md /docs/*/docs/how-to/graphql.md /docs/*/docs/how-to/index.md /docs/*/docs/how-to/separate-openapi-schemas.md /docs/*/docs/how-to/testing-database.md /docs/*/docs/how-to /docs/*/docs/learn/index.md /docs/*/docs/learn /docs/*/docs/resources/index.md /docs/*/docs/resources /docs/*/docs/tutorial/background-tasks.md /docs/*/docs/tutorial/bigger-applications.md /docs/*/docs/tutorial/body-fields.md /docs/*/docs/tutorial/body-multiple-params.md /docs/*/docs/tutorial/body-nested-models.md /docs/*/docs/tutorial/body-updates.md /docs/*/docs/tutorial/body.md /docs/*/docs/tutorial/cookie-param-models.md /docs/*/docs/tutorial/cookie-params.md /docs/*/docs/tutorial/cors.md /docs/*/docs/tutorial/debugging.md /docs/*/docs/tutorial/encoder.md /docs/*/docs/tutorial/extra-data-types.md /docs/*/docs/tutorial/extra-models.md /docs/*/docs/tutorial/first-steps.md /docs/*/docs/tutorial/handling-errors.md /docs/*/docs/tutorial/header-param-models.md /docs/*/docs/tutorial/header-params.md /docs/*/docs/tutorial/index.md /docs/*/docs/tutorial/metadata.md /docs/*/docs/tutorial/middleware.md /docs/*/docs/tutorial/path-operation-configuration.md /docs/*/docs/tutorial/path-params-numeric-validations.md /docs/*/docs/tutorial/path-params.md /docs/*/docs/tutorial/query-param-models.md /docs/*/docs/tutorial/query-params-str-validations.md /docs/*/docs/tutorial/query-params.md /docs/*/docs/tutorial/request-files.md /docs/*/docs/tutorial/request-form-models.md /docs/*/docs/tutorial/request-forms-and-files.md /docs/*/docs/tutorial/request-forms.md /docs/*/docs/tutorial/response-model.md /docs/*/docs/tutorial/response-status-code.md /docs/*/docs/tutorial/schema-extra-example.md /docs/*/docs/tutorial/sql-databases.md /docs/*/docs/tutorial/static-files.md /docs/*/docs/tutorial/testing.md /docs/*/docs/tutorial/dependencies/index.md /docs/*/docs/tutorial/dependencies/classes-as-dependencies.md /docs/*/docs/tutorial/dependencies/sub-dependencies.md /docs/*/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md /docs/*/docs/tutorial/dependencies/global-dependencies.md /docs/*/docs/tutorial/dependencies/dependencies-with-yield.md /docs/*/docs/tutorial/dependencies /docs/*/docs/tutorial/security/index.md /docs/*/docs/tutorial/security/first-steps.md /docs/*/docs/tutorial/security/get-current-user.md /docs/*/docs/tutorial/security/simple-oauth2.md /docs/*/docs/tutorial/security/oauth2-jwt.md /docs/*/docs/tutorial/security /docs/*/docs/tutorial /docs/*/docs /docs/* /docs --- docs/de/docs/tutorial/security/oauth2-jwt.md | 62 ++++++++++---------- 1 file changed, 30 insertions(+), 32 deletions(-) diff --git a/docs/de/docs/tutorial/security/oauth2-jwt.md b/docs/de/docs/tutorial/security/oauth2-jwt.md index 110cf30e5..91142995b 100644 --- a/docs/de/docs/tutorial/security/oauth2-jwt.md +++ b/docs/de/docs/tutorial/security/oauth2-jwt.md @@ -1,4 +1,4 @@ -# OAuth2 mit Password (und Hashing), Bearer mit JWT-Tokens +# OAuth2 mit Passwort (und Hashing), Bearer mit JWT-Tokens { #oauth2-with-password-and-hashing-bearer-with-jwt-tokens } Da wir nun über den gesamten Sicherheitsablauf verfügen, machen wir die Anwendung tatsächlich sicher, indem wir JWT-Tokens und sicheres Passwort-Hashing verwenden. @@ -6,7 +6,7 @@ Diesen Code können Sie tatsächlich in Ihrer Anwendung verwenden, die Passwort- Wir bauen auf dem vorherigen Kapitel auf. -## Über JWT +## Über JWT { #about-jwt } JWT bedeutet „JSON Web Tokens“. @@ -26,33 +26,31 @@ Nach einer Woche läuft der Token ab und der Benutzer wird nicht autorisiert und Wenn Sie mit JWT-Tokens spielen und sehen möchten, wie sie funktionieren, schauen Sie sich https://jwt.io an. -## `python-jose` installieren. +## `PyJWT` installieren { #install-pyjwt } -Wir müssen `python-jose` installieren, um die JWT-Tokens in Python zu generieren und zu verifizieren: +Wir müssen `PyJWT` installieren, um die JWT-Tokens in Python zu generieren und zu verifizieren. + +Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und dann `pyjwt` installieren:
```console -$ pip install "python-jose[cryptography]" +$ pip install pyjwt ---> 100% ```
-python-jose erfordert zusätzlich ein kryptografisches Backend. - -Hier verwenden wir das empfohlene: pyca/cryptography. - -/// tip | Tipp +/// info | Info -Dieses Tutorial verwendete zuvor PyJWT. +Wenn Sie planen, digitale Signaturalgorithmen wie RSA oder ECDSA zu verwenden, sollten Sie die Kryptografie-Abhängigkeit `pyjwt[crypto]` installieren. -Es wurde jedoch aktualisiert, stattdessen python-jose zu verwenden, da dieses alle Funktionen von PyJWT sowie einige Extras bietet, die Sie später möglicherweise benötigen, wenn Sie Integrationen mit anderen Tools erstellen. +Weitere Informationen finden Sie in der PyJWT-Installationsdokumentation. /// -## Passwort-Hashing +## Passwort-Hashing { #password-hashing } „Hashing“ bedeutet: Konvertieren eines Inhalts (in diesem Fall eines Passworts) in eine Folge von Bytes (ein schlichter String), die wie Kauderwelsch aussieht. @@ -60,13 +58,13 @@ Immer wenn Sie genau den gleichen Inhalt (genau das gleiche Passwort) übergeben Sie können jedoch nicht vom Kauderwelsch zurück zum Passwort konvertieren. -### Warum Passwort-Hashing verwenden? +### Warum Passwort-Hashing verwenden? { #why-use-password-hashing } Wenn Ihre Datenbank gestohlen wird, hat der Dieb nicht die Klartext-Passwörter Ihrer Benutzer, sondern nur die Hashes. Der Dieb kann also nicht versuchen, die gleichen Passwörter in einem anderen System zu verwenden (da viele Benutzer überall das gleiche Passwort verwenden, wäre dies gefährlich). -## `passlib` installieren +## `passlib` installieren { #install-passlib } PassLib ist ein großartiges Python-Package, um Passwort-Hashes zu handhaben. @@ -74,7 +72,7 @@ Es unterstützt viele sichere Hashing-Algorithmen und Werkzeuge, um mit diesen z Der empfohlene Algorithmus ist „Bcrypt“. -Installieren Sie also PassLib mit Bcrypt: +Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren, und installieren Sie dann PassLib mit Bcrypt:
@@ -96,7 +94,7 @@ Und Ihre Benutzer könnten sich gleichzeitig über Ihre Django-Anwendung oder Ih /// -## Die Passwörter hashen und überprüfen +## Die Passwörter hashen und überprüfen { #hash-and-verify-the-passwords } Importieren Sie die benötigten Tools aus `passlib`. @@ -118,7 +116,7 @@ Und eine weitere, um zu überprüfen, ob ein empfangenes Passwort mit dem gespei Und noch eine, um einen Benutzer zu authentifizieren und zurückzugeben. -{* ../../docs_src/security/tutorial004_an_py310.py hl[7,48,55:56,59:60,69:75] *} +{* ../../docs_src/security/tutorial004_an_py310.py hl[8,49,56:57,60:61,70:76] *} /// note | Hinweis @@ -126,7 +124,7 @@ Wenn Sie sich die neue (gefakte) Datenbank `fake_users_db` anschauen, sehen Sie, /// -## JWT-Token verarbeiten +## JWT-Token verarbeiten { #handle-jwt-tokens } Importieren Sie die installierten Module. @@ -154,9 +152,9 @@ Definieren Sie ein Pydantic-Modell, das im Token-Endpunkt für die Response verw Erstellen Sie eine Hilfsfunktion, um einen neuen Zugriffstoken zu generieren. -{* ../../docs_src/security/tutorial004_an_py310.py hl[6,12:14,28:30,78:86] *} +{* ../../docs_src/security/tutorial004_an_py310.py hl[4,7,13:15,29:31,79:87] *} -## Die Abhängigkeiten aktualisieren +## Die Abhängigkeiten aktualisieren { #update-the-dependencies } Aktualisieren Sie `get_current_user`, um den gleichen Token wie zuvor zu erhalten, dieses Mal jedoch unter Verwendung von JWT-Tokens. @@ -164,17 +162,17 @@ Dekodieren Sie den empfangenen Token, validieren Sie ihn und geben Sie den aktue Wenn der Token ungültig ist, geben Sie sofort einen HTTP-Fehler zurück. -{* ../../docs_src/security/tutorial004_an_py310.py hl[89:106] *} +{* ../../docs_src/security/tutorial004_an_py310.py hl[90:107] *} -## Die *Pfadoperation* `/token` aktualisieren +## Die *Pfadoperation* `/token` aktualisieren { #update-the-token-path-operation } Erstellen Sie ein `timedelta` mit der Ablaufzeit des Tokens. Erstellen Sie einen echten JWT-Zugriffstoken und geben Sie ihn zurück. -{* ../../docs_src/security/tutorial004_an_py310.py hl[117:132] *} +{* ../../docs_src/security/tutorial004_an_py310.py hl[118:133] *} -### Technische Details zum JWT-„Subjekt“ `sub` +### Technische Details zum JWT-„Subjekt“ `sub` { #technical-details-about-the-jwt-subject-sub } Die JWT-Spezifikation besagt, dass es einen Schlüssel `sub` mit dem Subjekt des Tokens gibt. @@ -196,7 +194,7 @@ Deshalb, um ID-Kollisionen zu vermeiden, könnten Sie beim Erstellen des JWT-Tok Der wesentliche Punkt ist, dass der `sub`-Schlüssel in der gesamten Anwendung eine eindeutige Kennung haben sollte, und er sollte ein String sein. -## Testen +## Testen { #check-it } Führen Sie den Server aus und gehen Sie zur Dokumentation: http://127.0.0.1:8000/docs. @@ -209,9 +207,9 @@ Melden Sie sich bei der Anwendung auf die gleiche Weise wie zuvor an. Verwenden Sie die Anmeldeinformationen: Benutzername: `johndoe` -Passwort: `secret`. +Passwort: `secret` -/// check +/// check | Testen Beachten Sie, dass im Code nirgendwo das Klartext-Passwort "`secret`" steht, wir haben nur die gehashte Version. @@ -238,11 +236,11 @@ Wenn Sie die Developer Tools öffnen, können Sie sehen, dass die gesendeten Dat /// note | Hinweis -Beachten Sie den Header `Authorization` mit einem Wert, der mit `Bearer` beginnt. +Beachten Sie den Header `Authorization` mit einem Wert, der mit `Bearer ` beginnt. /// -## Fortgeschrittene Verwendung mit `scopes` +## Fortgeschrittene Verwendung mit `scopes` { #advanced-usage-with-scopes } OAuth2 hat ein Konzept von „Scopes“. @@ -252,7 +250,7 @@ Anschließend können Sie diesen Token einem Benutzer direkt oder einem Dritten Wie Sie sie verwenden und wie sie in **FastAPI** integriert sind, erfahren Sie später im **Handbuch für fortgeschrittene Benutzer**. -## Zusammenfassung +## Zusammenfassung { #recap } Mit dem, was Sie bis hier gesehen haben, können Sie eine sichere **FastAPI**-Anwendung mithilfe von Standards wie OAuth2 und JWT einrichten. @@ -266,7 +264,7 @@ Viele Packages, die es stark vereinfachen, müssen viele Kompromisse beim Datenm Es gibt Ihnen die volle Flexibilität, diejenigen auszuwählen, die am besten zu Ihrem Projekt passen. -Und Sie können viele gut gepflegte und weit verbreitete Packages wie `passlib` und `python-jose` direkt verwenden, da **FastAPI** keine komplexen Mechanismen zur Integration externer Pakete erfordert. +Und Sie können viele gut gepflegte und weit verbreitete Packages wie `passlib` und `PyJWT` direkt verwenden, da **FastAPI** keine komplexen Mechanismen zur Integration externer Pakete erfordert. Aber es bietet Ihnen die Werkzeuge, um den Prozess so weit wie möglich zu vereinfachen, ohne Kompromisse bei Flexibilität, Robustheit oder Sicherheit einzugehen. From d3a5d0565515785330b2f20eb91d5513355b540e Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Mon, 25 Aug 2025 00:00:37 +0200 Subject: [PATCH 134/160] Intermezzo `z.B.` --> `z. B.` Forgot to include the change to the German prompt. It is in the later commit. --- docs/de/docs/advanced/custom-response.md | 10 +++++----- docs/de/docs/advanced/openapi-webhooks.md | 4 ++-- docs/de/docs/deployment/docker.md | 8 ++++---- docs/de/docs/deployment/manually.md | 4 ++-- docs/de/docs/help-fastapi.md | 2 +- docs/de/docs/tutorial/body-updates.md | 2 +- docs/de/docs/tutorial/cors.md | 4 ++-- docs/de/docs/tutorial/request-forms-and-files.md | 2 +- docs/de/docs/tutorial/request-forms.md | 2 +- docs/de/docs/virtual-environments.md | 6 +++--- 10 files changed, 22 insertions(+), 22 deletions(-) diff --git a/docs/de/docs/advanced/custom-response.md b/docs/de/docs/advanced/custom-response.md index b55fb2938..d896d312c 100644 --- a/docs/de/docs/advanced/custom-response.md +++ b/docs/de/docs/advanced/custom-response.md @@ -6,7 +6,7 @@ Sie können dies überschreiben, indem Sie direkt eine `Response` zurückgeben, Wenn Sie jedoch direkt eine `Response` (oder eine Unterklasse wie `JSONResponse`) zurückgeben, werden die Daten nicht automatisch konvertiert (selbst wenn Sie ein `response_model` deklariert haben), und die Dokumentation wird nicht automatisch generiert (zum Beispiel wird der spezifische „Medientyp“, der im HTTP-Header `Content-Type` angegeben ist, nicht Teil der generierten OpenAPI). -Sie können jedoch auch die `Response`, die Sie verwenden möchten (z.B. jede `Response`-Unterklasse), im *Pfadoperation-Dekorator* mit dem `response_class`-Parameter deklarieren. +Sie können jedoch auch die `Response`, die Sie verwenden möchten (z. B. jede `Response`-Unterklasse), im *Pfadoperation-Dekorator* mit dem `response_class`-Parameter deklarieren. Der Inhalt, den Sie von Ihrer *Pfadoperation-Funktion* zurückgeben, wird in diese `Response` eingefügt. @@ -132,7 +132,7 @@ Sie akzeptiert die folgenden Parameter: * `content` – Ein `str` oder `bytes`. * `status_code` – Ein `int`-HTTP-Statuscode. * `headers` – Ein `dict` von Strings. -* `media_type` – Ein `str`, der den Medientyp angibt. Z.B. `"text/html"`. +* `media_type` – Ein `str`, der den Medientyp angibt. Z. B. `"text/html"`. FastAPI (eigentlich Starlette) fügt automatisch einen Content-Length-Header ein. Außerdem wird es einen Content-Type-Header einfügen, der auf dem media_type basiert, und für Texttypen einen Zeichensatz (charset) anfügen. @@ -160,7 +160,7 @@ Eine schnelle alternative JSON-Response mit GitHub-Sponsoren unterstützen. Je nach Stufe können Sie einige zusätzliche Vorteile erhalten, wie z.B. ein Abzeichen in der Dokumentation. 🎁 +Wenn Ihr **Produkt/Firma** auf **FastAPI** angewiesen ist oder in Zusammenhang steht und Sie seine Benutzer erreichen möchten, können Sie den Autor (mich) über GitHub-Sponsoren unterstützen. Je nach Stufe können Sie einige zusätzliche Vorteile erhalten, wie z. B. ein Abzeichen in der Dokumentation. 🎁 --- diff --git a/docs/de/docs/tutorial/body-updates.md b/docs/de/docs/tutorial/body-updates.md index e2636cff3..1caff790b 100644 --- a/docs/de/docs/tutorial/body-updates.md +++ b/docs/de/docs/tutorial/body-updates.md @@ -4,7 +4,7 @@ Um einen Artikel zu aktualisieren, können Sie die HTTP `PUT` Operation verwenden. -Sie können den `jsonable_encoder` verwenden, um die empfangenen Daten in etwas zu konvertieren, das als JSON gespeichert werden kann (z.B. in einer NoSQL-Datenbank). Zum Beispiel, um ein `datetime` in einen `str` zu konvertieren. +Sie können den `jsonable_encoder` verwenden, um die empfangenen Daten in etwas zu konvertieren, das als JSON gespeichert werden kann (z. B. in einer NoSQL-Datenbank). Zum Beispiel, um ein `datetime` in einen `str` zu konvertieren. {* ../../docs_src/body_updates/tutorial001_py310.py hl[28:33] *} diff --git a/docs/de/docs/tutorial/cors.md b/docs/de/docs/tutorial/cors.md index e7a771260..40d73c50d 100644 --- a/docs/de/docs/tutorial/cors.md +++ b/docs/de/docs/tutorial/cors.md @@ -52,8 +52,8 @@ Die von der `CORSMiddleware`-Implementierung verwendeten Defaultparameter sind s Die folgenden Argumente werden unterstützt: -* `allow_origins` - Eine Liste von Origins, die Cross-Origin-Requests machen dürfen. z.B. `['https://example.org', 'https://www.example.org']`. Sie können `['*']` verwenden, um jedes Origin zuzulassen. -* `allow_origin_regex` - Ein Regex-String zum Abgleichen gegen Origins, die Cross-Origin-Requests machen dürfen. z.B. `'https://.*\.example\.org'`. +* `allow_origins` - Eine Liste von Origins, die Cross-Origin-Requests machen dürfen. z. B. `['https://example.org', 'https://www.example.org']`. Sie können `['*']` verwenden, um jedes Origin zuzulassen. +* `allow_origin_regex` - Ein Regex-String zum Abgleichen gegen Origins, die Cross-Origin-Requests machen dürfen. z. B. `'https://.*\.example\.org'`. * `allow_methods` - Eine Liste von HTTP-Methoden, die für Cross-Origin-Requests erlaubt sein sollen. Standardmäßig `['GET']`. Sie können `['*']` verwenden, um alle Standardmethoden zu erlauben. * `allow_headers` - Eine Liste von HTTP-Requestheadern, die für Cross-Origin-Requests unterstützt werden sollten. Standardmäßig `[]`. Sie können `['*']` verwenden, um alle Header zu erlauben. Die Header `Accept`, `Accept-Language`, `Content-Language` und `Content-Type` sind immer für einfache CORS-Requests erlaubt. * `allow_credentials` - Anzeigen, dass Cookies für Cross-Origin-Requests unterstützt werden sollten. Standardmäßig `False`. diff --git a/docs/de/docs/tutorial/request-forms-and-files.md b/docs/de/docs/tutorial/request-forms-and-files.md index 7c4da4b84..ce7d46801 100644 --- a/docs/de/docs/tutorial/request-forms-and-files.md +++ b/docs/de/docs/tutorial/request-forms-and-files.md @@ -6,7 +6,7 @@ Sie können gleichzeitig Dateien und Formulardaten mit `File` und `Form` definie Um hochgeladene Dateien und/oder Formulardaten zu empfangen, installieren Sie zuerst `python-multipart`. -Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, diese aktivieren und es dann installieren, z.B.: +Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, diese aktivieren und es dann installieren, z. B.: ```console $ pip install python-multipart diff --git a/docs/de/docs/tutorial/request-forms.md b/docs/de/docs/tutorial/request-forms.md index 1d7a7c235..0b3d66bdd 100644 --- a/docs/de/docs/tutorial/request-forms.md +++ b/docs/de/docs/tutorial/request-forms.md @@ -30,7 +30,7 @@ Zum Beispiel stellt eine der Möglichkeiten, die OAuth2-Spezifikation zu verwend Die Spec erfordert, dass die Felder exakt `username` und `password` genannt werden und als Formularfelder, nicht JSON, gesendet werden. -Mit `Form` haben Sie die gleichen Konfigurationsmöglichkeiten wie mit `Body` (und `Query`, `Path`, `Cookie`), inklusive Validierung, Beispielen, einem Alias (z.B. `user-name` statt `username`), usw. +Mit `Form` haben Sie die gleichen Konfigurationsmöglichkeiten wie mit `Body` (und `Query`, `Path`, `Cookie`), inklusive Validierung, Beispielen, einem Alias (z. B. `user-name` statt `username`), usw. /// info diff --git a/docs/de/docs/virtual-environments.md b/docs/de/docs/virtual-environments.md index 6ce687dfc..8f0faa3f9 100644 --- a/docs/de/docs/virtual-environments.md +++ b/docs/de/docs/virtual-environments.md @@ -150,7 +150,7 @@ $ .venv\Scripts\Activate.ps1 //// tab | Windows Bash -Oder wenn Sie Bash für Windows verwenden (z.B. Git Bash): +Oder wenn Sie Bash für Windows verwenden (z. B. Git Bash):
@@ -522,7 +522,7 @@ Es ist sehr üblich in Python-Paketen, alles zu versuchen, **Breaking Changes** Stellen Sie sich das jetzt mit **vielen** anderen **Paketen** vor, von denen alle Ihre **Projekte abhängen**. Das ist sehr schwierig zu verwalten. Und Sie würden wahrscheinlich einige Projekte mit einigen **inkompatiblen Versionen** der Pakete ausführen und nicht wissen, warum etwas nicht funktioniert. -Darüber hinaus könnte es je nach Ihrem Betriebssystem (z.B. Linux, Windows, macOS) bereits mit installiertem Python geliefert worden sein. Und in diesem Fall hatte es wahrscheinlich einige Pakete mit bestimmten Versionen **installiert**, die von Ihrem System benötigt werden. Wenn Sie Pakete in der globalen Python-Umgebung installieren, könnten Sie einige der Programme, die mit Ihrem Betriebssystem geliefert wurden, **kaputtmachen**. +Darüber hinaus könnte es je nach Ihrem Betriebssystem (z. B. Linux, Windows, macOS) bereits mit installiertem Python geliefert worden sein. Und in diesem Fall hatte es wahrscheinlich einige Pakete mit bestimmten Versionen **installiert**, die von Ihrem System benötigt werden. Wenn Sie Pakete in der globalen Python-Umgebung installieren, könnten Sie einige der Programme, die mit Ihrem Betriebssystem geliefert wurden, **kaputtmachen**. ## Wo werden Pakete installiert { #where-are-packages-installed } @@ -605,7 +605,7 @@ $ .venv\Scripts\Activate.ps1 //// tab | Windows Bash -Oder wenn Sie Bash für Windows verwenden (z.B. Git Bash): +Oder wenn Sie Bash für Windows verwenden (z. B. Git Bash):
From 2170725397ced8937f0ca28e9cc4f95784c0df25 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 24 Aug 2025 16:59:00 +0200 Subject: [PATCH 135/160] Prepare translate.py for Batch translation ... making a few fixes/changes: * Fix a deprecation warning * Fix a probably not intended hardcoded "es" language identifier when calling `translate_page` * Fix `iter_en_paths_to_translate` and `non_translated_sections ` to also work on Windows, which uses backslashes in stringified paths * Add `mode`, `verbose` and `preview` parameters to `translate_lang`, add a helper function to print path infos, and improve its output to show the progress. * Add documentation to some function parameters --- scripts/translate.py | 85 ++++++++++++++++++++++++++++---------------- 1 file changed, 54 insertions(+), 31 deletions(-) diff --git a/scripts/translate.py b/scripts/translate.py index 3e4b9458c..36dc6c021 100644 --- a/scripts/translate.py +++ b/scripts/translate.py @@ -2,7 +2,9 @@ import secrets import subprocess from functools import lru_cache from pathlib import Path -from typing import Annotated, Iterable +from os import sep as pathsep +from typing import Annotated +from collections.abc import Iterable import git import typer @@ -12,7 +14,7 @@ from pydantic_ai import Agent from rich import print non_translated_sections = ( - "reference/", + f"reference{pathsep}", "release-notes.md", "fastapi-people.md", "external-links.md", @@ -354,9 +356,10 @@ def generate_en_path(*, lang: str, path: Path) -> Path: @app.command() def translate_page( *, - language: Annotated[str, typer.Option(envvar="LANGUAGE")], - en_path: Annotated[Path, typer.Option(envvar="EN_PATH")], + language: Annotated[str, typer.Option(envvar="LANGUAGE", help="Target language, e.g. `es`, `fr`, `de`")], + en_path: Annotated[Path, typer.Option(envvar="EN_PATH", help="Path to the English source, relative to the FastAPI root directory, e.g. `docs/en/docs/index.md`")], ) -> None: + assert language != "en", "`en` is the source language, choose another language as translation target" langs = get_langs() language_name = langs[language] lang_path = Path(f"docs/{language}") @@ -440,39 +443,59 @@ def iter_all_en_paths() -> Iterable[Path]: def iter_en_paths_to_translate() -> Iterable[Path]: + en_docs_root = Path("docs/en/docs/") for path in iter_all_en_paths(): - if str(path).replace("docs/en/docs/", "").startswith(non_translated_sections): - continue - yield path + relpath = path.relative_to(en_docs_root) + if not str(relpath).startswith(non_translated_sections): + yield path @app.command() -def translate_lang(language: Annotated[str, typer.Option(envvar="LANGUAGE")]) -> None: - paths_to_process = list(iter_en_paths_to_translate()) - print("Original paths:") - for p in paths_to_process: - print(f" - {p}") - print(f"Total original paths: {len(paths_to_process)}") +def translate_lang( + language: Annotated[str, typer.Option(envvar="LANGUAGE", help="Target language, e.g. `es`, `fr`, `de`")], + mode: Annotated[str, typer.Option(help="Which files of the target language to translate, one of: `missing`, `existing`, `all`")] = "missing", + verbose: Annotated[bool, typer.Option(help="Print all paths")] = False, + preview: Annotated[bool, typer.Option(help="Show what will be done, but do not translate")] = False +) -> None: + allowed_modes = ["missing", "existing", "all"] + assert mode in allowed_modes, f"`mode` parameter must be one of {", ".join(f"`{mode}`" for mode in allowed_modes)}" + + translatable_paths = list(iter_en_paths_to_translate()) missing_paths: list[Path] = [] - skipped_paths: list[Path] = [] - for p in paths_to_process: + existing_paths: list[Path] = [] + for p in translatable_paths: lang_path = generate_lang_path(lang=language, path=p) - if lang_path.exists(): - skipped_paths.append(p) - continue - missing_paths.append(p) - print("Paths to skip:") - for p in skipped_paths: - print(f" - {p}") - print(f"Total paths to skip: {len(skipped_paths)}") - print("Paths to process:") - for p in missing_paths: - print(f" - {p}") - print(f"Total paths to process: {len(missing_paths)}") - for p in missing_paths: - print(f"Translating: {p}") - translate_page(language="es", en_path=p) - print(f"Done translating: {p}") + (existing_paths if lang_path.exists() else missing_paths).append(p) + + def print_pathinfo(title: str, paths: list[Path], verbose: bool = verbose): + print(f"{len(paths)} {title}", end="") + if verbose and paths: + print(":") + for p in paths: + print(f" - {p}") + else: + print() + print_pathinfo("translatable paths", translatable_paths) + print_pathinfo("paths with a translation", existing_paths) + print_pathinfo("paths with no translation", missing_paths) + + print(f"Mode: translate {mode}") + if mode == 'missing' or (mode == "all" and len(existing_paths) == 0): + tbd_paths = missing_paths + action = "translate" + elif mode == "existing" or (mode == "all" and len(missing_paths) == 0): + tbd_paths = existing_paths + action = "update" + else: + tbd_paths = translatable_paths + action = "translate/update" + print(f"{len(tbd_paths)} paths to {action}") + + if not preview: + for c, p in enumerate(tbd_paths): + print(f"({c+1}/{len(tbd_paths)}) Translating: {p}") + translate_page(language=language, en_path=p) + print(f"Done translating: {p}") @app.command() From 5e270ac1ec8c93a1c99abaa25702b244d3169e28 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Mon, 25 Aug 2025 00:08:56 +0200 Subject: [PATCH 136/160] German docs batch translation A complete run through the German docs to test how the prompts work "in production". gpt-5 found a lot of things which gpt-4o and I have overlooked. I had to manually modify/fix approximately 10 changes it suggested, which is a good result for 111 files. The German docs are now completely translated and in sync. --- docs/de/docs/advanced/additional-responses.md | 4 ++-- .../de/docs/advanced/advanced-dependencies.md | 2 +- docs/de/docs/advanced/async-tests.md | 6 +++--- docs/de/docs/advanced/behind-a-proxy.md | 2 +- docs/de/docs/advanced/custom-response.md | 2 +- docs/de/docs/advanced/events.md | 2 +- docs/de/docs/advanced/generate-clients.md | 2 +- docs/de/docs/advanced/index.md | 2 +- docs/de/docs/advanced/middleware.md | 4 ++-- .../path-operation-advanced-configuration.md | 2 +- .../advanced/response-change-status-code.md | 4 ++-- docs/de/docs/advanced/response-headers.md | 2 +- .../docs/advanced/security/http-basic-auth.md | 6 +++--- docs/de/docs/advanced/security/index.md | 2 +- .../docs/advanced/security/oauth2-scopes.md | 2 +- docs/de/docs/advanced/settings.md | 2 +- docs/de/docs/advanced/sub-applications.md | 8 ++++---- docs/de/docs/advanced/templates.md | 6 +++--- docs/de/docs/advanced/testing-dependencies.md | 5 +++-- docs/de/docs/advanced/testing-websockets.md | 2 +- .../docs/advanced/using-request-directly.md | 2 +- docs/de/docs/advanced/websockets.md | 4 ++-- docs/de/docs/advanced/wsgi.md | 2 +- docs/de/docs/async.md | 14 ++++++------- docs/de/docs/deployment/concepts.md | 2 +- docs/de/docs/deployment/docker.md | 12 +++++------ docs/de/docs/deployment/https.md | 4 ++-- docs/de/docs/deployment/manually.md | 4 ++-- docs/de/docs/deployment/server-workers.md | 4 ++-- docs/de/docs/deployment/versions.md | 5 +++-- docs/de/docs/fastapi-cli.md | 4 ++-- docs/de/docs/features.md | 16 +++++++-------- docs/de/docs/how-to/conditional-openapi.md | 2 +- docs/de/docs/how-to/configure-swagger-ui.md | 4 ++-- docs/de/docs/how-to/custom-docs-ui-assets.md | 8 ++++---- docs/de/docs/how-to/general.md | 6 +++--- docs/de/docs/how-to/graphql.md | 2 +- docs/de/docs/index.md | 2 +- docs/de/docs/project-generation.md | 2 +- docs/de/docs/python-types.md | 16 +++++++-------- docs/de/docs/tutorial/body-fields.md | 2 +- docs/de/docs/tutorial/body.md | 10 +++++----- docs/de/docs/tutorial/cors.md | 4 ++-- docs/de/docs/tutorial/debugging.md | 12 +++++------ .../dependencies/dependencies-with-yield.md | 2 +- docs/de/docs/tutorial/extra-data-types.md | 2 +- docs/de/docs/tutorial/first-steps.md | 12 +++++------ docs/de/docs/tutorial/header-param-models.md | 2 +- docs/de/docs/tutorial/header-params.md | 2 +- docs/de/docs/tutorial/metadata.md | 2 +- docs/de/docs/tutorial/middleware.md | 6 +++--- .../path-params-numeric-validations.md | 4 ++-- docs/de/docs/tutorial/path-params.md | 20 +++++++++---------- .../tutorial/query-params-str-validations.md | 4 ++-- docs/de/docs/tutorial/request-files.md | 2 +- docs/de/docs/tutorial/request-forms.md | 8 ++++---- docs/de/docs/tutorial/response-model.md | 12 +++++------ docs/de/docs/tutorial/response-status-code.md | 2 +- docs/de/docs/tutorial/schema-extra-example.md | 6 +++--- docs/de/docs/tutorial/security/oauth2-jwt.md | 4 ++-- docs/de/docs/tutorial/static-files.md | 2 +- docs/de/docs/tutorial/testing.md | 2 +- 62 files changed, 153 insertions(+), 151 deletions(-) diff --git a/docs/de/docs/advanced/additional-responses.md b/docs/de/docs/advanced/additional-responses.md index ebdbd41da..287d11c4c 100644 --- a/docs/de/docs/advanced/additional-responses.md +++ b/docs/de/docs/advanced/additional-responses.md @@ -243,5 +243,5 @@ Zum Beispiel: Um zu sehen, was genau Sie in die Responses aufnehmen können, können Sie die folgenden Abschnitte in der OpenAPI-Spezifikation überprüfen: -* OpenAPI Responses Object, enthält das `Response Object`. -* OpenAPI Response Object, 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`. +* OpenAPI Responses Object, enthält das `Response Object`. +* OpenAPI Response Object, 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`. diff --git a/docs/de/docs/advanced/advanced-dependencies.md b/docs/de/docs/advanced/advanced-dependencies.md index 0f870acdf..dd165bb90 100644 --- a/docs/de/docs/advanced/advanced-dependencies.md +++ b/docs/de/docs/advanced/advanced-dependencies.md @@ -36,7 +36,7 @@ Wir könnten eine Instanz dieser Klasse erstellen mit: {* ../../docs_src/dependencies/tutorial011_an_py39.py hl[18] *} -Und auf diese Weise können wir unsere Abhängigkeit „parametrisieren“, die jetzt `"bar"` enthält, als das Attribut `checker.fixed_content`. +Und auf diese Weise können wir unsere Abhängigkeit „parametrisieren“, die jetzt „bar“ enthält, als das Attribut `checker.fixed_content`. ## Die Instanz als Abhängigkeit verwenden { #use-the-instance-as-a-dependency } diff --git a/docs/de/docs/advanced/async-tests.md b/docs/de/docs/advanced/async-tests.md index 5c0c551e0..bd3c78113 100644 --- a/docs/de/docs/advanced/async-tests.md +++ b/docs/de/docs/advanced/async-tests.md @@ -14,9 +14,9 @@ Wenn wir in unseren Tests asynchrone Funktionen aufrufen möchten, müssen unser Auch wenn Ihre **FastAPI**-Anwendung normale `def`-Funktionen anstelle von `async def` verwendet, handelt es sich darunter immer noch um eine `async`-Anwendung. -Der `TestClient` macht unter der Haube magisches, um die asynchrone FastAPI-Anwendung in Ihren normalen `def`-Testfunktionen, mithilfe von Standard-Pytest aufzurufen. Aber diese Magie funktioniert nicht mehr, wenn wir sie in asynchronen Funktionen verwenden. Durch die asynchrone Ausführung unserer Tests können wir den `TestClient` nicht mehr in unseren Testfunktionen verwenden. +Der `TestClient` betreibt unter der Haube etwas Magie, um die asynchrone FastAPI-Anwendung in Ihren normalen `def`-Testfunktionen, mithilfe von Standard-Pytest aufzurufen. Aber diese Magie funktioniert nicht mehr, wenn wir sie in asynchronen Funktionen verwenden. Durch die asynchrone Ausführung unserer Tests können wir den `TestClient` nicht mehr in unseren Testfunktionen verwenden. -Der `TestClient` basiert auf HTTPX und glücklicherweise können wir ihn direkt verwenden, um die API zu testen. +Der `TestClient` basiert auf HTTPX und glücklicherweise können wir es direkt verwenden, um die API zu testen. ## Beispiel { #example } @@ -52,7 +52,7 @@ $ pytest
-## Details { #in-detail } +## Im Detail { #in-detail } Der Marker `@pytest.mark.anyio` teilt pytest mit, dass diese Testfunktion asynchron aufgerufen werden soll: diff --git a/docs/de/docs/advanced/behind-a-proxy.md b/docs/de/docs/advanced/behind-a-proxy.md index 884cc75fd..cb469b29b 100644 --- a/docs/de/docs/advanced/behind-a-proxy.md +++ b/docs/de/docs/advanced/behind-a-proxy.md @@ -297,7 +297,7 @@ Dies ist ein fortgeschrittener Anwendungsfall. Überspringen Sie das gerne. Standardmäßig erstellt **FastAPI** einen `server` im OpenAPI-Schema mit der URL für den `root_path`. -Sie können aber auch andere alternative `server` bereitstellen, beispielsweise wenn Sie möchten, dass *dieselbe* Dokumentationsoberfläche mit einer Staging- und Produktionsumgebung interagiert. +Sie können aber auch andere alternative `servers` bereitstellen, beispielsweise wenn Sie möchten, dass *dieselbe* Dokumentationsoberfläche mit einer Staging- und Produktionsumgebung interagiert. Wenn Sie eine benutzerdefinierte Liste von Servern (`servers`) übergeben und es einen `root_path` gibt (da Ihre API hinter einem Proxy läuft), fügt **FastAPI** einen „Server“ mit diesem `root_path` am Anfang der Liste ein. diff --git a/docs/de/docs/advanced/custom-response.md b/docs/de/docs/advanced/custom-response.md index d896d312c..d61920f84 100644 --- a/docs/de/docs/advanced/custom-response.md +++ b/docs/de/docs/advanced/custom-response.md @@ -91,7 +91,7 @@ Natürlich stammen der eigentliche `Content-Type`-Header, der Statuscode, usw., Wenn Sie die Response innerhalb der Funktion überschreiben und gleichzeitig den „Medientyp“ in OpenAPI dokumentieren möchten, können Sie den `response_class`-Parameter verwenden UND ein `Response`-Objekt zurückgeben. -Die `response_class` wird dann nur zur Dokumentation der OpenAPI-Pfadoperation* verwendet, Ihre `Response` wird jedoch unverändert verwendet. +Die `response_class` wird dann nur zur Dokumentation der OpenAPI-*Pfadoperation* verwendet, Ihre `Response` wird jedoch unverändert verwendet. #### Eine `HTMLResponse` direkt zurückgeben { #return-an-htmlresponse-directly } diff --git a/docs/de/docs/advanced/events.md b/docs/de/docs/advanced/events.md index d45de8409..1c3bb7aa2 100644 --- a/docs/de/docs/advanced/events.md +++ b/docs/de/docs/advanced/events.md @@ -110,7 +110,7 @@ In diesem Fall initialisiert die Eventhandler-Funktion `startup` die „Datenban Sie können mehr als eine Eventhandler-Funktion hinzufügen. -Und Ihre Anwendung empfängt erst dann Anfragen, wenn alle `startup`-Eventhandler abgeschlossen sind. +Und Ihre Anwendung empfängt erst dann Requests, wenn alle `startup`-Eventhandler abgeschlossen sind. ### `shutdown`-Event { #shutdown-event } diff --git a/docs/de/docs/advanced/generate-clients.md b/docs/de/docs/advanced/generate-clients.md index 65b4a4b91..f8fae132b 100644 --- a/docs/de/docs/advanced/generate-clients.md +++ b/docs/de/docs/advanced/generate-clients.md @@ -2,7 +2,7 @@ Da **FastAPI** auf der **OpenAPI**-Spezifikation basiert, können dessen APIs in einem standardisierten Format beschrieben werden, das viele Tools verstehen. -Dies vereinfacht es, aktuelle **Dokumentation** und Client-Bibliotheken (**SDKs**) in verschiedenen Sprachen zu generieren sowie **Test-** oder **Automatisierungs-Workflows**, die mit Ihrem Code synchron bleiben. +Dies vereinfacht es, aktuelle **Dokumentation** und Client-Bibliotheken (**SDKs**) in verschiedenen Sprachen zu generieren sowie **Test-** oder **Automatisierungs-Workflows**, die mit Ihrem Code synchron bleiben. In diesem Leitfaden erfahren Sie, wie Sie ein **TypeScript-SDK** für Ihr FastAPI-Backend generieren. diff --git a/docs/de/docs/advanced/index.md b/docs/de/docs/advanced/index.md index d969c4283..98fc7bc2f 100644 --- a/docs/de/docs/advanced/index.md +++ b/docs/de/docs/advanced/index.md @@ -14,7 +14,7 @@ Und es ist möglich, dass für Ihren Anwendungsfall die Lösung in einem davon l /// -## Lesen Sie zuerst das Tutorial { #read-the-tutorial-first } +## Das Tutorial zuerst lesen { #read-the-tutorial-first } Sie können immer noch die meisten Funktionen in **FastAPI** mit den Kenntnissen aus dem Haupt-[Tutorial – Benutzerhandbuch](../tutorial/index.md){.internal-link target=_blank} nutzen. diff --git a/docs/de/docs/advanced/middleware.md b/docs/de/docs/advanced/middleware.md index 80d57dbbe..59e15d3e2 100644 --- a/docs/de/docs/advanced/middleware.md +++ b/docs/de/docs/advanced/middleware.md @@ -8,7 +8,7 @@ In diesem Abschnitt werden wir sehen, wie man andere Middlewares verwendet. ## ASGI-Middleware hinzufügen { #adding-asgi-middlewares } -Da **FastAPI** auf Starlette basiert und die ASGI-Spezifikation implementiert, können Sie jede ASGI-Middleware verwenden. +Da **FastAPI** auf Starlette basiert und die ASGI-Spezifikation implementiert, können Sie jede ASGI-Middleware verwenden. Eine Middleware muss nicht speziell für FastAPI oder Starlette gemacht sein, um zu funktionieren, solange sie der ASGI-Spezifikation genügt. @@ -69,7 +69,7 @@ Die folgenden Argumente werden unterstützt: * `allowed_hosts` – Eine Liste von Domain-Namen, die als Hostnamen zulässig sein sollten. Wildcard-Domains wie `*.example.com` werden unterstützt, um Subdomains zu matchen. Um jeden Hostnamen zu erlauben, verwenden Sie entweder `allowed_hosts=["*"]` oder lassen Sie diese Middleware weg. -Wenn ein eingehender Request nicht korrekt validiert wird, wird eine „400“-Response gesendet. +Wenn ein eingehender Request nicht korrekt validiert wird, wird eine `400`-Response gesendet. ## `GZipMiddleware` { #gzipmiddleware } diff --git a/docs/de/docs/advanced/path-operation-advanced-configuration.md b/docs/de/docs/advanced/path-operation-advanced-configuration.md index ebfafaa22..ab1d511a7 100644 --- a/docs/de/docs/advanced/path-operation-advanced-configuration.md +++ b/docs/de/docs/advanced/path-operation-advanced-configuration.md @@ -149,7 +149,7 @@ Dennoch können wir das zu erwartende Schema für den Requestbody deklarieren. Mit demselben Trick könnten Sie ein Pydantic-Modell verwenden, um das JSON-Schema zu definieren, das dann im benutzerdefinierten Abschnitt des OpenAPI-Schemas für die *Pfadoperation* enthalten ist. -Und Sie könnten dies auch tun, wenn der Datentyp in der Anfrage nicht JSON ist. +Und Sie könnten dies auch tun, wenn der Datentyp im Request nicht JSON ist. In der folgenden Anwendung verwenden wir beispielsweise weder die integrierte Funktionalität von FastAPI zum Extrahieren des JSON-Schemas aus Pydantic-Modellen noch die automatische Validierung für JSON. Tatsächlich deklarieren wir den Request-Content-Type als YAML und nicht als JSON: diff --git a/docs/de/docs/advanced/response-change-status-code.md b/docs/de/docs/advanced/response-change-status-code.md index 2007e4dfa..011706e0a 100644 --- a/docs/de/docs/advanced/response-change-status-code.md +++ b/docs/de/docs/advanced/response-change-status-code.md @@ -1,8 +1,8 @@ # Response – Statuscode ändern { #response-change-status-code } -Sie haben wahrscheinlich schon vorher gelesen, dass Sie einen Standard-[Response-Statuscode](../tutorial/response-status-code.md){.internal-link target=_blank} festlegen können. +Sie haben wahrscheinlich schon vorher gelesen, dass Sie einen Default-[Response-Statuscode](../tutorial/response-status-code.md){.internal-link target=_blank} festlegen können. -In manchen Fällen müssen Sie jedoch einen anderen als den Standard-Statuscode zurückgeben. +In manchen Fällen müssen Sie jedoch einen anderen als den Default-Statuscode zurückgeben. ## Anwendungsfall { #use-case } diff --git a/docs/de/docs/advanced/response-headers.md b/docs/de/docs/advanced/response-headers.md index bef978dd5..9da1bbb39 100644 --- a/docs/de/docs/advanced/response-headers.md +++ b/docs/de/docs/advanced/response-headers.md @@ -38,4 +38,4 @@ Und da die `Response` häufig zum Setzen von Headern und Cookies verwendet wird, Beachten Sie, dass benutzerdefinierte proprietäre Header mittels des Präfix 'X-' hinzugefügt werden können. -Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen können soll, müssen Sie diese zu Ihren CORS-Konfigurationen hinzufügen (weitere Informationen finden Sie unter [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md){.internal-link target=_blank}), unter Verwendung des Parameters `expose_headers`, dokumentiert in Starlettes CORS-Dokumentation. +Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen können soll, müssen Sie diese zu Ihrer CORS-Konfiguration hinzufügen (weitere Informationen finden Sie unter [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md){.internal-link target=_blank}), unter Verwendung des Parameters `expose_headers`, dokumentiert in Starlettes CORS-Dokumentation. diff --git a/docs/de/docs/advanced/security/http-basic-auth.md b/docs/de/docs/advanced/security/http-basic-auth.md index cb16ffaa9..eff834b5d 100644 --- a/docs/de/docs/advanced/security/http-basic-auth.md +++ b/docs/de/docs/advanced/security/http-basic-auth.md @@ -58,7 +58,7 @@ Aber was ist ein „Timing-Angriff“? Stellen wir uns vor, dass einige Angreifer versuchen, den Benutzernamen und das Passwort zu erraten. -Und sie senden eine Anfrage mit dem Benutzernamen `johndoe` und dem Passwort `love123`. +Und sie senden einen Request mit dem Benutzernamen `johndoe` und dem Passwort `love123`. Dann würde der Python-Code in Ihrer Anwendung etwa so aussehen: @@ -78,11 +78,11 @@ if "stanleyjobsox" == "stanleyjobson" and "love123" == "swordfish": ... ``` -Python muss das gesamte `stanleyjobso` in `stanleyjobsox` und `stanleyjobson` vergleichen, bevor es erkennt, dass beide Zeichenfolgen nicht gleich sind. Daher wird es einige zusätzliche Mikrosekunden dauern, bis die Antwort „Incorrect username or password“ erfolgt. +Python muss das gesamte `stanleyjobso` in `stanleyjobsox` und `stanleyjobson` vergleichen, bevor es erkennt, dass beide Zeichenfolgen nicht gleich sind. Daher wird es einige zusätzliche Mikrosekunden dauern, bis die Response „Incorrect username or password“ erfolgt. #### Die Zeit zum Antworten hilft den Angreifern { #the-time-to-answer-helps-the-attackers } -Wenn die Angreifer zu diesem Zeitpunkt feststellen, dass der Server einige Mikrosekunden länger braucht, um die Antwort „Incorrect username or password“ zu senden, wissen sie, dass sie _etwas_ richtig gemacht haben, einige der Anfangsbuchstaben waren richtig. +Wenn die Angreifer zu diesem Zeitpunkt feststellen, dass der Server einige Mikrosekunden länger braucht, um die Response „Incorrect username or password“ zu senden, wissen sie, dass sie _etwas_ richtig gemacht haben, einige der Anfangsbuchstaben waren richtig. Und dann können sie es noch einmal versuchen, wohl wissend, dass es wahrscheinlich eher etwas mit `stanleyjobsox` als mit `johndoe` zu tun hat. diff --git a/docs/de/docs/advanced/security/index.md b/docs/de/docs/advanced/security/index.md index fda88c10a..d7e633231 100644 --- a/docs/de/docs/advanced/security/index.md +++ b/docs/de/docs/advanced/security/index.md @@ -12,7 +12,7 @@ Und es ist möglich, dass für Ihren Anwendungsfall die Lösung in einem davon l /// -## Lesen Sie zuerst das Tutorial { #read-the-tutorial-first } +## Das Tutorial zuerst lesen { #read-the-tutorial-first } Die nächsten Abschnitte setzen voraus, dass Sie das Haupt-[Tutorial – Benutzerhandbuch: Sicherheit](../../tutorial/security/index.md){.internal-link target=_blank} bereits gelesen haben. diff --git a/docs/de/docs/advanced/security/oauth2-scopes.md b/docs/de/docs/advanced/security/oauth2-scopes.md index cccb2cbe9..571c76f18 100644 --- a/docs/de/docs/advanced/security/oauth2-scopes.md +++ b/docs/de/docs/advanced/security/oauth2-scopes.md @@ -184,7 +184,7 @@ Wir verifizieren auch, dass wir einen Benutzer mit diesem Benutzernamen haben, u ## Die `scopes` verifizieren { #verify-the-scopes } -Wir überprüfen nun, ob das empfangenen Token alle Scopes enthält, die von dieser Abhängigkeit und deren Verwendern (einschließlich *Pfadoperationen*) gefordert werden. Andernfalls lösen wir eine `HTTPException` aus. +Wir überprüfen nun, ob das empfangene Token alle Scopes enthält, die von dieser Abhängigkeit und deren Verwendern (einschließlich *Pfadoperationen*) gefordert werden. Andernfalls lösen wir eine `HTTPException` aus. Hierzu verwenden wir `security_scopes.scopes`, das eine `list`e mit allen diesen Scopes als `str` enthält. diff --git a/docs/de/docs/advanced/settings.md b/docs/de/docs/advanced/settings.md index c8ffdcde2..29024c86c 100644 --- a/docs/de/docs/advanced/settings.md +++ b/docs/de/docs/advanced/settings.md @@ -118,7 +118,7 @@ Und dann würde die Einstellung `admin_email` auf `"deadpool@example.com"` geset Der `app_name` wäre `"ChimichangApp"`. -Und `items_per_user` würde seinen Standardwert von `50` behalten. +Und `items_per_user` würde seinen Defaultwert von `50` behalten. ## Einstellungen in einem anderen Modul { #settings-in-another-module } diff --git a/docs/de/docs/advanced/sub-applications.md b/docs/de/docs/advanced/sub-applications.md index 3b41946bc..d634aac23 100644 --- a/docs/de/docs/advanced/sub-applications.md +++ b/docs/de/docs/advanced/sub-applications.md @@ -2,7 +2,7 @@ Wenn Sie zwei unabhängige FastAPI-Anwendungen mit deren eigenen unabhängigen OpenAPI und deren eigenen Dokumentationsoberflächen benötigen, können Sie eine Hauptanwendung haben und dann eine (oder mehrere) Unteranwendung(en) „mounten“. -## Mounten einer **FastAPI**-Anwendung { #mounting-a-fastapi-application } +## Eine **FastAPI**-Anwendung mounten { #mounting-a-fastapi-application } „Mounten“ („Einhängen“) bedeutet das Hinzufügen einer völlig „unabhängigen“ Anwendung an einem bestimmten Pfad, die sich dann um die Handhabung aller unter diesem Pfad liegenden _Pfadoperationen_ kümmert, welche in dieser Unteranwendung deklariert sind. @@ -10,7 +10,7 @@ Wenn Sie zwei unabhängige FastAPI-Anwendungen mit deren eigenen unabhängigen O Erstellen Sie zunächst die Hauptanwendung **FastAPI** und deren *Pfadoperationen*: -{* ../../docs_src/sub_applications/tutorial001.py hl[3,6:8] *} +{* ../../docs_src/sub_applications/tutorial001.py hl[3, 6:8] *} ### Unteranwendung { #sub-application } @@ -18,7 +18,7 @@ Erstellen Sie dann Ihre Unteranwendung und deren *Pfadoperationen*. Diese Unteranwendung ist nur eine weitere Standard-FastAPI-Anwendung, aber diese wird „gemountet“: -{* ../../docs_src/sub_applications/tutorial001.py hl[11,14:16] *} +{* ../../docs_src/sub_applications/tutorial001.py hl[11, 14:16] *} ### Die Unteranwendung mounten { #mount-the-sub-application } @@ -26,7 +26,7 @@ Mounten Sie in Ihrer Top-Level-Anwendung `app` die Unteranwendung `subapi`. In diesem Fall wird sie im Pfad `/subapi` gemountet: -{* ../../docs_src/sub_applications/tutorial001.py hl[11,19] *} +{* ../../docs_src/sub_applications/tutorial001.py hl[11, 19] *} ### Die automatische API-Dokumentation testen { #check-the-automatic-api-docs } diff --git a/docs/de/docs/advanced/templates.md b/docs/de/docs/advanced/templates.md index f7f1a5e6b..1510d0a39 100644 --- a/docs/de/docs/advanced/templates.md +++ b/docs/de/docs/advanced/templates.md @@ -20,7 +20,7 @@ $ pip install jinja2
-## Verwendung von `Jinja2Templates` { #using-jinja2templates } +## `Jinja2Templates` verwenden { #using-jinja2templates } * Importieren Sie `Jinja2Templates`. * Erstellen Sie ein `templates`-Objekt, das Sie später wiederverwenden können. @@ -119,8 +119,8 @@ In diesem Beispiel würde das zu einer CSS-Datei unter `static/styles.css` verli {!../../docs_src/templates/static/styles.css!} ``` -Und da Sie `StaticFiles` verwenden, wird diese CSS-Datei automatisch von Ihrer **FastAPI**-Anwendung unter der URL `/static/styles.css` bereitgestellt. +Und da Sie `StaticFiles` verwenden, wird diese CSS-Datei automatisch von Ihrer **FastAPI**-Anwendung unter der URL `/static/styles.css` ausgeliefert. ## Mehr Details { #more-details } -Weitere Informationen, einschließlich, wie man Templates testet, finden Sie in der Starlette Dokumentation zu Templates. +Weitere Informationen, einschließlich, wie man Templates testet, finden Sie in Starlettes Dokumentation zu Templates. diff --git a/docs/de/docs/advanced/testing-dependencies.md b/docs/de/docs/advanced/testing-dependencies.md index 9961981a2..f673b78d2 100644 --- a/docs/de/docs/advanced/testing-dependencies.md +++ b/docs/de/docs/advanced/testing-dependencies.md @@ -14,11 +14,11 @@ Ein Beispiel könnte sein, dass Sie einen externen Authentifizierungsanbieter ha Sie senden ihm ein Token und er gibt einen authentifizierten Benutzer zurück. -Dieser Anbieter berechnet Ihnen möglicherweise Gebühren pro Anfrage, und der Aufruf könnte etwas länger dauern, als wenn Sie einen vordefinierten Scheinbenutzer für Tests hätten. +Dieser Anbieter berechnet Ihnen möglicherweise Gebühren pro Anfrage, und der Aufruf könnte etwas länger dauern, als wenn Sie einen vordefinierten Mock-Benutzer für Tests hätten. Sie möchten den externen Anbieter wahrscheinlich einmal testen, ihn aber nicht unbedingt bei jedem weiteren ausgeführten Test aufrufen. -In diesem Fall können Sie die Abhängigkeit, die diesen Anbieter aufruft, überschreiben und eine benutzerdefinierte Abhängigkeit verwenden, die einen Scheinbenutzer zurückgibt, nur für Ihre Tests. +In diesem Fall können Sie die Abhängigkeit, die diesen Anbieter aufruft, überschreiben und eine benutzerdefinierte Abhängigkeit verwenden, die einen Mock-Benutzer zurückgibt, nur für Ihre Tests. ### Das Attribut `app.dependency_overrides` verwenden { #use-the-app-dependency-overrides-attribute } @@ -46,6 +46,7 @@ Anschließend können Sie Ihre Überschreibungen zurücksetzen (entfernen), inde app.dependency_overrides = {} ``` + /// tip | Tipp Wenn Sie eine Abhängigkeit nur während einiger Tests überschreiben möchten, können Sie die Überschreibung zu Beginn des Tests (innerhalb der Testfunktion) festlegen und am Ende (am Ende der Testfunktion) zurücksetzen. diff --git a/docs/de/docs/advanced/testing-websockets.md b/docs/de/docs/advanced/testing-websockets.md index 059cbf13f..a71310cbf 100644 --- a/docs/de/docs/advanced/testing-websockets.md +++ b/docs/de/docs/advanced/testing-websockets.md @@ -8,6 +8,6 @@ Dazu verwenden Sie den `TestClient` in einer `with`-Anweisung, eine Verbindung z /// note | Hinweis -Weitere Informationen finden Sie in der Starlette-Dokumentation zum Testen von WebSockets. +Weitere Informationen finden Sie in Starlettes Dokumentation zum Testen von WebSockets. /// diff --git a/docs/de/docs/advanced/using-request-directly.md b/docs/de/docs/advanced/using-request-directly.md index 4701c5235..685e5f9b3 100644 --- a/docs/de/docs/advanced/using-request-directly.md +++ b/docs/de/docs/advanced/using-request-directly.md @@ -15,7 +15,7 @@ Es gibt jedoch Situationen, in denen Sie möglicherweise direkt auf das `Request ## Details zum `Request`-Objekt { #details-about-the-request-object } -Da **FastAPI** unter der Haube eigentlich **Starlette** ist, mit einer Ebene von mehreren Tools darüber, können Sie Starlette's `Request`-Objekt direkt verwenden, wenn Sie es benötigen. +Da **FastAPI** unter der Haube eigentlich **Starlette** ist, mit einer Ebene von mehreren Tools darüber, können Sie Starlettes `Request`-Objekt direkt verwenden, wenn Sie es benötigen. Das bedeutet allerdings auch, dass, wenn Sie Daten direkt vom `Request`-Objekt nehmen (z. B. dessen Body lesen), diese von FastAPI nicht validiert, konvertiert oder dokumentiert werden (mit OpenAPI, für die automatische API-Benutzeroberfläche). diff --git a/docs/de/docs/advanced/websockets.md b/docs/de/docs/advanced/websockets.md index 875bbb1a6..158377064 100644 --- a/docs/de/docs/advanced/websockets.md +++ b/docs/de/docs/advanced/websockets.md @@ -111,7 +111,7 @@ Diese funktionieren auf die gleiche Weise wie für andere FastAPI-Endpunkte/*Pfa {* ../../docs_src/websockets/tutorial002_an_py310.py hl[68:69,82] *} -/// info +/// info | Info Da es sich um einen WebSocket handelt, macht es keinen Sinn, eine `HTTPException` auszulösen, stattdessen lösen wir eine `WebSocketException` aus. @@ -150,7 +150,7 @@ Damit können Sie den WebSocket verbinden und dann Nachrichten senden und empfan -## Verbindungsabbrüche und mehreren Clients handhaben { #handling-disconnections-and-multiple-clients } +## Verbindungsabbrüche und mehrere Clients handhaben { #handling-disconnections-and-multiple-clients } Wenn eine WebSocket-Verbindung geschlossen wird, löst `await websocket.receive_text()` eine `WebSocketDisconnect`-Exception aus, die Sie dann wie in folgendem Beispiel abfangen und behandeln können. diff --git a/docs/de/docs/advanced/wsgi.md b/docs/de/docs/advanced/wsgi.md index a8e783907..1b547448c 100644 --- a/docs/de/docs/advanced/wsgi.md +++ b/docs/de/docs/advanced/wsgi.md @@ -16,7 +16,7 @@ Und dann mounten Sie das auf einem Pfad. ## Testen { #check-it } -Jetzt wird jede Anfrage unter dem Pfad `/v1/` von der Flask-Anwendung verarbeitet. +Jetzt wird jeder Request unter dem Pfad `/v1/` von der Flask-Anwendung verarbeitet. Und der Rest wird von **FastAPI** gehandhabt. diff --git a/docs/de/docs/async.md b/docs/de/docs/async.md index edca7f4c5..64542b47a 100644 --- a/docs/de/docs/async.md +++ b/docs/de/docs/async.md @@ -40,7 +40,7 @@ def results(): --- -Wenn Ihre Anwendung (irgendwie) mit nichts anderem kommunizieren und auf dessen Antwort warten muss, verwenden Sie `async def`, auch wenn Sie `await` im Inneren nicht verwenden müssen. +Wenn Ihre Anwendung (irgendwie) nicht mit etwas anderem kommunizieren und auf dessen Antwort warten muss, verwenden Sie `async def`, auch wenn Sie `await` im Inneren nicht verwenden müssen. --- @@ -316,16 +316,16 @@ Damit `await` funktioniert, muss es sich in einer Funktion befinden, die diese A ```Python hl_lines="1" async def get_burgers(number: int): - # Mach Sie hier etwas Asynchrones, um die Burger zu erstellen + # Mache hier etwas Asynchrones, um die Burger zu erstellen return burgers ``` ... statt mit `def`: ```Python hl_lines="2" -# Die ist nicht asynchron +# Dies ist nicht asynchron def get_sequential_burgers(number: int): - # Mach Sie hier etwas Sequentielles, um die Burger zu erstellen + # Mache hier etwas Sequentielles, um die Burger zu erstellen return burgers ``` @@ -363,9 +363,9 @@ Wenn Sie jedoch `async` / `await` ohne FastAPI verwenden möchten, können Sie d ### Schreiben Sie Ihren eigenen asynchronen Code { #write-your-own-async-code } -Starlette (und **FastAPI**) basiert auf AnyIO, was bedeutet, es ist sowohl kompatibel mit der Python-Standardbibliothek asyncio, als auch mit Trio. +Starlette (und **FastAPI**) basieren auf AnyIO, was bedeutet, dass es sowohl kompatibel mit der Python-Standardbibliothek asyncio als auch mit Trio ist. -Insbesondere können Sie AnyIO direkt verwenden für Ihre fortgeschritten nebenläufigen und parallelen Anwendungsfälle, die fortgeschrittenere Muster in Ihrem eigenen Code erfordern. +Insbesondere können Sie AnyIO direkt verwenden für Ihre fortgeschrittenen nebenläufigen und parallelen Anwendungsfälle, die fortgeschrittenere Muster in Ihrem eigenen Code erfordern. Und auch wenn Sie FastAPI nicht verwenden würden, könnten Sie Ihre eigenen asynchronen Anwendungen mit AnyIO schreiben, um hochkompatibel zu sein und dessen Vorteile zu nutzen (z. B. *strukturierte Nebenläufigkeit*). @@ -441,4 +441,4 @@ Wenn Ihre Hilfsfunktion eine normale Funktion mit `def` ist, wird sie direkt auf Nochmal, es handelt sich hier um sehr technische Details, die Ihnen helfen, falls Sie danach gesucht haben. -Andernfalls liegen Sie richtig, wenn Sie sich an die Richtlinien aus dem obigen Abschnitt halten: In Eile?. +Andernfalls liegen Sie richtig, wenn Sie sich an die Richtlinien aus dem obigen Abschnitt halten: In Eile?. diff --git a/docs/de/docs/deployment/concepts.md b/docs/de/docs/deployment/concepts.md index 7fb2e8426..f549f7fb2 100644 --- a/docs/de/docs/deployment/concepts.md +++ b/docs/de/docs/deployment/concepts.md @@ -13,7 +13,7 @@ Einige wichtige Konzepte sind: Wir werden sehen, wie diese sich auf das **Deployment** auswirken. -Letztendlich besteht das ultimative Ziel darin, **Ihre API-Clients** auf **sichere** Weise zu bedienen, um **Unterbrechungen** zu vermeiden und die **Rechenressourcen** (z. B. entfernte Server/virtuelle Maschinen) so effizient wie möglich zu nutzen. 🚀 +Letztendlich besteht das ultimative Ziel darin, **Ihre API-Clients** auf **sichere** Weise zu versorgen, um **Unterbrechungen** zu vermeiden und die **Rechenressourcen** (z. B. entfernte Server/virtuelle Maschinen) so effizient wie möglich zu nutzen. 🚀 Ich erzähle Ihnen hier etwas mehr über diese **Konzepte**, was Ihnen hoffentlich die **Intuition** gibt, die Sie benötigen, um zu entscheiden, wie Sie Ihre API in sehr unterschiedlichen Umgebungen bereitstellen, möglicherweise sogar in **zukünftigen**, die jetzt noch nicht existieren. diff --git a/docs/de/docs/deployment/docker.md b/docs/de/docs/deployment/docker.md index 4f7498a7d..85df44d63 100644 --- a/docs/de/docs/deployment/docker.md +++ b/docs/de/docs/deployment/docker.md @@ -190,7 +190,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"] 2. Setze das aktuelle Arbeitsverzeichnis auf `/code`. - Hier plazieren wir die Datei `requirements.txt` und das Verzeichnis `app`. + Hier platzieren wir die Datei `requirements.txt` und das Verzeichnis `app`. 3. Kopiere die Datei mit den Paketanforderungen in das Verzeichnis `/code`. @@ -277,7 +277,7 @@ Sie sollten jetzt eine Verzeichnisstruktur wie diese haben: #### Hinter einem TLS-Terminierungsproxy { #behind-a-tls-termination-proxy } -Wenn Sie Ihren Container hinter einem TLS-Terminierungsproxy (Load Balancer) wie Nginx oder Traefik ausführen, fügen Sie die Option `--proxy-headers` hinzu. Das sagt Uvicorn (durch das FastAPI CLI), den von diesem Proxy gesendeten Headern zu vertrauen und dass die Anwendung hinter HTTPS ausgeführt wird, usw. +Wenn Sie Ihren Container hinter einem TLS-Terminierungsproxy (Load Balancer) wie Nginx oder Traefik ausführen, fügen Sie die Option `--proxy-headers` hinzu. Das sagt Uvicorn (durch das FastAPI-CLI), den von diesem Proxy gesendeten Headern zu vertrauen und dass die Anwendung hinter HTTPS ausgeführt wird, usw. ```Dockerfile CMD ["fastapi", "run", "app/main.py", "--proxy-headers", "--port", "80"] @@ -411,7 +411,7 @@ CMD ["fastapi", "run", "main.py", "--port", "80"] 2. Verwenden Sie `fastapi run`, um Ihre Anwendung in der einzelnen Datei `main.py` bereitzustellen. -Indem Sie die Datei an `fastapi run` übergeben, wird automatisch erkannt, dass es sich um eine einzelne Datei handelt und nicht um den Teil eines Packages, und es wird wissen, wie es zu importieren ist und Ihre FastAPI-App auszuliefern. 😎 +Indem Sie die Datei an `fastapi run` übergeben, wird automatisch erkannt, dass es sich um eine einzelne Datei handelt und nicht um den Teil eines Packages, und es wird wissen, wie es zu importieren ist und Ihre FastAPI-App bereitzustellen. 😎 ## Deployment-Konzepte { #deployment-concepts } @@ -488,9 +488,9 @@ Und normalerweise wäre dieser **Load Balancer** in der Lage, Requests zu verarb ### Ein Prozess pro Container { #one-process-per-container } -In einem solchen Szenario möchten Sie wahrscheinlich **einen einzelnen (Uvicorn-)Prozess pro Container** haben, da Sie die Replikation bereits auf Cluster ebene durchführen würden. +In einem solchen Szenario möchten Sie wahrscheinlich **einen einzelnen (Uvicorn-)Prozess pro Container** haben, da Sie die Replikation bereits auf Cluster-Ebene durchführen würden. -In diesem Fall möchten Sie also **nicht** mehrere Worker im Container haben, z.B. mit der `--workers` Befehlszeilenoption. Sie möchten nur einen **einzelnen Uvicorn-Prozess** pro Container haben (wahrscheinlich aber mehrere Container). +In diesem Fall möchten Sie also **nicht** mehrere Worker im Container haben, z. B. mit der `--workers` Befehlszeilenoption. Sie möchten nur einen **einzelnen Uvicorn-Prozess** pro Container haben (wahrscheinlich aber mehrere Container). Ein weiterer Prozessmanager im Container (wie es bei mehreren Workern der Fall wäre) würde nur **unnötige Komplexität** hinzufügen, um welche Sie sich höchstwahrscheinlich bereits mit Ihrem Clustersystem kümmern. @@ -556,7 +556,7 @@ Wenn Sie Container (z. B. Docker, Kubernetes) verwenden, können Sie hauptsächl ### Mehrere Container { #multiple-containers } -Wenn Sie **mehrere Container** haben, von denen wahrscheinlich jeder einen **einzelnen Prozess** ausführt (z. B. in einem **Kubernetes**-Cluster), dann möchten Sie wahrscheinlich einen **separaten Container** haben, welcher die Arbeit der **Vorab-Schritte** in einem einzelnen Container, mit einem einzelnenen Prozess ausführt, **bevor** die replizierten Workercontainer ausgeführt werden. +Wenn Sie **mehrere Container** haben, von denen wahrscheinlich jeder einen **einzelnen Prozess** ausführt (z. B. in einem **Kubernetes**-Cluster), dann möchten Sie wahrscheinlich einen **separaten Container** haben, welcher die Arbeit der **Vorab-Schritte** in einem einzelnen Container, mit einem einzelnen Prozess ausführt, **bevor** die replizierten Workercontainer ausgeführt werden. /// info | Info diff --git a/docs/de/docs/deployment/https.md b/docs/de/docs/deployment/https.md index 11692926c..c8e11fd10 100644 --- a/docs/de/docs/deployment/https.md +++ b/docs/de/docs/deployment/https.md @@ -28,8 +28,8 @@ Aus **Sicht des Entwicklers** sollten Sie beim Nachdenken über HTTPS Folgendes * **Standardmäßig** bedeutet das, dass Sie nur **ein HTTPS-Zertifikat pro IP-Adresse** haben können. * Ganz gleich, wie groß Ihr Server ist oder wie klein die einzelnen Anwendungen darauf sind. * Hierfür gibt es jedoch eine **Lösung**. -* Es gibt eine **Erweiterung** zum **TLS**-Protokoll (dasjenige, das die Verschlüsselung auf TCP-Ebene, vor HTTP, verwaltet) namens **SNI**. - * Mit dieser SNI-Erweiterung kann ein einzelner Server (mit einer **einzelnen IP-Adresse**) über **mehrere HTTPS-Zertifikate** verfügen und **mehrere HTTPS-Domains/Anwendungen** bedienen. +* Es gibt eine **Erweiterung** zum **TLS**-Protokoll (dasjenige, das die Verschlüsselung auf TCP-Ebene, vor HTTP, verwaltet) namens **SNI**. + * Mit dieser SNI-Erweiterung kann ein einzelner Server (mit einer **einzelnen IP-Adresse**) über **mehrere HTTPS-Zertifikate** verfügen und **mehrere HTTPS-Domains/Anwendungen bereitstellen**. * Damit das funktioniert, muss eine **einzelne** Komponente (Programm), die auf dem Server ausgeführt wird und welche die **öffentliche IP-Adresse** überwacht, **alle HTTPS-Zertifikate** des Servers haben. * **Nachdem** eine sichere Verbindung hergestellt wurde, ist das Kommunikationsprotokoll **immer noch HTTP**. * Die Inhalte sind **verschlüsselt**, auch wenn sie mit dem **HTTP-Protokoll** gesendet werden. diff --git a/docs/de/docs/deployment/manually.md b/docs/de/docs/deployment/manually.md index 1efd169d5..daf3fad55 100644 --- a/docs/de/docs/deployment/manually.md +++ b/docs/de/docs/deployment/manually.md @@ -46,7 +46,7 @@ Sie könnten diesen Befehl beispielsweise verwenden, um Ihre **FastAPI**-App in Lassen Sie uns ein wenig tiefer in die Details eintauchen. -FastAPI verwendet einen Standard zum Erstellen von Python-Webframeworks und -Servern, der als ASGI bekannt ist. FastAPI ist ein ASGI-Webframework. +FastAPI verwendet einen Standard zum Erstellen von Python-Webframeworks und -Servern, der als ASGI bekannt ist. FastAPI ist ein ASGI-Webframework. Das Wichtigste, was Sie benötigen, um eine **FastAPI**-Anwendung (oder eine andere ASGI-Anwendung) auf einer entfernten Servermaschine auszuführen, ist ein ASGI-Serverprogramm wie **Uvicorn**, der standardmäßig im `fastapi`-Kommando enthalten ist. @@ -64,7 +64,7 @@ Es gibt ein kleines Detail bei den Namen, das Sie beachten sollten. 💡 Das Wort „**Server**“ wird häufig verwendet, um sowohl den entfernten/Cloud-Computer (die physische oder virtuelle Maschine) als auch das Programm zu bezeichnen, das auf dieser Maschine läuft (z. B. Uvicorn). -Denken Sie einfach daran, dass sich "Server" im Allgemeinen auf eines dieser beiden Dinge beziehen kann. +Denken Sie einfach daran, dass sich „Server“ im Allgemeinen auf eines dieser beiden Dinge beziehen kann. Wenn man sich auf die entfernte Maschine bezieht, wird sie üblicherweise als **Server**, aber auch als **Maschine**, **VM** (virtuelle Maschine) oder **Knoten** bezeichnet. Diese Begriffe beziehen sich auf irgendeine Art von entfernten Rechner, normalerweise unter Linux, auf dem Sie Programme ausführen. diff --git a/docs/de/docs/deployment/server-workers.md b/docs/de/docs/deployment/server-workers.md index 5bd6adad4..2654a70af 100644 --- a/docs/de/docs/deployment/server-workers.md +++ b/docs/de/docs/deployment/server-workers.md @@ -113,9 +113,9 @@ Sie können auch sehen, dass die **PID** jedes Prozesses angezeigt wird, `27365` ## Deployment-Konzepte { #deployment-concepts } -Hier haben Sie gesehen, wie Sie mehrere **Worker** verwenden, um die Ausführung der Anwendung zu **parallelisieren**, **mehrere Kerne** der CPU zu nutzen und in der Lage zu sein, **mehr Requests** zu bedienen. +Hier haben Sie gesehen, wie Sie mehrere **Worker** verwenden, um die Ausführung der Anwendung zu **parallelisieren**, **mehrere Kerne** der CPU zu nutzen und in der Lage zu sein, **mehr Requests** zu bearbeiten. -In der Liste der Deployment-Konzepte von oben würde die Verwendung von Workern hauptsächlich beim **Replikation**-Teil und ein wenig bei **Neustarts** helfen, aber Sie müssen sich trotzdem um die anderen kümmern: +In der Liste der Deployment-Konzepte von oben würde die Verwendung von Workern hauptsächlich bei der **Replikation** und ein wenig bei **Neustarts** helfen, aber Sie müssen sich trotzdem um die anderen kümmern: * **Sicherheit – HTTPS** * **Beim Hochfahren ausführen** diff --git a/docs/de/docs/deployment/versions.md b/docs/de/docs/deployment/versions.md index d28705d75..a749f4e10 100644 --- a/docs/de/docs/deployment/versions.md +++ b/docs/de/docs/deployment/versions.md @@ -12,7 +12,7 @@ Sie können jetzt Produktionsanwendungen mit **FastAPI** erstellen (und das tun Als Erstes sollten Sie die Version von **FastAPI**, die Sie verwenden, an die höchste Version „pinnen“, von der Sie wissen, dass sie für Ihre Anwendung korrekt funktioniert. -Angenommen, Sie verwenden in Ihrer Anwendung die Version `0.112.0`. +Angenommen, Sie verwenden in Ihrer App die Version `0.112.0`. Wenn Sie eine `requirements.txt`-Datei verwenden, können Sie die Version wie folgt angeben: @@ -64,7 +64,7 @@ Nicht abwärtskompatible Änderungen und neue Funktionen werden in „MINOR“-V ## Upgrade der FastAPI-Versionen { #upgrading-the-fastapi-versions } -Sie sollten Tests für Ihre Anwendung hinzufügen. +Sie sollten Tests für Ihre App hinzufügen. Mit **FastAPI** ist das sehr einfach (dank Starlette), schauen Sie sich die Dokumentation an: [Testen](../tutorial/testing.md){.internal-link target=_blank} @@ -87,6 +87,7 @@ Pydantic integriert die Tests für **FastAPI** in seine eigenen Tests, sodass ne Sie können Pydantic an jede für Sie geeignete Version über `1.0.0` anpinnen. Zum Beispiel: + ```txt pydantic>=2.7.0,<3.0.0 ``` diff --git a/docs/de/docs/fastapi-cli.md b/docs/de/docs/fastapi-cli.md index a867ab872..5a2ed9b94 100644 --- a/docs/de/docs/fastapi-cli.md +++ b/docs/de/docs/fastapi-cli.md @@ -1,6 +1,6 @@ # FastAPI CLI { #fastapi-cli } -**FastAPI CLI** ist ein Kommandozeilenprogramm, mit dem Sie Ihre FastAPI-App ausliefern, Ihr FastAPI-Projekt verwalten und mehr. +**FastAPI CLI** ist ein Kommandozeilenprogramm, mit dem Sie Ihre FastAPI-App bereitstellen, Ihr FastAPI-Projekt verwalten und mehr. Wenn Sie FastAPI installieren (z. B. mit `pip install "fastapi[standard]"`), wird ein Package namens `fastapi-cli` mitgeliefert, das den Befehl `fastapi` im Terminal bereitstellt. @@ -48,7 +48,7 @@ $ fastapi dev OpenAPI für die Erstellung von APIs, inklusive Deklarationen von Pfad-Operationen, Parametern, Requestbodys, Sicherheit, usw. +* OpenAPI für die Erstellung von APIs, inklusive Deklarationen von Pfad-Operationen, Parametern, Requestbodys, Sicherheit, usw. * Automatische Dokumentation der Datenmodelle mit JSON Schema (da OpenAPI selbst auf JSON Schema basiert). * Um diese Standards herum entworfen, nach sorgfältigem Studium. Statt einer nachträglichen Schicht darüber. * Dies ermöglicht auch automatische **Client-Code-Generierung** in vielen Sprachen. @@ -25,7 +25,7 @@ Interaktive API-Dokumentation und erkundbare Web-Benutzeroberflächen. Da das Fr ### Nur modernes Python { #just-modern-python } -Alles basiert auf **Python 3.8 Typ**-Deklarationen (dank Pydantic). Es muss keine neue Syntax gelernt werden, nur standardisiertes modernes Python. +Alles basiert auf Standard-**Python-Typ**-Deklarationen (dank Pydantic). Es muss keine neue Syntax gelernt werden, nur standardisiertes modernes Python. Wenn Sie eine zweiminütige Auffrischung benötigen, wie man Python-Typen verwendet (auch wenn Sie FastAPI nicht benutzen), schauen Sie sich das kurze Tutorial an: [Einführung in Python-Typen](python-types.md){.internal-link target=_blank}. @@ -126,8 +126,8 @@ Alle in OpenAPI definierten Sicherheitsschemas, inklusive: * HTTP Basic. * **OAuth2** (auch mit **JWT Tokens**). Siehe dazu das Tutorial zu [OAuth2 mit JWT](tutorial/security/oauth2-jwt.md){.internal-link target=_blank}. * API Schlüssel in: - * Header-Feldern. - * Anfrageparametern. + * Headern. + * Query-Parametern. * Cookies, usw. Zusätzlich alle Sicherheitsfunktionen von Starlette (inklusive **Session Cookies**). @@ -157,7 +157,7 @@ Jede Integration wurde so entworfen, dass sie so einfach zu nutzen ist (mit Abh * 100 % Typen annotiert. * Verwendet in Produktionsanwendungen. -## Starlette's Merkmale { #starlette-features } +## Starlette Merkmale { #starlette-features } **FastAPI** ist vollkommen kompatibel (und basiert auf) Starlette. Das bedeutet, wenn Sie eigenen Starlette Quellcode haben, funktioniert der. @@ -175,11 +175,11 @@ Mit **FastAPI** bekommen Sie alles von **Starlette** (da FastAPI nur Starlette a * 100 % Testabdeckung. * 100 % Typen annotierte Codebasis. -## Pydantic's Merkmale { #pydantic-features } +## Pydantic Merkmale { #pydantic-features } **FastAPI** ist vollkommen kompatibel (und basiert auf) Pydantic. Das bedeutet, wenn Sie eigenen Pydantic Quellcode haben, funktioniert der. -Inklusive externer Bibliotheken, die auf Pydantic basieren, wie ORMs, ODMs für Datenbanken. +Inklusive externer Bibliotheken, die auf Pydantic basieren, wie ORMs, ODMs für Datenbanken. Daher können Sie in vielen Fällen das Objekt einer Anfrage **direkt zur Datenbank** schicken, weil alles automatisch validiert wird. @@ -190,7 +190,7 @@ Mit **FastAPI** bekommen Sie alle Funktionen von **Pydantic** (da FastAPI für d * **Kein Kopfzerbrechen**: * Keine neue Schemadefinition-Mikrosprache zu lernen. * Wenn Sie Pythons Typen kennen, wissen Sie, wie man Pydantic verwendet. -* Gutes Zusammenspiel mit Ihrer/Ihrem **IDE/Linter/Gehirn**: +* Gutes Zusammenspiel mit Ihrer/Ihrem **IDE/Linter/Gehirn**: * Weil Pydantics Datenstrukturen einfach nur Instanzen ihrer definierten Klassen sind; Autovervollständigung, Linting, mypy und Ihre Intuition sollten alle einwandfrei mit Ihren validierten Daten funktionieren. * Validierung von **komplexen Strukturen**: * Benutzung von hierarchischen Pydantic-Modellen, Python-`typing`s `List` und `Dict`, etc. diff --git a/docs/de/docs/how-to/conditional-openapi.md b/docs/de/docs/how-to/conditional-openapi.md index 948519a67..a58351cf9 100644 --- a/docs/de/docs/how-to/conditional-openapi.md +++ b/docs/de/docs/how-to/conditional-openapi.md @@ -10,7 +10,7 @@ Dadurch wird Ihrer API keine zusätzliche Sicherheit hinzugefügt, die *Pfadoper Wenn Ihr Code eine Sicherheitslücke aufweist, ist diese weiterhin vorhanden. -Das Verstecken der Dokumentation macht es nur schwieriger zu verstehen, wie mit Ihrer API interagiert werden kann, und könnte es auch schwieriger machen, diese in der Produktion zu debuggen. Man könnte es einfach als eine Form von Security through obscurity betrachten. +Das Verstecken der Dokumentation macht es nur schwieriger zu verstehen, wie mit Ihrer API interagiert werden kann, und könnte es auch schwieriger machen, diese in der Produktion zu debuggen. Man könnte es einfach als eine Form von Security through Obscurity betrachten. Wenn Sie Ihre API sichern möchten, gibt es mehrere bessere Dinge, die Sie tun können, zum Beispiel: diff --git a/docs/de/docs/how-to/configure-swagger-ui.md b/docs/de/docs/how-to/configure-swagger-ui.md index cd899c483..d99d19912 100644 --- a/docs/de/docs/how-to/configure-swagger-ui.md +++ b/docs/de/docs/how-to/configure-swagger-ui.md @@ -52,9 +52,9 @@ Um beispielsweise `deepLinking` zu deaktivieren, könnten Sie folgende Einstellu Um alle anderen möglichen Konfigurationen zu sehen, die Sie verwenden können, lesen Sie die offizielle Dokumentation für die Parameter der Swagger-Oberfläche. -## JavaScript-basierte Einstellungen { #javascript-only-settings } +## Nur-JavaScript-Einstellungen { #javascript-only-settings } -Die Swagger-Oberfläche erlaubt, dass andere Konfigurationen auch **JavaScript**-Objekte sein können (z. B. JavaScript-Funktionen). +Die Swagger-Oberfläche erlaubt, dass andere Konfigurationen auch **Nur-JavaScript**-Objekte sein können (z. B. JavaScript-Funktionen). FastAPI umfasst auch diese Nur-JavaScript-`presets`-Einstellungen: diff --git a/docs/de/docs/how-to/custom-docs-ui-assets.md b/docs/de/docs/how-to/custom-docs-ui-assets.md index a2601eb5d..92322a9cd 100644 --- a/docs/de/docs/how-to/custom-docs-ui-assets.md +++ b/docs/de/docs/how-to/custom-docs-ui-assets.md @@ -2,13 +2,13 @@ Die API-Dokumentation verwendet **Swagger UI** und **ReDoc**, und jede dieser Dokumentationen benötigt einige JavaScript- und CSS-Dateien. -Standardmäßig werden diese Dateien von einem CDN bereitgestellt. +Standardmäßig werden diese Dateien von einem CDN bereitgestellt. Es ist jedoch möglich, das anzupassen, ein bestimmtes CDN festzulegen oder die Dateien selbst bereitzustellen. ## Benutzerdefiniertes CDN für JavaScript und CSS { #custom-cdn-for-javascript-and-css } -Nehmen wir an, Sie möchten ein anderes CDN verwenden, zum Beispiel möchten Sie `https://unpkg.com/` verwenden. +Nehmen wir an, Sie möchten ein anderes CDN verwenden, zum Beispiel möchten Sie `https://unpkg.com/` verwenden. Das kann nützlich sein, wenn Sie beispielsweise in einem Land leben, in dem bestimmte URLs eingeschränkt sind. @@ -29,8 +29,8 @@ Sie können die internen Funktionen von FastAPI wiederverwenden, um die HTML-Sei * `openapi_url`: die URL, unter welcher die HTML-Seite für die Dokumentation das OpenAPI-Schema für Ihre API abrufen kann. Sie können hier das Attribut `app.openapi_url` verwenden. * `title`: der Titel Ihrer API. * `oauth2_redirect_url`: Sie können hier `app.swagger_ui_oauth2_redirect_url` verwenden, um die Standardeinstellung zu verwenden. -* `swagger_js_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **JavaScript**-Datei abrufen kann. Dies ist die benutzerdefinierte CDN-URL. -* `swagger_css_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **CSS**-Datei abrufen kann. Dies ist die benutzerdefinierte CDN-URL. +* `swagger_js_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **JavaScript**-Datei abrufen kann. Dies ist die benutzerdefinite CDN-URL. +* `swagger_css_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **CSS**-Datei abrufen kann. Dies ist die benutzerdefinite CDN-URL. Und ähnlich für ReDoc... diff --git a/docs/de/docs/how-to/general.md b/docs/de/docs/how-to/general.md index 3adf9eee1..1a9536e80 100644 --- a/docs/de/docs/how-to/general.md +++ b/docs/de/docs/how-to/general.md @@ -28,12 +28,12 @@ Um Daten in etwas JSON-kompatibles zu konvertieren, lesen Sie die Dokumentation ## OpenAPI-Metadaten – Dokumentation { #openapi-metadata-docs } -Um Metadaten zu Ihrem OpenAPI-Schema hinzuzufügen, einschließlich einer Lizenz, Version, Kontakt, usw., lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentationen](../tutorial/metadata.md){.internal-link target=_blank}. +Um Metadaten zu Ihrem OpenAPI-Schema hinzuzufügen, einschließlich einer Lizenz, Version, Kontakt, usw., lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentation](../tutorial/metadata.md){.internal-link target=_blank}. ## Benutzerdefinierte OpenAPI-URL { #openapi-custom-url } -Um die OpenAPI-URL anzupassen (oder zu entfernen), lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentationen](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}. +Um die OpenAPI-URL anzupassen (oder zu entfernen), lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentation](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}. ## URLs der OpenAPI-Dokumentationen { #openapi-docs-urls } -Um die URLs zu aktualisieren, die für die automatisch generierten Dokumentations-Oberflächen verwendet werden, lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentationen](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}. +Um die URLs zu aktualisieren, die für die automatisch generierten Dokumentations-Oberflächen verwendet werden, lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentation](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}. diff --git a/docs/de/docs/how-to/graphql.md b/docs/de/docs/how-to/graphql.md index 1216380d1..3e46e2bc7 100644 --- a/docs/de/docs/how-to/graphql.md +++ b/docs/de/docs/how-to/graphql.md @@ -29,7 +29,7 @@ Hier sind einige der **GraphQL**-Bibliotheken, die **ASGI**-Unterstützung haben ## GraphQL mit Strawberry { #graphql-with-strawberry } -Wenn Sie mit **GraphQL** arbeiten möchten oder müssen, ist **Strawberry** die **empfohlene** Bibliothek, da deren Design dem Design von **FastAPI** am nächsten kommt und alles auf **Typannotationen** basiert. +Wenn Sie mit **GraphQL** arbeiten möchten oder müssen, ist **Strawberry** die **empfohlene** Bibliothek, da deren Design **FastAPIs** Design am nächsten kommt und alles auf **Typannotationen** basiert. Abhängig von Ihrem Anwendungsfall könnten Sie eine andere Bibliothek vorziehen, aber wenn Sie mich fragen würden, würde ich Ihnen wahrscheinlich empfehlen, **Strawberry** auszuprobieren. diff --git a/docs/de/docs/index.md b/docs/de/docs/index.md index bda5bc53b..cd68bc128 100644 --- a/docs/de/docs/index.md +++ b/docs/de/docs/index.md @@ -33,7 +33,7 @@ --- -FastAPI ist ein modernes, schnelles (hoch performantes) Webframework zur Erstellung von APIs mit Python auf Basis von Standard-Python-Type-Hinweisen. +FastAPI ist ein modernes, schnelles (hoch performantes) Webframework zur Erstellung von APIs mit Python auf Basis von Standard-Python-Typhinweisen. Seine Schlüssel-Merkmale sind: diff --git a/docs/de/docs/project-generation.md b/docs/de/docs/project-generation.md index def342d62..ac353375a 100644 --- a/docs/de/docs/project-generation.md +++ b/docs/de/docs/project-generation.md @@ -8,7 +8,7 @@ GitHub-Repository: Typ einer Variablen zu deklarieren. @@ -38,7 +38,7 @@ Die Funktion macht Folgendes: {* ../../docs_src/python_types/tutorial001.py hl[2] *} -### Bearbeiten Sie es { #edit-it } +### Es bearbeiten { #edit-it } Es ist ein sehr einfaches Programm. @@ -368,7 +368,7 @@ say_hi() # Oh, nein, das löst einen Fehler aus! 😱 Der `name` Parameter wird **immer noch benötigt** (nicht *optional*), weil er keinen Default-Wert hat. `name` akzeptiert aber dennoch `None` als Wert: ```Python -say_hi(name=None) # Das funktioniert, None is gültig 🎉 +say_hi(name=None) # Das funktioniert, None ist gültig 🎉 ``` Die gute Nachricht ist, dass Sie sich darüber keine Sorgen mehr machen müssen, wenn Sie Python 3.10 verwenden, da Sie einfach `|` verwenden können, um Vereinigungen von Typen zu definieren: @@ -449,7 +449,7 @@ Beachten Sie, das bedeutet: „`one_person` ist eine **Instanz** der Klasse `Per Es bedeutet nicht: „`one_person` ist die **Klasse** genannt `Person`“. -## Pydantic Modelle { #pydantic-models } +## Pydantic-Modelle { #pydantic-models } Pydantic ist eine Python-Bibliothek für die Validierung von Daten. @@ -495,17 +495,17 @@ Um mehr über Required fields mehr erfahren. +Pydantic verhält sich speziell, wenn Sie `Optional` oder `Union[Something, None]` ohne einen Defaultwert verwenden. Sie können darüber in der Pydantic Dokumentation unter Erforderliche optionale Felder mehr erfahren. /// ## Typhinweise mit Metadaten-Annotationen { #type-hints-with-metadata-annotations } -Python bietet auch die Möglichkeit, **zusätzliche Metadaten** in Typhinweisen unterzubringen, mittels `Annotated`. +Python bietet auch die Möglichkeit, **zusätzliche Metadaten** in Typhinweisen unterzubringen, mittels `Annotated`. //// tab | Python 3.9+ @@ -565,7 +565,7 @@ Mit **FastAPI** deklarieren Sie Parameter mit Typhinweisen, und Sie erhalten: * Die API mit OpenAPI zu **dokumentieren**: * Die dann von den Benutzeroberflächen der automatisch generierten interaktiven Dokumentation verwendet wird. -Das mag alles abstrakt klingen. Machen Sie sich keine Sorgen. Sie werden all das in Aktion sehen im [Tutorial - Benutzerhandbuch](tutorial/index.md){.internal-link target=_blank}. +Das mag alles abstrakt klingen. Machen Sie sich keine Sorgen. Sie werden all das in Aktion sehen im [Tutorial – Benutzerhandbuch](tutorial/index.md){.internal-link target=_blank}. Das Wichtigste ist, dass **FastAPI** durch die Verwendung von Standard-Python-Typen an einer einzigen Stelle (anstatt weitere Klassen, Dekoratoren usw. hinzuzufügen) einen Großteil der Arbeit für Sie erledigt. diff --git a/docs/de/docs/tutorial/body-fields.md b/docs/de/docs/tutorial/body-fields.md index 0fcaf6557..b73d57d2d 100644 --- a/docs/de/docs/tutorial/body-fields.md +++ b/docs/de/docs/tutorial/body-fields.md @@ -1,6 +1,6 @@ # Body – Felder { #body-fields } -So wie Sie zusätzliche Validation und Metadaten in Parametern der *Pfadoperation-Funktion* mittels `Query`, `Path` und `Body` deklarieren, können Sie auch innerhalb von Pydantic-Modellen zusätzliche Validierung und Metadaten deklarieren, mittels Pydantics `Field`. +So wie Sie zusätzliche Validierung und Metadaten in Parametern der *Pfadoperation-Funktion* mittels `Query`, `Path` und `Body` deklarieren, können Sie auch innerhalb von Pydantic-Modellen zusätzliche Validierung und Metadaten deklarieren, mittels Pydantics `Field`. ## `Field` importieren { #import-field } diff --git a/docs/de/docs/tutorial/body.md b/docs/de/docs/tutorial/body.md index 403ed3842..9fc288f4e 100644 --- a/docs/de/docs/tutorial/body.md +++ b/docs/de/docs/tutorial/body.md @@ -8,7 +8,7 @@ Ihre API muss fast immer einen **Response**body senden. Aber Clients müssen nic Um einen **Request**body zu deklarieren, verwenden Sie Pydantic-Modelle mit all deren Fähigkeiten und Vorzügen. -/// info | Hinweis +/// info | Info Um Daten zu senden, sollten Sie eines von: `POST` (meistverwendet), `PUT`, `DELETE` oder `PATCH` verwenden. @@ -18,13 +18,13 @@ Da davon abgeraten wird, zeigt die interaktive Dokumentation mit Swagger-Benutze /// -## Importieren Sie Pydantics `BaseModel` { #import-pydantics-basemodel } +## Pydantics `BaseModel` importieren { #import-pydantics-basemodel } Zuerst müssen Sie `BaseModel` von `pydantic` importieren: {* ../../docs_src/body/tutorial001_py310.py hl[2] *} -## Erstellen Sie Ihr Datenmodell { #create-your-data-model } +## Ihr Datenmodell erstellen { #create-your-data-model } Dann deklarieren Sie Ihr Datenmodell als eine Klasse, die von `BaseModel` erbt. @@ -54,7 +54,7 @@ Da `description` und `tax` optional sind (mit `None` als Defaultwert), wäre fol } ``` -## Deklarieren Sie es als Parameter { #declare-it-as-a-parameter } +## Als Parameter deklarieren { #declare-it-as-a-parameter } Um es zu Ihrer *Pfadoperation* hinzuzufügen, deklarieren Sie es auf die gleiche Weise, wie Sie Pfad- und Query-Parameter deklariert haben: @@ -73,7 +73,7 @@ Mit nur dieser Python-Typdeklaration wird **FastAPI**: * Ihnen die erhaltenen Daten im Parameter `item` übergeben. * Da Sie ihn in der Funktion als vom Typ `Item` deklariert haben, erhalten Sie auch die volle Unterstützung des Editors (Autovervollständigung, usw.) für alle Attribute und deren Typen. * JSON Schema-Definitionen für Ihr Modell generieren, die Sie auch überall sonst verwenden können, wenn es für Ihr Projekt Sinn macht. -* Diese Schemas werden Teil des generierten OpenAPI-Schemas und werden von den UIs der automatischen Dokumentation genutzt. +* Diese Schemas werden Teil des generierten OpenAPI-Schemas und werden von den UIs der automatischen Dokumentation genutzt. ## Automatische Dokumentation { #automatic-docs } diff --git a/docs/de/docs/tutorial/cors.md b/docs/de/docs/tutorial/cors.md index 40d73c50d..2d6ec224c 100644 --- a/docs/de/docs/tutorial/cors.md +++ b/docs/de/docs/tutorial/cors.md @@ -1,6 +1,6 @@ # CORS (Cross-Origin Resource Sharing) { #cors-cross-origin-resource-sharing } -CORS oder „Cross-Origin Resource Sharing“ bezieht sich auf Situationen, in denen ein Frontend, das in einem Browser läuft, JavaScript-Code enthält, der mit einem Backend kommuniziert, und das Backend sich in einem anderen „Origin“ als das Frontend befindet. +CORS oder „Cross-Origin Resource Sharing“ bezieht sich auf Situationen, in denen ein Frontend, das in einem Browser läuft, JavaScript-Code enthält, der mit einem Backend kommuniziert, und das Backend sich in einem anderen „Origin“ als das Frontend befindet. ## Origin { #origin } @@ -77,7 +77,7 @@ Jeder Request mit einem `Origin`-Header. In diesem Fall wird die Middleware den ## Weitere Informationen { #more-info } -Weitere Informationen zu CORS finden Sie in der Mozilla CORS-Dokumentation. +Weitere Informationen zu CORS finden Sie in der Mozilla CORS-Dokumentation. /// note | Technische Details diff --git a/docs/de/docs/tutorial/debugging.md b/docs/de/docs/tutorial/debugging.md index 7970ff5bf..927bea771 100644 --- a/docs/de/docs/tutorial/debugging.md +++ b/docs/de/docs/tutorial/debugging.md @@ -86,10 +86,10 @@ Da Sie den Uvicorn-Server direkt aus Ihrem Code ausführen, können Sie Ihr Pyth Zum Beispiel können Sie in Visual Studio Code: -* Zum "Debug"-Panel gehen. -* "Konfiguration hinzufügen..." auswählen. -* "Python" auswählen. -* Den Debugger mit der Option "`Python: Current File (Integrated Terminal)`" ausführen. +* Zum „Debug“-Panel gehen. +* „Konfiguration hinzufügen...“ auswählen. +* „Python“ auswählen. +* Den Debugger mit der Option „`Python: Current File (Integrated Terminal)`“ ausführen. Der Server wird dann mit Ihrem **FastAPI**-Code gestartet, an Ihren Haltepunkten angehalten, usw. @@ -101,8 +101,8 @@ So könnte es aussehen: Wenn Sie Pycharm verwenden, können Sie: -* Das Menü "Run" öffnen. -* Die Option "Debug..." auswählen. +* Das Menü „Run“ öffnen. +* Die Option „Debug...“ auswählen. * Ein Kontextmenü wird angezeigt. * Die zu debuggende Datei auswählen (in diesem Fall `main.py`). diff --git a/docs/de/docs/tutorial/dependencies/dependencies-with-yield.md b/docs/de/docs/tutorial/dependencies/dependencies-with-yield.md index 098df1ee3..11fd4a5e9 100644 --- a/docs/de/docs/tutorial/dependencies/dependencies-with-yield.md +++ b/docs/de/docs/tutorial/dependencies/dependencies-with-yield.md @@ -41,7 +41,7 @@ Der auf die `yield`-Anweisung folgende Code wird ausgeführt, nachdem die Respon /// tip | Tipp -Sie können `async`hrone oder reguläre Funktionen verwenden. +Sie können `async`- oder reguläre Funktionen verwenden. **FastAPI** wird bei jeder das Richtige tun, so wie auch bei normalen Abhängigkeiten. diff --git a/docs/de/docs/tutorial/extra-data-types.md b/docs/de/docs/tutorial/extra-data-types.md index e1986d3fb..9f01000a6 100644 --- a/docs/de/docs/tutorial/extra-data-types.md +++ b/docs/de/docs/tutorial/extra-data-types.md @@ -49,7 +49,7 @@ Hier sind einige der zusätzlichen Datentypen, die Sie verwenden können: * `Decimal`: * Standard-Python-`Decimal`. * In Requests und Responses wird es wie ein `float` behandelt. -* Sie können alle gültigen Pydantic-Datentypen hier überprüfen: Pydantic data types. +* Sie können alle gültigen Pydantic-Datentypen hier überprüfen: Pydantic-Datentypen. ## Beispiel { #example } diff --git a/docs/de/docs/tutorial/first-steps.md b/docs/de/docs/tutorial/first-steps.md index 8164f082b..dfd6a1363 100644 --- a/docs/de/docs/tutorial/first-steps.md +++ b/docs/de/docs/tutorial/first-steps.md @@ -106,7 +106,7 @@ In diesem Fall sind die JSON-Attribute und deren Datentypen, usw. gemeint. OpenAPI definiert ein API-Schema für Ihre API. Dieses Schema enthält Definitionen (oder „Schemas“) der Daten, die von Ihrer API unter Verwendung von **JSON Schema**, dem Standard für JSON-Datenschemata, gesendet und empfangen werden. -#### Überprüfen Sie die `openapi.json` { #check-the-openapi-json } +#### Die `openapi.json` testen { #check-the-openapi-json } Falls Sie wissen möchten, wie das rohe OpenAPI-Schema aussieht: FastAPI generiert automatisch ein JSON (Schema) mit den Beschreibungen Ihrer gesamten API. @@ -185,7 +185,7 @@ https://example.com/items/foo /items/foo ``` -/// info +/// info | Info Ein „Pfad“ wird häufig auch als „Endpunkt“ oder „Route“ bezeichnet. @@ -235,9 +235,9 @@ Wir werden sie auch „**Operationen**“ nennen. Das `@app.get("/")` sagt **FastAPI**, dass die Funktion direkt darunter für die Bearbeitung von Anfragen zuständig ist, die an: * den Pfad `/` -* unter der Verwendung der get-Operation gehen +* unter der Verwendung der get-Operation gehen -/// info | `@decorator` Information +/// info | `@decorator` Info Diese `@something`-Syntax wird in Python „Dekorator“ genannt. @@ -288,7 +288,7 @@ Das ist unsere „**Pfadoperation-Funktion**“: Dies ist eine Python-Funktion. -Sie wird von **FastAPI** immer dann aufgerufen, wenn sie eine Anfrage an die URL "`/`" mittels einer `GET`-Operation erhält. +Sie wird von **FastAPI** immer dann aufgerufen, wenn sie eine Anfrage an die URL „`/`“ mittels einer `GET`-Operation erhält. In diesem Fall handelt es sich um eine `async`-Funktion. @@ -300,7 +300,7 @@ Sie könnten sie auch als normale Funktion anstelle von `async def` definieren: /// note | Hinweis -Wenn Sie den Unterschied nicht kennen, lesen Sie [Async: *„In Eile?“*](../async.md#in-eile){.internal-link target=_blank}. +Wenn Sie den Unterschied nicht kennen, lesen Sie [Async: *„In Eile?“*](../async.md#in-a-hurry){.internal-link target=_blank}. /// diff --git a/docs/de/docs/tutorial/header-param-models.md b/docs/de/docs/tutorial/header-param-models.md index cbdcc252a..5a5409df9 100644 --- a/docs/de/docs/tutorial/header-param-models.md +++ b/docs/de/docs/tutorial/header-param-models.md @@ -63,7 +63,7 @@ Falls Sie aus irgendeinem Grund diese automatische Umwandlung deaktivieren müss /// warning | Achtung -Bevor Sie `convert_underscores` auf `False` setzen, bedenken Sie, dass einige HTTP-Proxies und -Server die Verwendung von Headers mit Unterstrichen nicht zulassen. +Bevor Sie `convert_underscores` auf `False` setzen, bedenken Sie, dass einige HTTP-Proxies und -Server die Verwendung von Headern mit Unterstrichen nicht zulassen. /// diff --git a/docs/de/docs/tutorial/header-params.md b/docs/de/docs/tutorial/header-params.md index b20fe4a9c..7f7211c38 100644 --- a/docs/de/docs/tutorial/header-params.md +++ b/docs/de/docs/tutorial/header-params.md @@ -24,7 +24,7 @@ Aber denken Sie daran, dass bei der Nutzung von `Query`, `Path`, `Header` und an /// -/// info +/// info | Info Um Header zu deklarieren, müssen Sie `Header` verwenden, da die Parameter sonst als Query-Parameter interpretiert werden würden. diff --git a/docs/de/docs/tutorial/metadata.md b/docs/de/docs/tutorial/metadata.md index 4ad509bcb..11541bf09 100644 --- a/docs/de/docs/tutorial/metadata.md +++ b/docs/de/docs/tutorial/metadata.md @@ -1,6 +1,6 @@ # Metadaten und Dokumentations-URLs { #metadata-and-docs-urls } -Sie können mehrere Metadaten-Einstellungen in Ihrer **FastAPI**-Anwendung anpassen. +Sie können mehrere Metadaten-Konfigurationen in Ihrer **FastAPI**-Anwendung anpassen. ## Metadaten für die API { #metadata-for-api } diff --git a/docs/de/docs/tutorial/middleware.md b/docs/de/docs/tutorial/middleware.md index 2dadc3c5a..96bf10120 100644 --- a/docs/de/docs/tutorial/middleware.md +++ b/docs/de/docs/tutorial/middleware.md @@ -35,9 +35,9 @@ Die Middleware-Funktion erhält: /// tip | Tipp -Beachten Sie, dass benutzerdefinierte proprietäre Header hinzugefügt werden können unter Verwendung des 'X-' Präfixes. +Beachten Sie, dass benutzerdefinierte proprietäre Header hinzugefügt werden können unter Verwendung des `X-`-Präfixes. -Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen soll, müssen Sie sie zu Ihren CORS-Konfigurationen ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) hinzufügen, indem Sie den Parameter `expose_headers` verwenden, der in der Starlette-CORS-Dokumentation dokumentiert ist. +Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen soll, müssen Sie sie zu Ihrer CORS-Konfiguration ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) hinzufügen, indem Sie den Parameter `expose_headers` verwenden, der in der Starlettes CORS-Dokumentation dokumentiert ist. /// @@ -92,4 +92,4 @@ Dieses Stapelverhalten stellt sicher, dass Middlewares in einer vorhersehbaren u Sie können später mehr über andere Middlewares im [Handbuch für fortgeschrittene Benutzer: Fortgeschrittene Middleware](../advanced/middleware.md){.internal-link target=_blank} lesen. -In der nächsten Sektion erfahren Sie, wie Sie CORS mit einer Middleware behandeln können. +In der nächsten Sektion erfahren Sie, wie Sie CORS mit einer Middleware behandeln können. diff --git a/docs/de/docs/tutorial/path-params-numeric-validations.md b/docs/de/docs/tutorial/path-params-numeric-validations.md index 664a95fc1..0b31daa13 100644 --- a/docs/de/docs/tutorial/path-params-numeric-validations.md +++ b/docs/de/docs/tutorial/path-params-numeric-validations.md @@ -122,11 +122,11 @@ Das Gleiche gilt für: Zahlenvalidierung funktioniert auch für `float`-Werte. -Hier wird es wichtig, in der Lage zu sein, gt und nicht nur ge zu deklarieren. Da Sie mit dieser Option erzwingen können, dass ein Wert größer als `0` sein muss, selbst wenn er kleiner als `1` ist. +Hier wird es wichtig, in der Lage zu sein, gt und nicht nur ge zu deklarieren. Da Sie mit dieser Option erzwingen können, dass ein Wert größer als `0` sein muss, selbst wenn er kleiner als `1` ist. Also wäre `0.5` ein gültiger Wert. Aber `0.0` oder `0` nicht. -Und das Gleiche gilt für lt. +Und das Gleiche gilt für lt. {* ../../docs_src/path_params_numeric_validations/tutorial006_an_py39.py hl[13] *} diff --git a/docs/de/docs/tutorial/path-params.md b/docs/de/docs/tutorial/path-params.md index 09f7ca083..4267533a3 100644 --- a/docs/de/docs/tutorial/path-params.md +++ b/docs/de/docs/tutorial/path-params.md @@ -20,7 +20,7 @@ Sie können den Typ eines Pfad-Parameters in der Argumentliste der Funktion dekl In diesem Fall wird `item_id` als `int` deklariert, also als Ganzzahl. -/// check +/// check | Testen Dadurch erhalten Sie Editor-Unterstützung innerhalb Ihrer Funktion, mit Fehlerprüfungen, Codevervollständigung, usw. @@ -34,7 +34,7 @@ Wenn Sie dieses Beispiel ausführen und Ihren Browser unter http://127.0.0.1:8000/items/4.2 -/// check +/// check | Testen Sprich, mit der gleichen Python-Typdeklaration gibt Ihnen **FastAPI** Datenvalidierung. @@ -83,7 +83,7 @@ Wenn Sie die Seite -/// check +/// check | Testen Wiederum, mit dieser gleichen Python-Typdeklaration gibt Ihnen **FastAPI** eine automatische, interaktive Dokumentation (verwendet die Swagger-Benutzeroberfläche). @@ -131,9 +131,9 @@ Die erste Definition wird immer verwendet werden, da ihr Pfad zuerst übereinsti ## Vordefinierte Parameterwerte { #predefined-values } -Wenn Sie eine *Pfadoperation* haben, welche einen *Pfad-Parameter* hat, aber Sie wollen, dass dessen gültige Werte vordefiniert sind, können Sie ein Standard-Python `Enum` verwenden. +Wenn Sie eine *Pfadoperation* haben, welche einen *Pfad-Parameter* hat, aber Sie wollen, dass dessen gültige Werte vordefiniert sind, können Sie ein Standard-Python `Enum` verwenden. -### Erstellen Sie eine `Enum`-Klasse { #create-an-enum-class } +### Eine `Enum`-Klasse erstellen { #create-an-enum-class } Importieren Sie `Enum` und erstellen Sie eine Unterklasse, die von `str` und `Enum` erbt. @@ -143,25 +143,25 @@ Erstellen Sie dann Klassen-Attribute mit festgelegten Werten, welches die erlaub {* ../../docs_src/path_params/tutorial005.py hl[1,6:9] *} -/// info +/// info | Info Enumerationen (oder kurz Enums) gibt es in Python seit Version 3.4. /// -/// tip +/// tip | Tipp Falls Sie sich fragen, was „AlexNet“, „ResNet“ und „LeNet“ ist, das sind Namen von Modellen für maschinelles Lernen. /// -### Deklarieren Sie einen *Pfad-Parameter* { #declare-a-path-parameter } +### Einen *Pfad-Parameter* deklarieren { #declare-a-path-parameter } Dann erstellen Sie einen *Pfad-Parameter*, der als Typ die gerade erstellte Enum-Klasse hat (`ModelName`): {* ../../docs_src/path_params/tutorial005.py hl[16] *} -### Testen Sie es in der API-Dokumentation { #check-the-docs } +### Die API-Dokumentation testen { #check-the-docs } Weil die erlaubten Werte für den *Pfad-Parameter* nun vordefiniert sind, kann die interaktive Dokumentation sie als Auswahl-Drop-Down anzeigen: diff --git a/docs/de/docs/tutorial/query-params-str-validations.md b/docs/de/docs/tutorial/query-params-str-validations.md index 6d27adb36..acf199af9 100644 --- a/docs/de/docs/tutorial/query-params-str-validations.md +++ b/docs/de/docs/tutorial/query-params-str-validations.md @@ -415,7 +415,7 @@ Pydantic unterstützt auch ISBN-Buchnummer oder mit `imdb-` für eine IMDB-Film-URL-ID beginnt: +Zum Beispiel überprüft dieser benutzerdefinierte Validator, ob die Artikel-ID mit `isbn-` für eine ISBN-Buchnummer oder mit `imdb-` für eine IMDB-Film-URL-ID beginnt: {* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *} @@ -433,7 +433,7 @@ Diese benutzerdefinierten Validatoren sind für Dinge gedacht, die einfach mit d /// -### Verstehen Sie dieses Codebeispiel { #understand-that-code } +### Dieses Codebeispiel verstehen { #understand-that-code } Der wichtige Punkt ist einfach die Verwendung von **`AfterValidator` mit einer Funktion innerhalb von `Annotated`**. Fühlen Sie sich frei, diesen Teil zu überspringen. 🤸 diff --git a/docs/de/docs/tutorial/request-files.md b/docs/de/docs/tutorial/request-files.md index e22bcb235..508f812b1 100644 --- a/docs/de/docs/tutorial/request-files.md +++ b/docs/de/docs/tutorial/request-files.md @@ -155,7 +155,7 @@ Um das zu machen, deklarieren Sie eine Liste von `bytes` oder `UploadFile`s: {* ../../docs_src/request_files/tutorial002_an_py39.py hl[10,15] *} -Sie erhalten, wie deklariert, eine `list`e von `bytes` oder `UploadFile`s. +Sie erhalten, wie deklariert, eine `list` von `bytes` oder `UploadFile`s. /// note | Technische Details diff --git a/docs/de/docs/tutorial/request-forms.md b/docs/de/docs/tutorial/request-forms.md index 0b3d66bdd..a7c1019fc 100644 --- a/docs/de/docs/tutorial/request-forms.md +++ b/docs/de/docs/tutorial/request-forms.md @@ -2,7 +2,7 @@ Wenn Sie Felder aus Formularen statt JSON empfangen müssen, können Sie `Form` verwenden. -/// info +/// info | Info Um Formulare zu verwenden, installieren Sie zuerst `python-multipart`. @@ -28,11 +28,11 @@ Erstellen Sie Formular-Parameter, so wie Sie es auch mit `Body` und `Query` mach Zum Beispiel stellt eine der Möglichkeiten, die OAuth2-Spezifikation zu verwenden (genannt „password flow“), die Bedingung, einen `username` und ein `password` als Formularfelder zu senden. -Die Spec erfordert, dass die Felder exakt `username` und `password` genannt werden und als Formularfelder, nicht JSON, gesendet werden. +Die Spec erfordert, dass die Felder exakt `username` und `password` genannt werden und als Formularfelder, nicht JSON, gesendet werden. Mit `Form` haben Sie die gleichen Konfigurationsmöglichkeiten wie mit `Body` (und `Query`, `Path`, `Cookie`), inklusive Validierung, Beispielen, einem Alias (z. B. `user-name` statt `username`), usw. -/// info +/// info | Info `Form` ist eine Klasse, die direkt von `Body` erbt. @@ -56,7 +56,7 @@ Daten aus Formularen werden normalerweise mit dem „med Wenn das Formular stattdessen Dateien enthält, werden diese mit `multipart/form-data` kodiert. Im nächsten Kapitel erfahren Sie mehr über die Handhabung von Dateien. -Wenn Sie mehr über Formularfelder und ihre Kodierungen lesen möchten, besuchen Sie die MDN-Webdokumentation für POST. +Wenn Sie mehr über Formularfelder und ihre Kodierungen lesen möchten, besuchen Sie die MDN-Webdokumentation für POST. /// diff --git a/docs/de/docs/tutorial/response-model.md b/docs/de/docs/tutorial/response-model.md index 5b3c189a6..591616da4 100644 --- a/docs/de/docs/tutorial/response-model.md +++ b/docs/de/docs/tutorial/response-model.md @@ -9,7 +9,7 @@ Hierbei können Sie **Typannotationen** genauso verwenden, wie Sie es bei Werten FastAPI wird diesen Rückgabetyp verwenden, um: * Die zurückzugebenden Daten zu **validieren**. - * 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. + * 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. @@ -61,9 +61,9 @@ So sagen Sie dem Editor, dass Sie absichtlich *irgendetwas* zurückgeben. Aber F 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`. +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. +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. ## Dieselben Eingabedaten zurückgeben { #return-the-same-input-data } @@ -151,7 +151,7 @@ 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. +`BaseUser` verfügt über die Basis-Felder. Dann erbt `UserIn` von `BaseUser` und fügt das Feld `password` hinzu, sodass es nun alle Felder beider Modelle hat. Wir annotieren den Funktionsrückgabetyp als `BaseUser`, geben aber tatsächlich eine `UserIn`-Instanz zurück. @@ -277,7 +277,7 @@ verwenden, wie in der Starlette ist das Testen von **FastAPI**-Anwendungen einfach und macht Spaß. -Es basiert auf HTTPX, welches wiederum auf der Grundlage von requests konzipiert wurde, es ist also sehr vertraut und intuitiv. +Es basiert auf HTTPX, welches wiederum auf der Grundlage von Requests konzipiert wurde, es ist also sehr vertraut und intuitiv. Damit können Sie pytest direkt mit **FastAPI** verwenden. From 38d36bb34baf4df043d45ba2d0819ee8d6432633 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Mon, 25 Aug 2025 16:17:01 +0200 Subject: [PATCH 137/160] Two Fixes in English documents Fond these while manually checking the previous batch translation commit --- docs/en/docs/advanced/async-tests.md | 2 +- docs/en/docs/tutorial/middleware.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/en/docs/advanced/async-tests.md b/docs/en/docs/advanced/async-tests.md index 7b6f08371..e920e22c3 100644 --- a/docs/en/docs/advanced/async-tests.md +++ b/docs/en/docs/advanced/async-tests.md @@ -94,6 +94,6 @@ As the testing function is now asynchronous, you can now also call (and `await`) /// tip -If you encounter a `RuntimeError: Task attached to a different loop` when integrating asynchronous function calls in your tests (e.g. when using MongoDB's MotorClient), remember to instantiate objects that need an event loop only within async functions, e.g. an `'@app.on_event("startup")` callback. +If you encounter a `RuntimeError: Task attached to a different loop` when integrating asynchronous function calls in your tests (e.g. when using MongoDB's MotorClient), remember to instantiate objects that need an event loop only within async functions, e.g. an `@app.on_event("startup")` callback. /// diff --git a/docs/en/docs/tutorial/middleware.md b/docs/en/docs/tutorial/middleware.md index 9bfbf47c9..bc0519c67 100644 --- a/docs/en/docs/tutorial/middleware.md +++ b/docs/en/docs/tutorial/middleware.md @@ -35,7 +35,7 @@ The middleware function receives: /// tip -Keep in mind that custom proprietary headers can be added using the 'X-' prefix. +Keep in mind that custom proprietary headers can be added using the `X-` prefix. But if you have custom headers that you want a client in a browser to be able to see, you need to add them to your CORS configurations ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) using the parameter `expose_headers` documented in Starlette's CORS docs. From 5f02331605b30ad73f22ee065042624e62515249 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Mon, 25 Aug 2025 16:51:42 +0200 Subject: [PATCH 138/160] Changes to German prompt reflecting results from batch translation * (Hopefully) improve rule when not to convert to typographic quotation marks, re-add some examples * Refine rule how to translate abbr elements * Include and remove some words --- docs/de/llm-prompt.md | 58 +++++++++++++++++++++++++++++++++++-------- 1 file changed, 48 insertions(+), 10 deletions(-) diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index 167352aba..6de425c20 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -6,26 +6,40 @@ Language code: de. 2) Use the formal grammar (use `Sie` instead of `Du`). -3) Translate quotation marks ("") in the English source with typographic quotation marks („“). +3) Convert quotation marks (") to typographic quotation marks („“). Example: Source (English): -"hello world" +"Hello world" Result (German): „Hallo Welt“ -However, when the quotation marks are inside code snippets or code blocks then do not change them. See the earlier defined rules about code snippets and code blocks. +3.1) Inside inline code (= surrounded by backticks), leave quotation marks (") as is, as they usually mark string literals and typographic quotation marks („“) can not be used for that. -Do not randomly add normal or typographic quotation marks into the German translation. +Example: + +Source (English) – contains four inline codes, three of them contain a string literal: + +Inline code: `i am inline code` +Inline code containing a string literal: `i am inline code "I am a string literal"` +Inline code containing only a short string literal: `"foo"` +`"__main__"` + +Result (German) – as all the quotation marks (") are inside inline code, you keep them as is, as you always should with content inside inline code: + +Inline-Code: `i am inline code` +Inline-Code der ein Stringliteral enthält: `i am inline code "I am a string literal"` +Inline-Code der nur ein kurzes Stringliteral enthält: `"foo"` +`"__main__"` 4) Translate HTML abbr elements as follows: -4.1) If the title attribute gives the full phrase for an abbrevation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase. +4.1) If the title attribute gives the full phrase for an abbreviation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase. Examples: @@ -51,7 +65,7 @@ Result (German): {full phrase} – {translation of full phrase} -If the phrase can not be translated or it is the same in the translation, then keep the title attribute as is. +4.1.1) If the phrase can not be translated, or it is the same in the translation, then keep the title attribute as is. Examples: @@ -75,6 +89,28 @@ Result (German): {full phrase} +4.1.2) If the phrase can be translated that translation has the same starting letters, then just use the translation. + +Examples: + +Source (English): + +ASGI + +Result (German): + +ASGI + +Conversion scheme title attribute: + +Source (English): + +{full phrase} + +Result (German): + +{translation of full phrase} + 4.2) If the title attribute explains something in its own words, then translate it, if possible. Examples: @@ -128,7 +164,7 @@ Result (German): {translation of term which abbr wraps}: {translation of explanation} -4.3) If the title attribute gives the full phrase for an abbrevation, followed by a colon (`:`) or a comma (`,`), followed by an explanation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase, followed by a colon (`:`), followed by the translation of the explanation. +4.3) If the title attribute gives the full phrase for an abbreviation, followed by a colon (`:`) or a comma (`,`), followed by an explanation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase, followed by a colon (`:`), followed by the translation of the explanation. Examples: @@ -162,7 +198,7 @@ Result (German): {full phrase} – {translation of full phrase}: {translation of explanation} -4.4) If there is an HTML abbr element in a sentence in an existing translation, but that element does not exist in the related sentence in the English text, then keep that HTML abbr element in the translation, do not change or remove it. Except when you remove the whole sentence from the translation, because the whole sentence was removed from the English text. The reasoning for this rule is, that such abbr elements are manually added by the human editor of the translation, in order to translate or explain an English word to the human readers of the translation. They would not make sense in the English text but they do make sense in the translation. So keep them in the translation, even though they are not part of the English text. This rule only applies to HTML abbr elements. +4.4) If there is an HTML abbr element in a sentence in an existing translation, but that element does not exist in the related sentence in the English text, then keep that HTML abbr element in the translation, do not change or remove it. Except when you remove the whole sentence from the translation, because the whole sentence was removed from the English text. The reasoning for this rule is, that such abbr elements are manually added by the human editor of the translation, in order to translate or explain an English word to the human readers of the translation. They would not make sense in the English text, but they do make sense in the translation. So keep them in the translation, even though they are not part of the English text. This rule only applies to HTML abbr elements. 5) Translate headings using the infinite form. @@ -224,7 +260,7 @@ Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriff * /// warning: /// warning | Achtung * you: Sie * your: Ihr -* e.g: z.B. +* e.g: z. B. * etc.: usw. * the `PATH` environment variable: die `PATH`-Umgebungsvariable * the `PATH`: der `PATH` @@ -234,10 +270,10 @@ Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriff * the application: die Anwendung * the Advanced User Guide: das Handbuch für fortgeschrittene Benutzer * the Authorization-Header: der Autorisierungsheader +* the `Authorization`-Header: der `Authorization`-Header * the background task: der Hintergrundtask * the cloud provider: der Cloudanbieter * the CLI: Das CLI -* the configurations (plural case): die Einstellungen * the command line interface: Das Kommandozeileninterface * the docs: die Dokumentation (use singular case) * the default value: der Defaultwert @@ -252,6 +288,7 @@ Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriff * the form body: der Formularbody * the header: der Header * the headers (plural case): die Header +* in headers (plural case): in Headern * the lifespan event: das Lifespan-Event * the locking: das Locking * the mobile application: die Mobile-Anwendung @@ -302,6 +339,7 @@ Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriff * Starlette's Y: Starlettes Y * X is case-sensitive: Groß-/Klein­schrei­bung ist relevant in X * X is case-insensitive: Groß-/Klein­schrei­bung ist nicht relevant in X +* standard Python: Standard-Python 8) Preserve indentation. Keep emoticons. Encode in utf-8. Use Linux line breaks (LF) From 3242cd89a5cc60c5d1570ec00109595df82b43da Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 25 Aug 2025 17:17:57 +0000 Subject: [PATCH 139/160] =?UTF-8?q?=F0=9F=8E=A8=20[pre-commit.ci]=20Auto?= =?UTF-8?q?=20format=20from=20pre-commit.com=20hooks?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scripts/translate.py | 46 +++++++++++++++++++++++++++++++++----------- 1 file changed, 35 insertions(+), 11 deletions(-) diff --git a/scripts/translate.py b/scripts/translate.py index 36dc6c021..398e5aecb 100644 --- a/scripts/translate.py +++ b/scripts/translate.py @@ -1,10 +1,10 @@ import secrets import subprocess +from collections.abc import Iterable from functools import lru_cache -from pathlib import Path from os import sep as pathsep +from pathlib import Path from typing import Annotated -from collections.abc import Iterable import git import typer @@ -356,10 +356,21 @@ def generate_en_path(*, lang: str, path: Path) -> Path: @app.command() def translate_page( *, - language: Annotated[str, typer.Option(envvar="LANGUAGE", help="Target language, e.g. `es`, `fr`, `de`")], - en_path: Annotated[Path, typer.Option(envvar="EN_PATH", help="Path to the English source, relative to the FastAPI root directory, e.g. `docs/en/docs/index.md`")], + language: Annotated[ + str, + typer.Option(envvar="LANGUAGE", help="Target language, e.g. `es`, `fr`, `de`"), + ], + en_path: Annotated[ + Path, + typer.Option( + envvar="EN_PATH", + help="Path to the English source, relative to the FastAPI root directory, e.g. `docs/en/docs/index.md`", + ), + ], ) -> None: - assert language != "en", "`en` is the source language, choose another language as translation target" + assert language != "en", ( + "`en` is the source language, choose another language as translation target" + ) langs = get_langs() language_name = langs[language] lang_path = Path(f"docs/{language}") @@ -452,13 +463,25 @@ def iter_en_paths_to_translate() -> Iterable[Path]: @app.command() def translate_lang( - language: Annotated[str, typer.Option(envvar="LANGUAGE", help="Target language, e.g. `es`, `fr`, `de`")], - mode: Annotated[str, typer.Option(help="Which files of the target language to translate, one of: `missing`, `existing`, `all`")] = "missing", + language: Annotated[ + str, + typer.Option(envvar="LANGUAGE", help="Target language, e.g. `es`, `fr`, `de`"), + ], + mode: Annotated[ + str, + typer.Option( + help="Which files of the target language to translate, one of: `missing`, `existing`, `all`" + ), + ] = "missing", verbose: Annotated[bool, typer.Option(help="Print all paths")] = False, - preview: Annotated[bool, typer.Option(help="Show what will be done, but do not translate")] = False + preview: Annotated[ + bool, typer.Option(help="Show what will be done, but do not translate") + ] = False, ) -> None: allowed_modes = ["missing", "existing", "all"] - assert mode in allowed_modes, f"`mode` parameter must be one of {", ".join(f"`{mode}`" for mode in allowed_modes)}" + assert mode in allowed_modes, ( + f"`mode` parameter must be one of {', '.join(f'`{mode}`' for mode in allowed_modes)}" + ) translatable_paths = list(iter_en_paths_to_translate()) missing_paths: list[Path] = [] @@ -475,12 +498,13 @@ def translate_lang( print(f" - {p}") else: print() + print_pathinfo("translatable paths", translatable_paths) print_pathinfo("paths with a translation", existing_paths) print_pathinfo("paths with no translation", missing_paths) print(f"Mode: translate {mode}") - if mode == 'missing' or (mode == "all" and len(existing_paths) == 0): + if mode == "missing" or (mode == "all" and len(existing_paths) == 0): tbd_paths = missing_paths action = "translate" elif mode == "existing" or (mode == "all" and len(missing_paths) == 0): @@ -493,7 +517,7 @@ def translate_lang( if not preview: for c, p in enumerate(tbd_paths): - print(f"({c+1}/{len(tbd_paths)}) Translating: {p}") + print(f"({c + 1}/{len(tbd_paths)}) Translating: {p}") translate_page(language=language, en_path=p) print(f"Done translating: {p}") From be27e1e61013d2a3c7423aad0de2dbf6418c88ca Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Mon, 25 Aug 2025 20:17:25 +0200 Subject: [PATCH 140/160] Fix two things in the German prompt --- docs/de/llm-prompt.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index 6de425c20..f8bd18f4e 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -89,7 +89,7 @@ Result (German): {full phrase} -4.1.2) If the phrase can be translated that translation has the same starting letters, then just use the translation. +4.1.2) If the phrase can be translated and that translation has the same starting letters, then just use the translation. Examples: @@ -141,7 +141,7 @@ Result (German): {translation of explanation} -If the term, which the HTML abbr element wraps, stays English in the translation, but it also has a translation, whose knowledge improves the explanation, then let the title attribute be that translation, followed by a colon (`:`), followed by the translation of the title attribute. +4.2.1) If the term, which the HTML abbr element wraps, stays English in the translation, but it also has a translation, whose knowledge improves the explanation, then let the title attribute be that translation, followed by a colon (`:`), followed by the translation of the title attribute. Examples: From 190538b6b9f573ac71a0e9cd5b96ee0e528a42b2 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Mon, 25 Aug 2025 22:36:16 +0200 Subject: [PATCH 141/160] A few more changes ... made while re-reading the diff until inclusive docs/de/docs/deployment/cloud.md One change is an addition of a sentence in an English dokument. Two word additions to the German prompt --- docs/de/docs/advanced/custom-response.md | 2 +- docs/de/docs/advanced/events.md | 2 +- docs/de/docs/advanced/openapi-webhooks.md | 6 +++--- docs/de/docs/advanced/websockets.md | 4 ++-- docs/de/llm-prompt.md | 2 ++ docs/en/docs/advanced/websockets.md | 4 ++-- 6 files changed, 11 insertions(+), 9 deletions(-) diff --git a/docs/de/docs/advanced/custom-response.md b/docs/de/docs/advanced/custom-response.md index d61920f84..dd0a6fe97 100644 --- a/docs/de/docs/advanced/custom-response.md +++ b/docs/de/docs/advanced/custom-response.md @@ -234,7 +234,7 @@ Das umfasst viele Bibliotheken zur Interaktion mit Cloud-Speicher, Videoverarbei Es handelt sich also hier um eine Generatorfunktion, die die „generierende“ Arbeit intern auf etwas anderes überträgt. - Auf diese Weise können wir das Ganze in einen `with`-Block einfügen und so sicherstellen, dass das dateiähnliche Objekt nach Abschluss geschlossen wird. + Auf diese Weise können wir das Ganze in einen `with`-Block einfügen und so sicherstellen, dass das dateiartige Objekt nach Abschluss geschlossen wird. /// tip | Tipp diff --git a/docs/de/docs/advanced/events.md b/docs/de/docs/advanced/events.md index 1c3bb7aa2..9c67a3833 100644 --- a/docs/de/docs/advanced/events.md +++ b/docs/de/docs/advanced/events.md @@ -96,7 +96,7 @@ Sie können diesen Teil wahrscheinlich überspringen. Es gibt eine alternative Möglichkeit, diese Logik zu definieren, sodass sie beim *Hochfahren* und beim *Herunterfahren* ausgeführt wird. -Sie können Eventhandler (Funktionen) definieren, die ausgeführt werden sollen, bevor die Anwendung hochgefahren wird oder wenn die Anwendung heruntergefahren wird. +Sie können Eventhandler (Funktionen) definieren, die ausgeführt werden sollen, bevor die Anwendung hochgefahren wird oder wenn die Anwendung heruntergefahren wird. Diese Funktionen können mit `async def` oder normalem `def` deklariert werden. diff --git a/docs/de/docs/advanced/openapi-webhooks.md b/docs/de/docs/advanced/openapi-webhooks.md index 3a82fd41d..af0f7b4ff 100644 --- a/docs/de/docs/advanced/openapi-webhooks.md +++ b/docs/de/docs/advanced/openapi-webhooks.md @@ -4,7 +4,7 @@ Es gibt Fälle, in denen Sie Ihren API-**Benutzern** mitteilen möchten, dass Ih Das bedeutet, dass anstelle des normalen Prozesses, bei dem Ihre Benutzer Requests an Ihre API senden, **Ihre API** (oder Ihre App) **Requests an deren System** (an deren API, deren App) senden könnte. -Das wird normalerweise als **Webhook** bezeichnet. +Das wird normalerweise als **Webhook** bezeichnet. ## Webhooks-Schritte { #webhooks-steps } @@ -12,13 +12,13 @@ Der Prozess besteht normalerweise darin, dass **Sie in Ihrem Code definieren**, Sie definieren auch auf irgendeine Weise, in welchen **Momenten** Ihre App diese Requests oder Events senden wird. -Und **Ihre Benutzer** definieren auf irgendeine Weise (zum Beispiel irgendwo in einem Web-Dashboard) die **URL**, an die Ihre App diese Requests senden soll. +Und **Ihre Benutzer** definieren auf irgendeine Weise (zum Beispiel irgendwo in einem Web-Dashboard) die **URL**, an die Ihre App diese Requests senden soll. Die gesamte **Logik** zur Registrierung der URLs für Webhooks und der Code zum tatsächlichen Senden dieser Requests liegt bei Ihnen. Sie schreiben es so, wie Sie möchten, in **Ihrem eigenen Code**. ## Webhooks mit **FastAPI** und OpenAPI dokumentieren { #documenting-webhooks-with-fastapi-and-openapi } -Mit **FastAPI**, mithilfe von OpenAPI, können Sie die Namen dieser Webhooks, die Arten von HTTP-Operationen, die Ihre App senden kann (z. B. `POST`, `PUT`, usw.) und die Request**bodies** definieren, die Ihre App senden würde. +Mit **FastAPI**, mithilfe von OpenAPI, können Sie die Namen dieser Webhooks, die Arten von HTTP-Operationen, die Ihre App senden kann (z. B. `POST`, `PUT`, usw.) und die Request**bodys** definieren, die Ihre App senden würde. Dies kann es Ihren Benutzern viel einfacher machen, **deren APIs zu implementieren**, um Ihre **Webhook**-Requests zu empfangen. Möglicherweise können diese sogar einen Teil ihres eigenen API-Codes automatisch generieren. diff --git a/docs/de/docs/advanced/websockets.md b/docs/de/docs/advanced/websockets.md index 158377064..e7f1910f4 100644 --- a/docs/de/docs/advanced/websockets.md +++ b/docs/de/docs/advanced/websockets.md @@ -2,9 +2,9 @@ Sie können WebSockets mit **FastAPI** verwenden. -## `WebSockets` installieren { #install-websockets } +## `websockets` installieren { #install-websockets } -Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und `websockets` installieren: +Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und `websockets` installieren (eine Python-Bibliothek, die die Verwendung von „WebSockets“, dem JavaScript-Standard, erleichtert):
diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index f8bd18f4e..cf548b53e 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -312,6 +312,8 @@ Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriff * the query: die Query * the recap: die Zusammenfassung * the request: der Request +* the requestbody: der Requestbody +* the requestbodies (plural case): die Requestbodys * the response: die Response * the return type: der Rückgabetyp * the return value: der Rückgabewert diff --git a/docs/en/docs/advanced/websockets.md b/docs/en/docs/advanced/websockets.md index 4ba24637f..4f5878a67 100644 --- a/docs/en/docs/advanced/websockets.md +++ b/docs/en/docs/advanced/websockets.md @@ -2,9 +2,9 @@ You can use WebSockets with **FastAPI**. -## Install `WebSockets` { #install-websockets } +## Install `websockets` { #install-websockets } -Make sure you create a [virtual environment](../virtual-environments.md){.internal-link target=_blank}, activate it, and install `websockets`: +Make sure you create a [virtual environment](../virtual-environments.md){.internal-link target=_blank}, activate it, and install `websockets` (a Python library which makes it easy to use "WebSockets", the JavaScript standard):
From c95beaf5def7c04befbe02ef7803234e05e19f80 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Tue, 26 Aug 2025 19:41:42 +0200 Subject: [PATCH 142/160] Fix headings which have periods And add a rule to the prompt. --- docs/de/docs/tutorial/bigger-applications.md | 2 +- docs/de/docs/tutorial/schema-extra-example.md | 2 +- docs/de/docs/tutorial/security/simple-oauth2.md | 2 +- docs/de/llm-prompt.md | 16 ++++++++++++++++ 4 files changed, 19 insertions(+), 3 deletions(-) diff --git a/docs/de/docs/tutorial/bigger-applications.md b/docs/de/docs/tutorial/bigger-applications.md index 148f357c3..6136c619e 100644 --- a/docs/de/docs/tutorial/bigger-applications.md +++ b/docs/de/docs/tutorial/bigger-applications.md @@ -159,7 +159,7 @@ Aber in der Praxis werden Sie mit den integrierten [Sicherheits-Werkzeugen](secu /// -## Ein weiteres Modul mit `APIRouter`. { #another-module-with-apirouter } +## Ein weiteres Modul mit `APIRouter` { #another-module-with-apirouter } Nehmen wir an, Sie haben im Modul unter `app/routers/items.py` auch die Endpunkte, die für die Verarbeitung von Artikeln („Items“) aus Ihrer Anwendung vorgesehen sind. diff --git a/docs/de/docs/tutorial/schema-extra-example.md b/docs/de/docs/tutorial/schema-extra-example.md index 79277dcb4..0b79bde5e 100644 --- a/docs/de/docs/tutorial/schema-extra-example.md +++ b/docs/de/docs/tutorial/schema-extra-example.md @@ -211,7 +211,7 @@ In Versionen von FastAPI vor 0.99.0 (0.99.0 und höher verwenden das neuere Open Aber jetzt, da FastAPI 0.99.0 und höher, OpenAPI 3.1.0 verwendet, das JSON Schema 2020-12 verwendet, und Swagger UI 5.0.0 und höher, ist alles konsistenter und die Beispiele sind in JSON Schema enthalten. -### Swagger-Benutzeroberfläche und OpenAPI-spezifische `examples`. { #swagger-ui-and-openapi-specific-examples } +### Swagger-Benutzeroberfläche und OpenAPI-spezifische `examples` { #swagger-ui-and-openapi-specific-examples } Da die Swagger-Benutzeroberfläche derzeit nicht mehrere JSON Schema Beispiele unterstützt (Stand: 26.08.2023), hatten Benutzer keine Möglichkeit, mehrere Beispiele in der Dokumentation anzuzeigen. diff --git a/docs/de/docs/tutorial/security/simple-oauth2.md b/docs/de/docs/tutorial/security/simple-oauth2.md index d77294cb1..4c9355959 100644 --- a/docs/de/docs/tutorial/security/simple-oauth2.md +++ b/docs/de/docs/tutorial/security/simple-oauth2.md @@ -44,7 +44,7 @@ Für OAuth2 sind es einfach nur Strings. /// -## Code, um `username` und `password` entgegenzunehmen. { #code-to-get-the-username-and-password } +## Code, um `username` und `password` entgegenzunehmen { #code-to-get-the-username-and-password } Lassen Sie uns nun die von **FastAPI** bereitgestellten Werkzeuge verwenden, um das zu erledigen. diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index cf548b53e..74dc2a962 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -241,6 +241,22 @@ Do NOT translate with (German): ### Führen Sie Ihr Programm aus { #run-your-program } +5.1) Make sure that the translated part of the heading does not end with a period. + +Example: + +Source (English): + +## Another module with `APIRouter` { #another-module-with-apirouter } + +Translate with (German): + +## Ein weiteres Modul mit `APIRouter` { #another-module-with-apirouter } + +Do NOT translate with (German) – notice the added period: + +## Ein weiteres Modul mit `APIRouter`. { #another-module-with-apirouter } + 6) Follow these German instructions: From 5b67c40c60033f32d5107248224d1ac7df1aab36 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Tue, 26 Aug 2025 20:13:23 +0200 Subject: [PATCH 143/160] Use long dashes in headings --- docs/de/docs/deployment/cloud.md | 2 +- docs/de/docs/deployment/docker.md | 8 +++--- docs/de/docs/project-generation.md | 2 +- docs/de/docs/tutorial/sql-databases.md | 10 ++++---- docs/de/llm-prompt.md | 34 ++++++++++++++++++++++++++ 5 files changed, 45 insertions(+), 11 deletions(-) diff --git a/docs/de/docs/deployment/cloud.md b/docs/de/docs/deployment/cloud.md index ca3638ac9..e3d08f8dc 100644 --- a/docs/de/docs/deployment/cloud.md +++ b/docs/de/docs/deployment/cloud.md @@ -4,7 +4,7 @@ Sie können praktisch **jeden Cloudanbieter** verwenden, um Ihre FastAPI-Anwendu In den meisten Fällen bieten die großen Cloudanbieter Anleitungen zum Bereitstellen von FastAPI an. -## Cloudanbieter - Sponsoren { #cloud-providers-sponsors } +## Cloudanbieter – Sponsoren { #cloud-providers-sponsors } Einige Cloudanbieter ✨ [**sponsern FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, dies stellt die kontinuierliche und gesunde **Entwicklung** von FastAPI und seinem **Ökosystem** sicher. diff --git a/docs/de/docs/deployment/docker.md b/docs/de/docs/deployment/docker.md index 85df44d63..0307768a1 100644 --- a/docs/de/docs/deployment/docker.md +++ b/docs/de/docs/deployment/docker.md @@ -1,4 +1,4 @@ -# FastAPI in Containern - Docker { #fastapi-in-containers-docker } +# FastAPI in Containern – Docker { #fastapi-in-containers-docker } Beim Deployment von FastAPI-Anwendungen besteht ein gängiger Ansatz darin, ein **Linux-Containerimage** zu erstellen. Normalerweise erfolgt dies mit **Docker**. Sie können dieses Containerimage dann auf eine von mehreren möglichen Arten bereitstellen. @@ -238,7 +238,7 @@ Stellen Sie sicher, dass Sie **immer** die **exec form** der Anweisung `CMD` ver /// -#### `CMD` - Exec Form verwenden { #use-cmd-exec-form } +#### `CMD` – Exec Form verwenden { #use-cmd-exec-form } Die `CMD` Docker-Anweisung kann in zwei Formen geschrieben werden: @@ -454,7 +454,7 @@ In den meisten (oder allen) Fällen gibt es eine einfache Option, um die Ausfüh Ohne die Verwendung von Containern kann es umständlich und schwierig sein, Anwendungen beim Hochfahren auszuführen und neu zu starten. Bei der **Arbeit mit Containern** ist diese Funktionalität jedoch in den meisten Fällen standardmäßig enthalten. ✨ -## Replikation - Anzahl der Prozesse { #replication-number-of-processes } +## Replikation – Anzahl der Prozesse { #replication-number-of-processes } Wenn Sie einen Cluster von Maschinen mit **Kubernetes**, Docker Swarm Mode, Nomad verwenden, oder einem anderen, ähnlich komplexen System zur Verwaltung verteilter Container auf mehreren Maschinen, möchten Sie wahrscheinlich die **Replikation auf Cluster-Ebene abwickeln**, anstatt in jedem Container einen **Prozessmanager** (wie Uvicorn mit Workern) zu verwenden. @@ -476,7 +476,7 @@ Die gleiche **TLS-Terminierungsproxy**-Komponente, die für HTTPS verwendet wird Und wenn Sie mit Containern arbeiten, verfügt das gleiche System, mit dem Sie diese starten und verwalten, bereits über interne Tools, um die **Netzwerkkommunikation** (z. B. HTTP-Requests) von diesem **Load Balancer** (das könnte auch ein **TLS-Terminierungsproxy** sein) zu den Containern mit Ihrer Anwendung weiterzuleiten. -### Ein Load Balancer - mehrere Workercontainer { #one-load-balancer-multiple-worker-containers } +### Ein Load Balancer – mehrere Workercontainer { #one-load-balancer-multiple-worker-containers } Bei der Arbeit mit **Kubernetes** oder ähnlichen verteilten Containerverwaltungssystemen würde die Verwendung ihrer internen Netzwerkmechanismen es dem einzelnen **Load Balancer**, der den Haupt-**Port** überwacht, ermöglichen, Kommunikation (Requests) an möglicherweise **mehrere Container** weiterzuleiten, in denen Ihre Anwendung ausgeführt wird. diff --git a/docs/de/docs/project-generation.md b/docs/de/docs/project-generation.md index ac353375a..e6da4949c 100644 --- a/docs/de/docs/project-generation.md +++ b/docs/de/docs/project-generation.md @@ -6,7 +6,7 @@ Sie können diese Vorlage verwenden, um loszulegen, da sie bereits vieles der an GitHub-Repository: Full Stack FastAPI Template -## Full Stack FastAPI Template - Technologiestack und Funktionen { #full-stack-fastapi-template-technology-stack-and-features } +## Full Stack FastAPI Template – Technologiestack und Funktionen { #full-stack-fastapi-template-technology-stack-and-features } - ⚡ [**FastAPI**](https://fastapi.tiangolo.com/de) für die Python-Backend-API. - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) für die Interaktion mit der Python-SQL-Datenbank (ORM). diff --git a/docs/de/docs/tutorial/sql-databases.md b/docs/de/docs/tutorial/sql-databases.md index 1cdacf132..e7f61b1f1 100644 --- a/docs/de/docs/tutorial/sql-databases.md +++ b/docs/de/docs/tutorial/sql-databases.md @@ -185,7 +185,7 @@ Und jede Modellklasse, die `table=True` nicht hat, ist ein **Datenmodell**, dies Mit SQLModel können wir **Vererbung** verwenden, um **doppelte Felder** in allen Fällen zu **vermeiden**. -#### `HeroBase` - die Basisklasse { #herobase-the-base-class } +#### `HeroBase` – die Basisklasse { #herobase-the-base-class } Fangen wir mit einem `HeroBase`-Modell an, das alle **Felder hat, die von allen Modellen geteilt werden**: @@ -194,7 +194,7 @@ Fangen wir mit einem `HeroBase`-Modell an, das alle **Felder hat, die von allen {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:9] hl[7:9] *} -#### `Hero` - das *Tabellenmodell* { #hero-the-table-model } +#### `Hero` – das *Tabellenmodell* { #hero-the-table-model } Dann erstellen wir `Hero`, das tatsächliche *Tabellenmodell*, mit den **zusätzlichen Feldern**, die nicht immer in den anderen Modellen enthalten sind: @@ -210,7 +210,7 @@ Da `Hero` von `HeroBase` erbt, hat es **auch** die **Felder**, die in `HeroBase` {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:14] hl[12:14] *} -#### `HeroPublic` - das öffentliche *Datenmodell* { #heropublic-the-public-data-model } +#### `HeroPublic` – das öffentliche *Datenmodell* { #heropublic-the-public-data-model } Als nächstes erstellen wir ein `HeroPublic`-Modell, das an die API-Clients **zurückgegeben** wird. @@ -236,7 +236,7 @@ Alle Felder in `HeroPublic` sind dieselben wie in `HeroBase`, mit `id`, das als {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:18] hl[17:18] *} -#### `HeroCreate` - das *Datenmodell* zum Erstellen eines Helden { #herocreate-the-data-model-to-create-a-hero } +#### `HeroCreate` – das *Datenmodell* zum Erstellen eines Helden { #herocreate-the-data-model-to-create-a-hero } Nun erstellen wir ein `HeroCreate`-Modell, das die Daten der Clients **validiert**. @@ -260,7 +260,7 @@ Die Felder von `HeroCreate` sind: {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:22] hl[21:22] *} -#### `HeroUpdate` - das *Datenmodell* zum Aktualisieren eines Helden { #heroupdate-the-data-model-to-update-a-hero } +#### `HeroUpdate` – das *Datenmodell* zum Aktualisieren eines Helden { #heroupdate-the-data-model-to-update-a-hero } In der vorherigen Version der App hatten wir keine Möglichkeit, einen Helden **zu aktualisieren**, aber jetzt mit **mehreren Modellen** können wir es. 🎉 diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index 74dc2a962..4711ac4c8 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -257,6 +257,40 @@ Do NOT translate with (German) – notice the added period: ## Ein weiteres Modul mit `APIRouter`. { #another-module-with-apirouter } +5.2) Replace occurrences of literal ` - ` (a space followed by a dash followed by a space) with ` – ` (a space followed by a long dash followed by a space) in the translated part of the heading. + +Example: + +Source (English): + +# FastAPI in Containers - Docker { #fastapi-in-containers-docker } + +Translate with (German) – notice the long dash: + +# FastAPI in Containern – Docker { #fastapi-in-containers-docker } + +Do NOT translate with (German): + +# FastAPI in Containern - Docker { #fastapi-in-containers-docker } + +5.2.1) Do not apply rule 5.2 when there is no space before or after the dash. + +Example: + +Source (English): + +## Type hints and annotations { #type-hints-and-annotations } + +Translate with (German) – use a short dash: + +## Typhinweise und -annotationen { #type-hints-and-annotations } + +Do NOT translate with (German): + +## Typhinweise und –annotationen { #type-hints-and-annotations } + +Rule 5.2 does not apply to the untranslated part of the heading, which is inside curly brackets. + 6) Follow these German instructions: From 9a47bacbe5b5e6f7de463d8d074d592f17a31185 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Tue, 26 Aug 2025 23:33:14 +0200 Subject: [PATCH 144/160] Add space between ellipsis and words Also added rule to prompt. I thought it is okay, meanwhile, in German when there is no space inbetween, (which is why i did not fix these changes before) but this is actually not the case. In English both spellings are okay. Has one change in the English document. If we leave those backticks, the LLM should by definition not translate it, but we want this here. --- docs/de/docs/advanced/templates.md | 4 +- docs/de/docs/deployment/concepts.md | 4 +- docs/de/docs/how-to/custom-docs-ui-assets.md | 6 +- docs/de/docs/index.md | 2 +- docs/de/docs/tutorial/bigger-applications.md | 4 +- docs/de/docs/tutorial/cors.md | 2 +- docs/de/docs/tutorial/debugging.md | 4 +- docs/de/docs/tutorial/extra-models.md | 4 +- .../path-params-numeric-validations.md | 2 +- .../tutorial/query-params-str-validations.md | 10 ++-- docs/de/docs/tutorial/sql-databases.md | 2 +- docs/de/llm-prompt.md | 55 +++++++++++++------ docs/en/docs/how-to/custom-docs-ui-assets.md | 2 +- 13 files changed, 62 insertions(+), 39 deletions(-) diff --git a/docs/de/docs/advanced/templates.md b/docs/de/docs/advanced/templates.md index 1510d0a39..b507c026a 100644 --- a/docs/de/docs/advanced/templates.md +++ b/docs/de/docs/advanced/templates.md @@ -71,7 +71,7 @@ Item ID: {{ id }} {% endraw %} -...wird die `id` angezeigt, welche dem „Kontext“-`dict` entnommen wird, welches Sie übergeben haben: +... wird die `id` angezeigt, welche dem „Kontext“-`dict` entnommen wird, welches Sie übergeben haben: ```Python {"id": id} @@ -97,7 +97,7 @@ Der Abschnitt mit: {% endraw %} -...generiert also einen Link zu derselben URL, welche von der *Pfadoperation-Funktion* `read_item(id=id)` gehandhabt werden würde. +... generiert also einen Link zu derselben URL, welche von der *Pfadoperation-Funktion* `read_item(id=id)` gehandhabt werden würde. Mit beispielsweise der ID `42` würde dies Folgendes ergeben: diff --git a/docs/de/docs/deployment/concepts.md b/docs/de/docs/deployment/concepts.md index f549f7fb2..a9e7fd7c9 100644 --- a/docs/de/docs/deployment/concepts.md +++ b/docs/de/docs/deployment/concepts.md @@ -121,7 +121,7 @@ Einige Beispiele für Tools, die diese Aufgabe übernehmen können, sind: * Systemd * Supervisor * Es wird intern von einem Cloud-Anbieter im Rahmen seiner Dienste verwaltet -* Andere... +* Andere ... In den nächsten Kapiteln werde ich Ihnen konkretere Beispiele geben. @@ -174,7 +174,7 @@ Dies könnte zum Beispiel erledigt werden durch: * Systemd * Supervisor * Intern von einem Cloud-Anbieter im Rahmen seiner Dienste -* Andere... +* Andere ... ## Replikation – Prozesse und Arbeitsspeicher { #replication-processes-and-memory } diff --git a/docs/de/docs/how-to/custom-docs-ui-assets.md b/docs/de/docs/how-to/custom-docs-ui-assets.md index 92322a9cd..21f55c8a3 100644 --- a/docs/de/docs/how-to/custom-docs-ui-assets.md +++ b/docs/de/docs/how-to/custom-docs-ui-assets.md @@ -32,7 +32,7 @@ Sie können die internen Funktionen von FastAPI wiederverwenden, um die HTML-Sei * `swagger_js_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **JavaScript**-Datei abrufen kann. Dies ist die benutzerdefinite CDN-URL. * `swagger_css_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **CSS**-Datei abrufen kann. Dies ist die benutzerdefinite CDN-URL. -Und ähnlich für ReDoc... +Und ähnlich für ReDoc ... {* ../../docs_src/custom_docs_ui/tutorial001.py hl[2:6,11:19,22:24,27:33] *} @@ -89,7 +89,7 @@ Ihre neue Dateistruktur könnte so aussehen: Laden Sie die für die Dokumentation benötigten statischen Dateien herunter und legen Sie diese im Verzeichnis `static/` ab. -Sie können wahrscheinlich mit der rechten Maustaste auf jeden Link klicken und eine Option wie etwa `Link speichern unter...` auswählen. +Sie können wahrscheinlich mit der rechten Maustaste auf jeden Link klicken und eine Option wie etwa „Link speichern unter ...“ auswählen. **Swagger UI** verwendet folgende Dateien: @@ -158,7 +158,7 @@ Auch hier können Sie die internen Funktionen von FastAPI wiederverwenden, um di * `swagger_js_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **JavaScript**-Datei abrufen kann. **Das ist die, welche jetzt von Ihrer eigenen Anwendung bereitgestellt wird**. * `swagger_css_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **CSS**-Datei abrufen kann. **Das ist die, welche jetzt von Ihrer eigenen Anwendung bereitgestellt wird**. -Und ähnlich für ReDoc... +Und ähnlich für ReDoc ... {* ../../docs_src/custom_docs_ui/tutorial002.py hl[2:6,14:22,25:27,30:36] *} diff --git a/docs/de/docs/index.md b/docs/de/docs/index.md index cd68bc128..c3e64df37 100644 --- a/docs/de/docs/index.md +++ b/docs/de/docs/index.md @@ -227,7 +227,7 @@ INFO: Application startup complete.
-Was der Befehl fastapi dev main.py macht... +Was der Befehl fastapi dev main.py macht ... Der Befehl `fastapi dev` liest Ihre `main.py`-Datei, erkennt die **FastAPI**-App darin und startet einen Server mit Uvicorn. diff --git a/docs/de/docs/tutorial/bigger-applications.md b/docs/de/docs/tutorial/bigger-applications.md index 6136c619e..b631f53b8 100644 --- a/docs/de/docs/tutorial/bigger-applications.md +++ b/docs/de/docs/tutorial/bigger-applications.md @@ -193,7 +193,7 @@ async def read_item(item_id: str): ... ``` -...darf das Präfix kein abschließendes `/` enthalten. +... darf das Präfix kein abschließendes `/` enthalten. Das Präfix lautet in diesem Fall also `/items`. @@ -212,7 +212,7 @@ Das Endergebnis ist, dass die Pfade für diese Artikel jetzt wie folgt lauten: * `/items/` * `/items/{item_id}` -...wie wir es beabsichtigt hatten. +... wie wir es beabsichtigt hatten. * Sie werden mit einer Liste von Tags gekennzeichnet, die einen einzelnen String `"items"` enthält. * Diese „Tags“ sind besonders nützlich für die automatischen interaktiven Dokumentationssysteme (unter Verwendung von OpenAPI). diff --git a/docs/de/docs/tutorial/cors.md b/docs/de/docs/tutorial/cors.md index 2d6ec224c..eff756250 100644 --- a/docs/de/docs/tutorial/cors.md +++ b/docs/de/docs/tutorial/cors.md @@ -63,7 +63,7 @@ Die folgenden Argumente werden unterstützt: * `expose_headers` - Angabe der Responseheader, auf die der Browser zugreifen können soll. Standardmäßig `[]`. * `max_age` - Legt eine maximale Zeit in Sekunden fest, die Browser CORS-Responses zwischenspeichern dürfen. Standardmäßig `600`. -Die Middleware antwortet auf zwei besondere Arten von HTTP-Requests... +Die Middleware antwortet auf zwei besondere Arten von HTTP-Requests ... ### CORS-Preflight-Requests { #cors-preflight-requests } diff --git a/docs/de/docs/tutorial/debugging.md b/docs/de/docs/tutorial/debugging.md index 927bea771..0a31f8653 100644 --- a/docs/de/docs/tutorial/debugging.md +++ b/docs/de/docs/tutorial/debugging.md @@ -87,7 +87,7 @@ Da Sie den Uvicorn-Server direkt aus Ihrem Code ausführen, können Sie Ihr Pyth Zum Beispiel können Sie in Visual Studio Code: * Zum „Debug“-Panel gehen. -* „Konfiguration hinzufügen...“ auswählen. +* „Konfiguration hinzufügen ...“ auswählen. * „Python“ auswählen. * Den Debugger mit der Option „`Python: Current File (Integrated Terminal)`“ ausführen. @@ -102,7 +102,7 @@ So könnte es aussehen: Wenn Sie Pycharm verwenden, können Sie: * Das Menü „Run“ öffnen. -* Die Option „Debug...“ auswählen. +* Die Option „Debug ...“ auswählen. * Ein Kontextmenü wird angezeigt. * Die zu debuggende Datei auswählen (in diesem Fall `main.py`). diff --git a/docs/de/docs/tutorial/extra-models.md b/docs/de/docs/tutorial/extra-models.md index 8bd65cdf2..f8bc5d616 100644 --- a/docs/de/docs/tutorial/extra-models.md +++ b/docs/de/docs/tutorial/extra-models.md @@ -116,7 +116,7 @@ gleichwertig zu: UserInDB(**user_in.dict()) ``` -...weil `user_in.dict()` ein `dict` ist, und dann lassen wir Python es „entpacken“, indem wir es an `UserInDB` mit vorangestelltem `**` übergeben. +... weil `user_in.dict()` ein `dict` ist, und dann lassen wir Python es „entpacken“, indem wir es an `UserInDB` mit vorangestelltem `**` übergeben. Auf diese Weise erhalten wir ein Pydantic-Modell aus den Daten eines anderen Pydantic-Modells. @@ -128,7 +128,7 @@ Und dann fügen wir das zusätzliche Schlüsselwort-Argument `hashed_password=ha UserInDB(**user_in.dict(), hashed_password=hashed_password) ``` -...was so ist wie: +... was so ist wie: ```Python UserInDB( diff --git a/docs/de/docs/tutorial/path-params-numeric-validations.md b/docs/de/docs/tutorial/path-params-numeric-validations.md index 0b31daa13..60101096e 100644 --- a/docs/de/docs/tutorial/path-params-numeric-validations.md +++ b/docs/de/docs/tutorial/path-params-numeric-validations.md @@ -87,7 +87,7 @@ Wenn Sie: * sie in einer anderen Reihenfolge haben * nicht `Annotated` verwenden -...möchten, dann hat Python eine kleine Spezial-Syntax dafür. +... möchten, dann hat Python eine kleine Spezial-Syntax dafür. Übergeben Sie `*`, als den ersten Parameter der Funktion. diff --git a/docs/de/docs/tutorial/query-params-str-validations.md b/docs/de/docs/tutorial/query-params-str-validations.md index acf199af9..669f63369 100644 --- a/docs/de/docs/tutorial/query-params-str-validations.md +++ b/docs/de/docs/tutorial/query-params-str-validations.md @@ -129,7 +129,7 @@ Also: q: str | None = Query(default=None) ``` -...macht den Parameter optional mit einem Defaultwert von `None`, genauso wie: +... macht den Parameter optional mit einem Defaultwert von `None`, genauso wie: ```Python q: str | None = None @@ -157,7 +157,7 @@ Zum Beispiel ist das nicht erlaubt: q: Annotated[str, Query(default="rick")] = "morty" ``` -...denn es ist nicht klar, ob der Defaultwert `"rick"` oder `"morty"` sein soll. +... denn es ist nicht klar, ob der Defaultwert `"rick"` oder `"morty"` sein soll. Sie würden also (bevorzugt) schreiben: @@ -165,7 +165,7 @@ Sie würden also (bevorzugt) schreiben: q: Annotated[str, Query()] = "rick" ``` -...oder in älteren Codebasen finden Sie: +... oder in älteren Codebasen finden Sie: ```Python q: str = Query(default="rick") @@ -375,7 +375,7 @@ Aber `item-query` ist kein gültiger Name für eine Variable in Python. Der am ähnlichsten wäre `item_query`. -Aber Sie benötigen dennoch, dass er genau `item-query` ist... +Aber Sie benötigen dennoch, dass er genau `item-query` ist ... Dann können Sie ein `alias` deklarieren, und dieser Alias wird verwendet, um den Parameterwert zu finden: @@ -459,7 +459,7 @@ Dann **weisen wir diese beiden Werte** des Tupels den Variablen `id` und `name` Wenn der Benutzer also keine Artikel-ID bereitgestellt hat, erhält er trotzdem einen zufälligen Vorschlag. -...wir tun all dies in einer **einzelnen einfachen Zeile**. 🤯 Lieben Sie nicht auch Python? 🐍 +... wir tun all dies in einer **einzelnen einfachen Zeile**. 🤯 Lieben Sie nicht auch Python? 🐍 {* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *} diff --git a/docs/de/docs/tutorial/sql-databases.md b/docs/de/docs/tutorial/sql-databases.md index e7f61b1f1..5cd0a6f84 100644 --- a/docs/de/docs/tutorial/sql-databases.md +++ b/docs/de/docs/tutorial/sql-databases.md @@ -173,7 +173,7 @@ Wenn Sie die vorherige App überprüfen, können Sie in der UI sehen, dass sie b Das sollten wir nicht zulassen, sie könnten eine `id` überschreiben, die wir bereits in der DB zugewiesen haben. Die Entscheidung über die `id` sollte vom **Backend** oder der **Datenbank** getroffen werden, **nicht vom Client**. -Außerdem erstellen wir einen `secret_name` für den Helden, aber bisher geben wir ihn überall zurück, das ist nicht sehr **geheim**... 😅 +Außerdem erstellen wir einen `secret_name` für den Helden, aber bisher geben wir ihn überall zurück, das ist nicht sehr **geheim** ... 😅 Wir werden diese Dinge beheben, indem wir ein paar **zusätzliche Modelle** hinzufügen. Hier wird SQLModel glänzen. ✨ diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index 4711ac4c8..628f0f5dd 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -37,9 +37,32 @@ Inline-Code der nur ein kurzes Stringliteral enthält: `"foo"` `"__main__"` -4) Translate HTML abbr elements as follows: +4) make sure there is a space between an ellipsis and a word following or preceding it. -4.1) If the title attribute gives the full phrase for an abbreviation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase. +Examples: + +Source (English): + +...as we intended. +...this would work: +...etc. +others... +More to come... + +Result (German): + +... wie wir es beabsichtigt hatten. +... das würde funktionieren: +... usw. +Andere ... +Später mehr ... + +4.1) Rule 4 does not apply in URLs, code blocks, inline code. Do not change the spaces there. + + +5) Translate HTML abbr elements as follows: + +5.1) If the title attribute gives the full phrase for an abbreviation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase. Examples: @@ -65,7 +88,7 @@ Result (German): {full phrase} – {translation of full phrase} -4.1.1) If the phrase can not be translated, or it is the same in the translation, then keep the title attribute as is. +5.1.1) If the phrase can not be translated, or it is the same in the translation, then keep the title attribute as is. Examples: @@ -89,7 +112,7 @@ Result (German): {full phrase} -4.1.2) If the phrase can be translated and that translation has the same starting letters, then just use the translation. +5.1.2) If the phrase can be translated and that translation has the same starting letters, then just use the translation. Examples: @@ -111,7 +134,7 @@ Result (German): {translation of full phrase} -4.2) If the title attribute explains something in its own words, then translate it, if possible. +5.2) If the title attribute explains something in its own words, then translate it, if possible. Examples: @@ -141,7 +164,7 @@ Result (German): {translation of explanation} -4.2.1) If the term, which the HTML abbr element wraps, stays English in the translation, but it also has a translation, whose knowledge improves the explanation, then let the title attribute be that translation, followed by a colon (`:`), followed by the translation of the title attribute. +5.2.1) If the term, which the HTML abbr element wraps, stays English in the translation, but it also has a translation, whose knowledge improves the explanation, then let the title attribute be that translation, followed by a colon (`:`), followed by the translation of the title attribute. Examples: @@ -164,7 +187,7 @@ Result (German): {translation of term which abbr wraps}: {translation of explanation} -4.3) If the title attribute gives the full phrase for an abbreviation, followed by a colon (`:`) or a comma (`,`), followed by an explanation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase, followed by a colon (`:`), followed by the translation of the explanation. +5.3) If the title attribute gives the full phrase for an abbreviation, followed by a colon (`:`) or a comma (`,`), followed by an explanation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase, followed by a colon (`:`), followed by the translation of the explanation. Examples: @@ -198,10 +221,10 @@ Result (German): {full phrase} – {translation of full phrase}: {translation of explanation} -4.4) If there is an HTML abbr element in a sentence in an existing translation, but that element does not exist in the related sentence in the English text, then keep that HTML abbr element in the translation, do not change or remove it. Except when you remove the whole sentence from the translation, because the whole sentence was removed from the English text. The reasoning for this rule is, that such abbr elements are manually added by the human editor of the translation, in order to translate or explain an English word to the human readers of the translation. They would not make sense in the English text, but they do make sense in the translation. So keep them in the translation, even though they are not part of the English text. This rule only applies to HTML abbr elements. +5.4) If there is an HTML abbr element in a sentence in an existing translation, but that element does not exist in the related sentence in the English text, then keep that HTML abbr element in the translation, do not change or remove it. Except when you remove the whole sentence from the translation, because the whole sentence was removed from the English text. The reasoning for this rule is, that such abbr elements are manually added by the human editor of the translation, in order to translate or explain an English word to the human readers of the translation. They would not make sense in the English text, but they do make sense in the translation. So keep them in the translation, even though they are not part of the English text. This rule only applies to HTML abbr elements. -5) Translate headings using the infinite form. +6) Translate headings using the infinite form. Examples: @@ -241,7 +264,7 @@ Do NOT translate with (German): ### Führen Sie Ihr Programm aus { #run-your-program } -5.1) Make sure that the translated part of the heading does not end with a period. +6.1) Make sure that the translated part of the heading does not end with a period. Example: @@ -257,7 +280,7 @@ Do NOT translate with (German) – notice the added period: ## Ein weiteres Modul mit `APIRouter`. { #another-module-with-apirouter } -5.2) Replace occurrences of literal ` - ` (a space followed by a dash followed by a space) with ` – ` (a space followed by a long dash followed by a space) in the translated part of the heading. +6.2) Replace occurrences of literal ` - ` (a space followed by a dash followed by a space) with ` – ` (a space followed by a long dash followed by a space) in the translated part of the heading. Example: @@ -273,7 +296,7 @@ Do NOT translate with (German): # FastAPI in Containern - Docker { #fastapi-in-containers-docker } -5.2.1) Do not apply rule 5.2 when there is no space before or after the dash. +6.2.1) Do not apply rule 6.2 when there is no space before or after the dash. Example: @@ -289,17 +312,17 @@ Do NOT translate with (German): ## Typhinweise und –annotationen { #type-hints-and-annotations } -Rule 5.2 does not apply to the untranslated part of the heading, which is inside curly brackets. +Rule 6.2 does not apply to the untranslated part of the heading inside curly brackets, which you shall not translate. -6) Follow these German instructions: +7) Follow these German instructions: In der Regel versuche ich so weit wie möglich Worte zusammenzuschreiben, also ohne Bindestrich, es sei denn, es ist Konkretesding-Klassevondingen, etwa `Pydantic-Modell` (aber: `Datenbankmodell`), `Python-Modul` (aber: `Standardmodul`). Ich setze auch einen Bindestrich, wenn er die gleichen Buchstaben verbindet, etwa `Enum-Member`, `Cloud-Dienst`, `Template-Engine`. Oder wenn das Wort sonst einfach zu lang wird, etwa, `Performance-Optimierung`. Oder um etwas visuell besser zu dokumentieren, etwa `Pfadoperation-Dekorator`, `Pfadoperation-Funktion`. Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriffe aus dem Bereich der Programmierung. Ich wandele zwar korrekt in Großschreibung um und setze Bindestriche, wo notwendig, aber ansonsten lasse ich solch ein Wort unverändert. Beispielsweise wird aus dem englischen Wort `string` in der deutschen Übersetzung `String`, aber nicht `Zeichenkette`. Oder aus dem englischen Wort `request body` wird in der deutschen Übersetzung `Requestbody`, aber nicht `Anfragekörper`. Oder aus dem englischen `response` wird im Deutschen `Response`, aber nicht `Antwort`. -7) Below is a list of English terms and their German translations, separated by a colon (`:`). Use these translations, do not use your own. Words inside brackets are explanations for you, they are not part of the term or the translation. If a list item starts with `NOT`, then that means: do NOT use this translation. Nouns, starting with the word `the`, have their German genus – `der`, `die`, `das` – included, to help you to grammatically decline them in the translation, and they are given in singular case unless they have `(plural case)` attached, which means they are given in plural case. Verbs are given in the full infinitive – starting with the word `to`. +8) Below is a list of English terms and their German translations, separated by a colon (`:`). Use these translations, do not use your own. Words inside brackets are explanations for you, they are not part of the term or the translation. If a list item starts with `NOT`, then that means: do NOT use this translation. Nouns, starting with the word `the`, have their German genus – `der`, `die`, `das` – included, to help you to grammatically decline them in the translation, and they are given in singular case unless they have `(plural case)` attached, which means they are given in plural case. Verbs are given in the full infinitive – starting with the word `to`. * /// check: /// check | Testen * /// danger: /// danger | Gefahr @@ -394,4 +417,4 @@ Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriff * standard Python: Standard-Python -8) Preserve indentation. Keep emoticons. Encode in utf-8. Use Linux line breaks (LF) +9) Preserve indentation. Keep emoticons. Encode in utf-8. Use Linux line breaks (LF) diff --git a/docs/en/docs/how-to/custom-docs-ui-assets.md b/docs/en/docs/how-to/custom-docs-ui-assets.md index b38c4ec02..91228c8c9 100644 --- a/docs/en/docs/how-to/custom-docs-ui-assets.md +++ b/docs/en/docs/how-to/custom-docs-ui-assets.md @@ -89,7 +89,7 @@ Your new file structure could look like this: Download the static files needed for the docs and put them on that `static/` directory. -You can probably right-click each link and select an option similar to `Save link as...`. +You can probably right-click each link and select an option similar to "Save link as...". **Swagger UI** uses the files: From 586492c1b01325da512b0e3af8f224b9b51ac852 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Wed, 27 Aug 2025 02:04:57 +0200 Subject: [PATCH 145/160] Intermezzo: `Testen` --> `Es testen` --- docs/de/docs/advanced/security/oauth2-scopes.md | 2 +- docs/de/docs/advanced/wsgi.md | 2 +- docs/de/docs/deployment/docker.md | 2 +- docs/de/docs/how-to/custom-docs-ui-assets.md | 2 +- docs/de/docs/how-to/extending-openapi.md | 2 +- docs/de/docs/index.md | 2 +- docs/de/docs/tutorial/bigger-applications.md | 2 +- docs/de/docs/tutorial/cookie-param-models.md | 2 +- docs/de/docs/tutorial/first-steps.md | 2 +- docs/de/docs/tutorial/header-param-models.md | 2 +- docs/de/docs/tutorial/metadata.md | 2 +- docs/de/docs/tutorial/query-param-models.md | 2 +- docs/de/docs/tutorial/security/first-steps.md | 2 +- docs/de/docs/tutorial/security/oauth2-jwt.md | 2 +- 14 files changed, 14 insertions(+), 14 deletions(-) diff --git a/docs/de/docs/advanced/security/oauth2-scopes.md b/docs/de/docs/advanced/security/oauth2-scopes.md index 571c76f18..af82ecd34 100644 --- a/docs/de/docs/advanced/security/oauth2-scopes.md +++ b/docs/de/docs/advanced/security/oauth2-scopes.md @@ -233,7 +233,7 @@ Da die `SecurityScopes` alle von den Verwendern der Abhängigkeiten deklarierten Diese werden für jede *Pfadoperation* unabhängig überprüft. -## Testen { #check-it } +## Es testen { #check-it } Wenn Sie die API-Dokumentation öffnen, können Sie sich authentisieren und angeben, welche Scopes Sie autorisieren möchten. diff --git a/docs/de/docs/advanced/wsgi.md b/docs/de/docs/advanced/wsgi.md index 1b547448c..6f9acc027 100644 --- a/docs/de/docs/advanced/wsgi.md +++ b/docs/de/docs/advanced/wsgi.md @@ -14,7 +14,7 @@ Und dann mounten Sie das auf einem Pfad. {* ../../docs_src/wsgi/tutorial001.py hl[2:3,3] *} -## Testen { #check-it } +## Es testen { #check-it } Jetzt wird jeder Request unter dem Pfad `/v1/` von der Flask-Anwendung verarbeitet. diff --git a/docs/de/docs/deployment/docker.md b/docs/de/docs/deployment/docker.md index 0307768a1..9398129bf 100644 --- a/docs/de/docs/deployment/docker.md +++ b/docs/de/docs/deployment/docker.md @@ -352,7 +352,7 @@ $ docker run -d --name mycontainer -p 80:80 myimage
-## Testen { #check-it } +## Es testen { #check-it } Sie sollten es in der URL Ihres Docker-Containers überprüfen können, zum Beispiel: http://192.168.99.100/items/5?q=somequery oder http://127.0.0.1/items/5?q=somequery (oder gleichwertig, unter Verwendung Ihres Docker-Hosts). diff --git a/docs/de/docs/how-to/custom-docs-ui-assets.md b/docs/de/docs/how-to/custom-docs-ui-assets.md index 21f55c8a3..fc3a4d1e8 100644 --- a/docs/de/docs/how-to/custom-docs-ui-assets.md +++ b/docs/de/docs/how-to/custom-docs-ui-assets.md @@ -52,7 +52,7 @@ Um nun testen zu können, ob alles funktioniert, erstellen Sie eine *Pfadoperati {* ../../docs_src/custom_docs_ui/tutorial001.py hl[36:38] *} -### Testen { #test-it } +### Es testen { #test-it } Jetzt sollten Sie in der Lage sein, zu Ihrer Dokumentation auf http://127.0.0.1:8000/docs zu gehen und die Seite neu zu laden. Die Assets werden nun vom neuen CDN geladen. diff --git a/docs/de/docs/how-to/extending-openapi.md b/docs/de/docs/how-to/extending-openapi.md index 925eb6e2b..ffbbc338f 100644 --- a/docs/de/docs/how-to/extending-openapi.md +++ b/docs/de/docs/how-to/extending-openapi.md @@ -73,7 +73,7 @@ Jetzt können Sie die Methode `.openapi()` durch Ihre neue Funktion ersetzen. {* ../../docs_src/extending_openapi/tutorial001.py hl[29] *} -### Testen { #check-it } +### Es testen { #check-it } Sobald Sie auf http://127.0.0.1:8000/redoc gehen, werden Sie sehen, dass Ihr benutzerdefiniertes Logo verwendet wird (in diesem Beispiel das Logo von **FastAPI**): diff --git a/docs/de/docs/index.md b/docs/de/docs/index.md index c3e64df37..d8b25a293 100644 --- a/docs/de/docs/index.md +++ b/docs/de/docs/index.md @@ -237,7 +237,7 @@ Sie können mehr darüber in der http://127.0.0.1:8000/items/5?q=somequery. diff --git a/docs/de/docs/tutorial/bigger-applications.md b/docs/de/docs/tutorial/bigger-applications.md index b631f53b8..e7ea1b195 100644 --- a/docs/de/docs/tutorial/bigger-applications.md +++ b/docs/de/docs/tutorial/bigger-applications.md @@ -517,7 +517,7 @@ Da wir sie nicht einfach isolieren und unabhängig vom Rest „mounten“ könne /// -## Es in der automatischen API-Dokumentation ansehen { #check-the-automatic-api-docs } +## Es in der automatischen API-Dokumentation testen { #check-the-automatic-api-docs } Führen Sie nun Ihre App aus: diff --git a/docs/de/docs/tutorial/cookie-param-models.md b/docs/de/docs/tutorial/cookie-param-models.md index 7a0a34f6a..e6a7909d6 100644 --- a/docs/de/docs/tutorial/cookie-param-models.md +++ b/docs/de/docs/tutorial/cookie-param-models.md @@ -24,7 +24,7 @@ Deklarieren Sie die **Cookie**-Parameter, die Sie benötigen, in einem **Pydanti **FastAPI** wird die Daten für **jedes Feld** aus den im Request empfangenen **Cookies** **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell bereitstellen. -## Die Dokumentation überprüfen { #check-the-docs } +## Die Dokumentation testen { #check-the-docs } Sie können die definierten Cookies in der Dokumentationsoberfläche unter `/docs` sehen: diff --git a/docs/de/docs/tutorial/first-steps.md b/docs/de/docs/tutorial/first-steps.md index dfd6a1363..b20da78df 100644 --- a/docs/de/docs/tutorial/first-steps.md +++ b/docs/de/docs/tutorial/first-steps.md @@ -56,7 +56,7 @@ INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) Diese Zeile zeigt die URL, unter der Ihre App auf Ihrem lokalen Computer bereitgestellt wird. -### Überprüfen { #check-it } +### Es testen { #check-it } Öffnen Sie Ihren Browser unter http://127.0.0.1:8000. diff --git a/docs/de/docs/tutorial/header-param-models.md b/docs/de/docs/tutorial/header-param-models.md index 5a5409df9..dab65cdb6 100644 --- a/docs/de/docs/tutorial/header-param-models.md +++ b/docs/de/docs/tutorial/header-param-models.md @@ -18,7 +18,7 @@ Deklarieren Sie die erforderlichen **Header-Parameter** in einem **Pydantic-Mode **FastAPI** wird die Daten für **jedes Feld** aus den **Headern** des Requests extrahieren und Ihnen das von Ihnen definierte Pydantic-Modell geben. -## Die Dokumentation überprüfen { #check-the-docs } +## Die Dokumentation testen { #check-the-docs } Sie können die erforderlichen Header in der Dokumentationsoberfläche unter `/docs` sehen: diff --git a/docs/de/docs/tutorial/metadata.md b/docs/de/docs/tutorial/metadata.md index 11541bf09..f1bf5faf8 100644 --- a/docs/de/docs/tutorial/metadata.md +++ b/docs/de/docs/tutorial/metadata.md @@ -80,7 +80,7 @@ Lesen Sie mehr zu Tags unter [Pfadoperation-Konfiguration](path-operation-config /// -### Die Dokumentation ansehen { #check-the-docs } +### Die Dokumentation testen { #check-the-docs } Wenn Sie nun die Dokumentation ansehen, werden dort alle zusätzlichen Metadaten angezeigt: diff --git a/docs/de/docs/tutorial/query-param-models.md b/docs/de/docs/tutorial/query-param-models.md index 3e32443df..2c6f59da6 100644 --- a/docs/de/docs/tutorial/query-param-models.md +++ b/docs/de/docs/tutorial/query-param-models.md @@ -18,7 +18,7 @@ Deklarieren Sie die benötigten **Query-Parameter** in einem **Pydantic-Modell** **FastAPI** wird die Daten für **jedes Feld** aus den **Query-Parametern** der Anfrage extrahieren und Ihnen das definierte Pydantic-Modell bereitstellen. -## Die Dokumentation überprüfen { #check-the-docs } +## Die Dokumentation testen { #check-the-docs } Sie können die Query-Parameter in der Dokumentations-Oberfläche unter `/docs` einsehen: diff --git a/docs/de/docs/tutorial/security/first-steps.md b/docs/de/docs/tutorial/security/first-steps.md index 37af6a171..fc810a4dc 100644 --- a/docs/de/docs/tutorial/security/first-steps.md +++ b/docs/de/docs/tutorial/security/first-steps.md @@ -54,7 +54,7 @@ $ fastapi dev main.py
-## Testen { #check-it } +## Es testen { #check-it } Gehen Sie zu der interaktiven Dokumentation unter: http://127.0.0.1:8000/docs. diff --git a/docs/de/docs/tutorial/security/oauth2-jwt.md b/docs/de/docs/tutorial/security/oauth2-jwt.md index 3b77a2040..f2018a78d 100644 --- a/docs/de/docs/tutorial/security/oauth2-jwt.md +++ b/docs/de/docs/tutorial/security/oauth2-jwt.md @@ -194,7 +194,7 @@ Deshalb, um ID-Kollisionen zu vermeiden, könnten Sie beim Erstellen des JWT-Tok Der wesentliche Punkt ist, dass der `sub`-Schlüssel in der gesamten Anwendung eine eindeutige Kennung haben sollte, und er sollte ein String sein. -## Testen { #check-it } +## Es testen { #check-it } Führen Sie den Server aus und gehen Sie zur Dokumentation: http://127.0.0.1:8000/docs. From 741353b31bea4150ced1242a95530c2e7b28b32d Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Wed, 27 Aug 2025 02:08:27 +0200 Subject: [PATCH 146/160] =?UTF-8?q?Intermezzo:=20`als`,=20`=C3=BCber`=20--?= =?UTF-8?q?>=20`via`?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/de/docs/advanced/additional-status-codes.md | 2 +- docs/de/docs/tutorial/handling-errors.md | 4 ++-- docs/de/docs/tutorial/response-status-code.md | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/de/docs/advanced/additional-status-codes.md b/docs/de/docs/advanced/additional-status-codes.md index 8e553c9ff..8d34c1c8c 100644 --- a/docs/de/docs/advanced/additional-status-codes.md +++ b/docs/de/docs/advanced/additional-status-codes.md @@ -30,7 +30,7 @@ Stellen Sie sicher, dass sie die gewünschten Daten enthält und dass die Werte Sie können auch `from starlette.responses import JSONResponse` verwenden. -**FastAPI** bietet dieselben `starlette.responses` auch über `fastapi.responses` an, als Annehmlichkeit für Sie, den Entwickler. Die meisten verfügbaren Responses kommen aber direkt von Starlette. Dasselbe gilt für `status`. +**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. Dasselbe gilt für `status`. /// diff --git a/docs/de/docs/tutorial/handling-errors.md b/docs/de/docs/tutorial/handling-errors.md index 27a0aa569..3791cc15e 100644 --- a/docs/de/docs/tutorial/handling-errors.md +++ b/docs/de/docs/tutorial/handling-errors.md @@ -105,7 +105,7 @@ Sie erhalten also einen sauberen Fehler mit einem HTTP-Statuscode von `418` und Sie könnten auch `from starlette.requests import Request` und `from starlette.responses import JSONResponse` verwenden. -**FastAPI** bietet dieselben `starlette.responses` auch als `fastapi.responses` an, nur als Annehmlichkeit für Sie, den Entwickler. Aber die meisten verfügbaren Responses kommen direkt von Starlette. Dasselbe gilt für `Request`. +**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, nur als Annehmlichkeit für Sie, den Entwickler. Aber die meisten verfügbaren Responses kommen direkt von Starlette. Dasselbe gilt für `Request`. /// @@ -184,7 +184,7 @@ Zum Beispiel könnten Sie eine Klartext-Response statt JSON für diese Fehler zu Sie könnten auch `from starlette.responses import PlainTextResponse` verwenden. -**FastAPI** bietet dieselben `starlette.responses` auch als `fastapi.responses` an, nur als Annehmlichkeit für Sie, den Entwickler. Aber die meisten verfügbaren Responses kommen direkt von Starlette. +**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, nur als Annehmlichkeit für Sie, den Entwickler. Aber die meisten verfügbaren Responses kommen direkt von Starlette. /// diff --git a/docs/de/docs/tutorial/response-status-code.md b/docs/de/docs/tutorial/response-status-code.md index de389b1ef..03a96c58a 100644 --- a/docs/de/docs/tutorial/response-status-code.md +++ b/docs/de/docs/tutorial/response-status-code.md @@ -92,7 +92,7 @@ Diese sind nur eine Annehmlichkeit, sie enthalten dieselbe Zahl, aber so können Sie könnten auch `from starlette import status` verwenden. -**FastAPI** bietet dieselben `starlette.status`-Codes auch über `fastapi.status` an, rein zu Ihrer Annehmlichkeit als Entwickler. Aber sie stammen direkt von Starlette. +**FastAPI** bietet dieselben `starlette.status`-Codes auch via `fastapi.status` an, rein zu Ihrer Annehmlichkeit als Entwickler. Aber sie stammen direkt von Starlette. /// From 8c30dee61c2e3ba8c84d88dd9121dd28362219e1 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Wed, 27 Aug 2025 02:11:35 +0200 Subject: [PATCH 147/160] Intermezzo: `Exception-Handler` --> `Exceptionhandler` --- docs/de/docs/tutorial/handling-errors.md | 20 ++++++++++---------- docs/de/llm-prompt.md | 1 + 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/docs/de/docs/tutorial/handling-errors.md b/docs/de/docs/tutorial/handling-errors.md index 3791cc15e..5ed676118 100644 --- a/docs/de/docs/tutorial/handling-errors.md +++ b/docs/de/docs/tutorial/handling-errors.md @@ -79,15 +79,15 @@ Aber falls Sie es für ein fortgeschrittenes Szenario benötigen, können Sie be {* ../../docs_src/handling_errors/tutorial002.py hl[14] *} -## Benutzerdefinierte Exception-Handler installieren { #install-custom-exception-handlers } +## Benutzerdefinierte Exceptionhandler installieren { #install-custom-exception-handlers } -Sie können benutzerdefinierte Exception-Handler mit den gleichen Exception-Werkzeugen von Starlette hinzufügen. +Sie können benutzerdefinierte Exceptionhandler mit den gleichen Exception-Werkzeugen von Starlette hinzufügen. Angenommen, Sie haben eine benutzerdefinierte Exception `UnicornException`, die Sie (oder eine Bibliothek, die Sie verwenden) `raise` könnte. Und Sie möchten diese Exception global mit FastAPI handhaben. -Sie könnten einen benutzerdefinierten Exception-Handler mit `@app.exception_handler()` hinzufügen: +Sie könnten einen benutzerdefinierten Exceptionhandler mit `@app.exception_handler()` hinzufügen: {* ../../docs_src/handling_errors/tutorial003.py hl[5:7,13:18,24] *} @@ -109,23 +109,23 @@ Sie könnten auch `from starlette.requests import Request` und `from starlette.r /// -## Die Default-Exception-Handler überschreiben { #override-the-default-exception-handlers } +## Die Default-Exceptionhandler überschreiben { #override-the-default-exception-handlers } -**FastAPI** hat einige Default-Exception-Handler. +**FastAPI** hat einige Default-Exceptionhandler. Diese Handler sind dafür verantwortlich, die standardmäßigen JSON-Responses zurückzugeben, wenn Sie eine `HTTPException` `raise`n und wenn die Anfrage ungültige Daten enthält. -Sie können diese Exception-Handler mit Ihren eigenen überschreiben. +Sie können diese Exceptionhandler mit Ihren eigenen überschreiben. ### Überschreiben von Request-Validierungs-Exceptions { #override-request-validation-exceptions } Wenn ein Request ungültige Daten enthält, löst **FastAPI** intern einen `RequestValidationError` aus. -Und es enthält auch einen Default-Exception-Handler für diesen. +Und es enthält auch einen Default-Exceptionhandler für diesen. -Um diesen zu überschreiben, importieren Sie den `RequestValidationError` und verwenden Sie ihn mit `@app.exception_handler(RequestValidationError)`, um den Exception-Handler zu dekorieren. +Um diesen zu überschreiben, importieren Sie den `RequestValidationError` und verwenden Sie ihn mit `@app.exception_handler(RequestValidationError)`, um den Exceptionhandler zu dekorieren. -Der Exception-Handler erhält einen `Request` und die Exception. +Der Exceptionhandler erhält einen `Request` und die Exception. {* ../../docs_src/handling_errors/tutorial004.py hl[2,14:16] *} @@ -236,7 +236,7 @@ Der einzige Unterschied besteht darin, dass die `HTTPException` von **FastAPI** Sie können also weiterhin die `HTTPException` von **FastAPI** wie üblich in Ihrem Code auslösen. -Aber wenn Sie einen Exception-Handler registrieren, sollten Sie ihn für die `HTTPException` von Starlette registrieren. +Aber wenn Sie einen Exceptionhandler registrieren, sollten Sie ihn für die `HTTPException` von Starlette registrieren. Auf diese Weise, wenn irgendein Teil des internen Codes von Starlette, oder eine Starlette-Erweiterung oder ein Plug-in, eine Starlette `HTTPException` auslöst, wird Ihr Handler in der Lage sein, diese abzufangen und zu handhaben. diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index 628f0f5dd..9b04c7102 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -357,6 +357,7 @@ Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriff * the error response: die Error-Response * the event: das Event * the exception: die Exception +* the exception handler: der Exceptionhandler * the form model: das Formularmodell * the form body: der Formularbody * the header: der Header From 0b70c3b5ca679964acc63581b9361f8bc8f2e549 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Wed, 27 Aug 2025 02:38:16 +0200 Subject: [PATCH 148/160] Intermezzo: `deprecated` --> `deprecatet` That is how such english words are spelled in German, they end with `t` (which I didnt know back then when I translated). And wrap it in an abbr which explains the meaning. --- docs/de/docs/advanced/events.md | 2 +- docs/de/docs/how-to/general.md | 2 +- docs/de/docs/how-to/graphql.md | 2 +- docs/de/docs/tutorial/body-updates.md | 4 ++-- docs/de/docs/tutorial/extra-models.md | 2 +- docs/de/docs/tutorial/path-operation-configuration.md | 4 ++-- docs/de/docs/tutorial/query-params-str-validations.md | 4 ++-- docs/de/docs/tutorial/response-model.md | 2 +- docs/de/docs/tutorial/schema-extra-example.md | 4 ++-- docs/de/docs/tutorial/security/oauth2-jwt.md | 2 +- docs/de/llm-prompt.md | 1 + 11 files changed, 15 insertions(+), 14 deletions(-) diff --git a/docs/de/docs/advanced/events.md b/docs/de/docs/advanced/events.md index 9c67a3833..2e54a5a73 100644 --- a/docs/de/docs/advanced/events.md +++ b/docs/de/docs/advanced/events.md @@ -84,7 +84,7 @@ Der Parameter `lifespan` der `FastAPI`-App benötigt einen **asynchronen Kontext {* ../../docs_src/events/tutorial003.py hl[22] *} -## Alternative Events (veraltet) { #alternative-events-deprecated } +## Alternative Events (deprecatet) { #alternative-events-deprecated } /// warning | Achtung diff --git a/docs/de/docs/how-to/general.md b/docs/de/docs/how-to/general.md index 1a9536e80..0045eab74 100644 --- a/docs/de/docs/how-to/general.md +++ b/docs/de/docs/how-to/general.md @@ -20,7 +20,7 @@ Um die Beschreibung der Response zu definieren, welche in der Oberfläche der Do ## *Pfadoperation* in der Dokumentation deprecaten – OpenAPI { #documentation-deprecate-a-path-operation-openapi } -Um eine *Pfadoperation* zu deprecaten – sie als veraltet zu markieren – und das in der Oberfläche der Dokumentation anzuzeigen, lesen Sie die Dokumentation unter [Tutorial – Pfadoperation-Konfiguration – Deprecaten](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}. +Um eine *Pfadoperation* zu deprecaten und das in der Oberfläche der Dokumentation anzuzeigen, lesen Sie die Dokumentation unter [Tutorial – Pfadoperation-Konfiguration – Deprecaten](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}. ## Daten in etwas JSON-kompatibles konvertieren { #convert-any-data-to-json-compatible } diff --git a/docs/de/docs/how-to/graphql.md b/docs/de/docs/how-to/graphql.md index 3e46e2bc7..6bd602445 100644 --- a/docs/de/docs/how-to/graphql.md +++ b/docs/de/docs/how-to/graphql.md @@ -45,7 +45,7 @@ Und auch in der Dokumentation zu Graphene. -Das wurde von Starlette deprecated, aber wenn Sie Code haben, der das verwendet, können Sie einfach zu starlette-graphene3 **migrieren**, das denselben Anwendungsfall abdeckt und eine **fast identische Schnittstelle** hat. +Das wurde von Starlette deprecatet, aber wenn Sie Code haben, der das verwendet, können Sie einfach zu starlette-graphene3 **migrieren**, das denselben Anwendungsfall abdeckt und eine **fast identische Schnittstelle** hat. /// tip | Tipp diff --git a/docs/de/docs/tutorial/body-updates.md b/docs/de/docs/tutorial/body-updates.md index 1caff790b..d106d01b3 100644 --- a/docs/de/docs/tutorial/body-updates.md +++ b/docs/de/docs/tutorial/body-updates.md @@ -52,7 +52,7 @@ Wie in `item.model_dump(exclude_unset=True)`. /// info | Info -In Pydantic v1 hieß diese Methode `.dict()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstützt) und in `.model_dump()` umbenannt. +In Pydantic v1 hieß diese Methode `.dict()`, in Pydantic v2 wurde sie deprecatet (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. @@ -70,7 +70,7 @@ Jetzt können Sie eine Kopie des existierenden Modells mittels `.model_copy()` e /// info | Info -In Pydantic v1 hieß diese Methode `.copy()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstützt) und in `.model_copy()` umbenannt. +In Pydantic v1 hieß diese Methode `.copy()`, in Pydantic v2 wurde sie deprecatet (aber immer noch unterstützt) und in `.model_copy()` umbenannt. Die Beispiele hier verwenden `.copy()` für die Kompatibilität mit Pydantic v1, Sie sollten jedoch stattdessen `.model_copy()` verwenden, wenn Sie Pydantic v2 verwenden können. diff --git a/docs/de/docs/tutorial/extra-models.md b/docs/de/docs/tutorial/extra-models.md index f8bc5d616..160ba1172 100644 --- a/docs/de/docs/tutorial/extra-models.md +++ b/docs/de/docs/tutorial/extra-models.md @@ -24,7 +24,7 @@ Hier ist eine allgemeine Idee, wie die Modelle mit ihren Passwortfeldern aussehe /// info | Info -In Pydantic v1 hieß die Methode `.dict()`, in Pydantic v2 wurde sie als veraltet markiert (aber weiterhin unterstützt) und in `.model_dump()` umbenannt. +In Pydantic v1 hieß die Methode `.dict()`, in Pydantic v2 wurde sie deprecatet (aber weiterhin unterstützt) und in `.model_dump()` umbenannt. Die Beispiele hier verwenden `.dict()` für die Kompatibilität mit Pydantic v1, aber Sie sollten `.model_dump()` verwenden, wenn Sie Pydantic v2 verwenden können. diff --git a/docs/de/docs/tutorial/path-operation-configuration.md b/docs/de/docs/tutorial/path-operation-configuration.md index 158abe57f..00cb8d722 100644 --- a/docs/de/docs/tutorial/path-operation-configuration.md +++ b/docs/de/docs/tutorial/path-operation-configuration.md @@ -90,11 +90,11 @@ Daher, wenn Sie keine vergeben, wird **FastAPI** automatisch eine für „Erfolg ## Eine *Pfadoperation* deprecaten { #deprecate-a-path-operation } -Wenn Sie eine *Pfadoperation* als deprecated kennzeichnen möchten, ohne sie zu entfernen, fügen Sie den Parameter `deprecated` hinzu: +Wenn Sie eine *Pfadoperation* als deprecatet kennzeichnen möchten, ohne sie zu entfernen, fügen Sie den Parameter `deprecated` hinzu: {* ../../docs_src/path_operation_configuration/tutorial006.py hl[16] *} -Sie wird in der interaktiven Dokumentation gut sichtbar als deprecated markiert werden: +Sie wird in der interaktiven Dokumentation gut sichtbar als deprecatet markiert werden: diff --git a/docs/de/docs/tutorial/query-params-str-validations.md b/docs/de/docs/tutorial/query-params-str-validations.md index 669f63369..09a03666f 100644 --- a/docs/de/docs/tutorial/query-params-str-validations.md +++ b/docs/de/docs/tutorial/query-params-str-validations.md @@ -381,11 +381,11 @@ Dann können Sie ein `alias` deklarieren, und dieser Alias wird verwendet, um de {* ../../docs_src/query_params_str_validations/tutorial009_an_py310.py hl[9] *} -## Parameter als deprecated ausweisen { #deprecating-parameters } +## Parameter als deprecatet ausweisen { #deprecating-parameters } Nehmen wir an, Ihnen gefällt dieser Parameter nicht mehr. -Sie müssen ihn eine Weile dort belassen, da es Clients gibt, die ihn verwenden, aber Sie möchten, dass die Dokumentation ihn klar als deprecated anzeigt. +Sie müssen ihn eine Weile dort belassen, da es Clients gibt, die ihn verwenden, aber Sie möchten, dass die Dokumentation ihn klar als deprecatet anzeigt. Dann übergeben Sie den Parameter `deprecated=True` an `Query`: diff --git a/docs/de/docs/tutorial/response-model.md b/docs/de/docs/tutorial/response-model.md index 591616da4..922b68655 100644 --- a/docs/de/docs/tutorial/response-model.md +++ b/docs/de/docs/tutorial/response-model.md @@ -252,7 +252,7 @@ Wenn Sie also den Artikel mit der ID `foo` bei der *Pfadoperation* anfragen, wir /// info | Info -In Pydantic v1 hieß diese Methode `.dict()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstützt) und in `.model_dump()` umbenannt. +In Pydantic v1 hieß diese Methode `.dict()`, in Pydantic v2 wurde sie deprecatet (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. diff --git a/docs/de/docs/tutorial/schema-extra-example.md b/docs/de/docs/tutorial/schema-extra-example.md index 0b79bde5e..e7a514c4f 100644 --- a/docs/de/docs/tutorial/schema-extra-example.md +++ b/docs/de/docs/tutorial/schema-extra-example.md @@ -50,7 +50,7 @@ Sie könnten das beispielsweise verwenden, um Metadaten für eine Frontend-Benut OpenAPI 3.1.0 (verwendet seit FastAPI 0.99.0) hat Unterstützung für `examples` hinzugefügt, was Teil des **JSON Schema** Standards ist. -Zuvor unterstützte es nur das Schlüsselwort `example` mit einem einzigen Beispiel. Dieses wird weiterhin von OpenAPI 3.1.0 unterstützt, ist jedoch deprecated und nicht Teil des JSON Schema Standards. Wir empfehlen Ihnen daher, von `example` nach `examples` zu migrieren. 🤓 +Zuvor unterstützte es nur das Schlüsselwort `example` mit einem einzigen Beispiel. Dieses wird weiterhin von OpenAPI 3.1.0 unterstützt, ist jedoch deprecatet und nicht Teil des JSON Schema Standards. Wir empfehlen Ihnen daher, von `example` nach `examples` zu migrieren. 🤓 Mehr erfahren Sie am Ende dieser Seite. @@ -189,7 +189,7 @@ Aber dann fügte JSON Schema ein deprecatet ist. Dieses neue `examples`-Feld in JSON Schema ist **nur eine `list`** von Beispielen, kein Dict mit zusätzlichen Metadaten wie an den anderen Stellen in OpenAPI (oben beschrieben). diff --git a/docs/de/docs/tutorial/security/oauth2-jwt.md b/docs/de/docs/tutorial/security/oauth2-jwt.md index f2018a78d..e4047af04 100644 --- a/docs/de/docs/tutorial/security/oauth2-jwt.md +++ b/docs/de/docs/tutorial/security/oauth2-jwt.md @@ -102,7 +102,7 @@ Erstellen Sie einen PassLib-„Kontext“. Der wird für das Hashen und Verifizi /// tip | Tipp -Der PassLib-Kontext kann auch andere Hashing-Algorithmen verwenden, einschließlich deprecateter Alter, um etwa nur eine Verifizierung usw. zu ermöglichen. +Der PassLib-Kontext kann auch andere Hashing-Algorithmen verwenden, einschließlich deprecateter Alter, um etwa nur eine Verifizierung usw. zu ermöglichen. Sie könnten ihn beispielsweise verwenden, um von einem anderen System (wie Django) generierte Passwörter zu lesen und zu verifizieren, aber alle neuen Passwörter mit einem anderen Algorithmus wie Bcrypt zu hashen. diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index 9b04c7102..a59b880f8 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -416,6 +416,7 @@ Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriff * X is case-sensitive: Groß-/Klein­schrei­bung ist relevant in X * X is case-insensitive: Groß-/Klein­schrei­bung ist nicht relevant in X * standard Python: Standard-Python +* deprecated: deprecatet 9) Preserve indentation. Keep emoticons. Encode in utf-8. Use Linux line breaks (LF) From 036295110206e89be8770f8bbdc12074e8358e74 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Wed, 27 Aug 2025 02:43:09 +0200 Subject: [PATCH 149/160] Misc fixes This and the previous six commits are changes which I did while going through the diff of the PR until inclusive tutorial/handling-errors.md --- .../docs/advanced/additional-status-codes.md | 2 +- docs/de/docs/deployment/concepts.md | 2 +- docs/de/docs/deployment/server-workers.md | 2 +- docs/de/docs/help-fastapi.md | 4 ++-- docs/de/docs/how-to/custom-docs-ui-assets.md | 10 +++++----- docs/de/docs/how-to/graphql.md | 2 +- docs/de/docs/python-types.md | 2 +- docs/de/docs/tutorial/extra-models.md | 6 +++--- docs/de/docs/tutorial/handling-errors.md | 18 +++++++++--------- 9 files changed, 24 insertions(+), 24 deletions(-) diff --git a/docs/de/docs/advanced/additional-status-codes.md b/docs/de/docs/advanced/additional-status-codes.md index 8d34c1c8c..4c61e283e 100644 --- a/docs/de/docs/advanced/additional-status-codes.md +++ b/docs/de/docs/advanced/additional-status-codes.md @@ -10,7 +10,7 @@ Wenn Sie neben dem Hauptstatuscode weitere Statuscodes zurückgeben möchten, k Angenommen, Sie möchten eine *Pfadoperation* haben, die das Aktualisieren von Artikeln ermöglicht und bei Erfolg den HTTP-Statuscode 200 „OK“ zurückgibt. -Sie möchten aber auch, dass sie neue Artikel akzeptiert. Und wenn die Elemente vorher nicht vorhanden waren, werden diese Elemente erstellt und der HTTP-Statuscode 201 „Created“ zurückgegeben. +Sie möchten aber auch, dass sie neue Artikel akzeptiert. Und wenn die Artikel vorher nicht vorhanden waren, werden diese Artikel erstellt und der HTTP-Statuscode 201 „Created“ zurückgegeben. Um dies zu erreichen, importieren Sie `JSONResponse`, und geben Sie Ihren Inhalt direkt zurück, indem Sie den gewünschten `status_code` setzen: diff --git a/docs/de/docs/deployment/concepts.md b/docs/de/docs/deployment/concepts.md index a9e7fd7c9..af63b66d4 100644 --- a/docs/de/docs/deployment/concepts.md +++ b/docs/de/docs/deployment/concepts.md @@ -186,7 +186,7 @@ In vielen Fällen möchten Sie jedoch mehrere Workerprozesse gleichzeitig ausfü Wenn Sie mehr Clients haben, als ein einzelner Prozess verarbeiten kann (z. B. wenn die virtuelle Maschine nicht sehr groß ist) und die CPU des Servers **mehrere Kerne** hat, dann könnten **mehrere Prozesse** gleichzeitig mit derselben Anwendung laufen und alle Requests unter sich verteilen. -Wenn Sie mit **mehreren Prozessen** dasselbe API-Programm ausführen, werden diese üblicherweise als **Worker** bezeichnet. +Wenn Sie mit **mehreren Prozessen** dasselbe API-Programm ausführen, werden diese üblicherweise als **Worker** bezeichnet. ### Workerprozesse und Ports { #worker-processes-and-ports } diff --git a/docs/de/docs/deployment/server-workers.md b/docs/de/docs/deployment/server-workers.md index 2654a70af..527068190 100644 --- a/docs/de/docs/deployment/server-workers.md +++ b/docs/de/docs/deployment/server-workers.md @@ -119,7 +119,7 @@ In der Liste der Deployment-Konzepte von oben würde die Verwendung von Workern * **Sicherheit – HTTPS** * **Beim Hochfahren ausführen** -* ***Neustarts*** +* **Neustarts** * Replikation (die Anzahl der laufenden Prozesse) * **Arbeitsspeicher** * **Schritte vor dem Start** diff --git a/docs/de/docs/help-fastapi.md b/docs/de/docs/help-fastapi.md index ab502e7c1..99841d41b 100644 --- a/docs/de/docs/help-fastapi.md +++ b/docs/de/docs/help-fastapi.md @@ -116,7 +116,7 @@ In vielen Fällen wird nur ein Fragment des Codes gepostet, aber das reicht nich ### Um Schließung bitten { #ask-to-close } -Wenn sie antworten, besteht eine hohe Chance, dass Sie ihr Problem gelöst haben. Herzlichen Glückwunsch, **Sie sind ein Held**! 🦸 +Wenn die Person antwortet, besteht eine hohe Chance, dass Sie ihr Problem gelöst haben. Herzlichen Glückwunsch, **Sie sind ein Held**! 🦸 * Wenn es tatsächlich das Problem gelöst hat, können Sie sie darum bitten: @@ -223,7 +223,7 @@ Die Hauptaufgaben, die Sie jetzt erledigen können, sind: Diese beiden Aufgaben sind die Dinge, die **am meisten Zeit verbrauchen**. Das ist die Hauptarbeit bei der Wartung von FastAPI. -Wenn Sie mir dabei helfen können, **helfen Sie mir, FastAPI zu pflegen** und stellen sicher, dass es weiterhin **schneller und besser voranschreitet**. 🚀 +Wenn Sie mir dabei helfen können, **helfen Sie mir, FastAPI zu pflegen** und Sie stellen sicher, dass es weiterhin **schneller und besser voranschreitet**. 🚀 ## Am Chat teilnehmen { #join-the-chat } diff --git a/docs/de/docs/how-to/custom-docs-ui-assets.md b/docs/de/docs/how-to/custom-docs-ui-assets.md index fc3a4d1e8..6b8b1a176 100644 --- a/docs/de/docs/how-to/custom-docs-ui-assets.md +++ b/docs/de/docs/how-to/custom-docs-ui-assets.md @@ -29,8 +29,8 @@ Sie können die internen Funktionen von FastAPI wiederverwenden, um die HTML-Sei * `openapi_url`: die URL, unter welcher die HTML-Seite für die Dokumentation das OpenAPI-Schema für Ihre API abrufen kann. Sie können hier das Attribut `app.openapi_url` verwenden. * `title`: der Titel Ihrer API. * `oauth2_redirect_url`: Sie können hier `app.swagger_ui_oauth2_redirect_url` verwenden, um die Standardeinstellung zu verwenden. -* `swagger_js_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **JavaScript**-Datei abrufen kann. Dies ist die benutzerdefinite CDN-URL. -* `swagger_css_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **CSS**-Datei abrufen kann. Dies ist die benutzerdefinite CDN-URL. +* `swagger_js_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **JavaScript**-Datei abrufen kann. Dies ist die benutzerdefinierte CDN-URL. +* `swagger_css_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **CSS**-Datei abrufen kann. Dies ist die benutzerdefinierte CDN-URL. Und ähnlich für ReDoc ... @@ -54,7 +54,7 @@ Um nun testen zu können, ob alles funktioniert, erstellen Sie eine *Pfadoperati ### Es testen { #test-it } -Jetzt sollten Sie in der Lage sein, zu Ihrer Dokumentation auf http://127.0.0.1:8000/docs zu gehen und die Seite neu zu laden. Die Assets werden nun vom neuen CDN geladen. +Jetzt sollten Sie in der Lage sein, zu Ihrer Dokumentation auf http://127.0.0.1:8000/docs zu gehen und die Seite neu zu laden, die Assets werden nun vom neuen CDN geladen. ## JavaScript und CSS für die Dokumentation selbst hosten { #self-hosting-javascript-and-css-for-docs } @@ -126,7 +126,7 @@ Starten Sie Ihre Anwendung und gehen Sie auf http://127.0.0.1:8000/docs und laden Sie die Seite neu. diff --git a/docs/de/docs/how-to/graphql.md b/docs/de/docs/how-to/graphql.md index 6bd602445..d2958dcd9 100644 --- a/docs/de/docs/how-to/graphql.md +++ b/docs/de/docs/how-to/graphql.md @@ -23,7 +23,7 @@ Hier sind einige der **GraphQL**-Bibliotheken, die **ASGI**-Unterstützung haben * Ariadne * Mit Dokumentation für FastAPI * Tartiflette - * Mit Tartiflette ASGI zur Bereitstellung der ASGI-Integration + * Mit Tartiflette ASGI für ASGI-Integration * Graphene * Mit starlette-graphene3 diff --git a/docs/de/docs/python-types.md b/docs/de/docs/python-types.md index dec4a4cf9..ac0eb4bd7 100644 --- a/docs/de/docs/python-types.md +++ b/docs/de/docs/python-types.md @@ -1,6 +1,6 @@ # Einführung in Python-Typen { #python-types-intro } -Python hat Unterstützung für optionale „Typhinweise“ (auch „Typannotationen“ genannt). +Python hat Unterstützung für optionale „Typhinweise“ (auch „Typannotationen“ genannt). Diese **„Typhinweise“** oder -annotationen sind eine spezielle Syntax, die es erlaubt, den Typ einer Variablen zu deklarieren. diff --git a/docs/de/docs/tutorial/extra-models.md b/docs/de/docs/tutorial/extra-models.md index 160ba1172..15c39fc24 100644 --- a/docs/de/docs/tutorial/extra-models.md +++ b/docs/de/docs/tutorial/extra-models.md @@ -32,7 +32,7 @@ Die Beispiele hier verwenden `.dict()` für die Kompatibilität mit Pydantic v1, ### Über `**user_in.dict()` { #about-user-in-dict } -#### Die `.dict()` Methode von Pydantic { #pydantics-dict } +#### Die `.dict()`-Methode von Pydantic { #pydantics-dict } `user_in` ist ein Pydantic-Modell der Klasse `UserIn`. @@ -158,7 +158,7 @@ Wir könnten es besser machen. Wir können ein `UserBase`-Modell deklarieren, das als Basis für unsere anderen Modelle dient. Und dann können wir Unterklassen dieses Modells erstellen, die seine Attribute (Typdeklarationen, Validierung usw.) erben. -Die ganze Datenkonvertierung, Validierung, Dokumentation usw. wird immer noch wie gewohnt funktionieren. +Die ganze Datenkonvertierung, -validierung, -dokumentation usw. wird immer noch wie gewohnt funktionieren. Auf diese Weise können wir nur die Unterschiede zwischen den Modellen (mit Klartext-`password`, mit `hashed_password` und ohne Passwort) deklarieren: @@ -199,7 +199,7 @@ Aber wenn wir das in der Zuweisung `response_model=PlaneItem | CarItem` machen, Auf die gleiche Weise können Sie Responses von Listen von Objekten deklarieren. -Dafür verwenden Sie das Standard-Python `typing.List` (oder nur `list` in Python 3.9 und höher): +Dafür verwenden Sie Pythons Standard-`typing.List` (oder nur `list` in Python 3.9 und höher): {* ../../docs_src/extra_models/tutorial004_py39.py hl[18] *} diff --git a/docs/de/docs/tutorial/handling-errors.md b/docs/de/docs/tutorial/handling-errors.md index 5ed676118..4fc9ac57a 100644 --- a/docs/de/docs/tutorial/handling-errors.md +++ b/docs/de/docs/tutorial/handling-errors.md @@ -8,7 +8,7 @@ Sie könnten dem Client mitteilen müssen, dass: * Der Client nicht genügend Berechtigungen für diese Operation hat. * Der Client keinen Zugriff auf diese Ressource hat. -* Der Artikel, auf den der Client zugreifen wollte, nicht existiert. +* Die Ressource, auf die der Client versucht hat, zuzugreifen, nicht existiert. * usw. In diesen Fällen würden Sie normalerweise einen **HTTP-Statuscode** im Bereich **400** (von 400 bis 499) zurückgeben. @@ -17,7 +17,7 @@ Dies ist vergleichbar mit den HTTP-Statuscodes im Bereich 200 (von 200 bis 299). Die Statuscodes im Bereich 400 bedeuten hingegen, dass es einen Fehler seitens des Clients gab. -Erinnern Sie sich an all diese **"404 Not Found"** Fehler (und Witze)? +Erinnern Sie sich an all diese **„404 Not Found“** Fehler (und Witze)? ## `HTTPException` verwenden { #use-httpexception } @@ -51,7 +51,7 @@ Wenn der Client `http://example.com/items/foo` anfordert (ein `item_id` `"foo"`) } ``` -Aber wenn der Client `http://example.com/items/bar` anfordert (ein nicht-existierendes `item_id` `"bar"`), erhält er einen HTTP-Statuscode 404 (der „not found“ Error) und eine JSON-Response wie: +Aber wenn der Client `http://example.com/items/bar` anfordert (ein nicht-existierendes `item_id` `"bar"`), erhält er einen HTTP-Statuscode 404 (der „not found“-Error) und eine JSON-Response wie: ```JSON { @@ -71,7 +71,7 @@ Diese werden von **FastAPI** automatisch gehandhabt und in JSON konvertiert. ## Benutzerdefinierte Header hinzufügen { #add-custom-headers } -Es gibt Situationen, in denen es nützlich ist, dem HTTP-Error benutzerdefinierte Header hinzuzufügen. Zum Beispiel für einige Arten der Sicherheit. +Es gibt Situationen, in denen es nützlich ist, dem HTTP-Error benutzerdefinierte Header hinzuzufügen. Zum Beispiel in einigen Sicherheitsszenarien. Sie werden es wahrscheinlich nicht direkt in Ihrem Code verwenden müssen. @@ -83,7 +83,7 @@ Aber falls Sie es für ein fortgeschrittenes Szenario benötigen, können Sie be Sie können benutzerdefinierte Exceptionhandler mit den gleichen Exception-Werkzeugen von Starlette hinzufügen. -Angenommen, Sie haben eine benutzerdefinierte Exception `UnicornException`, die Sie (oder eine Bibliothek, die Sie verwenden) `raise` könnte. +Angenommen, Sie haben eine benutzerdefinierte Exception `UnicornException`, die Sie (oder eine Bibliothek, die Sie verwenden) `raise`n könnten. Und Sie möchten diese Exception global mit FastAPI handhaben. @@ -95,7 +95,7 @@ Hier, wenn Sie `/unicorns/yolo` anfordern, wird die *Pfadoperation* eine `Unicor Aber diese wird von `unicorn_exception_handler` gehandhabt. -Sie erhalten also einen sauberen Fehler mit einem HTTP-Statuscode von `418` und einem JSON-Inhalt von: +Sie erhalten also einen sauberen Fehler mit einem HTTP-Statuscode von `418` und dem JSON-Inhalt: ```JSON {"message": "Oops! yolo did something. There goes a rainbow..."} @@ -113,7 +113,7 @@ Sie könnten auch `from starlette.requests import Request` und `from starlette.r **FastAPI** hat einige Default-Exceptionhandler. -Diese Handler sind dafür verantwortlich, die standardmäßigen JSON-Responses zurückzugeben, wenn Sie eine `HTTPException` `raise`n und wenn die Anfrage ungültige Daten enthält. +Diese Handler sind dafür verantwortlich, die Default-JSON-Responses zurückzugeben, wenn Sie eine `HTTPException` `raise`n und wenn der Request ungültige Daten enthält. Sie können diese Exceptionhandler mit Ihren eigenen überschreiben. @@ -240,7 +240,7 @@ Aber wenn Sie einen Exceptionhandler registrieren, sollten Sie ihn für die `HTT Auf diese Weise, wenn irgendein Teil des internen Codes von Starlette, oder eine Starlette-Erweiterung oder ein Plug-in, eine Starlette `HTTPException` auslöst, wird Ihr Handler in der Lage sein, diese abzufangen und zu handhaben. -Um in diesem Beispiel beide `HTTPException`s im selben Code zu haben, wird die Exception von Starlette als `StarletteHTTPException` umbenannt: +Um in diesem Beispiel beide `HTTPException`s im selben Code zu haben, wird die Exception von Starlette zu `StarletteHTTPException` umbenannt: ```Python from starlette.exceptions import HTTPException as StarletteHTTPException @@ -252,4 +252,4 @@ Wenn Sie die Exception zusammen mit den gleichen Default-Exceptionhandlern von * {* ../../docs_src/handling_errors/tutorial006.py hl[2:5,15,21] *} -In diesem Beispiel drucken Sie nur den Fehler mit einer sehr ausdrucksstarken Nachricht aus, aber Sie verstehen das Prinzip. Sie können die Exception verwenden und dann einfach die Default-Exceptionhandler wiederverwenden. +In diesem Beispiel geben Sie nur den Fehler mit einer sehr ausdrucksstarken Nachricht aus, aber Sie verstehen das Prinzip. Sie können die Exception verwenden und dann einfach die Default-Exceptionhandler wiederverwenden. From 018f8523ffd381c8cf103f82f9a242413bb947ac Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Fri, 29 Aug 2025 01:03:03 +0200 Subject: [PATCH 150/160] Update prompts --- docs/de/llm-prompt.md | 609 +++++++++++++++++--------------------- scripts/translate.py | 663 +++++++++++++++++++++++++++++++----------- 2 files changed, 755 insertions(+), 517 deletions(-) diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index a59b880f8..adae5d8ff 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -1,422 +1,345 @@ -1) Translate to German (Deutsch). +### Target language -Language code: de. - - -2) Use the formal grammar (use `Sie` instead of `Du`). - - -3) Convert quotation marks (") to typographic quotation marks („“). - -Example: - -Source (English): - -"Hello world" - -Result (German): - -„Hallo Welt“ - -3.1) Inside inline code (= surrounded by backticks), leave quotation marks (") as is, as they usually mark string literals and typographic quotation marks („“) can not be used for that. - -Example: - -Source (English) – contains four inline codes, three of them contain a string literal: - -Inline code: `i am inline code` -Inline code containing a string literal: `i am inline code "I am a string literal"` -Inline code containing only a short string literal: `"foo"` -`"__main__"` - -Result (German) – as all the quotation marks (") are inside inline code, you keep them as is, as you always should with content inside inline code: - -Inline-Code: `i am inline code` -Inline-Code der ein Stringliteral enthält: `i am inline code "I am a string literal"` -Inline-Code der nur ein kurzes Stringliteral enthält: `"foo"` -`"__main__"` - - -4) make sure there is a space between an ellipsis and a word following or preceding it. - -Examples: - -Source (English): - -...as we intended. -...this would work: -...etc. -others... -More to come... - -Result (German): - -... wie wir es beabsichtigt hatten. -... das würde funktionieren: -... usw. -Andere ... -Später mehr ... - -4.1) Rule 4 does not apply in URLs, code blocks, inline code. Do not change the spaces there. - - -5) Translate HTML abbr elements as follows: - -5.1) If the title attribute gives the full phrase for an abbreviation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase. - -Examples: - -Source (English): - -IoT -CPU -TL;DR: - -Result (German): - -IoT -CPU -TL;DR: - -Conversion scheme title attribute: +Translate to German (Deutsch). -Source (English): - -{full phrase} - -Result (German): - -{full phrase} – {translation of full phrase} - -5.1.1) If the phrase can not be translated, or it is the same in the translation, then keep the title attribute as is. - -Examples: - -Source (English): - -JWT -`Enum` - -Result (German): - -JWT -`Enum` - -Conversion scheme title attribute: - -Source (English): - -{full phrase} - -Result (German): - -{full phrase} - -5.1.2) If the phrase can be translated and that translation has the same starting letters, then just use the translation. - -Examples: +Language code: de. -Source (English): -ASGI +### Definitions -Result (German): +hyphen + The character «-» + Unicode U+002D (HYPHEN-MINUS) + Alternative names: hyphen, dash, minus sign -ASGI +dash + The character «–» + Unicode U+2013 (EN DASH) + German name: Halbgeviertstrich -Conversion scheme title attribute: -Source (English): +### Grammar to use when talking to the reader -{full phrase} +Use the formal grammar (use «Sie» instead of «Du»). -Result (German): -{translation of full phrase} +### Quotes -5.2) If the title attribute explains something in its own words, then translate it, if possible. +1) Convert neutral double quotes («"» and «"») and English double typographic quotes («“» and «”») to German double typographic quotes («„» and «“»). Convert neutral single quotes («'» and «'») and English single typographic quotes («‘» and «’») to German single typographic quotes («‚» and «‘»). Examples: -Source (English): + Source (English): -path -linter -"parsing" -0.95.0 -at the time of writing this + ««« + "Hello world" + “Hello Universe” + "He said: 'Hello'" + “my name is ‘Nils’” + »»» -Result (German): + Result (German): -Pfad -Linter -„Parsen“ -0.95.0 -zum Zeitpunkt als das hier geschrieben wurde + ««« + „Hallo Welt“ + „Hallo Universum“ + „Er sagte: ‚Hallo‘“ + „Mein Name ist ‚Nils‘“ + »»» -Conversion scheme title attribute: +2) Inside code snippets and code blocks, leave neutral double quotes («"») and neutral single quotes («'») AS IS. Do NOT convert them to typographic quotes. -Source (English): - -{explanation} - -Result (German): - -{translation of explanation} - -5.2.1) If the term, which the HTML abbr element wraps, stays English in the translation, but it also has a translation, whose knowledge improves the explanation, then let the title attribute be that translation, followed by a colon (`:`), followed by the translation of the title attribute. - -Examples: - -Source (English): - -Dependency Injection - -Result (German): - -Dependency Injection +Example: -Conversion scheme title attribute: + Source (English) – contains four code snippets, three of them contain a string literal: -Source (English): + ««« + Inline code: `i am inline code` + Inline code containing a string literal: `i am inline code "I am a string literal"` + Inline code containing only a short string literal: `"foo"` + `"__main__"` + `"fastapi[standard]"` + »»» -{explanation} + Result (German) – as all the quotes («"») are inside code snippets («`...`»), you keep them as is (as you always should do with content inside code snippets): -Result (German): + ««« + Inline-Code: `i am inline code` + Inline-Code der ein Stringliteral enthält: `i am inline code "I am a string literal"` + Inline-Code der nur ein kurzes Stringliteral enthält: `"foo"` + `"__main__"` + `"fastapi[standard]"` + »»» -{translation of term which abbr wraps}: {translation of explanation} +### Ellipsis -5.3) If the title attribute gives the full phrase for an abbreviation, followed by a colon (`:`) or a comma (`,`), followed by an explanation, then keep the phrase, append a long dash (`–`), followed by the translation of the phrase, followed by a colon (`:`), followed by the translation of the explanation. +1) Make sure there is a space between an ellipsis and a word following or preceding the ellipsis. Examples: -Source (English): - -I/O -CDN -IDE -"ORMs" - -Result (German): - -I/O -CDN -IDE -„ORMs“ - -Conversion scheme title attribute: - -Source (English): - -{full phrase}: {explanation} - -OR + Source (English): -Source (English): + ««« + ...as we intended. + ...this would work: + ...etc. + others... + More to come... + »»» -{full phrase}, {explanation} + Result (German): -Result (German): + ««« + ... wie wir es beabsichtigt hatten. + ... das würde funktionieren: + ... usw. + Andere ... + Später mehr ... + »»» -{full phrase} – {translation of full phrase}: {translation of explanation} +2) This does not apply in URLs, code blocks, and code snippets. Do not remove or add spaces there. -5.4) If there is an HTML abbr element in a sentence in an existing translation, but that element does not exist in the related sentence in the English text, then keep that HTML abbr element in the translation, do not change or remove it. Except when you remove the whole sentence from the translation, because the whole sentence was removed from the English text. The reasoning for this rule is, that such abbr elements are manually added by the human editor of the translation, in order to translate or explain an English word to the human readers of the translation. They would not make sense in the English text, but they do make sense in the translation. So keep them in the translation, even though they are not part of the English text. This rule only applies to HTML abbr elements. +### Headings -6) Translate headings using the infinite form. +1) Translate headings using the infinite form. Examples: -Source (English): + Source (English): -## Create a Project { #create-a-project } + ««« + ## Create a Project { #create-a-project } + »»» -Translate with (German): + Translate with (German): -## Ein Projekt erstellen { #create-a-project } + ««« + ## Ein Projekt erstellen { #create-a-project } + »»» -Do NOT translate with (German): + Do NOT translate with (German): -## Erstellen Sie ein Projekt { #create-a-project } + ««« + ## Erstellen Sie ein Projekt { #create-a-project } + »»» -Source (English): + Source (English): -# Install Packages { #install-packages } + ««« + # Install Packages { #install-packages } + »»» -Translate with (German): + Translate with (German): -# Pakete installieren { #install-packages } + ««« + # Pakete installieren { #install-packages } + »»» -Do NOT translate with (German): + Do NOT translate with (German): -# Installieren Sie Pakete { #install-packages } + ««« + # Installieren Sie Pakete { #install-packages } + »»» -Source (English): + Source (English): -### Run Your Program { #run-your-program } + ««« + ### Run Your Program { #run-your-program } + »»» -Translate with (German): + Translate with (German): -### Ihr Programm ausführen { #run-your-program } + ««« + ### Ihr Programm ausführen { #run-your-program } + »»» -Do NOT translate with (German): + Do NOT translate with (German): -### Führen Sie Ihr Programm aus { #run-your-program } + ««« + ### Führen Sie Ihr Programm aus { #run-your-program } + »»» -6.1) Make sure that the translated part of the heading does not end with a period. +2) Make sure that the translated part of the heading does not end with a period. Example: -Source (English): + Source (English): -## Another module with `APIRouter` { #another-module-with-apirouter } + ««« + ## Another module with `APIRouter` { #another-module-with-apirouter } + »»» -Translate with (German): + Translate with (German): -## Ein weiteres Modul mit `APIRouter` { #another-module-with-apirouter } + ««« + ## Ein weiteres Modul mit `APIRouter` { #another-module-with-apirouter } + »»» -Do NOT translate with (German) – notice the added period: + Do NOT translate with (German) – notice the added period: -## Ein weiteres Modul mit `APIRouter`. { #another-module-with-apirouter } + ««« + ## Ein weiteres Modul mit `APIRouter`. { #another-module-with-apirouter } + »»» -6.2) Replace occurrences of literal ` - ` (a space followed by a dash followed by a space) with ` – ` (a space followed by a long dash followed by a space) in the translated part of the heading. +3) Replace occurrences of literal « - » (a space followed by a hyphen followed by a space) with « – » (a space followed by a dash followed by a space) in the translated part of the heading. Example: -Source (English): + Source (English): -# FastAPI in Containers - Docker { #fastapi-in-containers-docker } + ««« + # FastAPI in Containers - Docker { #fastapi-in-containers-docker } + »»» -Translate with (German) – notice the long dash: + Translate with (German) – notice the dash: -# FastAPI in Containern – Docker { #fastapi-in-containers-docker } + ««« + # FastAPI in Containern – Docker { #fastapi-in-containers-docker } + »»» -Do NOT translate with (German): + Do NOT translate with (German) – notice the hyphen: -# FastAPI in Containern - Docker { #fastapi-in-containers-docker } + ««« + # FastAPI in Containern - Docker { #fastapi-in-containers-docker } + »»» -6.2.1) Do not apply rule 6.2 when there is no space before or after the dash. +3.1) Do not apply rule 3 when there is no space before or no space after the dash. Example: -Source (English): - -## Type hints and annotations { #type-hints-and-annotations } - -Translate with (German) – use a short dash: - -## Typhinweise und -annotationen { #type-hints-and-annotations } - -Do NOT translate with (German): - -## Typhinweise und –annotationen { #type-hints-and-annotations } - -Rule 6.2 does not apply to the untranslated part of the heading inside curly brackets, which you shall not translate. - - -7) Follow these German instructions: - -In der Regel versuche ich so weit wie möglich Worte zusammenzuschreiben, also ohne Bindestrich, es sei denn, es ist Konkretesding-Klassevondingen, etwa `Pydantic-Modell` (aber: `Datenbankmodell`), `Python-Modul` (aber: `Standardmodul`). Ich setze auch einen Bindestrich, wenn er die gleichen Buchstaben verbindet, etwa `Enum-Member`, `Cloud-Dienst`, `Template-Engine`. Oder wenn das Wort sonst einfach zu lang wird, etwa, `Performance-Optimierung`. Oder um etwas visuell besser zu dokumentieren, etwa `Pfadoperation-Dekorator`, `Pfadoperation-Funktion`. - -Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriffe aus dem Bereich der Programmierung. Ich wandele zwar korrekt in Großschreibung um und setze Bindestriche, wo notwendig, aber ansonsten lasse ich solch ein Wort unverändert. Beispielsweise wird aus dem englischen Wort `string` in der deutschen Übersetzung `String`, aber nicht `Zeichenkette`. Oder aus dem englischen Wort `request body` wird in der deutschen Übersetzung `Requestbody`, aber nicht `Anfragekörper`. Oder aus dem englischen `response` wird im Deutschen `Response`, aber nicht `Antwort`. - - -8) Below is a list of English terms and their German translations, separated by a colon (`:`). Use these translations, do not use your own. Words inside brackets are explanations for you, they are not part of the term or the translation. If a list item starts with `NOT`, then that means: do NOT use this translation. Nouns, starting with the word `the`, have their German genus – `der`, `die`, `das` – included, to help you to grammatically decline them in the translation, and they are given in singular case unless they have `(plural case)` attached, which means they are given in plural case. Verbs are given in the full infinitive – starting with the word `to`. - -* /// check: /// check | Testen -* /// danger: /// danger | Gefahr -* /// info: /// info | Info -* /// note | Technical Details: /// note | Technische Details -* /// note: /// note | Hinweis -* /// tip: /// tip | Tipp -* /// warning: /// warning | Achtung -* you: Sie -* your: Ihr -* e.g: z. B. -* etc.: usw. -* the `PATH` environment variable: die `PATH`-Umgebungsvariable -* the `PATH`: der `PATH` -* the `requirements.txt`: die `requirements.txt` -* the API Router: der API-Router -* the app: die App -* the application: die Anwendung -* the Advanced User Guide: das Handbuch für fortgeschrittene Benutzer -* the Authorization-Header: der Autorisierungsheader -* the `Authorization`-Header: der `Authorization`-Header -* the background task: der Hintergrundtask -* the cloud provider: der Cloudanbieter -* the CLI: Das CLI -* the command line interface: Das Kommandozeileninterface -* the docs: die Dokumentation (use singular case) -* the default value: der Defaultwert -* NOT the default value: der Standardwert -* the default declaration: die Default-Deklaration -* the engine: die Engine -* the env var: die Umgebungsvariable -* the error response: die Error-Response -* the event: das Event -* the exception: die Exception -* the exception handler: der Exceptionhandler -* the form model: das Formularmodell -* the form body: der Formularbody -* the header: der Header -* the headers (plural case): die Header -* in headers (plural case): in Headern -* the lifespan event: das Lifespan-Event -* the locking: das Locking -* the mobile application: die Mobile-Anwendung -* the model object: das Modellobjekt -* the mounting: das Mounten -* mounted: gemountet -* the origin: das Origin -* the override: Die Überschreibung -* the parameter: der Parameter -* the parameters (plural case): die Parameter -* the function parameter: der Funktionsparameter -* the default parameter: der Defaultparameter -* the body parameter: der Body-Parameter -* the request body parameter: der Requestbody-Parameter -* the path parameter: der Pfad-Parameter -* the query parameter: der Query-Parameter -* the cookie parameter: der Cookie-Parameter -* the header parameter: der Header-Parameter -* the form parameter: der Formular-Parameter -* the payload: die Payload -* the query: die Query -* the recap: die Zusammenfassung -* the request: der Request -* the requestbody: der Requestbody -* the requestbodies (plural case): die Requestbodys -* the response: die Response -* the return type: der Rückgabetyp -* the return value: der Rückgabewert -* the SQLModel docs: die SQLModel-Dokumentation -* the SDK: das SDK -* the tag: der Tag -* the Tutorial - User guide: das Tutorial – Benutzerhandbuch -* the type annotation: die Typannotation -* the type hint: der Typhinweis -* the wildcard: die Wildcard -* the worker class: die Workerklasse -* NOT the worker class: die Arbeiterklasse -* the worker process: der Workerprozess -* NOT the worker process: der Arbeiterprozess -* to commit: committen -* to modify: ändern -* to serve (an application): bereitstellen -* to serve (a response): ausliefern -* NOT to serve: bedienen -* to upgrade: aktualisieren -* to wrap: wrappen -* `foo` as a `type`: `foo` vom Typ `type` -* `foo` as a `type`: `foo`, ein `type` -* FastAPI's X: FastAPIs X -* Starlette's Y: Starlettes Y -* X is case-sensitive: Groß-/Klein­schrei­bung ist relevant in X -* X is case-insensitive: Groß-/Klein­schrei­bung ist nicht relevant in X -* standard Python: Standard-Python -* deprecated: deprecatet - - -9) Preserve indentation. Keep emoticons. Encode in utf-8. Use Linux line breaks (LF) + Source (English): + + ««« + ## Type hints and annotations { #type-hints-and-annotations } + »»» + + Translate with (German) – use a short dash: + + ««« + ## Typhinweise und -annotationen { #type-hints-and-annotations } + »»» + + Do NOT translate with (German): + + ««« + ## Typhinweise und –annotationen { #type-hints-and-annotations } + »»» + +3.2) Do not apply rule 3 to the untranslated part of the heading inside curly brackets, which you shall not translate. + + +### German instructions, when to use and when not to use hyphens in words (written in first person, which is you) + +In der Regel versuche ich so weit wie möglich Worte zusammenzuschreiben, also ohne Bindestrich, es sei denn, es ist Konkretesding-Klassevondingen, etwa «Pydantic-Modell» (aber: «Datenbankmodell»), «Python-Modul» (aber: «Standardmodul»). Ich setze auch einen Bindestrich, wenn er die gleichen Buchstaben verbindet, etwa «Enum-Member», «Cloud-Dienst», «Template-Engine». Oder wenn das Wort sonst einfach zu lang wird, etwa, «Performance-Optimierung». Oder um etwas visuell besser zu dokumentieren, etwa «Pfadoperation-Dekorator», «Pfadoperation-Funktion». + + +### German instructions about difficult to translate technical terms (written in first person, which is you) + +Ich versuche nicht, alles einzudeutschen. Das bezieht sich besonders auf Begriffe aus dem Bereich der Programmierung. Ich wandele zwar korrekt in Großschreibung um und setze Bindestriche, wo notwendig, aber ansonsten lasse ich solch ein Wort unverändert. Beispielsweise wird aus dem englischen Wort «string» in der deutschen Übersetzung «String», aber nicht «Zeichenkette». Oder aus dem englischen Wort «request body» wird in der deutschen Übersetzung «Requestbody», aber nicht «Anfragekörper». Oder aus dem englischen «response» wird im Deutschen «Response», aber nicht «Antwort». + + +### List of English terms and their preferred German translations + +Below is a list of English terms and their preferred German translations, separated by a colon («:»). Use these translations, do not use your own. If an existing translation does not use these terms, update it to use them. A term or a translation may be followed by an explanation in brackets, which explains when to translate the term this way. If a translation is preceded by «NOT», then that means: do NOT use this translation for this term. English nouns, starting with the word «the», have the German genus – «der», «die», «das» – prepended to their German translation, to help you to grammatically decline the translation. They are given in singular case, unless they have «(plural)» attached, which means they are given in plural case. Verbs are given in the full infinitive – starting with the word «to». + +* «/// check»: «/// check | Testen» +* «/// danger»: «/// danger | Gefahr» +* «/// info»: «/// info | Info» +* «/// note | Technical Details»: «/// note | Technische Details» +* «/// note»: «/// note | Hinweis» +* «/// tip»: «/// tip | Tipp» +* «/// warning»: «/// warning | Achtung» +* «you»: «Sie» +* «your»: «Ihr» +* «e.g»: «z. B.» +* «etc.»: «usw.» +* «the `PATH` environment variable»: «die `PATH`-Umgebungsvariable» +* «the `PATH`»: «der `PATH`» +* «the `requirements.txt`»: «die `requirements.txt`» +* «the API Router»: «der API-Router» +* «the app»: «die App» +* «the application»: «die Anwendung» +* «the Advanced User Guide»: «das Handbuch für fortgeschrittene Benutzer» +* «the Authorization-Header»: «der Autorisierungsheader» +* «the `Authorization`-Header»: «der `Authorization`-Header» +* «the background task»: «der Hintergrundtask» +* «the cloud provider»: «der Cloudanbieter» +* «the CLI»: «Das CLI» +* «the command line interface»: «Das Kommandozeileninterface» +* «the docs»: «die Dokumentation» (use singular case) +* «the default value»: «der Defaultwert» +* «the default value»: NOT «der Standardwert» +* «the default declaration»: «die Default-Deklaration» +* «the engine»: «die Engine» +* «the env var»: «die Umgebungsvariable» +* «the error response»: «die Error-Response» +* «the event»: «das Event» +* «the exception»: «die Exception» +* «the exception handler»: «der Exceptionhandler» +* «the form model»: «das Formularmodell» +* «the form body»: «der Formularbody» +* «the header»: «der Header» +* «the headers» (plural): «die Header» +* «in headers» (plural): «in Headern» +* «the lifespan event»: «das Lifespan-Event» +* «the lock»: «der Lock» +* «the locking»: «das Locking» +* «the mobile application»: «die Mobile-Anwendung» +* «the model object»: «das Modellobjekt» +* «the mounting»: «das Mounten» +* «mounted»: «gemountet» +* «the origin»: «das Origin» +* «the override»: «Die Überschreibung» +* «the parameter»: «der Parameter» +* «the parameters» (plural): «die Parameter» +* «the function parameter»: «der Funktionsparameter» +* «the default parameter»: «der Defaultparameter» +* «the body parameter»: «der Body-Parameter» +* «the request body parameter»: «der Requestbody-Parameter» +* «the path parameter»: «der Pfad-Parameter» +* «the query parameter»: «der Query-Parameter» +* «the cookie parameter»: «der Cookie-Parameter» +* «the header parameter»: «der Header-Parameter» +* «the form parameter»: «der Formular-Parameter» +* «the payload»: «die Payload» +* «the query»: «die Query» +* «the recap»: «die Zusammenfassung» +* «the request»: «der Request» +* «the request body»: «der Requestbody» +* «the request bodies» (plural): «die Requestbodys» +* «the response»: «die Response» +* «the return type»: «der Rückgabetyp» +* «the return value»: «der Rückgabewert» +* «the SQLModel docs»: «die SQLModel-Dokumentation» +* «the SDK»: «das SDK» +* «the tag»: «der Tag» +* «the Tutorial - User guide»: «das Tutorial – Benutzerhandbuch» +* «the type annotation»: «die Typannotation» +* «the type hint»: «der Typhinweis» +* «the wildcard»: «die Wildcard» +* «the worker class»: «die Workerklasse» +* «the worker class»: NOT «die Arbeiterklasse» +* «the worker process»: «der Workerprozess» +* «the worker process»: NOT «der Arbeiterprozess» +* «to commit»: «committen» +* «to modify»: «ändern» +* «to serve» (an application): «bereitstellen» +* «to serve» (a response): «ausliefern» +* «to serve»: NOT «bedienen» +* «to upgrade»: «aktualisieren» +* «to wrap»: «wrappen» +* «`foo` as a `type`»: «`foo` vom Typ `type`» +* «`foo` as a `type`»: «`foo`, ein `type`» +* «FastAPI's X»: «FastAPIs X» +* «Starlette's Y»: «Starlettes Y» +* «X is case-sensitive»: «Groß-/Klein­schrei­bung ist relevant in X» +* «X is case-insensitive»: «Groß-/Klein­schrei­bung ist nicht relevant in X» +* «standard Python»: «Standard-Python» +* «deprecated»: «deprecatet» + + +### Other rules + +Preserve indentation. Keep emoticons. Encode in utf-8. Use Linux line breaks (LF) diff --git a/scripts/translate.py b/scripts/translate.py index 398e5aecb..901ce2a45 100644 --- a/scripts/translate.py +++ b/scripts/translate.py @@ -24,303 +24,618 @@ non_translated_sections = ( "contributing.md", ) - general_prompt = """ -For technical terms in English that don't have a common translation term, use the original term in English. +### About literal text in this prompt -For code snippets or fragments, surrounded by backticks (`), don't translate the content, keep the original in English. For example, `list`, `dict`, keep them as is. +1) In the following instructions (after I say: `The above rules are in effect now`) the two characters `«` and `»` will be used to surround text and characters which you shall interpret literally. The `«` and the `»` are not part of the literal text (they are the meta characters denoting it). -The content is written in Markdown, write the translation in Markdown as well. +2) Furthermore, text surrounded by `«««` and `»»»` is a block of literal text which spans multiple lines. To get its content, dedent all lines of the block until the `«««` and `»»»` are at column zero, then remove the newline after the `«««` and the newline before the `»»»`. The `«««` and the `»»»` are not part of the literal text block (they are the meta characters denoting it). +3) The above two syntaxes – `«...»` and `«««...»»»` – are used to denote literal text. Other forms of quotation marks – especially backticks and triple backticks – do NOT denote literal text. -When there is a code block, surrounded by triple backticks, do not translate its content, except for comments in the language which the code block uses. +The above rules are relevant, because we will give code examples for Markdown. Markdown uses backticks to denote inline code and code blocks. So, if you see text surrounded by backticks, then do not interpret it as literal text and throw away the backticks, but interpret it as a Markdown code block or a Markdown code snippet, and keep the backticks. -Examples: +The above rules are in effect now. -Source (English) – The code block is a bash code example with one comment: - -```bash -# Print greeting -echo "Hello, World!" -``` - -Result (German): - -```bash -# Gruß ausgeben -echo "Hello, World!" -``` - -Source (English) – The code block is a console example containing HTML tags. No comments, nothing to change here: - -```console -$ fastapi run main.py - FastAPI Starting server - Searching for package file structure -``` - -Result (German): - -```console -$ fastapi run main.py - FastAPI Starting server - Searching for package file structure -``` - -Source (English) – The code block is a console example containing 5 comments: - -```console -// Go to the home directory -$ cd -// Create a directory for all your code projects -$ mkdir code -// Enter into that code directory -$ cd code -// Create a directory for this project -$ mkdir awesome-project -// Enter into that project directory -$ cd awesome-project -``` - -Result (German): - -```console -// Gehe zum Home-Verzeichnis -$ cd -// Erstelle ein Verzeichnis für alle Ihre Code-Projekte -$ mkdir code -// Gehe in dieses Code-Verzeichnis -$ cd code -// Erstelle ein Verzeichnis für dieses Projekt -$ mkdir awesome-project -// Gehe in dieses Projektverzeichnis -$ cd awesome-project -``` -If there is an existing translation and its Mermaid diagram is in sync with the Mermaid diagram in the English source, except a few translated words, then use the Mermaid diagram of the existing translation. The human editor of the translation translated these words in the Mermaid diagram. Keep these translations, do not revert them back to the English source. +### Definitions of terms used in this prompt -Example: +Backtick + The character «`» + Unicode U+0060 (GRAVE ACCENT) + +Single backtick + A single backtick – «`» + +triple backticks + Three backticks in a row – «```» + +Neutral double quote + The character «"» + Unicode U+0022 (QUOTATION MARK) + +Neutral single quote + The character «'» + Unicode U+0027 (APOSTROPHE) + +English double typographic quotes + The characters «“» and «”» + Unicode U+201C (LEFT DOUBLE QUOTATION MARK) and Unicode U+201D (RIGHT DOUBLE QUOTATION MARK) + +English single typographic quotes + The characters «‘» and «’» + Unicode U+2018 (LEFT SINGLE QUOTATION MARK) and Unicode U+2019 (RIGHT SINGLE QUOTATION MARK) + +Code snippet + Text in a Markdown document which is surrounded by single backticks. + + Examples: + + «`foo`» + «`lorem ipsum`» + +Code block + Text in a Markdown document which is surrounded by triple backticks. Spreads multiple lines. + + Example: + + ««« + ``` + Hello + World + ``` + »»» + + Example: + + ««« + ```python + print("hello World") + ``` + »»» + + +### Your task + +Translate an English text – the original content – to a target language. + +The original content is written in Markdown, write the translation in Markdown as well. + +The original content will be surrounded by triple percentage signs («%%%»). Do not include the triple percentage signs in the translation. -Source (English): -```mermaid -flowchart LR - subgraph global[global env] - harry-1[harry v1] - end - subgraph stone-project[philosophers-stone project] - stone(philosophers-stone) -->|requires| harry-1 - end -``` +### Technical terms in English -Existing translation (German) – has three translations: +For technical terms in English that don't have a common translation term, use the original term in English. + + +### Content of code snippets + +Do not translate the content of code snippets, keep the original in English. For example, «`list`», «`dict`», keep them as is. + + +### Content of code blocks -```mermaid -flowchart LR - subgraph global[globale Umgebung] - harry-1[harry v1] - end - subgraph stone-project[philosophers-stone-Projekt] - stone(philosophers-stone) -->|benötigt| harry-1 - end -``` +Do not translate the content of code blocks, except for comments in the language which the code block uses. -Result (German) – you change nothing: +Examples: -```mermaid -flowchart LR - subgraph global[globale Umgebung] - harry-1[harry v1] - end - subgraph stone-project[philosophers-stone-Projekt] - stone(philosophers-stone) -->|benötigt| harry-1 - end -``` + Source (English) – The code block is a bash code example with one comment: + + ««« + ```bash + # Print greeting + echo "Hello, World!" + ``` + »»» + + Result (German): + + ««« + ```bash + # Gruß ausgeben + echo "Hello, World!" + ``` + »»» + + Source (English) – The code block is a console example containing HTML tags. No comments, so nothing to change here: + + ««« + ```console + $ fastapi run main.py + FastAPI Starting server + Searching for package file structure + ``` + »»» + + Result (German): + + ««« + ```console + $ fastapi run main.py + FastAPI Starting server + Searching for package file structure + ``` + »»» + + Source (English) – The code block is a console example containing 5 comments: + + ««« + ```console + // Go to the home directory + $ cd + // Create a directory for all your code projects + $ mkdir code + // Enter into that code directory + $ cd code + // Create a directory for this project + $ mkdir awesome-project + // Enter into that project directory + $ cd awesome-project + ``` + »»» + + Result (German): + + ««« + ```console + // Gehe zum Home-Verzeichnis + $ cd + // Erstelle ein Verzeichnis für alle Ihre Code-Projekte + $ mkdir code + // Gehe in dieses Code-Verzeichnis + $ cd code + // Erstelle ein Verzeichnis für dieses Projekt + $ mkdir awesome-project + // Gehe in dieses Projektverzeichnis + $ cd awesome-project + ``` + »»» +If there is an existing translation and its Mermaid diagram is in sync with the Mermaid diagram in the English source, except a few translated words, then use the Mermaid diagram of the existing translation. The human editor of the translation translated these words in the Mermaid diagram. Keep these translations, do not revert them back to the English source. -The original content will be surrounded by triple percentage signs (%) and you should translate it to the target language. Do not include the triple percentage signs in the translation. +Example: + Source (English): + + ««« + ```mermaid + flowchart LR + subgraph global[global env] + harry-1[harry v1] + end + subgraph stone-project[philosophers-stone project] + stone(philosophers-stone) -->|requires| harry-1 + end + ``` + »»» + + Existing translation (German) – has three translations: + + ««« + ```mermaid + flowchart LR + subgraph global[globale Umgebung] + harry-1[harry v1] + end + subgraph stone-project[philosophers-stone-Projekt] + stone(philosophers-stone) -->|benötigt| harry-1 + end + ``` + »»» + + Result (German) – you change nothing: + + ««« + ```mermaid + flowchart LR + subgraph global[globale Umgebung] + harry-1[harry v1] + end + subgraph stone-project[philosophers-stone-Projekt] + stone(philosophers-stone) -->|benötigt| harry-1 + end + ``` + »»» + + +### Special blocks There are special blocks of notes, tips and others that look like: -/// note + ««« + /// note + »»» To translate it, keep the same line and add the translation after a vertical bar. For example, if you were translating to Spanish, you would write: -/// note | Nota + ««« + /// note | Nota + »»» Some examples in Spanish: -Source: + Source: -/// tip + ««« + /// tip + »»» -Result: + Result: -/// tip | Consejo + ««« + /// tip | Consejo + »»» -Source: + Source: -/// details | Preview + ««« + /// details | Preview + »»» -Result: + Result: -/// details | Vista previa + ««« + /// details | Vista previa + »»» -There are special blocks surrounded by four slashes (`////`). They mark text, which will be rendered as part of a tab in the final document. The scheme is: +### Tab blocks -//// tab | {tab title} -{tab content, may span many lines} -//// +There are special blocks surrounded by four slashes («////»). They mark text, which will be rendered as part of a tab in the final document. The scheme is: -Keep everything before the vertical bar (`|`) as is, including the vertical bar. Translate the tab title. Translate the tab content, applying the rules you know. Keep the four block closing slashes as is. + ««« + //// tab | {tab title} + {tab content, may span many lines} + //// + »»» + +Keep everything before the vertical bar («|») as is, including the vertical bar. Translate the tab title. Translate the tab content, applying the rules you know. Keep the four block closing slashes as is. Examples: -Source (English): + Source (English): + + ««« + //// tab | Python 3.8+ non-Annotated + Hello + //// + »»» -//// tab | Python 3.8+ non-Annotated -Hello -//// + Result (German): -Result (German): + ««« + //// tab | Python 3.8+ nicht annotiert + Hallo + //// + »»» -//// tab | Python 3.8+ nicht annotiert -Hallo -//// + Source (English) – Here there is nothing to translate in the tab title: -Source (English) – Here there is nothing to translate in the tab title: + ««« + //// tab | Linux, macOS, Windows Bash + Hello again + //// + »»» -//// tab | Linux, macOS, Windows Bash -Hello again -//// + Result (German): -Result (German): + ««« + //// tab | Linux, macOS, Windows Bash + Hallo wieder + //// + »»» -//// tab | Linux, macOS, Windows Bash -Hallo wieder -//// +### Headings Every Markdown heading in the English text (all levels) ends with a part inside curly brackets. This part denotes the hash of this heading, which is used in links to this heading. In translations, translate the heading, but do not translate this hash part, so that links do not break. Examples of how to translate a heading: -Source (English): + Source (English): + + ««« + ## Alternative API docs { #alternative-api-docs } + »»» -## Alternative API docs { #alternative-api-docs } + Result (Spanish): -Result (Spanish): + ««« + ## Documentación de la API alternativa { #alternative-api-docs } + »»» -## Documentación de la API alternativa { #alternative-api-docs } + Source (English): -Source (English): + ««« + ### Example { #example } + »»» -### Example { #example } + Result (German): -Result (German): + ««« + ### Beispiel { #example } + »»» -### Beispiel { #example } +### Links -Use the following rules for links (apply both to Markdown-style links ([text](url)) and to HTML-style tags): +Use the following rules for links (apply both to Markdown-style links («[text](url)») and to HTML-style «» tags): -1) For relative URLs only translate link text. Do not translate the URL or its parts +1) For relative URLs, only translate link text. Do not translate the URL or its parts Example: -Source (English): + Source (English): -[One of the fastest Python frameworks available](#performance) + ««« + [One of the fastest Python frameworks available](#performance) + »»» -Result (German): + Result (German): -[Eines der schnellsten verfügbaren Python-Frameworks](#performance) + ««« + [Eines der schnellsten verfügbaren Python-Frameworks](#performance) + »»» -2) For absolute URLs which DO NOT start EXACTLY with "https://fastapi.tiangolo.com", only translate link text and leave the URL unchanged. +2) For absolute URLs which DO NOT start EXACTLY with «https://fastapi.tiangolo.com», only translate link text and leave the URL unchanged. Example: -Source (English): + Source (English): -SQLModel docs + ««« + SQLModel docs + »»» -Result (German): + Result (German): -SQLModel-Dokumentation + ««« + SQLModel-Dokumentation + »»» -3) For absolute URLs which DO start EXACTLY with "https://fastapi.tiangolo.com", only translate link text and change the URL by adding language code (https://fastapi.tiangolo.com/{language_code}[rest part of the url]). +3) For absolute URLs which DO start EXACTLY with «https://fastapi.tiangolo.com», only translate link text and change the URL by adding language code («https://fastapi.tiangolo.com/{language_code}[rest part of the url]»). Example: -Source (English): + Source (English): -Documentation + ««« + Documentation + »»» -Result (Spanish): + Result (Spanish): -Documentación + ««« + Documentación + »»» 3.1) Do not add language codes for URLs that point to static assets (e.g., images, CSS, JavaScript). Example: -Source (English): + Source (English): -Something + ««« + Something + »»» -Result (Spanish): + Result (Spanish): -Algo + ««« + Algo + »»» 4) For internal links, only translate link text. Example: -Source (English): + Source (English): -[Create Pull Requests](help-fastapi.md#create-a-pull-request){.internal-link target=_blank} + ««« + [Create Pull Requests](help-fastapi.md#create-a-pull-request){.internal-link target=_blank} + »»» -Result (German): + Result (German): -[Pull Requests erzeugen](help-fastapi.md#create-a-pull-request){.internal-link target=_blank} + ««« + [Pull Requests erzeugen](help-fastapi.md#create-a-pull-request){.internal-link target=_blank} + »»» -5) Do not translate anchor fragments in links (the part after #), as they must remain the same to work correctly. +5) Do not translate anchor fragments in links (the part after «#»), as they must remain the same to work correctly. 5.1) If an existing translation has a link with an anchor fragment different to the anchor fragment in the English source, then this is an error. Fix this by using the anchor fragment of the English source. Example: -Source (English): + Source (English): -[Body - Multiple Parameters: Singular values in body](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank} + ««« + [Body - Multiple Parameters: Singular values in body](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank} + »»» -Existing wrong translation (German) – notice the wrongly translated anchor fragment: + Existing wrong translation (German) – notice the wrongly translated anchor fragment: -[Body – Mehrere Parameter: Einfache Werte im Body](body-multiple-params.md#einzelne-werte-im-body){.internal-link target=_blank}. + ««« + [Body – Mehrere Parameter: Einfache Werte im Body](body-multiple-params.md#einzelne-werte-im-body){.internal-link target=_blank}. + »»» -Result (German) – you fix the anchor fragment: + Result (German) – you fix the anchor fragment: -[Body – Mehrere Parameter: Einfache Werte im Body](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}. + ««« + [Body – Mehrere Parameter: Einfache Werte im Body](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}. + »»» 5.2) Do not add anchor fragments at will, even if this makes sense. If the English source has no anchor, don't add one. Example: -Source (English): + Source (English): + + ««« + Create a [virtual environment](../virtual-environments.md){.internal-link target=_blank} + »»» + + Wrong translation (German) – Anchor added to the URL. + + ««« + Erstelle eine [virtuelle Umgebung](../virtual-environments.md#create-a-virtual-environment){.internal-link target=_blank} + »»» + + Good translation (German) – URL stays like in the English source. + + ««« + Erstelle eine [Virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} + »»» + + +### Abbr elements + +Translate HTML abbr elements as follows: + +1) If the title attribute gives the full phrase for an abbreviation, then keep the phrase, append a dash («–»), followed by the translation of the phrase. + +Examples: + + Source (English): + + ««« + IoT + CPU + TL;DR: + »»» + + Result (German): + + ««« + IoT + CPU + TL;DR: + »»» + +Conversion scheme title attribute: + + Source (English): + + {full phrase} + + Result (German): + + {full phrase} – {translation of full phrase} + +1.1) If the translation of the phrase starts with the same letters, then just use the translation. + +Examples: + + Source (English): + + ««« + JWT + `Enum` + ASGI + »»» + + Result (German): + + ««« + JWT + `Enum` + ASGI + »»» + +Conversion scheme title attribute: + + Source (English): + + {full phrase} + + Result (German): + + {translation of full phrase} + +2) If the title attribute explains something in its own words, then translate it, if possible. + +Examples: + + Source (English): + + ««« + path + linter + "parsing" + 0.95.0 + at the time of writing this + »»» + + Result (German): + + ««« + Pfad + Linter + „Parsen“ + 0.95.0 + zum Zeitpunkt als das hier geschrieben wurde + »»» + +Conversion scheme title attribute: + + Source (English): + + {explanation} + + Result (German): + + {translation of explanation} + +3) If the title attribute gives the full phrase for an abbreviation, followed by a colon («:») or a comma («,»), followed by an explanation, then keep the phrase, append a dash («–»), followed by the translation of the phrase, followed by a colon («:»), followed by the translation of the explanation. + +Examples: + + Source (English): + + ««« + I/O + CDN + IDE + "ORMs" + »»» + + Result (German): + + ««« + I/O + CDN + IDE + „ORMs“ + »»» + +Conversion scheme title attribute: + + Source (English): + + {full phrase}: {explanation} + + OR + + Source (English): + + {full phrase}, {explanation} + + Result (German): + + {full phrase} – {translation of full phrase}: {translation of explanation} -Create a [virtual environment](../virtual-environments.md){.internal-link target=_blank} +3.1) For the full phrase (the part before the dash in the translation) rule 1.1 also applies, speak, you can leave the original full phrase away and just use the translated full phrase, if it starts with the same letters. The result becomes: -Wrong translation (German) – Anchor added to the URL. +Conversion scheme title attribute: -Erstelle eine [virtuelle Umgebung](../virtual-environments.md#create-a-virtual-environment){.internal-link target=_blank} + Result (German): -Good translation (German) – URL stays like in the English source. + {translation of full phrase}: {translation of explanation} -Erstelle eine [Virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} +4) If there is an HTML abbr element in a sentence in an existing translation, but that element does not exist in the related sentence in the English text, then keep that HTML abbr element in the translation, do not change or remove it. Except when you remove the whole sentence from the translation, because the whole sentence was removed from the English text. The reasoning for this rule is, that such abbr elements are manually added by the human editor of the translation, in order to translate or explain an English word to the human readers of the translation. They would not make sense in the English text, but they do make sense in the translation. So keep them in the translation, even though they are not part of the English text. This rule only applies to HTML abbr elements. """ From b13a42c7833c1912bcc10a56a0ad1524b8538d69 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sat, 30 Aug 2025 17:03:12 +0200 Subject: [PATCH 151/160] Add LLM test file --- docs/de/docs/_llm-test.md | 218 ++++++++++++++++++++++++++++++++++++++ docs/en/docs/_llm-test.md | 218 ++++++++++++++++++++++++++++++++++++++ scripts/translate.py | 4 +- 3 files changed, 438 insertions(+), 2 deletions(-) create mode 100644 docs/de/docs/_llm-test.md create mode 100644 docs/en/docs/_llm-test.md diff --git a/docs/de/docs/_llm-test.md b/docs/de/docs/_llm-test.md new file mode 100644 index 000000000..054f78402 --- /dev/null +++ b/docs/de/docs/_llm-test.md @@ -0,0 +1,218 @@ +# LLM-Test { #llm-test } + +Dieses Dokument testet, ob das LLM die Anweisungen im allgemeinen Prompt in `scripts/translate.py` und diejenigen im sprachspezifischen Prompt `docs/{language code}/llm-prompt.md` versteht (die an die Anweisungen im allgemeinen Prompt angehängt werden). + +Wie folgt verwenden: + +* Eine frische Übersetzung dieses Dokuments in die gewünschte Zielsprache erstellen. +* Prüfen, ob alles größtenteils in Ordnung ist. +* Wenn manches nicht in Ordnung ist, sich aber durch Verbesserungen am allgemeinen Prompt oder am sprachspezifischen Prompt beheben lässt, das tun. +* Dann die verbleibenden Probleme in der Übersetzung manuell beheben, sodass es eine gute Übersetzung ist. +* Erneut übersetzen, wobei die existierende, gute Übersetzung verwendet wird. Das ideale Ergebnis wäre, dass das LLM gar keine Änderungen vornimmt. Das würde bedeuten, dass der allgemeine Prompt und der Sprach-Prompt so gut wie möglich sind. (Plot Twist: Es wird normalerweise ein paar scheinbar zufällige Änderungen machen, der Grund ist vermutlich, dass LLMs keine deterministischen Algorithmen sind). + +Die Idee ist, dass Sie, wenn Sie an einer Übersetzung für eine Sprache arbeiten (unter der Annahme, dass Sie `scripts/translate.py` ausführen können), hier Beispiele gefundener Sonderfälle aufnehmen (keine detaillierte Liste, nur Beispiele für solche Sonderfälle) und mit diesem Dokument testen, statt jedes andere einzelne Dokument mehrfach zu testen und zu übersetzen, was pro Übersetzung ein paar Cent kostet. Außerdem werden durch das Hinzufügen solcher Sonderfälle hier auch andere Übersetzungsprojekte auf solche Sonderfälle aufmerksam. + +## Codeschnipsel { #codesnippets} + +Dies ist ein Codeschnipsel: `foo`. Und dies ist ein weiteres Codeschnipsel: `bar`. Und noch eins: `baz quux`. + +## Anführungszeichen { #quotes } + +Gestern schrieb mein Freund: „Wenn man falsch richtig buchstabiert, hat man es falsch buchstabiert“. Worauf ich antwortete: „Richtig, aber ‚falsch‘ ist fälschlich nicht ‚„falsch“‘“. + +## Anführungszeichen in Codeschnipseln { #quotes-in-codesnippets} + +`pip install "foo[bar]"` + +Beispiele für Stringliterale in Codeschnipseln: `"this"`, `'that'`. + +Ein schwieriges Beispiel für Stringliterale in Codeschnipseln: `f"I like {'oranges' if orange else "apples"}"` + +Hardcore: `Yesterday my friend wrote: "If you spell incorrectly correctly you have spelled it incorrectly". To which I answered: "Correct, but 'incorrectly' is incorrectly not '"incorrectly"'!"` + +## Codeblöcke { #code-blocks } + +Ein Bash-Codebeispiel ... + +```bash +# Gruß an das Universum ausgeben +echo "Hello universe" +``` + +... und ein Konsolen-Codebeispiel ... + +```console +$ fastapi run main.py + FastAPI Starting server + Searching for package file structure +``` + +... und noch ein Konsolen-Codebeispiel ... + +```console +// Erstellen Sie ein Verzeichnis "Code" +$ mkdir code +// Wechseln Sie in dieses Verzeichnis +$ cd code +``` + +... und ein Python-Codebeispiel ... + +```Python +wont_work() # Das wird nicht funktionieren 😱 +works(foo="bar") # Das funktioniert 🎉 +``` + +... und das war’s. + +## Tabs und farbige Kästen { #tabs-and-colored-boxes } + +//// tab | Dies ist ein Tab + +/// info | Info +Etwas Text +/// + +/// note | Hinweis +Etwas Text +/// + +/// note | Technische Details +Etwas Text +/// + +/// check | Testen +Etwas Text +/// + +/// tip | Tipp +Etwas Text +/// + +/// warning | Achtung +Etwas Text +/// + +/// danger | Gefahr +Etwas Text +/// + +//// + +## Web- und interne Links { #links } + +[Link zur Überschrift oben](#codesnippets) + +Externer Link + +FastAPI-Link + +Link zu einem Stil +Link zu einem Skript +Link zu einem Bild + +[Interner Link](foo.md#bar){.internal-link target=_blank} + +## Abbr-Elemente { #abbr-elements } + +Hier einige Dinge, die in `abbr`-Elemente gehüllt sind (einige sind erfunden): GTD, XWT, PSGI, Cluster, Deep Learning, MDN. + +## Überschriften { #headings } + +### Eine Webapp entwickeln – ein Tutorial { #develop-a-webapp-a-tutorial } + +Hallo. + +### Typhinweise und -annotationen { #type-hints-and-annotations } + +Hallo nochmal. + +### Super- und Subklassen { #super-and-subclasses } + +Hallo nochmal. + +## Sätze mit bevorzugten Übersetzungen (vielleicht) im Sprach-Prompt definiert { #sentences-with-preferred-translations-maybe-defined-in-the-language-prompt } + +Ich heiße Sie willkommen. +Ich bewundere Ihren Pullover. +Sie mag Obst, z. B. Äpfel +Er mag Orangen, Bananen, usw. +Lesen Sie die `PATH`-Umgebungsvariable. +Was dasselbe ist wie der `PATH`. +Installieren Sie aus der `requirements.txt`. +Verwenden Sie den API-Router. +Starten Sie die App. +Erstellen Sie die Anwendung. +Lesen Sie das Tutorial – Benutzerhandbuch. +Lesen Sie dann das Handbuch für fortgeschrittene Benutzer. +Dies ist der Autorisierungsheader. +Dies ist der `Authorization`-Header. +Warten auf den Hintergrundtask. +Probieren Sie diesen Cloudanbieter. +Verwenden Sie das CLI. +Was das Kommandozeileninterface ist. +Lesen Sie die Dokumentation. +Der Defaultwert ist „foo“. +Die Default-Deklaration ist „bar“. +Die Engine wird das tun. +Wenn die Umgebungsvariable existiert, tun Sie etwas. +Eine Error-Response zurückgeben. +Auf das Event warten. +Die Exception auslösen. +Der Exceptionhandler behandelt sie. +Das Formularmodell definieren. +Den Formularbody senden. +Auf den Header zugreifen. +Die Header ändern. +Schreibweise in Headern. +Auf das Lifespan-Event lauschen. +Locking bedeutet, dass wir ein Lock setzen, um etwas sicher zu ändern. +Eine Mobile-Anwendung entwickeln. +Das Modellobjekt definieren. +Etwas wartet auf das Mounten. +Es ist jetzt gemountet. +Ein weiteres Origin. +Dafür haben wir eine Überschreibung. +Die Funktion hat einen Parameter. +Der Funktionsparameter ist ein int. +Die Funktion hat viele Parameter. +Der Defaultparameter ist ein bool. +Der Body-Parameter enthält den Body des Requests. +Auch der Requestbody-Parameter genannt. +Der Pfad-Parameter enthält eine Variable im Requestpfad. +Der Query-Parameter enthält die Query-Parameter im Requestpfad. +Der Cookie-Parameter enthält die Request-Cookies. +Der Header-Parameter enthält die Request-Header. +Der Formular-Parameter enthält die Formularfelder des Requests. +Die Payload ist der Request/die Response ohne Metadaten. +Diese Query fragt nach Items, die älter als eine Woche sind. +Zusammenfassung: Es ist smooth. +Der Request wurde empfangen. +Den Requestbody empfangen. +Die Requestbodys empfangen. +Die Response zurückgeben. +Was eine Funktion zurückgibt, hat einen Rückgabewert. +Und einen Rückgabetyp. +Details sind in der SQLModel-Dokumentation beschrieben. +Verwenden Sie das SDK. +Der Tag `Horst` bedeutet, Horst muss es tun. +Dieser Parameter hat eine Typannotation. +Was ein Typhinweis ist. +Die Wildcard ist `*`. +Die Workerklasse macht dies und das. +Der Workerprozess macht auch Dinge. +Ich werde das morgen committen. +Gestern habe ich den Code geändert. +Lassen Sie uns unsere App bereitstellen. +Lassen Sie uns diese Seite ausliefern. +Aktualisieren Sie FastAPI, bevor Sie das tun. +Dies ist in ein HTML-Tag gewrappt. +`foo` vom Typ `int`. +`bar` vom Typ `str`. +`baz` vom Typ `list`. +FastAPIs Dokumentation. +Starlettes Performance. +Groß-/Klein­schrei­bung ist relevant in `foo`. +Groß-/Klein­schrei­bung ist nicht relevant in „Bar“. +Standard-Python-Klassen. +Dies ist deprecatet. diff --git a/docs/en/docs/_llm-test.md b/docs/en/docs/_llm-test.md new file mode 100644 index 000000000..1cc4f9de0 --- /dev/null +++ b/docs/en/docs/_llm-test.md @@ -0,0 +1,218 @@ +# LLM test { #llm-test } + +This document tests if the LLM understands the instructions given in the general prompt in `scripts/translate.py` and those in the language specific prompt `docs/{language code}/llm-prompt.md`, (which are appended to the instructions in the general prompt). + +Use as follows: + +* Do a fresh translation of this document into the desired target language. +* Check if things are mostly okay. +* If some things are not okay, but are fixable by improving the general or the language specific prompt, do that. +* Then manually fix the remaining issues in the translation, so that it is a good translation. +* Retranslate using the existing, good translation. The ideal result should be that the LLM makes no changes at all. That would mean that the general prompt and the language prompt are as good as they can be (Plot twist: It will usually make a few seemingly random changes, the reason is probably that LLMs are not deterministic algorithms). + +The idea is, that, when working on a translation for a language (assumed one is able to run `scripts/translate.py`), to include examples of found special cases here (not a detailed list, just examples for such special cases) and test with this document, rather than testing with every other single document, translating it multiple times, which costs a few cents per translation. Also, by adding such special cases here, other translation projects will also become aware of such special cases. + +## Code snippets { #codesnippets} + +This is a code snippet: `foo`. And this is another code snippet: `bar`. And another one: `baz quux`. + +## Quotes { #quotes } + +Yesterday, my friend wrote: "If you spell incorrectly correctly, you have spelled it incorrectly". To which I answered: "Correct, but 'incorrectly' is incorrectly not '"incorrectly"'". + +## Quotes in code snippets { #quotes-in-codesnippets} + +`pip install "foo[bar]"` + +Examples for string literals in code snippets: `"this"`, `'that'`. + +A difficult example for string literals in code snippets: `f"I like {'oranges' if orange else "apples"}"` + +Hardcore: `Yesterday my friend wrote: "If you spell incorrectly correctly you have spelled it incorrectly". To which I answered: "Correct, but 'incorrectly' is incorrectly not '"incorrectly"'!"` + +## code blocks { #code-blocks } + +A Bash code example... + +```bash +# Print a greeting to the universe +echo "Hello universe" +``` + +...and a console code example... + +```console +$ fastapi run main.py + FastAPI Starting server + Searching for package file structure +``` + +...and another console code example... + +```console +// Create a directory "Code" +$ mkdir code +// Switch into that directory +$ cd code +``` + +...and a Python code example... + +```Python +wont_work() # This won't work 😱 +works(foo="bar") # This works 🎉 +``` + +...and that's it. + +## Tabs and colored boxes { #tabs-and-colored-boxes } + +//// tab | This is a tab + +/// info +Some text +/// + +/// note +Some text +/// + +/// note | Technical details +Some text +/// + +/// check +Some text +/// + +/// tip +Some text +/// + +/// warning +Some text +/// + +/// danger +Some text +/// + +//// + +## Web- and internal links { #links } + +[Link to heading above](#codesnippets) + +External link + +FastAPI link + +Link to a style +Link to a script +Link to an image + +[Internal link](foo.md#bar){.internal-link target=_blank} + +## Abbr elements { #abbr-elements } + +Here some things wrapped in `abbr` elements (Some are invented): GTD, XWT, PSGI, cluster, Deep Learning, MDN. + +## Headings { #headings } + +### Develop a webapp - a tutorial { #develop-a-webapp-a-tutorial } + +Hello. + +### Type hints and -annotations { #type-hints-and-annotations } + +Hello again. + +### Super- and subclasses { #super-and-subclasses } + +Hello again. + +## Sentences with preferred translations, (maybe) defined in the language prompt { #sentences-with-preferred-translations-maybe-defined-in-the-language-prompt } + +I welcome you. +I admire your pullover. +She likes fruits e.g. apples +He likes oranges, bananas, etc. +Read the `PATH` environment variable. +Which is the same as the `PATH`. +Install from the `requirements.txt`. +Use the API Router. +Start the app. +Create the application. +Read the Tutorial - User guide. +Then read the Advanced User Guide. +This is the Authorization-Header. +This is the `Authorization`-Header. +Waiting for the background task. +Try this cloud provider. +Use the CLI. +Which is the command line interface. +Read the docs. +The default value is "foo". +The default declaration is "bar". +The engine will do that. +If the env var exists, do something. +Return an error response. +Wait for the event. +Raise the exception. +The exception handler handles it. +Defining the form model. +Sending the form body. +Accessing the header. +Modifying the headers. +Spelling in headers. +Listening to the lifespan event. +Locking means, we lock a thing to safely modify it. +Developing a mobile application. +Defining the model object. +Something waits for the mounting. +It is now mounted. +Another origin. +We have an override for this. +The function has one parameter. +The function parameter is an int. +The function has many parameters. +The default parameter is a bool. +The body parameter contains the body of the request. +Also called the request body parameter. +The path parameter contains a variable in the request path. +The query parameter contains the query parameters in the request path. +The cookie parameter contains the request cookies. +The header parameter contains the request headers. +The form parameter contains the request's form fields. +The payload is the request/response without metadata. +This query asks for items older than a week. +Recap: It's smooth. +The request has been received. +Receiving the request body. +Receiving the request bodies. +Returning the response. +What a function returns has a return value. +And a return type. +Details are described in the SQLModel docs. +Use the SDK. +The tag `Horst` means, Horst has to do it. +This parameter has a type annotation. +Which is a type hint. +The wildcard is `*`. +The worker class does this and that. +The worker process also does things. +I will commit this tomorrow. +Yesterday I modified the code. +Let's serve our app. +Let's serve this page. +Before doing this, upgrade FastAPI. +This is wrapped in an HTML tag. +`foo` as an `int`. +`bar` as a `str`. +`baz` as a `list`. +FastAPI's documentation. +Starlette's performance. +`foo` is case-sensitive. +"Bar" is case-insensitive. +Standard Python classes. +This is deprecated. diff --git a/scripts/translate.py b/scripts/translate.py index 901ce2a45..171f469bc 100644 --- a/scripts/translate.py +++ b/scripts/translate.py @@ -679,9 +679,9 @@ def translate_page( Path, typer.Option( envvar="EN_PATH", - help="Path to the English source, relative to the FastAPI root directory, e.g. `docs/en/docs/index.md`", + help="Path to the English source, relative to the FastAPI root directory. If not given, `docs/en/docs/_llm-test.md` is used.", ), - ], + ] = Path("docs/en/docs/_llm-test.md"), ) -> None: assert language != "en", ( "`en` is the source language, choose another language as translation target" From e9e686a105c04ca25f2e5bc94e9ca480dd6375eb Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sat, 30 Aug 2025 17:04:15 +0200 Subject: [PATCH 152/160] Update index.md --- docs/de/docs/index.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/de/docs/index.md b/docs/de/docs/index.md index d8b25a293..8603394df 100644 --- a/docs/de/docs/index.md +++ b/docs/de/docs/index.md @@ -91,7 +91,7 @@ Seine Schlüssel-Merkmale sind: --- -„_Ehrlich, was Sie gebaut haben, sieht super solide und poliert aus. In vielerlei Hinsicht ist es so, wie ich **Hug** haben wollte – es ist wirklich inspirierend, jemanden so etwas bauen zu sehen._“ +„_Ehrlich, was Du gebaut hast, sieht super solide und poliert aus. In vielerlei Hinsicht ist es so, wie ich **Hug** haben wollte – es ist wirklich inspirierend, jemanden so etwas bauen zu sehen._“
Timothy Crosley - Hug-Autor (Ref)
@@ -328,13 +328,13 @@ Gehen Sie jetzt auf http://127.0.0.1:8000/redoc. -* Die alternative Dokumentation wird ebenfalls den neuen Abfrageparameter und -inhalt widerspiegeln: +* Die alternative Dokumentation wird ebenfalls den neuen Query-Parameter und Body widerspiegeln: ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png) ### Zusammenfassung { #recap } -Zusammengefasst deklarieren Sie **einmal** die Typen von Parametern, Body, etc. als Funktionsparameter. +Zusammengefasst deklarieren Sie **einmal** die Typen von Parametern, Body, usw. als Funktionsparameter. Das machen Sie mit modernen Standard-Python-Typen. @@ -387,7 +387,7 @@ Um auf das vorherige Codebeispiel zurückzukommen, **FastAPI** wird: * Überprüfen, dass es eine `item_id` im Pfad für `GET`- und `PUT`-Anfragen gibt. * Überprüfen, ob die `item_id` vom Typ `int` für `GET`- und `PUT`-Anfragen ist. * Falls nicht, wird dem Client ein nützlicher, eindeutiger Fehler angezeigt. -* Prüfen, ob es einen optionalen Abfrageparameter namens `q` (wie in `http://127.0.0.1:8000/items/foo?q=somequery`) für `GET`-Anfragen gibt. +* Prüfen, ob es einen optionalen Query-Parameter namens `q` (wie in `http://127.0.0.1:8000/items/foo?q=somequery`) für `GET`-Anfragen gibt. * Da der `q`-Parameter mit `= None` deklariert ist, ist er optional. * Ohne das `None` wäre er erforderlich (wie der Body im Fall von `PUT`). * Bei `PUT`-Anfragen an `/items/{item_id}` den Body als JSON lesen: From 8256d09854b7f5829e502444de11b804faccaf9b Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 30 Aug 2025 18:35:32 +0000 Subject: [PATCH 153/160] =?UTF-8?q?=F0=9F=8E=A8=20[pre-commit.ci]=20Auto?= =?UTF-8?q?=20format=20from=20pre-commit.com=20hooks?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/de/docs/_llm-test.md | 6 +++--- docs/en/docs/_llm-test.md | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/de/docs/_llm-test.md b/docs/de/docs/_llm-test.md index 054f78402..ae364fee1 100644 --- a/docs/de/docs/_llm-test.md +++ b/docs/de/docs/_llm-test.md @@ -4,10 +4,10 @@ Dieses Dokument testet, ob das LLMs keine deterministischen Algorithmen sind). Die Idee ist, dass Sie, wenn Sie an einer Übersetzung für eine Sprache arbeiten (unter der Annahme, dass Sie `scripts/translate.py` ausführen können), hier Beispiele gefundener Sonderfälle aufnehmen (keine detaillierte Liste, nur Beispiele für solche Sonderfälle) und mit diesem Dokument testen, statt jedes andere einzelne Dokument mehrfach zu testen und zu übersetzen, was pro Übersetzung ein paar Cent kostet. Außerdem werden durch das Hinzufügen solcher Sonderfälle hier auch andere Übersetzungsprojekte auf solche Sonderfälle aufmerksam. diff --git a/docs/en/docs/_llm-test.md b/docs/en/docs/_llm-test.md index 1cc4f9de0..b413bcc33 100644 --- a/docs/en/docs/_llm-test.md +++ b/docs/en/docs/_llm-test.md @@ -4,10 +4,10 @@ This document tests if the LLM underst Use as follows: -* Do a fresh translation of this document into the desired target language. -* Check if things are mostly okay. +* Do a fresh translation of this document into the desired target language. +* Check if things are mostly okay. * If some things are not okay, but are fixable by improving the general or the language specific prompt, do that. -* Then manually fix the remaining issues in the translation, so that it is a good translation. +* Then manually fix the remaining issues in the translation, so that it is a good translation. * Retranslate using the existing, good translation. The ideal result should be that the LLM makes no changes at all. That would mean that the general prompt and the language prompt are as good as they can be (Plot twist: It will usually make a few seemingly random changes, the reason is probably that LLMs are not deterministic algorithms). The idea is, that, when working on a translation for a language (assumed one is able to run `scripts/translate.py`), to include examples of found special cases here (not a detailed list, just examples for such special cases) and test with this document, rather than testing with every other single document, translating it multiple times, which costs a few cents per translation. Also, by adding such special cases here, other translation projects will also become aware of such special cases. From 2ac0310b2a1631a38869b7b2a94a6209a7ef3079 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sat, 30 Aug 2025 22:12:35 +0200 Subject: [PATCH 154/160] Intermezzo: `Anfrage` --> `Request` First `Request` per page gets ann abbr with an explanation. --- docs/de/docs/advanced/async-tests.md | 2 +- docs/de/docs/advanced/behind-a-proxy.md | 6 +++--- docs/de/docs/advanced/dataclasses.md | 2 +- docs/de/docs/advanced/events.md | 2 +- docs/de/docs/advanced/generate-clients.md | 2 +- docs/de/docs/advanced/middleware.md | 2 +- docs/de/docs/advanced/openapi-callbacks.md | 2 +- docs/de/docs/advanced/openapi-webhooks.md | 2 +- .../path-operation-advanced-configuration.md | 2 +- docs/de/docs/advanced/security/http-basic-auth.md | 2 +- docs/de/docs/advanced/security/oauth2-scopes.md | 2 +- docs/de/docs/advanced/settings.md | 2 +- docs/de/docs/advanced/templates.md | 2 +- docs/de/docs/advanced/testing-dependencies.md | 2 +- docs/de/docs/advanced/using-request-directly.md | 2 +- docs/de/docs/advanced/wsgi.md | 2 +- docs/de/docs/alternatives.md | 4 ++-- docs/de/docs/async.md | 2 +- docs/de/docs/deployment/concepts.md | 2 +- docs/de/docs/deployment/docker.md | 2 +- docs/de/docs/deployment/https.md | 2 +- docs/de/docs/deployment/server-workers.md | 2 +- docs/de/docs/features.md | 8 ++++---- docs/de/docs/how-to/conditional-openapi.md | 2 +- docs/de/docs/how-to/custom-request-and-route.md | 2 +- docs/de/docs/how-to/extending-openapi.md | 2 +- docs/de/docs/index.md | 14 +++++++------- docs/de/docs/python-types.md | 6 +++--- docs/de/docs/tutorial/background-tasks.md | 2 +- docs/de/docs/tutorial/bigger-applications.md | 2 +- docs/de/docs/tutorial/body-multiple-params.md | 2 +- docs/de/docs/tutorial/body-nested-models.md | 2 +- docs/de/docs/tutorial/body-updates.md | 2 +- docs/de/docs/tutorial/body.md | 4 ++-- docs/de/docs/tutorial/cookie-param-models.md | 2 +- docs/de/docs/tutorial/cors.md | 2 +- .../dependencies-in-path-operation-decorators.md | 2 +- docs/de/docs/tutorial/dependencies/index.md | 4 ++-- .../docs/tutorial/dependencies/sub-dependencies.md | 2 +- docs/de/docs/tutorial/extra-data-types.md | 2 +- docs/de/docs/tutorial/first-steps.md | 4 ++-- docs/de/docs/tutorial/handling-errors.md | 4 ++-- docs/de/docs/tutorial/header-param-models.md | 2 +- docs/de/docs/tutorial/middleware.md | 6 +++--- docs/de/docs/tutorial/path-params.md | 4 ++-- docs/de/docs/tutorial/query-param-models.md | 2 +- .../docs/tutorial/query-params-str-validations.md | 4 ++-- docs/de/docs/tutorial/query-params.md | 2 +- docs/de/docs/tutorial/request-files.md | 2 +- docs/de/docs/tutorial/request-form-models.md | 2 +- docs/de/docs/tutorial/request-forms-and-files.md | 2 +- docs/de/docs/tutorial/request-forms.md | 2 +- docs/de/docs/tutorial/security/first-steps.md | 2 +- docs/de/docs/tutorial/security/get-current-user.md | 2 +- docs/de/docs/tutorial/security/oauth2-jwt.md | 2 +- docs/de/docs/tutorial/sql-databases.md | 6 +++--- docs/de/docs/tutorial/testing.md | 2 +- 57 files changed, 81 insertions(+), 81 deletions(-) diff --git a/docs/de/docs/advanced/async-tests.md b/docs/de/docs/advanced/async-tests.md index bd3c78113..ad8245205 100644 --- a/docs/de/docs/advanced/async-tests.md +++ b/docs/de/docs/advanced/async-tests.md @@ -2,7 +2,7 @@ Sie haben bereits gesehen, wie Sie Ihre **FastAPI**-Anwendungen mit dem bereitgestellten `TestClient` testen. Bisher haben Sie nur gesehen, wie man synchrone Tests schreibt, ohne `async`-Funktionen zu verwenden. -Die Möglichkeit, in Ihren Tests asynchrone Funktionen zu verwenden, könnte beispielsweise nützlich sein, wenn Sie Ihre Datenbank asynchron abfragen. Stellen Sie sich vor, Sie möchten das Senden von Requests an Ihre FastAPI-Anwendung testen und dann überprüfen, ob Ihr Backend die richtigen Daten erfolgreich in die Datenbank geschrieben hat, während Sie eine asynchrone Datenbankbibliothek verwenden. +Die Möglichkeit, in Ihren Tests asynchrone Funktionen zu verwenden, könnte beispielsweise nützlich sein, wenn Sie Ihre Datenbank asynchron abfragen. Stellen Sie sich vor, Sie möchten das Senden von Requests an Ihre FastAPI-Anwendung testen und dann überprüfen, ob Ihr Backend die richtigen Daten erfolgreich in die Datenbank geschrieben hat, während Sie eine asynchrone Datenbankbibliothek verwenden. Schauen wir uns an, wie wir das machen können. diff --git a/docs/de/docs/advanced/behind-a-proxy.md b/docs/de/docs/advanced/behind-a-proxy.md index cb469b29b..580ecfa71 100644 --- a/docs/de/docs/advanced/behind-a-proxy.md +++ b/docs/de/docs/advanced/behind-a-proxy.md @@ -20,7 +20,7 @@ Auch wenn Ihr gesamter Code unter der Annahme geschrieben ist, dass es nur `/app {* ../../docs_src/behind_a_proxy/tutorial001.py hl[6] *} -Und der Proxy würde das **Pfadpräfix** on-the-fly **„entfernen“**, bevor er die Anfrage an den Anwendungsserver (wahrscheinlich Uvicorn via FastAPI CLI) übermittelt, dafür sorgend, dass Ihre Anwendung davon überzeugt ist, dass sie unter `/app` bereitgestellt wird, sodass Sie nicht Ihren gesamten Code dahingehend aktualisieren müssen, das Präfix `/api/v1` zu verwenden. +Und der Proxy würde das **Pfadpräfix** on-the-fly **„entfernen“**, bevor er den Request an den Anwendungsserver (wahrscheinlich Uvicorn via FastAPI CLI) übermittelt, dafür sorgend, dass Ihre Anwendung davon überzeugt ist, dass sie unter `/app` bereitgestellt wird, sodass Sie nicht Ihren gesamten Code dahingehend aktualisieren müssen, das Präfix `/api/v1` zu verwenden. Bis hierher würde alles wie gewohnt funktionieren. @@ -92,7 +92,7 @@ Und die Kommandozeilenoption `--root-path` stellt diesen `root_path` bereit. ### Testen des aktuellen `root_path` { #checking-the-current-root-path } -Sie können den aktuellen `root_path` abrufen, der von Ihrer Anwendung für jede Anfrage verwendet wird. Er ist Teil des `scope`-Dictionarys (das ist Teil der ASGI-Spezifikation). +Sie können den aktuellen `root_path` abrufen, der von Ihrer Anwendung für jeden Request verwendet wird. Er ist Teil des `scope`-Dictionarys (das ist Teil der ASGI-Spezifikation). Hier fügen wir ihn, nur zu Demonstrationszwecken, in die Nachricht ein. @@ -205,7 +205,7 @@ Erstellen Sie nun die andere Datei `routes.toml`: Diese Datei konfiguriert Traefik, das Pfadpräfix `/api/v1` zu verwenden. -Und dann leitet Traefik seine Anfragen an Ihren Uvicorn weiter, der unter `http://127.0.0.1:8000` läuft. +Und dann leitet Traefik seine Requests an Ihren Uvicorn weiter, der unter `http://127.0.0.1:8000` läuft. Starten Sie nun Traefik: diff --git a/docs/de/docs/advanced/dataclasses.md b/docs/de/docs/advanced/dataclasses.md index 8b519464f..f7d081399 100644 --- a/docs/de/docs/advanced/dataclasses.md +++ b/docs/de/docs/advanced/dataclasses.md @@ -1,6 +1,6 @@ # Verwendung von Datenklassen { #using-dataclasses } -FastAPI basiert auf **Pydantic**, und ich habe Ihnen gezeigt, wie Sie Pydantic-Modelle verwenden können, um Requests und Responses zu deklarieren. +FastAPI basiert auf **Pydantic**, und ich habe Ihnen gezeigt, wie Sie Pydantic-Modelle verwenden können, um Requests und Responses zu deklarieren. Aber FastAPI unterstützt auf die gleiche Weise auch die Verwendung von `dataclasses`: diff --git a/docs/de/docs/advanced/events.md b/docs/de/docs/advanced/events.md index 2e54a5a73..4c644d7e2 100644 --- a/docs/de/docs/advanced/events.md +++ b/docs/de/docs/advanced/events.md @@ -1,6 +1,6 @@ # Lifespan-Events { #lifespan-events } -Sie können Logik (Code) definieren, die ausgeführt werden soll, bevor die Anwendung **hochfährt**. Dies bedeutet, dass dieser Code **einmal** ausgeführt wird, **bevor** die Anwendung **beginnt, Requests entgegenzunehmen**. +Sie können Logik (Code) definieren, die ausgeführt werden soll, bevor die Anwendung **hochfährt**. Dies bedeutet, dass dieser Code **einmal** ausgeführt wird, **bevor** die Anwendung **beginnt, Requests entgegenzunehmen**. Auf die gleiche Weise können Sie Logik (Code) definieren, die ausgeführt werden soll, wenn die Anwendung **heruntergefahren** wird. In diesem Fall wird dieser Code **einmal** ausgeführt, **nachdem** möglicherweise **viele Requests** bearbeitet wurden. diff --git a/docs/de/docs/advanced/generate-clients.md b/docs/de/docs/advanced/generate-clients.md index f8fae132b..5d3ad7aac 100644 --- a/docs/de/docs/advanced/generate-clients.md +++ b/docs/de/docs/advanced/generate-clients.md @@ -42,7 +42,7 @@ Beginnen wir mit einer einfachen FastAPI-Anwendung: {* ../../docs_src/generate_clients/tutorial001_py39.py hl[7:9,12:13,16:17,21] *} -Beachten Sie, dass die *Pfadoperationen* die Modelle definieren, die sie für die Request- und Response-Payload verwenden, indem sie die Modelle `Item` und `ResponseMessage` verwenden. +Beachten Sie, dass die *Pfadoperationen* die Modelle definieren, die sie für die Request- und Response-Payload verwenden, indem sie die Modelle `Item` und `ResponseMessage` verwenden. ### API-Dokumentation { #api-docs } diff --git a/docs/de/docs/advanced/middleware.md b/docs/de/docs/advanced/middleware.md index 59e15d3e2..58be3393b 100644 --- a/docs/de/docs/advanced/middleware.md +++ b/docs/de/docs/advanced/middleware.md @@ -53,7 +53,7 @@ Für die nächsten Beispiele könnten Sie auch `from starlette.middleware.someth ## `HTTPSRedirectMiddleware` { #httpsredirectmiddleware } -Erzwingt, dass alle eingehenden Requests entweder `https` oder `wss` sein müssen. +Erzwingt, dass alle eingehenden Requests entweder `https` oder `wss` sein müssen. Alle eingehenden Requests an `http` oder `ws` werden stattdessen an das sichere Schema umgeleitet. diff --git a/docs/de/docs/advanced/openapi-callbacks.md b/docs/de/docs/advanced/openapi-callbacks.md index f764b20cf..d88259ace 100644 --- a/docs/de/docs/advanced/openapi-callbacks.md +++ b/docs/de/docs/advanced/openapi-callbacks.md @@ -1,6 +1,6 @@ # OpenAPI Callbacks { #openapi-callbacks } -Sie könnten eine API mit einer *Pfadoperation* erstellen, die einen Request an eine *externe API* auslösen könnte, welche von jemand anderem erstellt wurde (wahrscheinlich derselbe Entwickler, der Ihre API *verwenden* würde). +Sie könnten eine API mit einer *Pfadoperation* erstellen, die einen Request an eine *externe API* auslösen könnte, welche von jemand anderem erstellt wurde (wahrscheinlich derselbe Entwickler, der Ihre API *verwenden* würde). Der Vorgang, der stattfindet, wenn Ihre API-Anwendung die *externe API* aufruft, wird als „Callback“ („Rückruf“) bezeichnet. Denn die Software, die der externe Entwickler geschrieben hat, sendet einen Request an Ihre API und dann *ruft Ihre API zurück* (*calls back*) und sendet einen Request an eine *externe API* (die wahrscheinlich vom selben Entwickler erstellt wurde). diff --git a/docs/de/docs/advanced/openapi-webhooks.md b/docs/de/docs/advanced/openapi-webhooks.md index af0f7b4ff..1aab619b1 100644 --- a/docs/de/docs/advanced/openapi-webhooks.md +++ b/docs/de/docs/advanced/openapi-webhooks.md @@ -1,6 +1,6 @@ # OpenAPI Webhooks { #openapi-webhooks } -Es gibt Fälle, in denen Sie Ihren API-**Benutzern** mitteilen möchten, dass Ihre App *deren* App mit einigen Daten aufrufen (einen Request senden) könnte, normalerweise um über ein bestimmtes **Event** zu **benachrichtigen**. +Es gibt Fälle, in denen Sie Ihren API-**Benutzern** mitteilen möchten, dass Ihre App *deren* App mit einigen Daten aufrufen (einen Request senden) könnte, normalerweise um über ein bestimmtes **Event** zu **benachrichtigen**. Das bedeutet, dass anstelle des normalen Prozesses, bei dem Ihre Benutzer Requests an Ihre API senden, **Ihre API** (oder Ihre App) **Requests an deren System** (an deren API, deren App) senden könnte. diff --git a/docs/de/docs/advanced/path-operation-advanced-configuration.md b/docs/de/docs/advanced/path-operation-advanced-configuration.md index ab1d511a7..3a0c25370 100644 --- a/docs/de/docs/advanced/path-operation-advanced-configuration.md +++ b/docs/de/docs/advanced/path-operation-advanced-configuration.md @@ -135,7 +135,7 @@ Das Dictionary in `openapi_extra` wird mit dem automatisch generierten OpenAPI-S Sie können dem automatisch generierten Schema also zusätzliche Daten hinzufügen. -Sie könnten sich beispielsweise dafür entscheiden, den Request mit Ihrem eigenen Code zu lesen und zu validieren, ohne die automatischen Funktionen von FastAPI mit Pydantic zu verwenden, aber Sie könnten den Request trotzdem im OpenAPI-Schema definieren wollen. +Sie könnten sich beispielsweise dafür entscheiden, den Request mit Ihrem eigenen Code zu lesen und zu validieren, ohne die automatischen Funktionen von FastAPI mit Pydantic zu verwenden, aber Sie könnten den Request trotzdem im OpenAPI-Schema definieren wollen. Das könnte man mit `openapi_extra` machen: diff --git a/docs/de/docs/advanced/security/http-basic-auth.md b/docs/de/docs/advanced/security/http-basic-auth.md index eff834b5d..f602858bb 100644 --- a/docs/de/docs/advanced/security/http-basic-auth.md +++ b/docs/de/docs/advanced/security/http-basic-auth.md @@ -58,7 +58,7 @@ Aber was ist ein „Timing-Angriff“? Stellen wir uns vor, dass einige Angreifer versuchen, den Benutzernamen und das Passwort zu erraten. -Und sie senden einen Request mit dem Benutzernamen `johndoe` und dem Passwort `love123`. +Und sie senden einen Request mit dem Benutzernamen `johndoe` und dem Passwort `love123`. Dann würde der Python-Code in Ihrer Anwendung etwa so aussehen: diff --git a/docs/de/docs/advanced/security/oauth2-scopes.md b/docs/de/docs/advanced/security/oauth2-scopes.md index af82ecd34..e9e0d8910 100644 --- a/docs/de/docs/advanced/security/oauth2-scopes.md +++ b/docs/de/docs/advanced/security/oauth2-scopes.md @@ -86,7 +86,7 @@ Das ist derselbe Mechanismus, der verwendet wird, wenn Sie beim Anmelden mit Fac Ändern Sie nun die Token-*Pfadoperation*, um die angeforderten Scopes zurückzugeben. -Wir verwenden immer noch dasselbe `OAuth2PasswordRequestForm`. Es enthält eine Eigenschaft `scopes` mit einer `list`e von `str`s für jeden Scope, den es im Request erhalten hat. +Wir verwenden immer noch dasselbe `OAuth2PasswordRequestForm`. Es enthält eine Eigenschaft `scopes` mit einer `list`e von `str`s für jeden Scope, den es im Request erhalten hat. Und wir geben die Scopes als Teil des JWT-Tokens zurück. diff --git a/docs/de/docs/advanced/settings.md b/docs/de/docs/advanced/settings.md index 29024c86c..6fa578d4c 100644 --- a/docs/de/docs/advanced/settings.md +++ b/docs/de/docs/advanced/settings.md @@ -249,7 +249,7 @@ Hier definieren wir die Konfiguration `env_file` innerhalb Ihrer Pydantic-`Setti ### Die `Settings` nur einmal laden mittels `lru_cache` { #creating-the-settings-only-once-with-lru-cache } -Das Lesen einer Datei von der Festplatte ist normalerweise ein kostspieliger (langsamer) Vorgang, daher möchten Sie ihn wahrscheinlich nur einmal ausführen und dann dasselbe Einstellungsobjekt erneut verwenden, anstatt es für jeden Request zu lesen. +Das Lesen einer Datei von der Festplatte ist normalerweise ein kostspieliger (langsamer) Vorgang, daher möchten Sie ihn wahrscheinlich nur einmal ausführen und dann dasselbe Einstellungsobjekt erneut verwenden, anstatt es für jeden Request zu lesen. Aber jedes Mal, wenn wir ausführen: diff --git a/docs/de/docs/advanced/templates.md b/docs/de/docs/advanced/templates.md index b507c026a..97801c04a 100644 --- a/docs/de/docs/advanced/templates.md +++ b/docs/de/docs/advanced/templates.md @@ -24,7 +24,7 @@ $ pip install jinja2 * Importieren Sie `Jinja2Templates`. * Erstellen Sie ein `templates`-Objekt, das Sie später wiederverwenden können. -* Deklarieren Sie einen `Request`-Parameter in der *Pfadoperation*, welcher ein Template zurückgibt. +* Deklarieren Sie einen `Request`-Parameter in der *Pfadoperation*, welcher ein Template zurückgibt. * Verwenden Sie die von Ihnen erstellten `templates`, um eine `TemplateResponse` zu rendern und zurückzugeben, übergeben Sie den Namen des Templates, das Requestobjekt und ein „Kontext“-Dictionary mit Schlüssel-Wert-Paaren, die innerhalb des Jinja2-Templates verwendet werden sollen. {* ../../docs_src/templates/tutorial001.py hl[4,11,15:18] *} diff --git a/docs/de/docs/advanced/testing-dependencies.md b/docs/de/docs/advanced/testing-dependencies.md index f673b78d2..4e5b16c89 100644 --- a/docs/de/docs/advanced/testing-dependencies.md +++ b/docs/de/docs/advanced/testing-dependencies.md @@ -14,7 +14,7 @@ Ein Beispiel könnte sein, dass Sie einen externen Authentifizierungsanbieter ha Sie senden ihm ein Token und er gibt einen authentifizierten Benutzer zurück. -Dieser Anbieter berechnet Ihnen möglicherweise Gebühren pro Anfrage, und der Aufruf könnte etwas länger dauern, als wenn Sie einen vordefinierten Mock-Benutzer für Tests hätten. +Dieser Anbieter berechnet Ihnen möglicherweise Gebühren pro Request, und der Aufruf könnte etwas länger dauern, als wenn Sie einen vordefinierten Mock-Benutzer für Tests hätten. Sie möchten den externen Anbieter wahrscheinlich einmal testen, ihn aber nicht unbedingt bei jedem weiteren ausgeführten Test aufrufen. diff --git a/docs/de/docs/advanced/using-request-directly.md b/docs/de/docs/advanced/using-request-directly.md index 685e5f9b3..7782237ec 100644 --- a/docs/de/docs/advanced/using-request-directly.md +++ b/docs/de/docs/advanced/using-request-directly.md @@ -1,6 +1,6 @@ # Den Request direkt verwenden { #using-the-request-directly } -Bisher haben Sie die Teile des Requests, die Sie benötigen, mithilfe von deren Typen deklariert. +Bisher haben Sie die Teile des Requests, die Sie benötigen, mithilfe von deren Typen deklariert. Daten nehmend von: diff --git a/docs/de/docs/advanced/wsgi.md b/docs/de/docs/advanced/wsgi.md index 6f9acc027..95aac4f88 100644 --- a/docs/de/docs/advanced/wsgi.md +++ b/docs/de/docs/advanced/wsgi.md @@ -16,7 +16,7 @@ Und dann mounten Sie das auf einem Pfad. ## Es testen { #check-it } -Jetzt wird jeder Request unter dem Pfad `/v1/` von der Flask-Anwendung verarbeitet. +Jetzt wird jeder Request unter dem Pfad `/v1/` von der Flask-Anwendung verarbeitet. Und der Rest wird von **FastAPI** gehandhabt. diff --git a/docs/de/docs/alternatives.md b/docs/de/docs/alternatives.md index 11cb8b525..a4b418796 100644 --- a/docs/de/docs/alternatives.md +++ b/docs/de/docs/alternatives.md @@ -82,7 +82,7 @@ Aus diesem Grund heißt es auf der offiziellen Website: > Requests ist eines der am häufigsten heruntergeladenen Python-Packages aller Zeiten -Die Art und Weise, wie Sie es verwenden, ist sehr einfach. Um beispielsweise einen `GET`-Request zu machen, würden Sie schreiben: +Die Art und Weise, wie Sie es verwenden, ist sehr einfach. Um beispielsweise einen `GET`-Request zu machen, würden Sie schreiben: ```Python response = requests.get("http://example.com/some/url") @@ -249,7 +249,7 @@ Da die Parameter mit TypeScript-Typen beschrieben werden (ähnlich den Python-Ty Da TypeScript-Daten jedoch nach der Kompilierung nach JavaScript nicht erhalten bleiben, können die Typen nicht gleichzeitig die Validierung, Serialisierung und Dokumentation definieren. Aus diesem Grund und aufgrund einiger Designentscheidungen ist es für die Validierung, Serialisierung und automatische Schemagenerierung erforderlich, an vielen Stellen Dekoratoren hinzuzufügen. Es wird also ziemlich ausführlich. -Es kann nicht sehr gut mit verschachtelten Modellen umgehen. Wenn es sich beim JSON-Body in der Anfrage also um ein JSON-Objekt mit inneren Feldern handelt, die wiederum verschachtelte JSON-Objekte sind, kann er nicht richtig dokumentiert und validiert werden. +Es kann nicht sehr gut mit verschachtelten Modellen umgehen. Wenn es sich beim JSON-Body im Request also um ein JSON-Objekt mit inneren Feldern handelt, die wiederum verschachtelte JSON-Objekte sind, kann er nicht richtig dokumentiert und validiert werden. /// check | Inspirierte **FastAPI** diff --git a/docs/de/docs/async.md b/docs/de/docs/async.md index 64542b47a..71c61711f 100644 --- a/docs/de/docs/async.md +++ b/docs/de/docs/async.md @@ -239,7 +239,7 @@ In diesem Szenario „Fastfood-Burger mit Ihrem Schwarm“ ist es viel sinnvolle Das ist auch bei den meisten Webanwendungen der Fall. -Viele, viele Benutzer, aber Ihr Server wartet 🕙 darauf, dass deren nicht so gute Internetverbindungen die Requests übermitteln. +Viele, viele Benutzer, aber Ihr Server wartet 🕙 darauf, dass deren nicht so gute Internetverbindungen die Requests übermitteln. Und dann wieder warten 🕙, bis die Responses zurückkommen. diff --git a/docs/de/docs/deployment/concepts.md b/docs/de/docs/deployment/concepts.md index af63b66d4..18174b66f 100644 --- a/docs/de/docs/deployment/concepts.md +++ b/docs/de/docs/deployment/concepts.md @@ -137,7 +137,7 @@ Und wir als Entwickler verbessern den Code ständig, wenn wir diese Bugs finden ### Kleine Fehler automatisch handhaben { #small-errors-automatically-handled } -Wenn beim Erstellen von Web-APIs mit FastAPI ein Fehler in unserem Code auftritt, wird FastAPI ihn normalerweise dem einzelnen Request zurückgeben, der den Fehler ausgelöst hat. 🛡 +Wenn beim Erstellen von Web-APIs mit FastAPI ein Fehler in unserem Code auftritt, wird FastAPI ihn normalerweise dem einzelnen Request zurückgeben, der den Fehler ausgelöst hat. 🛡 Der Client erhält für diesen Request einen **500 Internal Server Error**, aber die Anwendung arbeitet bei den nächsten Requests weiter, anstatt einfach komplett abzustürzen. diff --git a/docs/de/docs/deployment/docker.md b/docs/de/docs/deployment/docker.md index 9398129bf..04879c426 100644 --- a/docs/de/docs/deployment/docker.md +++ b/docs/de/docs/deployment/docker.md @@ -458,7 +458,7 @@ Ohne die Verwendung von Containern kann es umständlich und schwierig sein, Anwe Wenn Sie einen Cluster von Maschinen mit **Kubernetes**, Docker Swarm Mode, Nomad verwenden, oder einem anderen, ähnlich komplexen System zur Verwaltung verteilter Container auf mehreren Maschinen, möchten Sie wahrscheinlich die **Replikation auf Cluster-Ebene abwickeln**, anstatt in jedem Container einen **Prozessmanager** (wie Uvicorn mit Workern) zu verwenden. -Diese verteilten Containerverwaltungssysteme wie Kubernetes verfügen normalerweise über eine integrierte Möglichkeit, die **Replikation von Containern** zu handhaben und gleichzeitig **Load Balancing** für die eingehenden Requests zu unterstützen. Alles auf **Cluster-Ebene**. +Diese verteilten Containerverwaltungssysteme wie Kubernetes verfügen normalerweise über eine integrierte Möglichkeit, die **Replikation von Containern** zu handhaben und gleichzeitig **Load Balancing** für die eingehenden Requests zu unterstützen. Alles auf **Cluster-Ebene**. In diesen Fällen möchten Sie wahrscheinlich ein **Docker-Image von Grund auf** erstellen, wie [oben erklärt](#dockerfile), Ihre Abhängigkeiten installieren und **einen einzelnen Uvicorn-Prozess** ausführen, anstatt mehrere Uvicorn-Worker zu verwenden. diff --git a/docs/de/docs/deployment/https.md b/docs/de/docs/deployment/https.md index c8e11fd10..e52800323 100644 --- a/docs/de/docs/deployment/https.md +++ b/docs/de/docs/deployment/https.md @@ -34,7 +34,7 @@ Aus **Sicht des Entwicklers** sollten Sie beim Nachdenken über HTTPS Folgendes * **Nachdem** eine sichere Verbindung hergestellt wurde, ist das Kommunikationsprotokoll **immer noch HTTP**. * Die Inhalte sind **verschlüsselt**, auch wenn sie mit dem **HTTP-Protokoll** gesendet werden. -Es ist eine gängige Praxis, **ein Programm/HTTP-Server** auf dem Server (der Maschine, dem Host usw.) laufen zu lassen, welches **alle HTTPS-Aspekte verwaltet**: Empfangen der **verschlüsselten HTTPS-Requests**, Senden der **entschlüsselten HTTP-Requests** an die eigentliche HTTP-Anwendung die auf demselben Server läuft (in diesem Fall die **FastAPI**-Anwendung), entgegennehmen der **HTTP-Response** von der Anwendung, **verschlüsseln derselben** mithilfe des entsprechenden **HTTPS-Zertifikats** und Zurücksenden zum Client über **HTTPS**. Dieser Server wird oft als **TLS-Terminierungsproxy** bezeichnet. +Es ist eine gängige Praxis, **ein Programm/HTTP-Server** auf dem Server (der Maschine, dem Host usw.) laufen zu lassen, welches **alle HTTPS-Aspekte verwaltet**: Empfangen der **verschlüsselten HTTPS-Requests**, Senden der **entschlüsselten HTTP-Requests** an die eigentliche HTTP-Anwendung die auf demselben Server läuft (in diesem Fall die **FastAPI**-Anwendung), entgegennehmen der **HTTP-Response** von der Anwendung, **verschlüsseln derselben** mithilfe des entsprechenden **HTTPS-Zertifikats** und Zurücksenden zum Client über **HTTPS**. Dieser Server wird oft als **TLS-Terminierungsproxy** bezeichnet. Einige der Optionen, die Sie als TLS-Terminierungsproxy verwenden können, sind: diff --git a/docs/de/docs/deployment/server-workers.md b/docs/de/docs/deployment/server-workers.md index 527068190..169ed822b 100644 --- a/docs/de/docs/deployment/server-workers.md +++ b/docs/de/docs/deployment/server-workers.md @@ -11,7 +11,7 @@ Schauen wir uns die Deployment-Konzepte von früher noch einmal an: Bis zu diesem Punkt, in allen Tutorials in der Dokumentation, haben Sie wahrscheinlich ein **Serverprogramm** ausgeführt, zum Beispiel mit dem `fastapi`-Befehl, der Uvicorn startet, und einen **einzelnen Prozess** ausführt. -Wenn Sie Anwendungen bereitstellen, möchten Sie wahrscheinlich eine gewisse **Replikation von Prozessen**, um **mehrere Kerne** zu nutzen und mehr Requests bearbeiten zu können. +Wenn Sie Anwendungen bereitstellen, möchten Sie wahrscheinlich eine gewisse **Replikation von Prozessen**, um **mehrere Kerne** zu nutzen und mehr Requests bearbeiten zu können. Wie Sie im vorherigen Kapitel über [Deployment-Konzepte](concepts.md){.internal-link target=_blank} gesehen haben, gibt es mehrere Strategien, die Sie anwenden können. diff --git a/docs/de/docs/features.md b/docs/de/docs/features.md index 11cec583f..bd222984e 100644 --- a/docs/de/docs/features.md +++ b/docs/de/docs/features.md @@ -6,7 +6,7 @@ ### Basiert auf offenen Standards { #based-on-open-standards } -* OpenAPI für die Erstellung von APIs, inklusive Deklarationen von Pfad-Operationen, Parametern, Requestbodys, Sicherheit, usw. +* OpenAPI für die Erstellung von APIs, inklusive Deklarationen von Pfad-Operationen, Parametern, Requestbodys, Sicherheit, usw. * Automatische Dokumentation der Datenmodelle mit JSON Schema (da OpenAPI selbst auf JSON Schema basiert). * Um diese Standards herum entworfen, nach sorgfältigem Studium. Statt einer nachträglichen Schicht darüber. * Dies ermöglicht auch automatische **Client-Code-Generierung** in vielen Sprachen. @@ -91,7 +91,7 @@ So kann Ihr Editor Sie unterstützen: ![Editor Unterstützung](https://fastapi.tiangolo.com/img/pycharm-completion.png) -Sie bekommen sogar Autovervollständigung an Stellen, an denen Sie dies vorher nicht für möglich gehalten hätten. Zum Beispiel der `price` Schlüssel in einem JSON Datensatz (dieser könnte auch verschachtelt sein), der aus einer Anfrage kommt. +Sie bekommen sogar Autovervollständigung an Stellen, an denen Sie dies vorher nicht für möglich gehalten hätten. Zum Beispiel der `price` Schlüssel in einem JSON Datensatz (dieser könnte auch verschachtelt sein), der aus einem Request kommt. Nie wieder falsche Schlüsselnamen tippen, Hin und Herhüpfen zwischen der Dokumentation, Hoch- und Runterscrollen, um herauszufinden, ob es `username` oder `user_name` war. @@ -140,7 +140,7 @@ FastAPI enthält ein extrem einfach zu verwendendes, aber extrem mächtiges ORMs, ODMs für Datenbanken. -Daher können Sie in vielen Fällen das Objekt einer Anfrage **direkt zur Datenbank** schicken, weil alles automatisch validiert wird. +Daher können Sie in vielen Fällen das Objekt eines Requests **direkt zur Datenbank** schicken, weil alles automatisch validiert wird. Das gleiche gilt auch für die andere Richtung: Sie können in vielen Fällen das Objekt aus der Datenbank **direkt zum Client** senden. diff --git a/docs/de/docs/how-to/conditional-openapi.md b/docs/de/docs/how-to/conditional-openapi.md index a58351cf9..e174e456b 100644 --- a/docs/de/docs/how-to/conditional-openapi.md +++ b/docs/de/docs/how-to/conditional-openapi.md @@ -14,7 +14,7 @@ Das Verstecken der Dokumentation macht es nur schwieriger zu verstehen, wie mit Wenn Sie Ihre API sichern möchten, gibt es mehrere bessere Dinge, die Sie tun können, zum Beispiel: -* Stellen Sie sicher, dass Sie über gut definierte Pydantic-Modelle für Ihre Requestbodys und Responses verfügen. +* Stellen Sie sicher, dass Sie über gut definierte Pydantic-Modelle für Ihre Requestbodys und Responses verfügen. * Konfigurieren Sie alle erforderlichen Berechtigungen und Rollen mithilfe von Abhängigkeiten. * Speichern Sie niemals Klartext-Passwörter, sondern nur Passwort-Hashes. * Implementieren und verwenden Sie gängige kryptografische Tools wie Passlib und JWT-Tokens, usw. diff --git a/docs/de/docs/how-to/custom-request-and-route.md b/docs/de/docs/how-to/custom-request-and-route.md index e49485f66..2dccbaba1 100644 --- a/docs/de/docs/how-to/custom-request-and-route.md +++ b/docs/de/docs/how-to/custom-request-and-route.md @@ -4,7 +4,7 @@ In einigen Fällen möchten Sie möglicherweise die von den Klassen `Request` un Das kann insbesondere eine gute Alternative zur Logik in einer Middleware sein. -Wenn Sie beispielsweise den Requestbody lesen oder manipulieren möchten, bevor er von Ihrer Anwendung verarbeitet wird. +Wenn Sie beispielsweise den Requestbody lesen oder manipulieren möchten, bevor er von Ihrer Anwendung verarbeitet wird. /// danger | Gefahr diff --git a/docs/de/docs/how-to/extending-openapi.md b/docs/de/docs/how-to/extending-openapi.md index ffbbc338f..be85b8cd5 100644 --- a/docs/de/docs/how-to/extending-openapi.md +++ b/docs/de/docs/how-to/extending-openapi.md @@ -63,7 +63,7 @@ Sie können die Eigenschaft `.openapi_schema` als „Cache“ verwenden, um Ihr Auf diese Weise muss Ihre Anwendung das Schema nicht jedes Mal generieren, wenn ein Benutzer Ihre API-Dokumentation öffnet. -Es wird nur einmal generiert und dann wird dasselbe zwischengespeicherte Schema für die nächsten Requests verwendet. +Es wird nur einmal generiert und dann wird dasselbe zwischengespeicherte Schema für die nächsten Requests verwendet. {* ../../docs_src/extending_openapi/tutorial001.py hl[13:14,25:26] *} diff --git a/docs/de/docs/index.md b/docs/de/docs/index.md index 8603394df..a23ab6f6b 100644 --- a/docs/de/docs/index.md +++ b/docs/de/docs/index.md @@ -249,7 +249,7 @@ Sie sehen die JSON-Antwort als: Sie haben bereits eine API erstellt, welche: -* HTTP-Anfragen auf den _Pfaden_ `/` und `/items/{item_id}` entgegennimmt. +* HTTP-Requests auf den _Pfaden_ `/` und `/items/{item_id}` entgegennimmt. * Beide _Pfade_ erhalten `GET` Operationen (auch bekannt als HTTP _Methoden_). * Der _Pfad_ `/items/{item_id}` hat einen _Pfad-Parameter_ `item_id`, der ein `int` sein sollte. * Der _Pfad_ `/items/{item_id}` hat einen optionalen `str` _Query-Parameter_ `q`. @@ -272,7 +272,7 @@ Sie sehen die alternative automatische Dokumentation (bereitgestellt von Body einer `PUT`-Anfrage zu empfangen. +Ändern Sie jetzt die Datei `main.py`, um den Body eines `PUT`-Requests zu empfangen. Deklarieren Sie den Body mithilfe von Standard-Python-Typen, dank Pydantic. @@ -384,13 +384,13 @@ item: Item Um auf das vorherige Codebeispiel zurückzukommen, **FastAPI** wird: -* Überprüfen, dass es eine `item_id` im Pfad für `GET`- und `PUT`-Anfragen gibt. -* Überprüfen, ob die `item_id` vom Typ `int` für `GET`- und `PUT`-Anfragen ist. +* Überprüfen, dass es eine `item_id` im Pfad für `GET`- und `PUT`-Requests gibt. +* Überprüfen, ob die `item_id` vom Typ `int` für `GET`- und `PUT`-Requests ist. * Falls nicht, wird dem Client ein nützlicher, eindeutiger Fehler angezeigt. -* Prüfen, ob es einen optionalen Query-Parameter namens `q` (wie in `http://127.0.0.1:8000/items/foo?q=somequery`) für `GET`-Anfragen gibt. +* Prüfen, ob es einen optionalen Query-Parameter namens `q` (wie in `http://127.0.0.1:8000/items/foo?q=somequery`) für `GET`-Requests gibt. * Da der `q`-Parameter mit `= None` deklariert ist, ist er optional. * Ohne das `None` wäre er erforderlich (wie der Body im Fall von `PUT`). -* Bei `PUT`-Anfragen an `/items/{item_id}` den Body als JSON lesen: +* Bei `PUT`-Requests an `/items/{item_id}` den Body als JSON lesen: * Prüfen, ob er ein erforderliches Attribut `name` hat, das ein `str` sein muss. * Prüfen, ob er ein erforderliches Attribut `price` hat, das ein `float` sein muss. * Prüfen, ob er ein optionales Attribut `is_offer` hat, das ein `bool` sein muss, falls vorhanden. @@ -466,7 +466,7 @@ Wird von Starlette verwendet: * httpx - erforderlich, wenn Sie den `TestClient` verwenden möchten. * jinja2 - erforderlich, wenn Sie die Standardkonfiguration für Templates verwenden möchten. -* python-multipart - erforderlich, wenn Sie Formulare mittels `request.form()` „parsen“ möchten. +* python-multipart - erforderlich, wenn Sie Formulare mittels `request.form()` „parsen“ möchten. Wird von FastAPI verwendet: diff --git a/docs/de/docs/python-types.md b/docs/de/docs/python-types.md index ac0eb4bd7..3b0f8fd3f 100644 --- a/docs/de/docs/python-types.md +++ b/docs/de/docs/python-types.md @@ -558,9 +558,9 @@ Mit **FastAPI** deklarieren Sie Parameter mit Typhinweisen, und Sie erhalten: ... und **FastAPI** verwendet dieselben Deklarationen, um: -* **Anforderungen** zu definieren: aus Anfrage-Pfadparametern, Abfrageparametern, Header-Feldern, Bodys, Abhängigkeiten, usw. -* **Daten umzuwandeln**: aus der Anfrage in den erforderlichen Typ. -* **Daten zu validieren**: aus jeder Anfrage: +* **Anforderungen** zu definieren: aus Request-Pfadparametern, Abfrageparametern, Header-Feldern, Bodys, Abhängigkeiten, usw. +* **Daten umzuwandeln**: aus dem Request in den erforderlichen Typ. +* **Daten zu validieren**: aus jedem Request: * **Automatische Fehler** generieren, die an den Client zurückgegeben werden, wenn die Daten ungültig sind. * Die API mit OpenAPI zu **dokumentieren**: * Die dann von den Benutzeroberflächen der automatisch generierten interaktiven Dokumentation verwendet wird. diff --git a/docs/de/docs/tutorial/background-tasks.md b/docs/de/docs/tutorial/background-tasks.md index facd4f6f8..982d6f4a9 100644 --- a/docs/de/docs/tutorial/background-tasks.md +++ b/docs/de/docs/tutorial/background-tasks.md @@ -2,7 +2,7 @@ Sie können Hintergrundtasks definieren, die *nach* der Rückgabe einer Response ausgeführt werden sollen. -Das ist nützlich für Vorgänge, die nach einem Request ausgeführt werden müssen, bei denen der Client jedoch nicht unbedingt auf den Abschluss des Vorgangs warten muss, bevor er die Response erhält. +Das ist nützlich für Vorgänge, die nach einem Request ausgeführt werden müssen, bei denen der Client jedoch nicht unbedingt auf den Abschluss des Vorgangs warten muss, bevor er die Response erhält. Hierzu zählen beispielsweise: diff --git a/docs/de/docs/tutorial/bigger-applications.md b/docs/de/docs/tutorial/bigger-applications.md index e7ea1b195..7e996938b 100644 --- a/docs/de/docs/tutorial/bigger-applications.md +++ b/docs/de/docs/tutorial/bigger-applications.md @@ -199,7 +199,7 @@ Das Präfix lautet in diesem Fall also `/items`. Wir können auch eine Liste von `tags` und zusätzliche `responses` hinzufügen, die auf alle in diesem Router enthaltenen *Pfadoperationen* angewendet werden. -Und wir können eine Liste von `dependencies` hinzufügen, die allen *Pfadoperationen* im Router hinzugefügt und für jeden an sie gerichteten Request ausgeführt/aufgelöst werden. +Und wir können eine Liste von `dependencies` hinzufügen, die allen *Pfadoperationen* im Router hinzugefügt und für jeden an sie gerichteten Request ausgeführt/aufgelöst werden. /// tip | Tipp diff --git a/docs/de/docs/tutorial/body-multiple-params.md b/docs/de/docs/tutorial/body-multiple-params.md index 968daa03e..3b5fa52dd 100644 --- a/docs/de/docs/tutorial/body-multiple-params.md +++ b/docs/de/docs/tutorial/body-multiple-params.md @@ -1,6 +1,6 @@ # Body – Mehrere Parameter { #body-multiple-parameters } -Nun, da wir gesehen haben, wie `Path` und `Query` verwendet werden, schauen wir uns fortgeschrittenere Verwendungsmöglichkeiten von Requestbody-Deklarationen an. +Nun, da wir gesehen haben, wie `Path` und `Query` verwendet werden, schauen wir uns fortgeschrittenere Verwendungsmöglichkeiten von Requestbody-Deklarationen an. ## `Path`-, `Query`- und Body-Parameter vermischen { #mix-path-query-and-body-parameters } diff --git a/docs/de/docs/tutorial/body-nested-models.md b/docs/de/docs/tutorial/body-nested-models.md index 18d1c1f50..324d31928 100644 --- a/docs/de/docs/tutorial/body-nested-models.md +++ b/docs/de/docs/tutorial/body-nested-models.md @@ -61,7 +61,7 @@ Deklarieren wir also `tags` als Set von Strings. {* ../../docs_src/body_nested_models/tutorial003_py310.py hl[12] *} -Jetzt, selbst wenn Sie einen Request mit duplizierten Daten erhalten, werden diese zu einem Set eindeutiger Dinge konvertiert. +Jetzt, selbst wenn Sie einen Request mit duplizierten Daten erhalten, werden diese zu einem Set eindeutiger Dinge konvertiert. Und wann immer Sie diese Daten ausgeben, selbst wenn die Quelle Duplikate hatte, wird es als Set von eindeutigen Dingen ausgegeben. diff --git a/docs/de/docs/tutorial/body-updates.md b/docs/de/docs/tutorial/body-updates.md index d106d01b3..50b46098c 100644 --- a/docs/de/docs/tutorial/body-updates.md +++ b/docs/de/docs/tutorial/body-updates.md @@ -60,7 +60,7 @@ Die Beispiele hier verwenden `.dict()` für die Kompatibilität mit Pydantic v1, Das wird ein `dict` erstellen, mit nur den Daten, die gesetzt wurden, als das `item`-Modell erstellt wurde, Defaultwerte ausgeschlossen. -Sie können das verwenden, um ein `dict` zu erstellen, das nur die (im Request) gesendeten Daten enthält, ohne Defaultwerte: +Sie können das verwenden, um ein `dict` zu erstellen, das nur die (im Request) gesendeten Daten enthält, ohne Defaultwerte: {* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *} diff --git a/docs/de/docs/tutorial/body.md b/docs/de/docs/tutorial/body.md index 9fc288f4e..474e69b3d 100644 --- a/docs/de/docs/tutorial/body.md +++ b/docs/de/docs/tutorial/body.md @@ -1,8 +1,8 @@ # Requestbody { #request-body } -Wenn Sie Daten von einem Client (sagen wir, einem Browser) zu Ihrer API senden müssen, senden Sie sie als **Requestbody**. +Wenn Sie Daten von einem Client (sagen wir, einem Browser) zu Ihrer API senden müssen, senden Sie sie als **Requestbody**. -Ein **Request**body sind Daten, die vom Client zu Ihrer API gesendet werden. Ein **Response**body sind Daten, die Ihre API zum Client sendet. +Ein **Request**body sind Daten, die vom Client zu Ihrer API gesendet werden. Ein **Response**body sind Daten, die Ihre API zum Client sendet. Ihre API muss fast immer einen **Response**body senden. Aber Clients müssen nicht unbedingt immer **Requestbodys** senden, manchmal fordern sie nur einen Pfad an, vielleicht mit einigen Query-Parametern, aber senden keinen Body. diff --git a/docs/de/docs/tutorial/cookie-param-models.md b/docs/de/docs/tutorial/cookie-param-models.md index e6a7909d6..3b29020cf 100644 --- a/docs/de/docs/tutorial/cookie-param-models.md +++ b/docs/de/docs/tutorial/cookie-param-models.md @@ -22,7 +22,7 @@ Deklarieren Sie die **Cookie**-Parameter, die Sie benötigen, in einem **Pydanti {* ../../docs_src/cookie_param_models/tutorial001_an_py310.py hl[9:12,16] *} -**FastAPI** wird die Daten für **jedes Feld** aus den im Request empfangenen **Cookies** **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell bereitstellen. +**FastAPI** wird die Daten für **jedes Feld** aus den im Request empfangenen **Cookies** **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell bereitstellen. ## Die Dokumentation testen { #check-the-docs } diff --git a/docs/de/docs/tutorial/cors.md b/docs/de/docs/tutorial/cors.md index eff756250..692308edc 100644 --- a/docs/de/docs/tutorial/cors.md +++ b/docs/de/docs/tutorial/cors.md @@ -18,7 +18,7 @@ Auch wenn sie alle in `localhost` sind, verwenden sie unterschiedliche Protokoll Angenommen, Sie haben ein Frontend, das in Ihrem Browser unter `http://localhost:8080` läuft, und dessen JavaScript versucht, mit einem Backend zu kommunizieren, das unter `http://localhost` läuft (da wir keinen Port angegeben haben, geht der Browser vom Default-Port `80` aus). -Dann wird der Browser ein HTTP-`OPTIONS`-Request an das `:80`-Backend senden, und wenn das Backend die entsprechenden Header sendet, die die Kommunikation von diesem anderen Origin (`http://localhost:8080`) autorisieren, lässt der `:8080`-Browser das JavaScript im Frontend seinen Request an das `:80`-Backend senden. +Dann wird der Browser ein HTTP-`OPTIONS`-Request an das `:80`-Backend senden, und wenn das Backend die entsprechenden Header sendet, die die Kommunikation von diesem anderen Origin (`http://localhost:8080`) autorisieren, lässt der `:8080`-Browser das JavaScript im Frontend seinen Request an das `:80`-Backend senden. Um dies zu erreichen, muss das `:80`-Backend eine Liste von „erlaubten Origins“ haben. diff --git a/docs/de/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md b/docs/de/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md index f04d0a9a8..59c9fcf48 100644 --- a/docs/de/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md +++ b/docs/de/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md @@ -42,7 +42,7 @@ Sie können dieselben Abhängigkeits-*Funktionen* verwenden, die Sie normalerwei ### Abhängigkeitsanforderungen { #dependency-requirements } -Sie können Anforderungen für einen Request (wie Header) oder andere Unterabhängigkeiten deklarieren: +Sie können Anforderungen für einen Request (wie Header) oder andere Unterabhängigkeiten deklarieren: {* ../../docs_src/dependencies/tutorial006_an_py39.py hl[8,13] *} diff --git a/docs/de/docs/tutorial/dependencies/index.md b/docs/de/docs/tutorial/dependencies/index.md index fcdae27a5..40fb92c6b 100644 --- a/docs/de/docs/tutorial/dependencies/index.md +++ b/docs/de/docs/tutorial/dependencies/index.md @@ -86,7 +86,7 @@ Im nächsten Kapitel erfahren Sie, welche anderen „Dinge“, außer Funktionen /// -Immer wenn ein neuer Request eintrifft, kümmert sich **FastAPI** darum: +Immer wenn ein neuer Request eintrifft, kümmert sich **FastAPI** darum: * Ihre Abhängigkeitsfunktion („Dependable“) mit den richtigen Parametern aufzurufen. * Sich das Ergebnis von dieser Funktion zu holen. @@ -165,7 +165,7 @@ Die interaktive Dokumentation enthält also auch alle Informationen aus diesen A ## Einfache Verwendung { #simple-usage } -Näher betrachtet, werden *Pfadoperation-Funktionen* deklariert, um verwendet zu werden, wann immer ein *Pfad* und eine *Operation* übereinstimmen, und dann kümmert sich **FastAPI** darum, die Funktion mit den richtigen Parametern aufzurufen, die Daten aus der Anfrage extrahierend. +Näher betrachtet, werden *Pfadoperation-Funktionen* deklariert, um verwendet zu werden, wann immer ein *Pfad* und eine *Operation* übereinstimmen, und dann kümmert sich **FastAPI** darum, die Funktion mit den richtigen Parametern aufzurufen, die Daten aus dem Request extrahierend. Tatsächlich funktionieren alle (oder die meisten) Webframeworks auf die gleiche Weise. diff --git a/docs/de/docs/tutorial/dependencies/sub-dependencies.md b/docs/de/docs/tutorial/dependencies/sub-dependencies.md index e2552be64..061952f92 100644 --- a/docs/de/docs/tutorial/dependencies/sub-dependencies.md +++ b/docs/de/docs/tutorial/dependencies/sub-dependencies.md @@ -56,7 +56,7 @@ query_extractor --> query_or_cookie_extractor --> read_query ## Dieselbe Abhängigkeit mehrmals verwenden { #using-the-same-dependency-multiple-times } -Wenn eine Ihrer Abhängigkeiten mehrmals für dieselbe *Pfadoperation* deklariert wird, beispielsweise wenn mehrere Abhängigkeiten eine gemeinsame Unterabhängigkeit haben, wird **FastAPI** diese Unterabhängigkeit nur einmal pro Request aufrufen. +Wenn eine Ihrer Abhängigkeiten mehrmals für dieselbe *Pfadoperation* deklariert wird, beispielsweise wenn mehrere Abhängigkeiten eine gemeinsame Unterabhängigkeit haben, wird **FastAPI** diese Unterabhängigkeit nur einmal pro Request aufrufen. Und es speichert den zurückgegebenen Wert in einem „Cache“ und übergibt diesen gecachten Wert an alle „Dependanten“, die ihn in diesem spezifischen Request benötigen, anstatt die Abhängigkeit mehrmals für denselben Request aufzurufen. diff --git a/docs/de/docs/tutorial/extra-data-types.md b/docs/de/docs/tutorial/extra-data-types.md index 9f01000a6..e81eb9470 100644 --- a/docs/de/docs/tutorial/extra-data-types.md +++ b/docs/de/docs/tutorial/extra-data-types.md @@ -12,7 +12,7 @@ Sie können aber auch komplexere Datentypen verwenden. Und Sie haben immer noch dieselbe Funktionalität wie bisher gesehen: * Großartige Editor-Unterstützung. -* Datenkonvertierung bei eingehenden Requests. +* Datenkonvertierung bei eingehenden Requests. * Datenkonvertierung für Response-Daten. * Datenvalidierung. * Automatische Annotation und Dokumentation. diff --git a/docs/de/docs/tutorial/first-steps.md b/docs/de/docs/tutorial/first-steps.md index b20da78df..cf00a0c4d 100644 --- a/docs/de/docs/tutorial/first-steps.md +++ b/docs/de/docs/tutorial/first-steps.md @@ -232,7 +232,7 @@ Wir werden sie auch „**Operationen**“ nennen. {* ../../docs_src/first_steps/tutorial001.py hl[6] *} -Das `@app.get("/")` sagt **FastAPI**, dass die Funktion direkt darunter für die Bearbeitung von Anfragen zuständig ist, die an: +Das `@app.get("/")` sagt **FastAPI**, dass die Funktion direkt darunter für die Bearbeitung von Requests zuständig ist, die an: * den Pfad `/` * unter der Verwendung der get-Operation gehen @@ -288,7 +288,7 @@ Das ist unsere „**Pfadoperation-Funktion**“: Dies ist eine Python-Funktion. -Sie wird von **FastAPI** immer dann aufgerufen, wenn sie eine Anfrage an die URL „`/`“ mittels einer `GET`-Operation erhält. +Sie wird von **FastAPI** immer dann aufgerufen, wenn sie einen Request an die URL „`/`“ mittels einer `GET`-Operation erhält. In diesem Fall handelt es sich um eine `async`-Funktion. diff --git a/docs/de/docs/tutorial/handling-errors.md b/docs/de/docs/tutorial/handling-errors.md index 4fc9ac57a..f42614307 100644 --- a/docs/de/docs/tutorial/handling-errors.md +++ b/docs/de/docs/tutorial/handling-errors.md @@ -13,7 +13,7 @@ Sie könnten dem Client mitteilen müssen, dass: In diesen Fällen würden Sie normalerweise einen **HTTP-Statuscode** im Bereich **400** (von 400 bis 499) zurückgeben. -Dies ist vergleichbar mit den HTTP-Statuscodes im Bereich 200 (von 200 bis 299). Diese „200“-Statuscodes bedeuten, dass die Anfrage in irgendeiner Weise erfolgreich war. +Dies ist vergleichbar mit den HTTP-Statuscodes im Bereich 200 (von 200 bis 299). Diese „200“-Statuscodes bedeuten, dass der Request in irgendeiner Weise erfolgreich war. Die Statuscodes im Bereich 400 bedeuten hingegen, dass es einen Fehler seitens des Clients gab. @@ -33,7 +33,7 @@ Um HTTP-Responses mit Fehlern an den Client zurückzugeben, verwenden Sie `HTTPE Weil es eine Python-Exception ist, geben Sie sie nicht zurück (`return`), sondern lösen sie aus (`raise`). -Das bedeutet auch, wenn Sie sich innerhalb einer Hilfsfunktion befinden, die Sie innerhalb Ihrer *Pfadoperation-Funktion* aufrufen, und Sie die `HTTPException` aus dieser Hilfsfunktion heraus auslösen, wird der restliche Code in der *Pfadoperation-Funktion* nicht ausgeführt. Die Anfrage wird sofort abgebrochen und der HTTP-Error der `HTTPException` wird an den Client gesendet. +Das bedeutet auch, wenn Sie sich innerhalb einer Hilfsfunktion befinden, die Sie innerhalb Ihrer *Pfadoperation-Funktion* aufrufen, und Sie die `HTTPException` aus dieser Hilfsfunktion heraus auslösen, wird der restliche Code in der *Pfadoperation-Funktion* nicht ausgeführt. Der Request wird sofort abgebrochen und der HTTP-Error der `HTTPException` wird an den Client gesendet. Der Vorteil des Auslösens einer Exception gegenüber dem Zurückgeben eines Wertes wird im Abschnitt über Abhängigkeiten und Sicherheit deutlicher werden. diff --git a/docs/de/docs/tutorial/header-param-models.md b/docs/de/docs/tutorial/header-param-models.md index dab65cdb6..20d9121b9 100644 --- a/docs/de/docs/tutorial/header-param-models.md +++ b/docs/de/docs/tutorial/header-param-models.md @@ -16,7 +16,7 @@ Deklarieren Sie die erforderlichen **Header-Parameter** in einem **Pydantic-Mode {* ../../docs_src/header_param_models/tutorial001_an_py310.py hl[9:14,18] *} -**FastAPI** wird die Daten für **jedes Feld** aus den **Headern** des Requests extrahieren und Ihnen das von Ihnen definierte Pydantic-Modell geben. +**FastAPI** wird die Daten für **jedes Feld** aus den **Headern** des Request extrahieren und Ihnen das von Ihnen definierte Pydantic-Modell geben. ## Die Dokumentation testen { #check-the-docs } diff --git a/docs/de/docs/tutorial/middleware.md b/docs/de/docs/tutorial/middleware.md index 96bf10120..1bddf9157 100644 --- a/docs/de/docs/tutorial/middleware.md +++ b/docs/de/docs/tutorial/middleware.md @@ -2,7 +2,7 @@ Sie können Middleware zu **FastAPI**-Anwendungen hinzufügen. -Eine „Middleware“ ist eine Funktion, die mit jedem **Request** arbeitet, bevor er von einer bestimmten *Pfadoperation* verarbeitet wird. Und auch mit jeder **Response**, bevor sie zurückgegeben wird. +Eine „Middleware“ ist eine Funktion, die mit jedem **Request** arbeitet, bevor er von einer bestimmten *Pfadoperation* verarbeitet wird. Und auch mit jeder **Response**, bevor sie zurückgegeben wird. * Sie nimmt jeden **Request** entgegen, der an Ihre Anwendung gesendet wird. * Sie kann dann etwas mit diesem **Request** tun oder beliebigen Code ausführen. @@ -69,9 +69,9 @@ Hier verwenden wir „parsen“. +Sprich, mit dieser Typdeklaration wird **FastAPI** den Request automatisch „parsen“. /// @@ -249,7 +249,7 @@ In dem Fall wäre die URL: `/files//home/johndoe/myfile.txt`, mit einem doppelte In **FastAPI** erhalten Sie mittels kurzer, intuitiver Typdeklarationen: * Editor-Unterstützung: Fehlerprüfungen, Codevervollständigung, usw. -* Daten "parsen" +* Daten "parsen" * Datenvalidierung * API-Annotationen und automatische Dokumentation diff --git a/docs/de/docs/tutorial/query-param-models.md b/docs/de/docs/tutorial/query-param-models.md index 2c6f59da6..938fe5733 100644 --- a/docs/de/docs/tutorial/query-param-models.md +++ b/docs/de/docs/tutorial/query-param-models.md @@ -16,7 +16,7 @@ Deklarieren Sie die benötigten **Query-Parameter** in einem **Pydantic-Modell** {* ../../docs_src/query_param_models/tutorial001_an_py310.py hl[9:13,17] *} -**FastAPI** wird die Daten für **jedes Feld** aus den **Query-Parametern** der Anfrage extrahieren und Ihnen das definierte Pydantic-Modell bereitstellen. +**FastAPI** wird die Daten für **jedes Feld** aus den **Query-Parametern** des Request extrahieren und Ihnen das definierte Pydantic-Modell bereitstellen. ## Die Dokumentation testen { #check-the-docs } diff --git a/docs/de/docs/tutorial/query-params-str-validations.md b/docs/de/docs/tutorial/query-params-str-validations.md index 09a03666f..6223d251c 100644 --- a/docs/de/docs/tutorial/query-params-str-validations.md +++ b/docs/de/docs/tutorial/query-params-str-validations.md @@ -294,7 +294,7 @@ So wäre die Response zu dieser URL: /// tip | Tipp -Um einen Query-Parameter mit einem Typ `list` zu deklarieren, wie im obigen Beispiel, müssen Sie explizit `Query` verwenden, da er andernfalls als Requestbody interpretiert würde. +Um einen Query-Parameter mit einem Typ `list` zu deklarieren, wie im obigen Beispiel, müssen Sie explizit `Query` verwenden, da er andernfalls als Requestbody interpretiert würde. /// @@ -429,7 +429,7 @@ Dies ist verfügbar seit Pydantic Version 2 oder höher. 😎 Wenn Sie irgendeine Art von Validierung durchführen müssen, die eine Kommunikation mit einer **externen Komponente** erfordert, wie z. B. einer Datenbank oder einer anderen API, sollten Sie stattdessen **FastAPI-Abhängigkeiten** verwenden. Sie werden diese später kennenlernen. -Diese benutzerdefinierten Validatoren sind für Dinge gedacht, die einfach mit denselben **Daten** überprüft werden können, die in der Anfrage bereitgestellt werden. +Diese benutzerdefinierten Validatoren sind für Dinge gedacht, die einfach mit denselben **Daten** überprüft werden können, die im Request bereitgestellt werden. /// diff --git a/docs/de/docs/tutorial/query-params.md b/docs/de/docs/tutorial/query-params.md index ae5d92603..230cba069 100644 --- a/docs/de/docs/tutorial/query-params.md +++ b/docs/de/docs/tutorial/query-params.md @@ -24,7 +24,7 @@ Aber wenn Sie sie mit Python-Typen deklarieren (im obigen Beispiel als `int`), w Die gleichen Prozesse, die für Pfad-Parameter gelten, werden auch auf Query-Parameter angewendet: * Editor Unterstützung (natürlich) -* Daten-„Parsen“ +* Daten-„Parsen“ * Datenvalidierung * Automatische Dokumentation diff --git a/docs/de/docs/tutorial/request-files.md b/docs/de/docs/tutorial/request-files.md index 508f812b1..e77d6debc 100644 --- a/docs/de/docs/tutorial/request-files.md +++ b/docs/de/docs/tutorial/request-files.md @@ -127,7 +127,7 @@ Wenn Sie mehr über diese Kodierungen und Formularfelder lesen möchten, besuche /// warning | Achtung -Sie können mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `multipart/form-data` statt `application/json` kodiert. +Sie können mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `multipart/form-data` statt `application/json` kodiert. Das ist keine Limitation von **FastAPI**, sondern Teil des HTTP-Protokolls. diff --git a/docs/de/docs/tutorial/request-form-models.md b/docs/de/docs/tutorial/request-form-models.md index 41b0e17a2..0922b020c 100644 --- a/docs/de/docs/tutorial/request-form-models.md +++ b/docs/de/docs/tutorial/request-form-models.md @@ -26,7 +26,7 @@ Sie müssen nur ein **Pydantic-Modell** mit den Feldern deklarieren, die Sie als {* ../../docs_src/request_form_models/tutorial001_an_py39.py hl[9:11,15] *} -**FastAPI** wird die Daten für **jedes Feld** aus den **Formulardaten** in der Anfrage **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell übergeben. +**FastAPI** wird die Daten für **jedes Feld** aus den **Formulardaten** im Request **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell übergeben. ## Die Dokumentation testen { #check-the-docs } diff --git a/docs/de/docs/tutorial/request-forms-and-files.md b/docs/de/docs/tutorial/request-forms-and-files.md index ce7d46801..cda38bcc2 100644 --- a/docs/de/docs/tutorial/request-forms-and-files.md +++ b/docs/de/docs/tutorial/request-forms-and-files.md @@ -30,7 +30,7 @@ Und Sie können einige der Dateien als `bytes` und einige als `UploadFile` dekla /// warning | Achtung -Sie können mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht auch `Body`-Felder deklarieren, die Sie als JSON erwarten, da der Body des Requests mittels `multipart/form-data` statt `application/json` kodiert sein wird. +Sie können mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht auch `Body`-Felder deklarieren, die Sie als JSON erwarten, da der Body des Request mittels `multipart/form-data` statt `application/json` kodiert sein wird. Das ist keine Limitation von **FastAPI**, sondern Teil des HTTP-Protokolls. diff --git a/docs/de/docs/tutorial/request-forms.md b/docs/de/docs/tutorial/request-forms.md index a7c1019fc..cbac9f045 100644 --- a/docs/de/docs/tutorial/request-forms.md +++ b/docs/de/docs/tutorial/request-forms.md @@ -62,7 +62,7 @@ Wenn Sie mehr über Formularfelder und ihre Kodierungen lesen möchten, besuchen /// warning | Achtung -Sie können mehrere `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `application/x-www-form-urlencoded` statt `application/json` kodiert. +Sie können mehrere `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `application/x-www-form-urlencoded` statt `application/json` kodiert. Das ist keine Limitation von **FastAPI**, sondern Teil des HTTP-Protokolls. diff --git a/docs/de/docs/tutorial/security/first-steps.md b/docs/de/docs/tutorial/security/first-steps.md index fc810a4dc..b05c8d650 100644 --- a/docs/de/docs/tutorial/security/first-steps.md +++ b/docs/de/docs/tutorial/security/first-steps.md @@ -188,7 +188,7 @@ Alle Sicherheits-Werkzeuge, die in OpenAPI integriert sind (und die automatische ## Was es macht { #what-it-does } -FastAPI wird im Request nach diesem `Authorization`-Header suchen, prüfen, ob der Wert `Bearer` plus ein Token ist, und den Token als `str` zurückgeben. +FastAPI wird im Request nach diesem `Authorization`-Header suchen, prüfen, ob der Wert `Bearer` plus ein Token ist, und den Token als `str` zurückgeben. Wenn es keinen `Authorization`-Header sieht, oder der Wert keinen `Bearer`-Token hat, antwortet es direkt mit einem 401-Statuscode-Error (`UNAUTHORIZED`). diff --git a/docs/de/docs/tutorial/security/get-current-user.md b/docs/de/docs/tutorial/security/get-current-user.md index 5b5675c43..e32e36669 100644 --- a/docs/de/docs/tutorial/security/get-current-user.md +++ b/docs/de/docs/tutorial/security/get-current-user.md @@ -46,7 +46,7 @@ Das wird uns innerhalb der Funktion bei Codevervollständigung und Typprüfungen /// tip | Tipp -Sie erinnern sich vielleicht, dass Requestbodys ebenfalls mit Pydantic-Modellen deklariert werden. +Sie erinnern sich vielleicht, dass Requestbodys ebenfalls mit Pydantic-Modellen deklariert werden. Weil Sie `Depends` verwenden, wird **FastAPI** hier aber nicht verwirrt. diff --git a/docs/de/docs/tutorial/security/oauth2-jwt.md b/docs/de/docs/tutorial/security/oauth2-jwt.md index e4047af04..38d94904b 100644 --- a/docs/de/docs/tutorial/security/oauth2-jwt.md +++ b/docs/de/docs/tutorial/security/oauth2-jwt.md @@ -230,7 +230,7 @@ Rufen Sie den Endpunkt `/users/me/` auf, Sie erhalten die Response: -Wenn Sie die Developer Tools öffnen, können Sie sehen, dass die gesendeten Daten nur den Token enthalten. Das Passwort wird nur bei der ersten Anfrage gesendet, um den Benutzer zu authentisieren und diesen Zugriffstoken zu erhalten, aber nicht mehr danach: +Wenn Sie die Developer Tools öffnen, können Sie sehen, dass die gesendeten Daten nur den Token enthalten. Das Passwort wird nur beim ersten Request gesendet, um den Benutzer zu authentisieren und diesen Zugriffstoken zu erhalten, aber nicht mehr danach: diff --git a/docs/de/docs/tutorial/sql-databases.md b/docs/de/docs/tutorial/sql-databases.md index 5cd0a6f84..080d97ea1 100644 --- a/docs/de/docs/tutorial/sql-databases.md +++ b/docs/de/docs/tutorial/sql-databases.md @@ -79,9 +79,9 @@ Sie hätten **ein einziges `engine`-Objekt** für Ihren gesamten Code, um sich m {* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[14:18] hl[14:15,17:18] *} -Die Verwendung von `check_same_thread=False` erlaubt FastAPI, dieselbe SQLite-Datenbank in verschiedenen Threads zu verwenden. Dies ist notwendig, da **eine einzelne Anfrage** **mehr als einen Thread** verwenden könnte (zum Beispiel in Abhängigkeiten). +Die Verwendung von `check_same_thread=False` erlaubt FastAPI, dieselbe SQLite-Datenbank in verschiedenen Threads zu verwenden. Dies ist notwendig, da **ein einzelner Request** **mehr als einen Thread** verwenden könnte (zum Beispiel in Abhängigkeiten). -Keine Sorge, so wie der Code strukturiert ist, werden wir später sicherstellen, dass wir **eine einzige SQLModel-*Session* pro Anfrage** verwenden, das ist eigentlich das, was `check_same_thread` erreichen möchte. +Keine Sorge, so wie der Code strukturiert ist, werden wir später sicherstellen, dass wir **eine einzige SQLModel-*Session* pro Request** verwenden, das ist eigentlich das, was `check_same_thread` erreichen möchte. ### Die Tabellen erstellen { #create-the-tables } @@ -93,7 +93,7 @@ Dann fügen wir eine Funktion hinzu, die `SQLModel.metadata.create_all(engine)` Eine **`Session`** speichert die **Objekte im Speicher** und verfolgt alle Änderungen, die an den Daten vorgenommen werden müssen, dann **verwendet sie die `engine`**, um mit der Datenbank zu kommunizieren. -Wir werden eine FastAPI **Abhängigkeit** mit `yield` erstellen, die eine neue `Session` für jede Anfrage bereitstellt. Das ist es, was sicherstellt, dass wir eine einzige Session pro Anfrage verwenden. 🤓 +Wir werden eine FastAPI **Abhängigkeit** mit `yield` erstellen, die eine neue `Session` für jeden Request bereitstellt. Das ist es, was sicherstellt, dass wir eine einzige Session pro Request verwenden. 🤓 Dann erstellen wir eine `Annotated`-Abhängigkeit `SessionDep`, um den Rest des Codes zu vereinfachen, der diese Abhängigkeit nutzen wird. diff --git a/docs/de/docs/tutorial/testing.md b/docs/de/docs/tutorial/testing.md index 10e07f525..752ff0e8c 100644 --- a/docs/de/docs/tutorial/testing.md +++ b/docs/de/docs/tutorial/testing.md @@ -52,7 +52,7 @@ Sie könnten auch `from starlette.testclient import TestClient` verwenden. /// tip | Tipp -Wenn Sie in Ihren Tests neben dem Senden von Anfragen an Ihre FastAPI-Anwendung auch `async`-Funktionen aufrufen möchten (z. B. asynchrone Datenbankfunktionen), werfen Sie einen Blick auf die [Async-Tests](../advanced/async-tests.md){.internal-link target=_blank} im Handbuch für fortgeschrittene Benutzer. +Wenn Sie in Ihren Tests neben dem Senden von Requests an Ihre FastAPI-Anwendung auch `async`-Funktionen aufrufen möchten (z. B. asynchrone Datenbankfunktionen), werfen Sie einen Blick auf die [Async-Tests](../advanced/async-tests.md){.internal-link target=_blank} im Handbuch für fortgeschrittene Benutzer. /// From 9cf1f8a19da1907c9756f401d13c9df0ab47f19d Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sat, 30 Aug 2025 22:48:38 +0200 Subject: [PATCH 155/160] Intermezzo: `Antwort` --> `Response` As previous commit --- docs/de/docs/advanced/additional-responses.md | 2 +- docs/de/docs/advanced/additional-status-codes.md | 2 +- docs/de/docs/advanced/behind-a-proxy.md | 4 ++-- docs/de/docs/advanced/custom-response.md | 2 +- docs/de/docs/advanced/dataclasses.md | 2 +- docs/de/docs/advanced/generate-clients.md | 2 +- docs/de/docs/advanced/middleware.md | 4 ++-- docs/de/docs/advanced/openapi-callbacks.md | 2 +- .../de/docs/advanced/path-operation-advanced-configuration.md | 2 +- docs/de/docs/advanced/response-change-status-code.md | 2 +- docs/de/docs/advanced/response-cookies.md | 2 +- docs/de/docs/advanced/response-directly.md | 2 +- docs/de/docs/advanced/response-headers.md | 2 +- docs/de/docs/advanced/security/http-basic-auth.md | 2 +- docs/de/docs/advanced/templates.md | 2 +- docs/de/docs/advanced/wsgi.md | 2 +- docs/de/docs/alternatives.md | 2 +- docs/de/docs/async.md | 2 +- docs/de/docs/deployment/concepts.md | 2 +- docs/de/docs/features.md | 2 +- docs/de/docs/how-to/conditional-openapi.md | 2 +- docs/de/docs/how-to/custom-request-and-route.md | 2 +- docs/de/docs/how-to/extending-openapi.md | 2 +- docs/de/docs/how-to/separate-openapi-schemas.md | 2 +- docs/de/docs/index.md | 2 +- docs/de/docs/tutorial/background-tasks.md | 2 +- docs/de/docs/tutorial/bigger-applications.md | 2 +- docs/de/docs/tutorial/cookie-param-models.md | 2 +- docs/de/docs/tutorial/cors.md | 2 +- docs/de/docs/tutorial/dependencies/dependencies-with-yield.md | 2 +- docs/de/docs/tutorial/dependencies/index.md | 2 +- docs/de/docs/tutorial/extra-data-types.md | 2 +- docs/de/docs/tutorial/extra-models.md | 2 +- docs/de/docs/tutorial/first-steps.md | 2 +- docs/de/docs/tutorial/handling-errors.md | 2 +- docs/de/docs/tutorial/header-param-models.md | 2 +- docs/de/docs/tutorial/header-params.md | 2 +- docs/de/docs/tutorial/middleware.md | 2 +- docs/de/docs/tutorial/path-operation-configuration.md | 2 +- docs/de/docs/tutorial/path-params.md | 2 +- docs/de/docs/tutorial/query-param-models.md | 2 +- docs/de/docs/tutorial/query-params-str-validations.md | 4 ++-- docs/de/docs/tutorial/request-files.md | 2 +- docs/de/docs/tutorial/request-form-models.md | 2 +- docs/de/docs/tutorial/response-model.md | 2 +- docs/de/docs/tutorial/response-status-code.md | 2 +- docs/de/docs/tutorial/security/oauth2-jwt.md | 2 +- docs/de/docs/tutorial/security/simple-oauth2.md | 2 +- docs/de/llm-prompt.md | 4 ++-- 49 files changed, 53 insertions(+), 53 deletions(-) diff --git a/docs/de/docs/advanced/additional-responses.md b/docs/de/docs/advanced/additional-responses.md index 287d11c4c..9a7a70d3e 100644 --- a/docs/de/docs/advanced/additional-responses.md +++ b/docs/de/docs/advanced/additional-responses.md @@ -8,7 +8,7 @@ Wenn Sie mit **FastAPI** beginnen, benötigen Sie dies möglicherweise nicht. /// -Sie können zusätzliche Responses mit zusätzlichen Statuscodes, Medientypen, Beschreibungen, usw. deklarieren. +Sie können zusätzliche Responses mit zusätzlichen Statuscodes, Medientypen, Beschreibungen, usw. deklarieren. Diese zusätzlichen Responses werden in das OpenAPI-Schema aufgenommen, sodass sie auch in der API-Dokumentation erscheinen. diff --git a/docs/de/docs/advanced/additional-status-codes.md b/docs/de/docs/advanced/additional-status-codes.md index 4c61e283e..f948e1862 100644 --- a/docs/de/docs/advanced/additional-status-codes.md +++ b/docs/de/docs/advanced/additional-status-codes.md @@ -1,6 +1,6 @@ # Zusätzliche Statuscodes { #additional-status-codes } -Standardmäßig liefert **FastAPI** die Responses als `JSONResponse` zurück und fügt den Inhalt, den Sie aus Ihrer *Pfadoperation* zurückgeben, in diese `JSONResponse` ein. +Standardmäßig liefert **FastAPI** die Responses als `JSONResponse` zurück und fügt den Inhalt, den Sie aus Ihrer *Pfadoperation* zurückgeben, in diese `JSONResponse` ein. Es wird der Default-Statuscode oder derjenige verwendet, den Sie in Ihrer *Pfadoperation* festgelegt haben. diff --git a/docs/de/docs/advanced/behind-a-proxy.md b/docs/de/docs/advanced/behind-a-proxy.md index 580ecfa71..718a02158 100644 --- a/docs/de/docs/advanced/behind-a-proxy.md +++ b/docs/de/docs/advanced/behind-a-proxy.md @@ -110,7 +110,7 @@ $ fastapi run main.py --root-path /api/v1
-wäre die Response etwa: +wäre die Response etwa: ```JSON { @@ -131,7 +131,7 @@ Die Übergabe des `root_path` an `FastAPI` wäre das Äquivalent zur Übergabe d Beachten Sie, dass der Server (Uvicorn) diesen `root_path` für nichts anderes verwendet als für die Weitergabe an die Anwendung. -Aber wenn Sie mit Ihrem Browser auf http://127.0.0.1:8000/app gehen, sehen Sie die normale Antwort: +Aber wenn Sie mit Ihrem Browser auf http://127.0.0.1:8000/app gehen, sehen Sie die normale Response: ```JSON { diff --git a/docs/de/docs/advanced/custom-response.md b/docs/de/docs/advanced/custom-response.md index dd0a6fe97..f6a79c1ee 100644 --- a/docs/de/docs/advanced/custom-response.md +++ b/docs/de/docs/advanced/custom-response.md @@ -1,6 +1,6 @@ # Benutzerdefinierte Response – HTML, Stream, Datei, andere { #custom-response-html-stream-file-others } -Standardmäßig gibt **FastAPI** die Responses mittels `JSONResponse` zurück. +Standardmäßig gibt **FastAPI** die Responses mittels `JSONResponse` zurück. Sie können dies überschreiben, indem Sie direkt eine `Response` zurückgeben, wie in [Eine Response direkt zurückgeben](response-directly.md){.internal-link target=_blank} gezeigt. diff --git a/docs/de/docs/advanced/dataclasses.md b/docs/de/docs/advanced/dataclasses.md index f7d081399..add8d1848 100644 --- a/docs/de/docs/advanced/dataclasses.md +++ b/docs/de/docs/advanced/dataclasses.md @@ -1,6 +1,6 @@ # Verwendung von Datenklassen { #using-dataclasses } -FastAPI basiert auf **Pydantic**, und ich habe Ihnen gezeigt, wie Sie Pydantic-Modelle verwenden können, um Requests und Responses zu deklarieren. +FastAPI basiert auf **Pydantic**, und ich habe Ihnen gezeigt, wie Sie Pydantic-Modelle verwenden können, um Requests und Responses zu deklarieren. Aber FastAPI unterstützt auf die gleiche Weise auch die Verwendung von `dataclasses`: diff --git a/docs/de/docs/advanced/generate-clients.md b/docs/de/docs/advanced/generate-clients.md index 5d3ad7aac..b9ca5e808 100644 --- a/docs/de/docs/advanced/generate-clients.md +++ b/docs/de/docs/advanced/generate-clients.md @@ -42,7 +42,7 @@ Beginnen wir mit einer einfachen FastAPI-Anwendung: {* ../../docs_src/generate_clients/tutorial001_py39.py hl[7:9,12:13,16:17,21] *} -Beachten Sie, dass die *Pfadoperationen* die Modelle definieren, die sie für die Request- und Response-Payload verwenden, indem sie die Modelle `Item` und `ResponseMessage` verwenden. +Beachten Sie, dass die *Pfadoperationen* die Modelle definieren, die sie für die Request- und Response-Payload verwenden, indem sie die Modelle `Item` und `ResponseMessage` verwenden. ### API-Dokumentation { #api-docs } diff --git a/docs/de/docs/advanced/middleware.md b/docs/de/docs/advanced/middleware.md index 58be3393b..23d9ff430 100644 --- a/docs/de/docs/advanced/middleware.md +++ b/docs/de/docs/advanced/middleware.md @@ -69,7 +69,7 @@ Die folgenden Argumente werden unterstützt: * `allowed_hosts` – Eine Liste von Domain-Namen, die als Hostnamen zulässig sein sollten. Wildcard-Domains wie `*.example.com` werden unterstützt, um Subdomains zu matchen. Um jeden Hostnamen zu erlauben, verwenden Sie entweder `allowed_hosts=["*"]` oder lassen Sie diese Middleware weg. -Wenn ein eingehender Request nicht korrekt validiert wird, wird eine `400`-Response gesendet. +Wenn ein eingehender Request nicht korrekt validiert wird, wird eine `400`-Response gesendet. ## `GZipMiddleware` { #gzipmiddleware } @@ -81,7 +81,7 @@ Diese Middleware verarbeitet sowohl Standard- als auch Streaming-Responses. Die folgenden Argumente werden unterstützt: -* `minimum_size` – Antworten, die kleiner als diese Mindestgröße in Bytes sind, nicht per GZip komprimieren. Der Defaultwert ist `500`. +* `minimum_size` – Responsen, die kleiner als diese Mindestgröße in Bytes sind, nicht per GZip komprimieren. Der Defaultwert ist `500`. * `compresslevel` – Wird während der GZip-Kompression verwendet. Es ist ein Ganzzahlwert zwischen 1 und 9. Der Defaultwert ist `9`. Ein niedrigerer Wert resultiert in schnellerer Kompression, aber größeren Dateigrößen, während ein höherer Wert langsamere Kompression, aber kleinere Dateigrößen zur Folge hat. ## Andere Middlewares { #other-middlewares } diff --git a/docs/de/docs/advanced/openapi-callbacks.md b/docs/de/docs/advanced/openapi-callbacks.md index d88259ace..08e6263f3 100644 --- a/docs/de/docs/advanced/openapi-callbacks.md +++ b/docs/de/docs/advanced/openapi-callbacks.md @@ -4,7 +4,7 @@ Sie könnten eine API mit einer *Pfadoperation* erstellen, die einen Response sie zurückgeben sollte, usw. ## Eine Anwendung mit Callbacks { #an-app-with-callbacks } diff --git a/docs/de/docs/advanced/path-operation-advanced-configuration.md b/docs/de/docs/advanced/path-operation-advanced-configuration.md index 3a0c25370..454fa2b57 100644 --- a/docs/de/docs/advanced/path-operation-advanced-configuration.md +++ b/docs/de/docs/advanced/path-operation-advanced-configuration.md @@ -56,7 +56,7 @@ Sie wird nicht in der Dokumentation angezeigt, aber andere Tools (z. B. Sphinx) Sie haben wahrscheinlich gesehen, wie man das `response_model` und den `status_code` für eine *Pfadoperation* deklariert. -Das definiert die Metadaten der Haupt-Response einer *Pfadoperation*. +Das definiert die Metadaten der Haupt-Response einer *Pfadoperation*. Sie können auch zusätzliche Responses mit deren Modellen, Statuscodes usw. deklarieren. diff --git a/docs/de/docs/advanced/response-change-status-code.md b/docs/de/docs/advanced/response-change-status-code.md index 011706e0a..b079e241d 100644 --- a/docs/de/docs/advanced/response-change-status-code.md +++ b/docs/de/docs/advanced/response-change-status-code.md @@ -18,7 +18,7 @@ In diesen Fällen können Sie einen `Response`-Parameter verwenden. Sie können einen Parameter vom Typ `Response` in Ihrer *Pfadoperation-Funktion* deklarieren (wie Sie es auch für Cookies und Header tun können). -Anschließend können Sie den `status_code` in diesem *vorübergehenden* Response-Objekt festlegen. +Anschließend können Sie den `status_code` in diesem *vorübergehenden* Response-Objekt festlegen. {* ../../docs_src/response_change_status_code/tutorial001.py hl[1,9,12] *} diff --git a/docs/de/docs/advanced/response-cookies.md b/docs/de/docs/advanced/response-cookies.md index 6e8c436c9..0dd4175dd 100644 --- a/docs/de/docs/advanced/response-cookies.md +++ b/docs/de/docs/advanced/response-cookies.md @@ -4,7 +4,7 @@ Sie können einen Parameter vom Typ `Response` in Ihrer *Pfadoperation-Funktion* deklarieren. -Und dann können Sie Cookies in diesem *vorübergehenden* Response-Objekt setzen. +Und dann können Sie Cookies in diesem *vorübergehenden* Response-Objekt setzen. {* ../../docs_src/response_cookies/tutorial002.py hl[1, 8:9] *} diff --git a/docs/de/docs/advanced/response-directly.md b/docs/de/docs/advanced/response-directly.md index 3b2619a51..d99517373 100644 --- a/docs/de/docs/advanced/response-directly.md +++ b/docs/de/docs/advanced/response-directly.md @@ -4,7 +4,7 @@ Wenn Sie eine **FastAPI** *Pfadoperation* erstellen, können Sie normalerweise b Standardmäßig konvertiert **FastAPI** diesen Rückgabewert automatisch nach JSON, mithilfe des `jsonable_encoder`, der in [JSON-kompatibler Encoder](../tutorial/encoder.md){.internal-link target=_blank} erläutert wird. -Dann würde es hinter den Kulissen diese JSON-kompatiblen Daten (z. B. ein `dict`) in eine `JSONResponse` einfügen, die zum Senden der Response an den Client verwendet wird. +Dann würde es hinter den Kulissen diese JSON-kompatiblen Daten (z. B. ein `dict`) in eine `JSONResponse` einfügen, die zum Senden der Response an den Client verwendet wird. Sie können jedoch direkt eine `JSONResponse` von Ihren *Pfadoperationen* zurückgeben. diff --git a/docs/de/docs/advanced/response-headers.md b/docs/de/docs/advanced/response-headers.md index 9da1bbb39..46563f8a5 100644 --- a/docs/de/docs/advanced/response-headers.md +++ b/docs/de/docs/advanced/response-headers.md @@ -4,7 +4,7 @@ Sie können einen Parameter vom Typ `Response` in Ihrer *Pfadoperation-Funktion* deklarieren (wie Sie es auch für Cookies tun können). -Und dann können Sie Header in diesem *vorübergehenden* Response-Objekt festlegen. +Und dann können Sie Header in diesem *vorübergehenden* Response-Objekt festlegen. {* ../../docs_src/response_headers/tutorial002.py hl[1, 7:8] *} diff --git a/docs/de/docs/advanced/security/http-basic-auth.md b/docs/de/docs/advanced/security/http-basic-auth.md index f602858bb..d385669a1 100644 --- a/docs/de/docs/advanced/security/http-basic-auth.md +++ b/docs/de/docs/advanced/security/http-basic-auth.md @@ -78,7 +78,7 @@ if "stanleyjobsox" == "stanleyjobson" and "love123" == "swordfish": ... ``` -Python muss das gesamte `stanleyjobso` in `stanleyjobsox` und `stanleyjobson` vergleichen, bevor es erkennt, dass beide Zeichenfolgen nicht gleich sind. Daher wird es einige zusätzliche Mikrosekunden dauern, bis die Response „Incorrect username or password“ erfolgt. +Python muss das gesamte `stanleyjobso` in `stanleyjobsox` und `stanleyjobson` vergleichen, bevor es erkennt, dass beide Zeichenfolgen nicht gleich sind. Daher wird es einige zusätzliche Mikrosekunden dauern, bis die Response „Incorrect username or password“ erfolgt. #### Die Zeit zum Antworten hilft den Angreifern { #the-time-to-answer-helps-the-attackers } diff --git a/docs/de/docs/advanced/templates.md b/docs/de/docs/advanced/templates.md index 97801c04a..462556325 100644 --- a/docs/de/docs/advanced/templates.md +++ b/docs/de/docs/advanced/templates.md @@ -39,7 +39,7 @@ Außerdem wurde in früheren Versionen das `request`-Objekt als Teil der Schlüs /// tip | Tipp -Durch die Deklaration von `response_class=HTMLResponse` kann die Dokumentationsoberfläche erkennen, dass die Response HTML sein wird. +Durch die Deklaration von `response_class=HTMLResponse` kann die Dokumentationsoberfläche erkennen, dass die Response HTML sein wird. /// diff --git a/docs/de/docs/advanced/wsgi.md b/docs/de/docs/advanced/wsgi.md index 95aac4f88..1de9739dd 100644 --- a/docs/de/docs/advanced/wsgi.md +++ b/docs/de/docs/advanced/wsgi.md @@ -20,7 +20,7 @@ Jetzt wird jeder http://localhost:8000/v1/ gehen, sehen Sie die Response von Flask: +Wenn Sie das ausführen und auf http://localhost:8000/v1/ gehen, sehen Sie die Response von Flask: ```txt Hello, World from Flask! diff --git a/docs/de/docs/alternatives.md b/docs/de/docs/alternatives.md index a4b418796..6b32bc2ce 100644 --- a/docs/de/docs/alternatives.md +++ b/docs/de/docs/alternatives.md @@ -283,7 +283,7 @@ Aus diesem Grund basiert **FastAPI** auf Starlette, da dieses das schnellste ver Falcon ist ein weiteres leistungsstarkes Python-Framework. Es ist minimalistisch konzipiert und dient als Grundlage für andere Frameworks wie Hug. -Es ist so konzipiert, dass es über Funktionen verfügt, welche zwei Parameter empfangen, einen „Request“ und eine „Response“. Dann „lesen“ Sie Teile des Requests und „schreiben“ Teile der Response. Aufgrund dieses Designs ist es nicht möglich, Request-Parameter und -Bodys mit Standard-Python-Typhinweisen als Funktionsparameter zu deklarieren. +Es ist so konzipiert, dass es über Funktionen verfügt, welche zwei Parameter empfangen, einen „Request“ und eine „Response“. Dann „lesen“ Sie Teile des Requests und „schreiben“ Teile der Response. Aufgrund dieses Designs ist es nicht möglich, Request-Parameter und -Bodys mit Standard-Python-Typhinweisen als Funktionsparameter zu deklarieren. Daher müssen Datenvalidierung, Serialisierung und Dokumentation im Code und nicht automatisch erfolgen. Oder sie müssen als Framework oberhalb von Falcon implementiert werden, so wie Hug. Dieselbe Unterscheidung findet auch in anderen Frameworks statt, die vom Design von Falcon inspiriert sind und ein Requestobjekt und ein Responseobjekt als Parameter haben. diff --git a/docs/de/docs/async.md b/docs/de/docs/async.md index 71c61711f..78513f840 100644 --- a/docs/de/docs/async.md +++ b/docs/de/docs/async.md @@ -241,7 +241,7 @@ Das ist auch bei den meisten Webanwendungen der Fall. Viele, viele Benutzer, aber Ihr Server wartet 🕙 darauf, dass deren nicht so gute Internetverbindungen die Requests übermitteln. -Und dann wieder warten 🕙, bis die Responses zurückkommen. +Und dann wieder warten 🕙, bis die Responses zurückkommen. Dieses „Warten“ 🕙 wird in Mikrosekunden gemessen, aber zusammenfassend lässt sich sagen, dass am Ende eine Menge gewartet wird. diff --git a/docs/de/docs/deployment/concepts.md b/docs/de/docs/deployment/concepts.md index 18174b66f..a8eedb19a 100644 --- a/docs/de/docs/deployment/concepts.md +++ b/docs/de/docs/deployment/concepts.md @@ -214,7 +214,7 @@ Im folgenden Beispiel gibt es einen **Manager-Prozess**, welcher zwei **Workerpr Dieser Manager-Prozess wäre wahrscheinlich derjenige, welcher der IP am **Port** lauscht. Und er würde die gesamte Kommunikation an die Workerprozesse weiterleiten. -Diese Workerprozesse würden Ihre Anwendung ausführen, sie würden die Hauptberechnungen durchführen, um einen **Request** entgegenzunehmen und eine **Response** zurückzugeben, und sie würden alles, was Sie in Variablen einfügen, in den RAM laden. +Diese Workerprozesse würden Ihre Anwendung ausführen, sie würden die Hauptberechnungen durchführen, um einen **Request** entgegenzunehmen und eine **Response** zurückzugeben, und sie würden alles, was Sie in Variablen einfügen, in den RAM laden. diff --git a/docs/de/docs/features.md b/docs/de/docs/features.md index bd222984e..c8a30feb9 100644 --- a/docs/de/docs/features.md +++ b/docs/de/docs/features.md @@ -170,7 +170,7 @@ Mit **FastAPI** bekommen Sie alles von **Starlette** (da FastAPI nur Starlette a * Hintergrundaufgaben im selben Prozess. * Ereignisse beim Starten und Herunterfahren. * Testclient baut auf HTTPX auf. -* **CORS**, GZip, statische Dateien, Responses streamen. +* **CORS**, GZip, statische Dateien, Responses streamen. * **Sitzungs- und Cookie**-Unterstützung. * 100 % Testabdeckung. * 100 % Typen annotierte Codebasis. diff --git a/docs/de/docs/how-to/conditional-openapi.md b/docs/de/docs/how-to/conditional-openapi.md index e174e456b..b33c5703c 100644 --- a/docs/de/docs/how-to/conditional-openapi.md +++ b/docs/de/docs/how-to/conditional-openapi.md @@ -14,7 +14,7 @@ Das Verstecken der Dokumentation macht es nur schwieriger zu verstehen, wie mit Wenn Sie Ihre API sichern möchten, gibt es mehrere bessere Dinge, die Sie tun können, zum Beispiel: -* Stellen Sie sicher, dass Sie über gut definierte Pydantic-Modelle für Ihre Requestbodys und Responses verfügen. +* Stellen Sie sicher, dass Sie über gut definierte Pydantic-Modelle für Ihre Requestbodys und Responses verfügen. * Konfigurieren Sie alle erforderlichen Berechtigungen und Rollen mithilfe von Abhängigkeiten. * Speichern Sie niemals Klartext-Passwörter, sondern nur Passwort-Hashes. * Implementieren und verwenden Sie gängige kryptografische Tools wie Passlib und JWT-Tokens, usw. diff --git a/docs/de/docs/how-to/custom-request-and-route.md b/docs/de/docs/how-to/custom-request-and-route.md index 2dccbaba1..87dde5d38 100644 --- a/docs/de/docs/how-to/custom-request-and-route.md +++ b/docs/de/docs/how-to/custom-request-and-route.md @@ -50,7 +50,7 @@ Als Nächstes erstellen wir eine benutzerdefinierte Unterklasse von `fastapi.rou Dieses Mal wird die Methode `APIRoute.get_route_handler()` überschrieben. -Diese Methode gibt eine Funktion zurück. Und diese Funktion empfängt einen Request und gibt eine Response zurück. +Diese Methode gibt eine Funktion zurück. Und diese Funktion empfängt einen Request und gibt eine Response zurück. Hier verwenden wir sie, um aus dem ursprünglichen Request einen `GzipRequest` zu erstellen. diff --git a/docs/de/docs/how-to/extending-openapi.md b/docs/de/docs/how-to/extending-openapi.md index be85b8cd5..146ee098b 100644 --- a/docs/de/docs/how-to/extending-openapi.md +++ b/docs/de/docs/how-to/extending-openapi.md @@ -12,7 +12,7 @@ Eine `FastAPI`-Anwendung (Instanz) verfügt über eine `.openapi()`-Methode, von Als Teil der Erstellung des Anwendungsobjekts wird eine *Pfadoperation* für `/openapi.json` (oder welcher Wert für den Parameter `openapi_url` gesetzt wurde) registriert. -Diese gibt lediglich eine JSON-Response zurück, mit dem Ergebnis der Methode `.openapi()` der Anwendung. +Diese gibt lediglich eine JSON-Response zurück, mit dem Ergebnis der Methode `.openapi()` der Anwendung. Standardmäßig überprüft die Methode `.openapi()` die Eigenschaft `.openapi_schema`, um zu sehen, ob diese Inhalt hat, und gibt diesen zurück. diff --git a/docs/de/docs/how-to/separate-openapi-schemas.md b/docs/de/docs/how-to/separate-openapi-schemas.md index 86392173e..31653590b 100644 --- a/docs/de/docs/how-to/separate-openapi-schemas.md +++ b/docs/de/docs/how-to/separate-openapi-schemas.md @@ -38,7 +38,7 @@ Wenn Sie jedoch dasselbe Modell als Ausgabe verwenden, wie hier: ### Modell für Ausgabe-Responsedaten { #model-for-output-response-data } -Wenn Sie mit der Dokumentation interagieren und die Response überprüfen, enthält die JSON-Response den Defaultwert (`null`), obwohl der Code nichts in eines der `description`-Felder geschrieben hat: +Wenn Sie mit der Dokumentation interagieren und die Response überprüfen, enthält die JSON-Response den Defaultwert (`null`), obwohl der Code nichts in eines der `description`-Felder geschrieben hat:
diff --git a/docs/de/docs/index.md b/docs/de/docs/index.md index a23ab6f6b..aafce7d7f 100644 --- a/docs/de/docs/index.md +++ b/docs/de/docs/index.md @@ -241,7 +241,7 @@ Sie können mehr darüber in der http://127.0.0.1:8000/items/5?q=somequery. -Sie sehen die JSON-Antwort als: +Sie sehen die JSON-Response als: ```JSON {"item_id": 5, "q": "somequery"} diff --git a/docs/de/docs/tutorial/background-tasks.md b/docs/de/docs/tutorial/background-tasks.md index 982d6f4a9..ea85207ce 100644 --- a/docs/de/docs/tutorial/background-tasks.md +++ b/docs/de/docs/tutorial/background-tasks.md @@ -1,6 +1,6 @@ # Hintergrundtasks { #background-tasks } -Sie können Hintergrundtasks definieren, die *nach* der Rückgabe einer Response ausgeführt werden sollen. +Sie können Hintergrundtasks definieren, die *nach* der Rückgabe einer Response ausgeführt werden sollen. Das ist nützlich für Vorgänge, die nach einem Request ausgeführt werden müssen, bei denen der Client jedoch nicht unbedingt auf den Abschluss des Vorgangs warten muss, bevor er die Response erhält. diff --git a/docs/de/docs/tutorial/bigger-applications.md b/docs/de/docs/tutorial/bigger-applications.md index 7e996938b..928d50adf 100644 --- a/docs/de/docs/tutorial/bigger-applications.md +++ b/docs/de/docs/tutorial/bigger-applications.md @@ -323,7 +323,7 @@ Aber wir können immer noch _mehr_ `tags` hinzufügen, die auf eine bestimmte *P Diese letzte Pfadoperation wird eine Kombination von Tags haben: `["items", "custom"]`. -Und sie wird auch beide Responses in der Dokumentation haben, eine für `404` und eine für `403`. +Und sie wird auch beide Responses in der Dokumentation haben, eine für `404` und eine für `403`. /// diff --git a/docs/de/docs/tutorial/cookie-param-models.md b/docs/de/docs/tutorial/cookie-param-models.md index 3b29020cf..2baf3d70d 100644 --- a/docs/de/docs/tutorial/cookie-param-models.md +++ b/docs/de/docs/tutorial/cookie-param-models.md @@ -52,7 +52,7 @@ Sie können die Modellkonfiguration von Pydantic verwenden, um `extra` Felder zu {* ../../docs_src/cookie_param_models/tutorial002_an_py39.py hl[10] *} -Wenn ein Client versucht, einige **zusätzliche Cookies** zu senden, erhält er eine **Error-Response**. +Wenn ein Client versucht, einige **zusätzliche Cookies** zu senden, erhält er eine **Error-Response**. Arme Cookie-Banner, wie sie sich mühen, Ihre Einwilligung zu erhalten, dass die API sie ablehnen darf. 🍪 diff --git a/docs/de/docs/tutorial/cors.md b/docs/de/docs/tutorial/cors.md index 692308edc..5fb7e0bb4 100644 --- a/docs/de/docs/tutorial/cors.md +++ b/docs/de/docs/tutorial/cors.md @@ -69,7 +69,7 @@ Die Middleware antwortet auf zwei besondere Arten von HTTP-Requests ... Dies sind alle `OPTIONS`-Requests mit `Origin`- und `Access-Control-Request-Method`-Headern. -In diesem Fall wird die Middleware den eingehenden Request abfangen und mit entsprechenden CORS-Headern, und entweder einer `200`- oder `400`-Response zu Informationszwecken antworten. +In diesem Fall wird die Middleware den eingehenden Request abfangen und mit entsprechenden CORS-Headern, und entweder einer `200`- oder `400`-Response zu Informationszwecken antworten. ### Einfache Requests { #simple-requests } diff --git a/docs/de/docs/tutorial/dependencies/dependencies-with-yield.md b/docs/de/docs/tutorial/dependencies/dependencies-with-yield.md index 11fd4a5e9..178c2673e 100644 --- a/docs/de/docs/tutorial/dependencies/dependencies-with-yield.md +++ b/docs/de/docs/tutorial/dependencies/dependencies-with-yield.md @@ -27,7 +27,7 @@ Tatsächlich verwendet FastAPI diese beiden Dekoratoren intern. Sie könnten damit beispielsweise eine Datenbanksession erstellen und diese nach Abschluss schließen. -Nur der Code vor und einschließlich der `yield`-Anweisung wird ausgeführt, bevor eine Response erzeugt wird: +Nur der Code vor und einschließlich der `yield`-Anweisung wird ausgeführt, bevor eine Response erzeugt wird: {* ../../docs_src/dependencies/tutorial007.py hl[2:4] *} diff --git a/docs/de/docs/tutorial/dependencies/index.md b/docs/de/docs/tutorial/dependencies/index.md index 40fb92c6b..15f98d880 100644 --- a/docs/de/docs/tutorial/dependencies/index.md +++ b/docs/de/docs/tutorial/dependencies/index.md @@ -199,7 +199,7 @@ Die Einfachheit des Dependency Injection Systems macht **FastAPI** kompatibel mi * externen APIs * Authentifizierungs- und Autorisierungssystemen * API-Nutzungs-Überwachungssystemen -* Responsedaten-Injektionssystemen +* Responsedaten-Injektionssystemen * usw. ## Einfach und leistungsstark { #simple-and-powerful } diff --git a/docs/de/docs/tutorial/extra-data-types.md b/docs/de/docs/tutorial/extra-data-types.md index e81eb9470..5002f0534 100644 --- a/docs/de/docs/tutorial/extra-data-types.md +++ b/docs/de/docs/tutorial/extra-data-types.md @@ -13,7 +13,7 @@ Und Sie haben immer noch dieselbe Funktionalität wie bisher gesehen: * Großartige Editor-Unterstützung. * Datenkonvertierung bei eingehenden Requests. -* Datenkonvertierung für Response-Daten. +* Datenkonvertierung für Response-Daten. * Datenvalidierung. * Automatische Annotation und Dokumentation. diff --git a/docs/de/docs/tutorial/extra-models.md b/docs/de/docs/tutorial/extra-models.md index 15c39fc24..ef2de7413 100644 --- a/docs/de/docs/tutorial/extra-models.md +++ b/docs/de/docs/tutorial/extra-models.md @@ -166,7 +166,7 @@ Auf diese Weise können wir nur die Unterschiede zwischen den Modellen (mit Klar ## `Union` oder `anyOf` { #union-or-anyof } -Sie können deklarieren, dass eine Response eine `Union` mehrerer Typen ist, das bedeutet, dass die Response einer von ihnen ist. +Sie können deklarieren, dass eine Response eine `Union` mehrerer Typen ist, das bedeutet, dass die Response einer von ihnen ist. Dies wird in OpenAPI mit `anyOf` definiert. diff --git a/docs/de/docs/tutorial/first-steps.md b/docs/de/docs/tutorial/first-steps.md index cf00a0c4d..374127c17 100644 --- a/docs/de/docs/tutorial/first-steps.md +++ b/docs/de/docs/tutorial/first-steps.md @@ -60,7 +60,7 @@ Diese Zeile zeigt die URL, unter der Ihre App auf Ihrem lokalen Computer bereitg Öffnen Sie Ihren Browser unter http://127.0.0.1:8000. -Sie werden die JSON-Response sehen: +Sie werden die JSON-Response sehen: ```JSON {"message": "Hello World"} diff --git a/docs/de/docs/tutorial/handling-errors.md b/docs/de/docs/tutorial/handling-errors.md index f42614307..d331f5b0a 100644 --- a/docs/de/docs/tutorial/handling-errors.md +++ b/docs/de/docs/tutorial/handling-errors.md @@ -21,7 +21,7 @@ Erinnern Sie sich an all diese **„404 Not Found“** Fehler (und Witze)? ## `HTTPException` verwenden { #use-httpexception } -Um HTTP-Responses mit Fehlern an den Client zurückzugeben, verwenden Sie `HTTPException`. +Um HTTP-Responses mit Fehlern an den Client zurückzugeben, verwenden Sie `HTTPException`. ### `HTTPException` importieren { #import-httpexception } diff --git a/docs/de/docs/tutorial/header-param-models.md b/docs/de/docs/tutorial/header-param-models.md index 20d9121b9..8c1bf61ae 100644 --- a/docs/de/docs/tutorial/header-param-models.md +++ b/docs/de/docs/tutorial/header-param-models.md @@ -34,7 +34,7 @@ Sie können Pydantics Modellkonfiguration verwenden, um `extra` Felder zu verbie {* ../../docs_src/header_param_models/tutorial002_an_py310.py hl[10] *} -Wenn ein Client versucht, einige **zusätzliche Header** zu senden, erhält er eine **Error-Response**. +Wenn ein Client versucht, einige **zusätzliche Header** zu senden, erhält er eine **Error-Response**. Zum Beispiel, wenn der Client versucht, einen `tool`-Header mit einem Wert von `plumbus` zu senden, erhält er eine **Error-Response**, die ihm mitteilt, dass der Header-Parameter `tool` nicht erlaubt ist: diff --git a/docs/de/docs/tutorial/header-params.md b/docs/de/docs/tutorial/header-params.md index 7f7211c38..5bf917184 100644 --- a/docs/de/docs/tutorial/header-params.md +++ b/docs/de/docs/tutorial/header-params.md @@ -73,7 +73,7 @@ X-Token: foo X-Token: bar ``` -Dann wäre die Response: +Dann wäre die Response: ```JSON { diff --git a/docs/de/docs/tutorial/middleware.md b/docs/de/docs/tutorial/middleware.md index 1bddf9157..a1e2ba9df 100644 --- a/docs/de/docs/tutorial/middleware.md +++ b/docs/de/docs/tutorial/middleware.md @@ -2,7 +2,7 @@ Sie können Middleware zu **FastAPI**-Anwendungen hinzufügen. -Eine „Middleware“ ist eine Funktion, die mit jedem **Request** arbeitet, bevor er von einer bestimmten *Pfadoperation* verarbeitet wird. Und auch mit jeder **Response**, bevor sie zurückgegeben wird. +Eine „Middleware“ ist eine Funktion, die mit jedem **Request** arbeitet, bevor er von einer bestimmten *Pfadoperation* verarbeitet wird. Und auch mit jeder **Response**, bevor sie zurückgegeben wird. * Sie nimmt jeden **Request** entgegen, der an Ihre Anwendung gesendet wird. * Sie kann dann etwas mit diesem **Request** tun oder beliebigen Code ausführen. diff --git a/docs/de/docs/tutorial/path-operation-configuration.md b/docs/de/docs/tutorial/path-operation-configuration.md index 00cb8d722..41a965827 100644 --- a/docs/de/docs/tutorial/path-operation-configuration.md +++ b/docs/de/docs/tutorial/path-operation-configuration.md @@ -10,7 +10,7 @@ Beachten Sie, dass diese Parameter direkt dem *Pfadoperation-Dekorator* übergeb ## Response-Statuscode { #response-status-code } -Sie können den (HTTP-)`status_code` definieren, der in der Response Ihrer *Pfadoperation* verwendet werden soll. +Sie können den (HTTP-)`status_code` definieren, der in der Response Ihrer *Pfadoperation* verwendet werden soll. Sie können direkt den `int`-Code übergeben, etwa `404`. diff --git a/docs/de/docs/tutorial/path-params.md b/docs/de/docs/tutorial/path-params.md index 35309ab7a..0e25cb5f6 100644 --- a/docs/de/docs/tutorial/path-params.md +++ b/docs/de/docs/tutorial/path-params.md @@ -6,7 +6,7 @@ Sie können Pfad-„Parameter“ oder -„Variablen“ mit der gleichen Syntax d Der Wert des Pfad-Parameters `item_id` wird Ihrer Funktion als das Argument `item_id` übergeben. -Wenn Sie dieses Beispiel ausführen und auf http://127.0.0.1:8000/items/foo gehen, sehen Sie als Response: +Wenn Sie dieses Beispiel ausführen und auf http://127.0.0.1:8000/items/foo gehen, sehen Sie als Response: ```JSON {"item_id":"foo"} diff --git a/docs/de/docs/tutorial/query-param-models.md b/docs/de/docs/tutorial/query-param-models.md index 938fe5733..7d3f2d32e 100644 --- a/docs/de/docs/tutorial/query-param-models.md +++ b/docs/de/docs/tutorial/query-param-models.md @@ -34,7 +34,7 @@ Sie können die Modellkonfiguration von Pydantic verwenden, um jegliche `extra` {* ../../docs_src/query_param_models/tutorial002_an_py310.py hl[10] *} -Wenn ein Client versucht, einige **zusätzliche** Daten in den **Query-Parametern** zu senden, erhält er eine **Error-Response**. +Wenn ein Client versucht, einige **zusätzliche** Daten in den **Query-Parametern** zu senden, erhält er eine **Error-Response**. Wenn der Client beispielsweise versucht, einen `tool` Query-Parameter mit dem Wert `plumbus` zu senden, wie: diff --git a/docs/de/docs/tutorial/query-params-str-validations.md b/docs/de/docs/tutorial/query-params-str-validations.md index 6223d251c..4de9e0b83 100644 --- a/docs/de/docs/tutorial/query-params-str-validations.md +++ b/docs/de/docs/tutorial/query-params-str-validations.md @@ -281,7 +281,7 @@ http://localhost:8000/items/?q=foo&q=bar würden Sie die mehreren `q`-*Query-Parameter*-Werte (`foo` und `bar`) in einer Python-`list` in Ihrer *Pfadoperation-Funktion* im *Funktionsparameter* `q` erhalten. -So wäre die Response zu dieser URL: +So wäre die Response zu dieser URL: ```JSON { @@ -314,7 +314,7 @@ Wenn Sie zu: http://localhost:8000/items/ ``` -gehen, wird der Default für `q` sein: `["foo", "bar"]`, und Ihre Antwort wird sein: +gehen, wird der Default für `q` sein: `["foo", "bar"]`, und Ihre Response wird sein: ```JSON { diff --git a/docs/de/docs/tutorial/request-files.md b/docs/de/docs/tutorial/request-files.md index e77d6debc..d1d999195 100644 --- a/docs/de/docs/tutorial/request-files.md +++ b/docs/de/docs/tutorial/request-files.md @@ -161,7 +161,7 @@ Sie erhalten, wie deklariert, eine `list` von `bytes` oder `UploadFile`s. Sie können auch `from starlette.responses import HTMLResponse` verwenden. -**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. +**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. /// diff --git a/docs/de/docs/tutorial/request-form-models.md b/docs/de/docs/tutorial/request-form-models.md index 0922b020c..fbc6c094c 100644 --- a/docs/de/docs/tutorial/request-form-models.md +++ b/docs/de/docs/tutorial/request-form-models.md @@ -50,7 +50,7 @@ Sie können die Modellkonfiguration von Pydantic verwenden, um jegliche `extra` {* ../../docs_src/request_form_models/tutorial002_an_py39.py hl[12] *} -Wenn ein Client versucht, einige zusätzliche Daten zu senden, erhält er eine **Error-Response**. +Wenn ein Client versucht, einige zusätzliche Daten zu senden, erhält er eine **Error-Response**. Zum Beispiel, wenn der Client versucht, folgende Formularfelder zu senden: diff --git a/docs/de/docs/tutorial/response-model.md b/docs/de/docs/tutorial/response-model.md index 922b68655..90693f9da 100644 --- a/docs/de/docs/tutorial/response-model.md +++ b/docs/de/docs/tutorial/response-model.md @@ -1,6 +1,6 @@ # Responsemodell – Rückgabetyp { #response-model-return-type } -Sie können den Typ der Response deklarieren, indem Sie den **Rückgabetyp** der *Pfadoperation* annotieren. +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. diff --git a/docs/de/docs/tutorial/response-status-code.md b/docs/de/docs/tutorial/response-status-code.md index 03a96c58a..928003c3f 100644 --- a/docs/de/docs/tutorial/response-status-code.md +++ b/docs/de/docs/tutorial/response-status-code.md @@ -1,6 +1,6 @@ # Response-Statuscode { #response-status-code } -Genauso wie Sie ein Responsemodell angeben können, können Sie auch den HTTP-Statuscode für die Response mit dem Parameter `status_code` in jeder der *Pfadoperationen* deklarieren: +Genauso wie Sie ein Responsemodell angeben können, können Sie auch den HTTP-Statuscode für die Response mit dem Parameter `status_code` in jeder der *Pfadoperationen* deklarieren: * `@app.get()` * `@app.post()` diff --git a/docs/de/docs/tutorial/security/oauth2-jwt.md b/docs/de/docs/tutorial/security/oauth2-jwt.md index 38d94904b..2832e5a91 100644 --- a/docs/de/docs/tutorial/security/oauth2-jwt.md +++ b/docs/de/docs/tutorial/security/oauth2-jwt.md @@ -148,7 +148,7 @@ Erstellen Sie eine Variable `ALGORITHM` für den Algorithmus, der zum Signieren Erstellen Sie eine Variable für das Ablaufdatum des Tokens. -Definieren Sie ein Pydantic-Modell, das im Token-Endpunkt für die Response verwendet wird. +Definieren Sie ein Pydantic-Modell, das im Token-Endpunkt für die Response verwendet wird. Erstellen Sie eine Hilfsfunktion, um einen neuen Zugriffstoken zu generieren. diff --git a/docs/de/docs/tutorial/security/simple-oauth2.md b/docs/de/docs/tutorial/security/simple-oauth2.md index 4c9355959..348c843cf 100644 --- a/docs/de/docs/tutorial/security/simple-oauth2.md +++ b/docs/de/docs/tutorial/security/simple-oauth2.md @@ -152,7 +152,7 @@ Eine ausführlichere Erklärung von `**user_dict` finden Sie in [der Dokumentati ## Den Token zurückgeben { #return-the-token } -Die Response des `token`-Endpunkts muss ein JSON-Objekt sein. +Die Response des `token`-Endpunkts muss ein JSON-Objekt sein. Es sollte einen `token_type` haben. Da wir in unserem Fall „Bearer“-Token verwenden, sollte der Token-Typ "`bearer`" sein. diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index adae5d8ff..faa62e16d 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -306,10 +306,10 @@ Below is a list of English terms and their preferred German translations, separa * «the payload»: «die Payload» * «the query»: «die Query» * «the recap»: «die Zusammenfassung» -* «the request»: «der Request» +* «the request» (what the client sends to the server): «der Request» * «the request body»: «der Requestbody» * «the request bodies» (plural): «die Requestbodys» -* «the response»: «die Response» +* «the response» (what the server sends back to the client): «die Response» * «the return type»: «der Rückgabetyp» * «the return value»: «der Rückgabewert» * «the SQLModel docs»: «die SQLModel-Dokumentation» From 51eca405db84ec4b5f6a55bfe39f2fbf32dfc278 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sat, 30 Aug 2025 22:50:41 +0200 Subject: [PATCH 156/160] Intermezzo: `Abfrage` --> `Query` --- docs/de/docs/python-types.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/de/docs/python-types.md b/docs/de/docs/python-types.md index 3b0f8fd3f..3b85d46e1 100644 --- a/docs/de/docs/python-types.md +++ b/docs/de/docs/python-types.md @@ -558,7 +558,7 @@ Mit **FastAPI** deklarieren Sie Parameter mit Typhinweisen, und Sie erhalten: ... und **FastAPI** verwendet dieselben Deklarationen, um: -* **Anforderungen** zu definieren: aus Request-Pfadparametern, Abfrageparametern, Header-Feldern, Bodys, Abhängigkeiten, usw. +* **Anforderungen** zu definieren: aus Request-Pfadparametern, Query-Parametern, Header-Feldern, Bodys, Abhängigkeiten, usw. * **Daten umzuwandeln**: aus dem Request in den erforderlichen Typ. * **Daten zu validieren**: aus jedem Request: * **Automatische Fehler** generieren, die an den Client zurückgegeben werden, wenn die Daten ungültig sind. From 69bdfcca7a5dc2025df0b19c9e3a111d10c35968 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sat, 30 Aug 2025 23:07:16 +0200 Subject: [PATCH 157/160] =?UTF-8?q?Intermezzo:=20`datei=C3=A4hnlich`=20-->?= =?UTF-8?q?=20`dateiartig`?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit And linkify `file-like`, also in English document. It is the same link used in the other English document which uses that term. --- docs/de/docs/advanced/custom-response.md | 6 +++--- docs/en/docs/advanced/custom-response.md | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/de/docs/advanced/custom-response.md b/docs/de/docs/advanced/custom-response.md index f6a79c1ee..c3d0330a1 100644 --- a/docs/de/docs/advanced/custom-response.md +++ b/docs/de/docs/advanced/custom-response.md @@ -218,9 +218,9 @@ Nimmt einen asynchronen Generator oder einen normalen Generator/Iterator und str {* ../../docs_src/custom_response/tutorial007.py hl[2,14] *} -#### Verwendung von `StreamingResponse` mit dateiähnlichen Objekten { #using-streamingresponse-with-file-like-objects } +#### Verwendung von `StreamingResponse` mit dateiartigen Objekten { #using-streamingresponse-with-file-like-objects } -Wenn Sie ein dateiähnliches (file-like) Objekt haben (z. B. das von `open()` zurückgegebene Objekt), können Sie eine Generatorfunktion erstellen, um über dieses dateiähnliche Objekt zu iterieren. +Wenn Sie ein dateiartiges (file-like) Objekt haben (z. B. das von `open()` zurückgegebene Objekt), können Sie eine Generatorfunktion erstellen, um über dieses dateiartige Objekt zu iterieren. Auf diese Weise müssen Sie nicht alles zuerst in den Arbeitsspeicher lesen und können diese Generatorfunktion an `StreamingResponse` übergeben und zurückgeben. @@ -229,7 +229,7 @@ Das umfasst viele Bibliotheken zur Interaktion mit Cloud-Speicher, Videoverarbei {* ../../docs_src/custom_response/tutorial008.py hl[2,10:12,14] *} 1. Das ist die Generatorfunktion. Es handelt sich um eine „Generatorfunktion“, da sie `yield`-Anweisungen enthält. -2. Durch die Verwendung eines `with`-Blocks stellen wir sicher, dass das dateiähnliche Objekt geschlossen wird, nachdem die Generatorfunktion fertig ist. Also, nachdem sie mit dem Senden der Response fertig ist. +2. Durch die Verwendung eines `with`-Blocks stellen wir sicher, dass das dateiartige Objekt geschlossen wird, nachdem die Generatorfunktion fertig ist. Also, nachdem sie mit dem Senden der Response fertig ist. 3. Dieses `yield from` weist die Funktion an, über das Ding namens `file_like` zu iterieren. Und dann für jeden iterierten Teil, diesen Teil so zurückzugeben, als wenn er aus dieser Generatorfunktion (`iterfile`) stammen würde. Es handelt sich also hier um eine Generatorfunktion, die die „generierende“ Arbeit intern auf etwas anderes überträgt. diff --git a/docs/en/docs/advanced/custom-response.md b/docs/en/docs/advanced/custom-response.md index 5473d939c..0f3d8b701 100644 --- a/docs/en/docs/advanced/custom-response.md +++ b/docs/en/docs/advanced/custom-response.md @@ -221,7 +221,7 @@ Takes an async generator or a normal generator/iterator and streams the response #### Using `StreamingResponse` with file-like objects { #using-streamingresponse-with-file-like-objects } -If you have a file-like object (e.g. the object returned by `open()`), you can create a generator function to iterate over that file-like object. +If you have a file-like object (e.g. the object returned by `open()`), you can create a generator function to iterate over that file-like object. That way, you don't have to read it all first in memory, and you can pass that generator function to the `StreamingResponse`, and return it. From b817134dda6f17897ef85e6f469fd401dfd4a65f Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 31 Aug 2025 00:29:28 +0200 Subject: [PATCH 158/160] Intermezzo: enrich `Dictionary` Wrap first occurrence into explaining abbr. Translate closer to the english text (`dict` vs `dictionary`) --- docs/de/docs/advanced/additional-responses.md | 2 +- docs/de/docs/advanced/behind-a-proxy.md | 2 +- docs/de/docs/advanced/custom-response.md | 2 +- docs/de/docs/advanced/dataclasses.md | 2 +- docs/de/docs/advanced/events.md | 2 +- .../advanced/path-operation-advanced-configuration.md | 2 +- docs/de/docs/advanced/security/oauth2-scopes.md | 2 +- docs/de/docs/advanced/settings.md | 2 +- docs/de/docs/advanced/templates.md | 2 +- docs/de/docs/advanced/testing-dependencies.md | 2 +- docs/de/docs/features.md | 2 +- docs/de/docs/how-to/configure-swagger-ui.md | 2 +- docs/de/docs/how-to/custom-request-and-route.md | 2 +- docs/de/docs/tutorial/body-updates.md | 2 +- docs/de/docs/tutorial/body.md | 2 +- .../docs/tutorial/dependencies/classes-as-dependencies.md | 2 +- docs/de/docs/tutorial/dependencies/index.md | 2 +- docs/de/docs/tutorial/extra-models.md | 2 +- docs/de/docs/tutorial/metadata.md | 8 ++++---- docs/de/docs/tutorial/query-params-str-validations.md | 2 +- docs/de/docs/tutorial/response-model.md | 2 +- docs/de/docs/tutorial/schema-extra-example.md | 2 +- docs/de/docs/tutorial/sql-databases.md | 2 +- docs/de/docs/tutorial/testing.md | 2 +- docs/de/llm-prompt.md | 2 ++ 25 files changed, 29 insertions(+), 27 deletions(-) diff --git a/docs/de/docs/advanced/additional-responses.md b/docs/de/docs/advanced/additional-responses.md index 9a7a70d3e..218dd6c4f 100644 --- a/docs/de/docs/advanced/additional-responses.md +++ b/docs/de/docs/advanced/additional-responses.md @@ -18,7 +18,7 @@ Für diese zusätzlichen Responses müssen Sie jedoch sicherstellen, dass Sie ei Sie können Ihren *Pfadoperation-Dekoratoren* einen Parameter `responses` übergeben. -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. +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. Jedes dieser Response-`dict`s kann einen Schlüssel `model` haben, welcher ein Pydantic-Modell enthält, genau wie `response_model`. diff --git a/docs/de/docs/advanced/behind-a-proxy.md b/docs/de/docs/advanced/behind-a-proxy.md index 718a02158..083561903 100644 --- a/docs/de/docs/advanced/behind-a-proxy.md +++ b/docs/de/docs/advanced/behind-a-proxy.md @@ -92,7 +92,7 @@ Und die Kommandozeilenoption `--root-path` stellt diesen `root_path` bereit. ### Testen des aktuellen `root_path` { #checking-the-current-root-path } -Sie können den aktuellen `root_path` abrufen, der von Ihrer Anwendung für jeden Request verwendet wird. Er ist Teil des `scope`-Dictionarys (das ist Teil der ASGI-Spezifikation). +Sie können den aktuellen `root_path` abrufen, der von Ihrer Anwendung für jeden Request verwendet wird. Er ist Teil des `scope`-Dictionarys (das ist Teil der ASGI-Spezifikation). Hier fügen wir ihn, nur zu Demonstrationszwecken, in die Nachricht ein. diff --git a/docs/de/docs/advanced/custom-response.md b/docs/de/docs/advanced/custom-response.md index c3d0330a1..8714086e5 100644 --- a/docs/de/docs/advanced/custom-response.md +++ b/docs/de/docs/advanced/custom-response.md @@ -24,7 +24,7 @@ Um beispielsweise noch etwas Leistung herauszuholen, können Sie Dictionary zurückzugeben. Das liegt daran, dass FastAPI standardmäßig jedes enthaltene Element überprüft und sicherstellt, dass es als JSON serialisierbar ist, und zwar unter Verwendung desselben [JSON-kompatiblen Encoders](../tutorial/encoder.md){.internal-link target=_blank}, der im Tutorial erläutert wurde. Dadurch können Sie **beliebige Objekte** zurückgeben, zum Beispiel Datenbankmodelle. diff --git a/docs/de/docs/advanced/dataclasses.md b/docs/de/docs/advanced/dataclasses.md index add8d1848..12ea8e9ec 100644 --- a/docs/de/docs/advanced/dataclasses.md +++ b/docs/de/docs/advanced/dataclasses.md @@ -62,7 +62,7 @@ In diesem Fall können Sie einfach die Standard-`dataclasses` durch `pydantic.da In diesem Fall handelt es sich um eine Liste von `Item`-Datenklassen. -6. Hier geben wir ein Dictionary zurück, das `items` enthält, welches eine Liste von Datenklassen ist. +6. Hier geben wir ein Dictionary zurück, das `items` enthält, welches eine Liste von Datenklassen ist. FastAPI ist weiterhin in der Lage, die Daten nach JSON zu serialisieren. diff --git a/docs/de/docs/advanced/events.md b/docs/de/docs/advanced/events.md index 4c644d7e2..0e8c9369d 100644 --- a/docs/de/docs/advanced/events.md +++ b/docs/de/docs/advanced/events.md @@ -32,7 +32,7 @@ Wir erstellen eine asynchrone Funktion `lifespan()` mit `yield` wie folgt: {* ../../docs_src/events/tutorial003.py hl[16,19] *} -Hier simulieren wir das langsame *Hochfahren*, das Laden des Modells, indem wir die (Fake-)Modellfunktion vor dem `yield` in das Dictionary mit Modellen für maschinelles Lernen einfügen. Dieser Code wird ausgeführt, **bevor** die Anwendung **beginnt, Requests entgegenzunehmen**, während des *Hochfahrens*. +Hier simulieren wir das langsame *Hochfahren*, das Laden des Modells, indem wir die (Fake-)Modellfunktion vor dem `yield` in das Dictionary mit Modellen für maschinelles Lernen einfügen. Dieser Code wird ausgeführt, **bevor** die Anwendung **beginnt, Requests entgegenzunehmen**, während des *Hochfahrens*. Und dann, direkt nach dem `yield`, entladen wir das Modell. Dieser Code wird ausgeführt, **nachdem** die Anwendung **die Bearbeitung von Requests abgeschlossen hat**, direkt vor dem *Herunterfahren*. Dadurch könnten beispielsweise Ressourcen wie Arbeitsspeicher oder eine GPU freigegeben werden. diff --git a/docs/de/docs/advanced/path-operation-advanced-configuration.md b/docs/de/docs/advanced/path-operation-advanced-configuration.md index 454fa2b57..927c55032 100644 --- a/docs/de/docs/advanced/path-operation-advanced-configuration.md +++ b/docs/de/docs/advanced/path-operation-advanced-configuration.md @@ -131,7 +131,7 @@ Und wenn Sie die resultierende OpenAPI sehen (unter `/openapi.json` in Ihrer API ### Benutzerdefiniertes OpenAPI-*Pfadoperation*-Schema { #custom-openapi-path-operation-schema } -Das Dictionary in `openapi_extra` wird mit dem automatisch generierten OpenAPI-Schema für die *Pfadoperation* zusammengeführt (mittels Deep Merge). +Das Dictionary in `openapi_extra` wird mit dem automatisch generierten OpenAPI-Schema für die *Pfadoperation* zusammengeführt (mittels Deep Merge). Sie können dem automatisch generierten Schema also zusätzliche Daten hinzufügen. diff --git a/docs/de/docs/advanced/security/oauth2-scopes.md b/docs/de/docs/advanced/security/oauth2-scopes.md index e9e0d8910..39cb84b2e 100644 --- a/docs/de/docs/advanced/security/oauth2-scopes.md +++ b/docs/de/docs/advanced/security/oauth2-scopes.md @@ -70,7 +70,7 @@ Sehen wir uns diese Änderungen nun Schritt für Schritt an. Die erste Änderung ist, dass wir jetzt das OAuth2-Sicherheitsschema mit zwei verfügbaren Scopes deklarieren: `me` und `items`. -Der `scopes`-Parameter erhält ein `dict` mit jedem Scope als Schlüssel und dessen Beschreibung als Wert: +Der `scopes`-Parameter erhält ein `dict` mit jedem Scope als Schlüssel und dessen Beschreibung als Wert: {* ../../docs_src/security/tutorial005_an_py310.py hl[63:66] *} diff --git a/docs/de/docs/advanced/settings.md b/docs/de/docs/advanced/settings.md index 6fa578d4c..ccd7f373d 100644 --- a/docs/de/docs/advanced/settings.md +++ b/docs/de/docs/advanced/settings.md @@ -241,7 +241,7 @@ Die Klasse `Config` wird nur für die Pydantic-Konfiguration verwendet. Weitere /// info | Info -In Pydantic Version 1 erfolgte die Konfiguration in einer internen Klasse `Config`, in Pydantic Version 2 erfolgt sie in einem Attribut `model_config`. Dieses Attribut akzeptiert ein `dict`. Um automatische Codevervollständigung und Inline-Fehlerberichte zu erhalten, können Sie `SettingsConfigDict` importieren und verwenden, um dieses `dict` zu definieren. +In Pydantic Version 1 erfolgte die Konfiguration in einer internen Klasse `Config`, in Pydantic Version 2 erfolgt sie in einem Attribut `model_config`. Dieses Attribut akzeptiert ein `dict`. Um automatische Codevervollständigung und Inline-Fehlerberichte zu erhalten, können Sie `SettingsConfigDict` importieren und verwenden, um dieses `dict` zu definieren. /// diff --git a/docs/de/docs/advanced/templates.md b/docs/de/docs/advanced/templates.md index 462556325..fdaeb3413 100644 --- a/docs/de/docs/advanced/templates.md +++ b/docs/de/docs/advanced/templates.md @@ -25,7 +25,7 @@ $ pip install jinja2 * Importieren Sie `Jinja2Templates`. * Erstellen Sie ein `templates`-Objekt, das Sie später wiederverwenden können. * Deklarieren Sie einen `Request`-Parameter in der *Pfadoperation*, welcher ein Template zurückgibt. -* Verwenden Sie die von Ihnen erstellten `templates`, um eine `TemplateResponse` zu rendern und zurückzugeben, übergeben Sie den Namen des Templates, das Requestobjekt und ein „Kontext“-Dictionary mit Schlüssel-Wert-Paaren, die innerhalb des Jinja2-Templates verwendet werden sollen. +* Verwenden Sie die von Ihnen erstellten `templates`, um eine `TemplateResponse` zu rendern und zurückzugeben, übergeben Sie den Namen des Templates, das Requestobjekt und ein „Kontext“-Dictionary mit Schlüssel-Wert-Paaren, die innerhalb des Jinja2-Templates verwendet werden sollen. {* ../../docs_src/templates/tutorial001.py hl[4,11,15:18] *} diff --git a/docs/de/docs/advanced/testing-dependencies.md b/docs/de/docs/advanced/testing-dependencies.md index 4e5b16c89..4fc653f77 100644 --- a/docs/de/docs/advanced/testing-dependencies.md +++ b/docs/de/docs/advanced/testing-dependencies.md @@ -22,7 +22,7 @@ In diesem Fall können Sie die Abhängigkeit, die diesen Anbieter aufruft, über ### Das Attribut `app.dependency_overrides` verwenden { #use-the-app-dependency-overrides-attribute } -Für diese Fälle verfügt Ihre **FastAPI**-Anwendung über das Attribut `app.dependency_overrides`, bei diesem handelt sich um ein einfaches `dict`. +Für diese Fälle verfügt Ihre **FastAPI**-Anwendung über das Attribut `app.dependency_overrides`, bei diesem handelt sich um ein einfaches `dict`. Um eine Abhängigkeit für das Testen zu überschreiben, geben Sie als Schlüssel die ursprüngliche Abhängigkeit (eine Funktion) und als Wert Ihre Überschreibung der Abhängigkeit (eine andere Funktion) ein. diff --git a/docs/de/docs/features.md b/docs/de/docs/features.md index c8a30feb9..8d3ec37e6 100644 --- a/docs/de/docs/features.md +++ b/docs/de/docs/features.md @@ -67,7 +67,7 @@ my_second_user: User = User(**second_user_data) `**second_user_data` bedeutet: -Nimm die Schlüssel-Wert-Paare des `second_user_data` Dicts und übergebe sie direkt als Schlüsselwort-Argumente. Äquivalent zu: `User(id=4, name="Mary", joined="2018-11-30")` +Nimm die Schlüssel-Wert-Paare des `second_user_data` Dicts und übergebe sie direkt als Schlüsselwort-Argumente. Äquivalent zu: `User(id=4, name="Mary", joined="2018-11-30")` /// diff --git a/docs/de/docs/how-to/configure-swagger-ui.md b/docs/de/docs/how-to/configure-swagger-ui.md index d99d19912..351cb996c 100644 --- a/docs/de/docs/how-to/configure-swagger-ui.md +++ b/docs/de/docs/how-to/configure-swagger-ui.md @@ -4,7 +4,7 @@ Sie können einige zusätzliche Dictionary mit den Konfigurationen, die direkt an die Swagger-Oberfläche übergeben werden. FastAPI konvertiert die Konfigurationen nach **JSON**, um diese mit JavaScript kompatibel zu machen, da die Swagger-Oberfläche das benötigt. diff --git a/docs/de/docs/how-to/custom-request-and-route.md b/docs/de/docs/how-to/custom-request-and-route.md index 87dde5d38..bd6e42522 100644 --- a/docs/de/docs/how-to/custom-request-and-route.md +++ b/docs/de/docs/how-to/custom-request-and-route.md @@ -58,7 +58,7 @@ Hier verwenden wir sie, um aus dem ursprünglichen Request einen `GzipRequest` z /// note | Technische Details -Ein `Request` hat ein `request.scope`-Attribut, welches einfach ein Python-`dict` ist, welches die mit dem Request verbundenen Metadaten enthält. +Ein `Request` hat ein `request.scope`-Attribut, welches einfach ein Python-`dict` ist, welches die mit dem Request verbundenen Metadaten enthält. Ein `Request` hat auch ein `request.receive`, welches eine Funktion ist, die den Hauptteil des Requests empfängt. diff --git a/docs/de/docs/tutorial/body-updates.md b/docs/de/docs/tutorial/body-updates.md index 50b46098c..7d3e23101 100644 --- a/docs/de/docs/tutorial/body-updates.md +++ b/docs/de/docs/tutorial/body-updates.md @@ -58,7 +58,7 @@ Die Beispiele hier verwenden `.dict()` für die Kompatibilität mit Pydantic v1, /// -Das wird ein `dict` erstellen, mit nur den Daten, die gesetzt wurden, als das `item`-Modell erstellt wurde, Defaultwerte ausgeschlossen. +Das wird ein `dict` erstellen, mit nur den Daten, die gesetzt wurden, als das `item`-Modell erstellt wurde, Defaultwerte ausgeschlossen. Sie können das verwenden, um ein `dict` zu erstellen, das nur die (im Request) gesendeten Daten enthält, ohne Defaultwerte: diff --git a/docs/de/docs/tutorial/body.md b/docs/de/docs/tutorial/body.md index 474e69b3d..71b52df2a 100644 --- a/docs/de/docs/tutorial/body.md +++ b/docs/de/docs/tutorial/body.md @@ -34,7 +34,7 @@ Verwenden Sie Standard-Python-Typen für alle Attribute: Wie auch bei der Deklaration von Query-Parametern gilt: Wenn ein Modellattribut einen Defaultwert hat, ist das Attribut nicht erforderlich. Andernfalls ist es erforderlich. Verwenden Sie `None`, um es einfach optional zu machen. -Zum Beispiel deklariert das obige Modell ein JSON "`object`" (oder Python-`dict`) wie dieses: +Zum Beispiel deklariert das obige Modell ein JSON "`object`" (oder Python-`dict`) wie dieses: ```JSON { diff --git a/docs/de/docs/tutorial/dependencies/classes-as-dependencies.md b/docs/de/docs/tutorial/dependencies/classes-as-dependencies.md index 1dab2a277..3d4493f35 100644 --- a/docs/de/docs/tutorial/dependencies/classes-as-dependencies.md +++ b/docs/de/docs/tutorial/dependencies/classes-as-dependencies.md @@ -4,7 +4,7 @@ Bevor wir tiefer in das **Dependency Injection** System eintauchen, lassen Sie u ## Ein `dict` aus dem vorherigen Beispiel { #a-dict-from-the-previous-example } -Im vorherigen Beispiel haben wir ein `dict` von unserer Abhängigkeit („Dependable“) zurückgegeben: +Im vorherigen Beispiel haben wir ein `dict` von unserer Abhängigkeit („Dependable“) zurückgegeben: {* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *} diff --git a/docs/de/docs/tutorial/dependencies/index.md b/docs/de/docs/tutorial/dependencies/index.md index 15f98d880..87b07da37 100644 --- a/docs/de/docs/tutorial/dependencies/index.md +++ b/docs/de/docs/tutorial/dependencies/index.md @@ -48,7 +48,7 @@ In diesem Fall erwartet diese Abhängigkeit: * Einen optionalen Query-Parameter `skip`, der ein `int` ist und standardmäßig `0` ist. * Einen optionalen Query-Parameter `limit`, der ein `int` ist und standardmäßig `100` ist. -Und dann wird einfach ein `dict` zurückgegeben, welches diese Werte enthält. +Und dann wird einfach ein `dict` zurückgegeben, welches diese Werte enthält. /// info | Info diff --git a/docs/de/docs/tutorial/extra-models.md b/docs/de/docs/tutorial/extra-models.md index ef2de7413..967e8535b 100644 --- a/docs/de/docs/tutorial/extra-models.md +++ b/docs/de/docs/tutorial/extra-models.md @@ -36,7 +36,7 @@ Die Beispiele hier verwenden `.dict()` für die Kompatibilität mit Pydantic v1, `user_in` ist ein Pydantic-Modell der Klasse `UserIn`. -Pydantic-Modelle haben eine `.dict()`-Methode, die ein `dict` mit den Daten des Modells zurückgibt. +Pydantic-Modelle haben eine `.dict()`-Methode, die ein `dict` mit den Daten des Modells zurückgibt. Wenn wir also ein Pydantic-Objekt `user_in` erstellen, etwa so: diff --git a/docs/de/docs/tutorial/metadata.md b/docs/de/docs/tutorial/metadata.md index f1bf5faf8..18639c421 100644 --- a/docs/de/docs/tutorial/metadata.md +++ b/docs/de/docs/tutorial/metadata.md @@ -42,9 +42,9 @@ Zum Beispiel: Sie können auch zusätzliche Metadaten für die verschiedenen Tags hinzufügen, die zum Gruppieren Ihrer Pfadoperationen verwendet werden, mit dem Parameter `openapi_tags`. -Er nimmt eine Liste entgegen, die für jeden Tag ein Dict enthält. +Er nimmt eine Liste entgegen, die für jeden Tag ein Dictionary enthält. -Jedes Dict kann Folgendes enthalten: +Jedes Dictionary kann Folgendes enthalten: * `name` (**erforderlich**): ein `str` mit demselben Tag-Namen, den Sie im Parameter `tags` in Ihren *Pfadoperationen* und `APIRouter`n verwenden. * `description`: ein `str` mit einer kurzen Beschreibung für das Tag. Sie kann Markdown enthalten und wird in der Benutzeroberfläche der Dokumentation angezeigt. @@ -88,9 +88,9 @@ Wenn Sie nun die Dokumentation ansehen, werden dort alle zusätzlichen Metadaten ### Reihenfolge der Tags { #order-of-tags } -Die Reihenfolge der Tag-Metadaten-Dicts definiert auch die Reihenfolge, in der diese in der Benutzeroberfläche der Dokumentation angezeigt werden. +Die Reihenfolge der Tag-Metadaten-Dictionarys definiert auch die Reihenfolge, in der diese in der Benutzeroberfläche der Dokumentation angezeigt werden. -Auch wenn beispielsweise `users` im Alphabet nach `items` kommt, wird es vor diesen angezeigt, da wir deren Metadaten als erstes Dict der Liste hinzugefügt haben. +Auch wenn beispielsweise `users` im Alphabet nach `items` kommt, wird es vor diesen angezeigt, da wir deren Metadaten als erstes Dictionary der Liste hinzugefügt haben. ## OpenAPI-URL { #openapi-url } diff --git a/docs/de/docs/tutorial/query-params-str-validations.md b/docs/de/docs/tutorial/query-params-str-validations.md index 4de9e0b83..744160baf 100644 --- a/docs/de/docs/tutorial/query-params-str-validations.md +++ b/docs/de/docs/tutorial/query-params-str-validations.md @@ -449,7 +449,7 @@ Haben Sie bemerkt? Eine Zeichenkette mit `value.startswith()` kann ein Tuple üb #### Ein zufälliges Item { #a-random-item } -Mit `data.items()` erhalten wir ein iterierbares Objekt mit Tupeln, die Schlüssel und Wert für jedes Dictionary-Element enthalten. +Mit `data.items()` erhalten wir ein iterierbares Objekt mit Tupeln, die Schlüssel und Wert für jedes Dictionary-Element enthalten. Wir konvertieren dieses iterierbare Objekt mit `list(data.items())` in eine richtige `list`. diff --git a/docs/de/docs/tutorial/response-model.md b/docs/de/docs/tutorial/response-model.md index 90693f9da..25d82b942 100644 --- a/docs/de/docs/tutorial/response-model.md +++ b/docs/de/docs/tutorial/response-model.md @@ -23,7 +23,7 @@ Aber am wichtigsten: 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). +Zum Beispiel könnten Sie **ein Dictionary 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 Dictionary 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). diff --git a/docs/de/docs/tutorial/schema-extra-example.md b/docs/de/docs/tutorial/schema-extra-example.md index e7a514c4f..64add2963 100644 --- a/docs/de/docs/tutorial/schema-extra-example.md +++ b/docs/de/docs/tutorial/schema-extra-example.md @@ -24,7 +24,7 @@ Diese zusätzlichen Informationen werden unverändert zum für dieses Modell aus //// tab | Pydantic v2 -In Pydantic Version 2 würden Sie das Attribut `model_config` verwenden, das ein `dict` akzeptiert, wie beschrieben in Pydantic-Dokumentation: Configuration. +In Pydantic Version 2 würden Sie das Attribut `model_config` verwenden, das ein `dict` akzeptiert, wie beschrieben in Pydantic-Dokumentation: Configuration. Sie können `json_schema_extra` setzen, mit einem `dict`, das alle zusätzlichen Daten enthält, die im generierten JSON-Schema angezeigt werden sollen, einschließlich `examples`. diff --git a/docs/de/docs/tutorial/sql-databases.md b/docs/de/docs/tutorial/sql-databases.md index 080d97ea1..cf9731aee 100644 --- a/docs/de/docs/tutorial/sql-databases.md +++ b/docs/de/docs/tutorial/sql-databases.md @@ -316,7 +316,7 @@ Wir können einen einzelnen Helden **lesen**: Wir können einen Helden **aktualisieren**. Dafür verwenden wir eine HTTP-`PATCH`-Operation. -Und im Code erhalten wir ein `dict` mit allen Daten, die vom Client gesendet wurden, **nur die Daten, die vom Client gesendet wurden**, unter Ausschluss von Werten, die dort nur als Defaultwerte vorhanden wären. Um dies zu tun, verwenden wir `exclude_unset=True`. Das ist der Haupttrick. 🪄 +Und im Code erhalten wir ein `dict` mit allen Daten, die vom Client gesendet wurden, **nur die Daten, die vom Client gesendet wurden**, unter Ausschluss von Werten, die dort nur als Defaultwerte vorhanden wären. Um dies zu tun, verwenden wir `exclude_unset=True`. Das ist der Haupttrick. 🪄 Dann verwenden wir `hero_db.sqlmodel_update(hero_data)`, um die `hero_db` mit den Daten aus `hero_data` zu aktualisieren. diff --git a/docs/de/docs/tutorial/testing.md b/docs/de/docs/tutorial/testing.md index 752ff0e8c..75ee9fade 100644 --- a/docs/de/docs/tutorial/testing.md +++ b/docs/de/docs/tutorial/testing.md @@ -188,7 +188,7 @@ Dann machen Sie in Ihren Tests einfach das gleiche. Z. B.: * Um einen *Pfad*- oder *Query*-Parameter zu übergeben, fügen Sie ihn der URL selbst hinzu. -* Um einen JSON-Body zu übergeben, übergeben Sie ein Python-Objekt (z. B. ein `dict`) an den Parameter `json`. +* Um einen JSON-Body zu übergeben, übergeben Sie ein Python-Objekt (z. B. ein `dict`) an den Parameter `json`. * Wenn Sie *Formulardaten* anstelle von JSON senden müssen, verwenden Sie stattdessen den `data`-Parameter. * Um *Header* zu übergeben, verwenden Sie ein `dict` im `headers`-Parameter. * Für *Cookies* ein `dict` im `cookies`-Parameter. diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index faa62e16d..17e83acbf 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -272,6 +272,8 @@ Below is a list of English terms and their preferred German translations, separa * «the default value»: «der Defaultwert» * «the default value»: NOT «der Standardwert» * «the default declaration»: «die Default-Deklaration» +* «the dict»: «das Dict» +* «the dictionary»: «das Dictionary» * «the engine»: «die Engine» * «the env var»: «die Umgebungsvariable» * «the error response»: «die Error-Response» From ca6aa6c9d80b057e48976a478d2791d2286520b5 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 31 Aug 2025 03:01:03 +0200 Subject: [PATCH 159/160] Intermezzo: Enum --- docs/de/docs/tutorial/path-params.md | 16 ++++++++-------- docs/de/llm-prompt.md | 2 ++ 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/docs/de/docs/tutorial/path-params.md b/docs/de/docs/tutorial/path-params.md index 0e25cb5f6..d267cda8b 100644 --- a/docs/de/docs/tutorial/path-params.md +++ b/docs/de/docs/tutorial/path-params.md @@ -137,7 +137,7 @@ Wenn Sie eine *Pfadoperation* haben, welche einen *Pfad-Parameter* hat, aber Sie Importieren Sie `Enum` und erstellen Sie eine Unterklasse, die von `str` und `Enum` erbt. -Indem Sie von `str` erben, weiß die API Dokumentation, dass die Werte des Enums vom Typ `str` sein müssen, und wird in der Lage sein, korrekt zu rendern. +Indem Sie von `str` erben, weiß die API Dokumentation, dass die Werte vom Typ `str` sein müssen, und wird in der Lage sein, korrekt zu rendern. Erstellen Sie dann Klassen-Attribute mit festgelegten Werten, welches die erlaubten Werte sein werden: @@ -145,7 +145,7 @@ Erstellen Sie dann Klassen-Attribute mit festgelegten Werten, welches die erlaub /// info | Info -Enumerationen (oder kurz Enums) gibt es in Python seit Version 3.4. +Enumerationen (oder Enums) gibt es in Python seit Version 3.4. /// @@ -167,17 +167,17 @@ Weil die erlaubten Werte für den *Pfad-Parameter* nun vordefiniert sind, kann d -### Mit Python-*Enums* arbeiten { #working-with-python-enumerations } +### Mit Python-*Enumerationen* arbeiten { #working-with-python-enumerations } -Der *Pfad-Parameter* wird ein *Member eines Enums* sein. +Der *Pfad-Parameter* wird ein *Member einer Enumeration* sein. -#### *Enum-Member* vergleichen { #compare-enumeration-members } +#### *Enumeration-Member* vergleichen { #compare-enumeration-members } -Sie können ihn mit einem Member Ihres Enums `ModelName` vergleichen: +Sie können ihn mit einem Member Ihrer Enumeration `ModelName` vergleichen: {* ../../docs_src/path_params/tutorial005.py hl[17] *} -#### *Enum-Wert* erhalten { #get-the-enumeration-value } +#### *Enumerations-Wert* erhalten { #get-the-enumeration-value } Den tatsächlichen Wert (in diesem Fall ein `str`) erhalten Sie via `model_name.value`, oder generell, `ihr_enum_member.value`: @@ -189,7 +189,7 @@ Sie können den Wert `"lenet"` außerdem mittels `ModelName.lenet.value` abrufen /// -#### *Enum-Member* zurückgeben { #return-enumeration-members } +#### *Enumeration-Member* zurückgeben { #return-enumeration-members } Sie können *Enum-Member* in ihrer *Pfadoperation* zurückgeben, sogar verschachtelt in einem JSON-Body (z. B. als `dict`). diff --git a/docs/de/llm-prompt.md b/docs/de/llm-prompt.md index 17e83acbf..29b3d2974 100644 --- a/docs/de/llm-prompt.md +++ b/docs/de/llm-prompt.md @@ -275,6 +275,8 @@ Below is a list of English terms and their preferred German translations, separa * «the dict»: «das Dict» * «the dictionary»: «das Dictionary» * «the engine»: «die Engine» +* «the enumeration»: «die Enumeration» +* «the enum»: «das Enum» * «the env var»: «die Umgebungsvariable» * «the error response»: «die Error-Response» * «the event»: «das Event» From 7ade1cef746520ffc0f878abb5a1b00f89cb7929 Mon Sep 17 00:00:00 2001 From: Nils Lindemann Date: Sun, 31 Aug 2025 03:02:09 +0200 Subject: [PATCH 160/160] Misc fixes and changes Changes until tutorial/query-params.md --- docs/de/docs/advanced/advanced-dependencies.md | 2 +- docs/de/docs/advanced/generate-clients.md | 2 +- docs/de/docs/advanced/openapi-webhooks.md | 2 +- docs/de/docs/alternatives.md | 2 +- docs/de/docs/features.md | 2 +- docs/de/docs/tutorial/header-params.md | 4 ++-- docs/de/docs/tutorial/path-operation-configuration.md | 2 +- .../docs/tutorial/path-params-numeric-validations.md | 10 +++++----- docs/de/docs/tutorial/path-params.md | 2 +- docs/de/docs/virtual-environments.md | 4 ++-- .../docs/tutorial/path-params-numeric-validations.md | 2 +- 11 files changed, 17 insertions(+), 17 deletions(-) diff --git a/docs/de/docs/advanced/advanced-dependencies.md b/docs/de/docs/advanced/advanced-dependencies.md index dd165bb90..0f870acdf 100644 --- a/docs/de/docs/advanced/advanced-dependencies.md +++ b/docs/de/docs/advanced/advanced-dependencies.md @@ -36,7 +36,7 @@ Wir könnten eine Instanz dieser Klasse erstellen mit: {* ../../docs_src/dependencies/tutorial011_an_py39.py hl[18] *} -Und auf diese Weise können wir unsere Abhängigkeit „parametrisieren“, die jetzt „bar“ enthält, als das Attribut `checker.fixed_content`. +Und auf diese Weise können wir unsere Abhängigkeit „parametrisieren“, die jetzt `"bar"` enthält, als das Attribut `checker.fixed_content`. ## Die Instanz als Abhängigkeit verwenden { #use-the-instance-as-a-dependency } diff --git a/docs/de/docs/advanced/generate-clients.md b/docs/de/docs/advanced/generate-clients.md index b9ca5e808..d8836295b 100644 --- a/docs/de/docs/advanced/generate-clients.md +++ b/docs/de/docs/advanced/generate-clients.md @@ -2,7 +2,7 @@ Da **FastAPI** auf der **OpenAPI**-Spezifikation basiert, können dessen APIs in einem standardisierten Format beschrieben werden, das viele Tools verstehen. -Dies vereinfacht es, aktuelle **Dokumentation** und Client-Bibliotheken (**SDKs**) in verschiedenen Sprachen zu generieren sowie **Test-** oder **Automatisierungs-Workflows**, die mit Ihrem Code synchron bleiben. +Dies vereinfacht es, aktuelle **Dokumentation** und Client-Bibliotheken (**SDKs**) in verschiedenen Sprachen zu generieren sowie **Test-** oder **Automatisierungs-Workflows**, die mit Ihrem Code synchron bleiben. In diesem Leitfaden erfahren Sie, wie Sie ein **TypeScript-SDK** für Ihr FastAPI-Backend generieren. diff --git a/docs/de/docs/advanced/openapi-webhooks.md b/docs/de/docs/advanced/openapi-webhooks.md index 1aab619b1..2b9c51885 100644 --- a/docs/de/docs/advanced/openapi-webhooks.md +++ b/docs/de/docs/advanced/openapi-webhooks.md @@ -12,7 +12,7 @@ Der Prozess besteht normalerweise darin, dass **Sie in Ihrem Code definieren**, Sie definieren auch auf irgendeine Weise, in welchen **Momenten** Ihre App diese Requests oder Events senden wird. -Und **Ihre Benutzer** definieren auf irgendeine Weise (zum Beispiel irgendwo in einem Web-Dashboard) die **URL**, an die Ihre App diese Requests senden soll. +Und **Ihre Benutzer** definieren auf irgendeine Weise (zum Beispiel irgendwo in einem Web-Dashboard) die **URL**, an die Ihre App diese Requests senden soll. Die gesamte **Logik** zur Registrierung der URLs für Webhooks und der Code zum tatsächlichen Senden dieser Requests liegt bei Ihnen. Sie schreiben es so, wie Sie möchten, in **Ihrem eigenen Code**. diff --git a/docs/de/docs/alternatives.md b/docs/de/docs/alternatives.md index 6b32bc2ce..d573ca6b3 100644 --- a/docs/de/docs/alternatives.md +++ b/docs/de/docs/alternatives.md @@ -337,7 +337,7 @@ Da es auf dem bisherigen Standard für synchrone Python-Webframeworks (WSGI) bas /// info | Info -Hug wurde von Timothy Crosley erstellt, dem gleichen Schöpfer von `isort`, einem großartigen Tool zum automatischen Sortieren von Importen in Python-Dateien. +Hug wurde von Timothy Crosley erstellt, demselben Schöpfer von `isort`, einem großartigen Tool zum automatischen Sortieren von Importen in Python-Dateien. /// diff --git a/docs/de/docs/features.md b/docs/de/docs/features.md index 8d3ec37e6..2b42d1f1e 100644 --- a/docs/de/docs/features.md +++ b/docs/de/docs/features.md @@ -134,7 +134,7 @@ Zusätzlich alle Sicherheitsfunktionen von Starlette (inklusive **Session Cookie Alles als wiederverwendbare Tools und Komponenten gebaut, die einfach in Ihre Systeme, Datenspeicher, relationale und nicht-relationale Datenbanken, usw., integriert werden können. -### Einbringen von Abhängigkeiten (Dependency Injection) { #dependency-injection } +### Dependency Injection { #dependency-injection } FastAPI enthält ein extrem einfach zu verwendendes, aber extrem mächtiges Dependency Injection System. diff --git a/docs/de/docs/tutorial/header-params.md b/docs/de/docs/tutorial/header-params.md index 5bf917184..5c0bb3f87 100644 --- a/docs/de/docs/tutorial/header-params.md +++ b/docs/de/docs/tutorial/header-params.md @@ -12,7 +12,7 @@ Importieren Sie zuerst `Header`: Deklarieren Sie dann die Header-Parameter mit derselben Struktur wie bei `Path`, `Query` und `Cookie`. -Sie können den Defaultwert sowie alle zusätzlichen Validierungs- oder Annotierungsparameter definieren: +Sie können den Defaultwert sowie alle zusätzlichen Validierungs- oder Annotationsparameter definieren: {* ../../docs_src/header_params/tutorial001_an_py310.py hl[9] *} @@ -56,7 +56,7 @@ Bevor Sie `convert_underscores` auf `False` setzen, bedenken Sie, dass manche HT ## Doppelte Header { #duplicate-headers } -Es ist möglich, doppelte Header zu empfangen. Das bedeutet, denselben Header mit mehreren Werten. +Es ist möglich, doppelte Header zu empfangen. Damit ist gemeint, denselben Header mit mehreren Werten. Sie können solche Fälle definieren, indem Sie in der Typdeklaration eine Liste verwenden. diff --git a/docs/de/docs/tutorial/path-operation-configuration.md b/docs/de/docs/tutorial/path-operation-configuration.md index 41a965827..c483f4e40 100644 --- a/docs/de/docs/tutorial/path-operation-configuration.md +++ b/docs/de/docs/tutorial/path-operation-configuration.md @@ -30,7 +30,7 @@ Sie können auch `from starlette import status` verwenden. ## Tags { #tags } -Sie können Ihrer *Pfadoperation* Tags hinzufügen, indem Sie dem Parameter `tags` eine `list` von `str` übergeben (in der Regel nur ein `str`): +Sie können Ihrer *Pfadoperation* Tags hinzufügen, indem Sie dem Parameter `tags` eine `list`e von `str`s übergeben (in der Regel nur ein `str`): {* ../../docs_src/path_operation_configuration/tutorial002_py310.py hl[15,20,25] *} diff --git a/docs/de/docs/tutorial/path-params-numeric-validations.md b/docs/de/docs/tutorial/path-params-numeric-validations.md index 60101096e..36f466059 100644 --- a/docs/de/docs/tutorial/path-params-numeric-validations.md +++ b/docs/de/docs/tutorial/path-params-numeric-validations.md @@ -1,6 +1,6 @@ # Pfad-Parameter und Validierung von Zahlen { #path-parameters-and-numeric-validations } -So wie Sie mit `Query` für Query-Parameter zusätzliche Validierungen und Metadaten hinzufügen können, können Sie das gleiche für Pfad-Parameter mit `Path` tun. +So wie Sie mit `Query` für Query-Parameter zusätzliche Validierungen und Metadaten deklarieren können, können Sie mit `Path` die gleichen Validierungen und Metadaten für Pfad-Parameter deklarieren. ## `Path` importieren { #import-path } @@ -14,13 +14,13 @@ FastAPI hat in Version 0.95.0 Unterstützung für `Annotated` hinzugefügt und e Wenn Sie eine ältere Version haben, würden Fehler angezeigt werden, wenn Sie versuchen, `Annotated` zu verwenden. -Stellen Sie sicher, dass Sie [FastAPI aktualisieren](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} auf mindestens Version 0.95.1, bevor Sie `Annotated` verwenden. +Stellen Sie sicher, dass Sie [FastAPI aktualisieren](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank}, auf mindestens Version 0.95.1, bevor Sie `Annotated` verwenden. /// ## Metadaten deklarieren { #declare-metadata } -Sie können alle gleichen Parameter wie für `Query` deklarieren. +Sie können dieselben Parameter wie für `Query` deklarieren. Um zum Beispiel einen `title`-Metadaten-Wert für den Pfad-Parameter `item_id` zu deklarieren, können Sie schreiben: @@ -44,7 +44,7 @@ Angenommen, Sie möchten den Query-Parameter `q` als erforderlichen `str` deklar Und Sie müssen sonst nichts anderes für diesen Parameter deklarieren, Sie brauchen also `Query` nicht wirklich. -Aber Sie müssen dennoch `Path` für den `item_id` Pfad-Parameter verwenden. Und aus irgendeinem Grund möchten Sie `Annotated` nicht verwenden. +Aber Sie müssen dennoch `Path` für den `item_id`-Pfad-Parameter verwenden. Und aus irgendeinem Grund möchten Sie `Annotated` nicht verwenden. Python wird sich beschweren, wenn Sie einen Wert mit einem „Default“ vor einem Wert ohne „Default“ setzen. @@ -82,7 +82,7 @@ Hier ist ein **kleiner Trick**, der nützlich sein kann, obwohl Sie ihn nicht of Wenn Sie: -* den `q` Query-Parameter sowohl ohne `Query` als auch ohne Defaultwert deklarieren +* den `q`-Query-Parameter sowohl ohne `Query` als auch ohne Defaultwert deklarieren * den Pfad-Parameter `item_id` mit `Path` deklarieren * sie in einer anderen Reihenfolge haben * nicht `Annotated` verwenden diff --git a/docs/de/docs/tutorial/path-params.md b/docs/de/docs/tutorial/path-params.md index d267cda8b..5f5e229a8 100644 --- a/docs/de/docs/tutorial/path-params.md +++ b/docs/de/docs/tutorial/path-params.md @@ -1,6 +1,6 @@ # Pfad-Parameter { #path-parameters } -Sie können Pfad-„Parameter“ oder -„Variablen“ mit der gleichen Syntax deklarieren, welche in Python-Formatstrings verwendet wird: +Sie können Pfad-„Parameter“ oder -„Variablen“ mit der gleichen Syntax deklarieren, welche in Python-Formatstrings verwendet wird: {* ../../docs_src/path_params/tutorial001.py hl[6:7] *} diff --git a/docs/de/docs/virtual-environments.md b/docs/de/docs/virtual-environments.md index 8f0faa3f9..e91ee27b5 100644 --- a/docs/de/docs/virtual-environments.md +++ b/docs/de/docs/virtual-environments.md @@ -387,12 +387,12 @@ $ python main.py Hello World ``` - ++
## Ihren Editor konfigurieren { #configure-your-editor } -Sie würden wahrscheinlich einen Editor verwenden, stellen Sie sicher, dass Sie ihn so konfigurieren, dass er die gleiche virtuelle Umgebung verwendet, die Sie erstellt haben (er wird sie wahrscheinlich automatisch erkennen), sodass Sie Autovervollständigungen und Inline-Fehler erhalten können. +Sie würden wahrscheinlich einen Editor verwenden, stellen Sie sicher, dass Sie ihn so konfigurieren, dass er dieselbe virtuelle Umgebung verwendet, die Sie erstellt haben (er wird sie wahrscheinlich automatisch erkennen), sodass Sie Autovervollständigungen und Inline-Fehler erhalten können. Zum Beispiel: diff --git a/docs/en/docs/tutorial/path-params-numeric-validations.md b/docs/en/docs/tutorial/path-params-numeric-validations.md index 435606bbf..ef1caea42 100644 --- a/docs/en/docs/tutorial/path-params-numeric-validations.md +++ b/docs/en/docs/tutorial/path-params-numeric-validations.md @@ -2,7 +2,7 @@ In the same way that you can declare more validations and metadata for query parameters with `Query`, you can declare the same type of validations and metadata for path parameters with `Path`. -## Import Path { #import-path } +## Import `Path` { #import-path } First, import `Path` from `fastapi`, and import `Annotated`: