@@ -372,7 +372,7 @@ $ pip install -r requirements.txt
//// tab | `uv`
-Si vous avez
-Cela téléchargera un fichier compressé avec le code de FastAPI, normalement depuis
.
+Cela téléchargera un fichier compressé avec le code de FastAPI, normalement depuis [PyPI](https://pypi.org/project/fastapi/).
Il téléchargera également des fichiers pour d’autres packages dont FastAPI dépend.
@@ -627,7 +627,7 @@ $ .venv\Scripts\Activate.ps1
//// tab | Windows Bash
-Ou si vous utilisez Bash pour Windows (par exemple
) :
+Ou si vous utilisez Bash pour Windows (par exemple [Git Bash](https://gitforwindows.org/)) :
@@ -639,13 +639,13 @@ $ source .venv/Scripts/activate
////
-Cette commande créera ou modifiera certaines [variables d’environnement](environment-variables.md){.internal-link target=_blank} qui seront disponibles pour les prochaines commandes.
+Cette commande créera ou modifiera certaines [variables d’environnement](environment-variables.md) qui seront disponibles pour les prochaines commandes.
L’une de ces variables est la variable `PATH`.
/// tip | Astuce
-Vous pouvez en savoir plus sur la variable d’environnement `PATH` dans la section [Variables d’environnement](environment-variables.md#path-environment-variable){.internal-link target=_blank}.
+Vous pouvez en savoir plus sur la variable d’environnement `PATH` dans la section [Variables d’environnement](environment-variables.md#path-environment-variable).
///
@@ -846,7 +846,7 @@ Ceci est un guide simple pour vous lancer et vous montrer comment tout fonctionn
Il existe de nombreuses alternatives pour gérer les environnements virtuels, les dépendances de packages (requirements), les projets.
-Lorsque vous êtes prêt et souhaitez utiliser un outil pour gérer l’ensemble du projet, les dépendances, les environnements virtuels, etc., je vous suggère d’essayer
uv.
+Lorsque vous êtes prêt et souhaitez utiliser un outil pour gérer l’ensemble du projet, les dépendances, les environnements virtuels, etc., je vous suggère d’essayer [uv](https://github.com/astral-sh/uv).
`uv` peut faire beaucoup de choses, il peut :
diff --git a/docs/ja/docs/advanced/json-base64-bytes.md b/docs/ja/docs/advanced/json-base64-bytes.md
new file mode 100644
index 0000000000..c3c361a96b
--- /dev/null
+++ b/docs/ja/docs/advanced/json-base64-bytes.md
@@ -0,0 +1,63 @@
+# Base64 にしたバイトを含む JSON { #json-with-bytes-as-base64 }
+
+アプリで JSON データの受信・送信が必要だが、その中にバイナリデータを含める必要がある場合は、base64 にエンコードできます。
+
+## Base64 とファイル { #base64-vs-files }
+
+バイナリデータのアップロードにはまず、JSON にエンコードする代わりに [Request Files](../tutorial/request-files.md) を、バイナリデータの送信には [カスタムレスポンス - FileResponse](./custom-response.md#fileresponse--fileresponse-) を使えるか検討してください。
+
+JSON は UTF-8 でエンコードされた文字列のみを含められるため、生のバイト列は含められません。
+
+Base64 はバイナリデータを文字列にエンコードできますが、そのために元のバイナリより多くの文字を使用する必要があり、通常は通常のファイルより非効率です。
+
+JSON にバイナリデータをどうしても含める必要があり、ファイルを使えない場合にのみ base64 を使用してください。
+
+## Pydantic `bytes` { #pydantic-bytes }
+
+Pydantic モデルで `bytes` 型のフィールドを宣言し、モデル設定で `val_json_bytes` を使うと、入力 JSON データの検証時に base64 を用いるよう指示できます。この検証の一環として、base64 文字列はバイト列へデコードされます。
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
+
+「/docs」を確認すると、`data` フィールドが base64 でエンコードされたバイト列を期待していることが表示されます。
+
+
+
+
+
+次のようなリクエストを送れます:
+
+```json
+{
+ "description": "Some data",
+ "data": "aGVsbG8="
+}
+```
+
+/// tip | 豆知識
+
+`aGVsbG8=` は `hello` の base64 エンコードです。
+
+///
+
+その後、Pydantic は base64 文字列をデコードし、モデルの `data` フィールドに元のバイト列を渡します。
+
+次のようなレスポンスを受け取ります:
+
+```json
+{
+ "description": "Some data",
+ "content": "hello"
+}
+```
+
+## 出力データ向けの Pydantic `bytes` { #pydantic-bytes-for-output-data }
+
+出力データ用にモデル設定で `ser_json_bytes` とともに `bytes` フィールドを使用することもでき、Pydantic は JSON レスポンスを生成するときにバイト列を base64 でシリアライズします。
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,12:16,29,38:41] hl[16] *}
+
+## 入力・出力データ向けの Pydantic `bytes` { #pydantic-bytes-for-input-and-output-data }
+
+もちろん、同じモデルを base64 を使うように設定しておけば、JSON データの受信時は `val_json_bytes` で入力を「検証」し、送信時は `ser_json_bytes` で出力を「シリアライズ」する、といった具合に、入力と出力の両方を扱えます。
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,19:26,29,44:46] hl[23:26] *}
diff --git a/docs/ja/docs/advanced/stream-data.md b/docs/ja/docs/advanced/stream-data.md
new file mode 100644
index 0000000000..52bbfd3fd3
--- /dev/null
+++ b/docs/ja/docs/advanced/stream-data.md
@@ -0,0 +1,117 @@
+# データのストリーミング { #stream-data }
+
+JSON として構造化できるデータをストリームしたい場合は、[JSON Lines をストリームする](../tutorial/stream-json-lines.md) を参照してください。
+
+しかし、純粋なバイナリデータや文字列をストリームしたい場合は、次のようにできます。
+
+/// info | 情報
+
+FastAPI 0.134.0 で追加されました。
+
+///
+
+## ユースケース { #use-cases }
+
+例えば、AI LLM サービスの出力をそのまま、純粋な文字列としてストリームしたい場合に使えます。
+
+メモリに一度に全て読み込むことなく、読み込みながらチャンクごとに送ることで、巨大なバイナリファイルをストリームすることにも使えます。
+
+同様に、動画や音声をストリームすることもできます。処理しながら生成し、そのまま送信することも可能です。
+
+## `yield` を使った `StreamingResponse` { #a-streamingresponse-with-yield }
+
+path operation 関数で `response_class=StreamingResponse` を宣言すると、`yield` を使ってデータをチャンクごとに順次送信できます。
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[1:23] hl[20,23] *}
+
+FastAPI は各データチャンクをそのまま `StreamingResponse` に渡し、JSON などに変換しようとはしません。
+
+### 非 async な path operation 関数 { #non-async-path-operation-functions }
+
+`async` なしの通常の `def` 関数でも同様に `yield` を使えます。
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[26:29] hl[27] *}
+
+### アノテーションなし { #no-annotation }
+
+バイナリデータをストリームする場合、戻り値の型アノテーションを宣言する必要は実際にはありません。
+
+この場合、FastAPI はデータを Pydantic で JSON 化したり、何らかの方法でシリアライズしようとしないため、型アノテーションはエディタやツール向けの補助にすぎず、FastAPI 自体では使用されません。
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[32:35] hl[33] *}
+
+つまり、`StreamingResponse` では型アノテーションに依存せず、送信したい形式に合わせてバイト列を生成・エンコードする「自由」と「責任」があなたにあります。 🤓
+
+### バイト列をストリームする { #stream-bytes }
+
+主なユースケースの一つは、文字列ではなく `bytes` をストリームすることです。もちろん可能です。
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[44:47] hl[47] *}
+
+## カスタム `PNGStreamingResponse` { #a-custom-pngstreamingresponse }
+
+上記の例ではバイト列をストリームしましたが、レスポンスに `Content-Type` ヘッダがないため、クライアントは受け取るデータの種類を認識できませんでした。
+
+`StreamingResponse` を継承したカスタムクラスを作成し、ストリームするデータに応じて `Content-Type` ヘッダを設定できます。
+
+例えば、`media_type` 属性で `Content-Type` を `image/png` に設定する `PNGStreamingResponse` を作成できます:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[6,19:20] hl[20] *}
+
+その後、path operation 関数で `response_class=PNGStreamingResponse` としてこの新しいクラスを使用できます:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[23:27] hl[23] *}
+
+### ファイルを模擬する { #simulate-a-file }
+
+この例では `io.BytesIO` でファイルを模擬しています。これはメモリ上だけに存在するファイルライクオブジェクトですが、通常のファイルと同じインターフェースを提供します。
+
+例えば、ファイルと同様にイテレートして内容を読み出せます。
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[1:27] hl[3,12:13,25] *}
+
+/// note | 技術詳細
+
+他の2つの変数 `image_base64` と `binary_image` は、画像を Base64 でエンコードし、それを `bytes` に変換してから `io.BytesIO` に渡したものです。
+
+この例では1つのファイル内に完結させ、コピーしてそのまま実行できるようにするためだけのものです。 🥚
+
+///
+
+`with` ブロックを使うことで、ジェネレータ関数（`yield` を持つ関数）が終了した後、つまりレスポンス送信が完了した後に、そのファイルライクオブジェクトが確実にクローズされます。
+
+この例では `io.BytesIO` によるメモリ内の疑似ファイルなので重要度は高くありませんが、実ファイルの場合は処理後に確実にクローズすることが重要です。
+
+### ファイルと非同期 { #files-and-async }
+
+多くの場合、ファイルライクオブジェクトはデフォルトでは async/await と互換性がありません。
+
+例えば、`await file.read()` や `async for chunk in file` のような操作は提供されていません。
+
+また、多くの場合、ディスクやネットワークから読み出すため、読み取りはブロッキング（イベントループをブロックし得る）処理になります。
+
+/// info | 情報
+
+上記の例は例外で、`io.BytesIO` は既にメモリ上にあるため、読み取りが何かをブロックすることはありません。
+
+しかし多くの場合、ファイルやファイルライクオブジェクトの読み取りはブロッキングになります。
+
+///
+
+イベントループのブロッキングを避けるには、path operation 関数を `async def` ではなく通常の `def` で宣言してください。そうすると FastAPI はその関数をスレッドプールワーカー上で実行し、メインループのブロッキングを避けます。
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}
+
+/// tip | 豆知識
+
+async 関数内からブロッキングなコードを呼び出す必要がある場合、あるいはブロッキングな関数内から async 関数を呼び出す必要がある場合は、FastAPI の兄弟ライブラリである [Asyncer](https://asyncer.tiangolo.com) を利用できます。
+
+///
+
+### `yield from` { #yield-from }
+
+ファイルライクオブジェクトのようなものをイテレートして各要素に対して `yield` している場合、`for` ループを省略して、`yield from` で各要素をそのまま送ることもできます。
+
+これは FastAPI 固有ではなく単なる Python の機能ですが、知っておくと便利な小ワザです。 😎
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[37:40] hl[40] *}
diff --git a/docs/ja/docs/advanced/strict-content-type.md b/docs/ja/docs/advanced/strict-content-type.md
new file mode 100644
index 0000000000..994cb86722
--- /dev/null
+++ b/docs/ja/docs/advanced/strict-content-type.md
@@ -0,0 +1,88 @@
+# Content-Type の厳格チェック { #strict-content-type-checking }
+
+既定では、FastAPI は JSON リクエストボディに対して厳格な `Content-Type` ヘッダーのチェックを行います。つまり、JSON のリクエストを JSON として解析するには、有効な `Content-Type` ヘッダー（例: `application/json`）を必ず含める必要があります。
+
+## CSRF のリスク { #csrf-risk }
+
+この既定の挙動は、ある特定の状況における Cross-Site Request Forgery（CSRF）攻撃の一種に対する保護を提供します。
+
+これらの攻撃は、次の条件を満たすときにブラウザが CORS のプリフライトチェックを行わずにスクリプトからリクエストを送信できる事実を悪用します。
+
+- `Content-Type` ヘッダーがない（例: `Blob` をボディにして `fetch()` を使う）
+- かつ、いかなる認証情報も送信しない
+
+この種の攻撃は主に次のような場合に関係します。
+
+- アプリケーションがローカル（例: `localhost`）または社内ネットワークで動作している
+- かつ、アプリに認証がなく、同一ネットワークからのリクエストは信頼できると想定している
+
+## 攻撃例 { #example-attack }
+
+ローカルで AI エージェントを実行できる仕組みを構築したとします。
+
+それは次の API を提供します。
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+フロントエンドもあります。
+
+```
+http://localhost:8000
+```
+
+/// tip | 豆知識
+
+両方とも同じホストであることに注意してください。
+
+///
+
+そのフロントエンドを使って、AI エージェントに自分の代わりに作業をさせられます。
+
+それが「公開インターネット」ではなくローカルで動作しているため、ローカルネットワークへのアクセスを信頼し、認証を一切設定しないことにしたとします。
+
+すると、ユーザーの一人がそれをインストールしてローカルで実行できます。
+
+その後、例えば次のような悪意のあるサイトを開く可能性があります。
+
+```
+https://evilhackers.example.com
+```
+
+そしてその悪意のあるサイトが、`Blob` をボディにした `fetch()` を使ってローカルの API にリクエストを送信します。
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+悪意のあるサイトとローカルアプリのホストは異なるにもかかわらず、ブラウザは次の理由で CORS のプリフライトリクエストを発行しません。
+
+- 認証なしで動作しており、認証情報を送る必要がないため
+- ブラウザは（`Content-Type` ヘッダーがないため）JSON を送っていないと判断するため
+
+その結果、悪意のあるサイトがローカルの AI エージェントに、ユーザーの元上司に怒りのメッセージを送らせることができてしまいます... あるいは、もっと悪いことも。 😅
+
+## 公開インターネット { #open-internet }
+
+アプリが公開インターネット上にある場合、「ネットワークを信頼」して認証なしで誰にでも特権的なリクエストを送らせることはしないはずです。
+
+攻撃者は単にスクリプトを実行して API にリクエストを送れます。ブラウザを介する必要がないため、すでに特権エンドポイントは保護しているでしょう。
+
+その場合、これはあなたには当てはまらない攻撃／リスクです。
+
+このリスクと攻撃が主に問題になるのは、アプリがローカルネットワークで動作し、それだけが前提の保護となっている場合です。
+
+## Content-Type なしのリクエストを許可する { #allowing-requests-without-content-type }
+
+`Content-Type` ヘッダーを送らないクライアントをサポートする必要がある場合は、`strict_content_type=False` を設定して厳格チェックを無効化できます。
+
+{* ../../docs_src/strict_content_type/tutorial001_py310.py hl[4] *}
+
+この設定では、`Content-Type` ヘッダーがないリクエストでもボディが JSON として解析されます。これは古いバージョンの FastAPI と同じ挙動です。
+
+/// info | 情報
+
+この挙動と設定は FastAPI 0.132.0 で追加されました。
+
+///
diff --git a/docs/ja/docs/editor-support.md b/docs/ja/docs/editor-support.md
new file mode 100644
index 0000000000..d82e970f95
--- /dev/null
+++ b/docs/ja/docs/editor-support.md
@@ -0,0 +1,23 @@
+# エディタ対応 { #editor-support }
+
+公式の[FastAPI Extension](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode)は、*path operation* の検出・ナビゲーションに加え、FastAPI Cloud へのデプロイやライブログストリーミングなど、FastAPI の開発ワークフローを強化します。
+
+拡張機能の詳細は、[GitHub リポジトリ](https://github.com/fastapi/fastapi-vscode)の README を参照してください。
+
+## セットアップとインストール { #setup-and-installation }
+
+**FastAPI Extension** は [VS Code](https://code.visualstudio.com/) と [Cursor](https://www.cursor.com/) の両方で利用できます。各エディタの拡張機能パネルから「FastAPI」を検索し、**FastAPI Labs** が公開している拡張機能を選択して直接インストールできます。 [vscode.dev](https://vscode.dev) や [github.dev](https://github.dev) などのブラウザベースのエディタでも動作します。
+
+### アプリケーション検出 { #application-discovery }
+
+既定では、ワークスペース内で `FastAPI()` を生成しているファイルを走査し、FastAPI アプリケーションを自動検出します。プロジェクト構成の都合で自動検出が機能しない場合は、`pyproject.toml` の `[tool.fastapi]`、または VS Code 設定の `fastapi.entryPoint` にモジュール記法（例: `myapp.main:app`）でエントリポイントを指定できます。
+
+## 機能 { #features }
+
+- **Path Operation エクスプローラー** - アプリケーション内のすべての
*path operations* をサイドバーのツリービューで表示します。クリックして任意のルートまたはルーター定義へジャンプできます。
+- **ルート検索** -
Ctrl +
Shift +
E（macOS:
Cmd +
Shift +
E）で、パス・メソッド・名前で検索できます。
+- **CodeLens ナビゲーション** - テストクライアント呼び出し（例: `client.get('/items')`）の上に表示されるクリック可能なリンクから、対応する *path operation* にジャンプし、テストと実装の行き来をすばやく行えます。
+- **FastAPI Cloud へデプロイ** - [FastAPI Cloud](https://fastapicloud.com/) にワンクリックでアプリをデプロイできます。
+- **アプリケーションログのストリーミング** - FastAPI Cloud にデプロイしたアプリから、レベルフィルタやテキスト検索付きでリアルタイムにログをストリーミングできます。
+
+拡張機能の機能に慣れるには、コマンドパレット（
Ctrl +
Shift +
P、macOS:
Cmd +
Shift +
P）を開き、"Welcome: Open walkthrough..." を選択してから、"Get started with FastAPI" のウォークスルーを選んでください。
diff --git a/docs/ja/docs/tutorial/server-sent-events.md b/docs/ja/docs/tutorial/server-sent-events.md
new file mode 100644
index 0000000000..d8168cef30
--- /dev/null
+++ b/docs/ja/docs/tutorial/server-sent-events.md
@@ -0,0 +1,120 @@
+# Server-Sent Events (SSE) { #server-sent-events-sse }
+
+**Server-Sent Events** (SSE) を使うと、クライアントへデータをストリーミングできます。
+
+これは[JSON Lines のストリーミング](stream-json-lines.md)に似ていますが、`text/event-stream` フォーマットを使用します。これはブラウザがネイティブに [`EventSource` API](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) でサポートしています。
+
+/// info | 情報
+
+FastAPI 0.135.0 で追加されました。
+
+///
+
+## Server-Sent Events とは { #what-are-server-sent-events }
+
+SSE は、HTTP 経由でサーバーからクライアントへデータをストリーミングするための標準です。
+
+各イベントは、`data`、`event`、`id`、`retry` などの「フィールド」を含む小さなテキストブロックで、空行で区切られます。
+
+次のようになります:
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+SSE は、AI チャットのストリーミング、ライブ通知、ログやオブザビリティなど、サーバーがクライアントへ更新をプッシュする用途で一般的に使われます。
+
+/// tip | 豆知識
+
+バイナリデータ（例: 動画や音声）をストリーミングしたい場合は、上級ガイド [データのストリーミング](../advanced/stream-data.md) を参照してください。
+
+///
+
+## FastAPI で SSE をストリーミング { #stream-sse-with-fastapi }
+
+FastAPI で SSE をストリーミングするには、*path operation 関数*で `yield` を使い、`response_class=EventSourceResponse` を設定します。
+
+`EventSourceResponse` は `fastapi.sse` からインポートします:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+yield された各アイテムは JSON にエンコードされ、SSE イベントの `data:` フィールドで送信されます。
+
+戻り値の型を `AsyncIterable[Item]` と宣言すると、FastAPI は Pydantic を用いてデータを**検証**、**ドキュメント化**、**シリアライズ**します。
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[10:12,23] *}
+
+/// tip | 豆知識
+
+Pydantic が**Rust** 側でシリアライズを行うため、戻り値の型を宣言しない場合に比べて大幅に**高性能**になります。
+
+///
+
+### 非 async の *path operation 関数* { #non-async-path-operation-functions }
+
+通常の `def` 関数（`async` なし）も使用でき、同様に `yield` を使えます。
+
+イベントループをブロックしないよう、FastAPI が正しく実行されるように調整します。
+
+この場合は関数が async ではないため、適切な戻り値の型は `Iterable[Item]` です:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[28:31] hl[29] *}
+
+### 戻り値の型なし { #no-return-type }
+
+戻り値の型を省略することもできます。FastAPI は [`jsonable_encoder`](./encoder.md) を使ってデータを変換し、送信します。
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+`event`、`id`、`retry`、`comment` などの SSE フィールドを設定する必要がある場合は、生データの代わりに `ServerSentEvent` オブジェクトを `yield` できます。
+
+`ServerSentEvent` は `fastapi.sse` からインポートします:
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+`data` フィールドは常に JSON にエンコードされます。Pydantic モデルを含む、JSON にシリアライズ可能な任意の値を渡せます。
+
+## 生データ { #raw-data }
+
+JSON エンコードせずにデータを送る必要がある場合は、`data` の代わりに `raw_data` を使用します。
+
+これは、整形済みテキスト、ログ行、または `[DONE]` のような特別な
"センチネル" 値を送るのに有用です。
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | 備考
+
+`data` と `raw_data` は相互排他的です。各 `ServerSentEvent` ではどちらか一方しか設定できません。
+
+///
+
+## `Last-Event-ID` での再開 { #resuming-with-last-event-id }
+
+接続が途切れた後にブラウザが再接続すると、最後に受信した `id` を `Last-Event-ID` ヘッダーで送信します。
+
+これをヘッダーパラメータとして受け取り、クライアントが離脱した位置からストリームを再開できます:
+
+{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}
+
+## POST での SSE { #sse-with-post }
+
+SSE は `GET` だけでなく、**任意の HTTP メソッド**で動作します。
+
+これは、`POST` 上で SSE をストリーミングする [MCP](https://modelcontextprotocol.io) のようなプロトコルで有用です:
+
+{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}
+
+## 技術詳細 { #technical-details }
+
+FastAPI は SSE のいくつかのベストプラクティスを標準で実装しています。
+
+- メッセージがない場合は 15 秒ごとに「キープアライブ」用の `ping` コメントを送信し、一部のプロキシが接続を閉じるのを防ぎます（[HTML 仕様: Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes) の推奨に従います）。
+- ストリームの**キャッシュを防止**するため、`Cache-Control: no-cache` ヘッダーを設定します。
+- Nginx など一部のプロキシでの**バッファリングを防ぐ**ため、特別なヘッダー `X-Accel-Buffering: no` を設定します。
+
+追加の設定は不要で、そのまま動作します。🤓
diff --git a/docs/ja/docs/tutorial/stream-json-lines.md b/docs/ja/docs/tutorial/stream-json-lines.md
new file mode 100644
index 0000000000..a247234e24
--- /dev/null
+++ b/docs/ja/docs/tutorial/stream-json-lines.md
@@ -0,0 +1,111 @@
+# JSON Lines をストリームする { #stream-json-lines }
+
+データのシーケンスを**「ストリーム」**で送りたい場合、**JSON Lines** を使って実現できます。
+
+/// info | 情報
+
+FastAPI 0.134.0 で追加されました。
+
+///
+
+## ストリームとは { #what-is-a-stream }
+
+データを**ストリーミング**するとは、アイテムの全シーケンスが用意できるのを待たずに、アプリがデータアイテムの送信をクライアントに対して開始することを意味します。
+
+つまり、最初のアイテムを送信し、クライアントはそれを受け取って処理を始めます。その間に、次のアイテムをまだ生成しているかもしれません。
+
+```mermaid
+sequenceDiagram
+ participant App
+ participant Client
+
+ App->>App: Produce Item 1
+ App->>Client: Send Item 1
+ App->>App: Produce Item 2
+ Client->>Client: Process Item 1
+ App->>Client: Send Item 2
+ App->>App: Produce Item 3
+ Client->>Client: Process Item 2
+ App->>Client: Send Item 3
+ Client->>Client: Process Item 3
+ Note over App: Keeps producing...
+ Note over Client: Keeps consuming...
+```
+
+データを送り続ける無限ストリームにすることもできます。
+
+## JSON Lines { #json-lines }
+
+このような場合、1 行に 1 つの JSON オブジェクトを送る「**JSON Lines**」形式を使うのが一般的です。
+
+レスポンスの content type は `application/jsonl`（`application/json` の代わり）となり、ボディは次のようになります:
+
+```json
+{"name": "Plumbus", "description": "A multi-purpose household device."}
+{"name": "Portal Gun", "description": "A portal opening device."}
+{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
+```
+
+これは JSON 配列（Python の list に相当）にとてもよく似ていますが、`[]` で囲まず、アイテム間の `,` もありません。その代わりに、**1 行に 1 つの JSON オブジェクト**で、改行文字で区切られます。
+
+/// info | 情報
+
+重要な点は、クライアントが前の行を消費している間に、アプリ側は次の行を順次生成して送れることです。
+
+///
+
+/// note | 技術詳細
+
+各 JSON オブジェクトは改行で区切られるため、内容にリテラルな改行文字は含められません。ですが、エスケープした改行（`\n`）は含められます。これは JSON 標準の一部です。
+
+とはいえ、通常は気にする必要はありません。自動で処理されますので、読み進めてください。🤓
+
+///
+
+## ユースケース { #use-cases }
+
+これは **AI LLM** サービス、**ログ**や**テレメトリ**、あるいは **JSON** アイテムとして構造化できる他の種類のデータをストリームするのに使えます。
+
+/// tip | 豆知識
+
+動画や音声などのバイナリデータをストリームしたい場合は、上級ガイドを参照してください: [データのストリーム](../advanced/stream-data.md)。
+
+///
+
+## FastAPI で JSON Lines をストリームする { #stream-json-lines-with-fastapi }
+
+FastAPI で JSON Lines をストリームするには、*path operation 関数*で `return` を使う代わりに、`yield` を使って各アイテムを順に生成します。
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[24] *}
+
+送り返す各 JSON アイテムが `Item`（Pydantic モデル）型で、関数が async の場合、戻り値の型を `AsyncIterable[Item]` と宣言できます:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[9:11,22] *}
+
+戻り値の型を宣言すると、FastAPI はそれを使ってデータを**検証**し、OpenAPI に**ドキュメント化**し、**フィルター**し、Pydantic で**シリアライズ**します。
+
+/// tip | 豆知識
+
+Pydantic は **Rust** 側でシリアライズを行うため、戻り値の型を宣言しない場合に比べて大幅に高い**パフォーマンス**が得られます。
+
+///
+
+### 非 async の *path operation 関数* { #non-async-path-operation-functions }
+
+`async` を使わない通常の `def` 関数でも同様に `yield` を使えます。
+
+FastAPI が適切に実行されるように処理するため、イベントループをブロックしません。
+
+この場合は関数が async ではないので、適切な戻り値の型は `Iterable[Item]` です:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[27:30] hl[28] *}
+
+### 戻り値の型なし { #no-return-type }
+
+戻り値の型を省略することもできます。FastAPI はその場合、データを JSON にシリアライズ可能な形に変換するために [`jsonable_encoder`](./encoder.md) を使い、JSON Lines として送信します。
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[33:36] hl[34] *}
+
+## Server-Sent Events (SSE) { #server-sent-events-sse }
+
+FastAPI は Server-Sent Events (SSE) にもファーストクラスで対応しています。とても似ていますが、いくつか追加の詳細があります。次の章で学べます: [Server-Sent Events (SSE)](server-sent-events.md)。🤓
diff --git a/docs/ko/docs/advanced/json-base64-bytes.md b/docs/ko/docs/advanced/json-base64-bytes.md
new file mode 100644
index 0000000000..b5e55a41af
--- /dev/null
+++ b/docs/ko/docs/advanced/json-base64-bytes.md
@@ -0,0 +1,63 @@
+# 바이트를 Base64로 포함하는 JSON { #json-with-bytes-as-base64 }
+
+애플리케이션에서 JSON 데이터를 주고받아야 하지만 그 안에 바이너리 데이터를 포함해야 한다면, base64로 인코딩해서 포함할 수 있습니다.
+
+## Base64와 파일 { #base64-vs-files }
+
+바이너리 데이터 업로드에는 [요청 파일](../tutorial/request-files.md)을, 바이너리 데이터 전송에는 [커스텀 응답 - FileResponse](./custom-response.md#fileresponse--fileresponse-)를 사용할 수 있는지 먼저 고려하세요. JSON으로 인코딩하는 대신 말입니다.
+
+JSON은 UTF-8로 인코딩된 문자열만 포함할 수 있으므로, 원시 바이트를 그대로 담을 수 없습니다.
+
+Base64는 바이너리 데이터를 문자열로 인코딩할 수 있지만, 이를 위해 원래의 바이너리 데이터보다 더 많은 문자 수를 사용해야 하므로 일반적인 파일 전송보다 비효율적일 수 있습니다.
+
+반드시 JSON 안에 바이너리 데이터를 포함해야 하고, 파일을 사용할 수 없을 때만 base64를 사용하세요.
+
+## Pydantic `bytes` { #pydantic-bytes }
+
+`bytes` 필드를 가진 Pydantic 모델을 선언하고, 모델 설정에서 `val_json_bytes`를 사용하도록 지정하면 입력 JSON 데이터를 base64로 “검증”하도록 할 수 있습니다. 이 검증 과정의 일부로 base64 문자열을 바이트로 디코딩합니다.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
+
+`/docs`를 확인하면 `data` 필드가 base64로 인코딩된 bytes를 기대한다고 표시됩니다:
+
+
+
+
+
+아래와 같은 요청을 보낼 수 있습니다:
+
+```json
+{
+ "description": "Some data",
+ "data": "aGVsbG8="
+}
+```
+
+/// tip | 팁
+
+`aGVsbG8=`는 `hello`의 base64 인코딩입니다.
+
+///
+
+그러면 Pydantic이 base64 문자열을 디코딩하여 모델의 `data` 필드에 원래 바이트를 제공합니다.
+
+다음과 같은 응답을 받게 됩니다:
+
+```json
+{
+ "description": "Some data",
+ "content": "hello"
+}
+```
+
+## 출력 데이터용 Pydantic `bytes` { #pydantic-bytes-for-output-data }
+
+출력 데이터에도 모델 설정에서 `ser_json_bytes`와 함께 `bytes` 필드를 사용할 수 있습니다. 그러면 Pydantic이 JSON 응답을 생성할 때 바이트를 base64로 “직렬화”합니다.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,12:16,29,38:41] hl[16] *}
+
+## 입력과 출력 데이터용 Pydantic `bytes` { #pydantic-bytes-for-input-and-output-data }
+
+물론, 동일한 모델을 사용해 JSON 데이터를 받을 때는 `val_json_bytes`로 입력을 “검증”하고, JSON 데이터를 보낼 때는 `ser_json_bytes`로 출력을 “직렬화”하도록 base64를 모두 처리하게 구성할 수 있습니다.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,19:26,29,44:46] hl[23:26] *}
diff --git a/docs/ko/docs/advanced/stream-data.md b/docs/ko/docs/advanced/stream-data.md
new file mode 100644
index 0000000000..5eda170cb5
--- /dev/null
+++ b/docs/ko/docs/advanced/stream-data.md
@@ -0,0 +1,117 @@
+# 데이터 스트리밍 { #stream-data }
+
+JSON으로 구조화할 수 있는 데이터를 스트리밍하려면 [JSON Lines 스트리밍](../tutorial/stream-json-lines.md)을 사용하세요.
+
+하지만 순수 바이너리 데이터나 문자열을 스트리밍하려면 다음과 같이 하면 됩니다.
+
+/// info | 정보
+
+FastAPI 0.134.0에 추가되었습니다.
+
+///
+
+## 사용 예시 { #use-cases }
+
+예를 들어 AI LLM 서비스의 출력에서 바로 순수 문자열을 스트리밍하고 싶다면 이를 사용할 수 있습니다.
+
+또한 큰 바이너리 파일을 스트리밍하는 데 사용할 수 있습니다. 한 번에 모두 메모리로 읽지 않고, 읽는 즉시 데이터 청크를 순차적으로 스트리밍합니다.
+
+이 방식으로 비디오나 오디오를 스트리밍할 수도 있으며, 처리하면서 생성된 데이터를 곧바로 전송할 수도 있습니다.
+
+## `yield`와 함께 `StreamingResponse` 사용하기 { #a-streamingresponse-with-yield }
+
+경로 처리 함수에서 `response_class=StreamingResponse`를 선언하면 `yield`를 사용해 데이터 청크를 순차적으로 보낼 수 있습니다.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[1:23] hl[20,23] *}
+
+FastAPI는 각 데이터 청크를 있는 그대로 `StreamingResponse`에 전달하며, JSON 등으로 변환하려고 하지 않습니다.
+
+### async가 아닌 경로 처리 함수 { #non-async-path-operation-functions }
+
+`async`가 없는 일반 `def` 함수에서도 동일하게 `yield`를 사용할 수 있습니다.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[26:29] hl[27] *}
+
+### 타입 애너테이션 생략하기 { #no-annotation }
+
+바이너리 데이터를 스트리밍할 때는 반환 타입 애너테이션을 굳이 선언할 필요가 없습니다.
+
+FastAPI는 데이터를 Pydantic으로 JSON으로 변환하거나 어떤 방식으로든 직렬화하지 않으므로, 이 경우 타입 애너테이션은 편집기나 도구를 위한 용도일 뿐이며 FastAPI에서는 사용되지 않습니다.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[32:35] hl[33] *}
+
+이는 곧 `StreamingResponse`를 사용할 때 타입 애너테이션과 무관하게, 전송 기준에 맞춰 바이트 데이터를 생성하고 인코딩할 자유와 책임이 여러분에게 있음을 의미합니다. 🤓
+
+### 바이트 스트리밍 { #stream-bytes }
+
+주요 사용 사례 중 하나는 문자열 대신 `bytes`를 스트리밍하는 것입니다. 물론 그렇게 할 수 있습니다.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[44:47] hl[47] *}
+
+## 사용자 정의 `PNGStreamingResponse` { #a-custom-pngstreamingresponse }
+
+위 예시에서는 바이트 데이터를 스트리밍했지만, 응답에 `Content-Type` 헤더가 없어 클라이언트는 어떤 유형의 데이터를 받는지 알 수 없습니다.
+
+스트리밍하는 데이터 유형에 맞춰 `Content-Type` 헤더를 설정하는 `StreamingResponse`의 하위 클래스를 직접 만들 수 있습니다.
+
+예를 들어 `media_type` 속성을 사용해 `Content-Type` 헤더를 `image/png`로 설정하는 `PNGStreamingResponse`를 만들 수 있습니다:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[6,19:20] hl[20] *}
+
+그런 다음 경로 처리 함수에서 `response_class=PNGStreamingResponse`로 이 새 클래스를 사용할 수 있습니다:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[23:27] hl[23] *}
+
+### 파일 시뮬레이션 { #simulate-a-file }
+
+이 예시에서는 `io.BytesIO`로 파일을 시뮬레이션합니다. 이는 메모리에서만 존재하지만 파일과 동일한 인터페이스를 제공하는 파일 유사 객체입니다.
+
+예를 들어 실제 파일처럼 내용을 소비하기 위해 순회(iterate)할 수 있습니다.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[1:27] hl[3,12:13,25] *}
+
+/// note | 기술 세부사항
+
+다른 두 변수 `image_base64`와 `binary_image`는 이미지를 Base64로 인코딩한 뒤 바이트로 변환한 것이며, 이를 `io.BytesIO`에 전달합니다.
+
+이 예시에서 하나의 파일 안에 모두 담아, 그대로 복사해 실행할 수 있도록 하기 위한 목적입니다. 🥚
+
+///
+
+`with` 블록을 사용하면 제너레이터 함수(`yield`가 있는 함수)가 끝난 뒤, 즉 응답 전송이 완료된 후 파일 유사 객체가 닫히도록 보장합니다.
+
+이 예시처럼 메모리 상의 가짜 파일(`io.BytesIO`)이라면 크게 중요하지 않지만, 실제 파일의 경우 작업이 끝난 뒤 파일을 닫는 것이 매우 중요합니다.
+
+### 파일과 비동기 { #files-and-async }
+
+대부분의 경우 파일 유사 객체는 기본적으로 async/await와 호환되지 않습니다.
+
+예를 들어 `await file.read()`나 `async for chunk in file`과 같은 패턴을 지원하지 않습니다.
+
+또한 디스크나 네트워크에서 읽기 때문에, 많은 경우 읽기 작업은 이벤트 루프를 막을 수 있는 블로킹 연산입니다.
+
+/// info | 정보
+
+위의 예시는 예외적인 경우입니다. `io.BytesIO` 객체는 이미 메모리에 있으므로 읽기가 아무 것도 차단하지 않습니다.
+
+하지만 실제 파일이나 파일 유사 객체를 읽을 때는 블로킹되는 경우가 많습니다.
+
+///
+
+이벤트 루프가 블로킹되는 것을 피하려면 경로 처리 함수를 `async def` 대신 일반 `def`로 선언하세요. 그러면 FastAPI가 스레드풀 워커에서 실행하여 메인 루프가 막히지 않도록 합니다.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}
+
+/// tip | 팁
+
+비동기 함수 안에서 블로킹 코드를 호출해야 하거나, 반대로 블로킹 함수 안에서 비동기 함수를 호출해야 한다면 FastAPI의 형제 라이브러리인 [Asyncer](https://asyncer.tiangolo.com)를 사용할 수 있습니다.
+
+///
+
+### `yield from` { #yield-from }
+
+파일 유사 객체처럼 어떤 것을 순회하면서 각 항목마다 `yield`를 하는 대신, `yield from`을 사용해 각 항목을 직접 전달하고 `for` 루프를 생략할 수 있습니다.
+
+이는 FastAPI에 특화된 기능이 아니라 순수한 파이썬 기능이지만, 알아두면 유용한 트릭입니다. 😎
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[37:40] hl[40] *}
diff --git a/docs/ko/docs/advanced/strict-content-type.md b/docs/ko/docs/advanced/strict-content-type.md
new file mode 100644
index 0000000000..82683e15c3
--- /dev/null
+++ b/docs/ko/docs/advanced/strict-content-type.md
@@ -0,0 +1,88 @@
+# 엄격한 Content-Type 확인 { #strict-content-type-checking }
+
+기본적으로 **FastAPI**는 JSON 요청 본문에 대해 엄격한 `Content-Type` 헤더 검사를 사용합니다. 이는 JSON 요청의 본문을 JSON으로 파싱하려면 유효한 `Content-Type` 헤더(예: `application/json`)를 반드시 포함해야 함을 의미합니다.
+
+## CSRF 위험 { #csrf-risk }
+
+이 기본 동작은 매우 특정한 시나리오에서 **Cross-Site Request Forgery (CSRF)** 공격의 한 유형에 대한 보호를 제공합니다.
+
+이러한 공격은 브라우저가 다음과 같은 경우 CORS 사전 요청(preflight) 검사를 수행하지 않고 스크립트가 요청을 보내도록 허용한다는 점을 악용합니다:
+
+- `Content-Type` 헤더가 없음(예: `Blob` 본문과 함께 `fetch()` 사용)
+- 그리고 어떠한 인증 자격 증명도 보내지 않음
+
+이 유형의 공격은 주로 다음과 같은 경우에 관련이 있습니다:
+
+- 애플리케이션이 로컬(예: `localhost`) 또는 내부 네트워크에서 실행 중이고
+- 애플리케이션에 인증이 없어 같은 네트워크에서 오는 모든 요청을 신뢰한다고 가정하는 경우
+
+## 공격 예시 { #example-attack }
+
+로컬 AI 에이전트를 실행하는 방법을 만들었다고 가정해 봅시다.
+
+이 에이전트는 다음 위치에 API를 제공합니다:
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+또한 다음 위치에 프론트엔드가 있습니다:
+
+```
+http://localhost:8000
+```
+
+/// tip | 팁
+
+두 주소 모두 같은 호스트를 사용합니다.
+
+///
+
+그런 다음 프론트엔드를 통해 AI 에이전트가 여러분을 대신해 작업을 수행하도록 할 수 있습니다.
+
+이는 공개 인터넷이 아니라 로컬에서 실행되므로, 여러분은 로컬 네트워크 접근만을 신뢰하고 별도의 인증을 설정하지 않기로 합니다.
+
+그 후 사용자는 이를 설치해 로컬에서 실행할 수 있습니다.
+
+그리고 다음과 같은 악성 웹사이트를 열 수 있습니다:
+
+```
+https://evilhackers.example.com
+```
+
+그 악성 웹사이트가 `Blob` 본문으로 `fetch()`를 사용해 로컬 API로 요청을 보냅니다:
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+악성 웹사이트의 호스트와 로컬 앱의 호스트가 다르더라도, 브라우저는 다음과 같은 이유로 CORS 사전 요청(preflight)을 트리거하지 않습니다:
+
+- 인증 없이 동작하므로 자격 증명을 보낼 필요가 없습니다.
+- 브라우저는 JSON을 보내지 않는다고 판단합니다(`Content-Type` 헤더가 없기 때문).
+
+그러면 악성 웹사이트가 로컬 AI 에이전트로 하여금 사용자의 전 직장 상사에게 화난 메시지를 보내게 하거나... 더 나쁜 일을 시킬 수도 있습니다. 😅
+
+## 공개 인터넷 { #open-internet }
+
+여러분의 앱이 공개 인터넷에 있다면, '네트워크를 신뢰'하여 누구나 인증 없이 권한 있는 요청을 보내도록 두지는 않을 것입니다.
+
+공격자는 브라우저 상호작용 없이도 스크립트를 실행해 여러분의 API로 요청을 보낼 수 있으므로, 아마 이미 권한이 필요한 엔드포인트는 보호하고 있을 것입니다.
+
+그런 경우에는 이 공격/위험은 해당하지 않습니다.
+
+이 위험과 공격은 주로 앱이 **로컬 네트워크**에서 실행되고 그것이 **유일한 보호수단**이라고 가정할 때 관련이 있습니다.
+
+## Content-Type 없이 요청 허용하기 { #allowing-requests-without-content-type }
+
+만약 `Content-Type` 헤더를 보내지 않는 클라이언트를 지원해야 한다면, `strict_content_type=False`로 설정해 엄격한 검사를 비활성화할 수 있습니다:
+
+{* ../../docs_src/strict_content_type/tutorial001_py310.py hl[4] *}
+
+이 설정을 사용하면 `Content-Type` 헤더가 없는 요청도 본문이 JSON으로 파싱됩니다. 이는 이전 버전의 FastAPI와 동일한 동작입니다.
+
+/// info | 정보
+
+이 동작과 설정은 FastAPI 0.132.0에 추가되었습니다.
+
+///
diff --git a/docs/ko/docs/editor-support.md b/docs/ko/docs/editor-support.md
new file mode 100644
index 0000000000..6a6069df27
--- /dev/null
+++ b/docs/ko/docs/editor-support.md
@@ -0,0 +1,23 @@
+# 에디터 지원 { #editor-support }
+
+공식 [FastAPI 확장](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode)은 FastAPI 개발 워크플로우를 강화해 줍니다. *경로 처리* 탐색 및 이동, FastAPI Cloud 배포, 실시간 로그 스트리밍을 제공합니다.
+
+확장에 대한 자세한 내용은 [GitHub 저장소](https://github.com/fastapi/fastapi-vscode)의 README를 참고하세요.
+
+## 설치 및 설정 { #setup-and-installation }
+
+**FastAPI 확장**은 [VS Code](https://code.visualstudio.com/)와 [Cursor](https://www.cursor.com/)에서 사용할 수 있습니다. 각 에디터의 확장(Extensions) 패널에서 "FastAPI"로 검색한 뒤 **FastAPI Labs**가 배포한 확장을 선택해 바로 설치할 수 있습니다. 또한 [vscode.dev](https://vscode.dev), [github.dev](https://github.dev) 같은 브라우저 기반 에디터에서도 동작합니다.
+
+### 애플리케이션 자동 감지 { #application-discovery }
+
+기본적으로 이 확장은 작업 공간에서 `FastAPI()`를 생성하는 파일을 스캔하여 FastAPI 애플리케이션을 자동으로 감지합니다. 프로젝트 구조상 자동 감지가 어려운 경우, `pyproject.toml`의 `[tool.fastapi]` 항목이나 VS Code 설정 `fastapi.entryPoint`에 모듈 표기(예: `myapp.main:app`)로 엔트리포인트를 지정할 수 있습니다.
+
+## 기능 { #features }
+
+- **경로 처리 탐색기** - 애플리케이션의 모든
*경로 처리*를 사이드바 트리 뷰로 확인합니다. 클릭하면 해당 경로 또는 라우터 정의로 바로 이동합니다.
+- **경로 검색** -
Ctrl +
Shift +
E (macOS:
Cmd +
Shift +
E)로 경로, 메서드, 이름으로 검색합니다.
+- **CodeLens 탐색** - 테스트 클라이언트 호출(예: `client.get('/items')`) 위의 클릭 가능한 링크를 통해 해당 *경로 처리*로 즉시 이동하여 테스트와 구현 간을 빠르게 오갈 수 있습니다.
+- **FastAPI Cloud에 배포** - [FastAPI Cloud](https://fastapicloud.com/)로 원클릭 배포를 지원합니다.
+- **애플리케이션 로그 스트리밍** - FastAPI Cloud에 배포된 애플리케이션의 로그를 실시간으로 스트리밍하며, 레벨 필터링과 텍스트 검색을 제공합니다.
+
+확장의 기능을 먼저 익혀보고 싶다면, 명령 팔레트(
Ctrl +
Shift +
P, macOS:
Cmd +
Shift +
P)를 열고 "Welcome: Open walkthrough..."를 선택한 뒤 "Get started with FastAPI" walkthrough를 선택해 보세요.
diff --git a/docs/ko/docs/tutorial/server-sent-events.md b/docs/ko/docs/tutorial/server-sent-events.md
new file mode 100644
index 0000000000..a8ae1180fa
--- /dev/null
+++ b/docs/ko/docs/tutorial/server-sent-events.md
@@ -0,0 +1,120 @@
+# 서버 전송 이벤트(SSE) { #server-sent-events-sse }
+
+브라우저 클라이언트로 데이터를 스트리밍하려면 **Server-Sent Events**(SSE)를 사용할 수 있습니다.
+
+이는 [JSON Lines 스트리밍](stream-json-lines.md)과 비슷하지만, 브라우저가 기본적으로 [`EventSource` API](https://developer.mozilla.org/en-US/docs/Web/API/EventSource)를 통해 지원하는 `text/event-stream` 형식을 사용합니다.
+
+/// info | 정보
+
+FastAPI 0.135.0에 추가되었습니다.
+
+///
+
+## Server-Sent Events란 { #what-are-server-sent-events }
+
+SSE는 서버에서 클라이언트로 HTTP를 통해 데이터를 스트리밍하기 위한 표준입니다.
+
+각 이벤트는 `data`, `event`, `id`, `retry`와 같은 "필드"를 가진 작은 텍스트 블록이며, 빈 줄로 구분됩니다.
+
+다음과 같습니다:
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+SSE는 AI 채팅 스트리밍, 실시간 알림, 로그와 관측성, 그리고 서버가 클라이언트로 업데이트를 푸시하는 여러 경우에 흔히 사용됩니다.
+
+/// tip | 팁
+
+비디오나 오디오처럼 바이너리 데이터를 스트리밍하려면 고급 가이드: [데이터 스트리밍](../advanced/stream-data.md)을 확인하세요.
+
+///
+
+## FastAPI로 SSE 스트리밍 { #stream-sse-with-fastapi }
+
+FastAPI에서 SSE를 스트리밍하려면, 경로 처리 함수에서 `yield`를 사용하고 `response_class=EventSourceResponse`를 설정하세요.
+
+`EventSourceResponse`는 `fastapi.sse`에서 임포트합니다:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+각 `yield`된 항목은 JSON으로 인코딩되어 SSE 이벤트의 `data:` 필드로 전송됩니다.
+
+반환 타입을 `AsyncIterable[Item]`으로 선언하면 FastAPI가 이를 사용해 데이터를 Pydantic으로 **검증**, **문서화**, **직렬화**합니다.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[10:12,23] *}
+
+/// tip | 팁
+
+Pydantic이 **Rust** 쪽에서 직렬화하므로, 반환 타입을 선언하지 않았을 때보다 훨씬 더 높은 **성능**을 얻을 수 있습니다.
+
+///
+
+### 비 async *경로 처리 함수* { #non-async-path-operation-functions }
+
+`async`가 없는 일반 `def` 함수도 사용할 수 있으며, 동일하게 `yield`를 사용할 수 있습니다.
+
+FastAPI가 이벤트 루프를 막지 않도록 올바르게 실행을 보장합니다.
+
+이 경우 함수가 async가 아니므로 적절한 반환 타입은 `Iterable[Item]`입니다:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[28:31] hl[29] *}
+
+### 반환 타입 없음 { #no-return-type }
+
+반환 타입을 생략할 수도 있습니다. FastAPI는 [`jsonable_encoder`](./encoder.md)를 사용해 데이터를 변환하고 전송합니다.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+`event`, `id`, `retry`, `comment` 같은 SSE 필드를 설정해야 한다면, 일반 데이터 대신 `ServerSentEvent` 객체를 `yield`할 수 있습니다.
+
+`ServerSentEvent`는 `fastapi.sse`에서 임포트합니다:
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+`data` 필드는 항상 JSON으로 인코딩됩니다. Pydantic 모델을 포함해 JSON으로 직렬화할 수 있는 값을 모두 전달할 수 있습니다.
+
+## 원시 데이터 { #raw-data }
+
+JSON 인코딩 없이 데이터를 보내야 한다면, `data` 대신 `raw_data`를 사용하세요.
+
+미리 포맷된 텍스트, 로그 라인, 또는 `[DONE]`과 같은 특수한
"센티널" 값을 보낼 때 유용합니다.
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | 참고
+
+`data`와 `raw_data`는 상호 배타적입니다. 각 `ServerSentEvent`에는 이 둘 중 하나만 설정할 수 있습니다.
+
+///
+
+## `Last-Event-ID`로 재개하기 { #resuming-with-last-event-id }
+
+브라우저가 연결이 끊긴 후 재연결할 때, 마지막으로 받은 `id`를 `Last-Event-ID` 헤더에 담아 보냅니다.
+
+헤더 파라미터로 이를 읽어와 클라이언트가 중단한 지점부터 스트림을 재개할 수 있습니다:
+
+{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}
+
+## POST로 SSE 사용하기 { #sse-with-post }
+
+SSE는 `GET`뿐만 아니라 **모든 HTTP 메서드**와 함께 동작합니다.
+
+이는 `POST`로 SSE를 스트리밍하는 [MCP](https://modelcontextprotocol.io) 같은 프로토콜에 유용합니다:
+
+{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}
+
+## 기술 세부사항 { #technical-details }
+
+FastAPI는 일부 SSE 모범 사례를 기본으로 구현합니다.
+
+- 메시지가 없을 때는 15초마다 **"keep alive" `ping` 주석**을 보내 일부 프록시가 연결을 종료하지 않도록 합니다. [HTML 사양: Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes)에서 권장합니다.
+- 스트림이 **캐시되지 않도록** `Cache-Control: no-cache` 헤더를 설정합니다.
+- Nginx 같은 일부 프록시에서 **버퍼링을 방지**하기 위해 특수 헤더 `X-Accel-Buffering: no`를 설정합니다.
+
+여러분이 따로 할 일은 없습니다. 기본값으로 동작합니다. 🤓
diff --git a/docs/ko/docs/tutorial/stream-json-lines.md b/docs/ko/docs/tutorial/stream-json-lines.md
new file mode 100644
index 0000000000..816338d7e3
--- /dev/null
+++ b/docs/ko/docs/tutorial/stream-json-lines.md
@@ -0,0 +1,111 @@
+# JSON Lines 스트리밍 { #stream-json-lines }
+
+연속된 데이터를 "**스트림**"으로 보내고 싶다면 **JSON Lines**를 사용할 수 있습니다.
+
+/// info
+
+FastAPI 0.134.0에 추가되었습니다.
+
+///
+
+## 스트림이란 { #what-is-a-stream }
+
+데이터를 "**스트리밍**"한다는 것은 애플리케이션이 전체 항목 시퀀스가 모두 준비될 때까지 기다리지 않고 클라이언트로 데이터 항목을 보내기 시작한다는 뜻입니다.
+
+즉, 첫 번째 항목을 보내면 클라이언트는 그것을 받아 처리하기 시작하고, 그동안 애플리케이션은 다음 항목을 계속 생성할 수 있습니다.
+
+```mermaid
+sequenceDiagram
+ participant App
+ participant Client
+
+ App->>App: Produce Item 1
+ App->>Client: Send Item 1
+ App->>App: Produce Item 2
+ Client->>Client: Process Item 1
+ App->>Client: Send Item 2
+ App->>App: Produce Item 3
+ Client->>Client: Process Item 2
+ App->>Client: Send Item 3
+ Client->>Client: Process Item 3
+ Note over App: Keeps producing...
+ Note over Client: Keeps consuming...
+```
+
+데이터를 계속 보내는 무한 스트림일 수도 있습니다.
+
+## JSON Lines { #json-lines }
+
+이런 경우에는 한 줄에 하나의 JSON 객체를 보내는 형식인 "**JSON Lines**"를 사용하는 것이 일반적입니다.
+
+응답의 콘텐츠 타입은 `application/json` 대신 `application/jsonl`이고, 본문은 다음과 같습니다:
+
+```json
+{"name": "Plumbus", "description": "A multi-purpose household device."}
+{"name": "Portal Gun", "description": "A portal opening device."}
+{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
+```
+
+JSON 배열(Python의 list에 해당)과 매우 비슷하지만, 항목들을 `[]`로 감싸고 항목 사이에 `,`를 넣는 대신, 줄마다 하나의 JSON 객체가 있고, 새 줄 문자로 구분됩니다.
+
+/// info
+
+핵심은 애플리케이션이 각 줄을 차례로 생성하는 동안, 클라이언트는 이전 줄을 소비할 수 있다는 점입니다.
+
+///
+
+/// note | 기술 세부사항
+
+각 JSON 객체는 새 줄로 구분되므로, 내용에 실제 줄바꿈 문자를 포함할 수는 없습니다. 하지만 JSON 표준의 일부인 이스케이프된 줄바꿈(`\n`)은 포함할 수 있습니다.
+
+보통은 신경 쓸 필요가 없습니다. 자동으로 처리되니 계속 읽어 주세요. 🤓
+
+///
+
+## 사용 예 { #use-cases }
+
+이 방법을 사용해 **AI LLM** 서비스, **로그** 또는 **telemetry**에서 오는 데이터, 혹은 **JSON** 항목으로 구조화할 수 있는 다른 유형의 데이터를 스트리밍할 수 있습니다.
+
+/// tip
+
+비디오나 오디오처럼 바이너리 데이터를 스트리밍하려면 고급 가이드를 확인하세요: [스트림 데이터](../advanced/stream-data.md).
+
+///
+
+## FastAPI로 JSON Lines 스트리밍 { #stream-json-lines-with-fastapi }
+
+FastAPI에서 JSON Lines를 스트리밍하려면, *경로 처리 함수*에서 `return`을 사용하는 대신 `yield`로 각 항목을 차례로 생성하면 됩니다.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[24] *}
+
+보내려는 각 JSON 항목의 타입이 `Item`(Pydantic 모델)이고 함수가 async라면, 반환 타입을 `AsyncIterable[Item]`로 선언할 수 있습니다:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[9:11,22] *}
+
+반환 타입을 선언하면 FastAPI가 이를 사용해 데이터를 **검증**하고, OpenAPI에 **문서화**하고, **필터링**하고, Pydantic으로 **직렬화**합니다.
+
+/// tip
+
+Pydantic이 **Rust** 측에서 직렬화하므로, 반환 타입을 선언하지 않았을 때보다 훨씬 높은 **성능**을 얻게 됩니다.
+
+///
+
+### 비동기 아님 *경로 처리 함수* { #non-async-path-operation-functions }
+
+일반 `def` 함수(`async` 없이)도 사용할 수 있으며, 동일하게 `yield`를 사용할 수 있습니다.
+
+FastAPI가 이벤트 루프를 막지 않도록 올바르게 실행되게 보장합니다.
+
+이 경우 함수가 async가 아니므로, 올바른 반환 타입은 `Iterable[Item]`입니다:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[27:30] hl[28] *}
+
+### 반환 타입 생략 { #no-return-type }
+
+반환 타입을 생략할 수도 있습니다. 그러면 FastAPI가 [`jsonable_encoder`](./encoder.md)를 사용해 데이터를 JSON으로 직렬화 가능한 형태로 변환한 뒤 JSON Lines로 전송합니다.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[33:36] hl[34] *}
+
+## 서버 전송 이벤트(SSE) { #server-sent-events-sse }
+
+FastAPI는 Server-Sent Events(SSE)도 일급으로 지원합니다. 매우 비슷하지만 몇 가지 추가 세부사항이 있습니다. 다음 장에서 자세히 알아보세요: [Server-Sent Events (SSE)](server-sent-events.md). 🤓
diff --git a/docs/pt/docs/_llm-test.md b/docs/pt/docs/_llm-test.md
index 9f03c4b886..d5df9dd8bf 100644
--- a/docs/pt/docs/_llm-test.md
+++ b/docs/pt/docs/_llm-test.md
@@ -11,7 +11,7 @@ Use da seguinte forma:
* Verifique se está tudo certo na tradução.
* Se necessário, melhore seu prompt específico do idioma, o prompt geral ou o documento em inglês.
* Em seguida, corrija manualmente os problemas restantes na tradução, para que fique uma boa tradução.
-* Retraduzir, tendo a boa tradução no lugar. O resultado ideal seria que o LLM não fizesse mais mudanças na tradução. Isso significa que o prompt geral e o seu prompt específico do idioma estão tão bons quanto possível (às vezes fará algumas mudanças aparentemente aleatórias, a razão é que
LLMs não são algoritmos determinísticos).
+* Retraduzir, tendo a boa tradução no lugar. O resultado ideal seria que o LLM não fizesse mais mudanças na tradução. Isso significa que o prompt geral e o seu prompt específico do idioma estão tão bons quanto possível (às vezes fará algumas mudanças aparentemente aleatórias, a razão é que [LLMs não são algoritmos determinísticos](https://doublespeak.chat/#/handbook#deterministic-output)).
Os testes:
@@ -169,15 +169,15 @@ Veja as seções `### Special blocks` e `### Tab blocks` no prompt geral em `scr
O texto do link deve ser traduzido, o endereço do link deve permanecer inalterado:
* [Link para o título acima](#code-snippets)
-* [Link interno](index.md#installation){.internal-link target=_blank}
-*
Link externo
-*
Link para um estilo
-*
Link para um script
-*
Link para uma imagem
+* [Link interno](index.md#installation)
+* [Link externo](https://sqlmodel.tiangolo.com/)
+* [Link para um estilo](https://fastapi.tiangolo.com/css/styles.css)
+* [Link para um script](https://fastapi.tiangolo.com/js/logic.js)
+* [Link para uma imagem](https://fastapi.tiangolo.com/img/foo.jpg)
O texto do link deve ser traduzido, o endereço do link deve apontar para a tradução:
-*
Link do FastAPI
+* [Link do FastAPI](https://fastapi.tiangolo.com/pt/)
////
diff --git a/docs/pt/docs/advanced/additional-responses.md b/docs/pt/docs/advanced/additional-responses.md
index 2e277ac104..1df4b98519 100644
--- a/docs/pt/docs/advanced/additional-responses.md
+++ b/docs/pt/docs/advanced/additional-responses.md
@@ -199,7 +199,7 @@ Você pode declarar um `response_model`, utilizando o código de status padrão
O **FastAPI** manterá as informações adicionais do `responses`, e combinará com o esquema JSON do seu modelo.
-Por exemplo, você pode declarar um retorno com o código de status `404` que utiliza um modelo do Pydantic que possui um `description` customizado.
+Por exemplo, você pode declarar um retorno com o código de status `404` que utiliza um modelo do Pydantic e tem uma `description` customizada.
E um retorno com o código de status `200` que utiliza o seu `response_model`, porém inclui um `example` customizado:
@@ -243,5 +243,5 @@ Por exemplo:
Para verificar exatamente o que você pode incluir nos retornos, você pode conferir estas seções na especificação do OpenAPI:
-*
Objeto de Retornos do OpenAPI, inclui o `Response Object`.
-*
Objeto de Retorno do OpenAPI, você pode incluir qualquer coisa dele diretamente em cada retorno dentro do seu parâmetro `responses`. Incluindo `description`, `headers`, `content` (dentro dele que você declara diferentes media types e esquemas JSON), e `links`.
+* [Objeto de Retornos do OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object), inclui o `Response Object`.
+* [Objeto de Retorno do OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object), você pode incluir qualquer coisa dele diretamente em cada retorno dentro do seu parâmetro `responses`. Incluindo `description`, `headers`, `content` (dentro dele que você declara diferentes media types e esquemas JSON), e `links`.
diff --git a/docs/pt/docs/advanced/additional-status-codes.md b/docs/pt/docs/advanced/additional-status-codes.md
index fd90b1795d..af1cefaf2b 100644
--- a/docs/pt/docs/advanced/additional-status-codes.md
+++ b/docs/pt/docs/advanced/additional-status-codes.md
@@ -38,4 +38,4 @@ O **FastAPI** disponibiliza o `starlette.responses` como `fastapi.responses` ape
Se você retorna códigos de status adicionais e retornos diretamente, eles não serão incluídos no esquema do OpenAPI (a documentação da API), porque o FastAPI não tem como saber de antemão o que será retornado.
-Mas você pode documentar isso no seu código, utilizando: [Retornos Adicionais](additional-responses.md){.internal-link target=_blank}.
+Mas você pode documentar isso no seu código, utilizando: [Retornos Adicionais](additional-responses.md).
diff --git a/docs/pt/docs/advanced/advanced-dependencies.md b/docs/pt/docs/advanced/advanced-dependencies.md
index 419a092c80..dbcf993904 100644
--- a/docs/pt/docs/advanced/advanced-dependencies.md
+++ b/docs/pt/docs/advanced/advanced-dependencies.md
@@ -132,7 +132,7 @@ Se você tiver esse caso específico usando SQLModel (ou SQLAlchemy), você pode
Dessa forma a sessão liberaria a conexão com o banco de dados, para que outras requisições pudessem usá-la.
-Se você tiver um caso diferente que precise sair antecipadamente de uma dependência com `yield`, por favor crie uma
Pergunta no GitHub Discussions com o seu caso específico e por que você se beneficiaria de ter o fechamento antecipado para dependências com `yield`.
+Se você tiver um caso diferente que precise sair antecipadamente de uma dependência com `yield`, por favor crie uma [Pergunta no GitHub Discussions](https://github.com/fastapi/fastapi/discussions/new?category=questions) com o seu caso específico e por que você se beneficiaria de ter o fechamento antecipado para dependências com `yield`.
Se houver casos de uso convincentes para fechamento antecipado em dependências com `yield`, considerarei adicionar uma nova forma de optar por esse fechamento antecipado.
@@ -144,7 +144,7 @@ Isso foi alterado na versão 0.110.0 para corrigir consumo de memória não trat
### Tarefas em Segundo Plano e Dependências com `yield`, Detalhes Técnicos { #background-tasks-and-dependencies-with-yield-technical-details }
-Antes do FastAPI 0.106.0, lançar exceções após o `yield` não era possível, o código de saída em dependências com `yield` era executado depois que a resposta era enviada, então [Tratadores de Exceções](../tutorial/handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank} já teriam sido executados.
+Antes do FastAPI 0.106.0, lançar exceções após o `yield` não era possível, o código de saída em dependências com `yield` era executado depois que a resposta era enviada, então [Tratadores de Exceções](../tutorial/handling-errors.md#install-custom-exception-handlers) já teriam sido executados.
Isso foi projetado assim principalmente para permitir o uso dos mesmos objetos "yielded" por dependências dentro de tarefas em segundo plano, porque o código de saída seria executado depois que as tarefas em segundo plano fossem concluídas.
diff --git a/docs/pt/docs/advanced/async-tests.md b/docs/pt/docs/advanced/async-tests.md
index 2fe678adb9..9dfadc32a1 100644
--- a/docs/pt/docs/advanced/async-tests.md
+++ b/docs/pt/docs/advanced/async-tests.md
@@ -16,11 +16,11 @@ Mesmo que a sua aplicação **FastAPI** utilize funções normais com `def` no l
O `TestClient` faz algumas mágicas para invocar a aplicação FastAPI assíncrona em suas funções `def` normais, utilizando o pytest padrão. Porém a mágica não acontece mais quando nós estamos utilizando dentro de funções assíncronas. Ao executar os nossos testes de forma assíncrona, nós não podemos mais utilizar o `TestClient` dentro das nossas funções de teste.
-O `TestClient` é baseado no
HTTPX, e felizmente nós podemos utilizá-lo diretamente para testar a API.
+O `TestClient` é baseado no [HTTPX](https://www.python-httpx.org), e felizmente nós podemos utilizá-lo diretamente para testar a API.
## Exemplo { #example }
-Para um exemplos simples, vamos considerar uma estrutura de arquivos semelhante ao descrito em [Bigger Applications](../tutorial/bigger-applications.md){.internal-link target=_blank} e [Testing](../tutorial/testing.md){.internal-link target=_blank}:
+Para um exemplos simples, vamos considerar uma estrutura de arquivos semelhante ao descrito em [Aplicações Maiores](../tutorial/bigger-applications.md) e [Testes](../tutorial/testing.md):
```
.
@@ -84,7 +84,7 @@ Note que nós estamos utilizando async/await com o novo `AsyncClient` - a requis
/// warning | Atenção
-Se a sua aplicação depende de eventos de lifespan, o `AsyncClient` não acionará estes eventos. Para garantir que eles são acionados, utilize o `LifespanManager` do
florimondmanca/asgi-lifespan.
+Se a sua aplicação depende de eventos de lifespan, o `AsyncClient` não acionará estes eventos. Para garantir que eles são acionados, utilize o `LifespanManager` do [florimondmanca/asgi-lifespan](https://github.com/florimondmanca/asgi-lifespan#usage).
///
@@ -94,6 +94,6 @@ Como a função de teste agora é assíncrona, você pode chamar (e `await`) out
/// tip | Dica
-Se você se deparar com um `RuntimeError: Task attached to a different loop` ao integrar funções assíncronas em seus testes (e.g. ao utilizar o
MotorClient do MongoDB) Lembre-se de instanciar objetos que precisam de um loop de eventos (*event loop*) apenas em funções assíncronas, e.g. um callback `@app.on_event("startup")`.
+Se você se deparar com um `RuntimeError: Task attached to a different loop` ao integrar funções assíncronas em seus testes (e.g. ao utilizar o [MotorClient do MongoDB](https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop)) Lembre-se de instanciar objetos que precisam de um loop de eventos (*event loop*) apenas em funções assíncronas, e.g. um callback `@app.on_event("startup")`.
///
diff --git a/docs/pt/docs/advanced/behind-a-proxy.md b/docs/pt/docs/advanced/behind-a-proxy.md
index 1581415156..4dcdcc9d05 100644
--- a/docs/pt/docs/advanced/behind-a-proxy.md
+++ b/docs/pt/docs/advanced/behind-a-proxy.md
@@ -16,9 +16,9 @@ Mas, por segurança, como o servidor não sabe que está atrás de um proxy conf
Os headers do proxy são:
-*
X-Forwarded-For
-*
X-Forwarded-Proto
-*
X-Forwarded-Host
+* [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For)
+* [X-Forwarded-Proto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto)
+* [X-Forwarded-Host](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host)
///
@@ -60,7 +60,7 @@ https://mysuperapp.com/items/
/// tip | Dica
-Se você quiser saber mais sobre HTTPS, confira o tutorial [Sobre HTTPS](../deployment/https.md){.internal-link target=_blank}.
+Se você quiser saber mais sobre HTTPS, confira o tutorial [Sobre HTTPS](../deployment/https.md).
///
@@ -228,7 +228,7 @@ Passar o `root_path` para `FastAPI` seria o equivalente a passar a opção de li
Tenha em mente que o servidor (Uvicorn) não usará esse `root_path` para nada além de passá-lo para a aplicação.
-Mas se você acessar com seu navegador
http://127.0.0.1:8000/app você verá a resposta normal:
+Mas se você acessar com seu navegador [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app) você verá a resposta normal:
```JSON
{
@@ -251,9 +251,9 @@ Em um caso como esse (sem um prefixo de path removido), o proxy escutaria em alg
## Testando localmente com Traefik { #testing-locally-with-traefik }
-Você pode facilmente executar o experimento localmente com um prefixo de path removido usando
Traefik.
+Você pode facilmente executar o experimento localmente com um prefixo de path removido usando [Traefik](https://docs.traefik.io/).
-
Faça o download do Traefik, ele é um único binário, você pode extrair o arquivo compactado e executá-lo diretamente do terminal.
+[Faça o download do Traefik](https://github.com/containous/traefik/releases), ele é um único binário, você pode extrair o arquivo compactado e executá-lo diretamente do terminal.
Então, crie um arquivo `traefik.toml` com:
@@ -330,7 +330,7 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
### Verifique as respostas { #check-the-responses }
-Agora, se você for ao URL com a porta para o Uvicorn:
http://127.0.0.1:8000/app, você verá a resposta normal:
+Agora, se você for ao URL com a porta para o Uvicorn: [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app), você verá a resposta normal:
```JSON
{
@@ -345,7 +345,7 @@ Perceba que, mesmo acessando em `http://127.0.0.1:8000/app`, ele mostra o `root_
///
-E agora abra o URL com a porta para o Traefik, incluindo o prefixo de path:
http://127.0.0.1:9999/api/v1/app.
+E agora abra o URL com a porta para o Traefik, incluindo o prefixo de path: [http://127.0.0.1:9999/api/v1/app](http://127.0.0.1:9999/api/v1/app).
Obtemos a mesma resposta:
@@ -370,13 +370,13 @@ Mas aqui está a parte divertida. ✨
A maneira "oficial" de acessar a aplicação seria através do proxy com o prefixo de path que definimos. Então, como esperaríamos, se você tentar a interface de documentação servida diretamente pelo Uvicorn, sem o prefixo de path no URL, ela não funcionará, porque espera ser acessada através do proxy.
-Você pode verificar em
http://127.0.0.1:8000/docs:
+Você pode verificar em [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs):
Mas se acessarmos a interface de documentação no URL "oficial" usando o proxy com a porta `9999`, em `/api/v1/docs`, ela funciona corretamente! 🎉
-Você pode verificar em
http://127.0.0.1:9999/api/v1/docs:
+Você pode verificar em [http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs):
@@ -433,7 +433,7 @@ Perceba o servidor gerado automaticamente com um valor `url` de `/api/v1`, retir
///
-Na interface de documentação em
http://127.0.0.1:9999/api/v1/docs parecerá:
+Na interface de documentação em [http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs) parecerá:
@@ -461,6 +461,6 @@ e então ele não será incluído no OpenAPI schema.
## Montando uma sub-aplicação { #mounting-a-sub-application }
-Se você precisar montar uma sub-aplicação (como descrito em [Sub-aplicações - Montagens](sub-applications.md){.internal-link target=_blank}) enquanto também usa um proxy com `root_path`, você pode fazer isso normalmente, como esperaria.
+Se você precisar montar uma sub-aplicação (como descrito em [Sub-aplicações - Montagens](sub-applications.md)) enquanto também usa um proxy com `root_path`, você pode fazer isso normalmente, como esperaria.
O FastAPI usará internamente o `root_path` de forma inteligente, então tudo funcionará. ✨
diff --git a/docs/pt/docs/advanced/custom-response.md b/docs/pt/docs/advanced/custom-response.md
index a409f1dc85..a360bd3c9b 100644
--- a/docs/pt/docs/advanced/custom-response.md
+++ b/docs/pt/docs/advanced/custom-response.md
@@ -1,58 +1,42 @@
# Resposta Personalizada - HTML, Stream, File e outras { #custom-response-html-stream-file-others }
-Por padrão, o **FastAPI** irá retornar respostas utilizando `JSONResponse`.
+Por padrão, o **FastAPI** retornará respostas JSON.
-Mas você pode sobrescrever esse comportamento utilizando `Response` diretamente, como visto em [Retornando uma Resposta Diretamente](response-directly.md){.internal-link target=_blank}.
+Você pode sobrescrever isso retornando uma `Response` diretamente, como visto em [Retornando uma Resposta Diretamente](response-directly.md).
-Mas se você retornar uma `Response` diretamente (ou qualquer subclasse, como `JSONResponse`), os dados não serão convertidos automaticamente (mesmo que você declare um `response_model`), e a documentação não será gerada automaticamente (por exemplo, incluindo o "media type", no cabeçalho HTTP `Content-Type` como parte do esquema OpenAPI gerado).
+Mas se você retornar uma `Response` diretamente (ou qualquer subclasse, como `JSONResponse`), os dados não serão convertidos automaticamente (mesmo que você declare um `response_model`), e a documentação não será gerada automaticamente (por exemplo, incluindo o "media type" específico, no cabeçalho HTTP `Content-Type` como parte do OpenAPI gerado).
-Mas você também pode declarar a `Response` que você deseja utilizar (e.g. qualquer subclasse de `Response`), em um *decorador de operação de rota* utilizando o parâmetro `response_class`.
+Mas você também pode declarar a `Response` que deseja utilizar (e.g. qualquer subclasse de `Response`), no *decorador de operação de rota* usando o parâmetro `response_class`.
-Os conteúdos que você retorna em sua *função de operação de rota* serão colocados dentro dessa `Response`.
-
-E se a `Response` tiver um media type JSON (`application/json`), como é o caso com `JSONResponse` e `UJSONResponse`, os dados que você retornar serão automaticamente convertidos (e filtrados) com qualquer `response_model` do Pydantic que for declarado no decorador de operação de rota.
+O conteúdo que você retorna da sua *função de operação de rota* será colocado dentro dessa `Response`.
/// note | Nota
-Se você utilizar uma classe de Resposta sem media type, o FastAPI esperará que sua resposta não tenha conteúdo, então ele não irá documentar o formato da resposta na documentação OpenAPI gerada.
+Se você utilizar uma classe de resposta sem media type, o FastAPI esperará que sua resposta não tenha conteúdo, então ele não irá documentar o formato da resposta na documentação OpenAPI gerada.
///
-## Utilizando `ORJSONResponse` { #use-orjsonresponse }
-
-Por exemplo, se você precisa bastante de performance, você pode instalar e utilizar o
`orjson` e definir a resposta para ser uma `ORJSONResponse`.
-
-Importe a classe, ou subclasse, de `Response` que você deseja utilizar e declare ela no *decorador de operação de rota*.
-
-Para respostas grandes, retornar uma `Response` diretamente é muito mais rápido que retornar um dicionário.
-
-Isso ocorre por que, por padrão, o FastAPI irá verificar cada item dentro do dicionário e garantir que ele seja serializável para JSON, utilizando o mesmo[Codificador Compatível com JSON](../tutorial/encoder.md){.internal-link target=_blank} explicado no tutorial. Isso permite que você retorne **objetos abstratos**, como modelos do banco de dados, por exemplo.
-
-Mas se você tem certeza que o conteúdo que você está retornando é **serializável com JSON**, você pode passá-lo diretamente para a classe de resposta e evitar o trabalho extra que o FastAPI teria ao passar o conteúdo pelo `jsonable_encoder` antes de passar para a classe de resposta.
+## Respostas JSON { #json-responses }
-{* ../../docs_src/custom_response/tutorial001b_py310.py hl[2,7] *}
+Por padrão, o FastAPI retorna respostas JSON.
-/// info | Informação
-
-O parâmetro `response_class` também será usado para definir o "media type" da resposta.
+Se você declarar um [Modelo de Resposta](../tutorial/response-model.md), o FastAPI irá usá-lo para serializar os dados para JSON, usando Pydantic.
-Neste caso, o cabeçalho HTTP `Content-Type` irá ser definido como `application/json`.
+Se você não declarar um modelo de resposta, o FastAPI usará o `jsonable_encoder` explicado em [Codificador Compatível com JSON](../tutorial/encoder.md) e o colocará em uma `JSONResponse`.
-E será documentado como tal no OpenAPI.
+Se você declarar uma `response_class` com um media type JSON (`application/json`), como no caso de `JSONResponse`, os dados que você retorna serão automaticamente convertidos (e filtrados) com qualquer `response_model` do Pydantic que você declarou no *decorador de operação de rota*. Mas os dados não serão serializados para bytes JSON com Pydantic; em vez disso, serão convertidos com o `jsonable_encoder` e então passados para a classe `JSONResponse`, que fará a serialização para bytes usando a biblioteca padrão de JSON do Python.
-///
+### Performance com JSON { #json-performance }
-/// tip | Dica
+Resumindo, se você quer o máximo de performance, use um [Modelo de Resposta](../tutorial/response-model.md) e não declare uma `response_class` no *decorador de operação de rota*.
-A `ORJSONResponse` está disponível apenas no FastAPI, e não no Starlette.
-
-///
+{* ../../docs_src/response_model/tutorial001_01_py310.py ln[15:17] hl[16] *}
## Resposta HTML { #html-response }
Para retornar uma resposta com HTML diretamente do **FastAPI**, utilize `HTMLResponse`.
-* Importe `HTMLResponse`
+* Importe `HTMLResponse`.
* Passe `HTMLResponse` como o parâmetro de `response_class` do seu *decorador de operação de rota*.
{* ../../docs_src/custom_response/tutorial002_py310.py hl[2,7] *}
@@ -69,7 +53,7 @@ E será documentado como tal no OpenAPI.
### Retornando uma `Response` { #return-a-response }
-Como visto em [Retornando uma Resposta Diretamente](response-directly.md){.internal-link target=_blank}, você também pode sobrescrever a resposta diretamente na sua *operação de rota*, ao retornar ela.
+Como visto em [Retornando uma Resposta Diretamente](response-directly.md), você também pode sobrescrever a resposta diretamente na sua *operação de rota*, ao retornar ela.
O mesmo exemplo de antes, retornando uma `HTMLResponse`, poderia parecer com:
@@ -103,13 +87,13 @@ Neste exemplo, a função `generate_html_response()` já cria e retorna uma `Res
Ao retornar o resultado chamando `generate_html_response()`, você já está retornando uma `Response` que irá sobrescrever o comportamento padrão do **FastAPI**.
-Mas se você passasse uma `HTMLResponse` em `response_class` também, o **FastAPI** saberia como documentar isso no OpenAPI e na documentação interativa como um HTML com `text/html`:
+Mas como você passou `HTMLResponse` em `response_class` também, o **FastAPI** saberá como documentar isso no OpenAPI e na documentação interativa como um HTML com `text/html`:
## Respostas disponíveis { #available-responses }
-Aqui estão algumas dos tipos de resposta disponíveis.
+Aqui estão algumas das respostas disponíveis.
Lembre-se que você pode utilizar `Response` para retornar qualquer outra coisa, ou até mesmo criar uma subclasse personalizada.
@@ -129,9 +113,9 @@ Você pode retorná-la diretamente.
Ela aceita os seguintes parâmetros:
-* `content` - Uma sequência de caracteres (`str`) ou `bytes`.
+* `content` - Uma `str` ou `bytes`.
* `status_code` - Um código de status HTTP do tipo `int`.
-* `headers` - Um dicionário `dict` de strings.
+* `headers` - Um `dict` de strings.
* `media_type` - Uma `str` informando o media type. E.g. `"text/html"`.
O FastAPI (Starlette, na verdade) irá incluir o cabeçalho Content-Length automaticamente. Ele também irá incluir o cabeçalho Content-Type, baseado no `media_type` e acrescentando uma codificação para tipos textuais.
@@ -154,37 +138,11 @@ Pega alguns dados e retorna uma resposta com codificação `application/json`.
É a resposta padrão utilizada no **FastAPI**, como você leu acima.
-### `ORJSONResponse` { #orjsonresponse }
-
-Uma alternativa mais rápida de resposta JSON utilizando o
`orjson`, como você leu acima.
-
-/// info | Informação
-
-Essa resposta requer a instalação do pacote `orjson`, com o comando `pip install orjson`, por exemplo.
-
-///
-
-### `UJSONResponse` { #ujsonresponse }
-
-Uma alternativa de resposta JSON utilizando a biblioteca
`ujson`.
-
-/// info | Informação
-
-Essa resposta requer a instalação do pacote `ujson`, com o comando `pip install ujson`, por exemplo.
-
-///
-
-/// warning | Atenção
-
-`ujson` é menos cauteloso que a implementação nativa do Python na forma que os casos especiais são tratados
-
-///
-
-{* ../../docs_src/custom_response/tutorial001_py310.py hl[2,7] *}
+/// note | Detalhes Técnicos
-/// tip | Dica
+Mas se você declarar um modelo de resposta ou tipo de retorno, isso será usado diretamente para serializar os dados para JSON, e uma resposta com o media type correto para JSON será retornada diretamente, sem usar a classe `JSONResponse`.
-É possível que `ORJSONResponse` seja uma alternativa mais rápida.
+Esta é a forma ideal para obter a melhor performance.
///
@@ -202,9 +160,9 @@ Ou você pode utilizá-la no parâmetro `response_class`:
{* ../../docs_src/custom_response/tutorial006b_py310.py hl[2,7,9] *}
-Se você fizer isso, então você pode retornar a URL diretamente da sua *função de operação de rota*
+Se você fizer isso, então você pode retornar a URL diretamente da sua *função de operação de rota*.
-Neste caso, o `status_code` utilizada será o padrão de `RedirectResponse`, que é `307`.
+Neste caso, o `status_code` utilizado será o padrão de `RedirectResponse`, que é `307`.
---
@@ -214,46 +172,40 @@ Você também pode utilizar o parâmetro `status_code` combinado com o parâmetr
### `StreamingResponse` { #streamingresponse }
-Recebe um gerador assíncrono ou um gerador/iterador comum e retorna o corpo da resposta de forma contínua (stream).
-
-{* ../../docs_src/custom_response/tutorial007_py310.py hl[2,14] *}
-
-#### Utilizando `StreamingResponse` com objetos semelhantes a arquivos { #using-streamingresponse-with-file-like-objects }
+Recebe um gerador assíncrono ou um gerador/iterador comum (uma função com `yield`) e transmite (stream) o corpo da resposta.
-Se você tiver um objeto
semelhante a um arquivo (e.g. o objeto retornado por `open()`), você pode criar uma função geradora para iterar sobre esse objeto.
+{* ../../docs_src/custom_response/tutorial007_py310.py hl[3,16] *}
-Dessa forma, você não precisa ler todo o arquivo na memória primeiro, e você pode passar essa função geradora para `StreamingResponse` e retorná-la.
-
-Isso inclui muitas bibliotecas que interagem com armazenamento em nuvem, processamento de vídeos, entre outras.
+/// note | Detalhes Técnicos
-{* ../../docs_src/custom_response/tutorial008_py310.py hl[2,10:12,14] *}
+Uma tarefa `async` só pode ser cancelada quando alcança um `await`. Se não houver `await`, o gerador (função com `yield`) não pode ser cancelado adequadamente e pode continuar executando mesmo após o cancelamento ser solicitado.
-1. Essa é a função geradora. É definida como "função geradora" porque contém declarações `yield` nela.
-2. Ao utilizar o bloco `with`, nós garantimos que o objeto semelhante a um arquivo é fechado após a função geradora ser finalizada. Isto é, após a resposta terminar de ser enviada.
-3. Essa declaração `yield from` informa a função para iterar sobre essa coisa nomeada de `file_like`. E então, para cada parte iterada, fornece essa parte como se viesse dessa função geradora (`iterfile`).
+Como este pequeno exemplo não precisa de nenhuma instrução `await`, adicionamos um `await anyio.sleep(0)` para dar ao event loop a chance de lidar com o cancelamento.
- Então, é uma função geradora que transfere o trabalho de "geração" para alguma outra coisa interna.
+Isso seria ainda mais importante com streams grandes ou infinitos.
- Fazendo dessa forma, podemos colocá-la em um bloco `with`, e assim garantir que o objeto semelhante a um arquivo é fechado quando a função termina.
+///
/// tip | Dica
-Perceba que aqui estamos utilizando o `open()` da biblioteca padrão que não suporta `async` e `await`, e declaramos a operação de rota com o `def` básico.
+Em vez de retornar uma `StreamingResponse` diretamente, você deveria provavelmente seguir o estilo em [Transmitir Dados](./stream-data.md), é muito mais conveniente e lida com cancelamento nos bastidores para você.
+
+Se você estiver transmitindo JSON Lines, siga o tutorial [Transmitir JSON Lines](../tutorial/stream-json-lines.md).
///
### `FileResponse` { #fileresponse }
-Envia um arquivo de forma assíncrona e contínua (stream).
+Envia um arquivo de forma assíncrona e contínua (stream).
Recebe um conjunto de argumentos do construtor diferente dos outros tipos de resposta:
-* `path` - O caminho do arquivo que será transmitido
-* `headers` - quaisquer cabeçalhos que serão incluídos, como um dicionário.
-* `media_type` - Uma string com o media type. Se não for definida, o media type é inferido a partir do nome ou caminho do arquivo.
-* `filename` - Se for definido, é incluído no cabeçalho `Content-Disposition`.
+* `path` - O caminho do arquivo que será transmitido.
+* `headers` - Quaisquer cabeçalhos personalizados a serem incluídos, como um dicionário.
+* `media_type` - Uma string com o media type. Se não for definida, o nome do arquivo ou path será usado para inferir um media type.
+* `filename` - Se definido, será incluído no cabeçalho `Content-Disposition`.
-Respostas de Arquivos incluem o tamanho do arquivo, data da última modificação e ETags apropriados, nos cabeçalhos `Content-Length`, `Last-Modified` e `ETag`, respectivamente.
+Respostas de arquivos incluirão os cabeçalhos apropriados `Content-Length`, `Last-Modified` e `ETag`.
{* ../../docs_src/custom_response/tutorial009_py310.py hl[2,10] *}
@@ -261,17 +213,17 @@ Você também pode usar o parâmetro `response_class`:
{* ../../docs_src/custom_response/tutorial009b_py310.py hl[2,8,10] *}
-Nesse caso, você pode retornar o caminho do arquivo diretamente da sua *função de operação de rota*.
+Nesse caso, você pode retornar o path do arquivo diretamente da sua *função de operação de rota*.
## Classe de resposta personalizada { #custom-response-class }
-Você pode criar sua própria classe de resposta, herdando de `Response` e usando essa nova classe.
+Você pode criar sua própria classe de resposta personalizada, herdando de `Response` e usando-a.
-Por exemplo, vamos supor que você queira utilizar o
`orjson`, mas com algumas configurações personalizadas que não estão incluídas na classe `ORJSONResponse`.
+Por exemplo, vamos supor que você queira usar [`orjson`](https://github.com/ijl/orjson) com algumas configurações.
-Vamos supor também que você queira retornar um JSON indentado e formatado, então você quer utilizar a opção `orjson.OPT_INDENT_2` do orjson.
+Vamos supor que você queira retornar um JSON indentado e formatado, então você quer utilizar a opção `orjson.OPT_INDENT_2` do orjson.
-Você poderia criar uma classe `CustomORJSONResponse`. A principal coisa a ser feita é sobrecarregar o método render da classe Response, `Response.render(content)`, que retorna o conteúdo em bytes:
+Você poderia criar uma `CustomORJSONResponse`. A principal coisa que você tem que fazer é criar um método `Response.render(content)` que retorne o conteúdo como `bytes`:
{* ../../docs_src/custom_response/tutorial009c_py310.py hl[9:14,17] *}
@@ -291,13 +243,21 @@ Agora em vez de retornar:
Obviamente, você provavelmente vai encontrar maneiras muito melhores de se aproveitar disso do que a formatação de JSON. 😉
+### `orjson` ou Modelo de Resposta { #orjson-or-response-model }
+
+Se o que você procura é performance, provavelmente é melhor usar um [Modelo de Resposta](../tutorial/response-model.md) do que uma resposta com `orjson`.
+
+Com um modelo de resposta, o FastAPI usará o Pydantic para serializar os dados para JSON, sem passos intermediários, como convertê-los com `jsonable_encoder`, o que aconteceria em qualquer outro caso.
+
+E, por baixo dos panos, o Pydantic usa os mesmos mecanismos em Rust que o `orjson` para serializar para JSON, então você já terá a melhor performance com um modelo de resposta.
+
## Classe de resposta padrão { #default-response-class }
Quando você criar uma instância da classe **FastAPI** ou um `APIRouter` você pode especificar qual classe de resposta utilizar por padrão.
-O padrão que define isso é o `default_response_class`.
+O parâmetro que define isso é o `default_response_class`.
-No exemplo abaixo, o **FastAPI** irá utilizar `ORJSONResponse` por padrão, em todas as *operações de rota*, em vez de `JSONResponse`.
+No exemplo abaixo, o **FastAPI** utilizará `HTMLResponse` por padrão, em todas as *operações de rota*, em vez de JSON.
{* ../../docs_src/custom_response/tutorial010_py310.py hl[2,4] *}
@@ -309,4 +269,4 @@ Você ainda pode substituir `response_class` em *operações de rota* como antes
## Documentação adicional { #additional-documentation }
-Você também pode declarar o media type e muitos outros detalhes no OpenAPI utilizando `responses`: [Retornos Adicionais no OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Você também pode declarar o media type e muitos outros detalhes no OpenAPI utilizando `responses`: [Respostas Adicionais no OpenAPI](additional-responses.md).
diff --git a/docs/pt/docs/advanced/dataclasses.md b/docs/pt/docs/advanced/dataclasses.md
index c2af6fac6d..9a1f212d64 100644
--- a/docs/pt/docs/advanced/dataclasses.md
+++ b/docs/pt/docs/advanced/dataclasses.md
@@ -2,11 +2,11 @@
FastAPI é construído em cima do **Pydantic**, e eu tenho mostrado como usar modelos Pydantic para declarar requisições e respostas.
-Mas o FastAPI também suporta o uso de
`dataclasses` da mesma forma:
+Mas o FastAPI também suporta o uso de [`dataclasses`](https://docs.python.org/3/library/dataclasses.html) da mesma forma:
{* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}
-Isso ainda é suportado graças ao **Pydantic**, pois ele tem
suporte interno para `dataclasses`.
+Isso ainda é suportado graças ao **Pydantic**, pois ele tem [suporte interno para `dataclasses`](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel).
Então, mesmo com o código acima que não usa Pydantic explicitamente, o FastAPI está usando Pydantic para converter essas dataclasses padrão para a versão do Pydantic.
@@ -74,7 +74,7 @@ Nesse caso, você pode simplesmente trocar as `dataclasses` padrão por `pydanti
Como sempre, no FastAPI você pode combinar `def` e `async def` conforme necessário.
- Se você precisar de uma atualização sobre quando usar qual, confira a seção _"Com pressa?"_ na documentação sobre [`async` e `await`](../async.md#in-a-hurry){.internal-link target=_blank}.
+ Se você precisar de uma atualização sobre quando usar qual, confira a seção _"Com pressa?"_ na documentação sobre [`async` e `await`](../async.md#in-a-hurry).
9. Esta *função de operação de rota* não está retornando dataclasses (embora pudesse), mas uma lista de dicionários com dados internos.
@@ -88,7 +88,7 @@ Confira as dicas de anotação no código acima para ver mais detalhes específi
Você também pode combinar `dataclasses` com outros modelos Pydantic, herdar deles, incluí-los em seus próprios modelos, etc.
-Para saber mais, confira a
documentação do Pydantic sobre dataclasses.
+Para saber mais, confira a [documentação do Pydantic sobre dataclasses](https://docs.pydantic.dev/latest/concepts/dataclasses/).
## Versão { #version }
diff --git a/docs/pt/docs/advanced/events.md b/docs/pt/docs/advanced/events.md
index 551053508d..7f15d833e6 100644
--- a/docs/pt/docs/advanced/events.md
+++ b/docs/pt/docs/advanced/events.md
@@ -150,11 +150,11 @@ Por causa disso, agora é recomendado usar o `lifespan`, como explicado acima.
Apenas um detalhe técnico para nerds curiosos. 🤓
-Por baixo, na especificação técnica do ASGI, isso é parte do
Protocolo Lifespan, e define eventos chamados `startup` e `shutdown`.
+Por baixo, na especificação técnica do ASGI, isso é parte do [Protocolo Lifespan](https://asgi.readthedocs.io/en/latest/specs/lifespan.html), e define eventos chamados `startup` e `shutdown`.
/// info | Informação
-Você pode ler mais sobre os manipuladores de `lifespan` do Starlette na
Documentação do Lifespan do Starlette.
+Você pode ler mais sobre os manipuladores de `lifespan` do Starlette na [Documentação do Lifespan do Starlette](https://www.starlette.dev/lifespan/).
Incluindo como lidar com estado do lifespan que pode ser usado em outras áreas do seu código.
@@ -162,4 +162,4 @@ Incluindo como lidar com estado do lifespan que pode ser usado em outras áreas
## Sub Aplicações { #sub-applications }
-🚨 Tenha em mente que esses eventos de lifespan (inicialização e encerramento) serão executados apenas para a aplicação principal, não para [Sub Aplicações - Montagem](sub-applications.md){.internal-link target=_blank}.
+🚨 Tenha em mente que esses eventos de lifespan (inicialização e encerramento) serão executados apenas para a aplicação principal, não para [Sub Aplicações - Montagem](sub-applications.md).
diff --git a/docs/pt/docs/advanced/generate-clients.md b/docs/pt/docs/advanced/generate-clients.md
index c6c7785a01..0d31a69af8 100644
--- a/docs/pt/docs/advanced/generate-clients.md
+++ b/docs/pt/docs/advanced/generate-clients.md
@@ -2,17 +2,17 @@
Como o **FastAPI** é baseado na especificação **OpenAPI**, suas APIs podem ser descritas em um formato padrão que muitas ferramentas entendem.
-Isso facilita gerar **documentação** atualizada, bibliotecas clientes (
**SDKs**) em várias linguagens e **testes** ou **fluxos de trabalho de automação** que permanecem em sincronia com o seu código.
+Isso facilita gerar **documentação** atualizada, bibliotecas clientes (
**SDKs**) em várias linguagens e **testes** ou **fluxos de trabalho de automação** que permanecem em sincronia com o seu código.
Neste guia, você aprenderá como gerar um **SDK em TypeScript** para o seu backend FastAPI.
## Geradores de SDK de código aberto { #open-source-sdk-generators }
-Uma opção versátil é o
OpenAPI Generator, que suporta **muitas linguagens de programação** e pode gerar SDKs a partir da sua especificação OpenAPI.
+Uma opção versátil é o [OpenAPI Generator](https://openapi-generator.tech/), que suporta **muitas linguagens de programação** e pode gerar SDKs a partir da sua especificação OpenAPI.
-Para **clientes TypeScript**, o
Hey API é uma solução feita sob medida, oferecendo uma experiência otimizada para o ecossistema TypeScript.
+Para **clientes TypeScript**, o [Hey API](https://heyapi.dev/) é uma solução feita sob medida, oferecendo uma experiência otimizada para o ecossistema TypeScript.
-Você pode descobrir mais geradores de SDK em
OpenAPI.Tools.
+Você pode descobrir mais geradores de SDK em [OpenAPI.Tools](https://openapi.tools/#sdk).
/// tip | Dica
@@ -24,15 +24,15 @@ O FastAPI gera automaticamente especificações **OpenAPI 3.1**, então qualquer
Esta seção destaca soluções **financiadas por investimento** e **com suporte de empresas** que patrocinam o FastAPI. Esses produtos fornecem **funcionalidades adicionais** e **integrações** além de SDKs gerados com alta qualidade.
-Ao ✨ [**patrocinar o FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, essas empresas ajudam a garantir que o framework e seu **ecossistema** continuem saudáveis e **sustentáveis**.
+Ao ✨ [**patrocinar o FastAPI**](../help-fastapi.md#sponsor-the-author) ✨, essas empresas ajudam a garantir que o framework e seu **ecossistema** continuem saudáveis e **sustentáveis**.
O patrocínio também demonstra um forte compromisso com a **comunidade** FastAPI (você), mostrando que elas se importam não apenas em oferecer um **ótimo serviço**, mas também em apoiar um **framework robusto e próspero**, o FastAPI. 🙇
Por exemplo, você pode querer experimentar:
-*
Speakeasy
-*
Stainless
-*
liblab
+* [Speakeasy](https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship)
+* [Stainless](https://www.stainless.com/?utm_source=fastapi&utm_medium=referral)
+* [liblab](https://developers.liblab.com/tutorials/sdk-for-fastapi?utm_source=fastapi)
Algumas dessas soluções também podem ser open source ou oferecer planos gratuitos, para que você possa testá-las sem compromisso financeiro. Outros geradores comerciais de SDK estão disponíveis e podem ser encontrados online. 🤓
@@ -66,7 +66,7 @@ npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
Isso gerará um SDK TypeScript em `./src/client`.
-Você pode aprender como
instalar `@hey-api/openapi-ts` e ler sobre o
resultado gerado no site deles.
+Você pode aprender como [instalar `@hey-api/openapi-ts`](https://heyapi.dev/openapi-ts/get-started) e ler sobre o [resultado gerado](https://heyapi.dev/openapi-ts/output) no site deles.
### Usando o SDK { #using-the-sdk }
diff --git a/docs/pt/docs/advanced/index.md b/docs/pt/docs/advanced/index.md
index d2727be43f..bbb8b0b50b 100644
--- a/docs/pt/docs/advanced/index.md
+++ b/docs/pt/docs/advanced/index.md
@@ -2,7 +2,7 @@
## Recursos Adicionais { #additional-features }
-O [Tutorial - Guia de Usuário](../tutorial/index.md){.internal-link target=_blank} deve ser o suficiente para dar a você um tour por todos os principais recursos do **FastAPI**.
+O [Tutorial - Guia de Usuário](../tutorial/index.md) principal deve ser o suficiente para dar a você um tour por todos os principais recursos do **FastAPI**.
Nas próximas seções você verá outras opções, configurações, e recursos adicionais.
@@ -16,6 +16,6 @@ E é possível que para seu caso de uso, a solução esteja em uma delas.
## Leia o Tutorial primeiro { #read-the-tutorial-first }
-Você ainda pode usar a maior parte dos recursos no **FastAPI** com o conhecimento do [Tutorial - Guia de Usuário](../tutorial/index.md){.internal-link target=_blank}.
+Você ainda pode usar a maior parte dos recursos no **FastAPI** com o conhecimento do [Tutorial - Guia de Usuário](../tutorial/index.md) principal.
E as próximas seções assumem que você já leu ele, e que você conhece suas ideias principais.
diff --git a/docs/pt/docs/advanced/json-base64-bytes.md b/docs/pt/docs/advanced/json-base64-bytes.md
new file mode 100644
index 0000000000..cc956da4f0
--- /dev/null
+++ b/docs/pt/docs/advanced/json-base64-bytes.md
@@ -0,0 +1,63 @@
+# JSON com bytes em Base64 { #json-with-bytes-as-base64 }
+
+Se sua aplicação precisa receber e enviar dados JSON, mas você precisa incluir dados binários nele, você pode codificá-los em base64.
+
+## Base64 vs Arquivos { #base64-vs-files }
+
+Primeiro, considere se você pode usar [Arquivos na request](../tutorial/request-files.md) para fazer upload de dados binários e [Response personalizada - FileResponse](./custom-response.md#fileresponse--fileresponse-) para enviar dados binários, em vez de codificá-los em JSON.
+
+JSON só pode conter strings codificadas em UTF-8, portanto não pode conter bytes puros.
+
+Base64 pode codificar dados binários em strings, mas, para isso, precisa usar mais caracteres do que os dados binários originais; assim, normalmente é menos eficiente do que arquivos comuns.
+
+Use base64 apenas se realmente precisar incluir dados binários em JSON e não puder usar arquivos para isso.
+
+## Pydantic `bytes` { #pydantic-bytes }
+
+Você pode declarar um modelo Pydantic com campos `bytes` e então usar `val_json_bytes` na configuração do modelo para indicar que deve usar base64 para *validar* os dados JSON de entrada; como parte dessa validação, ele decodificará a string base64 em bytes.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
+
+Se você verificar a `/docs`, verá que o campo `data` espera bytes codificados em base64:
+
+
+
+
+
+Você poderia enviar uma request assim:
+
+```json
+{
+ "description": "Some data",
+ "data": "aGVsbG8="
+}
+```
+
+/// tip | Dica
+
+`aGVsbG8=` é a codificação base64 de `hello`.
+
+///
+
+Em seguida, o Pydantic decodificará a string base64 e fornecerá os bytes originais no campo `data` do modelo.
+
+Você receberá uma response assim:
+
+```json
+{
+ "description": "Some data",
+ "content": "hello"
+}
+```
+
+## Pydantic `bytes` para dados de saída { #pydantic-bytes-for-output-data }
+
+Você também pode usar campos `bytes` com `ser_json_bytes` na configuração do modelo para dados de saída, e o Pydantic irá *serializar* os bytes como base64 ao gerar a response JSON.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,12:16,29,38:41] hl[16] *}
+
+## Pydantic `bytes` para dados de entrada e saída { #pydantic-bytes-for-input-and-output-data }
+
+E, claro, você pode usar o mesmo modelo configurado para usar base64 para lidar tanto com a entrada (*validar*) com `val_json_bytes` quanto com a saída (*serializar*) com `ser_json_bytes` ao receber e enviar dados JSON.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,19:26,29,44:46] hl[23:26] *}
diff --git a/docs/pt/docs/advanced/middleware.md b/docs/pt/docs/advanced/middleware.md
index 6bc4bfd2f0..1f269da5e3 100644
--- a/docs/pt/docs/advanced/middleware.md
+++ b/docs/pt/docs/advanced/middleware.md
@@ -1,8 +1,8 @@
# Middleware Avançado { #advanced-middleware }
-No tutorial principal você leu como adicionar [Middleware Personalizado](../tutorial/middleware.md){.internal-link target=_blank} à sua aplicação.
+No tutorial principal você leu como adicionar [Middleware Personalizado](../tutorial/middleware.md) à sua aplicação.
-E então você também leu como lidar com [CORS com o `CORSMiddleware`](../tutorial/cors.md){.internal-link target=_blank}.
+E então você também leu como lidar com [CORS com o `CORSMiddleware`](../tutorial/cors.md).
Nesta seção, veremos como usar outros middlewares.
@@ -67,7 +67,7 @@ Garante que todas as requisições recebidas tenham um cabeçalho `Host` correta
Os seguintes argumentos são suportados:
-* `allowed_hosts` - Uma lista de nomes de domínio que são permitidos como nomes de host. Domínios com coringa, como `*.example.com`, são suportados para corresponder a subdomínios. Para permitir qualquer nome de host, use `allowed_hosts=["*"]` ou omita o middleware.
+* `allowed_hosts` - Uma lista de nomes de domínio que são permitidos como nomes de host. Domínios com curingas, como `*.example.com`, são suportados para corresponder a subdomínios. Para permitir qualquer nome de host, use `allowed_hosts=["*"]` ou omita o middleware.
* `www_redirect` - Se definido como True, as requisições para versões sem www dos hosts permitidos serão redirecionadas para suas versões com www. O padrão é `True`.
Se uma requisição recebida não for validada corretamente, uma resposta `400` será enviada.
@@ -91,7 +91,7 @@ Há muitos outros middlewares ASGI.
Por exemplo:
-*
`ProxyHeadersMiddleware` do Uvicorn
-*
MessagePack
+* [`ProxyHeadersMiddleware` do Uvicorn](https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py)
+* [MessagePack](https://github.com/florimondmanca/msgpack-asgi)
-Para checar outros middlewares disponíveis, confira
Documentação de Middlewares do Starlette e a
Lista Incrível do ASGI.
+Para checar outros middlewares disponíveis, confira [Documentação de Middlewares do Starlette](https://www.starlette.dev/middleware/) e a [Lista Incrível do ASGI](https://github.com/florimondmanca/awesome-asgi).
diff --git a/docs/pt/docs/advanced/openapi-callbacks.md b/docs/pt/docs/advanced/openapi-callbacks.md
index 653c26d99c..df9e7e0bf6 100644
--- a/docs/pt/docs/advanced/openapi-callbacks.md
+++ b/docs/pt/docs/advanced/openapi-callbacks.md
@@ -35,7 +35,7 @@ Essa parte é bastante normal, a maior parte do código provavelmente já é fam
/// tip | Dica
-O parâmetro de consulta `callback_url` usa um tipo Pydantic
Url.
+O parâmetro de consulta `callback_url` usa um tipo Pydantic [Url](https://docs.pydantic.dev/latest/api/networks/).
///
@@ -66,7 +66,7 @@ Esse exemplo não implementa o callback em si (que poderia ser apenas uma linha
O callback real é apenas um request HTTP.
-Ao implementar o callback por conta própria, você pode usar algo como
HTTPX ou
Requests.
+Ao implementar o callback por conta própria, você pode usar algo como [HTTPX](https://www.python-httpx.org) ou [Requests](https://requests.readthedocs.io/).
///
@@ -106,11 +106,11 @@ Ela deve parecer exatamente como uma *operação de rota* normal do FastAPI:
Há 2 diferenças principais de uma *operação de rota* normal:
* Ela não necessita ter nenhum código real, porque seu aplicativo nunca chamará esse código. Ele é usado apenas para documentar a *API externa*. Então, a função poderia ter apenas `pass`.
-* O *path* pode conter uma
expressão OpenAPI 3 (veja mais abaixo) em que pode usar variáveis com parâmetros e partes do request original enviado para *sua API*.
+* O *path* pode conter uma [expressão OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) (veja mais abaixo) em que pode usar variáveis com parâmetros e partes do request original enviado para *sua API*.
### A expressão do path do callback { #the-callback-path-expression }
-O *path* do callback pode ter uma
expressão OpenAPI 3 que pode conter partes do request original enviado para *sua API*.
+O *path* do callback pode ter uma [expressão OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) que pode conter partes do request original enviado para *sua API*.
Nesse caso, é a `str`:
@@ -179,7 +179,7 @@ Perceba que você não está passando o roteador em si (`invoices_callback_route
### Verifique a documentação { #check-the-docs }
-Agora você pode iniciar seu aplicativo e ir para
http://127.0.0.1:8000/docs.
+Agora você pode iniciar seu aplicativo e ir para [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Você verá sua documentação incluindo uma seção "Callbacks" para sua *operação de rota* que mostra como a *API externa* deveria ser:
diff --git a/docs/pt/docs/advanced/openapi-webhooks.md b/docs/pt/docs/advanced/openapi-webhooks.md
index ed0d702b2b..0c675089ca 100644
--- a/docs/pt/docs/advanced/openapi-webhooks.md
+++ b/docs/pt/docs/advanced/openapi-webhooks.md
@@ -16,7 +16,7 @@ E os **seus usuários** definem de alguma forma (em algum painel por exemplo) a
Toda a **lógica** sobre como cadastrar as URLs para os webhooks e o código para enviar de fato as requisições cabe a você definir. Você escreve da maneira que você desejar no **seu próprio código**.
-## Documentando webhooks com o FastAPI e OpenAPI { #documenting-webhooks-with-fastapi-and-openapi }
+## Documentando webhooks com o **FastAPI** e OpenAPI { #documenting-webhooks-with-fastapi-and-openapi }
Com o **FastAPI**, utilizando o OpenAPI, você pode definir os nomes destes webhooks, os tipos das operações HTTP que a sua aplicação pode enviar (e.g. `POST`, `PUT`, etc.) e os **corpos** da requisição que a sua aplicação enviaria.
@@ -48,7 +48,7 @@ Isto porque espera-se que os **seus usuários** definam o verdadeiro **URL path*
### Confira a documentação { #check-the-docs }
-Agora você pode iniciar a sua aplicação e ir até
http://127.0.0.1:8000/docs.
+Agora você pode iniciar a sua aplicação e ir até [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Você verá que a sua documentação possui as *operações de rota* normais e agora também possui alguns **webhooks**:
diff --git a/docs/pt/docs/advanced/path-operation-advanced-configuration.md b/docs/pt/docs/advanced/path-operation-advanced-configuration.md
index c4dd3cbe78..b9862876ca 100644
--- a/docs/pt/docs/advanced/path-operation-advanced-configuration.md
+++ b/docs/pt/docs/advanced/path-operation-advanced-configuration.md
@@ -60,7 +60,7 @@ Isso define os metadados sobre a resposta principal da *operação de rota*.
Você também pode declarar respostas adicionais, com seus modelos, códigos de status, etc.
-Existe um capítulo inteiro da nossa documentação sobre isso, você pode ler em [Retornos Adicionais no OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Existe um capítulo inteiro da nossa documentação sobre isso, você pode ler em [Respostas Adicionais no OpenAPI](additional-responses.md).
## Extras do OpenAPI { #openapi-extra }
@@ -68,7 +68,7 @@ Quando você declara uma *operação de rota* na sua aplicação, o **FastAPI**
/// note | Detalhes Técnicos
-Na especificação do OpenAPI, isso é chamado de um
Objeto de Operação.
+Na especificação do OpenAPI, isso é chamado de um [Objeto de Operação](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object).
///
@@ -82,7 +82,7 @@ Esse esquema específico para uma *operação de rota* normalmente é gerado aut
Esse é um ponto de extensão de baixo nível.
-Caso você só precise declarar respostas adicionais, uma forma conveniente de fazer isso é com [Retornos Adicionais no OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Caso você só precise declarar respostas adicionais, uma forma conveniente de fazer isso é com [Respostas Adicionais no OpenAPI](additional-responses.md).
///
diff --git a/docs/pt/docs/advanced/response-change-status-code.md b/docs/pt/docs/advanced/response-change-status-code.md
index 76d9462a87..44ca6062a5 100644
--- a/docs/pt/docs/advanced/response-change-status-code.md
+++ b/docs/pt/docs/advanced/response-change-status-code.md
@@ -1,6 +1,6 @@
# Retorno - Altere o Código de Status { #response-change-status-code }
-Você provavelmente leu anteriormente que você pode definir um [Código de Status do Retorno](../tutorial/response-status-code.md){.internal-link target=_blank} padrão.
+Você provavelmente leu anteriormente que você pode definir um [Código de Status do Retorno](../tutorial/response-status-code.md) padrão.
Porém em alguns casos você precisa retornar um código de status diferente do padrão.
diff --git a/docs/pt/docs/advanced/response-cookies.md b/docs/pt/docs/advanced/response-cookies.md
index ae9660743a..691bd1b9c5 100644
--- a/docs/pt/docs/advanced/response-cookies.md
+++ b/docs/pt/docs/advanced/response-cookies.md
@@ -20,7 +20,7 @@ Você também pode declarar o parâmetro `Response` em dependências e definir c
Você também pode criar cookies ao retornar uma `Response` diretamente no seu código.
-Para fazer isso, você pode criar uma resposta como descrito em [Retorne uma Resposta Diretamente](response-directly.md){.internal-link target=_blank}.
+Para fazer isso, você pode criar uma resposta como descrito em [Retorne uma Resposta Diretamente](response-directly.md).
Então, defina os cookies nela e a retorne:
@@ -48,4 +48,4 @@ E como o `Response` pode ser usado frequentemente para definir cabeçalhos e coo
///
-Para ver todos os parâmetros e opções disponíveis, verifique a
documentação no Starlette.
+Para ver todos os parâmetros e opções disponíveis, verifique a [documentação no Starlette](https://www.starlette.dev/responses/#set-cookie).
diff --git a/docs/pt/docs/advanced/response-directly.md b/docs/pt/docs/advanced/response-directly.md
index 311aba56ce..9024897c1a 100644
--- a/docs/pt/docs/advanced/response-directly.md
+++ b/docs/pt/docs/advanced/response-directly.md
@@ -1,20 +1,24 @@
# Retornando uma Resposta Diretamente { #return-a-response-directly }
-Quando você cria uma *operação de rota* no **FastAPI** você pode retornar qualquer dado nela: um dicionário (`dict`), uma lista (`list`), um modelo do Pydantic ou do seu banco de dados, etc.
+Quando você cria uma *operação de rota* no **FastAPI**, normalmente você pode retornar qualquer dado: um `dict`, uma `list`, um modelo do Pydantic, um modelo do banco de dados, etc.
-Por padrão, o **FastAPI** irá converter automaticamente o valor do retorno para JSON utilizando o `jsonable_encoder` explicado em [Codificador Compatível com JSON](../tutorial/encoder.md){.internal-link target=_blank}.
+Se você declarar um [Modelo de resposta](../tutorial/response-model.md), o FastAPI irá usá-lo para serializar os dados para JSON, usando o Pydantic.
-Então, por baixo dos panos, ele incluiria esses dados compatíveis com JSON (e.g. um `dict`) dentro de uma `JSONResponse` que é utilizada para enviar uma resposta para o cliente.
+Se você não declarar um modelo de resposta, o FastAPI usará o `jsonable_encoder` explicado em [Codificador Compatível com JSON](../tutorial/encoder.md) e o colocará em uma `JSONResponse`.
-Mas você pode retornar a `JSONResponse` diretamente nas suas *operações de rota*.
+Você também pode criar uma `JSONResponse` diretamente e retorná-la.
-Pode ser útil para retornar cabeçalhos e cookies personalizados, por exemplo.
+/// tip | Dica
+
+Normalmente você terá um desempenho muito melhor usando um [Modelo de resposta](../tutorial/response-model.md) do que retornando uma `JSONResponse` diretamente, pois assim ele serializa os dados usando o Pydantic, em Rust.
+
+///
## Retornando uma `Response` { #return-a-response }
-Na verdade, você pode retornar qualquer `Response` ou subclasse dela.
+Você pode retornar uma `Response` ou qualquer subclasse dela.
-/// tip | Dica
+/// info | Informação
A própria `JSONResponse` é uma subclasse de `Response`.
@@ -22,10 +26,12 @@ A própria `JSONResponse` é uma subclasse de `Response`.
E quando você retorna uma `Response`, o **FastAPI** vai repassá-la diretamente.
-Ele não vai fazer conversões de dados com modelos do Pydantic, não irá converter a tipagem de nenhum conteúdo, etc.
+Ele não fará conversões de dados com modelos do Pydantic, não converterá o conteúdo para nenhum tipo, etc.
Isso te dá bastante flexibilidade. Você pode retornar qualquer tipo de dado, sobrescrever qualquer declaração e validação nos dados, etc.
+Isso também te dá muita responsabilidade. Você precisa garantir que os dados retornados estão corretos, no formato correto, que podem ser serializados, etc.
+
## Utilizando o `jsonable_encoder` em uma `Response` { #using-the-jsonable-encoder-in-a-response }
Como o **FastAPI** não realiza nenhuma mudança na `Response` que você retorna, você precisa garantir que o conteúdo dela está pronto para uso.
@@ -50,16 +56,28 @@ O exemplo acima mostra todas as partes que você precisa, mas ainda não é muit
Agora, vamos ver como você pode usar isso para retornar uma resposta personalizada.
-Vamos dizer que você quer retornar uma resposta
XML.
+Vamos dizer que você quer retornar uma resposta [XML](https://en.wikipedia.org/wiki/XML).
Você pode colocar o seu conteúdo XML em uma string, colocar em uma `Response`, e retorná-lo:
{* ../../docs_src/response_directly/tutorial002_py310.py hl[1,18] *}
+## Como funciona um Modelo de resposta { #how-a-response-model-works }
+
+Quando você declara um [Modelo de resposta - Tipo de retorno](../tutorial/response-model.md) em uma operação de rota, o **FastAPI** irá usá-lo para serializar os dados para JSON, usando o Pydantic.
+
+{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}
+
+Como isso acontece no lado do Rust, o desempenho será muito melhor do que se fosse feito com Python comum e a classe `JSONResponse`.
+
+Ao usar um `response_model` ou tipo de retorno, o FastAPI não usará o `jsonable_encoder` para converter os dados (o que seria mais lento) nem a classe `JSONResponse`.
+
+Em vez disso, ele pega os bytes JSON gerados com o Pydantic usando o modelo de resposta (ou tipo de retorno) e retorna uma `Response` com o media type correto para JSON diretamente (`application/json`).
+
## Notas { #notes }
Quando você retorna uma `Response` diretamente os dados não são validados, convertidos (serializados) ou documentados automaticamente.
-Mas você ainda pode documentar como descrito em [Retornos Adicionais no OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Mas você ainda pode documentar como descrito em [Respostas adicionais no OpenAPI](additional-responses.md).
Você pode ver nas próximas seções como usar/declarar essas `Responses` customizadas enquanto mantém a conversão e documentação automática dos dados.
diff --git a/docs/pt/docs/advanced/response-headers.md b/docs/pt/docs/advanced/response-headers.md
index a7305bdb17..7235b5eb8c 100644
--- a/docs/pt/docs/advanced/response-headers.md
+++ b/docs/pt/docs/advanced/response-headers.md
@@ -20,7 +20,7 @@ Você também pode declarar o parâmetro `Response` em dependências e definir c
Você também pode adicionar cabeçalhos quando retornar uma `Response` diretamente.
-Crie uma resposta conforme descrito em [Retornar uma resposta diretamente](response-directly.md){.internal-link target=_blank} e passe os cabeçalhos como um parâmetro adicional:
+Crie uma resposta conforme descrito em [Retornar uma resposta diretamente](response-directly.md) e passe os cabeçalhos como um parâmetro adicional:
{* ../../docs_src/response_headers/tutorial001_py310.py hl[10:12] *}
@@ -36,6 +36,6 @@ E como a `Response` pode ser usada frequentemente para definir cabeçalhos e coo
## Cabeçalhos personalizados { #custom-headers }
-Tenha em mente que cabeçalhos personalizados proprietários podem ser adicionados
usando o prefixo `X-`.
+Tenha em mente que cabeçalhos personalizados proprietários podem ser adicionados [usando o prefixo `X-`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).
-Porém, se você tiver cabeçalhos personalizados que deseja que um cliente no navegador possa ver, você precisa adicioná-los às suas configurações de CORS (saiba mais em [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md){.internal-link target=_blank}), usando o parâmetro `expose_headers` descrito na
documentação de CORS do Starlette.
+Porém, se você tiver cabeçalhos personalizados que deseja que um cliente no navegador possa ver, você precisa adicioná-los às suas configurações de CORS (saiba mais em [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md)), usando o parâmetro `expose_headers` descrito na [documentação de CORS do Starlette](https://www.starlette.dev/middleware/#corsmiddleware).
diff --git a/docs/pt/docs/advanced/security/http-basic-auth.md b/docs/pt/docs/advanced/security/http-basic-auth.md
index 0ebdb1eb93..303d8480e1 100644
--- a/docs/pt/docs/advanced/security/http-basic-auth.md
+++ b/docs/pt/docs/advanced/security/http-basic-auth.md
@@ -32,7 +32,7 @@ Aqui está um exemplo mais completo.
Utilize uma dependência para verificar se o usuário e a senha estão corretos.
-Para isso, utilize o módulo padrão do Python
`secrets` para verificar o usuário e senha.
+Para isso, utilize o módulo padrão do Python [`secrets`](https://docs.python.org/3/library/secrets.html) para verificar o usuário e senha.
O `secrets.compare_digest()` necessita receber `bytes` ou `str` que possuem apenas caracteres ASCII (os em inglês). Isso significa que não funcionaria com caracteres como o `á`, como em `Sebastián`.
@@ -50,11 +50,11 @@ if not (credentials.username == "stanleyjobson") or not (credentials.password ==
...
```
-Porém, ao utilizar o `secrets.compare_digest()`, isso estará seguro contra um tipo de ataque chamado "timing attacks" (ataques de temporização).
+Porém, ao utilizar o `secrets.compare_digest()`, isso estará seguro contra um tipo de ataque chamado "timing attacks".
### Ataques de Temporização { #timing-attacks }
-Mas o que é um "timing attack" (ataque de temporização)?
+Mas o que é um "timing attack"?
Vamos imaginar que alguns invasores estão tentando adivinhar o usuário e a senha.
diff --git a/docs/pt/docs/advanced/security/index.md b/docs/pt/docs/advanced/security/index.md
index 70fb999d0e..b5ced914a7 100644
--- a/docs/pt/docs/advanced/security/index.md
+++ b/docs/pt/docs/advanced/security/index.md
@@ -2,7 +2,7 @@
## Funcionalidades Adicionais { #additional-features }
-Existem algumas funcionalidades adicionais para lidar com segurança além das cobertas em [Tutorial - Guia de Usuário: Segurança](../../tutorial/security/index.md){.internal-link target=_blank}.
+Existem algumas funcionalidades adicionais para lidar com segurança além das cobertas em [Tutorial - Guia de Usuário: Segurança](../../tutorial/security/index.md).
/// tip | Dica
@@ -14,6 +14,6 @@ E é possível que para o seu caso de uso, a solução está em uma delas.
## Leia o Tutorial primeiro { #read-the-tutorial-first }
-As próximas seções pressupõem que você já leu o principal [Tutorial - Guia de Usuário: Segurança](../../tutorial/security/index.md){.internal-link target=_blank}.
+As próximas seções pressupõem que você já leu o principal [Tutorial - Guia de Usuário: Segurança](../../tutorial/security/index.md).
Todas elas são baseadas nos mesmos conceitos, mas permitem algumas funcionalidades extras.
diff --git a/docs/pt/docs/advanced/security/oauth2-scopes.md b/docs/pt/docs/advanced/security/oauth2-scopes.md
index 0a0c785a01..7ea61ad60e 100644
--- a/docs/pt/docs/advanced/security/oauth2-scopes.md
+++ b/docs/pt/docs/advanced/security/oauth2-scopes.md
@@ -60,7 +60,7 @@ Para o OAuth2, eles são apenas strings.
## Visão global { #global-view }
-Primeiro, vamos olhar rapidamente as partes que mudam dos exemplos do **Tutorial - Guia de Usuário** para [OAuth2 com Senha (e hash), Bearer com tokens JWT](../../tutorial/security/oauth2-jwt.md){.internal-link target=_blank}. Agora utilizando escopos OAuth2:
+Primeiro, vamos olhar rapidamente as partes que mudam dos exemplos do **Tutorial - Guia de Usuário** para [OAuth2 com Senha (e hash), Bearer com tokens JWT](../../tutorial/security/oauth2-jwt.md). Agora utilizando escopos OAuth2:
{* ../../docs_src/security/tutorial005_an_py310.py hl[5,9,13,47,65,106,108:116,122:126,130:136,141,157] *}
@@ -126,7 +126,7 @@ Nós estamos fazendo isso aqui para demonstrar como o **FastAPI** lida com escop
{* ../../docs_src/security/tutorial005_an_py310.py hl[5,141,172] *}
-/// info | Detalhes Técnicos
+/// note | Detalhes Técnicos
`Security` é na verdade uma subclasse de `Depends`, e ele possui apenas um parâmetro extra que veremos depois.
@@ -271,4 +271,4 @@ O **FastAPI** inclui utilitários para todos esses fluxos de autenticação OAut
## `Security` em decoradores de `dependencies` { #security-in-decorator-dependencies }
-Da mesma forma que você pode definir uma `list` de `Depends` no parâmetro `dependencies` do decorador (como explicado em [Dependências em decoradores de operações de rota](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}), você também pode utilizar `Security` com escopos lá.
+Da mesma forma que você pode definir uma `list` de `Depends` no parâmetro `dependencies` do decorador (como explicado em [Dependências em decoradores de operações de rota](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md)), você também pode utilizar `Security` com escopos lá.
diff --git a/docs/pt/docs/advanced/settings.md b/docs/pt/docs/advanced/settings.md
index 88e7f591c3..371d5711bd 100644
--- a/docs/pt/docs/advanced/settings.md
+++ b/docs/pt/docs/advanced/settings.md
@@ -8,7 +8,7 @@ Por esse motivo, é comum fornecê-las em variáveis de ambiente lidas pela apli
/// tip | Dica
-Para entender variáveis de ambiente, você pode ler [Variáveis de Ambiente](../environment-variables.md){.internal-link target=_blank}.
+Para entender variáveis de ambiente, você pode ler [Variáveis de Ambiente](../environment-variables.md).
///
@@ -20,11 +20,11 @@ Isso significa que qualquer valor lido em Python a partir de uma variável de am
## Pydantic `Settings` { #pydantic-settings }
-Felizmente, o Pydantic fornece uma ótima utilidade para lidar com essas configurações vindas de variáveis de ambiente com
Pydantic: Settings management.
+Felizmente, o Pydantic fornece uma ótima utilidade para lidar com essas configurações vindas de variáveis de ambiente com [Pydantic: Settings management](https://docs.pydantic.dev/latest/concepts/pydantic_settings/).
### Instalar `pydantic-settings` { #install-pydantic-settings }
-Primeiro, certifique-se de criar seu [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalar o pacote `pydantic-settings`:
+Primeiro, certifique-se de criar seu [ambiente virtual](../virtual-environments.md), ativá-lo e então instalar o pacote `pydantic-settings`:
@@ -100,7 +100,7 @@ E `items_per_user` manteria seu valor padrão de `50`.
## Configurações em outro módulo { #settings-in-another-module }
-Você pode colocar essas configurações em outro arquivo de módulo como visto em [Aplicações Maiores - Múltiplos Arquivos](../tutorial/bigger-applications.md){.internal-link target=_blank}.
+Você pode colocar essas configurações em outro arquivo de módulo como visto em [Aplicações Maiores - Múltiplos Arquivos](../tutorial/bigger-applications.md).
Por exemplo, você poderia ter um arquivo `config.py` com:
@@ -112,7 +112,7 @@ E então usá-lo em um arquivo `main.py`:
/// tip | Dica
-Você também precisaria de um arquivo `__init__.py` como visto em [Aplicações Maiores - Múltiplos Arquivos](../tutorial/bigger-applications.md){.internal-link target=_blank}.
+Você também precisaria de um arquivo `__init__.py` como visto em [Aplicações Maiores - Múltiplos Arquivos](../tutorial/bigger-applications.md).
///
@@ -172,7 +172,7 @@ Mas um arquivo dotenv não precisa ter exatamente esse nome de arquivo.
///
-O Pydantic tem suporte para leitura desses tipos de arquivos usando uma biblioteca externa. Você pode ler mais em
Pydantic Settings: Dotenv (.env) support.
+O Pydantic tem suporte para leitura desses tipos de arquivos usando uma biblioteca externa. Você pode ler mais em [Pydantic Settings: Dotenv (.env) support](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support).
/// tip | Dica
@@ -197,7 +197,7 @@ E então atualizar seu `config.py` com:
/// tip | Dica
-O atributo `model_config` é usado apenas para configuração do Pydantic. Você pode ler mais em
Pydantic: Concepts: Configuration.
+O atributo `model_config` é usado apenas para configuração do Pydantic. Você pode ler mais em [Pydantic: Concepts: Configuration](https://docs.pydantic.dev/latest/concepts/config/).
///
@@ -291,7 +291,7 @@ No caso da nossa dependência `get_settings()`, a função nem recebe argumentos
Dessa forma, ela se comporta quase como se fosse apenas uma variável global. Mas como usa uma função de dependência, podemos sobrescrevê-la facilmente para testes.
-`@lru_cache` faz parte de `functools`, que faz parte da biblioteca padrão do Python; você pode ler mais sobre isso na
documentação do Python para `@lru_cache`.
+`@lru_cache` faz parte de `functools`, que faz parte da biblioteca padrão do Python; você pode ler mais sobre isso na [documentação do Python para `@lru_cache`](https://docs.python.org/3/library/functools.html#functools.lru_cache).
## Recapitulando { #recap }
diff --git a/docs/pt/docs/advanced/stream-data.md b/docs/pt/docs/advanced/stream-data.md
new file mode 100644
index 0000000000..8e0bf08b68
--- /dev/null
+++ b/docs/pt/docs/advanced/stream-data.md
@@ -0,0 +1,117 @@
+# Transmitir dados { #stream-data }
+
+Se você quer transmitir dados que podem ser estruturados como JSON, você deveria [Transmitir JSON Lines](../tutorial/stream-json-lines.md).
+
+Mas se você quer transmitir dados binários puros ou strings, veja como fazer.
+
+/// info | Informação
+
+Adicionado no FastAPI 0.134.0.
+
+///
+
+## Casos de uso { #use-cases }
+
+Você pode usar isto para transmitir strings puras, por exemplo diretamente da saída de um serviço de AI LLM.
+
+Você também pode usá-lo para transmitir arquivos binários grandes, enviando cada bloco de dados à medida que o lê, sem precisar carregar tudo na memória de uma vez.
+
+Você também pode transmitir vídeo ou áudio desta forma; pode até ser gerado enquanto você processa e envia.
+
+## Um `StreamingResponse` com `yield` { #a-streamingresponse-with-yield }
+
+Se você declarar `response_class=StreamingResponse` na sua função de operação de rota, você pode usar `yield` para enviar cada bloco de dados em sequência.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[1:23] hl[20,23] *}
+
+O FastAPI entregará cada bloco de dados para `StreamingResponse` como está, não tentará convertê-lo para JSON nem nada semelhante.
+
+### Funções de operação de rota não assíncronas { #non-async-path-operation-functions }
+
+Você também pode usar funções `def` normais (sem `async`) e usar `yield` da mesma forma.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[26:29] hl[27] *}
+
+### Sem anotação { #no-annotation }
+
+Você não precisa declarar a anotação de tipo de retorno para transmitir dados binários.
+
+Como o FastAPI não tentará converter os dados para JSON com Pydantic nem serializá-los de nenhuma forma, neste caso a anotação de tipo serve apenas para seu editor e ferramentas; ela não será usada pelo FastAPI.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[32:35] hl[33] *}
+
+Isso também significa que, com `StreamingResponse`, você tem a liberdade e a responsabilidade de produzir e codificar os bytes exatamente como precisam ser enviados, independentemente das anotações de tipo. 🤓
+
+### Transmitir bytes { #stream-bytes }
+
+Um dos principais casos de uso é transmitir `bytes` em vez de strings; você pode fazer isso sem problemas.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[44:47] hl[47] *}
+
+## Um `PNGStreamingResponse` personalizado { #a-custom-pngstreamingresponse }
+
+Nos exemplos acima, os bytes eram transmitidos, mas a resposta não tinha um cabeçalho `Content-Type`, então o cliente não sabia que tipo de dado estava recebendo.
+
+Você pode criar uma subclasse personalizada de `StreamingResponse` que define o cabeçalho `Content-Type` para o tipo de dado que você está transmitindo.
+
+Por exemplo, você pode criar um `PNGStreamingResponse` que define o cabeçalho `Content-Type` como `image/png` usando o atributo `media_type`:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[6,19:20] hl[20] *}
+
+Em seguida, você pode usar essa nova classe em `response_class=PNGStreamingResponse` na sua função de operação de rota:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[23:27] hl[23] *}
+
+### Simular um arquivo { #simulate-a-file }
+
+Neste exemplo, estamos simulando um arquivo com `io.BytesIO`, que é um objeto semelhante a arquivo que vive somente na memória, mas nos permite usar a mesma interface.
+
+Por exemplo, podemos iterar sobre ele para consumir seu conteúdo, como faríamos com um arquivo.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[1:27] hl[3,12:13,25] *}
+
+/// note | Detalhes Técnicos
+
+As outras duas variáveis, `image_base64` e `binary_image`, são uma imagem codificada em Base64 e depois convertida para bytes, para então passá-la para `io.BytesIO`.
+
+Apenas para que possa viver no mesmo arquivo deste exemplo e você possa copiar e executar como está. 🥚
+
+///
+
+Ao usar um bloco `with`, garantimos que o objeto semelhante a arquivo seja fechado após a função geradora (a função com `yield`) terminar. Ou seja, após terminar de enviar a resposta.
+
+Isso não seria tão importante neste exemplo específico porque é um arquivo falso em memória (com `io.BytesIO`), mas com um arquivo real, seria importante garantir que o arquivo fosse fechado ao final do trabalho.
+
+### Arquivos e async { #files-and-async }
+
+Na maioria dos casos, objetos semelhantes a arquivo não são compatíveis com async e await por padrão.
+
+Por exemplo, eles não têm `await file.read()`, nem `async for chunk in file`.
+
+E, em muitos casos, lê-los seria uma operação bloqueante (que poderia bloquear o loop de eventos), pois são lidos do disco ou da rede.
+
+/// info | Informação
+
+O exemplo acima é, na verdade, uma exceção, porque o objeto `io.BytesIO` já está em memória, então lê-lo não bloqueará nada.
+
+Mas, em muitos casos, ler um arquivo ou um objeto semelhante a arquivo bloquearia.
+
+///
+
+Para evitar bloquear o loop de eventos, você pode simplesmente declarar a função de operação de rota com `def` normal em vez de `async def`. Assim, o FastAPI a executará em um worker de threadpool, evitando bloquear o loop principal.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}
+
+/// tip | Dica
+
+Se você precisar chamar código bloqueante de dentro de uma função assíncrona ou uma função assíncrona de dentro de uma função bloqueante, você poderia usar o [Asyncer](https://asyncer.tiangolo.com), uma biblioteca irmã do FastAPI.
+
+///
+
+### `yield from` { #yield-from }
+
+Quando você está iterando sobre algo, como um objeto semelhante a arquivo, e faz `yield` para cada item, você também pode usar `yield from` para produzir cada item diretamente e pular o loop `for`.
+
+Isso não é particular do FastAPI, é apenas Python, mas é um truque útil para conhecer. 😎
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[37:40] hl[40] *}
diff --git a/docs/pt/docs/advanced/strict-content-type.md b/docs/pt/docs/advanced/strict-content-type.md
new file mode 100644
index 0000000000..9530501d4e
--- /dev/null
+++ b/docs/pt/docs/advanced/strict-content-type.md
@@ -0,0 +1,88 @@
+# Verificação Estrita de Content-Type { #strict-content-type-checking }
+
+Por padrão, o **FastAPI** usa verificação estrita do cabeçalho `Content-Type` para corpos de requisição JSON; isso significa que requisições JSON devem incluir um `Content-Type` válido (por exemplo, `application/json`) para que o corpo seja interpretado como JSON.
+
+## Risco de CSRF { #csrf-risk }
+
+Esse comportamento padrão oferece proteção contra uma classe de ataques de **Cross-Site Request Forgery (CSRF)** em um cenário muito específico.
+
+Esses ataques exploram o fato de que navegadores permitem que scripts enviem requisições sem fazer qualquer verificação de preflight de CORS quando:
+
+- não têm um cabeçalho `Content-Type` (por exemplo, usando `fetch()` com um corpo `Blob`)
+- e não enviam nenhuma credencial de autenticação.
+
+Esse tipo de ataque é relevante principalmente quando:
+
+- a aplicação está em execução localmente (por exemplo, em `localhost`) ou em uma rede interna
+- e a aplicação não tem autenticação, pressupondo que qualquer requisição da mesma rede é confiável.
+
+## Exemplo de Ataque { #example-attack }
+
+Imagine que você desenvolve uma forma de executar um agente de IA local.
+
+Ele fornece uma API em
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Há também um frontend em
+
+```
+http://localhost:8000
+```
+
+/// tip | Dica
+
+Observe que ambos têm o mesmo host.
+
+///
+
+Usando o frontend, você pode fazer o agente de IA executar ações em seu nome.
+
+Como está em execução localmente e não na Internet aberta, você decide não configurar autenticação, confiando apenas no acesso à rede local.
+
+Então um de seus usuários poderia instalá-lo e executá-lo localmente.
+
+Em seguida, poderia abrir um site malicioso, por exemplo:
+
+```
+https://evilhackers.example.com
+```
+
+E esse site malicioso envia requisições usando `fetch()` com um corpo `Blob` para a API local em
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Mesmo que o host do site malicioso e o da aplicação local sejam diferentes, o navegador não acionará uma requisição preflight de CORS porque:
+
+- Está em execução sem autenticação, não precisa enviar credenciais.
+- O navegador acha que não está enviando JSON (devido à falta do cabeçalho `Content-Type`).
+
+Então o site malicioso poderia fazer o agente de IA local enviar mensagens raivosas ao ex-chefe do usuário... ou pior. 😅
+
+## Internet Aberta { #open-internet }
+
+Se sua aplicação está na Internet aberta, você não “confiaria na rede” nem deixaria qualquer pessoa enviar requisições privilegiadas sem autenticação.
+
+Atacantes poderiam simplesmente executar um script para enviar requisições à sua API, sem necessidade de interação do navegador, então você provavelmente já está protegendo quaisquer endpoints privilegiados.
+
+Nesse caso, esse ataque/risco não se aplica a você.
+
+Esse risco e ataque é relevante principalmente quando a aplicação roda na rede local e essa é a única proteção presumida.
+
+## Permitindo Requisições sem Content-Type { #allowing-requests-without-content-type }
+
+Se você precisa dar suporte a clientes que não enviam um cabeçalho `Content-Type`, você pode desativar a verificação estrita definindo `strict_content_type=False`:
+
+{* ../../docs_src/strict_content_type/tutorial001_py310.py hl[4] *}
+
+Com essa configuração, requisições sem um cabeçalho `Content-Type` terão o corpo interpretado como JSON, o mesmo comportamento das versões mais antigas do FastAPI.
+
+/// info | Informação
+
+Esse comportamento e configuração foram adicionados no FastAPI 0.132.0.
+
+///
diff --git a/docs/pt/docs/advanced/sub-applications.md b/docs/pt/docs/advanced/sub-applications.md
index 7f176e98d9..1a82b02636 100644
--- a/docs/pt/docs/advanced/sub-applications.md
+++ b/docs/pt/docs/advanced/sub-applications.md
@@ -30,25 +30,25 @@ Neste caso, ela será montada no path `/subapi`:
### Verifique a documentação automática da API { #check-the-automatic-api-docs }
-Agora, execute o comando `fastapi` com o seu arquivo:
+Agora, execute o comando `fastapi`:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-E abra a documentação em
http://127.0.0.1:8000/docs.
+E abra a documentação em [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Você verá a documentação automática da API para a aplicação principal, incluindo apenas suas próprias _operações de rota_:
-E então, abra a documentação para a sub-aplicação, em
http://127.0.0.1:8000/subapi/docs.
+E então, abra a documentação para a sub-aplicação, em [http://127.0.0.1:8000/subapi/docs](http://127.0.0.1:8000/subapi/docs).
Você verá a documentação automática da API para a sub-aplicação, incluindo apenas suas próprias _operações de rota_, todas sob o prefixo de sub-path correto `/subapi`:
@@ -64,4 +64,4 @@ Dessa forma, a sub-aplicação saberá usar esse prefixo de path para a interfac
E a sub-aplicação também poderia ter suas próprias sub-aplicações montadas e tudo funcionaria corretamente, porque o FastAPI lida com todos esses `root_path`s automaticamente.
-Você aprenderá mais sobre o `root_path` e como usá-lo explicitamente na seção sobre [Atrás de um Proxy](behind-a-proxy.md){.internal-link target=_blank}.
+Você aprenderá mais sobre o `root_path` e como usá-lo explicitamente na seção sobre [Atrás de um Proxy](behind-a-proxy.md).
diff --git a/docs/pt/docs/advanced/templates.md b/docs/pt/docs/advanced/templates.md
index 843727f4f8..d3a8ad9b50 100644
--- a/docs/pt/docs/advanced/templates.md
+++ b/docs/pt/docs/advanced/templates.md
@@ -8,7 +8,7 @@ Existem utilitários para configurá-lo facilmente que você pode usar diretamen
## Instalar dependências { #install-dependencies }
-Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e instalar `jinja2`:
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e instalar `jinja2`:
@@ -123,4 +123,4 @@ E como você está usando `StaticFiles`, este arquivo CSS será automaticamente
## Mais detalhes { #more-details }
-Para obter mais detalhes, incluindo como testar templates, consulte a
documentação da Starlette sobre templates.
+Para obter mais detalhes, incluindo como testar templates, consulte a [documentação da Starlette sobre templates](https://www.starlette.dev/templates/).
diff --git a/docs/pt/docs/advanced/testing-websockets.md b/docs/pt/docs/advanced/testing-websockets.md
index ffb0ba3383..f562372729 100644
--- a/docs/pt/docs/advanced/testing-websockets.md
+++ b/docs/pt/docs/advanced/testing-websockets.md
@@ -8,6 +8,6 @@ Para isso, você utiliza o `TestClient` dentro de uma instrução `with`, conect
/// note | Nota
-Para mais detalhes, confira a documentação do Starlette para
testar WebSockets.
+Para mais detalhes, confira a documentação do Starlette para [testar WebSockets](https://www.starlette.dev/testclient/#testing-websocket-sessions).
///
diff --git a/docs/pt/docs/advanced/using-request-directly.md b/docs/pt/docs/advanced/using-request-directly.md
index 283a831d9a..14eac2bf7b 100644
--- a/docs/pt/docs/advanced/using-request-directly.md
+++ b/docs/pt/docs/advanced/using-request-directly.md
@@ -15,7 +15,7 @@ Porém há situações em que você possa precisar acessar o objeto `Request` di
## Detalhes sobre o objeto `Request` { #details-about-the-request-object }
-Como o **FastAPI** é na verdade o **Starlette** por baixo, com camadas de diversas funcionalidades por cima, você pode utilizar o objeto
`Request` do Starlette diretamente quando precisar.
+Como o **FastAPI** é na verdade o **Starlette** por baixo, com camadas de diversas funcionalidades por cima, você pode utilizar o objeto [`Request`](https://www.starlette.dev/requests/) do Starlette diretamente quando precisar.
Isso significaria também que se você obtiver informações do objeto `Request` diretamente (ler o corpo da requisição por exemplo), as informações não serão validadas, convertidas ou documentadas (com o OpenAPI, para a interface de usuário automática da API) pelo FastAPI.
@@ -45,7 +45,7 @@ Do mesmo jeito, você pode declarar qualquer outro parâmetro normalmente, e al
## Documentação do `Request` { #request-documentation }
-Você pode ler mais sobre os detalhes do objeto
`Request` no site da documentação oficial do Starlette..
+Você pode ler mais sobre os detalhes do [objeto `Request` no site da documentação oficial do Starlette](https://www.starlette.dev/requests/).
/// note | Detalhes Técnicos
diff --git a/docs/pt/docs/advanced/websockets.md b/docs/pt/docs/advanced/websockets.md
index f148defd4c..70b2ee853d 100644
--- a/docs/pt/docs/advanced/websockets.md
+++ b/docs/pt/docs/advanced/websockets.md
@@ -1,10 +1,10 @@
# WebSockets { #websockets }
-Você pode usar
WebSockets com **FastAPI**.
+Você pode usar [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) com **FastAPI**.
## Instale `websockets` { #install-websockets }
-Garanta que você criou um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, o ativou e instalou o `websockets` (uma biblioteca Python que facilita o uso do protocolo "WebSocket"):
+Garanta que você criou um [ambiente virtual](../virtual-environments.md), o ativou e instalou o `websockets` (uma biblioteca Python que facilita o uso do protocolo "WebSocket"):
@@ -64,19 +64,19 @@ Você pode receber e enviar dados binários, de texto e JSON.
## Tente { #try-it }
-Se seu arquivo for nomeado `main.py`, execute sua aplicação com:
+Coloque seu código em um arquivo `main.py` e então execute sua aplicação:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-Abra seu navegador em:
http://127.0.0.1:8000.
+Abra seu navegador em: [http://127.0.0.1:8000](http://127.0.0.1:8000).
Você verá uma página simples como:
@@ -115,25 +115,25 @@ Eles funcionam da mesma forma que para outros endpoints FastAPI/*operações de
Como isso é um WebSocket, não faz muito sentido levantar uma `HTTPException`, em vez disso levantamos uma `WebSocketException`.
-Você pode usar um código de fechamento dos
códigos válidos definidos na especificação.
+Você pode usar um código de fechamento dos [códigos válidos definidos na especificação](https://tools.ietf.org/html/rfc6455#section-7.4.1).
///
### Tente os WebSockets com dependências { #try-the-websockets-with-dependencies }
-Se seu arquivo for nomeado `main.py`, execute sua aplicação com:
+Execute sua aplicação:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-Abra seu navegador em:
http://127.0.0.1:8000.
+Abra seu navegador em: [http://127.0.0.1:8000](http://127.0.0.1:8000).
Lá você pode definir:
@@ -174,7 +174,7 @@ O app acima é um exemplo mínimo e simples para demonstrar como lidar e transmi
Mas tenha em mente que, como tudo é manipulado na memória, em uma única list, ele só funcionará enquanto o processo estiver em execução e só funcionará com um único processo.
-Se você precisa de algo fácil de integrar com o FastAPI, mas que seja mais robusto, suportado por Redis, PostgreSQL ou outros, verifique o
encode/broadcaster.
+Se você precisa de algo fácil de integrar com o FastAPI, mas que seja mais robusto, suportado por Redis, PostgreSQL ou outros, verifique [encode/broadcaster](https://github.com/encode/broadcaster).
///
@@ -182,5 +182,5 @@ Se você precisa de algo fácil de integrar com o FastAPI, mas que seja mais rob
Para aprender mais sobre as opções, verifique a documentação do Starlette para:
-*
A classe `WebSocket`.
-*
Manipulação de WebSockets baseada em classes.
+* [A classe `WebSocket`](https://www.starlette.dev/websockets/).
+* [Manipulação de WebSockets baseada em classes](https://www.starlette.dev/endpoints/#websocketendpoint).
diff --git a/docs/pt/docs/advanced/wsgi.md b/docs/pt/docs/advanced/wsgi.md
index 3178b85eb0..110bba0538 100644
--- a/docs/pt/docs/advanced/wsgi.md
+++ b/docs/pt/docs/advanced/wsgi.md
@@ -1,6 +1,6 @@
# Adicionando WSGI - Flask, Django, entre outros { #including-wsgi-flask-django-others }
-Como você viu em [Subaplicações - Montagens](sub-applications.md){.internal-link target=_blank} e [Atrás de um Proxy](behind-a-proxy.md){.internal-link target=_blank}, você pode montar aplicações WSGI.
+Como você viu em [Subaplicações - Montagens](sub-applications.md) e [Atrás de um Proxy](behind-a-proxy.md), você pode montar aplicações WSGI.
Para isso, você pode utilizar o `WSGIMiddleware` para encapsular a sua aplicação WSGI, como por exemplo Flask, Django, etc.
@@ -36,13 +36,13 @@ Agora, todas as requisições sob o path `/v1/` serão manipuladas pela aplicaç
E o resto será manipulado pelo **FastAPI**.
-Se você rodar a aplicação e ir até
http://localhost:8000/v1/, você verá o retorno do Flask:
+Se você rodar a aplicação e ir até [http://localhost:8000/v1/](http://localhost:8000/v1/), você verá o retorno do Flask:
```txt
Hello, World from Flask!
```
-E se você for até
http://localhost:8000/v2, você verá o retorno do FastAPI:
+E se você for até [http://localhost:8000/v2](http://localhost:8000/v2), você verá o retorno do FastAPI:
```JSON
{
diff --git a/docs/pt/docs/alternatives.md b/docs/pt/docs/alternatives.md
index 17ef260dd4..828561542d 100644
--- a/docs/pt/docs/alternatives.md
+++ b/docs/pt/docs/alternatives.md
@@ -14,7 +14,7 @@ Mas em algum momento, não havia outra opção senão criar algo que fornecesse
## Ferramentas anteriores { #previous-tools }
-###
Django { #django }
+### [Django](https://www.djangoproject.com/) { #django }
É o framework Python mais popular e amplamente confiável. É utilizado para construir sistemas como o Instagram.
@@ -22,7 +22,7 @@ Mas em algum momento, não havia outra opção senão criar algo que fornecesse
Foi criado para gerar o HTML no backend, não para criar APIs usadas por um frontend moderno (como React, Vue.js e Angular) ou por outros sistemas (como dispositivos
IoT) comunicando com ele.
-###
Django REST Framework { #django-rest-framework }
+### [Django REST Framework](https://www.django-rest-framework.org/) { #django-rest-framework }
Django REST framework foi criado para ser uma caixa de ferramentas flexível para construção de APIs Web utilizando Django por baixo, para melhorar suas capacidades de API.
@@ -36,13 +36,13 @@ Django REST Framework foi criado por Tom Christie. O mesmo criador de Starlette
///
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Ter uma interface web de documentação automática da API.
///
-###
Flask { #flask }
+### [Flask](https://flask.palletsprojects.com) { #flask }
Flask é um "microframework", não inclui integrações com banco de dados nem muitas das coisas que vêm por padrão no Django.
@@ -56,7 +56,7 @@ Esse desacoplamento de partes, e ser um "microframework" que pode ser estendido
Dada a simplicidade do Flask, ele parecia uma boa opção para construção de APIs. A próxima coisa a encontrar era um "Django REST Framework" para Flask.
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Ser um microframework. Tornar fácil misturar e combinar as ferramentas e partes necessárias.
@@ -64,7 +64,7 @@ Ter um sistema de roteamento simples e fácil de usar.
///
-###
Requests { #requests }
+### [Requests](https://requests.readthedocs.io) { #requests }
**FastAPI** na verdade não é uma alternativa ao **Requests**. O escopo deles é muito diferente.
@@ -98,7 +98,7 @@ def read_url():
Veja as similaridades em `requests.get(...)` e `@app.get(...)`.
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
* Ter uma API simples e intuitiva.
* Utilizar nomes de métodos HTTP (operações) diretamente, de um jeito direto e intuitivo.
@@ -106,7 +106,7 @@ Veja as similaridades em `requests.get(...)` e `@app.get(...)`.
///
-###
Swagger /
OpenAPI { #swagger-openapi }
+### [Swagger](https://swagger.io/) / [OpenAPI](https://github.com/OAI/OpenAPI-Specification/) { #swagger-openapi }
A principal funcionalidade que eu queria do Django REST Framework era a documentação automática da API.
@@ -118,14 +118,14 @@ Em algum ponto, Swagger foi doado para a Fundação Linux, para ser renomeado Op
É por isso que ao falar sobre a versão 2.0 é comum dizer "Swagger", e para a versão 3+ "OpenAPI".
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Adotar e usar um padrão aberto para especificações de API, em vez de um schema personalizado.
E integrar ferramentas de interface para usuários baseadas nos padrões:
-*
Swagger UI
-*
ReDoc
+* [Swagger UI](https://github.com/swagger-api/swagger-ui)
+* [ReDoc](https://github.com/Rebilly/ReDoc)
Essas duas foram escolhidas por serem bem populares e estáveis, mas fazendo uma pesquisa rápida, você pode encontrar dúzias de interfaces alternativas adicionais para OpenAPI (que você pode utilizar com **FastAPI**).
@@ -135,7 +135,7 @@ Essas duas foram escolhidas por serem bem populares e estáveis, mas fazendo uma
Existem vários Flask REST frameworks, mas depois de investir tempo e trabalho investigando-os, descobri que muitos estão descontinuados ou abandonados, com diversas questões em aberto que os tornaram inadequados.
-###
Marshmallow { #marshmallow }
+### [Marshmallow](https://marshmallow.readthedocs.io/en/stable/) { #marshmallow }
Uma das principais funcionalidades necessárias em sistemas de API é a "
serialização" de dados, que é pegar dados do código (Python) e convertê-los em algo que possa ser enviado pela rede. Por exemplo, converter um objeto contendo dados de um banco de dados em um objeto JSON. Converter objetos `datetime` em strings, etc.
@@ -147,13 +147,13 @@ Essas funcionalidades são o que o Marshmallow foi construído para fornecer. É
Mas ele foi criado antes de existirem as anotações de tipo do Python. Então, para definir cada
schema você precisa utilizar utilitários e classes específicos fornecidos pelo Marshmallow.
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Usar código para definir "schemas" que forneçam, automaticamente, tipos de dados e validação.
///
-###
Webargs { #webargs }
+### [Webargs](https://webargs.readthedocs.io/en/latest/) { #webargs }
Outra grande funcionalidade requerida pelas APIs é o
parsing de dados vindos de requisições de entrada.
@@ -169,13 +169,13 @@ Webargs foi criado pelos mesmos desenvolvedores do Marshmallow.
///
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Ter validação automática dos dados de requisições de entrada.
///
-###
APISpec { #apispec }
+### [APISpec](https://apispec.readthedocs.io/en/stable/) { #apispec }
Marshmallow e Webargs fornecem validação, parsing e serialização como plug-ins.
@@ -199,13 +199,13 @@ APISpec foi criado pelos mesmos desenvolvedores do Marshmallow.
///
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Dar suporte ao padrão aberto para APIs, OpenAPI.
///
-###
Flask-apispec { #flask-apispec }
+### [Flask-apispec](https://flask-apispec.readthedocs.io/en/latest/) { #flask-apispec }
É um plug-in Flask, que amarra juntos Webargs, Marshmallow e APISpec.
@@ -219,11 +219,11 @@ Essa combinação de Flask, Flask-apispec com Marshmallow e Webargs foi a minha
Usá-la levou à criação de vários geradores Flask full-stack. Estas são as principais stacks que eu (e várias equipes externas) tenho utilizado até agora:
-*
https://github.com/tiangolo/full-stack
-*
https://github.com/tiangolo/full-stack-flask-couchbase
-*
https://github.com/tiangolo/full-stack-flask-couchdb
+* [https://github.com/tiangolo/full-stack](https://github.com/tiangolo/full-stack)
+* [https://github.com/tiangolo/full-stack-flask-couchbase](https://github.com/tiangolo/full-stack-flask-couchbase)
+* [https://github.com/tiangolo/full-stack-flask-couchdb](https://github.com/tiangolo/full-stack-flask-couchdb)
-E esses mesmos geradores full-stack foram a base dos [Geradores de Projetos **FastAPI**](project-generation.md){.internal-link target=_blank}.
+E esses mesmos geradores full-stack foram a base dos [Geradores de Projetos **FastAPI**](project-generation.md).
/// info | Informação
@@ -231,13 +231,13 @@ Flask-apispec foi criado pelos mesmos desenvolvedores do Marshmallow.
///
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Gerar o schema OpenAPI automaticamente, a partir do mesmo código que define serialização e validação.
///
-###
NestJS (e
Angular) { #nestjs-and-angular }
+### [NestJS](https://nestjs.com/) (e [Angular](https://angular.io/)) { #nestjs-and-angular }
Isso nem é Python, NestJS é um framework NodeJS em JavaScript (TypeScript) inspirado pelo Angular.
@@ -251,7 +251,7 @@ Mas como os dados do TypeScript não são preservados após a compilação para
Ele não consegue lidar muito bem com modelos aninhados. Então, se o corpo JSON na requisição for um objeto JSON que contém campos internos que por sua vez são objetos JSON aninhados, ele não consegue ser documentado e validado apropriadamente.
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Usar tipos do Python para ter um ótimo suporte do editor.
@@ -259,19 +259,19 @@ Ter um sistema de injeção de dependência poderoso. Encontrar um jeito de mini
///
-###
Sanic { #sanic }
+### [Sanic](https://sanic.readthedocs.io/en/latest/) { #sanic }
Ele foi um dos primeiros frameworks Python extremamente rápidos baseados em `asyncio`. Ele foi feito para ser muito similar ao Flask.
/// note | Detalhes Técnicos
-Ele utilizava
`uvloop` em vez do loop `asyncio` padrão do Python. É isso que o deixava tão rápido.
+Ele utilizava [`uvloop`](https://github.com/MagicStack/uvloop) em vez do loop `asyncio` padrão do Python. É isso que o deixava tão rápido.
Ele claramente inspirou Uvicorn e Starlette, que atualmente são mais rápidos que o Sanic em benchmarks abertos.
///
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Encontrar um jeito de ter uma performance insana.
@@ -279,7 +279,7 @@ Encontrar um jeito de ter uma performance insana.
///
-###
Falcon { #falcon }
+### [Falcon](https://falconframework.org/) { #falcon }
Falcon é outro framework Python de alta performance, projetado para ser minimalista, e servir como base para outros frameworks como Hug.
@@ -287,7 +287,7 @@ Ele é projetado para ter funções que recebem dois parâmetros, uma "request"
Então, validação de dados, serialização e documentação têm que ser feitos no código, não automaticamente. Ou eles têm que ser implementados como um framework acima do Falcon, como o Hug. Essa mesma distinção acontece em outros frameworks inspirados pelo design do Falcon, de ter um objeto de request e um objeto de response como parâmetros.
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Encontrar maneiras de obter uma ótima performance.
@@ -297,7 +297,7 @@ Embora no FastAPI seja opcional, é utilizado principalmente para configurar cab
///
-###
Molten { #molten }
+### [Molten](https://moltenframework.com/) { #molten }
Eu descobri Molten nos primeiros estágios da construção do **FastAPI**. E ele tem ideias bastante similares:
@@ -313,7 +313,7 @@ O sistema de injeção de dependência exige pré-registro das dependências e e
As rotas são declaradas em um único lugar, usando funções declaradas em outros lugares (em vez de usar decorators que possam ser colocados diretamente acima da função que lida com o endpoint). Isso é mais próximo de como o Django faz do que de como o Flask (e o Starlette) fazem. Separa no código coisas que são relativamente bem acopladas.
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Definir validações extras para tipos de dados usando o valor "padrão" de atributos dos modelos. Isso melhora o suporte do editor, e não estava disponível no Pydantic antes.
@@ -321,7 +321,7 @@ Isso na verdade inspirou a atualização de partes do Pydantic, para dar suporte
///
-###
Hug { #hug }
+### [Hug](https://github.com/hugapi/hug) { #hug }
Hug foi um dos primeiros frameworks a implementar a declaração de tipos de parâmetros de API usando anotações de tipo do Python. Isso foi uma ótima ideia que inspirou outras ferramentas a fazer o mesmo.
@@ -337,7 +337,7 @@ Como é baseado no padrão anterior para frameworks web Python síncronos (WSGI)
/// info | Informação
-Hug foi criado por Timothy Crosley, o mesmo criador do
`isort`, uma ótima ferramenta para ordenar automaticamente imports em arquivos Python.
+Hug foi criado por Timothy Crosley, o mesmo criador do [`isort`](https://github.com/timothycrosley/isort), uma ótima ferramenta para ordenar automaticamente imports em arquivos Python.
///
@@ -351,7 +351,7 @@ Hug inspirou **FastAPI** a declarar um parâmetro de `response` em funções par
///
-###
APIStar (<= 0.5) { #apistar-0-5 }
+### [APIStar](https://github.com/encode/apistar) (<= 0.5) { #apistar-0-5 }
Pouco antes de decidir construir o **FastAPI** eu encontrei o servidor **APIStar**. Ele tinha quase tudo o que eu estava procurando e tinha um ótimo design.
@@ -385,7 +385,7 @@ APIStar foi criado por Tom Christie. O mesmo cara que criou:
///
-/// check | **FastAPI** inspirado para
+/// check | Inspirou o **FastAPI** a
Existir.
@@ -401,7 +401,7 @@ Eu considero o **FastAPI** um "sucessor espiritual" do APIStar, enquanto aprimor
## Usados por **FastAPI** { #used-by-fastapi }
-###
Pydantic { #pydantic }
+### [Pydantic](https://docs.pydantic.dev/) { #pydantic }
Pydantic é uma biblioteca para definir validação de dados, serialização e documentação (usando JSON Schema) com base nas anotações de tipo do Python.
@@ -417,7 +417,7 @@ Controlar toda a validação de dados, serialização de dados e documentação
///
-###
Starlette { #starlette }
+### [Starlette](https://www.starlette.dev/) { #starlette }
Starlette é um framework/caixa de ferramentas
ASGI leve, o que é ideal para construir serviços asyncio de alta performance.
@@ -462,7 +462,7 @@ Então, qualquer coisa que você pode fazer com Starlette, você pode fazer dire
///
-###
Uvicorn { #uvicorn }
+### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }
Uvicorn é um servidor ASGI extremamente rápido, construído com uvloop e httptools.
@@ -476,10 +476,10 @@ O principal servidor web para rodar aplicações **FastAPI**.
Você também pode usar a opção de linha de comando `--workers` para ter um servidor assíncrono multi-processos.
-Verifique mais detalhes na seção [Deployment](deployment/index.md){.internal-link target=_blank}.
+Verifique mais detalhes na seção [Implantação](deployment/index.md).
///
## Benchmarks e velocidade { #benchmarks-and-speed }
-Para entender, comparar e ver a diferença entre Uvicorn, Starlette e FastAPI, verifique a seção sobre [Benchmarks](benchmarks.md){.internal-link target=_blank}.
+Para entender, comparar e ver a diferença entre Uvicorn, Starlette e FastAPI, verifique a seção sobre [Benchmarks](benchmarks.md).
diff --git a/docs/pt/docs/async.md b/docs/pt/docs/async.md
index f01ff23159..fa1e430036 100644
--- a/docs/pt/docs/async.md
+++ b/docs/pt/docs/async.md
@@ -4,7 +4,7 @@ Detalhes sobre a sintaxe `async def` para *funções de operação de rota* e al
## Com pressa? { #in-a-hurry }
-
TL;DR:
+
TL;DR:
Se você estiver utilizando bibliotecas de terceiros que dizem para você chamar as funções com `await`, como:
@@ -74,7 +74,7 @@ Então o computador / programa 🤖 irá voltar sempre que tiver uma chance, sej
Depois, ele 🤖 pega a primeira tarefa para finalizar (vamos dizer, nosso "arquivo lento" 📝) e continua o que tem que fazer com ela.
-Esse "esperar por algo" normalmente se refere a operações
I/O que são relativamente "lentas" (comparadas à velocidade do processador e da memória RAM), como esperar por:
+Esse "esperar por algo" normalmente se refere a operações
I/O que são relativamente "lentas" (comparadas à velocidade do processador e da memória RAM), como esperar por:
* dados do cliente para serem enviados através da rede
* dados enviados pelo seu programa serem recebidos pelo cliente através da rede
@@ -85,7 +85,7 @@ Esse "esperar por algo" normalmente se refere a operações
I/O, essas operações são chamadas operações "limitadas por I/O".
+Quanto o tempo de execução é consumido majoritariamente pela espera de operações
I/O, essas operações são chamadas operações "limitadas por I/O".
Isso é chamado de "assíncrono" porque o computador / programa não tem que ser "sincronizado" com a tarefa lenta, esperando pelo momento exato em que a tarefa finaliza, enquanto não faz nada, para ser capaz de pegar o resultado da tarefa e dar continuidade ao trabalho.
@@ -141,7 +141,7 @@ Você e seu _crush_ comem os hambúrgueres e aproveitam o tempo. ✨
/// info | Informação
-Belas ilustrações de
Ketrina Thompson. 🎨
+Belas ilustrações de [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). 🎨
///
@@ -207,7 +207,7 @@ Não houve muita conversa ou flerte já que a maior parte do tempo foi gasto esp
/// info | Informação
-Belas ilustrações de
Ketrina Thompson. 🎨
+Belas ilustrações de [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). 🎨
///
@@ -251,7 +251,7 @@ Esse tipo de assincronicidade é o que fez NodeJS popular (embora NodeJS não se
E esse é o mesmo nível de performance que você tem com o **FastAPI**.
-E como você pode ter paralelismo e assincronicidade ao mesmo tempo, você tem uma maior performance do que a maioria dos frameworks NodeJS testados e lado a lado com Go, que é uma linguagem compilada, mais próxima ao C
(tudo graças ao Starlette).
+E como você pode ter paralelismo e assincronicidade ao mesmo tempo, você tem uma maior performance do que a maioria dos frameworks NodeJS testados e lado a lado com Go, que é uma linguagem compilada, mais próxima ao C [(tudo graças ao Starlette)](https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1).
### Concorrência é melhor que paralelismo? { #is-concurrency-better-than-parallelism }
@@ -277,7 +277,7 @@ Mas nesse caso, se você trouxesse os 8 ex-caixas / cozinheiros / agora-faxineir
Nesse cenário, cada um dos faxineiros (incluindo você) poderia ser um processador, fazendo a sua parte do trabalho.
-E a maior parte do tempo de execução é tomada por trabalho real (ao invés de ficar esperando), e o trabalho em um computador é feito pela
CPU. Eles chamam esses problemas de "limitados por CPU".
+E a maior parte do tempo de execução é tomada por trabalho real (ao invés de ficar esperando), e o trabalho em um computador é feito pela
CPU. Eles chamam esses problemas de "limitados por CPU".
---
@@ -298,7 +298,7 @@ Mas você também pode explorar os benefícios do paralelismo e multiprocessamen
Isso, somado ao simples fato que Python é a principal linguagem para **Data Science**, Aprendizado de Máquina e especialmente Deep Learning, faz do FastAPI uma ótima escolha para APIs web e aplicações com Data Science / Aprendizado de Máquina (entre muitas outras).
-Para ver como alcançar esse paralelismo em produção veja a seção sobre [Implantação](deployment/index.md){.internal-link target=_blank}.
+Para ver como alcançar esse paralelismo em produção veja a seção sobre [Implantação](deployment/index.md).
## `async` e `await` { #async-and-await }
@@ -363,13 +363,13 @@ Mas se você quiser usar `async` / `await` sem FastAPI, você também pode fazê
### Escreva seu próprio código assíncrono { #write-your-own-async-code }
-Starlette (e **FastAPI**) são baseados no
AnyIO, o que o torna compatível com ambos o
asyncio da biblioteca padrão do Python, e o
Trio.
+Starlette (e **FastAPI**) são baseados no [AnyIO](https://anyio.readthedocs.io/en/stable/), o que o torna compatível com ambos o [asyncio](https://docs.python.org/3/library/asyncio-task.html) da biblioteca padrão do Python, e o [Trio](https://trio.readthedocs.io/en/stable/).
-Em particular, você pode usar diretamente o
AnyIO para seus casos de uso avançados de concorrência que requerem padrões mais avançados no seu próprio código.
+Em particular, você pode usar diretamente o [AnyIO](https://anyio.readthedocs.io/en/stable/) para seus casos de uso avançados de concorrência que requerem padrões mais avançados no seu próprio código.
-E até se você não estiver utilizando FastAPI, você também pode escrever suas próprias aplicações assíncronas com o
AnyIO por ser altamente compatível e ganhar seus benefícios (e.g. *concorrência estruturada*).
+E até se você não estiver utilizando FastAPI, você também pode escrever suas próprias aplicações assíncronas com o [AnyIO](https://anyio.readthedocs.io/en/stable/) por ser altamente compatível e ganhar seus benefícios (e.g. *concorrência estruturada*).
-Eu criei outra biblioteca em cima do AnyIO, como uma fina camada acima, para melhorar um pouco as anotações de tipo e obter melhor **preenchimento automático**, **erros inline**, etc. Ela também possui uma introdução amigável e um tutorial para ajudar você a **entender** e escrever **seu próprio código async**:
Asyncer. Seria particularmente útil se você precisar **combinar código async com código regular** (bloqueador/síncrono).
+Eu criei outra biblioteca em cima do AnyIO, como uma fina camada acima, para melhorar um pouco as anotações de tipo e obter melhor **preenchimento automático**, **erros inline**, etc. Ela também possui uma introdução amigável e um tutorial para ajudar você a **entender** e escrever **seu próprio código async**: [Asyncer](https://asyncer.tiangolo.com/). Seria particularmente útil se você precisar **combinar código async com código regular** (bloqueador/síncrono).
### Outras formas de código assíncrono { #other-forms-of-asynchronous-code }
@@ -381,7 +381,7 @@ Essa mesma sintaxe (ou quase a mesma) foi também incluída recentemente em vers
Mas antes disso, controlar código assíncrono era bem mais complexo e difícil.
-Nas versões anteriores do Python, você poderia utilizar threads ou
Gevent. Mas o código é bem mais complexo de entender, debugar, e pensar sobre.
+Nas versões anteriores do Python, você poderia utilizar threads ou [Gevent](https://www.gevent.org/). Mas o código é bem mais complexo de entender, debugar, e pensar sobre.
Nas versões anteriores do NodeJS / Navegador JavaScript, você utilizaria "callbacks". O que leva ao "inferno do callback".
@@ -417,17 +417,17 @@ Se você tem certo conhecimento técnico (corrotinas, threads, blocking etc) e e
Quando você declara uma *função de operação de rota* com `def` normal ao invés de `async def`, ela é rodada em uma threadpool externa que é então aguardada, ao invés de ser chamada diretamente (já que ela bloquearia o servidor).
-Se você está chegando de outro framework assíncrono que não funciona como descrito acima e você está acostumado a definir *funções de operação de rota* triviais somente de computação com simples `def` para ter um mínimo ganho de performance (cerca de 100 nanosegundos), por favor observe que no **FastAPI** o efeito pode ser bem o oposto. Nesses casos, é melhor usar `async def` a menos que suas *funções de operação de rota* utilizem código que performe bloqueamento
I/O.
+Se você está chegando de outro framework assíncrono que não funciona como descrito acima e você está acostumado a definir *funções de operação de rota* triviais somente de computação com simples `def` para ter um mínimo ganho de performance (cerca de 100 nanosegundos), por favor observe que no **FastAPI** o efeito pode ser bem o oposto. Nesses casos, é melhor usar `async def` a menos que suas *funções de operação de rota* utilizem código que performe bloqueamento
I/O.
-Ainda, em ambas as situações, as chances são que o **FastAPI** [ainda será mais rápido](index.md#performance){.internal-link target=_blank} do que (ou ao menos comparável a) seu framework anterior.
+Ainda, em ambas as situações, as chances são que o **FastAPI** [ainda será mais rápido](index.md#performance) do que (ou ao menos comparável a) seu framework anterior.
### Dependências { #dependencies }
-O mesmo se aplica para as [dependências](tutorial/dependencies/index.md){.internal-link target=_blank}. Se uma dependência tem as funções com padrão `def` ao invés de `async def`, ela é rodada no threadpool externo.
+O mesmo se aplica para as [dependências](tutorial/dependencies/index.md). Se uma dependência tem as funções com padrão `def` ao invés de `async def`, ela é rodada no threadpool externo.
### Sub-dependências { #sub-dependencies }
-Você pode ter múltiplas dependências e [sub-dependências](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank} requisitando uma à outra (como parâmetros de definições de funções), algumas delas podem ser criadas com `async def` e algumas com `def` normal. Isso ainda funcionaria, e aquelas criadas com `def` normal seriam chamadas em uma thread externa (do threadpool) ao invés de serem "aguardadas".
+Você pode ter múltiplas dependências e [sub-dependências](tutorial/dependencies/sub-dependencies.md) requisitando uma à outra (como parâmetros de definições de funções), algumas delas podem ser criadas com `async def` e algumas com `def` normal. Isso ainda funcionaria, e aquelas criadas com `def` normal seriam chamadas em uma thread externa (do threadpool) ao invés de serem "aguardadas".
### Outras funções de utilidade { #other-utility-functions }
diff --git a/docs/pt/docs/benchmarks.md b/docs/pt/docs/benchmarks.md
index a54df3d9d5..ac34a4e5e0 100644
--- a/docs/pt/docs/benchmarks.md
+++ b/docs/pt/docs/benchmarks.md
@@ -1,6 +1,6 @@
# Benchmarks { #benchmarks }
-Benchmarks independentes da TechEmpower mostram as aplicações **FastAPI** rodando com Uvicorn como
um dos frameworks Python mais rápidos disponíveis, somente atrás dos próprios Starlette e Uvicorn (utilizados internamente pelo FastAPI).
+Benchmarks independentes da TechEmpower mostram as aplicações **FastAPI** rodando com Uvicorn como [um dos frameworks Python mais rápidos disponíveis](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7), somente atrás dos próprios Starlette e Uvicorn (utilizados internamente pelo FastAPI).
Mas quando se checa _benchmarks_ e comparações você deveria ter o seguinte em mente.
diff --git a/docs/pt/docs/deployment/cloud.md b/docs/pt/docs/deployment/cloud.md
index 2e181146ba..4b0eb9553f 100644
--- a/docs/pt/docs/deployment/cloud.md
+++ b/docs/pt/docs/deployment/cloud.md
@@ -6,7 +6,7 @@ Na maioria dos casos, os principais provedores de nuvem têm tutoriais para impl
## FastAPI Cloud { #fastapi-cloud }
-**
FastAPI Cloud** é desenvolvido pelo mesmo autor e equipe por trás do **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** é desenvolvido pelo mesmo autor e equipe por trás do **FastAPI**.
Ele simplifica o processo de **criar**, **implantar** e **acessar** uma API com o mínimo de esforço.
@@ -16,9 +16,9 @@ FastAPI Cloud é o patrocinador principal e provedor de financiamento dos projet
## Provedores de Nuvem - Patrocinadores { #cloud-providers-sponsors }
-Alguns outros provedores de nuvem ✨ [**patrocinam o FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨ também. 🙇
+Alguns outros provedores de nuvem ✨ [**patrocinam o FastAPI**](../help-fastapi.md#sponsor-the-author) ✨ também. 🙇
Você também pode considerá-los para seguir seus tutoriais e experimentar seus serviços:
-*
Render
-*
Railway
+* [Render](https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi)
+* [Railway](https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi)
diff --git a/docs/pt/docs/deployment/concepts.md b/docs/pt/docs/deployment/concepts.md
index 6af4b177a3..e6338d5eaf 100644
--- a/docs/pt/docs/deployment/concepts.md
+++ b/docs/pt/docs/deployment/concepts.md
@@ -25,7 +25,7 @@ Mas por enquanto, vamos verificar essas importantes **ideias conceituais**. Esse
## Segurança - HTTPS { #security-https }
-No [capítulo anterior sobre HTTPS](https.md){.internal-link target=_blank} aprendemos como o HTTPS fornece criptografia para sua API.
+No [capítulo anterior sobre HTTPS](https.md) aprendemos como o HTTPS fornece criptografia para sua API.
Também vimos que o HTTPS normalmente é fornecido por um componente **externo** ao seu servidor de aplicativos, um **Proxy de terminação TLS**.
@@ -145,7 +145,7 @@ O cliente receberá um **Erro Interno do Servidor 500** para essa solicitação,
No entanto, pode haver casos em que escrevemos algum código que **trava todo o aplicativo**, fazendo com que o Uvicorn e o Python travem. 💥
-E ainda assim, você provavelmente não gostaria que o aplicativo permanecesse inativo porque houve um erro em um lugar, você provavelmente quer que ele **continue em execução** pelo menos para as *operações de caminho* que não estão quebradas.
+E ainda assim, você provavelmente não gostaria que o aplicativo permanecesse inativo porque houve um erro em um lugar, você provavelmente quer que ele **continue em execução** pelo menos para as *operações de rota* que não estão quebradas.
### Reiniciar após falha { #restart-after-crash }
@@ -190,7 +190,7 @@ Quando você executa **vários processos** do mesmo programa de API, eles são c
### Processos do Trabalhador e Portas { #worker-processes-and-ports }
-Lembra da documentação [Sobre HTTPS](https.md){.internal-link target=_blank} que diz que apenas um processo pode escutar em uma combinação de porta e endereço IP em um servidor?
+Lembra da documentação [Sobre HTTPS](https.md) que diz que apenas um processo pode escutar em uma combinação de porta e endereço IP em um servidor?
Isso ainda é verdade.
@@ -204,7 +204,7 @@ E vários processos normalmente **não compartilham nenhuma memória**. Isso sig
### Memória do servidor { #server-memory }
-Por exemplo, se seu código carrega um modelo de Machine Learning com **1 GB de tamanho**, quando você executa um processo com sua API, ele consumirá pelo menos 1 GB de RAM. E se você iniciar **4 processos** (4 trabalhadores), cada um consumirá 1 GB de RAM. Então, no total, sua API consumirá **4 GB de RAM**.
+Por exemplo, se seu código carrega um modelo de Aprendizado de Máquina com **1 GB de tamanho**, quando você executa um processo com sua API, ele consumirá pelo menos 1 GB de RAM. E se você iniciar **4 processos** (4 trabalhadores), cada um consumirá 1 GB de RAM. Então, no total, sua API consumirá **4 GB de RAM**.
E se o seu servidor remoto ou máquina virtual tiver apenas 3 GB de RAM, tentar carregar mais de 4 GB de RAM causará problemas. 🚨
@@ -243,7 +243,7 @@ Aqui estão algumas combinações e estratégias possíveis:
Não se preocupe se alguns desses itens sobre **contêineres**, Docker ou Kubernetes ainda não fizerem muito sentido.
-Falarei mais sobre imagens de contêiner, Docker, Kubernetes, etc. em um capítulo futuro: [FastAPI em contêineres - Docker](docker.md){.internal-link target=_blank}.
+Falarei mais sobre imagens de contêiner, Docker, Kubernetes, etc. em um capítulo futuro: [FastAPI em contêineres - Docker](docker.md).
///
@@ -281,7 +281,7 @@ Aqui estão algumas ideias possíveis:
/// tip | Dica
-Darei exemplos mais concretos de como fazer isso com contêineres em um capítulo futuro: [FastAPI em contêineres - Docker](docker.md){.internal-link target=_blank}.
+Darei exemplos mais concretos de como fazer isso com contêineres em um capítulo futuro: [FastAPI em contêineres - Docker](docker.md).
///
diff --git a/docs/pt/docs/deployment/docker.md b/docs/pt/docs/deployment/docker.md
index 4663e96a11..33e23351f3 100644
--- a/docs/pt/docs/deployment/docker.md
+++ b/docs/pt/docs/deployment/docker.md
@@ -1,6 +1,6 @@
# FastAPI em contêineres - Docker { #fastapi-in-containers-docker }
-Ao fazer o deploy de aplicações FastAPI uma abordagem comum é construir uma **imagem de contêiner Linux**. Isso normalmente é feito usando o
**Docker**. Você pode a partir disso fazer o deploy dessa imagem de algumas maneiras.
+Ao fazer o deploy de aplicações FastAPI uma abordagem comum é construir uma **imagem de contêiner Linux**. Isso normalmente é feito usando o [**Docker**](https://www.docker.com/). Você pode a partir disso fazer o deploy dessa imagem de algumas maneiras.
Usando contêineres Linux você tem diversas vantagens incluindo **segurança**, **replicabilidade**, **simplicidade**, entre outras.
@@ -60,16 +60,16 @@ E o **contêiner** em si (em contraste à **imagem de contêiner**) é a própri
Docker tem sido uma das principais ferramentas para criar e gerenciar **imagens de contêiner** e **contêineres**.
-E existe um
Docker Hub público com **imagens de contêiner oficiais** pré-prontas para diversas ferramentas, ambientes, bancos de dados e aplicações.
+E existe um [Docker Hub](https://hub.docker.com/) público com **imagens de contêiner oficiais** pré-prontas para diversas ferramentas, ambientes, bancos de dados e aplicações.
-Por exemplo, há uma
Imagem Python oficial.
+Por exemplo, há uma [Imagem Python](https://hub.docker.com/_/python) oficial.
E existe muitas outras imagens para diferentes coisas, como bancos de dados, por exemplo:
-*
PostgreSQL
-*
MySQL
-*
MongoDB
-*
Redis, etc.
+* [PostgreSQL](https://hub.docker.com/_/postgres)
+* [MySQL](https://hub.docker.com/_/mysql)
+* [MongoDB](https://hub.docker.com/_/mongo)
+* [Redis](https://hub.docker.com/_/redis), etc.
Usando imagens de contêiner pré-prontas é muito fácil **combinar** e usar diferentes ferramentas. Por exemplo, para testar um novo banco de dados. Em muitos casos, você pode usar as **imagens oficiais**, precisando somente de variáveis de ambiente para configurá-las.
@@ -111,7 +111,7 @@ Isso pode depender principalmente da ferramenta que você usa para **instalar**
A forma mais comum de fazer isso é ter um arquivo `requirements.txt` com os nomes dos pacotes e suas versões, um por linha.
-Você, naturalmente, usaria as mesmas ideias que você leu em [Sobre versões do FastAPI](versions.md){.internal-link target=_blank} para definir os intervalos de versões.
+Você, naturalmente, usaria as mesmas ideias que você leu em [Sobre versões do FastAPI](versions.md) para definir os intervalos de versões.
Por exemplo, seu `requirements.txt` poderia parecer com:
@@ -238,7 +238,7 @@ Certifique-se de **sempre** usar a **forma exec** da instrução `CMD`, como exp
#### Use `CMD` - Forma Exec { #use-cmd-exec-form }
-A instrução
`CMD` no Docker pode ser escrita de duas formas:
+A instrução [`CMD`](https://docs.docker.com/reference/dockerfile/#cmd) no Docker pode ser escrita de duas formas:
✅ Forma **Exec**:
@@ -254,11 +254,11 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"]
CMD fastapi run app/main.py --port 80
```
-Garanta que você sempre use a forma **exec** para assegurar que o FastAPI consiga encerrar graciosamente e que os [eventos de lifespan](../advanced/events.md){.internal-link target=_blank} sejam disparados.
+Garanta que você sempre use a forma **exec** para assegurar que o FastAPI consiga encerrar graciosamente e que os [eventos de lifespan](../advanced/events.md) sejam disparados.
-Você pode ler mais na
documentação do Docker sobre as formas shell e exec.
+Você pode ler mais na [documentação do Docker sobre as formas shell e exec](https://docs.docker.com/reference/dockerfile/#shell-and-exec-form).
-Isso pode ser bem perceptível ao usar `docker compose`. Veja esta seção de FAQ do Docker Compose para mais detalhes técnicos:
Por que meus serviços demoram 10 segundos para recriar ou parar?.
+Isso pode ser bem perceptível ao usar `docker compose`. Veja esta seção de FAQ do Docker Compose para mais detalhes técnicos: [Por que meus serviços demoram 10 segundos para recriar ou parar?](https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop).
#### Estrutura de diretórios { #directory-structure }
@@ -352,7 +352,7 @@ $ docker run -d --name mycontainer -p 80:80 myimage
## Verifique { #check-it }
-Você deve ser capaz de verificar isso no URL do seu contêiner Docker, por exemplo:
http://192.168.99.100/items/5?q=somequery ou
http://127.0.0.1/items/5?q=somequery (ou equivalente, usando seu host Docker).
+Você deve ser capaz de verificar isso no URL do seu contêiner Docker, por exemplo: [http://192.168.99.100/items/5?q=somequery](http://192.168.99.100/items/5?q=somequery) ou [http://127.0.0.1/items/5?q=somequery](http://127.0.0.1/items/5?q=somequery) (ou equivalente, usando seu host Docker).
Você verá algo como:
@@ -362,17 +362,17 @@ Você verá algo como:
## Documentação interativa da API { #interactive-api-docs }
-Agora você pode ir para
http://192.168.99.100/docs ou
http://127.0.0.1/docs (ou equivalente, usando seu host Docker).
+Agora você pode ir para [http://192.168.99.100/docs](http://192.168.99.100/docs) ou [http://127.0.0.1/docs](http://127.0.0.1/docs) (ou equivalente, usando seu host Docker).
-Você verá a documentação interativa automática da API (fornecida pelo
Swagger UI):
+Você verá a documentação interativa automática da API (fornecida pelo [Swagger UI](https://github.com/swagger-api/swagger-ui)):
## Documentação alternativa da API { #alternative-api-docs }
-E você também pode ir para
http://192.168.99.100/redoc ou
http://127.0.0.1/redoc (ou equivalente, usando seu host Docker).
+E você também pode ir para [http://192.168.99.100/redoc](http://192.168.99.100/redoc) ou [http://127.0.0.1/redoc](http://127.0.0.1/redoc) (ou equivalente, usando seu host Docker).
-Você verá a documentação alternativa automática (fornecida pela
ReDoc):
+Você verá a documentação alternativa automática (fornecida pelo [ReDoc](https://github.com/Rebilly/ReDoc)):
@@ -413,7 +413,7 @@ Quando você passa o arquivo para `fastapi run` ele detecta automaticamente que
## Conceitos de Implantação { #deployment-concepts }
-Vamos falar novamente sobre alguns dos mesmos [Conceitos de Implantação](concepts.md){.internal-link target=_blank} em termos de contêineres.
+Vamos falar novamente sobre alguns dos mesmos [Conceitos de Implantação](concepts.md) em termos de contêineres.
Contêineres são principalmente uma ferramenta para simplificar o processo de **construção e implantação** de um aplicativo, mas eles não impõem uma abordagem particular para lidar com esses **conceitos de implantação** e existem várias estratégias possíveis.
@@ -432,7 +432,7 @@ Vamos revisar esses **conceitos de implantação** em termos de contêineres:
Se nos concentrarmos apenas na **imagem do contêiner** para um aplicativo FastAPI (e posteriormente no **contêiner** em execução), o HTTPS normalmente seria tratado **externamente** por outra ferramenta.
-Isso poderia ser outro contêiner, por exemplo, com
Traefik, lidando com **HTTPS** e aquisição **automática** de **certificados**.
+Isso poderia ser outro contêiner, por exemplo, com [Traefik](https://traefik.io/), lidando com **HTTPS** e aquisição **automática** de **certificados**.
/// tip | Dica
@@ -558,7 +558,7 @@ Se você tiver **múltiplos contêineres**, provavelmente cada um executando um
/// info | Informação
-Se você estiver usando o Kubernetes, provavelmente será um
Init Container.
+Se você estiver usando o Kubernetes, provavelmente será um [Init Container](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/).
///
@@ -570,7 +570,7 @@ Se você tiver uma configuração simples, com um **único contêiner** que ent
### Imagem Docker base { #base-docker-image }
-Antes havia uma imagem oficial do FastAPI para Docker:
tiangolo/uvicorn-gunicorn-fastapi. Mas agora ela está descontinuada. ⛔️
+Antes havia uma imagem oficial do FastAPI para Docker: [tiangolo/uvicorn-gunicorn-fastapi](https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker). Mas agora ela está descontinuada. ⛔️
Você provavelmente **não** deve usar essa imagem base do Docker (ou qualquer outra semelhante).
@@ -600,7 +600,7 @@ Por exemplo:
## Imagem Docker com `uv` { #docker-image-with-uv }
-Se você está usando o
uv para instalar e gerenciar seu projeto, você pode seguir o
guia de Docker do uv.
+Se você está usando o [uv](https://github.com/astral-sh/uv) para instalar e gerenciar seu projeto, você pode seguir o [guia de Docker do uv](https://docs.astral.sh/uv/guides/integration/docker/).
## Recapitulando { #recap }
diff --git a/docs/pt/docs/deployment/fastapicloud.md b/docs/pt/docs/deployment/fastapicloud.md
index 03d3bd03be..26ec85ac07 100644
--- a/docs/pt/docs/deployment/fastapicloud.md
+++ b/docs/pt/docs/deployment/fastapicloud.md
@@ -1,6 +1,6 @@
# FastAPI Cloud { #fastapi-cloud }
-Você pode implantar sua aplicação FastAPI no
FastAPI Cloud com um **único comando**; entre na lista de espera, caso ainda não tenha feito isso. 🚀
+Você pode implantar sua aplicação FastAPI no [FastAPI Cloud](https://fastapicloud.com) com um **único comando**; entre na lista de espera, caso ainda não tenha feito isso. 🚀
## Login { #login }
@@ -40,7 +40,7 @@ Deploying to FastAPI Cloud...
## Sobre o FastAPI Cloud { #about-fastapi-cloud }
-O **
FastAPI Cloud** é desenvolvido pelo mesmo autor e equipe por trás do **FastAPI**.
+O **[FastAPI Cloud](https://fastapicloud.com)** é desenvolvido pelo mesmo autor e equipe por trás do **FastAPI**.
Ele simplifica o processo de **criar**, **implantar** e **acessar** uma API com esforço mínimo.
diff --git a/docs/pt/docs/deployment/https.md b/docs/pt/docs/deployment/https.md
index ccd842adbc..0e8ae2ba64 100644
--- a/docs/pt/docs/deployment/https.md
+++ b/docs/pt/docs/deployment/https.md
@@ -10,7 +10,7 @@ Se você está com pressa ou não se importa, continue com as seções seguintes
///
-Para aprender o básico de HTTPS do ponto de vista do consumidor, verifique
https://howhttps.works/.
+Para aprender o básico de HTTPS do ponto de vista do consumidor, verifique [https://howhttps.works/](https://howhttps.works/).
Agora, a partir de uma perspectiva do desenvolvedor, aqui estão algumas coisas para ter em mente ao pensar em HTTPS:
@@ -28,13 +28,13 @@ Agora, a partir de uma perspectiva do desenvolvedor, aqui estão algumas coisas
* Por padrão, isso significa que você só pode ter um certificado HTTPS por endereço IP.
* Não importa o tamanho do seu servidor ou quão pequeno cada aplicativo que você tem nele possa ser.
* No entanto, existe uma solução para isso.
-* Há uma extensão para o protocolo TLS (aquele que lida com a criptografia no nível TCP, antes do HTTP) chamada
SNI.
+* Há uma extensão para o protocolo TLS (aquele que lida com a criptografia no nível TCP, antes do HTTP) chamada [
SNI](https://en.wikipedia.org/wiki/Server_Name_Indication).
* Esta extensão SNI permite que um único servidor (com um único endereço IP) tenha vários certificados HTTPS e atenda a vários domínios / aplicativos HTTPS.
* Para que isso funcione, um único componente (programa) em execução no servidor, ouvindo no endereço IP público, deve ter todos os certificados HTTPS no servidor.
* Depois de obter uma conexão segura, o protocolo de comunicação ainda é HTTP.
* Os conteúdos são criptografados, embora sejam enviados com o protocolo HTTP.
-É uma prática comum ter um programa/servidor HTTP em execução no servidor (máquina, host, etc.) e gerenciar todas as partes HTTPS: recebendo as requisições HTTPS encriptadas, enviando as solicitações HTTP descriptografadas para o aplicativo HTTP real em execução no mesmo servidor (a aplicação FastAPI, neste caso), pegar a resposta HTTP do aplicativo, criptografá-la usando o certificado HTTPS apropriado e enviá-la de volta ao cliente usando HTTPS. Este servidor é frequentemente chamado de
Proxy de Terminação TLS.
+É uma prática comum ter um programa/servidor HTTP em execução no servidor (máquina, host, etc.) e gerenciar todas as partes HTTPS: recebendo as requisições HTTPS encriptadas, enviando as solicitações HTTP descriptografadas para o aplicativo HTTP real em execução no mesmo servidor (a aplicação FastAPI, neste caso), pegar a resposta HTTP do aplicativo, criptografá-la usando o certificado HTTPS apropriado e enviá-la de volta ao cliente usando HTTPS. Este servidor é frequentemente chamado de [Proxy de Terminação TLS](https://en.wikipedia.org/wiki/TLS_termination_proxy).
Algumas das opções que você pode usar como Proxy de Terminação TLS são:
@@ -49,7 +49,7 @@ Antes de Let's Encrypt, esses certificados HTTPS eram vendidos por terceiros con
O processo de aquisição de um desses certificados costumava ser complicado, exigia bastante papelada e os certificados eram bastante caros.
-Mas então o
Let's Encrypt foi criado.
+Mas então o [Let's Encrypt](https://letsencrypt.org/) foi criado.
Ele é um projeto da Linux Foundation que fornece certificados HTTPS gratuitamente. De forma automatizada. Esses certificados usam toda a segurança criptográfica padrão e têm vida curta (cerca de 3 meses), então a segurança é, na verdade, melhor por causa do seu lifespan reduzido.
@@ -200,9 +200,9 @@ Esse proxy normalmente define alguns cabeçalhos HTTP dinamicamente antes de tra
Os cabeçalhos do proxy são:
-*
X-Forwarded-For
-*
X-Forwarded-Proto
-*
X-Forwarded-Host
+* [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For)
+* [X-Forwarded-Proto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto)
+* [X-Forwarded-Host](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host)
///
@@ -218,7 +218,7 @@ Isso seria útil, por exemplo, para lidar corretamente com redirecionamentos.
/// tip | Dica
-Você pode saber mais sobre isso na documentação em [Atrás de um Proxy - Habilitar cabeçalhos encaminhados pelo proxy](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers){.internal-link target=_blank}
+Você pode saber mais sobre isso na documentação em [Atrás de um Proxy - Habilitar cabeçalhos encaminhados pelo proxy](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers)
///
diff --git a/docs/pt/docs/deployment/index.md b/docs/pt/docs/deployment/index.md
index d9755d0a2b..da4194f014 100644
--- a/docs/pt/docs/deployment/index.md
+++ b/docs/pt/docs/deployment/index.md
@@ -16,7 +16,7 @@ Há várias maneiras de fazer isso, dependendo do seu caso de uso específico e
Você pode **implantar um servidor** por conta própria usando uma combinação de ferramentas, pode usar um **serviço em nuvem** que faça parte do trabalho por você, entre outras opções.
-Por exemplo, nós, a equipe por trás do FastAPI, criamos
**FastAPI Cloud**, para tornar a implantação de aplicações FastAPI na nuvem o mais simples possível, com a mesma experiência de desenvolvimento de trabalhar com o FastAPI.
+Por exemplo, nós, a equipe por trás do FastAPI, criamos [**FastAPI Cloud**](https://fastapicloud.com), para tornar a implantação de aplicações FastAPI na nuvem o mais simples possível, com a mesma experiência de desenvolvimento de trabalhar com o FastAPI.
Vou mostrar alguns dos principais conceitos que você provavelmente deve ter em mente ao implantar uma aplicação **FastAPI** (embora a maior parte se aplique a qualquer outro tipo de aplicação web).
diff --git a/docs/pt/docs/deployment/manually.md b/docs/pt/docs/deployment/manually.md
index da3a52cf3a..19ed1a4abb 100644
--- a/docs/pt/docs/deployment/manually.md
+++ b/docs/pt/docs/deployment/manually.md
@@ -52,11 +52,11 @@ A principal coisa que você precisa para executar uma aplicação **FastAPI** (o
Existem diversas alternativas, incluindo:
-*
Uvicorn: um servidor ASGI de alta performance.
-*
Hypercorn: um servidor ASGI compatível com HTTP/2, Trio e outros recursos.
-*
Daphne: servidor ASGI construído para Django Channels.
-*
Granian: um servidor HTTP Rust para aplicações Python.
-*
NGINX Unit: NGINX Unit é um runtime de aplicação web leve e versátil.
+* [Uvicorn](https://www.uvicorn.dev/): um servidor ASGI de alta performance.
+* [Hypercorn](https://hypercorn.readthedocs.io/): um servidor ASGI compatível com HTTP/2, Trio e outros recursos.
+* [Daphne](https://github.com/django/daphne): servidor ASGI construído para Django Channels.
+* [Granian](https://github.com/emmett-framework/granian): um servidor HTTP Rust para aplicações Python.
+* [NGINX Unit](https://unit.nginx.org/howto/fastapi/): NGINX Unit é um runtime de aplicação web leve e versátil.
## Máquina Servidora e Programa Servidor { #server-machine-and-server-program }
@@ -74,7 +74,7 @@ Quando você instala o FastAPI, ele vem com um servidor de produção, o Uvicorn
Mas você também pode instalar um servidor ASGI manualmente.
-Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e, em seguida, você pode instalar a aplicação do servidor.
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e, em seguida, você pode instalar a aplicação do servidor.
Por exemplo, para instalar o Uvicorn:
diff --git a/docs/pt/docs/deployment/server-workers.md b/docs/pt/docs/deployment/server-workers.md
index bfb1e66873..98c1877c22 100644
--- a/docs/pt/docs/deployment/server-workers.md
+++ b/docs/pt/docs/deployment/server-workers.md
@@ -13,13 +13,13 @@ Até este ponto, com todos os tutoriais nos documentos, você provavelmente esta
Ao implantar aplicativos, você provavelmente desejará ter alguma **replicação de processos** para aproveitar **vários núcleos** e poder lidar com mais solicitações.
-Como você viu no capítulo anterior sobre [Conceitos de implantação](concepts.md){.internal-link target=_blank}, há várias estratégias que você pode usar.
+Como você viu no capítulo anterior sobre [Conceitos de implantação](concepts.md), há várias estratégias que você pode usar.
Aqui mostrarei como usar o **Uvicorn** com **processos de trabalho** usando o comando `fastapi` ou o comando `uvicorn` diretamente.
/// info | Informação
-Se você estiver usando contêineres, por exemplo com Docker ou Kubernetes, falarei mais sobre isso no próximo capítulo: [FastAPI em contêineres - Docker](docker.md){.internal-link target=_blank}.
+Se você estiver usando contêineres, por exemplo com Docker ou Kubernetes, falarei mais sobre isso no próximo capítulo: [FastAPI em contêineres - Docker](docker.md).
Em particular, ao executar no **Kubernetes** você provavelmente **não** vai querer usar vários trabalhadores e, em vez disso, executar **um único processo Uvicorn por contêiner**, mas falarei sobre isso mais adiante neste capítulo.
@@ -126,7 +126,7 @@ Da lista de conceitos de implantação acima, o uso de trabalhadores ajudaria pr
## Contêineres e Docker { #containers-and-docker }
-No próximo capítulo sobre [FastAPI em contêineres - Docker](docker.md){.internal-link target=_blank}, explicarei algumas estratégias que você pode usar para lidar com os outros **conceitos de implantação**.
+No próximo capítulo sobre [FastAPI em contêineres - Docker](docker.md), explicarei algumas estratégias que você pode usar para lidar com os outros **conceitos de implantação**.
Vou mostrar como **construir sua própria imagem do zero** para executar um único processo Uvicorn. É um processo simples e provavelmente é o que você gostaria de fazer ao usar um sistema de gerenciamento de contêineres distribuídos como o **Kubernetes**.
diff --git a/docs/pt/docs/deployment/versions.md b/docs/pt/docs/deployment/versions.md
index 32676da236..e20019c79b 100644
--- a/docs/pt/docs/deployment/versions.md
+++ b/docs/pt/docs/deployment/versions.md
@@ -4,7 +4,7 @@
Novas funcionalidades são adicionadas com frequência, bugs são corrigidos regularmente e o código continua melhorando continuamente.
-É por isso que as versões atuais ainda são `0.x.x`, isso reflete que cada versão pode potencialmente ter mudanças significativas. Isso segue as convenções de
Versionamento Semântico.
+É por isso que as versões atuais ainda são `0.x.x`, isso reflete que cada versão pode potencialmente ter mudanças significativas. Isso segue as convenções de [Versionamento Semântico](https://semver.org/).
Você pode criar aplicações de produção com **FastAPI** agora mesmo (e provavelmente já vem fazendo isso há algum tempo), apenas certifique-se de usar uma versão que funcione corretamente com o resto do seu código.
@@ -34,7 +34,7 @@ Se você usa qualquer outra ferramenta para gerenciar suas instalações, como `
## Versões disponíveis { #available-versions }
-Você pode ver as versões disponíveis (por exemplo, para verificar qual é a mais recente) nas [Release Notes](../release-notes.md){.internal-link target=_blank}.
+Você pode ver as versões disponíveis (por exemplo, para verificar qual é a mais recente) nas [Release Notes](../release-notes.md).
## Sobre versões { #about-versions }
@@ -66,7 +66,7 @@ O "MINOR" é o número do meio, por exemplo, em `0.2.3`, a versão MINOR é `2`.
Você deveria adicionar testes para a sua aplicação.
-Com **FastAPI** isso é muito fácil (graças ao Starlette), veja a documentação: [Testes](../tutorial/testing.md){.internal-link target=_blank}
+Com **FastAPI** isso é muito fácil (graças ao Starlette), veja a documentação: [Testes](../tutorial/testing.md)
Depois que você tiver testes, você pode atualizar a sua versão do **FastAPI** para uma mais recente e se certificar de que todo o seu código está funcionando corretamente executando seus testes.
diff --git a/docs/pt/docs/editor-support.md b/docs/pt/docs/editor-support.md
new file mode 100644
index 0000000000..7eedd3908e
--- /dev/null
+++ b/docs/pt/docs/editor-support.md
@@ -0,0 +1,23 @@
+# Suporte a Editores { #editor-support }
+
+A [FastAPI Extension](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) oficial melhora seu fluxo de trabalho de desenvolvimento com descoberta e navegação de *operação de rota*, além de implantação no FastAPI Cloud e transmissão ao vivo de logs.
+
+Para mais detalhes sobre a extensão, consulte o README no [repositório do GitHub](https://github.com/fastapi/fastapi-vscode).
+
+## Configuração e Instalação { #setup-and-installation }
+
+A **FastAPI Extension** está disponível para [VS Code](https://code.visualstudio.com/) e [Cursor](https://www.cursor.com/). Pode ser instalada diretamente pelo painel de Extensões de cada editor, pesquisando por "FastAPI" e selecionando a extensão publicada por **FastAPI Labs**. A extensão também funciona em editores no navegador, como [vscode.dev](https://vscode.dev) e [github.dev](https://github.dev).
+
+### Descoberta da Aplicação { #application-discovery }
+
+Por padrão, a extensão descobre automaticamente aplicações FastAPI no seu workspace procurando por arquivos que instanciam `FastAPI()`. Se a detecção automática não funcionar para a estrutura do seu projeto, você pode especificar um ponto de entrada via `[tool.fastapi]` em `pyproject.toml` ou pela configuração `fastapi.entryPoint` do VS Code usando notação de módulo (por exemplo, `myapp.main:app`).
+
+## Funcionalidades { #features }
+
+- **Explorador de Operações de Rota** - Uma visualização em árvore na barra lateral de todas as
*operações de rota* da sua aplicação. Clique para ir diretamente a qualquer definição de rota ou de router.
+- **Pesquisa de Rotas** - Pesquise por path, método ou nome com
Ctrl +
Shift +
E (no macOS:
Cmd +
Shift +
E).
+- **Navegação com CodeLens** - Links clicáveis acima das chamadas do cliente de testes (por exemplo, `client.get('/items')`) que levam à *operação de rota* correspondente, facilitando a navegação entre testes e implementação.
+- **Implantar no FastAPI Cloud** - Implantação com um clique da sua aplicação no [FastAPI Cloud](https://fastapicloud.com/).
+- **Transmitir logs da aplicação** - Transmissão em tempo real dos logs da aplicação implantada no FastAPI Cloud, com filtragem por nível e busca de texto.
+
+Se quiser se familiarizar com as funcionalidades da extensão, você pode abrir o walkthrough da extensão acessando a Paleta de Comandos (
Ctrl +
Shift +
P ou no macOS:
Cmd +
Shift +
P), selecionando "Welcome: Open walkthrough..." e, em seguida, escolhendo o walkthrough "Get started with FastAPI".
diff --git a/docs/pt/docs/environment-variables.md b/docs/pt/docs/environment-variables.md
index 342361b913..a464beceeb 100644
--- a/docs/pt/docs/environment-variables.md
+++ b/docs/pt/docs/environment-variables.md
@@ -65,7 +65,7 @@ print(f"Hello {name} from Python")
/// tip | Dica
-O segundo argumento para
`os.getenv()` é o valor padrão a ser retornado.
+O segundo argumento para [`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) é o valor padrão a ser retornado.
Se não for fornecido, é `None` por padrão, Aqui fornecemos `"World"` como o valor padrão a ser usado.
@@ -153,7 +153,7 @@ Hello World from Python
/// tip | Dica
-Você pode ler mais sobre isso em
The Twelve-Factor App: Config.
+Você pode ler mais sobre isso em [The Twelve-Factor App: Config](https://12factor.net/config).
///
@@ -163,7 +163,7 @@ Essas variáveis de ambiente só podem lidar com **strings de texto**, pois são
Isso significa que **qualquer valor** lido em Python de uma variável de ambiente **será uma `str`**, e qualquer conversão para um tipo diferente ou qualquer validação precisa ser feita no código.
-Você aprenderá mais sobre como usar variáveis de ambiente para lidar com **configurações do aplicativo** no [Guia do Usuário Avançado - Configurações e Variáveis de Ambiente](./advanced/settings.md){.internal-link target=_blank}.
+Você aprenderá mais sobre como usar variáveis de ambiente para lidar com **configurações do aplicativo** no [Guia do Usuário Avançado - Configurações e Variáveis de Ambiente](./advanced/settings.md).
## Variável de Ambiente `PATH` { #path-environment-variable }
@@ -285,13 +285,13 @@ $ C:\opt\custompython\bin\python
////
-Essas informações serão úteis ao aprender sobre [Ambientes Virtuais](virtual-environments.md){.internal-link target=_blank}.
+Essas informações serão úteis ao aprender sobre [Ambientes Virtuais](virtual-environments.md).
## Conclusão { #conclusion }
Com isso, você deve ter uma compreensão básica do que são **variáveis de ambiente** e como usá-las em Python.
-Você também pode ler mais sobre elas na
Wikipedia para Variáveis de Ambiente.
+Você também pode ler mais sobre elas na [Wikipedia para Variáveis de Ambiente](https://en.wikipedia.org/wiki/Environment_variable).
Em muitos casos, não é muito óbvio como as variáveis de ambiente seriam úteis e aplicáveis imediatamente. Mas elas continuam aparecendo em muitos cenários diferentes quando você está desenvolvendo, então é bom saber sobre elas.
diff --git a/docs/pt/docs/fastapi-cli.md b/docs/pt/docs/fastapi-cli.md
index f1e633a236..2a1a7da9fa 100644
--- a/docs/pt/docs/fastapi-cli.md
+++ b/docs/pt/docs/fastapi-cli.md
@@ -1,15 +1,15 @@
# FastAPI CLI { #fastapi-cli }
-**FastAPI CLI** é um programa de linha de comando que você pode usar para servir sua aplicação FastAPI, gerenciar seu projeto FastAPI e muito mais.
+**FastAPI
CLI** é um programa de linha de comando que você pode usar para servir sua aplicação FastAPI, gerenciar seu projeto FastAPI e muito mais.
-Quando você instala o FastAPI (por exemplo, com `pip install "fastapi[standard]"`), isso inclui um pacote chamado `fastapi-cli`; esse pacote disponibiliza o comando `fastapi` no terminal.
+Quando você instala o FastAPI (por exemplo, com `pip install "fastapi[standard]"`), ele vem com um programa de linha de comando que você pode executar no terminal.
Para executar sua aplicação FastAPI durante o desenvolvimento, você pode usar o comando `fastapi dev`:
```console
-$
fastapi dev
main.py
+$
fastapi dev
FastAPI Starting development server 🚀
@@ -46,30 +46,83 @@ $
fastapi dev
Uvicorn, um servidor ASGI de alta performance e pronto para produção. 😎
+Além disso, outras ferramentas podem não conseguir encontrá-la, por exemplo a [Extensão do VS Code](editor-support.md) ou a [FastAPI Cloud](https://fastapicloud.com), então é recomendado usar o `entrypoint` em `pyproject.toml`.
## `fastapi dev` { #fastapi-dev }
Executar `fastapi dev` inicia o modo de desenvolvimento.
-Por padrão, o recarregamento automático está ativado, recarregando o servidor automaticamente quando você faz mudanças no seu código. Isso consome muitos recursos e pode ser menos estável do que quando está desativado. Você deveria usá-lo apenas no desenvolvimento. Ele também escuta no endereço IP `127.0.0.1`, que é o IP para a sua máquina se comunicar apenas consigo mesma (`localhost`).
+Por padrão, o **recarregamento automático** está ativado, recarregando o servidor automaticamente quando você faz mudanças no seu código. Isso consome muitos recursos e pode ser menos estável do que quando está desativado. Você deveria usá-lo apenas no desenvolvimento. Ele também escuta no endereço IP `127.0.0.1`, que é o IP para a sua máquina se comunicar apenas consigo mesma (`localhost`).
## `fastapi run` { #fastapi-run }
-Executar `fastapi run` inicia o FastAPI em modo de produção por padrão.
+Executar `fastapi run` inicia o FastAPI em modo de produção.
-Por padrão, o recarregamento automático está desativado. Ele também escuta no endereço IP `0.0.0.0`, o que significa todos os endereços IP disponíveis; dessa forma, ficará acessível publicamente para qualquer pessoa que consiga se comunicar com a máquina. É assim que você normalmente o executaria em produção, por exemplo, em um contêiner.
+Por padrão, o **recarregamento automático** está desativado. Ele também escuta no endereço IP `0.0.0.0`, o que significa todos os endereços IP disponíveis; dessa forma, ficará acessível publicamente para qualquer pessoa que consiga se comunicar com a máquina. É assim que você normalmente o executaria em produção, por exemplo, em um contêiner.
-Na maioria dos casos, você teria (e deveria ter) um "proxy de terminação" tratando o HTTPS por cima; isso dependerá de como você faz o deploy da sua aplicação, seu provedor pode fazer isso por você ou talvez seja necessário que você configure isso por conta própria.
+Na maioria dos casos, você teria (e você deveria ter) um "proxy de terminação" tratando o HTTPS por cima; isso dependerá de como você faz o deploy da sua aplicação, seu provedor pode fazer isso por você ou talvez seja necessário que você configure isso por conta própria.
/// tip | Dica
-Você pode aprender mais sobre isso na [documentação de deployment](deployment/index.md){.internal-link target=_blank}.
+Você pode aprender mais sobre isso na [documentação de deployment](deployment/index.md).
///
diff --git a/docs/pt/docs/features.md b/docs/pt/docs/features.md
index a417d5fff3..bd7fb093ea 100644
--- a/docs/pt/docs/features.md
+++ b/docs/pt/docs/features.md
@@ -6,20 +6,20 @@
### Baseado em padrões abertos { #based-on-open-standards }
-* OpenAPI para criação de APIs, incluindo declarações de caminho operações, parâmetros, requisições de corpo, segurança etc.
-* Modelo de documentação automática com JSON Schema (já que o OpenAPI em si é baseado no JSON Schema).
-* Projetado em cima desses padrões após um estudo meticuloso, em vez de uma reflexão breve.
+* [**OpenAPI**](https://github.com/OAI/OpenAPI-Specification) para criação de APIs, incluindo declarações de caminho operações, parâmetros, requisições de corpo, segurança etc.
+* Documentação automática de modelos de dados com [**JSON Schema**](https://json-schema.org/) (já que o OpenAPI em si é baseado no JSON Schema).
+* Projetado em torno desses padrões, após um estudo meticuloso. Em vez de uma camada improvisada por cima.
* Isso também permite o uso de **geração de código do cliente** automaticamente em muitas linguagens.
### Documentação automática { #automatic-docs }
Documentação interativa da API e navegação web da interface de usuário. Como o framework é baseado no OpenAPI, há várias opções, 2 incluídas por padrão.
-* Swagger UI, com navegação interativa, chame e teste sua API diretamente do navegador.
+* [**Swagger UI**](https://github.com/swagger-api/swagger-ui), com navegação interativa, chame e teste sua API diretamente do navegador.
-* Documentação alternativa da API com ReDoc.
+* Documentação alternativa da API com [**ReDoc**](https://github.com/Rebilly/ReDoc).
@@ -27,7 +27,7 @@ Documentação interativa da API e navegação web da interface de usuário. Com
Tudo é baseado no padrão das declarações de **tipos do Python** (graças ao Pydantic). Nenhuma sintaxe nova para aprender. Apenas o padrão moderno do Python.
-Se você precisa refrescar a memória rapidamente sobre como usar tipos do Python (mesmo que você não use o FastAPI), confira esse rápido tutorial: [Tipos do Python](python-types.md){.internal-link target=_blank}.
+Se você precisa refrescar a memória rapidamente sobre como usar tipos do Python (mesmo que você não use o FastAPI), confira esse rápido tutorial: [Tipos do Python](python-types.md).
Você escreve Python padrão com tipos:
@@ -75,7 +75,7 @@ Passe as chaves e valores do dicionário `second_user_data` diretamente como arg
Todo o framework foi projetado para ser fácil e intuitivo de usar, todas as decisões foram testadas em vários editores antes do início do desenvolvimento, para garantir a melhor experiência de desenvolvimento.
-Na pesquisa de desenvolvedores Python, ficou claro que um dos recursos mais utilizados é o "preenchimento automático".
+Na pesquisa de desenvolvedores Python, ficou claro [que um dos recursos mais utilizados é o "preenchimento automático"](https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features).
Todo o framework **FastAPI** é feito para satisfazer isso. O preenchimento automático funciona em todos os lugares.
@@ -83,11 +83,11 @@ Você raramente precisará voltar à documentação.
Aqui está como o editor poderá te ajudar:
-* no Visual Studio Code:
+* no [Visual Studio Code](https://code.visualstudio.com/):
-* no PyCharm:
+* no [PyCharm](https://www.jetbrains.com/pycharm/):
@@ -124,7 +124,7 @@ Segurança e autenticação integradas. Sem nenhum compromisso com bancos de dad
Todos os esquemas de seguranças definidos no OpenAPI, incluindo:
* HTTP Basic.
-* **OAuth2** (também com **tokens JWT**). Confira o tutorial em [OAuth2 com JWT](tutorial/security/oauth2-jwt.md){.internal-link target=_blank}.
+* **OAuth2** (também com **tokens JWT**). Confira o tutorial em [OAuth2 com JWT](tutorial/security/oauth2-jwt.md).
* Chaves de API em:
* Headers.
* parâmetros da Query.
@@ -140,8 +140,8 @@ FastAPI inclui um sistema de Starlette. Então, qualquer código adicional Starlette que você tiver, também funcionará.
+**FastAPI** é totalmente compatível com (e baseado no) [**Starlette**](https://www.starlette.dev/). Então, qualquer código adicional Starlette que você tiver, também funcionará.
`FastAPI` é na verdade uma sub-classe do `Starlette`. Então, se você já conhece ou usa Starlette, a maioria das funcionalidades se comportará da mesma forma.
Com **FastAPI**, você terá todos os recursos do **Starlette** (já que FastAPI é apenas um Starlette com esteróides):
-* Desempenho realmente impressionante. É um dos frameworks Python disponíveis mais rápidos, a par com o **NodeJS** e **Go**.
+* Desempenho realmente impressionante. É [um dos frameworks Python disponíveis mais rápidos, a par com o **NodeJS** e **Go**](https://github.com/encode/starlette#performance).
* Suporte a **WebSocket**.
* Tarefas em processo background.
* Eventos na inicialização e encerramento.
@@ -177,7 +177,7 @@ Com **FastAPI**, você terá todos os recursos do **Starlette** (já que FastAPI
## Recursos do Pydantic { #pydantic-features }
-**FastAPI** é totalmente compatível com (e baseado no) Pydantic. Então, qualquer código Pydantic adicional que você tiver, também funcionará.
+**FastAPI** é totalmente compatível com (e baseado no) [**Pydantic**](https://docs.pydantic.dev/). Então, qualquer código Pydantic adicional que você tiver, também funcionará.
Incluindo bibliotecas externas também baseadas no Pydantic, como ORMs e ODMs para bancos de dados.
diff --git a/docs/pt/docs/help-fastapi.md b/docs/pt/docs/help-fastapi.md
index 4f58c091f7..3e8ea4b448 100644
--- a/docs/pt/docs/help-fastapi.md
+++ b/docs/pt/docs/help-fastapi.md
@@ -12,7 +12,7 @@ E também há várias formas de obter ajuda.
## Assine a newsletter { #subscribe-to-the-newsletter }
-Você pode assinar a (infrequente) [newsletter do **FastAPI and friends**](newsletter.md){.internal-link target=_blank} para ficar por dentro de:
+Você pode assinar a (infrequente) [newsletter do **FastAPI and friends**](newsletter.md) para ficar por dentro de:
* Notícias sobre FastAPI e amigos 🚀
* Tutoriais 📝
@@ -22,63 +22,63 @@ Você pode assinar a (infrequente) [newsletter do **FastAPI and friends**](newsl
## Siga o FastAPI no X (Twitter) { #follow-fastapi-on-x-twitter }
-Siga @fastapi no **X (Twitter)** para receber as últimas notícias sobre o **FastAPI**. 🐦
+[Siga @fastapi no **X (Twitter)**](https://x.com/fastapi) para receber as últimas notícias sobre o **FastAPI**. 🐦
## Dê uma estrela ao **FastAPI** no GitHub { #star-fastapi-in-github }
-Você pode “marcar com estrela” o FastAPI no GitHub (clicando no botão de estrela no canto superior direito): https://github.com/fastapi/fastapi. ⭐️
+Você pode “marcar com estrela” o FastAPI no GitHub (clicando no botão de estrela no canto superior direito): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). ⭐️
Ao adicionar uma estrela, outras pessoas conseguirão encontrá-lo com mais facilidade e verão que já foi útil para muita gente.
## Acompanhe o repositório no GitHub para lançamentos { #watch-the-github-repository-for-releases }
-Você pode “acompanhar” (watch) o FastAPI no GitHub (clicando no botão “watch” no canto superior direito): https://github.com/fastapi/fastapi. 👀
+Você pode “acompanhar” (watch) o FastAPI no GitHub (clicando no botão “watch” no canto superior direito): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀
-Lá você pode selecionar “Apenas lançamentos” (Releases only).
+Lá você pode selecionar “Apenas lançamentos”.
Fazendo isso, você receberá notificações (no seu email) sempre que houver um novo lançamento (uma nova versão) do **FastAPI** com correções de bugs e novas funcionalidades.
## Conecte-se com o autor { #connect-with-the-author }
-Você pode se conectar comigo (Sebastián Ramírez / `tiangolo`), o autor.
+Você pode se conectar [comigo (Sebastián Ramírez / `tiangolo`)](https://tiangolo.com), o autor.
Você pode:
-* Me seguir no **GitHub**.
+* [Me seguir no **GitHub**](https://github.com/tiangolo).
* Ver outros projetos Open Source que criei e que podem ajudar você.
* Me seguir para saber quando eu criar um novo projeto Open Source.
-* Me seguir no **X (Twitter)** ou no Mastodon.
+* [Me seguir no **X (Twitter)**](https://x.com/tiangolo) ou no [Mastodon](https://fosstodon.org/@tiangolo).
* Me contar como você usa o FastAPI (adoro saber disso).
* Ficar sabendo quando eu fizer anúncios ou lançar novas ferramentas.
- * Você também pode seguir @fastapi no X (Twitter) (uma conta separada).
-* Me seguir no **LinkedIn**.
+ * Você também pode [seguir @fastapi no X (Twitter)](https://x.com/fastapi) (uma conta separada).
+* [Me seguir no **LinkedIn**](https://www.linkedin.com/in/tiangolo/).
* Ver quando eu fizer anúncios ou lançar novas ferramentas (embora eu use mais o X (Twitter) 🤷♂).
-* Ler o que escrevo (ou me seguir) no **Dev.to** ou no **Medium**.
+* Ler o que escrevo (ou me seguir) no [**Dev.to**](https://dev.to/tiangolo) ou no [**Medium**](https://medium.com/@tiangolo).
* Ler outras ideias, artigos e conhecer ferramentas que criei.
* Me seguir para ver quando eu publicar algo novo.
## Tweet sobre o **FastAPI** { #tweet-about-fastapi }
-Tweet sobre o **FastAPI** e conte para mim e para outras pessoas por que você gosta dele. 🎉
+[Tweet sobre o **FastAPI**](https://x.com/compose/tweet?text=I'm loving @fastapi because... https://github.com/fastapi/fastapi) e conte para mim e para outras pessoas por que você gosta dele. 🎉
Eu adoro saber como o **FastAPI** está sendo usado, o que você tem curtido nele, em qual projeto/empresa você o utiliza, etc.
## Vote no FastAPI { #vote-for-fastapi }
-* Vote no **FastAPI** no Slant.
-* Vote no **FastAPI** no AlternativeTo.
-* Diga que você usa o **FastAPI** no StackShare.
+* [Vote no **FastAPI** no Slant](https://www.slant.co/options/34241/~fastapi-review).
+* [Vote no **FastAPI** no AlternativeTo](https://alternativeto.net/software/fastapi/about/).
+* [Diga que você usa o **FastAPI** no StackShare](https://stackshare.io/pypi-fastapi).
## Ajude outras pessoas com perguntas no GitHub { #help-others-with-questions-in-github }
Você pode tentar ajudar outras pessoas com suas perguntas em:
-* GitHub Discussions
-* GitHub Issues
+* [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered)
+* [GitHub Issues](https://github.com/fastapi/fastapi/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Aquestion+-label%3Aanswered+)
Em muitos casos você já pode saber a resposta para aquelas perguntas. 🤓
-Se você estiver ajudando muitas pessoas com suas perguntas, você se tornará um(a) [Especialista em FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank} oficial. 🎉
+Se você estiver ajudando muitas pessoas com suas perguntas, você se tornará um(a) [Especialista em FastAPI](fastapi-people.md#fastapi-experts) oficial. 🎉
Apenas lembre-se, o ponto mais importante é: tente ser gentil. As pessoas chegam com frustrações e, em muitos casos, não perguntam da melhor forma, mas tente ao máximo ser gentil. 🤗
@@ -104,9 +104,9 @@ Na maioria dos casos e na maioria das perguntas há algo relacionado ao **códig
Em muitos casos ela só copia um fragmento do código, mas isso não é suficiente para **reproduzir o problema**.
-* Você pode pedir que forneçam um exemplo mínimo, reproduzível, que você possa **copiar e colar** e executar localmente para ver o mesmo erro ou comportamento que elas estão vendo, ou para entender melhor o caso de uso.
+* Você pode pedir que forneçam um [exemplo mínimo, reproduzível](https://stackoverflow.com/help/minimal-reproducible-example), que você possa **copiar e colar** e executar localmente para ver o mesmo erro ou comportamento que elas estão vendo, ou para entender melhor o caso de uso.
-* Se você estiver muito generoso(a), pode tentar **criar um exemplo** assim você mesmo(a), apenas com base na descrição do problema. Só tenha em mente que isso pode levar bastante tempo e pode ser melhor pedir primeiro que esclareçam o problema.
+* Se você estiver muito generoso, pode tentar **criar um exemplo** assim você mesmo, apenas com base na descrição do problema. Só tenha em mente que isso pode levar bastante tempo e pode ser melhor pedir primeiro que esclareçam o problema.
### Sugira soluções { #suggest-solutions }
@@ -116,7 +116,7 @@ Em muitos casos ela só copia um fragmento do código, mas isso não é suficien
### Peça para encerrar { #ask-to-close }
-Se a pessoa responder, há uma grande chance de você ter resolvido o problema, parabéns, **você é um(a) herói(na)**! 🦸
+Se a pessoa responder, há uma grande chance de você ter resolvido o problema, parabéns, **você é um herói**! 🦸
* Agora, se isso resolveu o problema, você pode pedir para:
@@ -125,15 +125,15 @@ Se a pessoa responder, há uma grande chance de você ter resolvido o problema,
## Acompanhe o repositório do GitHub { #watch-the-github-repository }
-Você pode “acompanhar” (watch) o FastAPI no GitHub (clicando no botão “watch” no canto superior direito): https://github.com/fastapi/fastapi. 👀
+Você pode “acompanhar” (watch) o FastAPI no GitHub (clicando no botão “watch” no canto superior direito): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀
-Se você selecionar “Acompanhando” (Watching) em vez de “Apenas lançamentos” (Releases only), receberá notificações quando alguém criar uma nova issue ou pergunta. Você também pode especificar que quer ser notificado(a) apenas sobre novas issues, ou discussions, ou PRs, etc.
+Se você selecionar “Acompanhando” em vez de “Apenas lançamentos”, receberá notificações quando alguém criar uma nova issue ou pergunta. Você também pode especificar que quer ser notificado apenas sobre novas issues, ou discussions, ou PRs, etc.
Assim você pode tentar ajudar a resolver essas questões.
## Faça perguntas { #ask-questions }
-Você pode criar uma nova pergunta no repositório do GitHub, por exemplo para:
+Você pode [criar uma nova pergunta](https://github.com/fastapi/fastapi/discussions/new?category=questions) no repositório do GitHub, por exemplo para:
* Fazer uma **pergunta** ou perguntar sobre um **problema**.
* Sugerir uma nova **funcionalidade**.
@@ -190,18 +190,18 @@ Por isso, é realmente importante que você leia e execute o código, e me avise
* Depois verifique se os testes **passam** após o PR. ✅
-* Muitos PRs não têm testes, você pode **lembrar** a pessoa de adicionar testes, ou até **sugerir** alguns testes você mesmo(a). Essa é uma das coisas que consomem mais tempo e você pode ajudar muito com isso.
+* Muitos PRs não têm testes, você pode **lembrar** a pessoa de adicionar testes, ou até **sugerir** alguns testes você mesmo. Essa é uma das coisas que consomem mais tempo e você pode ajudar muito com isso.
* Depois também comente o que você testou, assim vou saber que você verificou. 🤓
## Crie um Pull Request { #create-a-pull-request }
-Você pode [contribuir](contributing.md){.internal-link target=_blank} com o código-fonte fazendo Pull Requests, por exemplo:
+Você pode [contribuir](contributing.md) com o código-fonte fazendo Pull Requests, por exemplo:
* Para corrigir um erro de digitação que você encontrou na documentação.
-* Para compartilhar um artigo, vídeo ou podcast que você criou ou encontrou sobre o FastAPI, editando este arquivo.
+* Para compartilhar um artigo, vídeo ou podcast que você criou ou encontrou sobre o FastAPI, [editando este arquivo](https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml).
* Garanta que você adicione seu link no início da seção correspondente.
-* Para ajudar a [traduzir a documentação](contributing.md#translations){.internal-link target=_blank} para seu idioma.
+* Para ajudar a [traduzir a documentação](contributing.md#translations) para seu idioma.
* Você também pode ajudar a revisar as traduções criadas por outras pessoas.
* Para propor novas seções de documentação.
* Para corrigir uma issue/bug existente.
@@ -218,8 +218,8 @@ Há muito trabalho a fazer e, para a maior parte dele, **VOCÊ** pode ajudar.
As principais tarefas que você pode fazer agora são:
-* [Ajudar outras pessoas com perguntas no GitHub](#help-others-with-questions-in-github){.internal-link target=_blank} (veja a seção acima).
-* [Revisar Pull Requests](#review-pull-requests){.internal-link target=_blank} (veja a seção acima).
+* [Ajudar outras pessoas com perguntas no GitHub](#help-others-with-questions-in-github) (veja a seção acima).
+* [Revisar Pull Requests](#review-pull-requests) (veja a seção acima).
Essas duas tarefas são as que **mais consomem tempo**. Esse é o principal trabalho de manter o FastAPI.
@@ -227,11 +227,11 @@ Se você puder me ajudar com isso, **você está me ajudando a manter o FastAPI*
## Entre no chat { #join-the-chat }
-Entre no 👥 servidor de chat do Discord 👥 e converse com outras pessoas da comunidade FastAPI.
+Entre no 👥 [servidor de chat do Discord](https://discord.gg/VQjSZaeJmf) 👥 e converse com outras pessoas da comunidade FastAPI.
/// tip | Dica
-Para perguntas, faça-as no GitHub Discussions, há uma chance muito maior de você receber ajuda pelos [Especialistas em FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}.
+Para perguntas, faça-as no [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/new?category=questions), há uma chance muito maior de você receber ajuda pelos [Especialistas em FastAPI](fastapi-people.md#fastapi-experts).
Use o chat apenas para outras conversas gerais.
@@ -241,15 +241,15 @@ Use o chat apenas para outras conversas gerais.
Tenha em mente que, como os chats permitem uma “conversa mais livre”, é fácil fazer perguntas muito gerais e mais difíceis de responder, então você pode acabar não recebendo respostas.
-No GitHub, o template vai orientar você a escrever a pergunta certa para que você consiga obter uma boa resposta com mais facilidade, ou até resolver o problema sozinho(a) antes de perguntar. E no GitHub eu consigo garantir que sempre vou responder tudo, mesmo que leve algum tempo. Eu pessoalmente não consigo fazer isso com os sistemas de chat. 😅
+No GitHub, o template vai orientar você a escrever a pergunta certa para que você consiga obter uma boa resposta com mais facilidade, ou até resolver o problema sozinho antes de perguntar. E no GitHub eu consigo garantir que sempre vou responder tudo, mesmo que leve algum tempo. Eu pessoalmente não consigo fazer isso com os sistemas de chat. 😅
-As conversas nos sistemas de chat também não são tão fáceis de pesquisar quanto no GitHub, então perguntas e respostas podem se perder na conversa. E somente as que estão no GitHub contam para você se tornar um(a) [Especialista em FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}, então é bem provável que você receba mais atenção no GitHub.
+As conversas nos sistemas de chat também não são tão fáceis de pesquisar quanto no GitHub, então perguntas e respostas podem se perder na conversa. E somente as que estão no GitHub contam para você se tornar um(a) [Especialista em FastAPI](fastapi-people.md#fastapi-experts), então é bem provável que você receba mais atenção no GitHub.
Por outro lado, há milhares de usuários nos sistemas de chat, então há uma grande chance de você encontrar alguém para conversar por lá quase o tempo todo. 😄
## Patrocine o autor { #sponsor-the-author }
-Se o seu **produto/empresa** depende de ou está relacionado ao **FastAPI** e você quer alcançar suas pessoas usuárias, você pode patrocinar o autor (eu) através do GitHub sponsors. Dependendo do nível, você pode obter benefícios extras, como um selo na documentação. 🎁
+Se o seu **produto/empresa** depende de ou está relacionado ao **FastAPI** e você quer alcançar suas pessoas usuárias, você pode patrocinar o autor (eu) através do [GitHub sponsors](https://github.com/sponsors/tiangolo). Dependendo do nível, você pode obter benefícios extras, como um selo na documentação. 🎁
---
diff --git a/docs/pt/docs/history-design-future.md b/docs/pt/docs/history-design-future.md
index fb90d1e1c3..7d59495835 100644
--- a/docs/pt/docs/history-design-future.md
+++ b/docs/pt/docs/history-design-future.md
@@ -1,6 +1,6 @@
# História, Design e Futuro { #history-design-and-future }
-Há algum tempo, um usuário **FastAPI** perguntou:
+Há algum tempo, [um usuário **FastAPI** perguntou](https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920):
> Qual é a história desse projeto? Parece que surgiu do nada e se tornou incrível em poucas semanas [...]
@@ -14,7 +14,7 @@ Como parte disso, eu precisava investigar, testar e usar muitas alternativas.
A história do **FastAPI** é, em grande parte, a história de seus predecessores.
-Como dito na seção [Alternativas](alternatives.md){.internal-link target=_blank}:
+Como dito na seção [Alternativas](alternatives.md):
@@ -44,7 +44,7 @@ Eu então dediquei algum tempo projetando a "API" de desenvolvimento que eu quer
Eu testei várias ideias nos editores Python mais populares: PyCharm, VS Code, e editores baseados no Jedi.
-Pela última Pesquisa do Desenvolvedor Python, isso cobre cerca de 80% dos usuários.
+Pela última [Pesquisa do Desenvolvedor Python](https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools), isso cobre cerca de 80% dos usuários.
Isso significa que o **FastAPI** foi testado especificamente com os editores usados por 80% dos desenvolvedores Python. Como a maioria dos outros editores tendem a funcionar de forma similar, todos os seus benefícios devem funcionar para virtualmente todos os editores.
@@ -54,11 +54,11 @@ Tudo de uma forma que oferecesse a melhor experiência de desenvolvimento para t
## Requisitos { #requirements }
-Após testar várias alternativas, eu decidi que usaria o **Pydantic** por suas vantagens.
+Após testar várias alternativas, eu decidi que usaria o [**Pydantic**](https://docs.pydantic.dev/) por suas vantagens.
Então eu contribuí com ele, para deixá-lo completamente de acordo com o JSON Schema, para dar suporte a diferentes maneiras de definir declarações de restrições, e melhorar o suporte a editores (conferências de tipos, preenchimento automático) baseado nos testes em vários editores.
-Durante o desenvolvimento, eu também contribuí com o **Starlette**, outro requisito chave.
+Durante o desenvolvimento, eu também contribuí com o [**Starlette**](https://www.starlette.dev/), outro requisito chave.
## Desenvolvimento { #development }
@@ -68,7 +68,7 @@ Quando comecei a criar o **FastAPI** de fato, a maior parte das peças já estav
Nesse ponto, já está claro que o **FastAPI** com suas ideias está sendo útil para muitas pessoas.
-Ele foi escolhido sobre outras alternativas anteriores por se adequar melhor em muitos casos.
+Ele está sendo escolhido em relação a alternativas anteriores por se adequar melhor em muitos casos.
Muitos desenvolvedores e times já dependem do **FastAPI** para seus projetos (incluindo eu e meu time).
@@ -76,4 +76,4 @@ Mas ainda há muitas melhorias e funcionalidades a vir.
**FastAPI** tem um grande futuro à frente.
-E [sua ajuda](help-fastapi.md){.internal-link target=_blank} é muito bem-vinda.
+E [sua ajuda](help-fastapi.md) é muito bem-vinda.
diff --git a/docs/pt/docs/how-to/authentication-error-status-code.md b/docs/pt/docs/how-to/authentication-error-status-code.md
index 40790f180d..62b660e732 100644
--- a/docs/pt/docs/how-to/authentication-error-status-code.md
+++ b/docs/pt/docs/how-to/authentication-error-status-code.md
@@ -2,7 +2,7 @@
Antes da versão `0.122.0` do FastAPI, quando os utilitários de segurança integrados retornavam um erro ao cliente após uma falha na autenticação, eles usavam o código de status HTTP `403 Forbidden`.
-A partir da versão `0.122.0` do FastAPI, eles usam o código de status HTTP `401 Unauthorized`, mais apropriado, e retornam um cabeçalho `WWW-Authenticate` adequado na response, seguindo as especificações HTTP, RFC 7235, RFC 9110.
+A partir da versão `0.122.0` do FastAPI, eles usam o código de status HTTP `401 Unauthorized`, mais apropriado, e retornam um cabeçalho `WWW-Authenticate` adequado na response, seguindo as especificações HTTP, [RFC 7235](https://datatracker.ietf.org/doc/html/rfc7235#section-3.1), [RFC 9110](https://datatracker.ietf.org/doc/html/rfc9110#name-401-unauthorized).
Mas, se por algum motivo seus clientes dependem do comportamento antigo, você pode voltar a ele sobrescrevendo o método `make_not_authenticated_error` nas suas classes de segurança.
diff --git a/docs/pt/docs/how-to/conditional-openapi.md b/docs/pt/docs/how-to/conditional-openapi.md
index b77600a7bc..f6838eb6d8 100644
--- a/docs/pt/docs/how-to/conditional-openapi.md
+++ b/docs/pt/docs/how-to/conditional-openapi.md
@@ -10,11 +10,11 @@ Isso não adiciona nenhuma segurança extra à sua API; as *operações de rota*
Se houver uma falha de segurança no seu código, ela ainda existirá.
-Ocultar a documentação apenas torna mais difícil entender como interagir com sua API e pode dificultar sua depuração na produção. Pode ser considerado simplesmente uma forma de Segurança através da obscuridade.
+Ocultar a documentação apenas torna mais difícil entender como interagir com sua API e pode dificultar sua depuração na produção. Pode ser considerado simplesmente uma forma de [Segurança através da obscuridade](https://en.wikipedia.org/wiki/Security_through_obscurity).
Se você quiser proteger sua API, há várias coisas melhores que você pode fazer, por exemplo:
-* Certifique-se de ter modelos Pydantic bem definidos para seus corpos de solicitação e respostas.
+* Certifique-se de ter modelos Pydantic bem definidos para seus corpos de request e respostas.
* Configure quaisquer permissões e funções necessárias usando dependências.
* Nunca armazene senhas em texto simples, apenas hashes de senha.
* Implemente e use ferramentas criptográficas bem conhecidas, como pwdlib e tokens JWT, etc.
diff --git a/docs/pt/docs/how-to/configure-swagger-ui.md b/docs/pt/docs/how-to/configure-swagger-ui.md
index a8f9bed476..d47d579634 100644
--- a/docs/pt/docs/how-to/configure-swagger-ui.md
+++ b/docs/pt/docs/how-to/configure-swagger-ui.md
@@ -1,6 +1,6 @@
# Configure a UI do Swagger { #configure-swagger-ui }
-Você pode configurar alguns parâmetros extras da UI do Swagger.
+Você pode configurar alguns [parâmetros extras da UI do Swagger](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/).
Para configurá-los, passe o argumento `swagger_ui_parameters` ao criar o objeto da aplicação `FastAPI()` ou para a função `get_swagger_ui_html()`.
@@ -50,7 +50,7 @@ Por exemplo, para desabilitar `deepLinking` você pode passar essas configuraç
## Outros parâmetros da UI do Swagger { #other-swagger-ui-parameters }
-Para ver todas as outras configurações possíveis que você pode usar, leia a documentação oficial dos parâmetros da UI do Swagger.
+Para ver todas as outras configurações possíveis que você pode usar, leia a [documentação oficial dos parâmetros da UI do Swagger](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/).
## Configurações somente JavaScript { #javascript-only-settings }
diff --git a/docs/pt/docs/how-to/custom-docs-ui-assets.md b/docs/pt/docs/how-to/custom-docs-ui-assets.md
index c7a62aefdf..5437434d57 100644
--- a/docs/pt/docs/how-to/custom-docs-ui-assets.md
+++ b/docs/pt/docs/how-to/custom-docs-ui-assets.md
@@ -54,7 +54,7 @@ Agora, para poder testar se tudo funciona, crie uma *operação de rota*:
### Teste { #test-it }
-Agora, você deve ser capaz de ir para a documentação em http://127.0.0.1:8000/docs, e recarregar a página, ela carregará esses recursos do novo CDN.
+Agora, você deve ser capaz de ir para a documentação em [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs), e recarregar a página, ela carregará esses recursos do novo CDN.
## Hospedagem Própria de JavaScript e CSS para a documentação { #self-hosting-javascript-and-css-for-docs }
@@ -89,16 +89,16 @@ Sua nova estrutura de arquivos poderia se parecer com isso:
Baixe os arquivos estáticos necessários para a documentação e coloque-os no diretório `static/`.
-Você provavelmente pode clicar com o botão direito em cada link e selecionar uma opção semelhante a `Salvar link como...`.
+Você provavelmente pode clicar com o botão direito em cada link e selecionar uma opção semelhante a "Salvar link como...".
**Swagger UI** usa os arquivos:
-* `swagger-ui-bundle.js`
-* `swagger-ui.css`
+* [`swagger-ui-bundle.js`](https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js)
+* [`swagger-ui.css`](https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css)
E o **ReDoc** usa o arquivo:
-* `redoc.standalone.js`
+* [`redoc.standalone.js`](https://cdn.jsdelivr.net/npm/redoc@2/bundles/redoc.standalone.js)
Depois disso, sua estrutura de arquivos deve se parecer com:
@@ -122,9 +122,9 @@ Depois disso, sua estrutura de arquivos deve se parecer com:
### Teste os arquivos estáticos { #test-the-static-files }
-Inicialize seu aplicativo e vá para http://127.0.0.1:8000/static/redoc.standalone.js.
+Inicialize seu aplicativo e vá para [http://127.0.0.1:8000/static/redoc.standalone.js](http://127.0.0.1:8000/static/redoc.standalone.js).
-Você deverá ver um arquivo JavaScript muito longo para o **ReDoc**.
+Você deverá ser ver um arquivo JavaScript muito longo para o **ReDoc**.
Esse arquivo pode começar com algo como:
@@ -180,6 +180,6 @@ Agora, para poder testar se tudo funciona, crie uma *operação de rota*:
### Teste a UI de Arquivos Estáticos { #test-static-files-ui }
-Agora, você deve ser capaz de desconectar o WiFi, ir para a documentação em http://127.0.0.1:8000/docs, e recarregar a página.
+Agora, você deve ser capaz de desconectar o WiFi, ir para a documentação em [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs), e recarregar a página.
E mesmo sem Internet, você será capaz de ver a documentação da sua API e interagir com ela.
diff --git a/docs/pt/docs/how-to/custom-request-and-route.md b/docs/pt/docs/how-to/custom-request-and-route.md
index b4ea1c282b..5603535320 100644
--- a/docs/pt/docs/how-to/custom-request-and-route.md
+++ b/docs/pt/docs/how-to/custom-request-and-route.md
@@ -18,7 +18,7 @@ Se você for um iniciante em **FastAPI** você deve considerar pular essa seçã
Alguns casos de uso incluem:
-* Converter requisições não-JSON para JSON (por exemplo, `msgpack`).
+* Converter requisições não-JSON para JSON (por exemplo, [`msgpack`](https://msgpack.org/index.html)).
* Descomprimir corpos de requisição comprimidos com gzip.
* Registrar automaticamente todos os corpos de requisição.
@@ -32,7 +32,7 @@ E uma subclasse de `APIRoute` para usar essa classe de requisição personalizad
/// tip | Dica
-Isso é um exemplo de brincadeira para demonstrar como funciona, se você precisar de suporte para Gzip, você pode usar o [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware){.internal-link target=_blank} fornecido.
+Isso é um exemplo de brincadeira para demonstrar como funciona, se você precisar de suporte para Gzip, você pode usar o [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware) fornecido.
///
@@ -66,7 +66,7 @@ O dicionário `scope` e a função `receive` são ambos parte da especificação
E essas duas coisas, `scope` e `receive`, são o que é necessário para criar uma nova instância de `Request`.
-Para aprender mais sobre o `Request` confira a documentação do Starlette sobre Requests.
+Para aprender mais sobre o `Request` confira a [documentação do Starlette sobre Requests](https://www.starlette.dev/requests/).
///
@@ -82,7 +82,7 @@ Mas por causa das nossas mudanças em `GzipRequest.body`, o corpo da requisiçã
/// tip | Dica
-Para resolver esse mesmo problema, é provavelmente muito mais fácil usar o `body` em um manipulador personalizado para `RequestValidationError` ([Tratando Erros](../tutorial/handling-errors.md#use-the-requestvalidationerror-body){.internal-link target=_blank}).
+Para resolver esse mesmo problema, é provavelmente muito mais fácil usar o `body` em um manipulador personalizado para `RequestValidationError` ([Tratando Erros](../tutorial/handling-errors.md#use-the-requestvalidationerror-body)).
Mas esse exemplo ainda é valido e mostra como interagir com os componentes internos.
diff --git a/docs/pt/docs/how-to/extending-openapi.md b/docs/pt/docs/how-to/extending-openapi.md
index b8277c1c4b..23737e5fa1 100644
--- a/docs/pt/docs/how-to/extending-openapi.md
+++ b/docs/pt/docs/how-to/extending-openapi.md
@@ -37,7 +37,7 @@ O parâmetro `summary` está disponível no OpenAPI 3.1.0 e superior, suportado
Com as informações acima, você pode usar a mesma função utilitária para gerar o esquema OpenAPI e sobrescrever cada parte que precisar.
-Por exemplo, vamos adicionar Extensão OpenAPI do ReDoc para incluir um logo personalizado.
+Por exemplo, vamos adicionar [Extensão OpenAPI do ReDoc para incluir um logo personalizado](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo).
### **FastAPI** Normal { #normal-fastapi }
@@ -75,6 +75,6 @@ Agora, você pode substituir o método `.openapi()` pela sua nova função.
### Verificar { #check-it }
-Uma vez que você acessar http://127.0.0.1:8000/redoc, verá que está usando seu logo personalizado (neste exemplo, o logo do **FastAPI**):
+Uma vez que você acessar [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc), verá que está usando seu logo personalizado (neste exemplo, o logo do **FastAPI**):
diff --git a/docs/pt/docs/how-to/general.md b/docs/pt/docs/how-to/general.md
index 3cabb6753e..ce04ada16e 100644
--- a/docs/pt/docs/how-to/general.md
+++ b/docs/pt/docs/how-to/general.md
@@ -1,38 +1,42 @@
# Geral - Como Fazer - Receitas { #general-how-to-recipes }
-Aqui estão vários links para outros locais na documentação, para perguntas gerais ou frequentes
+Aqui estão vários links para outros locais na documentação, para perguntas gerais ou frequentes.
## Filtro de dados- Segurança { #filter-data-security }
-Para assegurar que você não vai retornar mais dados do que deveria, leia a seção [Tutorial - Modelo de Resposta - Tipo de Retorno](../tutorial/response-model.md){.internal-link target=_blank}.
+Para assegurar que você não vai retornar mais dados do que deveria, leia a documentação de [Tutorial - Modelo de Resposta - Tipo de Retorno](../tutorial/response-model.md).
+
+## Otimizar Desempenho da Resposta - Modelo de Resposta - Tipo de Retorno { #optimize-response-performance-response-model-return-type }
+
+Para otimizar o desempenho ao retornar dados JSON, use um tipo de retorno ou modelo de resposta; assim, o Pydantic fará a serialização para JSON no lado do Rust, sem passar pelo Python. Leia mais na documentação de [Tutorial - Modelo de Resposta - Tipo de Retorno](../tutorial/response-model.md).
## Tags de Documentação - OpenAPI { #documentation-tags-openapi }
-Para adicionar tags às suas *operações de rota* e agrupá-las na UI da documentação, leia a seção [Tutorial - Configurações da Operação de Rota - Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}.
+Para adicionar tags às suas *operações de rota* e agrupá-las na UI da documentação, leia a documentação de [Tutorial - Configurações da Operação de Rota - Tags](../tutorial/path-operation-configuration.md#tags).
## Resumo e Descrição da documentação - OpenAPI { #documentation-summary-and-description-openapi }
-Para adicionar um resumo e uma descrição às suas *operações de rota* e exibi-los na UI da documentação, leia a seção [Tutorial - Configurações da Operação de Rota - Resumo e Descrição](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank}.
+Para adicionar um resumo e uma descrição às suas *operações de rota* e exibi-los na UI da documentação, leia a documentação de [Tutorial - Configurações da Operação de Rota - Resumo e Descrição](../tutorial/path-operation-configuration.md#summary-and-description).
-## Documentação das Descrições de Resposta - OpenAPI { #documentation-response-description-openapi }
+## Documentação - Descrição da Resposta - OpenAPI { #documentation-response-description-openapi }
-Para definir a descrição de uma resposta exibida na interface da documentação, leia a seção [Tutorial - Configurações da Operação de Rota - Descrição da Resposta](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}.
+Para definir a descrição de uma resposta exibida na interface da documentação, leia a documentação de [Tutorial - Configurações da Operação de Rota - Descrição da Resposta](../tutorial/path-operation-configuration.md#response-description).
-## Documentação para Depreciar uma *Operação de Rota* - OpenAPI { #documentation-deprecate-a-path-operation-openapi }
+## Documentação - Descontinuar uma *Operação de Rota* - OpenAPI { #documentation-deprecate-a-path-operation-openapi }
-Para depreciar uma *operação de rota* e exibi-la na interface da documentação, leia a seção [Tutorial - Configurações da Operação de Rota - Depreciação](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}.
+Para descontinuar uma *operação de rota* e exibi-la na UI da documentação, leia a documentação de [Tutorial - Configurações da Operação de Rota - Descontinuação](../tutorial/path-operation-configuration.md#deprecate-a-path-operation).
## Converter qualquer dado para compatível com JSON { #convert-any-data-to-json-compatible }
-Para converter qualquer dado para um formato compatível com JSON, leia a seção [Tutorial - Codificador Compatível com JSON](../tutorial/encoder.md){.internal-link target=_blank}.
+Para converter qualquer dado para um formato compatível com JSON, leia a documentação de [Tutorial - Codificador Compatível com JSON](../tutorial/encoder.md).
## OpenAPI Metadata - Docs { #openapi-metadata-docs }
-Para adicionar metadados ao seu esquema OpenAPI, incluindo licença, versão, contato, etc, leia a seção [Tutorial - Metadados e URLs da Documentação](../tutorial/metadata.md){.internal-link target=_blank}.
+Para adicionar metadados ao seu esquema OpenAPI, incluindo licença, versão, contato, etc, leia a documentação de [Tutorial - Metadados e URLs da Documentação](../tutorial/metadata.md).
## OpenAPI com URL customizada { #openapi-custom-url }
-Para customizar a URL do OpenAPI (ou removê-la), leia a seção [Tutorial - Metadados e URLs da Documentação](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}.
+Para customizar a URL do OpenAPI (ou removê-la), leia a documentação de [Tutorial - Metadados e URLs da Documentação](../tutorial/metadata.md#openapi-url).
## URLs de documentação do OpenAPI { #openapi-docs-urls }
-Para alterar as URLs usadas para as interfaces de usuário da documentação gerada automaticamente, leia a seção [Tutorial - Metadados e URLs da Documentação](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}.
+Para alterar as URLs usadas para as interfaces de usuário da documentação gerada automaticamente, leia a documentação de [Tutorial - Metadados e URLs da Documentação](../tutorial/metadata.md#docs-urls).
diff --git a/docs/pt/docs/how-to/graphql.md b/docs/pt/docs/how-to/graphql.md
index 3fcaa4dd28..f96a202f08 100644
--- a/docs/pt/docs/how-to/graphql.md
+++ b/docs/pt/docs/how-to/graphql.md
@@ -18,18 +18,18 @@ Certifique-se de avaliar se os **benefícios** para o seu caso de uso compensam
Aqui estão algumas das bibliotecas **GraphQL** que têm suporte **ASGI**. Você pode usá-las com **FastAPI**:
-* Strawberry 🍓
- * Com docs para FastAPI
-* Ariadne
- * Com docs para FastAPI
-* Tartiflette
- * Com Tartiflette ASGI para fornecer integração ASGI
-* Graphene
- * Com starlette-graphene3
+* [Strawberry](https://strawberry.rocks/) 🍓
+ * Com [documentação para FastAPI](https://strawberry.rocks/docs/integrations/fastapi)
+* [Ariadne](https://ariadnegraphql.org/)
+ * Com [documentação para FastAPI](https://ariadnegraphql.org/docs/fastapi-integration)
+* [Tartiflette](https://tartiflette.io/)
+ * Com [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) para fornecer integração ASGI
+* [Graphene](https://graphene-python.org/)
+ * Com [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3)
## GraphQL com Strawberry { #graphql-with-strawberry }
-Se você precisar ou quiser trabalhar com **GraphQL**, **Strawberry** é a biblioteca **recomendada** pois tem o design mais próximo ao design do **FastAPI**, ela é toda baseada em **anotações de tipo**.
+Se você precisar ou quiser trabalhar com **GraphQL**, [**Strawberry**](https://strawberry.rocks/) é a biblioteca **recomendada** pois tem o design mais próximo ao design do **FastAPI**, ela é toda baseada em **anotações de tipo**.
Dependendo do seu caso de uso, você pode preferir usar uma biblioteca diferente, mas se você me perguntasse, eu provavelmente sugeriria que você experimentasse o **Strawberry**.
@@ -37,24 +37,24 @@ Aqui está uma pequena prévia de como você poderia integrar Strawberry com Fas
{* ../../docs_src/graphql_/tutorial001_py310.py hl[3,22,25] *}
-Você pode aprender mais sobre Strawberry na documentação do Strawberry.
+Você pode aprender mais sobre Strawberry na [documentação do Strawberry](https://strawberry.rocks/).
-E também na documentação sobre Strawberry com FastAPI.
+E também na documentação sobre [Strawberry com FastAPI](https://strawberry.rocks/docs/integrations/fastapi).
## Antigo `GraphQLApp` do Starlette { #older-graphqlapp-from-starlette }
-Versões anteriores do Starlette incluiam uma classe `GraphQLApp` para integrar com Graphene.
+Versões anteriores do Starlette incluiam uma classe `GraphQLApp` para integrar com [Graphene](https://graphene-python.org/).
-Ela foi descontinuada do Starlette, mas se você tem código que a utilizava, você pode facilmente **migrar** para starlette-graphene3, que cobre o mesmo caso de uso e tem uma **interface quase idêntica**.
+Ela foi descontinuada do Starlette, mas se você tem código que a utilizava, você pode facilmente **migrar** para [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3), que cobre o mesmo caso de uso e tem uma **interface quase idêntica**.
/// tip | Dica
-Se você precisa de GraphQL, eu ainda recomendaria que você desse uma olhada no Strawberry, pois ele é baseado em anotações de tipo em vez de classes e tipos personalizados.
+Se você precisa de GraphQL, eu ainda recomendaria que você desse uma olhada no [Strawberry](https://strawberry.rocks/), pois ele é baseado em anotações de tipo em vez de classes e tipos personalizados.
///
## Saiba Mais { #learn-more }
-Você pode aprender mais sobre **GraphQL** na documentação oficial do GraphQL.
+Você pode aprender mais sobre **GraphQL** na [documentação oficial do GraphQL](https://graphql.org/).
Você também pode ler mais sobre cada uma das bibliotecas descritas acima em seus links.
diff --git a/docs/pt/docs/how-to/index.md b/docs/pt/docs/how-to/index.md
index 91df638d7a..3f3d344354 100644
--- a/docs/pt/docs/how-to/index.md
+++ b/docs/pt/docs/how-to/index.md
@@ -8,6 +8,6 @@ Se algo parecer interessante e útil para o seu projeto, vá em frente e dê uma
/// tip | Dica
-Se você deseja **aprender FastAPI** de forma estruturada (recomendado), leia capítulo por capítulo [Tutorial - Guia de Usuário](../tutorial/index.md){.internal-link target=_blank} em vez disso.
+Se você deseja **aprender FastAPI** de forma estruturada (recomendado), leia capítulo por capítulo [Tutorial - Guia de Usuário](../tutorial/index.md) em vez disso.
///
diff --git a/docs/pt/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md b/docs/pt/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
index 0995e10285..1352abda94 100644
--- a/docs/pt/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
+++ b/docs/pt/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
@@ -22,7 +22,7 @@ Se você tem uma aplicação FastAPI antiga com Pydantic v1, aqui vou mostrar co
## Guia oficial { #official-guide }
-O Pydantic tem um Guia de Migração oficial do v1 para o v2.
+O Pydantic tem um [Guia de Migração](https://docs.pydantic.dev/latest/migration/) oficial do v1 para o v2.
Ele também inclui o que mudou, como as validações agora são mais corretas e rigorosas, possíveis ressalvas, etc.
@@ -30,7 +30,7 @@ Você pode lê-lo para entender melhor o que mudou.
## Testes { #tests }
-Garanta que você tenha [testes](../tutorial/testing.md){.internal-link target=_blank} para sua aplicação e que os execute na integração contínua (CI).
+Garanta que você tenha [testes](../tutorial/testing.md) para sua aplicação e que os execute na integração contínua (CI).
Assim, você pode fazer a atualização e garantir que tudo continua funcionando como esperado.
@@ -38,7 +38,7 @@ Assim, você pode fazer a atualização e garantir que tudo continua funcionando
Em muitos casos, quando você usa modelos Pydantic regulares sem personalizações, será possível automatizar a maior parte do processo de migração do Pydantic v1 para o Pydantic v2.
-Você pode usar o `bump-pydantic` da própria equipe do Pydantic.
+Você pode usar [`bump-pydantic`](https://github.com/pydantic/bump-pydantic) da própria equipe do Pydantic.
Essa ferramenta ajuda a alterar automaticamente a maior parte do código que precisa ser modificado.
diff --git a/docs/pt/docs/how-to/testing-database.md b/docs/pt/docs/how-to/testing-database.md
index 4258d1e24c..1ec82ae6d8 100644
--- a/docs/pt/docs/how-to/testing-database.md
+++ b/docs/pt/docs/how-to/testing-database.md
@@ -1,7 +1,7 @@
# Testando a Base de Dados { #testing-a-database }
-Você pode estudar sobre bases de dados, SQL e SQLModel na documentação de SQLModel. 🤓
+Você pode estudar sobre bases de dados, SQL e SQLModel na [documentação de SQLModel](https://sqlmodel.tiangolo.com/). 🤓
-Aqui tem um mini tutorial de como usar SQLModel com FastAPI. ✨
+Aqui tem um mini [tutorial de como usar SQLModel com FastAPI](https://sqlmodel.tiangolo.com/tutorial/fastapi/). ✨
-Esse tutorial inclui uma seção sobre testar bases de dados SQL. 😎
+Esse tutorial inclui uma seção sobre [testar bases de dados SQL](https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/). 😎
diff --git a/docs/pt/docs/index.md b/docs/pt/docs/index.md
index c337f6d3ac..1679e34bae 100644
--- a/docs/pt/docs/index.md
+++ b/docs/pt/docs/index.md
@@ -8,43 +8,43 @@
- Framework FastAPI, alta performance, fácil de aprender, fácil de codar, pronto para produção
+ Framework FastAPI, alta performance, fácil de aprender, rápido para codar, pronto para produção
-
+
-
+
-
+
-
+
---
-**Documentação**: https://fastapi.tiangolo.com
+**Documentação**: [https://fastapi.tiangolo.com/pt](https://fastapi.tiangolo.com/pt)
-**Código fonte**: https://github.com/fastapi/fastapi
+**Código fonte**: [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi)
---
-FastAPI é um moderno e rápido (alta performance) framework web para construção de APIs com Python, baseado nos type hints padrões do Python.
+FastAPI é um framework web moderno e rápido (alta performance) para construção de APIs com Python, baseado nos type hints padrões do Python.
Os recursos chave são:
-* **Rápido**: alta performance, equivalente a **NodeJS** e **Go** (graças ao Starlette e Pydantic). [Um dos frameworks mais rápidos disponíveis](#performance).
+* **Rápido**: alta performance, equivalente a **NodeJS** e **Go** (graças ao Starlette e Pydantic). [Um dos frameworks Python mais rápidos disponíveis](#performance).
* **Rápido para codar**: Aumenta a velocidade para desenvolver recursos entre 200% a 300%. *
* **Poucos bugs**: Reduz cerca de 40% de erros induzidos por humanos (desenvolvedores). *
* **Intuitivo**: Grande suporte a editores. Completação em todos os lugares. Menos tempo debugando.
* **Fácil**: Projetado para ser fácil de aprender e usar. Menos tempo lendo docs.
* **Enxuto**: Minimize duplicação de código. Múltiplas funcionalidades para cada declaração de parâmetro. Menos bugs.
* **Robusto**: Tenha código pronto para produção. E com documentação interativa automática.
-* **Baseado em padrões**: Baseado em (e totalmente compatível com) os padrões abertos para APIs: OpenAPI (anteriormente conhecido como Swagger) e JSON Schema.
+* **Baseado em padrões**: Baseado em (e totalmente compatível com) os padrões abertos para APIs: [OpenAPI](https://github.com/OAI/OpenAPI-Specification) (anteriormente conhecido como Swagger) e [JSON Schema](https://json-schema.org/).
* estimativas baseadas em testes realizados com equipe interna de desenvolvimento, construindo aplicações em produção.
@@ -55,51 +55,51 @@ Os recursos chave são:
### Patrocinador Keystone { #keystone-sponsor }
{% for sponsor in sponsors.keystone -%}
-
+
{% endfor -%}
### Patrocinadores Ouro e Prata { #gold-and-silver-sponsors }
{% for sponsor in sponsors.gold -%}
-
+
{% endfor -%}
{%- for sponsor in sponsors.silver -%}
-
+
{% endfor %}
-Outros patrocinadores
+[Outros patrocinadores](https://fastapi.tiangolo.com/pt/fastapi-people/#sponsors)
## Opiniões { #opinions }
"_[...] Estou usando **FastAPI** muito esses dias. [...] Estou na verdade planejando utilizar ele em todos os times de **serviços ML na Microsoft**. Alguns deles estão sendo integrados no _core_ do produto **Windows** e alguns produtos **Office**._"
-Kabir Khan -
Microsoft (ref)Kabir Khan -
Microsoft (ref)Piero Molino, Yaroslav Dudin, e Sai Sumanth Miryala -
Uber (ref)Piero Molino, Yaroslav Dudin, e Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Brian Okken -
[Python Bytes](https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855) apresentador do podcast (ref)Timothy Crosley -
criador do [Hug](https://github.com/hugapi/hug) (ref)Ines Montani - Matthew Honnibal -
fundadores da [Explosion AI](https://explosion.ai) - criadores da [spaCy](https://spacy.io) (ref) -
(ref)Deon Pillsbury -
Cisco (ref)Deon Pillsbury -
Cisco (ref)
+
## **Typer**, o FastAPI das interfaces de linhas de comando { #typer-the-fastapi-of-clis }
-
+
-Se você estiver construindo uma aplicação CLI para ser utilizada no terminal ao invés de uma API web, dê uma olhada no **Typer**.
+Se você estiver construindo uma aplicação CLI para ser utilizada no terminal ao invés de uma API web, dê uma olhada no [**Typer**](https://typer.tiangolo.com/).
**Typer** é o irmão menor do FastAPI. E seu propósito é ser o **FastAPI das CLIs**. ⌨️ 🚀
@@ -135,12 +135,12 @@ Se você estiver construindo uma aplicação Starlette para as partes web.
-* Pydantic para a parte de dados.
+* [Starlette](https://www.starlette.dev/) para as partes web.
+* [Pydantic](https://docs.pydantic.dev/) para a parte de dados.
## Instalação { #installation }
-Crie e ative um ambiente virtual e então instale o FastAPI:
+Crie e ative um [ambiente virtual](https://fastapi.tiangolo.com/pt/virtual-environments/) e então instale o FastAPI:
@@ -199,7 +199,7 @@ async def read_item(item_id: int, q: str | None = None):
**Nota**:
-Se você não sabe, verifique a seção _"Com pressa?"_ sobre
`async` e `await` nas docs.
+Se você não sabe, verifique a seção _"Com pressa?"_ sobre [`async` e `await` nas docs](https://fastapi.tiangolo.com/pt/async/#in-a-hurry).
@@ -210,7 +210,7 @@ Rode o servidor com:
```console
-$ fastapi dev main.py
+$ fastapi dev
╭────────── FastAPI CLI - Development mode ───────────╮
│ │
@@ -235,19 +235,19 @@ INFO: Application startup complete.
-Sobre o comando fastapi dev main.py...
+Sobre o comando fastapi dev...
-O comando `fastapi dev` lê o seu arquivo `main.py`, identifica o aplicativo **FastAPI** nele, e inicia um servidor usando o Uvicorn.
+O comando `fastapi dev` lê automaticamente o seu arquivo `main.py`, detecta a aplicação **FastAPI** nele e inicia um servidor usando o [Uvicorn](https://www.uvicorn.dev).
-Por padrão, o `fastapi dev` iniciará com *auto-reload* habilitado para desenvolvimento local.
+Por padrão, o `fastapi dev` iniciará com auto-reload habilitado para desenvolvimento local.
-Você pode ler mais sobre isso na documentação do FastAPI CLI.
+Você pode ler mais sobre isso na [documentação do FastAPI CLI](https://fastapi.tiangolo.com/pt/fastapi-cli/).
### Verifique { #check-it }
-Abra seu navegador em
http://127.0.0.1:8000/items/5?q=somequery.
+Abra seu navegador em [http://127.0.0.1:8000/items/5?q=somequery](http://127.0.0.1:8000/items/5?q=somequery).
Você verá a resposta JSON como:
@@ -264,17 +264,17 @@ Você acabou de criar uma API que:
### Documentação Interativa da API { #interactive-api-docs }
-Agora vá para
http://127.0.0.1:8000/docs.
+Agora vá para [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
-Você verá a documentação automática interativa da API (fornecida por
Swagger UI):
+Você verá a documentação automática interativa da API (fornecida por [Swagger UI](https://github.com/swagger-api/swagger-ui)):
### Documentação Alternativa da API { #alternative-api-docs }
-E agora, vá para
http://127.0.0.1:8000/redoc.
+E agora, vá para [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
-Você verá a documentação automática alternativa (fornecida por
ReDoc):
+Você verá a documentação automática alternativa (fornecida por [ReDoc](https://github.com/Rebilly/ReDoc)):
@@ -316,7 +316,7 @@ O servidor `fastapi dev` deverá recarregar automaticamente.
### Evoluindo a Documentação Interativa da API { #interactive-api-docs-upgrade }
-Agora vá para
http://127.0.0.1:8000/docs.
+Agora vá para [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
* A documentação interativa da API será automaticamente atualizada, incluindo o novo corpo:
@@ -332,7 +332,7 @@ Agora vá para
http://127.0.0.1:8000/redoc.
+E agora, vá para [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
* A documentação alternativa também irá refletir o novo parâmetro query e o corpo:
@@ -344,7 +344,7 @@ Resumindo, você declara **uma vez** os tipos dos parâmetros, corpo etc. como p
Você faz isso com os tipos padrão do Python moderno.
-Você não terá que aprender uma nova sintaxe, métodos ou classes de uma biblioteca específica etc.
+Você não terá que aprender uma nova sintaxe, os métodos ou classes de uma biblioteca específica etc.
Apenas **Python** padrão.
@@ -433,7 +433,7 @@ Experimente mudar a seguinte linha:
-Para um exemplo mais completo incluindo mais recursos, veja
Tutorial - Guia do Usuário.
+Para um exemplo mais completo incluindo mais recursos, veja o
Tutorial - Guia do Usuário.
**Alerta de Spoiler**: o tutorial - guia do usuário inclui:
@@ -442,7 +442,7 @@ Para um exemplo mais completo incluindo mais recursos, veja
Injeção de Dependência**.
* Segurança e autenticação, incluindo suporte para **OAuth2** com autenticação com **JWT tokens** e **HTTP Basic**.
* Técnicas mais avançadas (mas igualmente fáceis) para declaração de **modelos JSON profundamente aninhados** (graças ao Pydantic).
-* Integrações **GraphQL** com o Strawberry e outras bibliotecas.
+* Integrações **GraphQL** com o [Strawberry](https://strawberry.rocks) e outras bibliotecas.
* Muitos recursos extras (graças ao Starlette) como:
* **WebSockets**
* testes extremamente fáceis baseados em HTTPX e `pytest`
@@ -452,24 +452,10 @@ Para um exemplo mais completo incluindo mais recursos, veja
FastAPI Cloud, vá e entre na lista de espera se ainda não o fez. 🚀
+Você pode opcionalmente implantar sua aplicação FastAPI na [FastAPI Cloud](https://fastapicloud.com), vá e entre na lista de espera se ainda não o fez. 🚀
Se você já tem uma conta na **FastAPI Cloud** (nós convidamos você da lista de espera 😉), pode implantar sua aplicação com um único comando.
-Antes de implantar, certifique-se de que está autenticado:
-
-
-
-```console
-$ fastapi login
-
-You are logged in to FastAPI Cloud 🚀
-```
-
-
-
-Depois, implemente sua aplicação:
-
```console
@@ -488,7 +474,7 @@ Deploying to FastAPI Cloud...
#### Sobre a FastAPI Cloud { #about-fastapi-cloud }
-**
FastAPI Cloud** é construída pelo mesmo autor e equipe por trás do **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** é construída pelo mesmo autor e equipe por trás do **FastAPI**.
Ela simplifica o processo de **construir**, **implantar** e **acessar** uma API com esforço mínimo.
@@ -504,9 +490,9 @@ Siga os tutoriais do seu provedor de nuvem para implantar aplicações FastAPI c
## Performance { #performance }
-Testes de performance da Independent TechEmpower mostram aplicações **FastAPI** rodando sob Uvicorn como
um dos frameworks Python mais rápidos disponíveis, somente atrás de Starlette e Uvicorn (utilizados internamente pelo FastAPI). (*)
+Testes de performance independentes do TechEmpower mostram aplicações **FastAPI** rodando sob Uvicorn como [um dos frameworks Python mais rápidos disponíveis](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7), somente atrás de Starlette e Uvicorn (utilizados internamente pelo FastAPI). (*)
-Para entender mais sobre isso, veja a seção
Comparações.
+Para entender mais sobre isso, veja a seção [Comparações](https://fastapi.tiangolo.com/pt/benchmarks/).
## Dependências { #dependencies }
@@ -518,19 +504,19 @@ Quando você instala o FastAPI com `pip install "fastapi[standard]"`, ele vem co
Utilizado pelo Pydantic:
-*
email-validator - para validação de email.
+* [`email-validator`](https://github.com/JoshData/python-email-validator) - para validação de email.
Utilizado pelo Starlette:
-*
httpx - Obrigatório caso você queira utilizar o `TestClient`.
-*
jinja2 - Obrigatório se você quer utilizar a configuração padrão de templates.
-*
python-multipart - Obrigatório se você deseja suporte a
"parsing" de formulário, com `request.form()`.
+* [`httpx`](https://www.python-httpx.org) - Obrigatório caso você queira utilizar o `TestClient`.
+* [`jinja2`](https://jinja.palletsprojects.com) - Obrigatório se você quer utilizar a configuração padrão de templates.
+* [`python-multipart`](https://github.com/Kludex/python-multipart) - Obrigatório se você deseja suporte a
"parsing" de formulário, com `request.form()`.
Utilizado pelo FastAPI:
-*
uvicorn - para o servidor que carrega e serve a sua aplicação. Isto inclui `uvicorn[standard]`, que inclui algumas dependências (e.g. `uvloop`) necessárias para servir em alta performance.
+* [`uvicorn`](https://www.uvicorn.dev) - para o servidor que carrega e serve a sua aplicação. Isto inclui `uvicorn[standard]`, que inclui algumas dependências (e.g. `uvloop`) necessárias para servir em alta performance.
* `fastapi-cli[standard]` - que disponibiliza o comando `fastapi`.
- * Isso inclui `fastapi-cloud-cli`, que permite implantar sua aplicação FastAPI na
FastAPI Cloud.
+ * Isso inclui `fastapi-cloud-cli`, que permite implantar sua aplicação FastAPI na [FastAPI Cloud](https://fastapicloud.com).
### Sem as dependências `standard` { #without-standard-dependencies }
@@ -546,13 +532,13 @@ Existem algumas dependências adicionais que você pode querer instalar.
Dependências opcionais adicionais do Pydantic:
-*
pydantic-settings - para gerenciamento de configurações.
-*
pydantic-extra-types - para tipos extras a serem utilizados com o Pydantic.
+* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) - para gerenciamento de configurações.
+* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) - para tipos extras a serem utilizados com o Pydantic.
Dependências opcionais adicionais do FastAPI:
-*
orjson - Obrigatório se você deseja utilizar o `ORJSONResponse`.
-*
ujson - Obrigatório se você deseja utilizar o `UJSONResponse`.
+* [`orjson`](https://github.com/ijl/orjson) - Obrigatório se você deseja utilizar o `ORJSONResponse`.
+* [`ujson`](https://github.com/esnme/ultrajson) - Obrigatório se você deseja utilizar o `UJSONResponse`.
## Licença { #license }
diff --git a/docs/pt/docs/project-generation.md b/docs/pt/docs/project-generation.md
index 419a39879f..8a34071a65 100644
--- a/docs/pt/docs/project-generation.md
+++ b/docs/pt/docs/project-generation.md
@@ -4,7 +4,7 @@ _Templates_, embora tipicamente venham com alguma configuração específica, s
Você pode usar esse _template_ para começar, já que ele inclui várias configurações iniciais, segurança, banco de dados, e alguns _endpoints_ de API já feitos para você.
-Repositório GitHub:
Full Stack FastAPI Template
+Repositório GitHub: [Full Stack FastAPI Template](https://github.com/tiangolo/full-stack-fastapi-template)
## Full Stack FastAPI Template - Pilha de Tecnologias e Recursos { #full-stack-fastapi-template-technology-stack-and-features }
@@ -19,10 +19,10 @@ Repositório GitHub:
Pydantic é uma biblioteca Python para executar a validação de dados.
+[Pydantic](https://docs.pydantic.dev/) é uma biblioteca Python para executar a validação de dados.
Você declara a "forma" dos dados como classes com atributos.
@@ -285,13 +285,13 @@ Um exemplo da documentação oficial do Pydantic:
/// info | Informação
-Para saber mais sobre o
Pydantic, verifique a sua documentação.
+Para saber mais sobre o [Pydantic, verifique a documentação](https://docs.pydantic.dev/).
///
O **FastAPI** é todo baseado em Pydantic.
-Você verá muito mais disso na prática no [Tutorial - Guia do usuário](tutorial/index.md){.internal-link target=_blank}.
+Você verá muito mais disso na prática no [Tutorial - Guia do usuário](tutorial/index.md).
## Type Hints com Metadados de Anotações { #type-hints-with-metadata-annotations }
@@ -337,12 +337,12 @@ Com o **FastAPI**, você declara parâmetros com type hints e obtém:
* **Documentar** a API usando OpenAPI:
* que é usada pelas interfaces de usuário da documentação interativa automática.
-Tudo isso pode parecer abstrato. Não se preocupe. Você verá tudo isso em ação no [Tutorial - Guia do usuário](tutorial/index.md){.internal-link target=_blank}.
+Tudo isso pode parecer abstrato. Não se preocupe. Você verá tudo isso em ação no [Tutorial - Guia do usuário](tutorial/index.md).
O importante é que, usando tipos padrão de Python, em um único local (em vez de adicionar mais classes, decoradores, etc.), o **FastAPI** fará muito trabalho para você.
/// info | Informação
-Se você já passou por todo o tutorial e voltou para ver mais sobre os tipos, um bom recurso é
a "cheat sheet" do `mypy`.
+Se você já passou por todo o tutorial e voltou para ver mais sobre os tipos, um bom recurso é [a "cheat sheet" do `mypy`](https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html).
///
diff --git a/docs/pt/docs/tutorial/background-tasks.md b/docs/pt/docs/tutorial/background-tasks.md
index 462fb00dcb..20152d9cf4 100644
--- a/docs/pt/docs/tutorial/background-tasks.md
+++ b/docs/pt/docs/tutorial/background-tasks.md
@@ -62,7 +62,7 @@ E então outra tarefa em segundo plano gerada na *função de operação de rota
## Detalhes técnicos { #technical-details }
-A classe `BackgroundTasks` vem diretamente de
`starlette.background`.
+A classe `BackgroundTasks` vem diretamente de [`starlette.background`](https://www.starlette.dev/background/).
Ela é importada/incluída diretamente no FastAPI para que você possa importá-la de `fastapi` e evitar importar acidentalmente a alternativa `BackgroundTask` (sem o `s` no final) de `starlette.background`.
@@ -70,11 +70,11 @@ Usando apenas `BackgroundTasks` (e não `BackgroundTask`), é possível usá-la
Ainda é possível usar `BackgroundTask` sozinho no FastAPI, mas você precisa criar o objeto no seu código e retornar uma `Response` da Starlette incluindo-o.
-Você pode ver mais detalhes na
documentação oficial da Starlette para tarefas em segundo plano.
+Você pode ver mais detalhes na [documentação oficial da Starlette para tarefas em segundo plano](https://www.starlette.dev/background/).
## Ressalva { #caveat }
-Se você precisar realizar computação pesada em segundo plano e não necessariamente precisar que seja executada pelo mesmo processo (por exemplo, você não precisa compartilhar memória, variáveis, etc.), pode se beneficiar do uso de outras ferramentas maiores, como o
Celery.
+Se você precisar realizar computação pesada em segundo plano e não necessariamente precisar que seja executada pelo mesmo processo (por exemplo, você não precisa compartilhar memória, variáveis, etc.), pode se beneficiar do uso de outras ferramentas maiores, como o [Celery](https://docs.celeryq.dev).
Elas tendem a exigir configurações mais complexas, um gerenciador de fila de mensagens/tarefas, como RabbitMQ ou Redis, mas permitem executar tarefas em segundo plano em vários processos e, especialmente, em vários servidores.
diff --git a/docs/pt/docs/tutorial/bigger-applications.md b/docs/pt/docs/tutorial/bigger-applications.md
index ad758988f7..971504fa4f 100644
--- a/docs/pt/docs/tutorial/bigger-applications.md
+++ b/docs/pt/docs/tutorial/bigger-applications.md
@@ -123,7 +123,7 @@ Agora usaremos uma dependência simples para ler um cabeçalho `X-Token` persona
Estamos usando um cabeçalho inventado para simplificar este exemplo.
-Mas em casos reais, você obterá melhores resultados usando os [Utilitários de Segurança](security/index.md){.internal-link target=_blank} integrados.
+Mas em casos reais, você obterá melhores resultados usando os [Utilitários de Segurança](security/index.md) integrados.
///
@@ -169,7 +169,7 @@ E podemos adicionar uma list de `dependencies` que serão adicionadas a todas as
/// tip | Dica
-Observe que, assim como [dependências em *decoradores de operação de rota*](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, nenhum valor será passado para sua *função de operação de rota*.
+Observe que, assim como [dependências em *decoradores de operação de rota*](dependencies/dependencies-in-path-operation-decorators.md), nenhum valor será passado para sua *função de operação de rota*.
///
@@ -185,8 +185,8 @@ O resultado final é que os paths dos itens agora são:
* Todas elas incluirão as `responses` predefinidas.
* Todas essas *operações de rota* terão a list de `dependencies` avaliada/executada antes delas.
* Se você também declarar dependências em uma *operação de rota* específica, **elas também serão executadas**.
- * As dependências do router são executadas primeiro, depois as [`dependencies` no decorador](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank} e, em seguida, as dependências de parâmetros normais.
- * Você também pode adicionar [dependências de `Segurança` com `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
+ * As dependências do router são executadas primeiro, depois as [`dependencies` no decorador](dependencies/dependencies-in-path-operation-decorators.md) e, em seguida, as dependências de parâmetros normais.
+ * Você também pode adicionar [dependências de `Segurança` com `scopes`](../advanced/security/oauth2-scopes.md).
/// tip | Dica
@@ -303,7 +303,7 @@ E como a maior parte de sua lógica agora viverá em seu próprio módulo espec
Você importa e cria uma classe `FastAPI` normalmente.
-E podemos até declarar [dependências globais](dependencies/global-dependencies.md){.internal-link target=_blank} que serão combinadas com as dependências para cada `APIRouter`:
+E podemos até declarar [dependências globais](dependencies/global-dependencies.md) que serão combinadas com as dependências para cada `APIRouter`:
{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[1,3,7] title["app/main.py"] *}
@@ -353,7 +353,7 @@ A segunda versão é uma "importação absoluta":
from app.routers import items, users
```
-Para saber mais sobre pacotes e módulos Python, leia
a documentação oficial do Python sobre módulos.
+Para saber mais sobre pacotes e módulos Python, leia [a documentação oficial do Python sobre módulos](https://docs.python.org/3/tutorial/modules.html).
///
@@ -465,6 +465,37 @@ Como não podemos simplesmente isolá-los e "montá-los" independentemente do re
///
+## Configure o `entrypoint` em `pyproject.toml` { #configure-the-entrypoint-in-pyproject-toml }
+
+Como seu objeto `app` do FastAPI fica em `app/main.py`, você pode configurar o `entrypoint` no seu arquivo `pyproject.toml` assim:
+
+```toml
+[tool.fastapi]
+entrypoint = "app.main:app"
+```
+
+isso é equivalente a importar como:
+
+```python
+from app.main import app
+```
+
+Dessa forma o comando `fastapi` saberá onde encontrar sua aplicação.
+
+/// Note | Nota
+
+Você também poderia passar o path para o comando, como:
+
+```console
+$ fastapi dev app/main.py
+```
+
+Mas você teria que lembrar de passar o path correto toda vez que chamar o comando `fastapi`.
+
+Além disso, outras ferramentas podem não conseguir encontrá-la, por exemplo a [Extensão do VS Code](../editor-support.md) ou a [FastAPI Cloud](https://fastapicloud.com), portanto é recomendável usar o `entrypoint` em `pyproject.toml`.
+
+///
+
## Verifique a documentação automática da API { #check-the-automatic-api-docs }
Agora, execute sua aplicação:
@@ -472,14 +503,14 @@ Agora, execute sua aplicação:
```console
-$ fastapi dev app/main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-E abra a documentação em
http://127.0.0.1:8000/docs.
+E abra a documentação em [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Você verá a documentação automática da API, incluindo os paths de todos os submódulos, usando os paths (e prefixos) corretos e as tags corretas:
diff --git a/docs/pt/docs/tutorial/body-nested-models.md b/docs/pt/docs/tutorial/body-nested-models.md
index d53d3f649a..343f94997a 100644
--- a/docs/pt/docs/tutorial/body-nested-models.md
+++ b/docs/pt/docs/tutorial/body-nested-models.md
@@ -65,7 +65,7 @@ Por exemplo, nós podemos definir um modelo `Image`:
### Use o sub-modelo como um tipo { #use-the-submodel-as-a-type }
-E então podemos usa-lo como o tipo de um atributo:
+E então podemos usá-lo como o tipo de um atributo:
{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[18] *}
@@ -90,15 +90,15 @@ Novamente, apenas fazendo essa declaração, com o **FastAPI**, você ganha:
* Suporte do editor (preenchimento automático, etc.), inclusive para modelos aninhados
* Conversão de dados
* Validação de dados
-* Documentação automatica
+* Documentação automática
## Tipos especiais e validação { #special-types-and-validation }
Além dos tipos singulares normais como `str`, `int`, `float`, etc. Você também pode usar tipos singulares mais complexos que herdam de `str`.
-Para ver todas as opções possíveis, consulte a
Visão geral dos tipos do Pydantic. Você verá alguns exemplos no próximo capítulo.
+Para ver todas as opções possíveis, consulte a [Visão geral dos tipos do Pydantic](https://docs.pydantic.dev/latest/concepts/types/). Você verá alguns exemplos no próximo capítulo.
-Por exemplo, no modelo `Image` nós temos um campo `url`, nós podemos declara-lo como um `HttpUrl` do Pydantic invés de como uma `str`:
+Por exemplo, no modelo `Image` nós temos um campo `url`, nós podemos declará-lo como um `HttpUrl` do Pydantic invés de como uma `str`:
{* ../../docs_src/body_nested_models/tutorial005_py310.py hl[2,8] *}
@@ -110,7 +110,7 @@ Você também pode usar modelos Pydantic como subtipos de `list`, `set`, etc:
{* ../../docs_src/body_nested_models/tutorial006_py310.py hl[18] *}
-Isso vai esperar(converter, validar, documentar, etc) um corpo JSON tal qual:
+Isso vai esperar (converter, validar, documentar, etc) um corpo JSON tal qual:
```JSON hl_lines="11"
{
@@ -198,7 +198,7 @@ Neste caso, você aceitaria qualquer `dict`, desde que tenha chaves` int` com va
/// tip | Dica
-Leve em condideração que o JSON só suporta `str` como chaves.
+Leve em consideração que o JSON só suporta `str` como chaves.
Mas o Pydantic tem conversão automática de dados.
diff --git a/docs/pt/docs/tutorial/body-updates.md b/docs/pt/docs/tutorial/body-updates.md
index 95f89c8d23..abd14c42ce 100644
--- a/docs/pt/docs/tutorial/body-updates.md
+++ b/docs/pt/docs/tutorial/body-updates.md
@@ -2,7 +2,7 @@
## Atualização substituindo com `PUT` { #update-replacing-with-put }
-Para atualizar um item, você pode usar a operação
HTTP `PUT`.
+Para atualizar um item, você pode usar a operação [HTTP `PUT`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT).
Você pode usar `jsonable_encoder` para converter os dados de entrada em dados que podem ser armazenados como JSON (por exemplo, com um banco de dados NoSQL). Por exemplo, convertendo `datetime` em `str`.
@@ -28,7 +28,7 @@ E os dados seriam salvos com esse "novo" `tax` de `10.5`.
## Atualizações parciais com `PATCH` { #partial-updates-with-patch }
-Você também pode usar a operação
HTTP `PATCH` para atualizar dados *parcialmente*.
+Você também pode usar a operação [HTTP `PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) para atualizar dados *parcialmente*.
Isso significa que você pode enviar apenas os dados que deseja atualizar, deixando o restante intacto.
@@ -95,6 +95,6 @@ Observe que o modelo de entrada ainda é validado.
Portanto, se você quiser receber atualizações parciais que possam omitir todos os atributos, você precisa ter um modelo com todos os atributos marcados como opcionais (com valores padrão ou `None`).
-Para distinguir entre os modelos com todos os valores opcionais para **atualizações** e modelos com valores obrigatórios para **criação**, você pode usar as ideias descritas em [Modelos Adicionais](extra-models.md){.internal-link target=_blank}.
+Para distinguir entre os modelos com todos os valores opcionais para **atualizações** e modelos com valores obrigatórios para **criação**, você pode usar as ideias descritas em [Modelos Adicionais](extra-models.md).
///
diff --git a/docs/pt/docs/tutorial/body.md b/docs/pt/docs/tutorial/body.md
index bec553e215..926de84fac 100644
--- a/docs/pt/docs/tutorial/body.md
+++ b/docs/pt/docs/tutorial/body.md
@@ -6,7 +6,7 @@ O corpo da **requisição** é a informação enviada pelo cliente para sua API.
Sua API quase sempre precisa enviar um corpo na **resposta**. Mas os clientes não necessariamente precisam enviar **corpos de requisição** o tempo todo, às vezes eles apenas requisitam um path, talvez com alguns parâmetros de consulta, mas não enviam um corpo.
-Para declarar um corpo da **requisição**, você utiliza os modelos do
Pydantic com todos os seus poderes e benefícios.
+Para declarar um corpo da **requisição**, você utiliza os modelos do [Pydantic](https://docs.pydantic.dev/) com todos os seus poderes e benefícios.
/// info | Informação
@@ -73,7 +73,7 @@ Apenas com essa declaração de tipos do Python, o **FastAPI** irá:
* Se algum dado for inválido, irá retornar um erro bem claro, indicando exatamente onde e o que estava incorreto.
* Entregar a você a informação recebida no parâmetro `item`.
* Como você o declarou na função como do tipo `Item`, você também terá o suporte do editor (preenchimento automático, etc) para todos os atributos e seus tipos.
-* Gerar definições de
JSON Schema para o seu modelo; você também pode usá-las em qualquer outro lugar se fizer sentido para o seu projeto.
+* Gerar definições de [JSON Schema](https://json-schema.org) para o seu modelo; você também pode usá-las em qualquer outro lugar se fizer sentido para o seu projeto.
* Esses schemas farão parte do esquema OpenAPI gerado, e serão usados pelas
UIs de documentação automática.
## Documentação automática { #automatic-docs }
@@ -102,15 +102,15 @@ E foi imensamente testado na fase de design, antes de qualquer implementação,
Houveram mudanças no próprio Pydantic para que isso fosse possível.
-As capturas de tela anteriores foram capturas no
Visual Studio Code.
+As capturas de tela anteriores foram capturas no [Visual Studio Code](https://code.visualstudio.com).
-Mas você terá o mesmo suporte do editor no
PyCharm e na maioria dos editores Python:
+Mas você terá o mesmo suporte do editor no [PyCharm](https://www.jetbrains.com/pycharm/) e na maioria dos editores Python:
/// tip | Dica
-Se você utiliza o
PyCharm como editor, você pode utilizar o
Plugin do Pydantic para o PyCharm .
+Se você utiliza o [PyCharm](https://www.jetbrains.com/pycharm/) como editor, você pode utilizar o [Plugin do Pydantic para o PyCharm](https://github.com/koxudaxi/pydantic-pycharm-plugin/).
Melhora o suporte do editor para seus modelos Pydantic com:
@@ -163,4 +163,4 @@ Mas adicionar as anotações de tipo permitirá ao seu editor oferecer um suport
## Sem o Pydantic { #without-pydantic }
-Se você não quer utilizar os modelos Pydantic, você também pode utilizar o parâmetro **Body**. Veja a documentação para [Body - Parâmetros múltiplos: Valores singulares no body](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
+Se você não quer utilizar os modelos Pydantic, você também pode utilizar o parâmetro **Body**. Veja a documentação para [Body - Parâmetros múltiplos: Valores singulares no body](body-multiple-params.md#singular-values-in-body).
diff --git a/docs/pt/docs/tutorial/cors.md b/docs/pt/docs/tutorial/cors.md
index 055cfeacad..e351d5c5cf 100644
--- a/docs/pt/docs/tutorial/cors.md
+++ b/docs/pt/docs/tutorial/cors.md
@@ -1,6 +1,6 @@
# CORS (Cross-Origin Resource Sharing) { #cors-cross-origin-resource-sharing }
-
CORS ou "Cross-Origin Resource Sharing" refere-se às situações em que um frontend rodando em um navegador possui um código JavaScript que se comunica com um backend, e o backend está em uma "origem" diferente do frontend.
+[CORS ou "Cross-Origin Resource Sharing"](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) refere-se às situações em que um frontend rodando em um navegador possui um código JavaScript que se comunica com um backend, e o backend está em uma "origem" diferente do frontend.
## Origem { #origin }
@@ -56,10 +56,10 @@ Os seguintes argumentos são suportados:
* `allow_origins` - Uma lista de origens que devem ter permissão para fazer requisições de origem cruzada. Por exemplo, `['https://example.org', 'https://www.example.org']`. Você pode usar `['*']` para permitir qualquer origem.
* `allow_origin_regex` - Uma string regex para corresponder às origens que devem ter permissão para fazer requisições de origem cruzada. Por exemplo, `'https://.*\.example\.org'`.
* `allow_methods` - Uma lista de métodos HTTP que devem ser permitidos para requisições de origem cruzada. O padrão é `['GET']`. Você pode usar `['*']` para permitir todos os métodos padrão.
-* `allow_headers` - Uma lista de cabeçalhos de solicitação HTTP que devem ter suporte para requisições de origem cruzada. O padrão é `[]`. Você pode usar `['*']` para permitir todos os cabeçalhos. Os cabeçalhos `Accept`, `Accept-Language`, `Content-Language` e `Content-Type` são sempre permitidos para
requisições CORS simples.
+* `allow_headers` - Uma lista de cabeçalhos de solicitação HTTP que devem ter suporte para requisições de origem cruzada. O padrão é `[]`. Você pode usar `['*']` para permitir todos os cabeçalhos. Os cabeçalhos `Accept`, `Accept-Language`, `Content-Language` e `Content-Type` são sempre permitidos para [requisições CORS simples](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests).
* `allow_credentials` - Indica que os cookies devem ser suportados para requisições de origem cruzada. O padrão é `False`.
- Nenhum de `allow_origins`, `allow_methods` e `allow_headers` pode ser definido como `['*']` se `allow_credentials` estiver definido como `True`. Todos eles devem ser
especificados explicitamente.
+ Nenhum de `allow_origins`, `allow_methods` e `allow_headers` pode ser definido como `['*']` se `allow_credentials` estiver definido como `True`. Todos eles devem ser [especificados explicitamente](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards).
* `expose_headers` - Indica quaisquer cabeçalhos de resposta que devem ser disponibilizados ao navegador. O padrão é `[]`.
* `max_age` - Define um tempo máximo em segundos para os navegadores armazenarem em cache as respostas CORS. O padrão é `600`.
@@ -78,7 +78,7 @@ Qualquer solicitação com um cabeçalho `Origin`. Neste caso, o middleware pass
## Mais informações { #more-info }
-Para mais informações sobre
CORS, consulte a
documentação do CORS da Mozilla.
+Para mais informações sobre
CORS, consulte a [documentação do CORS da Mozilla](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS).
/// note | Detalhes Técnicos
diff --git a/docs/pt/docs/tutorial/debugging.md b/docs/pt/docs/tutorial/debugging.md
index 773921bb3c..b2c0ed8caf 100644
--- a/docs/pt/docs/tutorial/debugging.md
+++ b/docs/pt/docs/tutorial/debugging.md
@@ -74,7 +74,7 @@ não será executada.
/// info | Informação
-Para mais informações, consulte
a documentação oficial do Python.
+Para mais informações, consulte [a documentação oficial do Python](https://docs.python.org/3/library/__main__.html).
///
diff --git a/docs/pt/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md b/docs/pt/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
index 4a99091d11..05742c8e0c 100644
--- a/docs/pt/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
+++ b/docs/pt/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
@@ -8,7 +8,7 @@ Mas você ainda precisa que ela seja executada/resolvida.
Para esses casos, em vez de declarar um parâmetro em uma *função de operação de rota* com `Depends`, você pode adicionar um argumento `dependencies` do tipo `list` ao decorador da operação de rota.
-## Adicione `dependencies` ao decorador da operação de rota { #add-dependencies-to-the-path-operation-decorator }
+## Adicione `dependencies` ao *decorador da operação de rota* { #add-dependencies-to-the-path-operation-decorator }
O *decorador da operação de rota* recebe um argumento opcional `dependencies`.
@@ -32,7 +32,7 @@ Isso também pode ser útil para evitar confundir novos desenvolvedores que ao v
Neste exemplo utilizamos cabeçalhos personalizados inventados `X-Key` e `X-Token`.
-Mas em situações reais, como implementações de segurança, você pode obter mais vantagens em usar as [Ferramentas de segurança integradas (o próximo capítulo)](../security/index.md){.internal-link target=_blank}.
+Mas em situações reais, como implementações de segurança, você pode obter mais vantagens em usar as [Ferramentas de segurança integradas (o próximo capítulo)](../security/index.md).
///
@@ -62,7 +62,7 @@ Então, você pode reutilizar uma dependência comum (que retorna um valor) que
## Dependências para um grupo de *operações de rota* { #dependencies-for-a-group-of-path-operations }
-Mais a frente, quando você ler sobre como estruturar aplicações maiores ([Aplicações maiores - Múltiplos arquivos](../../tutorial/bigger-applications.md){.internal-link target=_blank}), possivelmente com múltiplos arquivos, você aprenderá a declarar um único parâmetro `dependencies` para um grupo de *operações de rota*.
+Mais a frente, quando você ler sobre como estruturar aplicações maiores ([Aplicações maiores - Múltiplos arquivos](../../tutorial/bigger-applications.md)), possivelmente com múltiplos arquivos, você aprenderá a declarar um único parâmetro `dependencies` para um grupo de *operações de rota*.
## Dependências globais { #global-dependencies }
diff --git a/docs/pt/docs/tutorial/dependencies/dependencies-with-yield.md b/docs/pt/docs/tutorial/dependencies/dependencies-with-yield.md
index dd9d9fbe6d..3e4a31d6ff 100644
--- a/docs/pt/docs/tutorial/dependencies/dependencies-with-yield.md
+++ b/docs/pt/docs/tutorial/dependencies/dependencies-with-yield.md
@@ -14,8 +14,8 @@ Garanta utilizar `yield` apenas uma vez por dependência.
Qualquer função que possa ser utilizada com:
-*
`@contextlib.contextmanager` ou
-*
`@contextlib.asynccontextmanager`
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) ou
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
pode ser utilizada como uma dependência do **FastAPI**.
@@ -87,7 +87,7 @@ O **FastAPI** se encarrega de executá-las na ordem certa.
/// note | Detalhes Técnicos
-Tudo isso funciona graças aos
gerenciadores de contexto do Python.
+Tudo isso funciona graças aos [gerenciadores de contexto](https://docs.python.org/3/library/contextlib.html) do Python.
O **FastAPI** utiliza eles internamente para alcançar isso.
@@ -111,7 +111,7 @@ Mas ela existe para ser utilizada caso você precise. 🤓
{* ../../docs_src/dependencies/tutorial008b_an_py310.py hl[18:22,31] *}
-Se você quiser capturar exceções e criar uma resposta personalizada com base nisso, crie um [Manipulador de Exceções Customizado](../handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank}.
+Se você quiser capturar exceções e criar uma resposta personalizada com base nisso, crie um [Manipulador de Exceções Customizado](../handling-errors.md#install-custom-exception-handlers).
## Dependências com `yield` e `except` { #dependencies-with-yield-and-except }
@@ -233,14 +233,14 @@ participant operation as Operação de Rota
Dependências com `yield` evoluíram ao longo do tempo para cobrir diferentes casos de uso e corrigir alguns problemas.
-Se você quiser ver o que mudou em diferentes versões do FastAPI, você pode ler mais sobre isso no guia avançado, em [Dependências Avançadas - Dependências com `yield`, `HTTPException`, `except` e Tarefas de Background](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks){.internal-link target=_blank}.
+Se você quiser ver o que mudou em diferentes versões do FastAPI, você pode ler mais sobre isso no guia avançado, em [Dependências Avançadas - Dependências com `yield`, `HTTPException`, `except` e Tarefas de Background](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks).
## Gerenciadores de contexto { #context-managers }
### O que são "Gerenciadores de Contexto" { #what-are-context-managers }
"Gerenciadores de Contexto" são qualquer um dos objetos Python que podem ser utilizados com a declaração `with`.
-Por exemplo,
você pode utilizar `with` para ler um arquivo:
+Por exemplo, [você pode utilizar `with` para ler um arquivo](https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files):
```Python
with open("./somefile.txt") as f:
@@ -264,7 +264,7 @@ Se você está apenas iniciando com o **FastAPI** você pode querer pular isso p
///
-Em Python, você pode criar Gerenciadores de Contexto ao
criar uma classe com dois métodos: `__enter__()` e `__exit__()`.
+Em Python, você pode criar Gerenciadores de Contexto ao [criar uma classe com dois métodos: `__enter__()` e `__exit__()`](https://docs.python.org/3/reference/datamodel.html#context-managers).
Você também pode usá-los dentro de dependências com `yield` do **FastAPI** ao utilizar
`with` ou `async with` dentro da função da dependência:
@@ -275,8 +275,8 @@ Você também pode usá-los dentro de dependências com `yield` do **FastAPI** a
Outra forma de criar um gerenciador de contexto é utilizando:
-*
`@contextlib.contextmanager` ou
-*
`@contextlib.asynccontextmanager`
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) ou
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
Para decorar uma função com um único `yield`.
diff --git a/docs/pt/docs/tutorial/dependencies/global-dependencies.md b/docs/pt/docs/tutorial/dependencies/global-dependencies.md
index d85b72f8e7..5ff106c230 100644
--- a/docs/pt/docs/tutorial/dependencies/global-dependencies.md
+++ b/docs/pt/docs/tutorial/dependencies/global-dependencies.md
@@ -2,15 +2,15 @@
Para alguns tipos de aplicação você pode querer adicionar dependências para toda a aplicação.
-De forma semelhante a [adicionar `dependencies` aos *decoradores de operação de rota*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, você pode adicioná-las à aplicação `FastAPI`.
+De forma semelhante a [adicionar `dependencies` aos *decoradores de operação de rota*](dependencies-in-path-operation-decorators.md), você pode adicioná-las à aplicação `FastAPI`.
Nesse caso, elas serão aplicadas a todas as *operações de rota* da aplicação:
{* ../../docs_src/dependencies/tutorial012_an_py310.py hl[17] *}
-E todos os conceitos apresentados na seção sobre [adicionar `dependencies` aos *decoradores de operação de rota*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} ainda se aplicam, mas nesse caso, para todas as *operações de rota* da aplicação.
+E todos os conceitos apresentados na seção sobre [adicionar `dependencies` aos *decoradores de operação de rota*](dependencies-in-path-operation-decorators.md) ainda se aplicam, mas nesse caso, para todas as *operações de rota* da aplicação.
## Dependências para conjuntos de *operações de rota* { #dependencies-for-groups-of-path-operations }
-Mais para a frente, quando você ler sobre como estruturar aplicações maiores ([Aplicações Maiores - Múltiplos Arquivos](../../tutorial/bigger-applications.md){.internal-link target=_blank}), possivelmente com múltiplos arquivos, você irá aprender a declarar um único parâmetro `dependencies` para um conjunto de *operações de rota*.
+Mais para a frente, quando você ler sobre como estruturar aplicações maiores ([Aplicações Maiores - Múltiplos Arquivos](../../tutorial/bigger-applications.md)), possivelmente com múltiplos arquivos, você irá aprender a declarar um único parâmetro `dependencies` para um conjunto de *operações de rota*.
diff --git a/docs/pt/docs/tutorial/dependencies/index.md b/docs/pt/docs/tutorial/dependencies/index.md
index 5b8afe783b..baea97f7ff 100644
--- a/docs/pt/docs/tutorial/dependencies/index.md
+++ b/docs/pt/docs/tutorial/dependencies/index.md
@@ -1,6 +1,6 @@
# Dependências { #dependencies }
-O **FastAPI** possui um poderoso, mas intuitivo sistema de **
Injeção de Dependência**.
+O **FastAPI** possui um poderoso, mas intuitivo sistema de **
Injeção de Dependência**.
Esse sistema foi pensado para ser fácil de usar, e permitir que qualquer desenvolvedor possa integrar facilmente outros componentes ao **FastAPI**.
@@ -57,7 +57,7 @@ FastAPI passou a suportar a notação `Annotated` (e começou a recomendá-la) n
Se você utiliza uma versão anterior, ocorrerão erros ao tentar utilizar `Annotated`.
-Certifique-se de [Atualizar a versão do FastAPI](../../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} para pelo menos 0.95.1 antes de usar `Annotated`.
+Certifique-se de [Atualizar a versão do FastAPI](../../deployment/versions.md#upgrading-the-fastapi-versions) para pelo menos 0.95.1 antes de usar `Annotated`.
///
@@ -152,7 +152,7 @@ Não faz diferença. O **FastAPI** sabe o que fazer.
/// note | Nota
-Caso você não conheça, veja em [Async: *"Com Pressa?"*](../../async.md#in-a-hurry){.internal-link target=_blank} a sessão acerca de `async` e `await` na documentação.
+Caso você não conheça, veja em [Async: *"Com Pressa?"*](../../async.md#in-a-hurry) a sessão acerca de `async` e `await` na documentação.
///
diff --git a/docs/pt/docs/tutorial/encoder.md b/docs/pt/docs/tutorial/encoder.md
index b3b1b69bc3..e1ee2eccfd 100644
--- a/docs/pt/docs/tutorial/encoder.md
+++ b/docs/pt/docs/tutorial/encoder.md
@@ -12,7 +12,7 @@ Vamos imaginar que você tenha um banco de dados `fake_db` que recebe apenas dad
Por exemplo, ele não recebe objetos `datetime`, pois estes objetos não são compatíveis com JSON.
-Então, um objeto `datetime` teria que ser convertido em um `str` contendo os dados no
formato ISO.
+Então, um objeto `datetime` teria que ser convertido em um `str` contendo os dados no [formato ISO](https://en.wikipedia.org/wiki/ISO_8601).
Da mesma forma, este banco de dados não receberia um modelo Pydantic (um objeto com atributos), apenas um `dict`.
@@ -24,7 +24,7 @@ A função recebe um objeto, como um modelo Pydantic e retorna uma versão compa
Neste exemplo, ele converteria o modelo Pydantic em um `dict`, e o `datetime` em um `str`.
-O resultado de chamar a função é algo que pode ser codificado com o padrão do Python
`json.dumps()`.
+O resultado de chamar a função é algo que pode ser codificado com o padrão do Python [`json.dumps()`](https://docs.python.org/3/library/json.html#json.dumps).
A função não retorna um grande `str` contendo os dados no formato JSON (como uma string). Mas sim, retorna uma estrutura de dados padrão do Python (por exemplo, um `dict`) com valores e subvalores compatíveis com JSON.
diff --git a/docs/pt/docs/tutorial/extra-data-types.md b/docs/pt/docs/tutorial/extra-data-types.md
index 97e4cc4757..e323d57301 100644
--- a/docs/pt/docs/tutorial/extra-data-types.md
+++ b/docs/pt/docs/tutorial/extra-data-types.md
@@ -36,12 +36,12 @@ Aqui estão alguns dos tipos de dados adicionais que você pode usar:
* `datetime.timedelta`:
* O `datetime.timedelta` do Python.
* Em requisições e respostas será representado como um `float` de segundos totais.
- * O Pydantic também permite representá-lo como uma "codificação ISO 8601 diferença de tempo",
cheque a documentação para mais informações.
+ * O Pydantic também permite representá-lo como uma "codificação ISO 8601 diferença de tempo", [cheque a documentação para mais informações](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
* `frozenset`:
* Em requisições e respostas, será tratado da mesma forma que um `set`:
* Nas requisições, uma lista será lida, eliminando duplicadas e convertendo-a em um `set`.
* Nas respostas, o `set` será convertido para uma `list`.
- * O esquema gerado vai especificar que os valores do `set` são unicos (usando o `uniqueItems` do JSON Schema).
+ * O esquema gerado vai especificar que os valores do `set` são únicos (usando o `uniqueItems` do JSON Schema).
* `bytes`:
* O `bytes` padrão do Python.
* Em requisições e respostas será representado como uma `str`.
@@ -49,7 +49,7 @@ Aqui estão alguns dos tipos de dados adicionais que você pode usar:
* `Decimal`:
* O `Decimal` padrão do Python.
* Em requisições e respostas será representado como um `float`.
-* Você pode checar todos os tipos de dados válidos do Pydantic aqui:
Tipos de dados do Pydantic.
+* Você pode checar todos os tipos de dados válidos do Pydantic aqui: [Tipos de dados do Pydantic](https://docs.pydantic.dev/latest/usage/types/types/).
## Exemplo { #example }
@@ -57,6 +57,6 @@ Aqui está um exemplo de *operação de rota* com parâmetros utilizando-se de a
{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[1,3,12:16] *}
-Note que os parâmetros dentro da função tem seu tipo de dados natural, e você pode, por exemplo, realizar manipulações normais de data, como:
+Note que os parâmetros dentro da função têm seu tipo de dados natural, e você pode, por exemplo, realizar manipulações normais de data, como:
{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[18:19] *}
diff --git a/docs/pt/docs/tutorial/extra-models.md b/docs/pt/docs/tutorial/extra-models.md
index 3136597417..424e0fe185 100644
--- a/docs/pt/docs/tutorial/extra-models.md
+++ b/docs/pt/docs/tutorial/extra-models.md
@@ -12,7 +12,7 @@ Isso é especialmente o caso para modelos de usuários, porque:
Nunca armazene senhas em texto simples dos usuários. Sempre armazene uma "hash segura" que você pode verificar depois.
-Se não souber, você aprenderá o que é uma "senha hash" nos [capítulos de segurança](security/simple-oauth2.md#password-hashing){.internal-link target=_blank}.
+Se não souber, você aprenderá o que é uma "senha hash" nos [capítulos de segurança](security/simple-oauth2.md#password-hashing).
///
@@ -162,11 +162,11 @@ Você pode declarar uma resposta como o `Union` de dois ou mais tipos, o que sig
Isso será definido no OpenAPI com `anyOf`.
-Para fazer isso, use a anotação de tipo padrão do Python
`typing.Union`:
+Para fazer isso, use a anotação de tipo padrão do Python [`typing.Union`](https://docs.python.org/3/library/typing.html#typing.Union):
/// note | Nota
-Ao definir um
`Union`, inclua o tipo mais específico primeiro, seguido pelo tipo menos específico. No exemplo abaixo, o tipo mais específico `PlaneItem` vem antes de `CarItem` em `Union[PlaneItem, CarItem]`.
+Ao definir um [`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions), inclua o tipo mais específico primeiro, seguido pelo tipo menos específico. No exemplo abaixo, o tipo mais específico `PlaneItem` vem antes de `CarItem` em `Union[PlaneItem, CarItem]`.
///
diff --git a/docs/pt/docs/tutorial/first-steps.md b/docs/pt/docs/tutorial/first-steps.md
index 4ccc7cf040..719a38c209 100644
--- a/docs/pt/docs/tutorial/first-steps.md
+++ b/docs/pt/docs/tutorial/first-steps.md
@@ -6,12 +6,12 @@ O arquivo FastAPI mais simples pode se parecer com:
Copie o conteúdo para um arquivo `main.py`.
-Execute o servidor:
+Execute o servidor ao vivo:
```console
-$
fastapi dev
main.py
+$
fastapi dev
FastAPI Starting development server 🚀
@@ -58,7 +58,7 @@ Essa linha mostra a URL onde a sua aplicação está sendo servida, na sua máqu
### Confira { #check-it }
-Abra o seu navegador em
http://127.0.0.1:8000.
+Abra o seu navegador em [http://127.0.0.1:8000](http://127.0.0.1:8000).
Você verá essa resposta em JSON:
@@ -68,17 +68,17 @@ Você verá essa resposta em JSON:
### Documentação Interativa de APIs { #interactive-api-docs }
-Agora vá para
http://127.0.0.1:8000/docs.
+Agora vá para [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
-Você verá a documentação interativa automática da API (fornecida por
Swagger UI):
+Você verá a documentação interativa automática da API (fornecida por [Swagger UI](https://github.com/swagger-api/swagger-ui)):
### Documentação Alternativa de APIs { #alternative-api-docs }
-E agora, vá para
http://127.0.0.1:8000/redoc.
+E agora, vá para [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
-Você verá a documentação alternativa automática (fornecida por
ReDoc):
+Você verá a documentação alternativa automática (fornecida por [ReDoc](https://github.com/Rebilly/ReDoc)):
@@ -92,7 +92,7 @@ Um "*schema*" é uma definição ou descrição de algo. Não o código que o im
#### API "*schema*" { #api-schema }
-Nesse caso,
OpenAPI é uma especificação que determina como definir um *schema* da sua API.
+Nesse caso, [OpenAPI](https://github.com/OAI/OpenAPI-Specification) é uma especificação que determina como definir um *schema* da sua API.
Esta definição de *schema* inclui os paths da sua API, os parâmetros possíveis que eles usam, etc.
@@ -110,7 +110,7 @@ OpenAPI define um *schema* de API para sua API. E esse *schema* inclui definiç
Se você está curioso(a) sobre a aparência do *schema* bruto OpenAPI, o FastAPI gera automaticamente um JSON (*schema*) com as descrições de toda a sua API.
-Você pode ver isso diretamente em:
http://127.0.0.1:8000/openapi.json.
+Você pode ver isso diretamente em: [http://127.0.0.1:8000/openapi.json](http://127.0.0.1:8000/openapi.json).
Ele mostrará um JSON começando com algo como:
@@ -143,9 +143,58 @@ E existem dezenas de alternativas, todas baseadas em OpenAPI. Você pode facilme
Você também pode usá-lo para gerar código automaticamente para clientes que se comunicam com sua API. Por exemplo, aplicativos front-end, móveis ou IoT.
+### Configure o `entrypoint` da aplicação em `pyproject.toml` { #configure-the-app-entrypoint-in-pyproject-toml }
+
+Você pode configurar onde sua aplicação está localizada em um arquivo `pyproject.toml`, assim:
+
+```toml
+[tool.fastapi]
+entrypoint = "main:app"
+```
+
+Esse `entrypoint` dirá ao comando `fastapi` que ele deve importar a aplicação assim:
+
+```python
+from main import app
+```
+
+Se o seu código estiver estruturado assim:
+
+```
+.
+├── backend
+│ ├── main.py
+│ ├── __init__.py
+```
+
+Então você definiria o `entrypoint` como:
+
+```toml
+[tool.fastapi]
+entrypoint = "backend.main:app"
+```
+
+o que seria equivalente a:
+
+```python
+from backend.main import app
+```
+
+### `fastapi dev` com path { #fastapi-dev-with-path }
+
+Você também pode passar o path do arquivo para o comando `fastapi dev`, e ele vai deduzir o objeto de aplicação FastAPI a ser usado:
+
+```console
+$ fastapi dev main.py
+```
+
+Mas você teria que lembrar de passar o path correto toda vez que chamar o comando `fastapi`.
+
+Além disso, outras ferramentas podem não conseguir encontrá-la, por exemplo, a [Extensão do VS Code](../editor-support.md) ou a [FastAPI Cloud](https://fastapicloud.com), então é recomendado usar o `entrypoint` no `pyproject.toml`.
+
### Faça o deploy da sua aplicação (opcional) { #deploy-your-app-optional }
-Você pode, opcionalmente, fazer o deploy da sua aplicação FastAPI na
FastAPI Cloud; acesse e entre na lista de espera, se ainda não entrou. 🚀
+Você pode, opcionalmente, fazer o deploy da sua aplicação FastAPI na [FastAPI Cloud](https://fastapicloud.com); acesse e entre na lista de espera, se ainda não entrou. 🚀
Se você já tem uma conta na **FastAPI Cloud** (nós convidamos você da lista de espera 😉), pode fazer o deploy da sua aplicação com um único comando.
@@ -191,7 +240,7 @@ Deploying to FastAPI Cloud...
`FastAPI` é uma classe que herda diretamente de `Starlette`.
-Você pode usar todas as funcionalidades do
Starlette com `FastAPI` também.
+Você pode usar todas as funcionalidades do [Starlette](https://www.starlette.dev/) com `FastAPI` também.
///
@@ -312,7 +361,7 @@ Por exemplo, ao usar GraphQL, você normalmente executa todas as ações usando
///
-### Passo 4: defina a função de operação de rota { #step-4-define-the-path-operation-function }
+### Passo 4: defina a **função de operação de rota** { #step-4-define-the-path-operation-function }
Esta é a nossa "**função de operação de rota**":
@@ -336,7 +385,7 @@ Você também pode defini-la como uma função normal em vez de `async def`:
/// note | Nota
-Se você não sabe a diferença, verifique o [Async: *"Com pressa?"*](../async.md#in-a-hurry){.internal-link target=_blank}.
+Se você não sabe a diferença, verifique o [Async: *"Com pressa?"*](../async.md#in-a-hurry).
///
@@ -352,11 +401,11 @@ Existem muitos outros objetos e modelos que serão convertidos automaticamente p
### Passo 6: Faça o deploy { #step-6-deploy-it }
-Faça o deploy da sua aplicação para a **
FastAPI Cloud** com um comando: `fastapi deploy`. 🎉
+Faça o deploy da sua aplicação para a **[FastAPI Cloud](https://fastapicloud.com)** com um comando: `fastapi deploy`. 🎉
#### Sobre o FastAPI Cloud { #about-fastapi-cloud }
-A **
FastAPI Cloud** é construída pelo mesmo autor e equipe por trás do **FastAPI**.
+A **[FastAPI Cloud](https://fastapicloud.com)** é construída pelo mesmo autor e equipe por trás do **FastAPI**.
Ela simplifica o processo de **construir**, **fazer deploy** e **acessar** uma API com o mínimo de esforço.
diff --git a/docs/pt/docs/tutorial/handling-errors.md b/docs/pt/docs/tutorial/handling-errors.md
index 252dbb06fb..c400a1e848 100644
--- a/docs/pt/docs/tutorial/handling-errors.md
+++ b/docs/pt/docs/tutorial/handling-errors.md
@@ -81,7 +81,7 @@ Mas caso você precise, para um cenário mais complexo, você pode adicionar hea
## Instale manipuladores de exceções customizados { #install-custom-exception-handlers }
-Você pode adicionar manipuladores de exceção customizados com
a mesma seção de utilidade de exceções presentes no Starlette.
+Você pode adicionar manipuladores de exceção customizados com [a mesma seção de utilidade de exceções presentes no Starlette](https://www.starlette.dev/exceptions/).
Digamos que você tenha uma exceção customizada `UnicornException` que você (ou uma biblioteca que você use) precise lançar (`raise`).
diff --git a/docs/pt/docs/tutorial/index.md b/docs/pt/docs/tutorial/index.md
index cd7dd88fe9..49cb48adb1 100644
--- a/docs/pt/docs/tutorial/index.md
+++ b/docs/pt/docs/tutorial/index.md
@@ -10,12 +10,12 @@ Ele também foi construído para servir como uma referência futura, então voc
Todos os blocos de código podem ser copiados e utilizados diretamente (eles são, na verdade, arquivos Python testados).
-Para rodar qualquer um dos exemplos, copie o código para um arquivo `main.py`, e inicie o `fastapi dev` com:
+Para rodar qualquer um dos exemplos, copie o código para um arquivo `main.py`, e inicie o `fastapi dev`:
```console
-$
fastapi dev
main.py
+$
fastapi dev
FastAPI Starting development server 🚀
@@ -62,7 +62,7 @@ Usá-lo em seu editor é o que realmente te mostra os benefícios do FastAPI, ve
O primeiro passo é instalar o FastAPI.
-Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então **instalar o FastAPI**:
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e então **instalar o FastAPI**:
@@ -76,7 +76,7 @@ $ pip install "fastapi[standard]"
/// note | Nota
-Quando você instala com `pip install "fastapi[standard]"`, ele vem com algumas dependências opcionais padrão, incluindo `fastapi-cloud-cli`, que permite fazer deploy na
FastAPI Cloud.
+Quando você instala com `pip install "fastapi[standard]"`, ele vem com algumas dependências opcionais padrão, incluindo `fastapi-cloud-cli`, que permite fazer deploy na [FastAPI Cloud](https://fastapicloud.com).
Se você não quiser ter essas dependências opcionais, pode instalar `pip install fastapi` em vez disso.
@@ -84,6 +84,12 @@ Se você quiser instalar as dependências padrão, mas sem o `fastapi-cloud-cli`
///
+/// tip | Dica
+
+O FastAPI tem uma [extensão oficial para o VS Code](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (e para o Cursor), que fornece vários recursos, incluindo um explorador de operações de rota, busca de operações de rota, navegação CodeLens em testes (ir para a definição a partir dos testes) e deploy e logs da FastAPI Cloud, tudo direto do seu editor.
+
+///
+
## Guia Avançado de Usuário { #advanced-user-guide }
Há também um **Guia Avançado de Usuário** que você pode ler após esse **Tutorial - Guia de Usuário**.
diff --git a/docs/pt/docs/tutorial/metadata.md b/docs/pt/docs/tutorial/metadata.md
index 476b5c806e..3d96109789 100644
--- a/docs/pt/docs/tutorial/metadata.md
+++ b/docs/pt/docs/tutorial/metadata.md
@@ -14,7 +14,7 @@ Você pode definir os seguintes campos que são usados na especificação OpenAP
| `version` | `string` | A versão da API. Esta é a versão da sua aplicação, não do OpenAPI. Por exemplo, `2.5.0`. |
| `terms_of_service` | `str` | Uma URL para os Termos de Serviço da API. Se fornecido, deve ser uma URL. |
| `contact` | `dict` | As informações de contato da API exposta. Pode conter vários campos.
Campos de contact
| Parâmetro | Tipo | Descrição |
|---|
name | str | O nome identificador da pessoa/organização de contato. |
url | str | A URL que aponta para as informações de contato. DEVE estar no formato de uma URL. |
email | str | O endereço de e-mail da pessoa/organização de contato. DEVE estar no formato de um endereço de e-mail. |
|
-| `license_info` | `dict` | As informações de licença para a API exposta. Ela pode conter vários campos.
Campos de license_info
| Parâmetro | Tipo | Descrição |
|---|
name | str | OBRIGATÓRIO (se um license_info for definido). O nome da licença usada para a API. |
identifier | str | Uma expressão de licença SPDX para a API. O campo identifier é mutuamente exclusivo do campo url. Disponível desde OpenAPI 3.1.0, FastAPI 0.99.0. |
url | str | Uma URL para a licença usada para a API. DEVE estar no formato de uma URL. |
|
+| `license_info` | `dict` | As informações de licença para a API exposta. Ela pode conter vários campos.
Campos de license_info
| Parâmetro | Tipo | Descrição |
|---|
name | str | OBRIGATÓRIO (se um license_info for definido). O nome da licença usada para a API. |
identifier | str | Uma expressão de licença [SPDX](https://spdx.org/licenses/) para a API. O campo identifier é mutuamente exclusivo do campo url. Disponível desde OpenAPI 3.1.0, FastAPI 0.99.0. |
url | str | Uma URL para a licença usada para a API. DEVE estar no formato de uma URL. |
|
Você pode defini-los da seguinte maneira:
@@ -76,7 +76,7 @@ Use o parâmetro `tags` com suas *operações de rota* (e `APIRouter`s) para atr
/// info | Informação
-Leia mais sobre tags em [Configuração de operação de rota](path-operation-configuration.md#tags){.internal-link target=_blank}.
+Leia mais sobre tags em [Configuração de operação de rota](path-operation-configuration.md#tags).
///
diff --git a/docs/pt/docs/tutorial/middleware.md b/docs/pt/docs/tutorial/middleware.md
index 7cccfcb6ac..5ae5854da7 100644
--- a/docs/pt/docs/tutorial/middleware.md
+++ b/docs/pt/docs/tutorial/middleware.md
@@ -15,7 +15,7 @@ Um "middleware" é uma função que manipula cada **requisição** antes de ser
Se você tiver dependências com `yield`, o código de saída será executado *depois* do middleware.
-Se houver alguma tarefa em segundo plano (abordada na seção [Tarefas em segundo plano](background-tasks.md){.internal-link target=_blank}, que você verá mais adiante), ela será executada *depois* de todo o middleware.
+Se houver alguma tarefa em segundo plano (abordada na seção [Tarefas em segundo plano](background-tasks.md), que você verá mais adiante), ela será executada *depois* de todo o middleware.
///
@@ -35,9 +35,9 @@ A função middleware recebe:
/// tip | Dica
-Tenha em mente que cabeçalhos proprietários personalizados podem ser adicionados
usando o prefixo `X-`.
+Tenha em mente que cabeçalhos proprietários personalizados podem ser adicionados [usando o prefixo `X-`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).
-Mas se você tiver cabeçalhos personalizados desejando que um cliente em um navegador esteja apto a ver, você precisa adicioná-los às suas configurações CORS ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) usando o parâmetro `expose_headers` documentado em
Documentação CORS da Starlette.
+Mas se você tiver cabeçalhos personalizados desejando que um cliente em um navegador esteja apto a ver, você precisa adicioná-los às suas configurações CORS ([CORS (Cross-Origin Resource Sharing)](cors.md)) usando o parâmetro `expose_headers` documentado na [Documentação CORS da Starlette](https://www.starlette.dev/middleware/#corsmiddleware).
///
@@ -61,7 +61,7 @@ Por exemplo, você pode adicionar um cabeçalho personalizado `X-Process-Time` c
/// tip | Dica
-Aqui usamos
`time.perf_counter()` em vez de `time.time()` porque ele pode ser mais preciso para esses casos de uso. 🤓
+Aqui usamos [`time.perf_counter()`](https://docs.python.org/3/library/time.html#time.perf_counter) em vez de `time.time()` porque ele pode ser mais preciso para esses casos de uso. 🤓
///
@@ -90,6 +90,6 @@ Esse comportamento de empilhamento garante que os middlewares sejam executados e
## Outros middlewares { #other-middlewares }
-Mais tarde, você pode ler mais sobre outros middlewares no [Guia do usuário avançado: Middleware avançado](../advanced/middleware.md){.internal-link target=_blank}.
+Mais tarde, você pode ler mais sobre outros middlewares no [Guia do usuário avançado: Middleware avançado](../advanced/middleware.md).
Você lerá sobre como manipular
CORS com um middleware na próxima seção.
diff --git a/docs/pt/docs/tutorial/path-operation-configuration.md b/docs/pt/docs/tutorial/path-operation-configuration.md
index c17b12e2bd..745b9b6980 100644
--- a/docs/pt/docs/tutorial/path-operation-configuration.md
+++ b/docs/pt/docs/tutorial/path-operation-configuration.md
@@ -40,7 +40,7 @@ Eles serão adicionados ao esquema OpenAPI e usados pelas interfaces de document
### Tags com Enums { #tags-with-enums }
-Se você tem uma grande aplicação, você pode acabar acumulando **várias tags**, e você gostaria de ter certeza de que você sempre usa a **mesma tag** para *operações de rota* relacionadas.
+Se você tem uma grande aplicação, você pode acabar acumulando **várias tags**, e você gostaria de ter certeza de que você sempre usa a ** mesma tag** para *operações de rota* relacionadas.
Nestes casos, pode fazer sentido armazenar as tags em um `Enum`.
@@ -58,7 +58,7 @@ Você pode adicionar um `summary` e uma `description`:
Como as descrições tendem a ser longas e cobrir várias linhas, você pode declarar a descrição da *operação de rota* na
docstring da função e o **FastAPI** irá lê-la de lá.
-Você pode escrever
Markdown na docstring, ele será interpretado e exibido corretamente (levando em conta a indentação da docstring).
+Você pode escrever [Markdown](https://en.wikipedia.org/wiki/Markdown) na docstring, ele será interpretado e exibido corretamente (levando em conta a indentação da docstring).
{* ../../docs_src/path_operation_configuration/tutorial004_py310.py hl[17:25] *}
diff --git a/docs/pt/docs/tutorial/path-params-numeric-validations.md b/docs/pt/docs/tutorial/path-params-numeric-validations.md
index bb2e154f43..9bbe14c759 100644
--- a/docs/pt/docs/tutorial/path-params-numeric-validations.md
+++ b/docs/pt/docs/tutorial/path-params-numeric-validations.md
@@ -14,7 +14,7 @@ O FastAPI adicionou suporte a `Annotated` (e passou a recomendá-lo) na versão
Se você tiver uma versão mais antiga, verá erros ao tentar usar `Annotated`.
-Certifique-se de [Atualizar a versão do FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} para pelo menos 0.95.1 antes de usar `Annotated`.
+Certifique-se de [Atualizar a versão do FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions) para pelo menos 0.95.1 antes de usar `Annotated`.
///
@@ -122,7 +122,7 @@ E o mesmo para
lt.
## Recapitulando { #recap }
-Com `Query`, `Path` (e outras que você ainda não viu) você pode declarar metadados e validações de string do mesmo modo que em [Parâmetros de consulta e validações de string](query-params-str-validations.md){.internal-link target=_blank}.
+Com `Query`, `Path` (e outras que você ainda não viu) você pode declarar metadados e validações de string do mesmo modo que em [Parâmetros de consulta e validações de string](query-params-str-validations.md).
E você também pode declarar validações numéricas:
diff --git a/docs/pt/docs/tutorial/path-params.md b/docs/pt/docs/tutorial/path-params.md
index e8e420ad0d..ea9af63f36 100644
--- a/docs/pt/docs/tutorial/path-params.md
+++ b/docs/pt/docs/tutorial/path-params.md
@@ -6,7 +6,7 @@ Você pode declarar "parâmetros" ou "variáveis" de path com a mesma sintaxe us
O valor do parâmetro de path `item_id` será passado para a sua função como o argumento `item_id`.
-Então, se você executar este exemplo e acessar
http://127.0.0.1:8000/items/foo, você verá uma resposta:
+Então, se você executar este exemplo e acessar [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo), você verá uma resposta:
```JSON
{"item_id":"foo"}
@@ -26,7 +26,7 @@ Isso fornecerá suporte do editor dentro da sua função, com verificações de
## Dados
conversão { #data-conversion }
-Se você executar este exemplo e abrir seu navegador em
http://127.0.0.1:8000/items/3, você verá uma resposta:
+Se você executar este exemplo e abrir seu navegador em [http://127.0.0.1:8000/items/3](http://127.0.0.1:8000/items/3), você verá uma resposta:
```JSON
{"item_id":3}
@@ -40,7 +40,7 @@ Então, com essa declaração de tipo, o **FastAPI** fornece
http://127.0.0.1:8000/items/foo, verá um bom erro HTTP:
+Mas se você for no navegador para [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo), verá um bom erro HTTP:
```JSON
{
@@ -60,7 +60,7 @@ Mas se você for no navegador para http://127.0.0.1:8000/items/4.2
+O mesmo erro apareceria se você fornecesse um `float` em vez de um `int`, como em: [http://127.0.0.1:8000/items/4.2](http://127.0.0.1:8000/items/4.2)
/// check | Verifique
Então, com a mesma declaração de tipo do Python, o **FastAPI** fornece validação de dados.
@@ -72,7 +72,7 @@ Isso é incrivelmente útil ao desenvolver e depurar código que interage com su
## Documentação { #documentation }
-E quando você abrir seu navegador em http://127.0.0.1:8000/docs, você verá documentação automática, interativa, da API como:
+E quando você abrir seu navegador em [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs), você verá documentação automática, interativa, da API como:
@@ -84,9 +84,9 @@ Observe que o parâmetro de path está declarado como um inteiro.
## Benefícios baseados em padrões, documentação alternativa { #standards-based-benefits-alternative-documentation }
-E como o schema gerado é do padrão OpenAPI, existem muitas ferramentas compatíveis.
+E como o schema gerado é do padrão [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md), existem muitas ferramentas compatíveis.
-Por causa disso, o próprio **FastAPI** fornece uma documentação alternativa da API (usando ReDoc), que você pode acessar em http://127.0.0.1:8000/redoc:
+Por causa disso, o próprio **FastAPI** fornece uma documentação alternativa da API (usando ReDoc), que você pode acessar em [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc):
@@ -94,7 +94,7 @@ Da mesma forma, existem muitas ferramentas compatíveis. Incluindo ferramentas d
## Pydantic { #pydantic }
-Toda a validação de dados é realizada nos bastidores pelo Pydantic, então você recebe todos os benefícios disso. E você sabe que está em boas mãos.
+Toda a validação de dados é realizada nos bastidores pelo [Pydantic](https://docs.pydantic.dev/), então você recebe todos os benefícios disso. E você sabe que está em boas mãos.
Você pode usar as mesmas declarações de tipo com `str`, `float`, `bool` e muitos outros tipos de dados complexos.
@@ -122,7 +122,7 @@ A primeira sempre será usada, já que o path corresponde primeiro.
## Valores predefinidos { #predefined-values }
-Se você tem uma *operação de rota* que recebe um *parâmetro de path*, mas quer que os valores válidos possíveis do *parâmetro de path* sejam predefinidos, você pode usar um `Enum` padrão do Python.
+Se você tem uma *operação de rota* que recebe um *parâmetro de path*, mas quer que os valores válidos possíveis do *parâmetro de path* sejam predefinidos, você pode usar um `Enum` padrão do Python.
### Crie uma classe `Enum` { #create-an-enum-class }
diff --git a/docs/pt/docs/tutorial/query-params-str-validations.md b/docs/pt/docs/tutorial/query-params-str-validations.md
index b76b76a268..5ee41684a2 100644
--- a/docs/pt/docs/tutorial/query-params-str-validations.md
+++ b/docs/pt/docs/tutorial/query-params-str-validations.md
@@ -35,13 +35,13 @@ O FastAPI adicionou suporte a `Annotated` (e passou a recomendá-lo) na versão
Se você tiver uma versão mais antiga, teria erros ao tentar usar `Annotated`.
-Certifique-se de [Atualizar a versão do FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} para pelo menos 0.95.1 antes de usar `Annotated`.
+Certifique-se de [Atualizar a versão do FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions) para pelo menos 0.95.1 antes de usar `Annotated`.
///
## Use `Annotated` no tipo do parâmetro `q` { #use-annotated-in-the-type-for-the-q-parameter }
-Lembra que eu disse antes que `Annotated` pode ser usado para adicionar metadados aos seus parâmetros na [Introdução aos tipos do Python](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank}?
+Lembra que eu disse antes que `Annotated` pode ser usado para adicionar metadados aos seus parâmetros na [Introdução aos tipos do Python](../python-types.md#type-hints-with-metadata-annotations)?
Agora é a hora de usá-lo com FastAPI. 🚀
@@ -158,7 +158,7 @@ Você poderia chamar essa mesma função em outros lugares sem FastAPI, e ela fu
Quando você não usa `Annotated` e em vez disso usa o estilo de valor padrão (antigo), se você chamar essa função sem FastAPI em outros lugares, terá que lembrar de passar os argumentos para a função para que funcione corretamente, caso contrário os valores serão diferentes do esperado (por exemplo, `QueryInfo` ou algo parecido em vez de `str`). E seu editor não vai avisar, e o Python também não vai reclamar ao executar a função, apenas quando as operações internas falharem.
-Como `Annotated` pode ter mais de uma anotação de metadados, você agora pode até usar a mesma função com outras ferramentas, como o Typer. 🚀
+Como `Annotated` pode ter mais de uma anotação de metadados, você agora pode até usar a mesma função com outras ferramentas, como o [Typer](https://typer.tiangolo.com/). 🚀
## Adicione mais validações { #add-more-validations }
@@ -370,11 +370,11 @@ Podem existir casos em que você precise fazer alguma validação personalizada
Nesses casos, você pode usar uma função validadora personalizada que é aplicada após a validação normal (por exemplo, depois de validar que o valor é uma `str`).
-Você pode fazer isso usando o `AfterValidator` do Pydantic dentro de `Annotated`.
+Você pode fazer isso usando o [`AfterValidator` do Pydantic](https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator) dentro de `Annotated`.
/// tip | Dica
-O Pydantic também tem `BeforeValidator` e outros. 🤓
+O Pydantic também tem [`BeforeValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator) e outros. 🤓
///
diff --git a/docs/pt/docs/tutorial/query-params.md b/docs/pt/docs/tutorial/query-params.md
index f429885660..472c12be64 100644
--- a/docs/pt/docs/tutorial/query-params.md
+++ b/docs/pt/docs/tutorial/query-params.md
@@ -129,7 +129,7 @@ Porém, quando você quiser fazer com que o parâmetro de consulta seja obrigat
{* ../../docs_src/query_params/tutorial005_py310.py hl[6:7] *}
-Aqui o parâmetro de consulta `needy` é um valor obrigatório, do tipo `str`.
+Aqui o parâmetro da consulta `needy` é um valor obrigatório, do tipo `str`.
Se você abrir no seu navegador a URL:
@@ -182,6 +182,6 @@ Nesse caso, existem 3 parâmetros de consulta:
/// tip | Dica
-Você também poderia usar `Enum` da mesma forma que com [Path Parameters](path-params.md#predefined-values){.internal-link target=_blank}.
+Você também poderia usar `Enum`s da mesma forma que com [Parâmetros de rota](path-params.md#predefined-values).
///
diff --git a/docs/pt/docs/tutorial/request-files.md b/docs/pt/docs/tutorial/request-files.md
index 1364a1dd46..912878cd52 100644
--- a/docs/pt/docs/tutorial/request-files.md
+++ b/docs/pt/docs/tutorial/request-files.md
@@ -4,9 +4,9 @@ Você pode definir arquivos para serem enviados pelo cliente usando `File`.
/// info | Informação
-Para receber arquivos enviados, primeiro instale o `python-multipart`.
+Para receber arquivos enviados, primeiro instale [`python-multipart`](https://github.com/Kludex/python-multipart).
-Garanta que você criou um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, o ativou e então o instalou, por exemplo:
+Garanta que você criou um [ambiente virtual](../virtual-environments.md), o ativou e então o instalou, por exemplo:
```console
$ pip install python-multipart
@@ -63,8 +63,8 @@ Utilizar `UploadFile` tem várias vantagens sobre `bytes`:
* Um arquivo armazenado na memória até um limite máximo de tamanho, e após passar esse limite, ele será armazenado no disco.
* Isso significa que funcionará bem para arquivos grandes como imagens, vídeos, binários grandes, etc., sem consumir toda a memória.
* Você pode receber metadados do arquivo enviado.
-* Ele tem uma file-like interface `assíncrona`.
-* Ele expõe um objeto python `SpooledTemporaryFile` que você pode passar diretamente para outras bibliotecas que esperam um objeto semelhante a um arquivo("file-like").
+* Ele tem uma [file-like](https://docs.python.org/3/glossary.html#term-file-like-object) interface `assíncrona`.
+* Ele expõe um objeto python [`SpooledTemporaryFile`](https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile) que você pode passar diretamente para outras bibliotecas que esperam um objeto semelhante a um arquivo.
### `UploadFile` { #uploadfile }
@@ -72,7 +72,7 @@ Utilizar `UploadFile` tem várias vantagens sobre `bytes`:
* `filename`: Uma `str` com o nome do arquivo original que foi enviado (por exemplo, `myimage.jpg`).
* `content_type`: Uma `str` com o tipo de conteúdo (MIME type / media type) (por exemplo, `image/jpeg`).
-* `file`: Um `SpooledTemporaryFile` (um file-like objeto). Este é o objeto de arquivo Python que você pode passar diretamente para outras funções ou bibliotecas que esperam um objeto semelhante a um arquivo("file-like").
+* `file`: Um [`SpooledTemporaryFile`](https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile) (um [file-like](https://docs.python.org/3/glossary.html#term-file-like-object) objeto). Este é o objeto de arquivo Python que você pode passar diretamente para outras funções ou bibliotecas que esperam um objeto semelhante a um arquivo.
`UploadFile` tem os seguintes métodos `assíncronos`. Todos eles chamam os métodos de arquivo correspondentes por baixo dos panos (usando o `SpooledTemporaryFile` interno).
@@ -121,7 +121,7 @@ Dados de formulários normalmente são codificados usando o "media type" `applic
Mas quando o formulário inclui arquivos, ele é codificado como `multipart/form-data`. Se você usar `File`, o **FastAPI** saberá que tem que pegar os arquivos da parte correta do corpo da requisição.
-Se você quiser ler mais sobre essas codificações e campos de formulário, vá para a MDN web docs para POST.
+Se você quiser ler mais sobre essas codificações e campos de formulário, vá para a [MDN web docs para `POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST).
///
diff --git a/docs/pt/docs/tutorial/request-form-models.md b/docs/pt/docs/tutorial/request-form-models.md
index 38f160aa83..953c3fdcee 100644
--- a/docs/pt/docs/tutorial/request-form-models.md
+++ b/docs/pt/docs/tutorial/request-form-models.md
@@ -4,9 +4,9 @@ Você pode utilizar **Modelos Pydantic** para declarar **campos de formulários*
/// info | Informação
-Para utilizar formulários, instale primeiramente o `python-multipart`.
+Para utilizar formulários, instale primeiramente o [`python-multipart`](https://github.com/Kludex/python-multipart).
-Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo, e então instalar. Por exemplo:
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo, e então instalar. Por exemplo:
```console
$ pip install python-multipart
diff --git a/docs/pt/docs/tutorial/request-forms-and-files.md b/docs/pt/docs/tutorial/request-forms-and-files.md
index 8b5f034e9e..04d7f9a4eb 100644
--- a/docs/pt/docs/tutorial/request-forms-and-files.md
+++ b/docs/pt/docs/tutorial/request-forms-and-files.md
@@ -4,9 +4,9 @@ Você pode definir arquivos e campos de formulário ao mesmo tempo usando `File`
/// info | Informação
-Para receber arquivos carregados e/ou dados de formulário, primeiro instale `python-multipart`.
+Para receber arquivos carregados e/ou dados de formulário, primeiro instale [`python-multipart`](https://github.com/Kludex/python-multipart).
-Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalar, por exemplo:
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e então instalar, por exemplo:
```console
$ pip install python-multipart
diff --git a/docs/pt/docs/tutorial/request-forms.md b/docs/pt/docs/tutorial/request-forms.md
index d255d0f9be..5b7c4d8090 100644
--- a/docs/pt/docs/tutorial/request-forms.md
+++ b/docs/pt/docs/tutorial/request-forms.md
@@ -4,9 +4,9 @@ Quando você precisar receber campos de formulário em vez de JSON, você pode u
/// info | Informação
-Para usar formulários, primeiro instale `python-multipart`.
+Para usar formulários, primeiro instale [`python-multipart`](https://github.com/Kludex/python-multipart).
-Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalá-lo, por exemplo:
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e então instalá-lo, por exemplo:
```console
$ pip install python-multipart
@@ -56,7 +56,7 @@ Os dados dos formulários são normalmente codificados usando o "media type" `ap
Mas quando o formulário inclui arquivos, ele é codificado como `multipart/form-data`. Você lerá sobre como lidar com arquivos no próximo capítulo.
-Se você quiser ler mais sobre essas codificações e campos de formulário, vá para o MDN web docs para POST.
+Se você quiser ler mais sobre essas codificações e campos de formulário, vá para o [MDN web docs para `POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST).
///
diff --git a/docs/pt/docs/tutorial/response-model.md b/docs/pt/docs/tutorial/response-model.md
index e3b97b630f..7a28bcecdd 100644
--- a/docs/pt/docs/tutorial/response-model.md
+++ b/docs/pt/docs/tutorial/response-model.md
@@ -13,6 +13,7 @@ O FastAPI usará este tipo de retorno para:
* Adicionar um **JSON Schema** para a resposta, na *operação de rota* do OpenAPI.
* Isso será usado pela **documentação automática**.
* Também será usado por ferramentas de geração automática de código do cliente.
+* **Serializar** os dados retornados para JSON usando Pydantic, que é escrito em **Rust**, então será **muito mais rápido**.
Mas o mais importante:
@@ -73,9 +74,9 @@ Aqui estamos declarando um modelo `UserIn`, ele conterá uma senha em texto simp
/// info | Informação
-Para usar `EmailStr`, primeiro instale `email-validator`.
+Para usar `EmailStr`, primeiro instale [`email-validator`](https://github.com/JoshData/python-email-validator).
-Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ative-o e instale-o, por exemplo:
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ative-o e então instale-o, por exemplo:
```console
$ pip install email-validator
@@ -181,7 +182,7 @@ Pode haver casos em que você retorna algo que não é um campo Pydantic válido
### Retorne uma Response diretamente { #return-a-response-directly }
-O caso mais comum seria [retornar uma Response diretamente, conforme explicado posteriormente na documentação avançada](../advanced/response-directly.md){.internal-link target=_blank}.
+O caso mais comum seria [retornar uma Response diretamente, conforme explicado posteriormente na documentação avançada](../advanced/response-directly.md).
{* ../../docs_src/response_model/tutorial003_02_py310.py hl[8,10:11] *}
@@ -257,7 +258,7 @@ Você também pode usar:
* `response_model_exclude_defaults=True`
* `response_model_exclude_none=True`
-conforme descrito na documentação do Pydantic para `exclude_defaults` e `exclude_none`.
+conforme descrito na [documentação do Pydantic](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict) para `exclude_defaults` e `exclude_none`.
///
diff --git a/docs/pt/docs/tutorial/response-status-code.md b/docs/pt/docs/tutorial/response-status-code.md
index a3f8d8a568..d5a81fa03b 100644
--- a/docs/pt/docs/tutorial/response-status-code.md
+++ b/docs/pt/docs/tutorial/response-status-code.md
@@ -20,7 +20,7 @@ O parâmetro `status_code` recebe um número com o código de status HTTP.
/// info | Informação
-`status_code` também pode receber um `IntEnum`, como o do Python `http.HTTPStatus`.
+`status_code` também pode receber um `IntEnum`, como [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus) do Python.
///
@@ -66,7 +66,7 @@ Resumidamente:
/// tip | Dica
-Para saber mais sobre cada código de status e qual código serve para quê, verifique a documentação do MDN sobre códigos de status HTTP.
+Para saber mais sobre cada código de status e qual código serve para quê, verifique a [documentação do MDN sobre códigos de status HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status).
///
@@ -98,4 +98,4 @@ Você também pode usar `from starlette import status`.
## Alterando o padrão { #changing-the-default }
-Mais tarde, no [Guia do Usuário Avançado](../advanced/response-change-status-code.md){.internal-link target=_blank}, você verá como retornar um código de status diferente do padrão que você está declarando aqui.
+Mais tarde, no [Guia do Usuário Avançado](../advanced/response-change-status-code.md), você verá como retornar um código de status diferente do padrão que você está declarando aqui.
diff --git a/docs/pt/docs/tutorial/schema-extra-example.md b/docs/pt/docs/tutorial/schema-extra-example.md
index 560fda908e..cd2ac13c5f 100644
--- a/docs/pt/docs/tutorial/schema-extra-example.md
+++ b/docs/pt/docs/tutorial/schema-extra-example.md
@@ -1,4 +1,4 @@
-# Declarar dados de exemplo da requisição { #declare-request-example-data }
+# Declare dados de exemplo da requisição { #declare-request-example-data }
Você pode declarar exemplos dos dados que sua aplicação pode receber.
@@ -12,7 +12,7 @@ Você pode declarar `examples` para um modelo Pydantic que serão adicionados ao
Essas informações extras serão adicionadas como estão ao **JSON Schema** de saída para esse modelo e serão usadas na documentação da API.
-Você pode usar o atributo `model_config`, que recebe um `dict`, conforme descrito na documentação do Pydantic: Configuration.
+Você pode usar o atributo `model_config`, que recebe um `dict`, conforme descrito na [documentação do Pydantic: Configuration](https://docs.pydantic.dev/latest/api/config/).
Você pode definir `"json_schema_extra"` com um `dict` contendo quaisquer dados adicionais que você queira que apareçam no JSON Schema gerado, incluindo `examples`.
@@ -145,12 +145,12 @@ O JSON Schema não tinha `examples`, então o OpenAPI adicionou seu próprio cam
O OpenAPI também adicionou os campos `example` e `examples` a outras partes da especificação:
-* `Parameter Object` (na especificação), usado no FastAPI por:
+* [`Parameter Object` (na especificação)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object), usado no FastAPI por:
* `Path()`
* `Query()`
* `Header()`
* `Cookie()`
-* `Request Body Object`, no campo `content`, no `Media Type Object` (na especificação), usado no FastAPI por:
+* [`Request Body Object`, no campo `content`, no `Media Type Object` (na especificação)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object), usado no FastAPI por:
* `Body()`
* `File()`
* `Form()`
@@ -163,7 +163,7 @@ Esse parâmetro antigo `examples` específico do OpenAPI agora é `openapi_examp
### Campo `examples` do JSON Schema { #json-schemas-examples-field }
-Depois, o JSON Schema adicionou um campo `examples` em uma nova versão da especificação.
+Depois, o JSON Schema adicionou um campo [`examples`](https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.9.5) em uma nova versão da especificação.
E então o novo OpenAPI 3.1.0 passou a se basear na versão mais recente (JSON Schema 2020-12), que incluiu esse novo campo `examples`.
diff --git a/docs/pt/docs/tutorial/security/first-steps.md b/docs/pt/docs/tutorial/security/first-steps.md
index f0edd57533..d16c15140e 100644
--- a/docs/pt/docs/tutorial/security/first-steps.md
+++ b/docs/pt/docs/tutorial/security/first-steps.md
@@ -26,11 +26,11 @@ Copie o exemplo em um arquivo `main.py`:
/// info | Informação
-O pacote `python-multipart` é instalado automaticamente com o **FastAPI** quando você executa o comando `pip install "fastapi[standard]"`.
+O pacote [`python-multipart`](https://github.com/Kludex/python-multipart) é instalado automaticamente com o **FastAPI** quando você executa o comando `pip install "fastapi[standard]"`.
Entretanto, se você usar o comando `pip install fastapi`, o pacote `python-multipart` não é incluído por padrão.
-Para instalá-lo manualmente, certifique-se de criar um [ambiente virtual](../../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalá-lo com:
+Para instalá-lo manualmente, certifique-se de criar um [ambiente virtual](../../virtual-environments.md), ativá-lo e então instalá-lo com:
```console
$ pip install python-multipart
@@ -45,7 +45,7 @@ Execute o exemplo com:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -54,7 +54,7 @@ $ fastapi dev main.py
## Verifique-o { #check-it }
-Vá até a documentação interativa em:
http://127.0.0.1:8000/docs.
+Vá até a documentação interativa em: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Você verá algo deste tipo:
@@ -140,7 +140,7 @@ Aqui `tokenUrl="token"` refere-se a uma URL relativa `token` que ainda não cria
Como estamos usando uma URL relativa, se sua API estivesse localizada em `https://example.com/`, então se referiria a `https://example.com/token`. Mas se sua API estivesse localizada em `https://example.com/api/v1/`, então se referiria a `https://example.com/api/v1/token`.
-Usar uma URL relativa é importante para garantir que sua aplicação continue funcionando mesmo em um caso de uso avançado como [Atrás de um Proxy](../../advanced/behind-a-proxy.md){.internal-link target=_blank}.
+Usar uma URL relativa é importante para garantir que sua aplicação continue funcionando mesmo em um caso de uso avançado como [Atrás de um Proxy](../../advanced/behind-a-proxy.md).
///
diff --git a/docs/pt/docs/tutorial/security/oauth2-jwt.md b/docs/pt/docs/tutorial/security/oauth2-jwt.md
index 4ba38b9f04..6397664fbf 100644
--- a/docs/pt/docs/tutorial/security/oauth2-jwt.md
+++ b/docs/pt/docs/tutorial/security/oauth2-jwt.md
@@ -24,13 +24,13 @@ Dessa forma, você pode criar um token com um prazo de expiração, digamos, de
Depois de uma semana, o token expirará e o usuário não estará autorizado, precisando fazer login novamente para obter um novo token. E se o usuário (ou uma terceira parte) tentar modificar o token para alterar a expiração, você seria capaz de descobrir isso, pois as assinaturas não iriam corresponder.
-Se você quiser brincar com tokens JWT e ver como eles funcionam, visite
https://jwt.io.
+Se você quiser brincar com tokens JWT e ver como eles funcionam, visite [https://jwt.io](https://jwt.io/).
## Instalar `PyJWT` { #install-pyjwt }
Nós precisamos instalar o `PyJWT` para criar e verificar os tokens JWT em Python.
-Certifique-se de criar um [ambiente virtual](../../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalar o `pyjwt`:
+Certifique-se de criar um [ambiente virtual](../../virtual-environments.md), ativá-lo e então instalar o `pyjwt`:
@@ -46,7 +46,7 @@ $ pip install pyjwt
Se você pretente utilizar algoritmos de assinatura digital como o RSA ou o ECDSA, você deve instalar a dependência da biblioteca de criptografia `pyjwt[crypto]`.
-Você pode ler mais sobre isso na
documentação de instalação do PyJWT.
+Você pode ler mais sobre isso na [documentação de instalação do PyJWT](https://pyjwt.readthedocs.io/en/latest/installation.html).
///
@@ -72,7 +72,7 @@ Ele suporta muitos algoritmos de hashing seguros e utilitários para trabalhar c
O algoritmo recomendado é o "Argon2".
-Certifique-se de criar um [ambiente virtual](../../virtual-environments.md){.internal-link target=_blank}, ativá-lo e então instalar o pwdlib com Argon2:
+Certifique-se de criar um [ambiente virtual](../../virtual-environments.md), ativá-lo e então instalar o pwdlib com Argon2:
@@ -200,7 +200,7 @@ O importante a se lembrar é que a chave `sub` deve ter um identificador único
## Verifique { #check-it }
-Execute o servidor e vá para a documentação:
http://127.0.0.1:8000/docs.
+Execute o servidor e vá para a documentação: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Você verá a interface de usuário assim:
diff --git a/docs/pt/docs/tutorial/security/simple-oauth2.md b/docs/pt/docs/tutorial/security/simple-oauth2.md
index 902ae2d225..f582a81417 100644
--- a/docs/pt/docs/tutorial/security/simple-oauth2.md
+++ b/docs/pt/docs/tutorial/security/simple-oauth2.md
@@ -144,9 +144,10 @@ UserInDB(
)
```
+
/// info | Informação
-Para uma explicação mais completa de `**user_dict`, verifique [a documentação para **Extra Models**](../extra-models.md#about-user-in-dict){.internal-link target=_blank}.
+Para uma explicação mais completa de `**user_dict`, verifique [a documentação para **Extra Models**](../extra-models.md#about-user-in-dict).
///
@@ -216,7 +217,7 @@ Esse é o benefício dos padrões...
## Veja em ação { #see-it-in-action }
-Abra o docs interativo:
http://127.0.0.1:8000/docs.
+Abra o docs interativo: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
### Autentique-se { #authenticate }
diff --git a/docs/pt/docs/tutorial/server-sent-events.md b/docs/pt/docs/tutorial/server-sent-events.md
new file mode 100644
index 0000000000..33389873ce
--- /dev/null
+++ b/docs/pt/docs/tutorial/server-sent-events.md
@@ -0,0 +1,120 @@
+# Eventos Enviados pelo Servidor (SSE) { #server-sent-events-sse }
+
+Você pode transmitir dados para o cliente usando Server-Sent Events (SSE).
+
+Isso é semelhante a [Stream de JSON Lines](stream-json-lines.md), mas usa o formato `text/event-stream`, que é suportado nativamente pelos navegadores com a [`EventSource` API](https://developer.mozilla.org/en-US/docs/Web/API/EventSource).
+
+/// info | Informação
+
+Adicionado no FastAPI 0.135.0.
+
+///
+
+## O que são Server-Sent Events? { #what-are-server-sent-events }
+
+SSE é um padrão para transmitir dados do servidor para o cliente via HTTP.
+
+Cada evento é um pequeno bloco de texto com “campos” como `data`, `event`, `id` e `retry`, separados por linhas em branco.
+
+Fica assim:
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+SSE é comumente usado para streaming de chat de IA, notificações em tempo real, logs e observabilidade, e outros casos em que o servidor envia atualizações para o cliente.
+
+/// tip | Dica
+
+Se você quiser transmitir dados binários, por exemplo vídeo ou áudio, veja o guia avançado: [Stream de Dados](../advanced/stream-data.md).
+
+///
+
+## Transmitir SSE com FastAPI { #stream-sse-with-fastapi }
+
+Para transmitir SSE com FastAPI, use `yield` na sua função de operação de rota e defina `response_class=EventSourceResponse`.
+
+Importe `EventSourceResponse` de `fastapi.sse`:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+Cada item produzido é codificado como JSON e enviado no campo `data:` de um evento SSE.
+
+Se você declarar o tipo de retorno como `AsyncIterable[Item]`, o FastAPI o usará para validar, documentar e serializar os dados com o Pydantic.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[10:12,23] *}
+
+/// tip | Dica
+
+Como o Pydantic fará a serialização no lado em **Rust**, você terá um desempenho muito maior do que se não declarar um tipo de retorno.
+
+///
+
+### *Funções de operação de rota* não assíncronas { #non-async-path-operation-functions }
+
+Você também pode usar funções `def` normais (sem `async`) e usar `yield` da mesma forma.
+
+O FastAPI garantirá a execução correta para não bloquear o event loop.
+
+Como, neste caso, a função não é assíncrona, o tipo de retorno adequado seria `Iterable[Item]`:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[28:31] hl[29] *}
+
+### Sem tipo de retorno { #no-return-type }
+
+Você também pode omitir o tipo de retorno. O FastAPI usará o [`jsonable_encoder`](./encoder.md) para converter os dados e enviá-los.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+Se você precisar definir campos de SSE como `event`, `id`, `retry` ou `comment`, você pode produzir objetos `ServerSentEvent` em vez de dados simples.
+
+Importe `ServerSentEvent` de `fastapi.sse`:
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+O campo `data` é sempre codificado como JSON. Você pode passar qualquer valor que possa ser serializado como JSON, incluindo modelos do Pydantic.
+
+## Dados brutos { #raw-data }
+
+Se você precisar enviar dados sem codificação JSON, use `raw_data` em vez de `data`.
+
+Isto é útil para enviar texto pré-formatado, linhas de log ou valores
"sentinela" especiais como `[DONE]`.
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | Nota
+
+`data` e `raw_data` são mutuamente exclusivos. Você só pode definir um deles em cada `ServerSentEvent`.
+
+///
+
+## Retomando com `Last-Event-ID` { #resuming-with-last-event-id }
+
+Quando um navegador se reconecta após uma queda na conexão, ele envia o último `id` recebido no cabeçalho `Last-Event-ID`.
+
+Você pode lê-lo como um parâmetro de cabeçalho e usá-lo para retomar o stream de onde o cliente parou:
+
+{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}
+
+## SSE com POST { #sse-with-post }
+
+SSE funciona com qualquer método HTTP, não apenas `GET`.
+
+Isso é útil para protocolos como o [MCP](https://modelcontextprotocol.io) que fazem stream de SSE via `POST`:
+
+{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}
+
+## Detalhes Técnicos { #technical-details }
+
+O FastAPI implementa algumas boas práticas de SSE prontas para uso.
+
+- Enviar um comentário de keep alive `ping` a cada 15 segundos quando não houver mensagens, para evitar que alguns proxies fechem a conexão, como sugerido na [especificação HTML: Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes).
+- Definir o cabeçalho `Cache-Control: no-cache` para evitar o cache do stream.
+- Definir o cabeçalho especial `X-Accel-Buffering: no` para evitar buffering em alguns proxies como o Nginx.
+
+Você não precisa fazer nada, isso funciona automaticamente. 🤓
diff --git a/docs/pt/docs/tutorial/sql-databases.md b/docs/pt/docs/tutorial/sql-databases.md
index 543e164e9f..10be4c865c 100644
--- a/docs/pt/docs/tutorial/sql-databases.md
+++ b/docs/pt/docs/tutorial/sql-databases.md
@@ -2,13 +2,13 @@
**FastAPI** não exige que você use um banco de dados SQL (relacional). Mas você pode usar **qualquer banco de dados** que quiser.
-Aqui veremos um exemplo usando
SQLModel.
+Aqui veremos um exemplo usando [SQLModel](https://sqlmodel.tiangolo.com/).
-**SQLModel** é construído sobre
SQLAlchemy e Pydantic. Ele foi criado pelo mesmo autor do **FastAPI** para ser o par perfeito para aplicações **FastAPI** que precisam usar **bancos de dados SQL**.
+**SQLModel** é construído sobre [SQLAlchemy](https://www.sqlalchemy.org/) e Pydantic. Ele foi criado pelo mesmo autor do **FastAPI** para ser o par perfeito para aplicações **FastAPI** que precisam usar **bancos de dados SQL**.
/// tip | Dica
-Você pode usar qualquer outra biblioteca de banco de dados SQL ou NoSQL que quiser (em alguns casos chamadas de
"ORMs"), o FastAPI não obriga você a usar nada. 😎
+Você pode usar qualquer outra biblioteca de banco de dados SQL ou NoSQL que quiser (em alguns casos chamadas de
"ORMs"), o FastAPI não obriga você a usar nada. 😎
///
@@ -26,15 +26,15 @@ Mais tarde, para sua aplicação em produção, você pode querer usar um servid
/// tip | Dica
-Existe um gerador de projetos oficial com **FastAPI** e **PostgreSQL** incluindo um frontend e mais ferramentas:
https://github.com/fastapi/full-stack-fastapi-template
+Existe um gerador de projetos oficial com **FastAPI** e **PostgreSQL** incluindo um frontend e mais ferramentas: [https://github.com/fastapi/full-stack-fastapi-template](https://github.com/fastapi/full-stack-fastapi-template)
///
-Este é um tutorial muito simples e curto, se você quiser aprender sobre bancos de dados em geral, sobre SQL ou recursos mais avançados, acesse a
documentação do SQLModel.
+Este é um tutorial muito simples e curto, se você quiser aprender sobre bancos de dados em geral, sobre SQL ou recursos mais avançados, acesse a [documentação do SQLModel](https://sqlmodel.tiangolo.com/).
## Instalar o `SQLModel` { #install-sqlmodel }
-Primeiro, certifique-se de criar seu [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e, em seguida, instalar o `sqlmodel`:
+Primeiro, certifique-se de criar seu [ambiente virtual](../virtual-environments.md), ativá-lo e, em seguida, instalar o `sqlmodel`:
@@ -45,7 +45,7 @@ $ pip install sqlmodel
-## Criar o App com um Único Modelo { #create-the-app-with-a-single-model }
+## Crear o App com um Único Modelo { #create-the-app-with-a-single-model }
Vamos criar a primeira versão mais simples do app com um único modelo **SQLModel**.
@@ -65,7 +65,7 @@ Existem algumas diferenças:
* `Field(primary_key=True)` informa ao SQLModel que o `id` é a **chave primária** no banco de dados SQL (você pode aprender mais sobre chaves primárias SQL na documentação do SQLModel).
- **Nota:** Usamos `int | None` para o campo de chave primária para que, no código Python, possamos *criar um objeto sem um `id`* (`id=None`), assumindo que o banco de dados irá *gerá-lo ao salvar*. O SQLModel entende que o banco de dados fornecerá o `id` e *define a coluna como um `INTEGER` não nulo* no esquema do banco de dados. Veja a
documentação do SQLModel sobre chaves primárias para detalhes.
+ **Nota:** Usamos `int | None` para o campo de chave primária para que, no código Python, possamos *criar um objeto sem um `id`* (`id=None`), assumindo que o banco de dados irá *gerá-lo ao salvar*. O SQLModel entende que o banco de dados fornecerá o `id` e *define a coluna como um `INTEGER` não nulo* no esquema do banco de dados. Veja a [documentação do SQLModel sobre chaves primárias](https://sqlmodel.tiangolo.com/tutorial/create-db-and-table/#primary-key-id) para detalhes.
* `Field(index=True)` informa ao SQLModel que ele deve criar um **índice SQL** para essa coluna, o que permitirá buscas mais rápidas no banco de dados ao ler dados filtrados por essa coluna.
@@ -96,7 +96,7 @@ Vamos criar uma **dependência** do FastAPI com `yield` que fornecerá uma nova
Então, criamos uma dependência `Annotated` chamada `SessionDep` para simplificar o restante do código que usará essa dependência.
-{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[25:30] hl[25:27,30] *}
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[25:30] hl[25:27,30] *}
### Criar Tabelas de Banco de Dados na Inicialização { #create-database-tables-on-startup }
@@ -110,7 +110,7 @@ Para produção, você provavelmente usaria um script de migração que é execu
/// tip | Dica
-O SQLModel terá utilitários de migração envolvendo o Alembic, mas por enquanto, você pode usar o
Alembic diretamente.
+O SQLModel terá utilitários de migração envolvendo o Alembic, mas por enquanto, você pode usar o [Alembic](https://alembic.sqlalchemy.org/en/latest/) diretamente.
///
@@ -151,7 +151,7 @@ Você pode executar o app:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -168,7 +168,7 @@ Então, vá para a interface `/docs`, você verá que o **FastAPI** está usando
Agora vamos **refatorar** este app um pouco para aumentar a **segurança** e **versatilidade**.
-Se você verificar o app anterior, na interface você pode ver que, até agora, ele permite que o cliente decida o `id` do `Hero` a ser criado. 😱
+Se você verificar o app anterior, na interface você pode ser que, até agora, ele permite que o cliente decida o `id` do `Hero` a ser criado. 😱
Não deveríamos deixar isso acontecer, eles poderiam sobrescrever um `id` que já atribuimos na base de dados. Decidir o `id` deve ser feito pelo **backend** ou pelo **banco de dados**, **não pelo cliente**.
@@ -336,7 +336,7 @@ Você pode executar o app novamente:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -351,6 +351,6 @@ Se você for para a interface `/docs` da API, verá que agora ela está atualiza
## Recapitulando { #recap }
-Você pode usar
**SQLModel** para interagir com um banco de dados SQL e simplificar o código com *modelos de dados* e *modelos de tabela*.
+Você pode usar [**SQLModel**](https://sqlmodel.tiangolo.com/) para interagir com um banco de dados SQL e simplificar o código com *modelos de dados* e *modelos de tabela*.
-Você pode aprender muito mais na documentação do **SQLModel**, há um mini
tutorial sobre como usar SQLModel com **FastAPI** mais longo. 🚀
+Você pode aprender muito mais na documentação do **SQLModel**, há um mini [tutorial sobre como usar SQLModel com **FastAPI**](https://sqlmodel.tiangolo.com/tutorial/fastapi/) mais longo. 🚀
diff --git a/docs/pt/docs/tutorial/static-files.md b/docs/pt/docs/tutorial/static-files.md
index 0b2d0718f2..e9150facd9 100644
--- a/docs/pt/docs/tutorial/static-files.md
+++ b/docs/pt/docs/tutorial/static-files.md
@@ -23,7 +23,7 @@ O **FastAPI** fornece o mesmo que `starlette.staticfiles` como `fastapi.staticfi
Isso é diferente de usar um `APIRouter`, pois uma aplicação montada é completamente independente. A OpenAPI e a documentação da sua aplicação principal não incluirão nada da aplicação montada, etc.
-Você pode ler mais sobre isso no [Guia Avançado do Usuário](../advanced/index.md){.internal-link target=_blank}.
+Você pode ler mais sobre isso no [Guia Avançado do Usuário](../advanced/index.md).
## Detalhes { #details }
@@ -37,4 +37,4 @@ Todos esses parâmetros podem ser diferentes de "`static`", ajuste-os de acordo
## Mais informações { #more-info }
-Para mais detalhes e opções, consulte
a documentação da Starlette sobre Arquivos Estáticos.
+Para mais detalhes e opções, consulte [a documentação da Starlette sobre Arquivos Estáticos](https://www.starlette.dev/staticfiles/).
diff --git a/docs/pt/docs/tutorial/stream-json-lines.md b/docs/pt/docs/tutorial/stream-json-lines.md
new file mode 100644
index 0000000000..f6d5c26f09
--- /dev/null
+++ b/docs/pt/docs/tutorial/stream-json-lines.md
@@ -0,0 +1,111 @@
+# Stream de JSON Lines { #stream-json-lines }
+
+Você pode ter uma sequência de dados que deseja enviar em um "**Stream**"; é possível fazer isso com **JSON Lines**.
+
+/// info | Informação
+
+Adicionado no FastAPI 0.134.0.
+
+///
+
+## O que é um Stream? { #what-is-a-stream }
+
+"**Streaming**" de dados significa que sua aplicação começará a enviar itens ao cliente sem esperar que toda a sequência esteja pronta.
+
+Assim, ela envia o primeiro item, o cliente o recebe e começa a processá-lo, enquanto você ainda pode estar produzindo o próximo item.
+
+```mermaid
+sequenceDiagram
+ participant App
+ participant Client
+
+ App->>App: Produce Item 1
+ App->>Client: Send Item 1
+ App->>App: Produce Item 2
+ Client->>Client: Process Item 1
+ App->>Client: Send Item 2
+ App->>App: Produce Item 3
+ Client->>Client: Process Item 2
+ App->>Client: Send Item 3
+ Client->>Client: Process Item 3
+ Note over App: Keeps producing...
+ Note over Client: Keeps consuming...
+```
+
+Pode até ser um Stream infinito, em que você continua enviando dados.
+
+## JSON Lines { #json-lines }
+
+Nesses casos, é comum enviar "**JSON Lines**", um formato em que você envia um objeto JSON por linha.
+
+Uma response teria um tipo de conteúdo `application/jsonl` (em vez de `application/json`) e o corpo seria algo como:
+
+```json
+{"name": "Plumbus", "description": "A multi-purpose household device."}
+{"name": "Portal Gun", "description": "A portal opening device."}
+{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
+```
+
+É muito semelhante a um array JSON (equivalente a uma list do Python), mas em vez de estar envolto em `[]` e ter `,` entre os itens, há **um objeto JSON por linha**, separados por um caractere de nova linha.
+
+/// info | Informação
+
+O ponto importante é que sua aplicação poderá produzir cada linha em sequência, enquanto o cliente consome as anteriores.
+
+///
+
+/// note | Detalhes Técnicos
+
+Como cada objeto JSON será separado por uma nova linha, eles não podem conter caracteres de nova linha literais em seu conteúdo, mas podem conter novas linhas com escape (`\n`), o que faz parte do padrão JSON.
+
+Mas, normalmente, você não precisará se preocupar com isso, é feito automaticamente, continue lendo. 🤓
+
+///
+
+## Casos de uso { #use-cases }
+
+Você pode usar isso para transmitir dados de um serviço de **IA LLM**, de **logs** ou **telemetria**, ou de outros tipos de dados que possam ser estruturados em itens **JSON**.
+
+/// tip | Dica
+
+Se você quiser transmitir dados binários, por exemplo vídeo ou áudio, confira o guia avançado: [Stream Data](../advanced/stream-data.md).
+
+///
+
+## Stream de JSON Lines com FastAPI { #stream-json-lines-with-fastapi }
+
+Para transmitir JSON Lines com FastAPI, em vez de usar `return` na sua *função de operação de rota*, use `yield` para produzir cada item em sequência.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[24] *}
+
+Se cada item JSON que você quer enviar de volta for do tipo `Item` (um modelo Pydantic) e a função for assíncrona, você pode declarar o tipo de retorno como `AsyncIterable[Item]`:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[9:11,22] *}
+
+Se você declarar o tipo de retorno, o FastAPI o usará para **validar** os dados, **documentá-los** no OpenAPI, **filtrá-los** e **serializá-los** usando o Pydantic.
+
+/// tip | Dica
+
+Como o Pydantic fará a serialização no lado em **Rust**, você terá uma **performance** muito maior do que se não declarar um tipo de retorno.
+
+///
+
+### Funções de operação de rota não assíncronas { #non-async-path-operation-functions }
+
+Você também pode usar funções `def` normais (sem `async`) e usar `yield` da mesma forma.
+
+O FastAPI garantirá que sejam executadas corretamente para não bloquear o event loop.
+
+Como, neste caso, a função não é assíncrona, o tipo de retorno adequado seria `Iterable[Item]`:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[27:30] hl[28] *}
+
+### Sem tipo de retorno { #no-return-type }
+
+Você também pode omitir o tipo de retorno. O FastAPI então usará o [`jsonable_encoder`](./encoder.md) para converter os dados em algo que possa ser serializado para JSON e depois enviá-los como JSON Lines.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[33:36] hl[34] *}
+
+## Eventos enviados pelo servidor (SSE) { #server-sent-events-sse }
+
+O FastAPI também tem suporte de primeira classe a Server-Sent Events (SSE), que são bastante semelhantes, mas com alguns detalhes extras. Você pode aprender sobre eles no próximo capítulo: [Eventos enviados pelo servidor (SSE)](server-sent-events.md). 🤓
diff --git a/docs/pt/docs/tutorial/testing.md b/docs/pt/docs/tutorial/testing.md
index 44dc2d2257..1730511e6d 100644
--- a/docs/pt/docs/tutorial/testing.md
+++ b/docs/pt/docs/tutorial/testing.md
@@ -1,18 +1,18 @@
# Testando { #testing }
-Graças ao
Starlette, testar aplicações **FastAPI** é fácil e agradável.
+Graças ao [Starlette](https://www.starlette.dev/testclient/), testar aplicações **FastAPI** é fácil e agradável.
-Ele é baseado no
HTTPX, que por sua vez é projetado com base em Requests, por isso é muito familiar e intuitivo.
+Ele é baseado no [HTTPX](https://www.python-httpx.org), que por sua vez é projetado com base em Requests, por isso é muito familiar e intuitivo.
-Com ele, você pode usar o
pytest diretamente com **FastAPI**.
+Com ele, você pode usar o [pytest](https://docs.pytest.org/) diretamente com **FastAPI**.
## Usando `TestClient` { #using-testclient }
/// info | Informação
-Para usar o `TestClient`, primeiro instale o
`httpx`.
+Para usar o `TestClient`, primeiro instale [`httpx`](https://www.python-httpx.org).
-Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e instalá-lo, por exemplo:
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e instalá-lo, por exemplo:
```console
$ pip install httpx
@@ -52,7 +52,7 @@ Você também pode usar `from starlette.testclient import TestClient`.
/// tip | Dica
-Se você quiser chamar funções `async` em seus testes além de enviar solicitações à sua aplicação FastAPI (por exemplo, funções de banco de dados assíncronas), dê uma olhada em [Testes assíncronos](../advanced/async-tests.md){.internal-link target=_blank} no tutorial avançado.
+Se você quiser chamar funções `async` em seus testes além de enviar solicitações à sua aplicação FastAPI (por exemplo, funções de banco de dados assíncronas), dê uma olhada em [Testes assíncronos](../advanced/async-tests.md) no tutorial avançado.
///
@@ -64,7 +64,7 @@ E sua aplicação **FastAPI** também pode ser composta de vários arquivos/mód
### Arquivo da aplicação **FastAPI** { #fastapi-app-file }
-Digamos que você tenha uma estrutura de arquivo conforme descrito em [Aplicações maiores](bigger-applications.md){.internal-link target=_blank}:
+Digamos que você tenha uma estrutura de arquivo conforme descrito em [Aplicações maiores](bigger-applications.md):
```
.
@@ -140,13 +140,13 @@ Por exemplo:
* Para passar *headers*, use um `dict` no parâmetro `headers`.
* Para *cookies*, um `dict` no parâmetro `cookies`.
-Para mais informações sobre como passar dados para o backend (usando `httpx` ou `TestClient`), consulte a
documentação do HTTPX.
+Para mais informações sobre como passar dados para o backend (usando `httpx` ou `TestClient`), consulte a [documentação do HTTPX](https://www.python-httpx.org).
/// info | Informação
Observe que o `TestClient` recebe dados que podem ser convertidos para JSON, não para modelos Pydantic.
-Se você tiver um modelo Pydantic em seu teste e quiser enviar seus dados para o aplicativo durante o teste, poderá usar o `jsonable_encoder` descrito em [Codificador compatível com JSON](encoder.md){.internal-link target=_blank}.
+Se você tiver um modelo Pydantic em seu teste e quiser enviar seus dados para o aplicativo durante o teste, poderá usar o `jsonable_encoder` descrito em [Codificador compatível com JSON](encoder.md).
///
@@ -154,7 +154,7 @@ Se você tiver um modelo Pydantic em seu teste e quiser enviar seus dados para o
Depois disso, você só precisa instalar o `pytest`.
-Certifique-se de criar um [ambiente virtual](../virtual-environments.md){.internal-link target=_blank}, ativá-lo e instalá-lo, por exemplo:
+Certifique-se de criar um [ambiente virtual](../virtual-environments.md), ativá-lo e instalá-lo, por exemplo:
diff --git a/docs/pt/docs/virtual-environments.md b/docs/pt/docs/virtual-environments.md
index e222c61ad6..cfb86887fd 100644
--- a/docs/pt/docs/virtual-environments.md
+++ b/docs/pt/docs/virtual-environments.md
@@ -22,7 +22,7 @@ Um **ambiente virtual** é um diretório com alguns arquivos.
Esta página lhe ensinará como usar **ambientes virtuais** e como eles funcionam.
-Se você estiver pronto para adotar uma **ferramenta que gerencia tudo** para você (incluindo a instalação do Python), experimente
uv.
+Se você estiver pronto para adotar uma **ferramenta que gerencia tudo** para você (incluindo a instalação do Python), experimente [uv](https://github.com/astral-sh/uv).
///
@@ -86,7 +86,7 @@ $ python -m venv .venv
//// tab | `uv`
-Se você tiver o
`uv` instalado, poderá usá-lo para criar um ambiente virtual.
+Se você tiver [`uv`](https://github.com/astral-sh/uv) instalado, poderá usá-lo para criar um ambiente virtual.
@@ -150,7 +150,7 @@ $ .venv\Scripts\Activate.ps1
//// tab | Windows Bash
-Ou se você usa o Bash para Windows (por exemplo,
Git Bash):
+Ou se você usa o Bash para Windows (por exemplo, [Git Bash](https://gitforwindows.org/)):
@@ -216,7 +216,7 @@ Se ele mostrar o binário `python` em `.venv\Scripts\python`, dentro do seu proj
/// tip | Dica
-Se você usar
`uv`, você o usará para instalar coisas em vez do `pip`, então não precisará atualizar o `pip`. 😎
+Se você usar [`uv`](https://github.com/astral-sh/uv), você o usará para instalar coisas em vez do `pip`, então não precisará atualizar o `pip`. 😎
///
@@ -268,7 +268,7 @@ Se você estiver usando **Git** (você deveria), adicione um arquivo `.gitignore
/// tip | Dica
-Se você usou
`uv` para criar o ambiente virtual, ele já fez isso para você, você pode pular esta etapa. 😎
+Se você usou [`uv`](https://github.com/astral-sh/uv) para criar o ambiente virtual, ele já fez isso para você, você pode pular esta etapa. 😎
///
@@ -340,7 +340,7 @@ $ pip install "fastapi[standard]"
//// tab | `uv`
-Se você tem o
`uv`:
+Se você tem o [`uv`](https://github.com/astral-sh/uv):
@@ -372,7 +372,7 @@ $ pip install -r requirements.txt
//// tab | `uv`
-Se você tem o
`uv`:
+Se você tem o [`uv`](https://github.com/astral-sh/uv):
@@ -416,8 +416,8 @@ Você provavelmente usaria um editor. Certifique-se de configurá-lo para usar o
Por exemplo:
-*
VS Code
-*
PyCharm
+* [VS Code](https://code.visualstudio.com/docs/python/environments#_select-and-activate-an-environment)
+* [PyCharm](https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html)
/// tip | Dica
@@ -455,7 +455,7 @@ Continue lendo. 👇🤓
## Por que ambientes virtuais { #why-virtual-environments }
-Para trabalhar com o FastAPI, você precisa instalar o
Python.
+Para trabalhar com o FastAPI, você precisa instalar o [Python](https://www.python.org/).
Depois disso, você precisará **instalar** o FastAPI e quaisquer outros **pacotes** que queira usar.
@@ -564,7 +564,7 @@ $ pip install "fastapi[standard]"
-Isso fará o download de um arquivo compactado com o código FastAPI, normalmente do
PyPI.
+Isso fará o download de um arquivo compactado com o código FastAPI, normalmente do [PyPI](https://pypi.org/project/fastapi/).
Ele também fará o **download** de arquivos para outros pacotes dos quais o FastAPI depende.
@@ -627,7 +627,7 @@ $ .venv\Scripts\Activate.ps1
//// tab | Windows Bash
-Ou se você usa o Bash para Windows (por exemplo,
Git Bash):
+Ou se você usa o Bash para Windows (por exemplo, [Git Bash](https://gitforwindows.org/)):
@@ -639,13 +639,13 @@ $ source .venv/Scripts/activate
////
-Esse comando criará ou modificará algumas [variáveis de ambiente](environment-variables.md){.internal-link target=_blank} que estarão disponíveis para os próximos comandos.
+Esse comando criará ou modificará algumas [variáveis de ambiente](environment-variables.md) que estarão disponíveis para os próximos comandos.
Uma dessas variáveis é a variável `PATH`.
/// tip | Dica
-Você pode aprender mais sobre a variável de ambiente `PATH` na seção [Variáveis de ambiente](environment-variables.md#path-environment-variable){.internal-link target=_blank}.
+Você pode aprender mais sobre a variável de ambiente `PATH` na seção [Variáveis de ambiente](environment-variables.md#path-environment-variable).
///
@@ -846,7 +846,7 @@ Este é um guia simples para você começar e lhe ensinar como tudo funciona **p
Existem muitas **alternativas** para gerenciar ambientes virtuais, dependências de pacotes (requisitos) e projetos.
-Quando estiver pronto e quiser usar uma ferramenta para **gerenciar todo o projeto**, dependências de pacotes, ambientes virtuais, etc., sugiro que você experimente o
uv.
+Quando estiver pronto e quiser usar uma ferramenta para **gerenciar todo o projeto**, dependências de pacotes, ambientes virtuais, etc., sugiro que você experimente o [uv](https://github.com/astral-sh/uv).
`uv` pode fazer muitas coisas, ele pode:
diff --git a/docs/ru/docs/_llm-test.md b/docs/ru/docs/_llm-test.md
index 247d3a964f..dbb1a2b7fe 100644
--- a/docs/ru/docs/_llm-test.md
+++ b/docs/ru/docs/_llm-test.md
@@ -11,7 +11,7 @@
* Проверьте, всё ли в порядке в переводе.
* При необходимости улучшите ваш языковой специфичный промпт, общий промпт или английский документ.
* Затем вручную исправьте оставшиеся проблемы в переводе, чтобы он был хорошим.
-* Переведите заново, имея хороший перевод на месте. Идеальным результатом будет ситуация, когда LLM больше не вносит изменений в перевод. Это означает, что общий промпт и ваш языковой специфичный промпт настолько хороши, насколько это возможно (иногда он будет делать несколько, казалось бы, случайных изменений, причина в том, что
LLM — недетерминированные алгоритмы).
+* Переведите заново, имея хороший перевод на месте. Идеальным результатом будет ситуация, когда LLM больше не вносит изменений в перевод. Это означает, что общий промпт и ваш языковой специфичный промпт настолько хороши, насколько это возможно (иногда он будет делать несколько, казалось бы, случайных изменений, причина в том, что [LLM — недетерминированные алгоритмы](https://doublespeak.chat/#/handbook#deterministic-output)).
Тесты:
@@ -169,15 +169,15 @@ works(foo="bar") # Это работает 🎉
Текст ссылок должен переводиться, адрес ссылки не должен изменяться:
* [Ссылка на заголовок выше](#code-snippets)
-* [Внутренняя ссылка](index.md#installation){.internal-link target=_blank}
-*
Внешняя ссылка
-*
Ссылка на стиль
-*
Ссылка на скрипт
-*
Ссылка на изображение
+* [Внутренняя ссылка](index.md#installation)
+* [Внешняя ссылка](https://sqlmodel.tiangolo.com/)
+* [Ссылка на стиль](https://fastapi.tiangolo.com/css/styles.css)
+* [Ссылка на скрипт](https://fastapi.tiangolo.com/js/logic.js)
+* [Ссылка на изображение](https://fastapi.tiangolo.com/img/foo.jpg)
Текст ссылок должен переводиться, адрес ссылки должен указывать на перевод:
-*
Ссылка на FastAPI
+* [Ссылка на FastAPI](https://fastapi.tiangolo.com/ru/)
////
@@ -294,7 +294,7 @@ works(foo="bar") # Это работает 🎉
* чувствительный к регистру
* нечувствительный к регистру
-* обслуживать приложение
+* отдавать приложение
* отдавать страницу
* приложение
diff --git a/docs/ru/docs/advanced/additional-responses.md b/docs/ru/docs/advanced/additional-responses.md
index ca36ba20e3..f7e8d9dec0 100644
--- a/docs/ru/docs/advanced/additional-responses.md
+++ b/docs/ru/docs/advanced/additional-responses.md
@@ -243,5 +243,5 @@ new_dict = {**old_dict, "new key": "new value"}
Чтобы увидеть, что именно можно включать в ответы, посмотрите эти разделы спецификации OpenAPI:
-*
Объект Responses OpenAPI, он включает `Response Object`.
-*
Объект Response OpenAPI, вы можете включить всё из этого объекта напрямую в каждый ответ внутри вашего параметра `responses`. Включая `description`, `headers`, `content` (внутри него вы объявляете разные типы содержимого и JSON‑схемы) и `links`.
+* [Объект Responses OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object), он включает `Response Object`.
+* [Объект Response OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object), вы можете включить всё из этого объекта напрямую в каждый ответ внутри вашего параметра `responses`. Включая `description`, `headers`, `content` (внутри него вы объявляете разные типы содержимого и JSON‑схемы) и `links`.
diff --git a/docs/ru/docs/advanced/additional-status-codes.md b/docs/ru/docs/advanced/additional-status-codes.md
index 7c73cf5d5d..aec66a13ff 100644
--- a/docs/ru/docs/advanced/additional-status-codes.md
+++ b/docs/ru/docs/advanced/additional-status-codes.md
@@ -38,4 +38,4 @@
Если вы возвращаете дополнительные статус-коды и ответы напрямую, они не будут включены в схему OpenAPI (документацию API), потому что у FastAPI нет способа заранее знать, что вы собираетесь вернуть.
-Но вы можете задокументировать это в своём коде, используя: [Дополнительные ответы](additional-responses.md){.internal-link target=_blank}.
+Но вы можете задокументировать это в своём коде, используя: [Дополнительные ответы](additional-responses.md).
diff --git a/docs/ru/docs/advanced/advanced-dependencies.md b/docs/ru/docs/advanced/advanced-dependencies.md
index 686a0cf91e..fe37a79c1f 100644
--- a/docs/ru/docs/advanced/advanced-dependencies.md
+++ b/docs/ru/docs/advanced/advanced-dependencies.md
@@ -48,7 +48,7 @@
checker(q="somequery")
```
-…и передаст возвращённое значение как значение зависимости в параметр `fixed_content_included` нашей *функции-обработчика пути*:
+…и передаст возвращённое значение как значение зависимости в параметр `fixed_content_included` нашей *функции-обработчику пути*:
{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[22] *}
@@ -132,7 +132,7 @@ checker(q="somequery")
Так сессия освободит подключение к базе данных, и другие запросы смогут его использовать.
-Если у вас есть другой сценарий, где нужно раннее завершение зависимости с `yield`, пожалуйста, создайте
вопрос в GitHub Discussions с описанием конкретного кейса и почему вам было бы полезно иметь раннее закрытие для зависимостей с `yield`.
+Если у вас есть другой сценарий, где нужно раннее завершение зависимости с `yield`, пожалуйста, создайте [вопрос в GitHub Discussions](https://github.com/fastapi/fastapi/discussions/new?category=questions) с описанием конкретного кейса и почему вам было бы полезно иметь раннее закрытие для зависимостей с `yield`.
Если появятся веские причины для раннего закрытия в зависимостях с `yield`, я рассмотрю добавление нового способа опционально включать раннее закрытие.
@@ -144,7 +144,7 @@ checker(q="somequery")
### Фоновые задачи и зависимости с `yield`, технические детали { #background-tasks-and-dependencies-with-yield-technical-details }
-До FastAPI 0.106.0 вызывать исключения после `yield` было невозможно: код после `yield` в зависимостях выполнялся уже после отправки ответа, поэтому [Обработчики исключений](../tutorial/handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank} к тому моменту уже отработали.
+До FastAPI 0.106.0 вызывать исключения после `yield` было невозможно: код после `yield` в зависимостях выполнялся уже после отправки ответа, поэтому [Обработчики исключений](../tutorial/handling-errors.md#install-custom-exception-handlers) к тому моменту уже отработали.
Так было сделано в основном для того, чтобы можно было использовать те же объекты, «отданные» зависимостями через `yield`, внутри фоновых задач, потому что код после `yield` выполнялся после завершения фоновых задач.
diff --git a/docs/ru/docs/advanced/async-tests.md b/docs/ru/docs/advanced/async-tests.md
index 52939c2559..1c0b888cc9 100644
--- a/docs/ru/docs/advanced/async-tests.md
+++ b/docs/ru/docs/advanced/async-tests.md
@@ -16,11 +16,11 @@
Чтобы работать с асинхронным FastAPI приложением в ваших обычных тестовых функциях `def`, используя стандартный pytest, `TestClient` внутри себя делает некоторую магию. Но эта магия перестает работать, когда мы используем его внутри асинхронных функций. Запуская наши тесты асинхронно, мы больше не можем использовать `TestClient` внутри наших тестовых функций.
-`TestClient` основан на
HTTPX, и, к счастью, мы можем использовать его (`HTTPX`) напрямую для тестирования API.
+`TestClient` основан на [HTTPX](https://www.python-httpx.org), и, к счастью, мы можем использовать его (`HTTPX`) напрямую для тестирования API.
## Пример { #example }
-В качестве простого примера, давайте рассмотрим файловую структуру, схожую с описанной в [Большие приложения](../tutorial/bigger-applications.md){.internal-link target=_blank} и [Тестирование](../tutorial/testing.md){.internal-link target=_blank}:
+В качестве простого примера, давайте рассмотрим файловую структуру, схожую с описанной в [Большие приложения](../tutorial/bigger-applications.md) и [Тестирование](../tutorial/testing.md):
```
.
@@ -84,7 +84,7 @@ response = client.get('/')
/// warning | Внимание
-Если ваше приложение полагается на lifespan события, то `AsyncClient` не запустит эти события. Чтобы обеспечить их срабатывание используйте `LifespanManager` из
florimondmanca/asgi-lifespan.
+Если ваше приложение полагается на lifespan события, то `AsyncClient` не запустит эти события. Чтобы обеспечить их срабатывание используйте `LifespanManager` из [florimondmanca/asgi-lifespan](https://github.com/florimondmanca/asgi-lifespan#usage).
///
@@ -94,6 +94,6 @@ response = client.get('/')
/// tip | Подсказка
-Если вы столкнулись с `RuntimeError: Task attached to a different loop` при вызове асинхронных функций в ваших тестах (например, при использовании
MongoDB's MotorClient), то не забывайте инициализировать объекты, которым нужен цикл событий (event loop), только внутри асинхронных функций, например, в `@app.on_event("startup")` callback.
+Если вы столкнулись с `RuntimeError: Task attached to a different loop` при вызове асинхронных функций в ваших тестах (например, при использовании [MongoDB's MotorClient](https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop)), то не забывайте создавать экземпляры объектов, которым нужен цикл событий (event loop), только внутри асинхронных функций, например, в `@app.on_event("startup")` callback.
///
diff --git a/docs/ru/docs/advanced/behind-a-proxy.md b/docs/ru/docs/advanced/behind-a-proxy.md
index ec75ed3698..4f212868ad 100644
--- a/docs/ru/docs/advanced/behind-a-proxy.md
+++ b/docs/ru/docs/advanced/behind-a-proxy.md
@@ -16,9 +16,9 @@
Заголовки прокси:
-*
X-Forwarded-For
-*
X-Forwarded-Proto
-*
X-Forwarded-Host
+* [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For)
+* [X-Forwarded-Proto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto)
+* [X-Forwarded-Host](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host)
///
@@ -60,7 +60,7 @@ https://mysuperapp.com/items/
/// tip | Совет
-Если хотите узнать больше об HTTPS, смотрите руководство [О HTTPS](../deployment/https.md){.internal-link target=_blank}.
+Если хотите узнать больше об HTTPS, смотрите руководство [О HTTPS](../deployment/https.md).
///
@@ -228,7 +228,7 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
Учтите, что сервер (Uvicorn) не использует `root_path` ни для чего, кроме как передать его в приложение.
-Если вы откроете в браузере
http://127.0.0.1:8000/app, вы увидите обычный ответ:
+Если вы откроете в браузере [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app), вы увидите обычный ответ:
```JSON
{
@@ -251,9 +251,9 @@ Uvicorn ожидает, что прокси обратится к нему по
## Локальное тестирование с Traefik { #testing-locally-with-traefik }
-Вы можете легко поэкспериментировать локально с функцией удаления префикса пути, используя
Traefik.
+Вы можете легко поэкспериментировать локально с функцией удаления префикса пути, используя [Traefik](https://docs.traefik.io/).
-
Скачайте Traefik — это один бинарный файл; распакуйте архив и запустите его прямо из терминала.
+[Скачайте Traefik](https://github.com/containous/traefik/releases) — это один бинарный файл; распакуйте архив и запустите его прямо из терминала.
Затем создайте файл `traefik.toml` со следующим содержимым:
@@ -330,7 +330,7 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
### Проверьте ответы { #check-the-responses }
-Теперь, если вы перейдёте на URL с портом Uvicorn:
http://127.0.0.1:8000/app, вы увидите обычный ответ:
+Теперь, если вы перейдёте на URL с портом Uvicorn: [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app), вы увидите обычный ответ:
```JSON
{
@@ -345,7 +345,7 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
///
-А теперь откройте URL с портом Traefik и префиксом пути:
http://127.0.0.1:9999/api/v1/app.
+А теперь откройте URL с портом Traefik и префиксом пути: [http://127.0.0.1:9999/api/v1/app](http://127.0.0.1:9999/api/v1/app).
Мы получим тот же ответ:
@@ -370,13 +370,13 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
«Официальный» способ доступа к приложению — через прокси с заданным префиксом пути. Поэтому, как и ожидается, если открыть интерфейс документации, отдаваемый напрямую Uvicorn, без префикса пути в URL, он не будет работать, так как предполагается доступ через прокси.
-Проверьте по адресу
http://127.0.0.1:8000/docs:
+Проверьте по адресу [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs):
А вот если открыть интерфейс документации по «официальному» URL через прокси на порту `9999`, по `/api/v1/docs`, всё работает корректно! 🎉
-Проверьте по адресу
http://127.0.0.1:9999/api/v1/docs:
+Проверьте по адресу [http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs):
@@ -433,7 +433,7 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
///
-В интерфейсе документации по адресу
http://127.0.0.1:9999/api/v1/docs это будет выглядеть так:
+В интерфейсе документации по адресу [http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs) это будет выглядеть так:
@@ -461,6 +461,6 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
## Монтирование вложенного приложения { #mounting-a-sub-application }
-Если вам нужно смонтировать вложенное приложение (как описано в [Вложенные приложения — монтирование](sub-applications.md){.internal-link target=_blank}), и при этом вы используете прокси с `root_path`, делайте это обычным образом — всё будет работать, как ожидается.
+Если вам нужно смонтировать вложенное приложение (как описано в [Вложенные приложения — монтирование](sub-applications.md)), и при этом вы используете прокси с `root_path`, делайте это обычным образом — всё будет работать, как ожидается.
FastAPI умно использует `root_path` внутри, так что всё просто работает. ✨
diff --git a/docs/ru/docs/advanced/custom-response.md b/docs/ru/docs/advanced/custom-response.md
index b9f91373da..fdfe2c5498 100644
--- a/docs/ru/docs/advanced/custom-response.md
+++ b/docs/ru/docs/advanced/custom-response.md
@@ -1,52 +1,36 @@
# Кастомные ответы — HTML, поток, файл и другие { #custom-response-html-stream-file-others }
-По умолчанию **FastAPI** возвращает ответы с помощью `JSONResponse`.
+По умолчанию **FastAPI** возвращает ответы в формате JSON.
-Вы можете переопределить это, вернув `Response` напрямую, как показано в разделе [Вернуть Response напрямую](response-directly.md){.internal-link target=_blank}.
+Вы можете переопределить это, вернув `Response` напрямую, как показано в разделе [Вернуть Response напрямую](response-directly.md).
Но если вы возвращаете `Response` напрямую (или любой его подкласс, например `JSONResponse`), данные не будут автоматически преобразованы (даже если вы объявили `response_model`), и документация не будет автоматически сгенерирована (например, со специфичным «типом содержимого» в HTTP-заголовке `Content-Type` как частью сгенерированного OpenAPI).
-Но вы можете также объявить `Response`, который хотите использовать (например, любой подкласс `Response`), в декораторе операции пути, используя параметр `response_class`.
+Но вы также можете объявить `Response`, который хотите использовать (например, любой подкласс `Response`), в декораторе операции пути, указав параметр `response_class`.
Содержимое, которое вы возвращаете из своей функции-обработчика пути, будет помещено внутрь этого `Response`.
-И если у этого `Response` тип содержимого JSON (`application/json`), как в случае с `JSONResponse` и `UJSONResponse`, данные, которые вы возвращаете, будут автоматически преобразованы (и отфильтрованы) любым объявленным вами в декораторе операции пути Pydantic `response_model`.
-
/// note | Примечание
Если вы используете класс ответа без типа содержимого, FastAPI будет ожидать, что у вашего ответа нет содержимого, поэтому он не будет документировать формат ответа в сгенерированной документации OpenAPI.
///
-## Используйте `ORJSONResponse` { #use-orjsonresponse }
-
-Например, если вы выжимаете максимум производительности, вы можете установить и использовать
`orjson` и задать ответ как `ORJSONResponse`.
-
-Импортируйте класс (подкласс) `Response`, который вы хотите использовать, и объявите его в декораторе операции пути.
-
-Для больших ответов возвращать `Response` напрямую значительно быстрее, чем возвращать словарь.
-
-Это потому, что по умолчанию FastAPI проверяет каждый элемент внутри и убеждается, что он сериализуем в JSON, используя тот же [JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank}, объяснённый в руководстве. Это позволяет возвращать **произвольные объекты**, например модели из базы данных.
-
-Но если вы уверены, что содержимое, которое вы возвращаете, **сериализуемо в JSON**, вы можете передать его напрямую в класс ответа и избежать дополнительных накладных расходов, которые FastAPI понёс бы, пропуская возвращаемое содержимое через `jsonable_encoder` перед передачей в класс ответа.
+## JSON-ответы { #json-responses }
-{* ../../docs_src/custom_response/tutorial001b_py310.py hl[2,7] *}
+По умолчанию FastAPI возвращает ответы в формате JSON.
-/// info | Информация
-
-Параметр `response_class` также используется для указания «типа содержимого» ответа.
+Если вы объявите [Модель ответа](../tutorial/response-model.md), FastAPI использует её для сериализации данных в JSON с помощью Pydantic.
-В этом случае HTTP-заголовок `Content-Type` будет установлен в `application/json`.
+Если вы не объявите модель ответа, FastAPI использует `jsonable_encoder`, описанный в разделе [JSON-совместимый энкодер](../tutorial/encoder.md), и поместит результат в `JSONResponse`.
-И это будет задокументировано как таковое в OpenAPI.
+Если вы объявите `response_class` с JSON типом содержимого (`application/json`), как в случае с `JSONResponse`, данные, которые вы возвращаете, будут автоматически преобразованы (и отфильтрованы) любой Pydantic-моделью ответа (`response_model`), объявленной вами в декораторе операции пути. Но данные не будут сериализованы в JSON-байты через Pydantic; вместо этого они будут преобразованы с помощью `jsonable_encoder`, а затем переданы в класс `JSONResponse`, который сериализует их в байты, используя стандартную JSON-библиотеку Python.
-///
+### Производительность JSON { #json-performance }
-/// tip | Совет
+Коротко: если вам нужна максимальная производительность, используйте [Модель ответа](../tutorial/response-model.md) и не объявляйте `response_class` в декораторе операции пути.
-`ORJSONResponse` доступен только в FastAPI, а не в Starlette.
-
-///
+{* ../../docs_src/response_model/tutorial001_01_py310.py ln[15:17] hl[16] *}
## HTML-ответ { #html-response }
@@ -69,7 +53,7 @@
### Вернуть `Response` { #return-a-response }
-Как показано в разделе [Вернуть Response напрямую](response-directly.md){.internal-link target=_blank}, вы также можете переопределить ответ прямо в своей операции пути, просто вернув его.
+Как показано в разделе [Вернуть Response напрямую](response-directly.md), вы также можете переопределить ответ прямо в своей операции пути, просто вернув его.
Тот же пример сверху, возвращающий `HTMLResponse`, может выглядеть так:
@@ -154,37 +138,11 @@ FastAPI (фактически Starlette) автоматически добави
Это ответ по умолчанию, используемый в **FastAPI**, как было сказано выше.
-### `ORJSONResponse` { #orjsonresponse }
-
-Быстрая альтернативная реализация JSON-ответа с использованием
`orjson`, как было сказано выше.
-
-/// info | Информация
-
-Требуется установка `orjson`, например командой `pip install orjson`.
-
-///
-
-### `UJSONResponse` { #ujsonresponse }
-
-Альтернативная реализация JSON-ответа с использованием
`ujson`.
-
-/// info | Информация
-
-Требуется установка `ujson`, например командой `pip install ujson`.
-
-///
-
-/// warning | Предупреждение
-
-`ujson` менее аккуратен, чем встроенная реализация Python, в обработке некоторых крайних случаев.
-
-///
-
-{* ../../docs_src/custom_response/tutorial001_py310.py hl[2,7] *}
+/// note | Технические детали
-/// tip | Совет
+Но если вы объявите модель ответа или тип возвращаемого значения, они будут использованы напрямую для сериализации данных в JSON, и ответ с корректным типом содержимого для JSON будет возвращён напрямую, без использования класса `JSONResponse`.
-Возможно, `ORJSONResponse` окажется более быстрым вариантом.
+Это идеальный способ получить наилучшую производительность.
///
@@ -214,31 +172,25 @@ FastAPI (фактически Starlette) автоматически добави
### `StreamingResponse` { #streamingresponse }
-Принимает асинхронный генератор или обычный генератор/итератор и отправляет тело ответа потоково.
-
-{* ../../docs_src/custom_response/tutorial007_py310.py hl[2,14] *}
-
-#### Использование `StreamingResponse` с файлоподобными объектами { #using-streamingresponse-with-file-like-objects }
+Принимает асинхронный генератор или обычный генератор/итератор (функцию с `yield`) и отправляет тело ответа потоково.
-Если у вас есть
файлоподобный объект (например, объект, возвращаемый `open()`), вы можете создать функцию-генератор для итерации по этому файлоподобному объекту.
+{* ../../docs_src/custom_response/tutorial007_py310.py hl[3,16] *}
-Таким образом, вам не нужно сначала читать всё в память, вы можете передать эту функцию-генератор в `StreamingResponse` и вернуть его.
-
-Это включает многие библиотеки для работы с облачным хранилищем, обработки видео и т.д.
+/// note | Технические детали
-{* ../../docs_src/custom_response/tutorial008_py310.py hl[2,10:12,14] *}
+Задача `async` может быть отменена только при достижении `await`. Если `await` отсутствует, генератор (функция с `yield`) не может быть корректно отменён и может продолжить работу даже после запроса на отмену.
-1. Это функция-генератор. Она является «функцией-генератором», потому что содержит оператор(ы) `yield` внутри.
-2. Используя блок `with`, мы гарантируем, что файлоподобный объект будет закрыт после завершения работы функции-генератора. То есть после того, как она закончит отправку ответа.
-3. Этот `yield from` говорит функции итерироваться по объекту с именем `file_like`. И затем, для каждой итерации, отдавать эту часть как исходящую из этой функции-генератора (`iterfile`).
+Так как этому небольшому примеру не нужны операторы `await`, мы добавляем `await anyio.sleep(0)`, чтобы дать циклу событий возможность обработать отмену.
- Таким образом, это функция-генератор, которая внутренне передаёт работу по «генерации» чему-то другому.
+Это ещё более важно для больших или бесконечных потоков.
- Делая это таким образом, мы можем поместить её в блок `with` и тем самым гарантировать, что файлоподобный объект будет закрыт после завершения.
+///
/// tip | Совет
-Заметьте, что здесь мы используем стандартный `open()`, который не поддерживает `async` и `await`, поэтому объявляем операцию пути обычной `def`.
+Вместо того чтобы возвращать `StreamingResponse` напрямую, вероятно, лучше следовать стилю из раздела [Передача данных потоком](./stream-data.md) - так гораздо удобнее, и отмена обрабатывается «за кулисами».
+
+Если вы передаёте JSON Lines потоком, следуйте руководству [Поток JSON Lines](../tutorial/stream-json-lines.md).
///
@@ -267,7 +219,7 @@ FastAPI (фактически Starlette) автоматически добави
Вы можете создать собственный класс ответа, унаследовавшись от `Response`, и использовать его.
-Например, предположим, что вы хотите использовать
`orjson`, но с некоторыми пользовательскими настройками, которые не используются во встроенном классе `ORJSONResponse`.
+Например, предположим, что вы хотите использовать [`orjson`](https://github.com/ijl/orjson) с некоторыми настройками.
Скажем, вы хотите, чтобы возвращался отформатированный JSON с отступами, то есть хотите использовать опцию orjson `orjson.OPT_INDENT_2`.
@@ -291,13 +243,21 @@ FastAPI (фактически Starlette) автоматически добави
Разумеется, вы наверняка найдёте гораздо более полезные способы воспользоваться этим, чем просто форматирование JSON. 😉
+### `orjson` или Модель ответа { #orjson-or-response-model }
+
+Если вы стремитесь увеличить производительность, вероятно, лучше использовать [Модель ответа](../tutorial/response-model.md), чем ответ на базе `orjson`.
+
+С моделью ответа FastAPI использует Pydantic для сериализации данных в JSON, без промежуточных шагов, таких как преобразование через `jsonable_encoder`, которое происходило бы в любом другом случае.
+
+А под капотом Pydantic использует те же базовые механизмы на Rust, что и `orjson`, для сериализации в JSON, так что с моделью ответа вы и так получите лучшую производительность.
+
## Класс ответа по умолчанию { #default-response-class }
При создании экземпляра класса **FastAPI** или `APIRouter` вы можете указать, какой класс ответа использовать по умолчанию.
Параметр, который это определяет, — `default_response_class`.
-В примере ниже **FastAPI** будет использовать `ORJSONResponse` по умолчанию во всех операциях пути вместо `JSONResponse`.
+В примере ниже **FastAPI** будет использовать `HTMLResponse` по умолчанию во всех операциях пути, вместо JSON.
{* ../../docs_src/custom_response/tutorial010_py310.py hl[2,4] *}
@@ -309,4 +269,4 @@ FastAPI (фактически Starlette) автоматически добави
## Дополнительная документация { #additional-documentation }
-Вы также можете объявить тип содержимого и многие другие детали в OpenAPI с помощью `responses`: [Дополнительные ответы в OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Вы также можете объявить тип содержимого и многие другие детали в OpenAPI с помощью `responses`: [Дополнительные ответы в OpenAPI](additional-responses.md).
diff --git a/docs/ru/docs/advanced/dataclasses.md b/docs/ru/docs/advanced/dataclasses.md
index 87a5763c10..f9f8689b04 100644
--- a/docs/ru/docs/advanced/dataclasses.md
+++ b/docs/ru/docs/advanced/dataclasses.md
@@ -2,11 +2,11 @@
FastAPI построен поверх **Pydantic**, и я показывал вам, как использовать Pydantic-модели для объявления HTTP-запросов и HTTP-ответов.
-Но FastAPI также поддерживает использование
`dataclasses` тем же способом:
+Но FastAPI также поддерживает использование [`dataclasses`](https://docs.python.org/3/library/dataclasses.html) тем же способом:
{* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}
-Это по-прежнему поддерживается благодаря **Pydantic**, так как в нём есть
встроенная поддержка `dataclasses`.
+Это по-прежнему поддерживается благодаря **Pydantic**, так как в нём есть [встроенная поддержка `dataclasses`](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel).
Так что даже если в коде выше Pydantic не используется явно, FastAPI использует Pydantic, чтобы конвертировать стандартные dataclasses в собственный вариант dataclasses от Pydantic.
@@ -74,7 +74,7 @@ FastAPI построен поверх **Pydantic**, и я показывал в
Как и всегда в FastAPI, вы можете сочетать `def` и `async def` по необходимости.
- Если хотите освежить в памяти, когда что использовать, посмотрите раздел _"Нет времени?"_ в документации про [`async` и `await`](../async.md#in-a-hurry){.internal-link target=_blank}.
+ Если хотите освежить в памяти, когда что использовать, посмотрите раздел _"Нет времени?"_ в документации про [`async` и `await`](../async.md#in-a-hurry).
9. Эта *функция-обработчик пути* возвращает не dataclasses (хотя могла бы), а список словарей с внутренними данными.
@@ -88,7 +88,7 @@ FastAPI построен поверх **Pydantic**, и я показывал в
Вы также можете комбинировать `dataclasses` с другими Pydantic-моделями, наследоваться от них, включать их в свои модели и т.д.
-Чтобы узнать больше, посмотрите
документацию Pydantic о dataclasses.
+Чтобы узнать больше, посмотрите [документацию Pydantic о dataclasses](https://docs.pydantic.dev/latest/concepts/dataclasses/).
## Версия { #version }
diff --git a/docs/ru/docs/advanced/events.md b/docs/ru/docs/advanced/events.md
index bcb5b000a4..464bba93e9 100644
--- a/docs/ru/docs/advanced/events.md
+++ b/docs/ru/docs/advanced/events.md
@@ -150,11 +150,11 @@ async with lifespan(app):
Немного технических подробностей для любопытных умников. 🤓
-Под капотом, в ASGI-технической спецификации, это часть
Протокола Lifespan, и он определяет события `startup` и `shutdown`.
+Под капотом, в ASGI-технической спецификации, это часть [Протокола Lifespan](https://asgi.readthedocs.io/en/latest/specs/lifespan.html), и он определяет события `startup` и `shutdown`.
/// info | Информация
-Вы можете прочитать больше про обработчики `lifespan` в Starlette в
документации Starlette по Lifespan.
+Вы можете прочитать больше про обработчики `lifespan` в Starlette в [документации Starlette по Lifespan](https://www.starlette.dev/lifespan/).
Включая то, как работать с состоянием lifespan, которое можно использовать в других частях вашего кода.
@@ -162,4 +162,4 @@ async with lifespan(app):
## Подприложения { #sub-applications }
-🚨 Имейте в виду, что эти события lifespan (startup и shutdown) будут выполнены только для основного приложения, а не для [Подприложения — Mounts](sub-applications.md){.internal-link target=_blank}.
+🚨 Имейте в виду, что эти события lifespan (startup и shutdown) будут выполнены только для основного приложения, а не для [Подприложения — Mounts](sub-applications.md).
diff --git a/docs/ru/docs/advanced/generate-clients.md b/docs/ru/docs/advanced/generate-clients.md
index 4eb098a88f..75bd7c47c4 100644
--- a/docs/ru/docs/advanced/generate-clients.md
+++ b/docs/ru/docs/advanced/generate-clients.md
@@ -8,11 +8,11 @@
## Генераторы SDK с открытым исходным кодом { #open-source-sdk-generators }
-Гибкий вариант —
OpenAPI Generator, который поддерживает **многие языки программирования** и умеет генерировать SDK из вашей спецификации OpenAPI.
+Гибкий вариант — [OpenAPI Generator](https://openapi-generator.tech/), который поддерживает **многие языки программирования** и умеет генерировать SDK из вашей спецификации OpenAPI.
-Для **TypeScript‑клиентов**
Hey API — специализированное решение, обеспечивающее оптимальный опыт для экосистемы TypeScript.
+Для **TypeScript‑клиентов** [Hey API](https://heyapi.dev/) — специализированное решение, обеспечивающее оптимальный опыт для экосистемы TypeScript.
-Больше генераторов SDK можно найти на
OpenAPI.Tools.
+Больше генераторов SDK можно найти на [OpenAPI.Tools](https://openapi.tools/#sdk).
/// tip | Совет
@@ -24,15 +24,15 @@ FastAPI автоматически генерирует спецификации
В этом разделе представлены решения с **венчурной поддержкой** и **поддержкой компаний** от компаний, которые спонсируют FastAPI. Эти продукты предоставляют **дополнительные возможности** и **интеграции** сверх высококачественно генерируемых SDK.
-Благодаря ✨ [**спонсорству FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨ эти компании помогают обеспечивать, чтобы фреймворк и его **экосистема** оставались здоровыми и **устойчивыми**.
+Благодаря ✨ [**спонсорству FastAPI**](../help-fastapi.md#sponsor-the-author) ✨ эти компании помогают обеспечивать, чтобы фреймворк и его **экосистема** оставались здоровыми и **устойчивыми**.
Их спонсорство также демонстрирует серьёзную приверженность **сообществу** FastAPI (вам), показывая, что им важно не только предоставлять **отличный сервис**, но и поддерживать **надёжный и процветающий фреймворк** FastAPI. 🙇
Например, вы можете попробовать:
-*
Speakeasy
-*
Stainless
-*
liblab
+* [Speakeasy](https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship)
+* [Stainless](https://www.stainless.com/?utm_source=fastapi&utm_medium=referral)
+* [liblab](https://developers.liblab.com/tutorials/sdk-for-fastapi?utm_source=fastapi)
Некоторые из этих решений также могут быть open source или иметь бесплатные тарифы, так что вы сможете попробовать их без финансовых затрат. Другие коммерческие генераторы SDK доступны и их можно найти онлайн. 🤓
@@ -66,11 +66,11 @@ npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
Это сгенерирует TypeScript SDK в `./src/client`.
-Вы можете узнать, как
установить `@hey-api/openapi-ts` и почитать о
сгенерированном результате на их сайте.
+Вы можете узнать, как [установить `@hey-api/openapi-ts`](https://heyapi.dev/openapi-ts/get-started) и почитать о [сгенерированном результате](https://heyapi.dev/openapi-ts/output) на их сайте.
### Использование SDK { #using-the-sdk }
-Теперь вы можете импортировать и использовать клиентский код. Это может выглядеть так, обратите внимание, что вы получаете автозавершение для методoв:
+Теперь вы можете импортировать и использовать клиентский код. Это может выглядеть так, обратите внимание, что вы получаете автозавершение для методов:
diff --git a/docs/ru/docs/advanced/index.md b/docs/ru/docs/advanced/index.md
index c0a52c6c14..6cb92dd004 100644
--- a/docs/ru/docs/advanced/index.md
+++ b/docs/ru/docs/advanced/index.md
@@ -2,7 +2,7 @@
## Дополнительные возможности { #additional-features }
-Основное [Учебник - Руководство пользователя](../tutorial/index.md){.internal-link target=_blank} должно быть достаточно, чтобы познакомить вас со всеми основными функциями **FastAPI**.
+Основное [Учебник - Руководство пользователя](../tutorial/index.md) должно быть достаточно, чтобы познакомить вас со всеми основными функциями **FastAPI**.
В следующих разделах вы увидите другие варианты, конфигурации и дополнительные возможности.
@@ -16,6 +16,6 @@
## Сначала прочитайте Учебник - Руководство пользователя { #read-the-tutorial-first }
-Вы все еще можете использовать большинство функций **FastAPI** со знаниями из [Учебник - Руководство пользователя](../tutorial/index.md){.internal-link target=_blank}.
+Вы все еще можете использовать большинство функций **FastAPI** со знаниями из [Учебник - Руководство пользователя](../tutorial/index.md).
И следующие разделы предполагают, что вы уже прочитали его, и предполагают, что вы знаете эти основные идеи.
diff --git a/docs/ru/docs/advanced/json-base64-bytes.md b/docs/ru/docs/advanced/json-base64-bytes.md
new file mode 100644
index 0000000000..390dd17fa1
--- /dev/null
+++ b/docs/ru/docs/advanced/json-base64-bytes.md
@@ -0,0 +1,63 @@
+# JSON с байтами в Base64 { #json-with-bytes-as-base64 }
+
+Если вашему приложению нужно принимать и отправлять JSON-данные, но при этом необходимо включать в них бинарные данные, вы можете кодировать их в base64.
+
+## Base64 и файлы { #base64-vs-files }
+
+Сначала рассмотрите возможность использовать [Файлы в запросе](../tutorial/request-files.md) для загрузки бинарных данных и [Пользовательский HTTP-ответ — FileResponse](./custom-response.md#fileresponse--fileresponse-) для отправки бинарных данных вместо кодирования их в JSON.
+
+JSON может содержать только строки в кодировке UTF-8, поэтому он не может содержать «сырые» байты.
+
+Base64 может кодировать бинарные данные в строки, но для этого используется больше символов, чем в исходных бинарных данных, поэтому обычно это менее эффективно, чем обычные файлы.
+
+Используйте base64 только если вам действительно нужно включать бинарные данные в JSON и вы не можете использовать файлы для этого.
+
+## Pydantic `bytes` { #pydantic-bytes }
+
+Вы можете объявить Pydantic-модель с полями `bytes`, а затем использовать `val_json_bytes` в конфиге модели, чтобы указать использовать base64 для валидации входящих JSON-данных; как часть этой валидации строка base64 будет декодирована в байты.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
+
+Если вы откроете `/docs`, вы увидите, что поле `data` ожидает байты, закодированные в base64:
+
+
+
+
+
+Вы можете отправить такой HTTP-запрос:
+
+```json
+{
+ "description": "Some data",
+ "data": "aGVsbG8="
+}
+```
+
+/// tip | Совет
+
+`aGVsbG8=` — это base64-кодирование строки `hello`.
+
+///
+
+Затем Pydantic декодирует строку base64 и передаст вам исходные байты в поле `data` модели.
+
+Вы получите такой HTTP-ответ:
+
+```json
+{
+ "description": "Some data",
+ "content": "hello"
+}
+```
+
+## Pydantic `bytes` для выходных данных { #pydantic-bytes-for-output-data }
+
+Вы также можете использовать поля `bytes` с `ser_json_bytes` в конфиге модели для выходных данных, и Pydantic будет сериализовать байты в base64 при формировании JSON-ответа.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,12:16,29,38:41] hl[16] *}
+
+## Pydantic `bytes` для входных и выходных данных { #pydantic-bytes-for-input-and-output-data }
+
+И, конечно, вы можете использовать одну и ту же модель, настроенную на использование base64, чтобы обрабатывать и входящие данные (валидация) с `val_json_bytes`, и исходящие данные (сериализация) с `ser_json_bytes` при приеме и отправке JSON-данных.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,19:26,29,44:46] hl[23:26] *}
diff --git a/docs/ru/docs/advanced/middleware.md b/docs/ru/docs/advanced/middleware.md
index 1f1a160604..805866499c 100644
--- a/docs/ru/docs/advanced/middleware.md
+++ b/docs/ru/docs/advanced/middleware.md
@@ -1,8 +1,8 @@
# Расширенное использование middleware { #advanced-middleware }
-В основном руководстве вы читали, как добавить [пользовательское middleware](../tutorial/middleware.md){.internal-link target=_blank} в ваше приложение.
+В основном руководстве вы читали, как добавить [пользовательское middleware](../tutorial/middleware.md) в ваше приложение.
-А затем — как работать с [CORS с помощью `CORSMiddleware`](../tutorial/cors.md){.internal-link target=_blank}.
+А затем — как работать с [CORS с помощью `CORSMiddleware`](../tutorial/cors.md).
В этом разделе посмотрим, как использовать другие middleware.
@@ -91,7 +91,7 @@ app.add_middleware(UnicornMiddleware, some_config="rainbow")
Например:
--
`ProxyHeadersMiddleware` от Uvicorn
--
MessagePack
+- [`ProxyHeadersMiddleware` от Uvicorn](https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py)
+- [MessagePack](https://github.com/florimondmanca/msgpack-asgi)
-Чтобы увидеть другие доступные middleware, посмотрите
документацию по middleware в Starlette и
список ASGI Awesome.
+Чтобы увидеть другие доступные middleware, посмотрите [документацию по middleware в Starlette](https://www.starlette.dev/middleware/) и [список ASGI Awesome](https://github.com/florimondmanca/awesome-asgi).
diff --git a/docs/ru/docs/advanced/openapi-callbacks.md b/docs/ru/docs/advanced/openapi-callbacks.md
index de7e283017..3d791de2c6 100644
--- a/docs/ru/docs/advanced/openapi-callbacks.md
+++ b/docs/ru/docs/advanced/openapi-callbacks.md
@@ -35,7 +35,7 @@
/// tip | Совет
-Query-параметр `callback_url` использует тип Pydantic
Url.
+Query-параметр `callback_url` использует тип Pydantic [Url](https://docs.pydantic.dev/latest/api/networks/).
///
@@ -66,7 +66,7 @@ httpx.post(callback_url, json={"description": "Invoice paid", "paid": True})
Сам обратный вызов — это всего лишь HTTP-запрос.
-Реализуя обратный вызов, вы можете использовать, например,
HTTPX или
Requests.
+Реализуя обратный вызов, вы можете использовать, например, [HTTPX](https://www.python-httpx.org) или [Requests](https://requests.readthedocs.io/).
///
@@ -106,11 +106,11 @@ httpx.post(callback_url, json={"description": "Invoice paid", "paid": True})
Есть 2 основных отличия от обычной *операции пути*:
* Ей не нужен реальный код, потому что ваше приложение никогда не будет вызывать эту функцию. Она используется только для документирования *внешнего API*. Поэтому в функции может быть просто `pass`.
-* *Путь* может содержать
выражение OpenAPI 3 (подробнее ниже), где можно использовать переменные с параметрами и части исходного HTTP-запроса, отправленного *вашему API*.
+* *Путь* может содержать [выражение OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) (подробнее ниже), где можно использовать переменные с параметрами и части исходного HTTP-запроса, отправленного *вашему API*.
### Выражение пути для обратного вызова { #the-callback-path-expression }
-*Путь* обратного вызова может содержать
выражение OpenAPI 3, которое может включать части исходного запроса, отправленного *вашему API*.
+*Путь* обратного вызова может содержать [выражение OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression), которое может включать части исходного запроса, отправленного *вашему API*.
В нашем случае это `str`:
@@ -179,7 +179,7 @@ https://www.external.org/events/invoices/2expen51ve
### Проверьте документацию { #check-the-docs }
-Теперь вы можете запустить приложение и перейти по адресу
http://127.0.0.1:8000/docs.
+Теперь вы можете запустить приложение и перейти по адресу [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Вы увидите документацию, включающую раздел «Callbacks» для вашей *операции пути*, который показывает, как должен выглядеть *внешний API*:
diff --git a/docs/ru/docs/advanced/openapi-webhooks.md b/docs/ru/docs/advanced/openapi-webhooks.md
index b477075c11..9b1988ff31 100644
--- a/docs/ru/docs/advanced/openapi-webhooks.md
+++ b/docs/ru/docs/advanced/openapi-webhooks.md
@@ -10,7 +10,7 @@
Обычно процесс таков: вы определяете в своем коде, какое сообщение вы будете отправлять, то есть тело запроса.
-Вы также определяете, в какие моменты (при каких событиях) ваше приложение будет отправлять эти запросы.
+Вы также определяете, в какие моменты (при каких событиях) ваше приложение будет отправлять эти запросы (события).
А ваши пользователи каким-то образом (например, в веб‑панели) указывают URL-адрес, на который ваше приложение должно отправлять эти запросы.
@@ -48,7 +48,7 @@
### Посмотрите документацию { #check-the-docs }
-Теперь вы можете запустить приложение и перейти по ссылке
http://127.0.0.1:8000/docs.
+Теперь вы можете запустить приложение и перейти по ссылке [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Вы увидите, что в документации есть обычные операции пути, а также появились вебхуки:
diff --git a/docs/ru/docs/advanced/path-operation-advanced-configuration.md b/docs/ru/docs/advanced/path-operation-advanced-configuration.md
index b8c879bf6f..fe2996362b 100644
--- a/docs/ru/docs/advanced/path-operation-advanced-configuration.md
+++ b/docs/ru/docs/advanced/path-operation-advanced-configuration.md
@@ -60,7 +60,7 @@
Также можно объявлять дополнительные ответы с их моделями, статус-кодами и т.д.
-В документации есть целая глава об этом — [Дополнительные ответы в OpenAPI](additional-responses.md){.internal-link target=_blank}.
+В документации есть целая глава об этом — [Дополнительные ответы в OpenAPI](additional-responses.md).
## Дополнительные данные OpenAPI { #openapi-extra }
@@ -68,7 +68,7 @@
/// note | Технические детали
-В спецификации OpenAPI это называется
Объект операции.
+В спецификации OpenAPI это называется [Объект операции](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object).
///
@@ -82,7 +82,7 @@
Это низкоуровневая возможность расширения.
-Если вам нужно лишь объявить дополнительные ответы, удобнее сделать это через [Дополнительные ответы в OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Если вам нужно лишь объявить дополнительные ответы, удобнее сделать это через [Дополнительные ответы в OpenAPI](additional-responses.md).
///
diff --git a/docs/ru/docs/advanced/response-change-status-code.md b/docs/ru/docs/advanced/response-change-status-code.md
index 273862bae9..3dd0c9446e 100644
--- a/docs/ru/docs/advanced/response-change-status-code.md
+++ b/docs/ru/docs/advanced/response-change-status-code.md
@@ -1,6 +1,6 @@
# Response - Изменение статус-кода { #response-change-status-code }
-Вы, вероятно, уже читали о том, что можно установить [статус-код ответа по умолчанию](../tutorial/response-status-code.md){.internal-link target=_blank}.
+Вы, вероятно, уже читали о том, что можно установить [статус-код ответа по умолчанию](../tutorial/response-status-code.md).
Но в некоторых случаях нужно вернуть другой статус-код, отличный от значения по умолчанию.
diff --git a/docs/ru/docs/advanced/response-cookies.md b/docs/ru/docs/advanced/response-cookies.md
index d3662ef8ed..2adc1af85a 100644
--- a/docs/ru/docs/advanced/response-cookies.md
+++ b/docs/ru/docs/advanced/response-cookies.md
@@ -20,7 +20,7 @@
Вы также можете установить Cookies, если возвращаете `Response` напрямую в вашем коде.
-Для этого создайте объект `Response`, как описано в разделе [Возвращение ответа напрямую](response-directly.md){.internal-link target=_blank}.
+Для этого создайте объект `Response`, как описано в разделе [Возвращение ответа напрямую](response-directly.md).
Затем установите cookies и верните этот объект:
@@ -48,4 +48,4 @@
///
-Чтобы увидеть все доступные параметры и настройки, ознакомьтесь с
документацией Starlette.
+Чтобы увидеть все доступные параметры и настройки, ознакомьтесь с [документацией Starlette](https://www.starlette.dev/responses/#set-cookie).
diff --git a/docs/ru/docs/advanced/response-directly.md b/docs/ru/docs/advanced/response-directly.md
index 60facdd857..fcb8d533db 100644
--- a/docs/ru/docs/advanced/response-directly.md
+++ b/docs/ru/docs/advanced/response-directly.md
@@ -2,19 +2,23 @@
Когда вы создаёте **FastAPI** *операцию пути*, вы можете возвращать из неё любые данные: `dict`, `list`, Pydantic-модель, модель базы данных и т.д.
-По умолчанию **FastAPI** автоматически преобразует возвращаемое значение в JSON с помощью `jsonable_encoder`, как описано в [JSON кодировщик](../tutorial/encoder.md){.internal-link target=_blank}.
+Если вы объявите [Модель ответа](../tutorial/response-model.md), FastAPI будет использовать её для сериализации данных в JSON с помощью Pydantic.
-Затем "под капотом" эти данные, совместимые с JSON (например `dict`), помещаются в `JSONResponse`, который используется для отправки ответа клиенту.
+Если вы не объявите модель ответа, FastAPI использует `jsonable_encoder`, как описано в [JSON кодировщик](../tutorial/encoder.md), и поместит результат в `JSONResponse`.
-Но вы можете возвращать `JSONResponse` напрямую из ваших *операций пути*.
+Также вы можете создать `JSONResponse` напрямую и вернуть его.
-Это может быть полезно, например, если нужно вернуть пользовательские HTTP-заголовки или cookie.
+/// tip | Подсказка
+
+Обычно вы получите значительно лучшую производительность, если будете использовать [Модель ответа](../tutorial/response-model.md), а не возвращать `JSONResponse` напрямую, так как в этом случае сериализация данных с помощью Pydantic происходит на стороне Rust.
+
+///
## Возврат `Response` { #return-a-response }
-На самом деле, вы можете возвращать любой объект `Response` или его подкласс.
+Вы можете возвращать `Response` или любой его подкласс.
-/// tip | Подсказка
+/// info | Информация
`JSONResponse` сам по себе является подклассом `Response`.
@@ -26,6 +30,8 @@
Это даёт вам большую гибкость. Вы можете возвращать любые типы данных, переопределять любые объявления или валидацию данных и т.д.
+Это также накладывает на вас ответственность. Вам нужно удостовериться, что возвращаемые данные корректны, в правильном формате, что их можно сериализовать и т.д.
+
## Использование `jsonable_encoder` в `Response` { #using-the-jsonable-encoder-in-a-response }
Поскольку **FastAPI** не изменяет объект `Response`, который вы возвращаете, вы должны убедиться, что его содержимое готово к отправке.
@@ -50,16 +56,28 @@
Теперь давайте посмотрим, как можно использовать это для возврата пользовательского ответа.
-Допустим, вы хотите вернуть ответ в формате
XML.
+Допустим, вы хотите вернуть ответ в формате [XML](https://en.wikipedia.org/wiki/XML).
Вы можете поместить ваш XML-контент в строку, поместить её в `Response` и вернуть:
{* ../../docs_src/response_directly/tutorial002_py310.py hl[1,18] *}
+## Как работает модель ответа { #how-a-response-model-works }
+
+Когда вы объявляете [Модель ответа - возвращаемый тип](../tutorial/response-model.md) в операции пути, **FastAPI** будет использовать её для сериализации данных в JSON с помощью Pydantic.
+
+{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}
+
+Поскольку это происходит на стороне Rust, производительность будет значительно выше, чем если бы это выполнялось обычным Python и классом `JSONResponse`.
+
+При использовании `response_model` или возвращаемого типа FastAPI не будет использовать `jsonable_encoder` для преобразования данных (что было бы медленнее) и не будет использовать класс `JSONResponse`.
+
+Вместо этого он берёт JSON-байты, сгенерированные Pydantic с использованием модели ответа (или возвращаемого типа), и возвращает `Response` с правильным типом содержимого для JSON (`application/json`) напрямую.
+
## Примечания { #notes }
Когда вы возвращаете объект `Response` напрямую, его данные не валидируются, не преобразуются (не сериализуются) и не документируются автоматически.
-Но вы всё равно можете задокументировать это, как описано в [Дополнительные ответы в OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Но вы всё равно можете задокументировать это, как описано в [Дополнительные ответы в OpenAPI](additional-responses.md).
В следующих разделах вы увидите, как использовать/объявлять такие кастомные `Response`, при этом сохраняя автоматическое преобразование данных, документацию и т.д.
diff --git a/docs/ru/docs/advanced/response-headers.md b/docs/ru/docs/advanced/response-headers.md
index dc821983bc..806b89e1f8 100644
--- a/docs/ru/docs/advanced/response-headers.md
+++ b/docs/ru/docs/advanced/response-headers.md
@@ -20,7 +20,7 @@
Вы также можете добавить HTTP-заголовки, когда возвращаете `Response` напрямую.
-Создайте ответ, как описано в [Вернуть Response напрямую](response-directly.md){.internal-link target=_blank}, и передайте заголовки как дополнительный параметр:
+Создайте ответ, как описано в [Вернуть Response напрямую](response-directly.md), и передайте заголовки как дополнительный параметр:
{* ../../docs_src/response_headers/tutorial001_py310.py hl[10:12] *}
@@ -36,6 +36,6 @@
## Пользовательские HTTP-заголовки { #custom-headers }
-Помните, что собственные проприетарные заголовки можно добавлять,
используя префикс `X-`.
+Помните, что собственные проприетарные заголовки можно добавлять, [используя префикс `X-`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).
-Но если у вас есть пользовательские заголовки, которые вы хотите показывать клиенту в браузере, вам нужно добавить их в настройки CORS (подробнее см. в [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md){.internal-link target=_blank}), используя параметр `expose_headers`, описанный в
документации Starlette по CORS.
+Но если у вас есть пользовательские заголовки, которые вы хотите показывать клиенту в браузере, вам нужно добавить их в настройки CORS (подробнее см. в [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md)), используя параметр `expose_headers`, описанный в [документации Starlette по CORS](https://www.starlette.dev/middleware/#corsmiddleware).
diff --git a/docs/ru/docs/advanced/security/http-basic-auth.md b/docs/ru/docs/advanced/security/http-basic-auth.md
index a6bfb7c546..b094fec773 100644
--- a/docs/ru/docs/advanced/security/http-basic-auth.md
+++ b/docs/ru/docs/advanced/security/http-basic-auth.md
@@ -32,7 +32,7 @@
Используйте зависимость, чтобы проверить, корректны ли имя пользователя и пароль.
-Для этого используйте стандартный модуль Python
`secrets` для проверки имени пользователя и пароля.
+Для этого используйте стандартный модуль Python [`secrets`](https://docs.python.org/3/library/secrets.html) для проверки имени пользователя и пароля.
`secrets.compare_digest()` должен получать `bytes` или `str`, который содержит только символы ASCII (английские символы). Это значит, что он не будет работать с символами вроде `á`, как в `Sebastián`.
diff --git a/docs/ru/docs/advanced/security/index.md b/docs/ru/docs/advanced/security/index.md
index 912e4812a5..89a7236d81 100644
--- a/docs/ru/docs/advanced/security/index.md
+++ b/docs/ru/docs/advanced/security/index.md
@@ -2,11 +2,11 @@
## Дополнительные возможности { #additional-features }
-Есть дополнительные возможности для работы с безопасностью помимо тех, что описаны в [Учебник — Руководство пользователя: Безопасность](../../tutorial/security/index.md){.internal-link target=_blank}.
+Есть дополнительные возможности для работы с безопасностью помимо тех, что описаны в [Учебник — Руководство пользователя: Безопасность](../../tutorial/security/index.md).
/// tip | Совет
-Следующие разделы **не обязательно являются «продвинутыми»**.
+Следующие разделы не обязательно являются «продвинутыми».
И возможно, что решение для вашего варианта использования находится в одном из них.
@@ -14,6 +14,6 @@
## Сначала прочитайте руководство { #read-the-tutorial-first }
-В следующих разделах предполагается, что вы уже прочитали основной [Учебник — Руководство пользователя: Безопасность](../../tutorial/security/index.md){.internal-link target=_blank}.
+В следующих разделах предполагается, что вы уже прочитали основной [Учебник — Руководство пользователя: Безопасность](../../tutorial/security/index.md).
Все они основаны на тех же концепциях, но предоставляют дополнительные возможности.
diff --git a/docs/ru/docs/advanced/security/oauth2-scopes.md b/docs/ru/docs/advanced/security/oauth2-scopes.md
index 8788df1991..944baeeeb6 100644
--- a/docs/ru/docs/advanced/security/oauth2-scopes.md
+++ b/docs/ru/docs/advanced/security/oauth2-scopes.md
@@ -1,6 +1,6 @@
# OAuth2 scopes { #oauth2-scopes }
-Вы можете использовать OAuth2 scopes (scope - область, рамки) напрямую с **FastAPI** — они интегрированы и работают бесшовно.
+Вы можете использовать OAuth2 scopes напрямую с **FastAPI** — они интегрированы и работают бесшовно.
Это позволит вам иметь более детальную систему разрешений по стандарту OAuth2, интегрированную в ваше OpenAPI‑приложение (и документацию API).
@@ -60,7 +60,7 @@ OAuth2 со scopes — это механизм, который использу
## Взгляд издалека { #global-view }
-Сначала быстро посмотрим, что изменилось по сравнению с примерами из основного раздела **Учебник - Руководство пользователя** — [OAuth2 с паролем (и хешированием), Bearer с JWT-токенами](../../tutorial/security/oauth2-jwt.md){.internal-link target=_blank}. Теперь — с использованием OAuth2 scopes:
+Сначала быстро посмотрим, что изменилось по сравнению с примерами из основного раздела **Учебник - Руководство пользователя** — [OAuth2 с паролем (и хешированием), Bearer с JWT-токенами](../../tutorial/security/oauth2-jwt.md). Теперь — с использованием OAuth2 scopes:
{* ../../docs_src/security/tutorial005_an_py310.py hl[5,9,13,47,65,106,108:116,122:126,130:136,141,157] *}
@@ -267,8 +267,8 @@ OAuth2 со scopes — это механизм, который использу
///
-FastAPI включает утилиты для всех этих OAuth2‑flows в `fastapi.security.oauth2`.
+**FastAPI** включает утилиты для всех этих OAuth2‑flows в `fastapi.security.oauth2`.
## `Security` в параметре `dependencies` декоратора { #security-in-decorator-dependencies }
-Точно так же, как вы можете определить `list` из `Depends` в параметре `dependencies` декоратора (см. [Зависимости в декораторах операции пути](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}), вы можете использовать там и `Security` со `scopes`.
+Точно так же, как вы можете определить `list` из `Depends` в параметре `dependencies` декоратора (см. [Зависимости в декораторах операции пути](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md)), вы можете использовать там и `Security` со `scopes`.
diff --git a/docs/ru/docs/advanced/settings.md b/docs/ru/docs/advanced/settings.md
index 15537e2b40..3ae063340b 100644
--- a/docs/ru/docs/advanced/settings.md
+++ b/docs/ru/docs/advanced/settings.md
@@ -8,7 +8,7 @@
/// tip | Совет
-Чтобы понять, что такое переменные окружения, вы можете прочитать [Переменные окружения](../environment-variables.md){.internal-link target=_blank}.
+Чтобы понять, что такое переменные окружения, вы можете прочитать [Переменные окружения](../environment-variables.md).
///
@@ -20,11 +20,11 @@
## Pydantic `Settings` { #pydantic-settings }
-К счастью, Pydantic предоставляет отличную утилиту для работы с этими настройками, поступающими из переменных окружения, —
Pydantic: управление настройками.
+К счастью, Pydantic предоставляет отличную утилиту для работы с этими настройками, поступающими из переменных окружения, — [Pydantic: управление настройками](https://docs.pydantic.dev/latest/concepts/pydantic_settings/).
### Установка `pydantic-settings` { #install-pydantic-settings }
-Сначала убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его, а затем установили пакет `pydantic-settings`:
+Сначала убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md), активировали его, а затем установили пакет `pydantic-settings`:
@@ -100,7 +100,7 @@ $ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.p
## Настройки в другом модуле { #settings-in-another-module }
-Вы можете вынести эти настройки в другой модуль, как показано в разделе [Большие приложения — несколько файлов](../tutorial/bigger-applications.md){.internal-link target=_blank}.
+Вы можете вынести эти настройки в другой модуль, как показано в разделе [Большие приложения — несколько файлов](../tutorial/bigger-applications.md).
Например, у вас может быть файл `config.py` со следующим содержимым:
@@ -112,7 +112,7 @@ $ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.p
/// tip | Совет
-Вам также понадобится файл `__init__.py`, как в разделе [Большие приложения — несколько файлов](../tutorial/bigger-applications.md){.internal-link target=_blank}.
+Вам также понадобится файл `__init__.py`, как в разделе [Большие приложения — несколько файлов](../tutorial/bigger-applications.md).
///
@@ -172,7 +172,7 @@ $ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.p
///
-Pydantic поддерживает чтение таких файлов с помощью внешней библиотеки. Подробнее вы можете прочитать здесь:
Pydantic Settings: поддержка Dotenv (.env).
+Pydantic поддерживает чтение таких файлов с помощью внешней библиотеки. Подробнее вы можете прочитать здесь: [Pydantic Settings: поддержка Dotenv (.env)](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support).
/// tip | Совет
@@ -197,7 +197,7 @@ APP_NAME="ChimichangApp"
/// tip | Совет
-Атрибут `model_config` используется только для конфигурации Pydantic. Подробнее см.
Pydantic: Concepts: Configuration.
+Атрибут `model_config` используется только для конфигурации Pydantic. Подробнее см. [Pydantic: Concepts: Configuration](https://docs.pydantic.dev/latest/concepts/config/).
///
@@ -291,7 +291,7 @@ participant execute as Execute function
Таким образом, она ведет себя почти как глобальная переменная. Но так как используется функция‑зависимость, мы можем легко переопределить ее для тестирования.
-`@lru_cache` — часть `functools`, что входит в стандартную библиотеку Python. Подробнее можно прочитать в
документации Python по `@lru_cache`.
+`@lru_cache` — часть `functools`, что входит в стандартную библиотеку Python. Подробнее можно прочитать в [документации Python по `@lru_cache`](https://docs.python.org/3/library/functools.html#functools.lru_cache).
## Итоги { #recap }
diff --git a/docs/ru/docs/advanced/stream-data.md b/docs/ru/docs/advanced/stream-data.md
new file mode 100644
index 0000000000..4c373db1ad
--- /dev/null
+++ b/docs/ru/docs/advanced/stream-data.md
@@ -0,0 +1,117 @@
+# Потоковая передача данных { #stream-data }
+
+Если вам нужно передавать потоковые данные, которые можно представить как JSON, воспользуйтесь [стримингом JSON Lines](../tutorial/stream-json-lines.md).
+
+Но если вы хотите передавать в потоке чистые бинарные данные или строки, ниже показано, как это сделать.
+
+/// info | Информация
+
+Добавлено в FastAPI 0.134.0.
+
+///
+
+## Варианты использования { #use-cases }
+
+Это можно использовать, если вы хотите стримить чистые строки, например, напрямую из вывода сервиса **AI LLM**.
+
+Также вы можете стримить **большие бинарные файлы**, передавая каждый чанк данных по мере чтения, без необходимости загружать всё в память сразу.
+
+Аналогично можно стримить **видео** или **аудио** — данные могут даже генерироваться по мере обработки и отправки.
+
+## «`StreamingResponse` с `yield`» { #a-streamingresponse-with-yield }
+
+Если вы укажете `response_class=StreamingResponse` в своей *функции-обработчике пути*, вы можете использовать `yield`, чтобы по очереди отправлять каждый чанк данных.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[1:23] hl[20,23] *}
+
+FastAPI будет передавать каждый чанк данных в `StreamingResponse` как есть, не пытаясь конвертировать его в JSON или что-то подобное.
+
+### Не-async *функции-обработчики пути* { #non-async-path-operation-functions }
+
+Можно использовать и обычные функции `def` (без `async`) и точно так же применять `yield`.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[26:29] hl[27] *}
+
+### Без аннотации { #no-annotation }
+
+Для потоковой передачи бинарных данных вам не нужно указывать аннотацию типа возвращаемого значения.
+
+Поскольку FastAPI не будет пытаться конвертировать данные в JSON с помощью Pydantic или сериализовать их каким-либо образом, в данном случае аннотация типа нужна только для вашего редактора кода и инструментов, FastAPI её использовать не будет.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[32:35] hl[33] *}
+
+Это также означает, что с `StreamingResponse` у вас есть и свобода, и ответственность — производить и кодировать байты данных ровно в том виде, в котором они должны быть отправлены, независимо от аннотаций типов. 🤓
+
+### Потоковая передача байтов { #stream-bytes }
+
+Один из основных сценариев — стримить `bytes` вместо строк, и, конечно, это можно сделать.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[44:47] hl[47] *}
+
+## Пользовательский `PNGStreamingResponse` { #a-custom-pngstreamingresponse }
+
+В примерах выше байты данных передавались потоком, но в ответе не было HTTP-заголовка `Content-Type`, поэтому клиент не знал, какой тип данных он получает.
+
+Вы можете создать пользовательский подкласс `StreamingResponse`, который устанавливает HTTP-заголовок `Content-Type` в тип данных, которые вы стримите.
+
+Например, вы можете создать `PNGStreamingResponse`, который устанавливает HTTP-заголовок `Content-Type` в `image/png` с помощью атрибута `media_type`:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[6,19:20] hl[20] *}
+
+Затем вы можете использовать этот новый класс в `response_class=PNGStreamingResponse` в своей *функции-обработчике пути*:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[23:27] hl[23] *}
+
+### Симулировать файл { #simulate-a-file }
+
+В этом примере мы симулируем файл с помощью `io.BytesIO` — это «файлоподобный» объект, который существует только в памяти, но позволяет использовать тот же интерфейс.
+
+Например, мы можем итерироваться по нему, чтобы потреблять его содержимое, как и по обычному файлу.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[1:27] hl[3,12:13,25] *}
+
+/// note | Технические детали
+
+Две другие переменные, `image_base64` и `binary_image`, — это изображение, закодированное в Base64, а затем преобразованное в байты, после чего переданное в `io.BytesIO`.
+
+Только для того, чтобы всё помещалось в одном файле для этого примера, и вы могли скопировать код и запустить его как есть. 🥚
+
+///
+
+Используя блок `with`, мы гарантируем, что объект, ведущий себя как файл, будет закрыт после завершения работы функции‑генератора (функции с `yield`). То есть после того, как она закончит отправку ответа.
+
+В этом конкретном примере это не столь важно, потому что это «фейковый» файл в памяти (`io.BytesIO`), но для реального файла важно удостовериться, что файл закрыт после завершения работы с ним.
+
+### Файлы и async { #files-and-async }
+
+В большинстве случаев «файлоподобные» объекты по умолчанию не совместимы с async и await.
+
+Например, у них нет `await file.read()` или `async for chunk in file`.
+
+И во многих случаях чтение таких объектов будет блокирующей операцией (которая может заблокировать цикл событий), потому что данные читаются с диска или из сети.
+
+/// info | Информация
+
+Приведённый выше пример — исключение, потому что объект `io.BytesIO` уже находится в памяти, поэтому чтение ничего не блокирует.
+
+Но во многих случаях чтение файла или «файлоподобного» объекта будет блокировать.
+
+///
+
+Чтобы не блокировать цикл событий, вы можете просто объявить *функцию-обработчик пути* обычной `def` вместо `async def`. Тогда FastAPI выполнит её в воркере из пула потоков (threadpool), чтобы не блокировать основной цикл.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}
+
+/// tip | Совет
+
+Если вам нужно вызвать блокирующий код изнутри async-функции, или async-функцию изнутри блокирующей функции, вы можете использовать [Asyncer](https://asyncer.tiangolo.com), родственную библиотеку к FastAPI.
+
+///
+
+### `yield from` { #yield-from }
+
+Когда вы итерируетесь по чему‑то, например, по «файлоподобному» объекту, и делаете `yield` для каждого элемента, вы можете также использовать `yield from`, чтобы отдавать каждый элемент напрямую и не писать цикл `for`.
+
+Это не специфично для FastAPI, это просто Python, но полезный приём. 😎
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[37:40] hl[40] *}
diff --git a/docs/ru/docs/advanced/strict-content-type.md b/docs/ru/docs/advanced/strict-content-type.md
new file mode 100644
index 0000000000..1a0cbbc31d
--- /dev/null
+++ b/docs/ru/docs/advanced/strict-content-type.md
@@ -0,0 +1,88 @@
+# Строгая проверка HTTP-заголовка Content-Type { #strict-content-type-checking }
+
+По умолчанию **FastAPI** использует строгую проверку HTTP-заголовка `Content-Type` для JSON-тел запросов. Это означает, что JSON-запросы должны включать корректный заголовок `Content-Type` (например, `application/json`), чтобы тело запроса было обработано как JSON.
+
+## Риск CSRF { #csrf-risk }
+
+Такое поведение по умолчанию обеспечивает защиту от класса атак **Cross-Site Request Forgery (CSRF)** в очень специфическом сценарии.
+
+Эти атаки используют то, что браузеры позволяют скриптам отправлять запросы без выполнения CORS preflight, когда они:
+
+- не имеют заголовка `Content-Type` (например, при использовании `fetch()` с телом `Blob`)
+- и не отправляют никаких учетных данных аутентификации.
+
+Этот тип атак в основном актуален, когда:
+
+- приложение запускается локально (например, на `localhost`) или во внутренней сети
+- и в приложении нет аутентификации, оно предполагает, что любому запросу из той же сети можно доверять.
+
+## Пример атаки { #example-attack }
+
+Представьте, что вы сделали способ запускать локального ИИ-агента.
+
+Он предоставляет API по адресу
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Есть также фронтенд по адресу
+
+```
+http://localhost:8000
+```
+
+/// tip | Совет
+
+Обратите внимание, что у обоих один и тот же хост.
+
+///
+
+Через фронтенд вы можете заставлять ИИ-агента выполнять действия от вашего имени.
+
+Так как он работает локально и не в открытом интернете, вы решаете не настраивать аутентификацию, полагаясь на доступ к локальной сети.
+
+Затем один из ваших пользователей может установить это и запускать локально.
+
+Потом он может открыть вредоносный сайт, например что-то вроде
+
+```
+https://evilhackers.example.com
+```
+
+И этот вредоносный сайт отправит запросы с помощью `fetch()` с телом `Blob` к локальному API по адресу
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Несмотря на то, что хост вредоносного сайта и локального приложения различается, браузер не запустит CORS preflight-запрос, потому что:
+
+- Приложение работает без аутентификации, ему не нужно отправлять какие-либо учетные данные.
+- Браузер «считает», что он не отправляет JSON (из-за отсутствия заголовка `Content-Type`).
+
+В итоге вредоносный сайт может заставить локального ИИ-агента отправить злые сообщения бывшему начальнику пользователя... или что-то похуже. 😅
+
+## Открытый интернет { #open-internet }
+
+Если ваше приложение доступно в открытом интернете, вы не будете «доверять сети» и позволять кому угодно отправлять привилегированные запросы без аутентификации.
+
+Злоумышленники могут просто запустить скрипт и слать запросы к вашему API, без участия браузера, так что вы, вероятно, уже защищаете любые привилегированные эндпоинты.
+
+В этом случае эта атака/риск на вас не распространяется.
+
+Этот риск и атака в основном актуальны, когда приложение работает в локальной сети и это единственная предполагаемая защита.
+
+## Разрешение запросов без Content-Type { #allowing-requests-without-content-type }
+
+Если вам нужно поддерживать клиентов, которые не отправляют заголовок `Content-Type`, вы можете отключить строгую проверку, установив `strict_content_type=False`:
+
+{* ../../docs_src/strict_content_type/tutorial001_py310.py hl[4] *}
+
+С этой настройкой запросы без заголовка `Content-Type` будут иметь тело запроса, обработанное как JSON — это такое же поведение, как в более старых версиях FastAPI.
+
+/// info | Информация
+
+Это поведение и настройка были добавлены в FastAPI 0.132.0.
+
+///
diff --git a/docs/ru/docs/advanced/sub-applications.md b/docs/ru/docs/advanced/sub-applications.md
index 4fd5649ce3..37257e0f3b 100644
--- a/docs/ru/docs/advanced/sub-applications.md
+++ b/docs/ru/docs/advanced/sub-applications.md
@@ -30,25 +30,25 @@
### Проверьте автоматическую документацию API { #check-the-automatic-api-docs }
-Теперь запустите команду `fastapi` с вашим файлом:
+Теперь запустите команду `fastapi`:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-И откройте документацию по адресу
http://127.0.0.1:8000/docs.
+И откройте документацию по адресу [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Вы увидите автоматическую документацию API для основного приложения, включающую только его собственные _операции пути_:
-Затем откройте документацию для подприложения по адресу
http://127.0.0.1:8000/subapi/docs.
+Затем откройте документацию для подприложения по адресу [http://127.0.0.1:8000/subapi/docs](http://127.0.0.1:8000/subapi/docs).
Вы увидите автоматическую документацию API для подприложения, включающую только его собственные _операции пути_, все под корректным префиксом подпути `/subapi`:
@@ -64,4 +64,4 @@ $ fastapi dev main.py
У подприложения также могут быть свои собственные смонтированные подприложения, и всё будет работать корректно, потому что FastAPI автоматически обрабатывает все эти `root_path`.
-Вы узнаете больше о `root_path` и о том, как использовать его явно, в разделе [За прокси](behind-a-proxy.md){.internal-link target=_blank}.
+Вы узнаете больше о `root_path` и о том, как использовать его явно, в разделе [За прокси](behind-a-proxy.md).
diff --git a/docs/ru/docs/advanced/templates.md b/docs/ru/docs/advanced/templates.md
index 68adcb5151..5fc938eec2 100644
--- a/docs/ru/docs/advanced/templates.md
+++ b/docs/ru/docs/advanced/templates.md
@@ -8,7 +8,7 @@
## Установка зависимостей { #install-dependencies }
-Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его и установили `jinja2`:
+Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md), активировали его и установили `jinja2`:
@@ -123,4 +123,4 @@ Item ID: 42
## Подробнее { #more-details }
-Больше подробностей, включая то, как тестировать шаблоны, смотрите в
документации Starlette по шаблонам.
+Больше подробностей, включая то, как тестировать шаблоны, смотрите в [документации Starlette по шаблонам](https://www.starlette.dev/templates/).
diff --git a/docs/ru/docs/advanced/testing-websockets.md b/docs/ru/docs/advanced/testing-websockets.md
index f6fa6a04be..6ab395f8f4 100644
--- a/docs/ru/docs/advanced/testing-websockets.md
+++ b/docs/ru/docs/advanced/testing-websockets.md
@@ -8,6 +8,6 @@
/// note | Примечание
-Подробности смотрите в документации Starlette по
тестированию WebSocket.
+Подробности смотрите в документации Starlette по [тестированию WebSocket](https://www.starlette.dev/testclient/#testing-websocket-sessions).
///
diff --git a/docs/ru/docs/advanced/using-request-directly.md b/docs/ru/docs/advanced/using-request-directly.md
index 0c091cdeda..99074bf7b6 100644
--- a/docs/ru/docs/advanced/using-request-directly.md
+++ b/docs/ru/docs/advanced/using-request-directly.md
@@ -15,7 +15,7 @@
## Подробности об объекте `Request` { #details-about-the-request-object }
-Так как под капотом **FastAPI** — это **Starlette** с дополнительным слоем инструментов, вы можете при необходимости напрямую использовать объект
`Request` из Starlette.
+Так как под капотом **FastAPI** — это **Starlette** с дополнительным слоем инструментов, вы можете при необходимости напрямую использовать объект [`Request`](https://www.starlette.dev/requests/) из Starlette.
Это также означает, что если вы получаете данные напрямую из объекта `Request` (например, читаете тело запроса), то они не будут валидироваться, конвертироваться или документироваться (с OpenAPI, для автоматического пользовательского интерфейса API) средствами FastAPI.
@@ -45,7 +45,7 @@
## Документация по `Request` { #request-documentation }
-Подробнее об
объекте `Request` на официальном сайте документации Starlette.
+Подробнее об [объекте `Request` на официальном сайте документации Starlette](https://www.starlette.dev/requests/).
/// note | Технические детали
diff --git a/docs/ru/docs/advanced/websockets.md b/docs/ru/docs/advanced/websockets.md
index d565d507bc..abfd789a48 100644
--- a/docs/ru/docs/advanced/websockets.md
+++ b/docs/ru/docs/advanced/websockets.md
@@ -1,10 +1,10 @@
# Веб-сокеты { #websockets }
-Вы можете использовать
веб-сокеты в **FastAPI**.
+Вы можете использовать [веб-сокеты](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) в **FastAPI**.
## Установка `websockets` { #install-websockets }
-Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его и установили `websockets` (библиотека Python, упрощающая работу с протоколом "WebSocket"):
+Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md), активировали его и установили `websockets` (библиотека Python, упрощающая работу с протоколом "WebSocket"):
@@ -64,19 +64,19 @@ $ pip install websockets
## Проверка в действии { #try-it }
-Если ваш файл называется `main.py`, то запустите приложение командой:
+Поместите ваш код в файл `main.py`, затем запустите приложение:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-Откройте браузер по адресу
http://127.0.0.1:8000.
+Откройте браузер по адресу [http://127.0.0.1:8000](http://127.0.0.1:8000).
Вы увидите следующую простенькую страницу:
@@ -115,25 +115,25 @@ $ fastapi dev main.py
В веб-сокете вызывать `HTTPException` не имеет смысла. Вместо этого нужно использовать `WebSocketException`.
-Закрывающий статус код можно использовать из
valid codes defined in the specification.
+Вы можете использовать код закрытия из [допустимых кодов, определённых в спецификации](https://tools.ietf.org/html/rfc6455#section-7.4.1).
///
### Веб-сокеты с зависимостями: проверка в действии { #try-the-websockets-with-dependencies }
-Если ваш файл называется `main.py`, то запустите приложение командой:
+Запустите приложение:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-Откройте браузер по адресу
http://127.0.0.1:8000.
+Откройте браузер по адресу [http://127.0.0.1:8000](http://127.0.0.1:8000).
Там вы можете задать:
@@ -152,7 +152,7 @@ $ fastapi dev main.py
## Обработка отключений и работа с несколькими клиентами { #handling-disconnections-and-multiple-clients }
-Если веб-сокет соединение закрыто, то `await websocket.receive_text()` вызовет исключение `WebSocketDisconnect`, которое можно поймать и обработать как в этом примере:
+Если веб-сокет соединение закрыто, то `await websocket.receive_text()` вызовет исключение `WebSocketDisconnect`, которое можно поймать и обработать как в этом примере.
{* ../../docs_src/websockets_/tutorial003_py310.py hl[79:81] *}
@@ -174,7 +174,7 @@ Client #1596980209979 left the chat
Но имейте в виду, что это будет работать только в одном процессе и только пока он активен, так как всё обрабатывается в простом списке в оперативной памяти.
-Если нужно что-то легко интегрируемое с FastAPI, но более надежное и с поддержкой Redis, PostgreSQL или другого, то можно воспользоваться
encode/broadcaster.
+Если нужно что-то легко интегрируемое с FastAPI, но более надежное и с поддержкой Redis, PostgreSQL или другого, то можно воспользоваться [encode/broadcaster](https://github.com/encode/broadcaster).
///
@@ -182,5 +182,5 @@ Client #1596980209979 left the chat
Для более глубокого изучения темы воспользуйтесь документацией Starlette:
-*
The `WebSocket` class.
-*
Class-based WebSocket handling.
+* [Класс `WebSocket`](https://www.starlette.dev/websockets/).
+* [Обработка WebSocket на основе классов](https://www.starlette.dev/endpoints/#websocketendpoint).
diff --git a/docs/ru/docs/advanced/wsgi.md b/docs/ru/docs/advanced/wsgi.md
index aa630c228e..3ed85d0e95 100644
--- a/docs/ru/docs/advanced/wsgi.md
+++ b/docs/ru/docs/advanced/wsgi.md
@@ -1,6 +1,6 @@
# Подключение WSGI — Flask, Django и другие { #including-wsgi-flask-django-others }
-Вы можете монтировать WSGI‑приложения, как вы видели в [Подприложения — Mounts](sub-applications.md){.internal-link target=_blank}, [За прокси‑сервером](behind-a-proxy.md){.internal-link target=_blank}.
+Вы можете монтировать WSGI‑приложения, как вы видели в [Подприложения — Mounts](sub-applications.md), [За прокси‑сервером](behind-a-proxy.md).
Для этого вы можете использовать `WSGIMiddleware` и обернуть им ваше WSGI‑приложение, например Flask, Django и т.д.
@@ -36,13 +36,13 @@
А всё остальное будет обрабатываться **FastAPI**.
-Если вы запустите это и перейдёте по
http://localhost:8000/v1/, вы увидите HTTP‑ответ от Flask:
+Если вы запустите это и перейдёте по [http://localhost:8000/v1/](http://localhost:8000/v1/), вы увидите HTTP‑ответ от Flask:
```txt
Hello, World from Flask!
```
-А если вы перейдёте по
http://localhost:8000/v2, вы увидите HTTP‑ответ от FastAPI:
+А если вы перейдёте по [http://localhost:8000/v2](http://localhost:8000/v2), вы увидите HTTP‑ответ от FastAPI:
```JSON
{
diff --git a/docs/ru/docs/alternatives.md b/docs/ru/docs/alternatives.md
index 1f713c3f39..13bac7f92b 100644
--- a/docs/ru/docs/alternatives.md
+++ b/docs/ru/docs/alternatives.md
@@ -14,7 +14,7 @@
## Предшествующие инструменты { #previous-tools }
-###
Django { #django }
+### [Django](https://www.djangoproject.com/) { #django }
Это самый популярный Python-фреймворк, ему широко доверяют. Он используется для построения систем вроде Instagram.
@@ -22,7 +22,7 @@
Он был создан для генерации HTML на бэкенде, а не для создания API, используемых современным фронтендом (например, React, Vue.js и Angular) или другими системами (например, устройствами
IoT), которые с ним общаются.
-###
Django REST Framework { #django-rest-framework }
+### [Django REST Framework](https://www.django-rest-framework.org/) { #django-rest-framework }
Django REST Framework был создан как гибкий набор инструментов для построения веб-API поверх Django, чтобы улучшить его возможности в части API.
@@ -42,7 +42,7 @@ Django REST Framework был создан Томом Кристи. Он же с
///
-###
Flask { #flask }
+### [Flask](https://flask.palletsprojects.com) { #flask }
Flask — это «микрофреймворк», он не включает интеграции с базами данных и многие другие вещи, которые в Django идут «из коробки».
@@ -64,7 +64,7 @@ Flask — это «микрофреймворк», он не включает и
///
-###
Requests { #requests }
+### [Requests](https://requests.readthedocs.io) { #requests }
**FastAPI** на самом деле не альтернатива **Requests**. Их области применения очень различны.
@@ -106,7 +106,7 @@ def read_url():
///
-###
Swagger /
OpenAPI { #swagger-openapi }
+### [Swagger](https://swagger.io/) / [OpenAPI](https://github.com/OAI/OpenAPI-Specification/) { #swagger-openapi }
Главной возможностью, которую хотелось взять из Django REST Framework, была автоматическая документация API.
@@ -124,8 +124,8 @@ def read_url():
И интегрировать основанные на стандартах инструменты пользовательского интерфейса:
-*
Swagger UI
-*
ReDoc
+* [Swagger UI](https://github.com/swagger-api/swagger-ui)
+* [ReDoc](https://github.com/Rebilly/ReDoc)
Эти два инструмента выбраны за популярность и стабильность, но даже при беглом поиске можно найти десятки альтернативных интерфейсов для OpenAPI (которые можно использовать с **FastAPI**).
@@ -135,7 +135,7 @@ def read_url():
Существует несколько REST-фреймворков для Flask, но, вложив время и усилия в исследование, я обнаружил, что многие из них прекращены или заброшены, с несколькими нерешёнными Issue (тикет\обращение), из-за которых они непригодны.
-###
Marshmallow { #marshmallow }
+### [Marshmallow](https://marshmallow.readthedocs.io/en/stable/) { #marshmallow }
Одна из основных возможностей, нужных системам API, — «
сериализация» данных, то есть преобразование данных из кода (Python) во что-то, что можно отправить по сети. Например, преобразование объекта с данными из базы в JSON-объект. Преобразование объектов `datetime` в строки и т. п.
@@ -153,7 +153,7 @@ def read_url():
///
-###
Webargs { #webargs }
+### [Webargs](https://webargs.readthedocs.io/en/latest/) { #webargs }
Ещё одна важная возможность для API —
парсинг данных из входящих HTTP-запросов.
@@ -175,7 +175,7 @@ Webargs был создан теми же разработчиками, что
///
-###
APISpec { #apispec }
+### [APISpec](https://apispec.readthedocs.io/en/stable/) { #apispec }
Marshmallow и Webargs предоставляют валидацию, парсинг и сериализацию как плагины.
@@ -205,7 +205,7 @@ APISpec был создан теми же разработчиками, что
///
-###
Flask-apispec { #flask-apispec }
+### [Flask-apispec](https://flask-apispec.readthedocs.io/en/latest/) { #flask-apispec }
Это плагин для Flask, который связывает Webargs, Marshmallow и APISpec.
@@ -219,11 +219,11 @@ APISpec был создан теми же разработчиками, что
Его использование привело к созданию нескольких full-stack генераторов на Flask. Это основные стеки, которые я (и несколько внешних команд) использовали до сих пор:
-*
https://github.com/tiangolo/full-stack
-*
https://github.com/tiangolo/full-stack-flask-couchbase
-*
https://github.com/tiangolo/full-stack-flask-couchdb
+* [https://github.com/tiangolo/full-stack](https://github.com/tiangolo/full-stack)
+* [https://github.com/tiangolo/full-stack-flask-couchbase](https://github.com/tiangolo/full-stack-flask-couchbase)
+* [https://github.com/tiangolo/full-stack-flask-couchdb](https://github.com/tiangolo/full-stack-flask-couchdb)
-И эти же full-stack генераторы стали основой для [Генераторов проектов **FastAPI**](project-generation.md){.internal-link target=_blank}.
+И эти же full-stack генераторы стали основой для [Генераторов проектов **FastAPI**](project-generation.md).
/// info | Информация
@@ -237,7 +237,7 @@ Flask-apispec был создан теми же разработчиками, ч
///
-###
NestJS (и
Angular) { #nestjs-and-angular }
+### [NestJS](https://nestjs.com/) (и [Angular](https://angular.io/)) { #nestjs-and-angular }
Это даже не Python. NestJS — это JavaScript/TypeScript-фреймворк на NodeJS, вдохновлённый Angular.
@@ -259,13 +259,13 @@ Flask-apispec был создан теми же разработчиками, ч
///
-###
Sanic { #sanic }
+### [Sanic](https://sanic.readthedocs.io/en/latest/) { #sanic }
Это был один из первых чрезвычайно быстрых Python-фреймворков на основе `asyncio`. Он был сделан очень похожим на Flask.
/// note | Технические детали
-Он использовал
`uvloop` вместо стандартного цикла `asyncio` в Python. Это и сделало его таким быстрым.
+Он использовал [`uvloop`](https://github.com/MagicStack/uvloop) вместо стандартного цикла `asyncio` в Python. Это и сделало его таким быстрым.
Он явно вдохновил Uvicorn и Starlette, которые сейчас быстрее Sanic в открытых бенчмарках.
@@ -279,7 +279,7 @@ Flask-apispec был создан теми же разработчиками, ч
///
-###
Falcon { #falcon }
+### [Falcon](https://falconframework.org/) { #falcon }
Falcon — ещё один высокопроизводительный Python-фреймворк, он минималистичен и служит основой для других фреймворков, таких как Hug.
@@ -297,7 +297,7 @@ Falcon — ещё один высокопроизводительный Python-
///
-###
Molten { #molten }
+### [Molten](https://moltenframework.com/) { #molten }
Я обнаружил Molten на ранних этапах создания **FastAPI**. И у него были очень похожие идеи:
@@ -321,7 +321,7 @@ Falcon — ещё один высокопроизводительный Python-
///
-###
Hug { #hug }
+### [Hug](https://github.com/hugapi/hug) { #hug }
Hug был одним из первых фреймворков, реализовавших объявление типов параметров API с использованием аннотаций типов Python. Это была отличная идея, которая вдохновила и другие инструменты.
@@ -337,7 +337,7 @@ Hug был одним из первых фреймворков, реализов
/// info | Информация
-Hug был создан Тимоти Кросли, тем же автором
`isort`, отличного инструмента для автоматической сортировки импортов в файлах Python.
+Hug был создан Тимоти Кросли, тем же автором [`isort`](https://github.com/timothycrosley/isort), отличного инструмента для автоматической сортировки импортов в файлах Python.
///
@@ -351,7 +351,7 @@ Hug вдохновил **FastAPI** объявлять параметр `response
///
-###
APIStar (<= 0.5) { #apistar-0-5 }
+### [APIStar](https://github.com/encode/apistar) (<= 0.5) { #apistar-0-5 }
Прямо перед решением строить **FastAPI** я нашёл сервер **APIStar**. В нём было почти всё, что я искал, и отличный дизайн.
@@ -401,7 +401,7 @@ APIStar был создан Томом Кристи. Тем самым чело
## Что используется в **FastAPI** { #used-by-fastapi }
-###
Pydantic { #pydantic }
+### [Pydantic](https://docs.pydantic.dev/) { #pydantic }
Pydantic — это библиотека для определения валидации данных, сериализации и документации (с использованием JSON Schema) на основе аннотаций типов Python.
@@ -417,7 +417,7 @@ Pydantic — это библиотека для определения вали
///
-###
Starlette { #starlette }
+### [Starlette](https://www.starlette.dev/) { #starlette }
Starlette — это лёгкий
ASGI фреймворк/набор инструментов, идеально подходящий для создания высокопроизводительных asyncio‑сервисов.
@@ -462,7 +462,7 @@ ASGI — это новый «стандарт», разрабатываемый
///
-###
Uvicorn { #uvicorn }
+### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }
Uvicorn — молниеносный ASGI-сервер, построенный на uvloop и httptools.
@@ -476,10 +476,10 @@ Uvicorn — молниеносный ASGI-сервер, построенный
Также вы можете использовать опцию командной строки `--workers`, чтобы получить асинхронный многопроцессный сервер.
-Подробнее см. раздел [Развёртывание](deployment/index.md){.internal-link target=_blank}.
+Подробнее см. раздел [Развёртывание](deployment/index.md).
///
## Бенчмарки и скорость { #benchmarks-and-speed }
-Чтобы понять, сравнить и увидеть разницу между Uvicorn, Starlette и FastAPI, см. раздел о [Бенчмарках](benchmarks.md){.internal-link target=_blank}.
+Чтобы понять, сравнить и увидеть разницу между Uvicorn, Starlette и FastAPI, см. раздел о [Бенчмарках](benchmarks.md).
diff --git a/docs/ru/docs/async.md b/docs/ru/docs/async.md
index bff32aaf49..7fd702184c 100644
--- a/docs/ru/docs/async.md
+++ b/docs/ru/docs/async.md
@@ -12,7 +12,7 @@
results = await some_library()
```
-Тогда объявляйте *функции-обработчики пути* с `async def`, например:
+Тогда объявляйте *функции-обработчиков пути* с `async def`, например:
```Python hl_lines="2"
@app.get('/')
@@ -29,7 +29,7 @@ async def read_results():
---
-Если вы используете стороннюю библиотеку, которая взаимодействует с чем-то (база данных, API, файловая система и т.д.) и не поддерживает использование `await` (сейчас это относится к большинству библиотек для БД), тогда объявляйте *функции-обработчики пути* как обычно, просто с `def`, например:
+Если вы используете стороннюю библиотеку, которая взаимодействует с чем-то (база данных, API, файловая система и т.д.) и не поддерживает использование `await` (сейчас это относится к большинству библиотек для БД), тогда объявляйте *функции-обработчиков пути* как обычно, просто с `def`, например:
```Python hl_lines="2"
@app.get('/')
@@ -48,7 +48,7 @@ def results():
---
-**Примечание**: вы можете смешивать `def` и `async def` в *функциях-обработчиках пути* столько, сколько нужно, и объявлять каждую так, как лучше для вашего случая. FastAPI сделает с ними всё как надо.
+**Примечание**: вы можете смешивать `def` и `async def` в *функциях-обработчиков пути* столько, сколько нужно, и объявлять каждую так, как лучше для вашего случая. FastAPI сделает с ними всё как надо.
В любом из случаев выше FastAPI всё равно работает асинхронно и очень быстро.
@@ -141,7 +141,7 @@ def results():
/// info | Информация
-Прекрасные иллюстрации от
Ketrina Thompson. 🎨
+Прекрасные иллюстрации от [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). 🎨
///
@@ -207,7 +207,7 @@ def results():
/// info | Информация
-Прекрасные иллюстрации от
Ketrina Thompson. 🎨
+Прекрасные иллюстрации от [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). 🎨
///
@@ -251,7 +251,7 @@ def results():
Того же уровня производительности вы получаете с **FastAPI**.
-А так как можно одновременно использовать параллелизм и асинхронность, вы получаете производительность выше, чем у большинства протестированных фреймворков на NodeJS и на уровне Go, который — компилируемый язык, ближе к C
(всё благодаря Starlette).
+А так как можно одновременно использовать параллелизм и асинхронность, вы получаете производительность выше, чем у большинства протестированных фреймворков на NodeJS и на уровне Go, который — компилируемый язык, ближе к C [(всё благодаря Starlette)](https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1).
### Конкурентность лучше параллелизма? { #is-concurrency-better-than-parallelism }
@@ -298,7 +298,7 @@ def results():
Плюс к этому простой факт, что Python — основной язык для **Data Science**, Машинного обучения и особенно Глубокого обучения, делает FastAPI очень хорошим выбором для веб-API и приложений в области Data Science / Машинного обучения (среди многих других).
-Как добиться такого параллелизма в продакшн, см. раздел [Развёртывание](deployment/index.md){.internal-link target=_blank}.
+Как добиться такого параллелизма в продакшн, см. раздел [Развёртывание](deployment/index.md).
## `async` и `await` { #async-and-await }
@@ -363,13 +363,13 @@ async def read_burgers():
### Пишите свой асинхронный код { #write-your-own-async-code }
-Starlette (и **FastAPI**) основаны на
AnyIO, что делает их совместимыми и со стандартной библиотекой Python
asyncio, и с
Trio.
+Starlette (и **FastAPI**) основаны на [AnyIO](https://anyio.readthedocs.io/en/stable/), что делает их совместимыми и со стандартной библиотекой Python [asyncio](https://docs.python.org/3/library/asyncio-task.html), и с [Trio](https://trio.readthedocs.io/en/stable/).
-В частности, вы можете напрямую использовать
AnyIO для продвинутых сценариев конкурентности, где в вашем коде нужны более сложные паттерны.
+В частности, вы можете напрямую использовать [AnyIO](https://anyio.readthedocs.io/en/stable/) для продвинутых сценариев конкурентности, где в вашем коде нужны более сложные паттерны.
-И даже если вы не используете FastAPI, вы можете писать свои асинхронные приложения с
AnyIO, чтобы они были максимально совместимыми и получали его преимущества (например, *структурную конкурентность*).
+И даже если вы не используете FastAPI, вы можете писать свои асинхронные приложения с [AnyIO](https://anyio.readthedocs.io/en/stable/), чтобы они были максимально совместимыми и получали его преимущества (например, *структурную конкурентность*).
-Я создал ещё одну библиотеку поверх AnyIO, тонкий слой, чтобы немного улучшить аннотации типов и получить более качественное **автозавершение**, **ошибки прямо в редакторе** и т.д. Там также есть дружелюбное введение и руководство, чтобы помочь вам **понять** и писать **свой собственный асинхронный код**:
Asyncer. Она особенно полезна, если вам нужно **комбинировать асинхронный код с обычным** (блокирующим/синхронным) кодом.
+Я создал ещё одну библиотеку поверх AnyIO, тонкий слой, чтобы немного улучшить аннотации типов и получить более качественное **автозавершение**, **ошибки прямо в редакторе** и т.д. Там также есть дружелюбное введение и руководство, чтобы помочь вам **понять** и писать **свой собственный асинхронный код**: [Asyncer](https://asyncer.tiangolo.com/). Она особенно полезна, если вам нужно **комбинировать асинхронный код с обычным** (блокирующим/синхронным) кодом.
### Другие формы асинхронного кода { #other-forms-of-asynchronous-code }
@@ -381,7 +381,7 @@ Starlette (и **FastAPI**) основаны на
Gevent. Но такой код гораздо сложнее понимать, отлаживать и держать в голове.
+В предыдущих версиях Python можно было использовать потоки или [Gevent](https://www.gevent.org/). Но такой код гораздо сложнее понимать, отлаживать и держать в голове.
В прежних версиях NodeJS/браузерного JavaScript вы бы использовали «callbacks» (обратные вызовы), что приводит к «callback hell» (ад обратных вызовов).
@@ -419,15 +419,15 @@ Starlette (и **FastAPI**) основаны на
I/O.
-Тем не менее, в обоих случаях велика вероятность, что **FastAPI** [всё равно будет быстрее](index.md#performance){.internal-link target=_blank} (или как минимум сопоставим) с вашим предыдущим фреймворком.
+Тем не менее, в обоих случаях велика вероятность, что **FastAPI** [всё равно будет быстрее](index.md#performance) (или как минимум сопоставим) с вашим предыдущим фреймворком.
### Зависимости { #dependencies }
-То же относится к [зависимостям](tutorial/dependencies/index.md){.internal-link target=_blank}. Если зависимость — это обычная функция `def`, а не `async def`, она запускается во внешнем пуле потоков.
+То же относится к [зависимостям](tutorial/dependencies/index.md). Если зависимость — это обычная функция `def`, а не `async def`, она запускается во внешнем пуле потоков.
### Подзависимости { #sub-dependencies }
-У вас может быть несколько зависимостей и [подзависимостей](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank}, которые требуют друг друга (в виде параметров определений функций): часть из них может быть объявлена с `async def`, а часть — обычным `def`. Всё будет работать, а те, что объявлены обычным `def`, будут вызываться во внешнем потоке (из пула), а не «ожидаться».
+У вас может быть несколько зависимостей и [подзависимостей](tutorial/dependencies/sub-dependencies.md), которые требуют друг друга (в виде параметров определений функций): часть из них может быть объявлена с `async def`, а часть — обычным `def`. Всё будет работать, а те, что объявлены обычным `def`, будут вызываться во внешнем потоке (из пула), а не «ожидаться».
### Другие служебные функции { #other-utility-functions }
diff --git a/docs/ru/docs/benchmarks.md b/docs/ru/docs/benchmarks.md
index c8cacae5f3..671baba76c 100644
--- a/docs/ru/docs/benchmarks.md
+++ b/docs/ru/docs/benchmarks.md
@@ -1,6 +1,6 @@
# Бенчмарки (тесты производительности) { #benchmarks }
-Независимые бенчмарки TechEmpower показывают, что приложения **FastAPI** под управлением Uvicorn — одни из самых быстрых Python‑фреймворков, уступающие только Starlette и самому Uvicorn (используются внутри FastAPI).
+Независимые бенчмарки TechEmpower показывают, что приложения **FastAPI** под управлением Uvicorn — [одни из самых быстрых Python‑фреймворков](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7), уступающие только Starlette и самому Uvicorn (используются внутри FastAPI).
Но при просмотре бенчмарков и сравнений следует иметь в виду следующее.
diff --git a/docs/ru/docs/deployment/cloud.md b/docs/ru/docs/deployment/cloud.md
index 955db2a157..cbd517e36e 100644
--- a/docs/ru/docs/deployment/cloud.md
+++ b/docs/ru/docs/deployment/cloud.md
@@ -6,7 +6,7 @@
## FastAPI Cloud { #fastapi-cloud }
-**
FastAPI Cloud** создан тем же автором и командой, стоящими за **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** создан тем же автором и командой, стоящими за **FastAPI**.
Он упрощает процесс **создания образа**, **развертывания** и **доступа** к API с минимальными усилиями.
@@ -16,9 +16,9 @@ FastAPI Cloud — основной спонсор и источник финан
## Облачные провайдеры — спонсоры { #cloud-providers-sponsors }
-Некоторые другие облачные провайдеры ✨ [**спонсируют FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨ тоже. 🙇
+Некоторые другие облачные провайдеры ✨ [**спонсируют FastAPI**](../help-fastapi.md#sponsor-the-author) ✨ тоже. 🙇
Возможно, вы захотите попробовать их сервисы и воспользоваться их руководствами:
-*
Render
-*
Railway
+* [Render](https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi)
+* [Railway](https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi)
diff --git a/docs/ru/docs/deployment/concepts.md b/docs/ru/docs/deployment/concepts.md
index 173dbb962d..900b842f9a 100644
--- a/docs/ru/docs/deployment/concepts.md
+++ b/docs/ru/docs/deployment/concepts.md
@@ -25,7 +25,7 @@
## Безопасность — HTTPS { #security-https }
-В [предыдущей главе про HTTPS](https.md){.internal-link target=_blank} мы разобрались, как HTTPS обеспечивает шифрование для вашего API.
+В [предыдущей главе про HTTPS](https.md) мы разобрались, как HTTPS обеспечивает шифрование для вашего API.
Также мы увидели, что HTTPS обычно обеспечивает компонент, **внешний** по отношению к серверу вашего приложения — **прокси-сервер TSL-терминации**.
@@ -190,7 +190,7 @@
### Процессы‑воркеры и порты { #worker-processes-and-ports }
-Помните из раздела [Об HTTPS](https.md){.internal-link target=_blank}, что на сервере только один процесс может слушать конкретную комбинацию порта и IP‑адреса?
+Помните из раздела [Об HTTPS](https.md), что на сервере только один процесс может слушать конкретную комбинацию порта и IP‑адреса?
Это по‑прежнему так.
@@ -243,7 +243,7 @@
Не беспокойтесь, если некоторые пункты про **контейнеры**, Docker или Kubernetes пока кажутся неочевидными.
-Я расскажу больше про образы контейнеров, Docker, Kubernetes и т.п. в следующей главе: [FastAPI внутри контейнеров — Docker](docker.md){.internal-link target=_blank}.
+Я расскажу больше про образы контейнеров, Docker, Kubernetes и т.п. в следующей главе: [FastAPI внутри контейнеров — Docker](docker.md).
///
@@ -281,7 +281,7 @@
/// tip | Совет
-Я приведу более конкретные примеры с контейнерами в следующей главе: [FastAPI внутри контейнеров — Docker](docker.md){.internal-link target=_blank}.
+Я приведу более конкретные примеры с контейнерами в следующей главе: [FastAPI внутри контейнеров — Docker](docker.md).
///
diff --git a/docs/ru/docs/deployment/docker.md b/docs/ru/docs/deployment/docker.md
index 5dfa211599..3b16d7798b 100644
--- a/docs/ru/docs/deployment/docker.md
+++ b/docs/ru/docs/deployment/docker.md
@@ -1,6 +1,6 @@
# FastAPI в контейнерах — Docker { #fastapi-in-containers-docker }
-При развёртывании приложений FastAPI распространённый подход — собирать **образ контейнера на Linux**. Обычно это делают с помощью
**Docker**. Затем такой образ контейнера можно развернуть несколькими способами.
+При развёртывании приложений FastAPI распространённый подход — собирать **образ контейнера на Linux**. Обычно это делают с помощью [**Docker**](https://www.docker.com/). Затем такой образ контейнера можно развернуть несколькими способами.
Использование Linux-контейнеров даёт ряд преимуществ: **безопасность**, **воспроизводимость**, **простоту** и другие.
@@ -60,16 +60,16 @@ Linux-контейнеры запускаются, используя то же
Docker — один из основных инструментов для создания и управления **образами контейнеров** и **контейнерами**.
-Существует публичный
Docker Hub с готовыми **официальными образами** для многих инструментов, окружений, баз данных и приложений.
+Существует публичный [Docker Hub](https://hub.docker.com/) с готовыми **официальными образами** для многих инструментов, окружений, баз данных и приложений.
-Например, есть официальный
образ Python.
+Например, есть официальный [образ Python](https://hub.docker.com/_/python).
А также множество образов для разных вещей, например баз данных:
-*
PostgreSQL
-*
MySQL
-*
MongoDB
-*
Redis, и т.д.
+* [PostgreSQL](https://hub.docker.com/_/postgres)
+* [MySQL](https://hub.docker.com/_/mysql)
+* [MongoDB](https://hub.docker.com/_/mongo)
+* [Redis](https://hub.docker.com/_/redis), и т.д.
Используя готовые образы, очень легко **комбинировать** разные инструменты и использовать их. Например, чтобы попробовать новую базу данных. В большинстве случаев можно воспользоваться **официальными образами** и просто настроить их через переменные окружения.
@@ -111,7 +111,7 @@ Docker — один из основных инструментов для соз
Чаще всего используется файл `requirements.txt` с именами пакетов и их версиями по одному на строку.
-Разумеется, вы будете придерживаться тех же идей, что описаны здесь: [О версиях FastAPI](versions.md){.internal-link target=_blank}, чтобы задать диапазоны версий.
+Разумеется, вы будете придерживаться тех же идей, что описаны здесь: [О версиях FastAPI](versions.md), чтобы задать диапазоны версий.
Например, ваш `requirements.txt` может выглядеть так:
@@ -238,7 +238,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"]
#### Используйте `CMD` — exec-форма { #use-cmd-exec-form }
-Инструкцию Docker
`CMD` можно писать в двух формах:
+Инструкцию Docker [`CMD`](https://docs.docker.com/reference/dockerfile/#cmd) можно писать в двух формах:
✅ **Exec**-форма:
@@ -254,11 +254,11 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"]
CMD fastapi run app/main.py --port 80
```
-Обязательно используйте **exec**-форму, чтобы FastAPI мог корректно завершаться и чтобы срабатывали [события lifespan](../advanced/events.md){.internal-link target=_blank}.
+Обязательно используйте **exec**-форму, чтобы FastAPI мог корректно завершаться и чтобы срабатывали [события lifespan](../advanced/events.md).
-Подробнее об этом читайте в
документации Docker о shell- и exec-формах.
+Подробнее об этом читайте в [документации Docker о shell- и exec-формах](https://docs.docker.com/reference/dockerfile/#shell-and-exec-form).
-Это особенно заметно при использовании `docker compose`. См. раздел FAQ Docker Compose с техническими подробностями:
Почему мои сервисы пересоздаются или останавливаются 10 секунд?.
+Это особенно заметно при использовании `docker compose`. См. раздел FAQ Docker Compose с техническими подробностями: [Почему мои сервисы пересоздаются или останавливаются 10 секунд?](https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop).
#### Структура директорий { #directory-structure }
@@ -352,7 +352,7 @@ $ docker run -d --name mycontainer -p 80:80 myimage
## Проверка { #check-it }
-Проверьте работу по адресу вашего Docker-хоста, например:
http://192.168.99.100/items/5?q=somequery или
http://127.0.0.1/items/5?q=somequery (или аналогичный URL вашего Docker-хоста).
+Проверьте работу по адресу вашего Docker-хоста, например: [http://192.168.99.100/items/5?q=somequery](http://192.168.99.100/items/5?q=somequery) или [http://127.0.0.1/items/5?q=somequery](http://127.0.0.1/items/5?q=somequery) (или аналогичный URL вашего Docker-хоста).
Вы увидите что-то вроде:
@@ -362,17 +362,17 @@ $ docker run -d --name mycontainer -p 80:80 myimage
## Интерактивная документация API { #interactive-api-docs }
-Теперь зайдите на
http://192.168.99.100/docs или
http://127.0.0.1/docs (или аналогичный URL вашего Docker-хоста).
+Теперь зайдите на [http://192.168.99.100/docs](http://192.168.99.100/docs) или [http://127.0.0.1/docs](http://127.0.0.1/docs) (или аналогичный URL вашего Docker-хоста).
-Вы увидите автоматическую интерактивную документацию API (на базе
Swagger UI):
+Вы увидите автоматическую интерактивную документацию API (на базе [Swagger UI](https://github.com/swagger-api/swagger-ui)):
## Альтернативная документация API { #alternative-api-docs }
-Также можно открыть
http://192.168.99.100/redoc или
http://127.0.0.1/redoc (или аналогичный URL вашего Docker-хоста).
+Также можно открыть [http://192.168.99.100/redoc](http://192.168.99.100/redoc) или [http://127.0.0.1/redoc](http://127.0.0.1/redoc) (или аналогичный URL вашего Docker-хоста).
-Вы увидите альтернативную автоматическую документацию (на базе
ReDoc):
+Вы увидите альтернативную автоматическую документацию (на базе [ReDoc](https://github.com/Rebilly/ReDoc)):
@@ -413,7 +413,7 @@ CMD ["fastapi", "run", "main.py", "--port", "80"]
## Концепции развертывания { #deployment-concepts }
-Ещё раз рассмотрим [концепции развертывания](concepts.md){.internal-link target=_blank} применительно к контейнерам.
+Ещё раз рассмотрим [концепции развертывания](concepts.md) применительно к контейнерам.
Контейнеры главным образом упрощают **сборку и развёртывание** приложения, но не навязывают конкретный подход к этим **концепциям развертывания**, и существует несколько стратегий.
@@ -432,7 +432,7 @@ CMD ["fastapi", "run", "main.py", "--port", "80"]
Если мы рассматриваем только **образ контейнера** для приложения FastAPI (и далее запущенный **контейнер**), то HTTPS обычно обрабатывается **внешним** инструментом.
-Это может быть другой контейнер, например с
Traefik, который берёт на себя **HTTPS** и **автоматическое** получение **сертификатов**.
+Это может быть другой контейнер, например с [Traefik](https://traefik.io/), который берёт на себя **HTTPS** и **автоматическое** получение **сертификатов**.
/// tip | Подсказка
@@ -558,7 +558,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
/// info | Информация
-Если вы используете Kubernetes, это, вероятно, будет
Init Container.
+Если вы используете Kubernetes, это, вероятно, будет [Init Container](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/).
///
@@ -570,7 +570,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
### Базовый Docker-образ { #base-docker-image }
-Ранее существовал официальный Docker-образ FastAPI:
tiangolo/uvicorn-gunicorn-fastapi. Сейчас он помечен как устаревший. ⛔️
+Ранее существовал официальный Docker-образ FastAPI: [tiangolo/uvicorn-gunicorn-fastapi](https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker). Сейчас он помечен как устаревший. ⛔️
Скорее всего, вам **не стоит** использовать этот базовый образ (или какой-либо аналогичный).
@@ -600,7 +600,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
## Docker-образ с `uv` { #docker-image-with-uv }
-Если вы используете
uv для установки и управления проектом, следуйте их
руководству по Docker для uv.
+Если вы используете [uv](https://github.com/astral-sh/uv) для установки и управления проектом, следуйте их [руководству по Docker для uv](https://docs.astral.sh/uv/guides/integration/docker/).
## Резюме { #recap }
@@ -615,4 +615,4 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
В большинстве случаев вы, вероятно, не захотите использовать какой-либо базовый образ, а вместо этого **соберёте образ контейнера с нуля** на основе официального Docker-образа Python.
-Заботясь о **порядке** инструкций в `Dockerfile`и используя **кэш Docker**, вы можете **минимизировать время сборки**, чтобы повысить продуктивность (и не скучать). 😎
+Заботясь о **порядке** инструкций в `Dockerfile` и используя **кэш Docker**, вы можете **минимизировать время сборки**, чтобы повысить продуктивность (и не скучать). 😎
diff --git a/docs/ru/docs/deployment/fastapicloud.md b/docs/ru/docs/deployment/fastapicloud.md
index 9e7430ecb0..95db3387f2 100644
--- a/docs/ru/docs/deployment/fastapicloud.md
+++ b/docs/ru/docs/deployment/fastapicloud.md
@@ -1,6 +1,6 @@
# FastAPI Cloud { #fastapi-cloud }
-Вы можете развернуть своё приложение FastAPI в
FastAPI Cloud одной командой, присоединяйтесь к списку ожидания, если ещё не сделали этого. 🚀
+Вы можете развернуть своё приложение FastAPI в [FastAPI Cloud](https://fastapicloud.com) одной командой, присоединяйтесь к списку ожидания, если ещё не сделали этого. 🚀
## Вход { #login }
@@ -40,7 +40,7 @@ Deploying to FastAPI Cloud...
## О FastAPI Cloud { #about-fastapi-cloud }
-**
FastAPI Cloud** создан тем же автором и командой, что и **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** создан тем же автором и командой, что и **FastAPI**.
Он упрощает процесс **создания образа**, **развертывания** и **доступа** к API с минимальными усилиями.
diff --git a/docs/ru/docs/deployment/https.md b/docs/ru/docs/deployment/https.md
index ffeccfd7da..181cac0d89 100644
--- a/docs/ru/docs/deployment/https.md
+++ b/docs/ru/docs/deployment/https.md
@@ -10,7 +10,7 @@
///
-Чтобы **изучить основы HTTPS** с точки зрения пользователя, загляните на
https://howhttps.works/.
+Чтобы **изучить основы HTTPS** с точки зрения пользователя, загляните на [https://howhttps.works/](https://howhttps.works/).
Теперь, со стороны **разработчика**, вот несколько вещей, которые стоит держать в голове, размышляя об HTTPS:
@@ -28,13 +28,13 @@
* **По умолчанию** это означает, что вы можете иметь **лишь один HTTPS-сертификат на один IP-адрес**.
* Неважно, насколько мощный у вас сервер или насколько маленькие приложения на нём работают.
* Однако у этого есть **решение**.
-* Есть **расширение** протокола **TLS** (того самого, что занимается шифрованием на уровне TCP, до HTTP) под названием **
SNI**.
+* Есть **расширение** протокола **TLS** (того самого, что занимается шифрованием на уровне TCP, до HTTP) под названием **[
SNI](https://en.wikipedia.org/wiki/Server_Name_Indication)**.
* Это расширение SNI позволяет одному серверу (с **одним IP-адресом**) иметь **несколько HTTPS-сертификатов** и обслуживать **несколько HTTPS-доменов/приложений**.
* Чтобы это работало, **один** компонент (программа), запущенный на сервере и слушающий **публичный IP-адрес**, должен иметь **все HTTPS-сертификаты** на этом сервере.
* **После** установления защищённого соединения, протокол обмена данными — **всё ещё HTTP**.
* Содержимое **зашифровано**, несмотря на то, что оно отправляется по **протоколу HTTP**.
-Обычно на сервере (машине, хосте и т.п.) запускают **одну программу/HTTP‑сервер**, которая **управляет всей частью, связанной с HTTPS**: принимает **зашифрованные HTTPS-запросы**, отправляет **расшифрованные HTTP-запросы** в само HTTP‑приложение, работающее на том же сервере (в нашем случае это приложение **FastAPI**), получает **HTTP-ответ** от приложения, **шифрует его** с использованием подходящего **HTTPS‑сертификата** и отправляет клиенту по **HTTPS**. Такой сервер часто называют **
прокси‑сервером TLS-терминации**.
+Обычно на сервере (машине, хосте и т.п.) запускают **одну программу/HTTP‑сервер**, которая **управляет всей частью, связанной с HTTPS**: принимает **зашифрованные HTTPS-запросы**, отправляет **расшифрованные HTTP-запросы** в само HTTP‑приложение, работающее на том же сервере (в нашем случае это приложение **FastAPI**), получает **HTTP-ответ** от приложения, **шифрует его** с использованием подходящего **HTTPS‑сертификата** и отправляет клиенту по **HTTPS**. Такой сервер часто называют **[прокси‑сервером TLS-терминации](https://en.wikipedia.org/wiki/TLS_termination_proxy)**.
Некоторые варианты, которые вы можете использовать как прокси‑сервер TLS-терминации:
@@ -49,7 +49,7 @@
Процесс получения таких сертификатов был неудобным, требовал бумажной волокиты, а сами сертификаты были довольно дорогими.
-Затем появился **
Let's Encrypt**.
+Затем появился **[Let's Encrypt](https://letsencrypt.org/)**.
Это проект Linux Foundation. Он предоставляет **HTTPS‑сертификаты бесплатно**, в автоматическом режиме. Эти сертификаты используют стандартные криптографические механизмы и имеют короткий срок действия (около 3 месяцев), поэтому **безопасность фактически выше** благодаря уменьшенному сроку жизни.
@@ -200,9 +200,9 @@ DNS‑серверы ответят браузеру, какой **конкре
Заголовки прокси:
-*
X-Forwarded-For
-*
X-Forwarded-Proto
-*
X-Forwarded-Host
+* [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For)
+* [X-Forwarded-Proto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto)
+* [X-Forwarded-Host](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host)
///
@@ -218,7 +218,7 @@ DNS‑серверы ответят браузеру, какой **конкре
/// tip | Совет
-Подробнее об этом вы можете узнать в документации: [За прокси — Включить пересылаемые заголовки прокси](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers){.internal-link target=_blank}
+Подробнее об этом вы можете узнать в документации: [За прокси — Включить пересылаемые заголовки прокси](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers)
///
diff --git a/docs/ru/docs/deployment/index.md b/docs/ru/docs/deployment/index.md
index 7e735593be..a64366d4da 100644
--- a/docs/ru/docs/deployment/index.md
+++ b/docs/ru/docs/deployment/index.md
@@ -16,7 +16,7 @@
Вы можете **развернуть сервер** самостоятельно, используя различные инструменты. Например, можно использовать **облачный сервис**, который выполнит часть работы за вас. Также возможны и другие варианты.
-Например, мы, команда, стоящая за FastAPI, создали
**FastAPI Cloud**, чтобы сделать развёртывание приложений FastAPI в облаке как можно более простым и прямолинейным, с тем же удобством для разработчика, что и при работе с FastAPI.
+Например, мы, команда, стоящая за FastAPI, создали [**FastAPI Cloud**](https://fastapicloud.com), чтобы сделать развёртывание приложений FastAPI в облаке как можно более простым и прямолинейным, с тем же удобством для разработчика, что и при работе с FastAPI.
Я покажу вам некоторые из основных концепций, которые вы, вероятно, должны иметь в виду при развертывании приложения **FastAPI** (хотя большинство из них применимо к любому другому типу веб-приложений).
diff --git a/docs/ru/docs/deployment/manually.md b/docs/ru/docs/deployment/manually.md
index 93287372a2..3169f31893 100644
--- a/docs/ru/docs/deployment/manually.md
+++ b/docs/ru/docs/deployment/manually.md
@@ -52,11 +52,11 @@ FastAPI использует стандарт для построения Python
Есть несколько альтернатив, например:
-*
Uvicorn: высокопроизводительный ASGI‑сервер.
-*
Hypercorn: ASGI‑сервер, среди прочего совместимый с HTTP/2 и Trio.
-*
Daphne: ASGI‑сервер, созданный для Django Channels.
-*
Granian: HTTP‑сервер на Rust для Python‑приложений.
-*
NGINX Unit: NGINX Unit — лёгкая и многофункциональная среда выполнения веб‑приложений.
+* [Uvicorn](https://www.uvicorn.dev/): высокопроизводительный ASGI‑сервер.
+* [Hypercorn](https://hypercorn.readthedocs.io/): ASGI‑сервер, среди прочего совместимый с HTTP/2 и Trio.
+* [Daphne](https://github.com/django/daphne): ASGI‑сервер, созданный для Django Channels.
+* [Granian](https://github.com/emmett-framework/granian): HTTP‑сервер на Rust для Python‑приложений.
+* [NGINX Unit](https://unit.nginx.org/howto/fastapi/): NGINX Unit — лёгкая и многофункциональная среда выполнения веб‑приложений.
## Сервер как машина и сервер как программа { #server-machine-and-server-program }
@@ -74,7 +74,7 @@ FastAPI использует стандарт для построения Python
Но вы также можете установить ASGI‑сервер вручную.
-Создайте [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активируйте его и затем установите серверное приложение.
+Создайте [виртуальное окружение](../virtual-environments.md), активируйте его и затем установите серверное приложение.
Например, чтобы установить Uvicorn:
diff --git a/docs/ru/docs/deployment/server-workers.md b/docs/ru/docs/deployment/server-workers.md
index e756ab3774..2caf79f7d8 100644
--- a/docs/ru/docs/deployment/server-workers.md
+++ b/docs/ru/docs/deployment/server-workers.md
@@ -13,13 +13,13 @@
При деплое приложения вам, скорее всего, захочется использовать **репликацию процессов**, чтобы задействовать **несколько ядер** и иметь возможность обрабатывать больше запросов.
-Как вы видели в предыдущей главе о [Концепциях деплоя](concepts.md){.internal-link target=_blank}, существует несколько стратегий.
+Как вы видели в предыдущей главе о [Концепциях деплоя](concepts.md), существует несколько стратегий.
Здесь я покажу, как использовать **Uvicorn** с **воркер-процессами** через команду `fastapi` или напрямую через команду `uvicorn`.
/// info | Информация
-Если вы используете контейнеры, например Docker или Kubernetes, я расскажу об этом подробнее в следующей главе: [FastAPI в контейнерах — Docker](docker.md){.internal-link target=_blank}.
+Если вы используете контейнеры, например Docker или Kubernetes, я расскажу об этом подробнее в следующей главе: [FastAPI в контейнерах — Docker](docker.md).
В частности, при запуске в **Kubernetes** вам, скорее всего, **не** понадобится использовать воркеры — вместо этого запускайте **один процесс Uvicorn на контейнер**, но об этом подробнее далее в той главе.
@@ -126,7 +126,7 @@ $ uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
## Контейнеры и Docker { #containers-and-docker }
-В следующей главе о [FastAPI в контейнерах — Docker](docker.md){.internal-link target=_blank} я объясню стратегии, которые можно использовать для решения остальных **концепций деплоя**.
+В следующей главе о [FastAPI в контейнерах — Docker](docker.md) я объясню стратегии, которые можно использовать для решения остальных **концепций деплоя**.
Я покажу, как **собрать свой образ с нуля**, чтобы запускать один процесс Uvicorn. Это простой подход и, вероятно, именно то, что вам нужно при использовании распределённой системы управления контейнерами, такой как **Kubernetes**.
diff --git a/docs/ru/docs/deployment/versions.md b/docs/ru/docs/deployment/versions.md
index 4195d689fe..b52ca456f2 100644
--- a/docs/ru/docs/deployment/versions.md
+++ b/docs/ru/docs/deployment/versions.md
@@ -4,7 +4,7 @@
Часто добавляются новые функции, регулярно исправляются баги, код продолжает постоянно совершенствоваться.
-По указанным причинам текущие версии до сих пор `0.x.x`. Это говорит о том, что каждая версия может содержать обратно несовместимые изменения, следуя
Семантическому версионированию.
+По указанным причинам текущие версии до сих пор `0.x.x`. Это говорит о том, что каждая версия может содержать обратно несовместимые изменения, следуя [Семантическому версионированию](https://semver.org/).
Уже сейчас вы можете создавать приложения в продакшн, используя **FastAPI** (и скорее всего так и делаете), главное убедиться в том, что вы используете версию, которая корректно работает с вашим кодом.
@@ -34,7 +34,7 @@ fastapi[standard]>=0.112.0,<0.113.0
## Доступные версии { #available-versions }
-Вы можете посмотреть доступные версии (например, проверить последнюю на данный момент) в [Примечаниях к выпуску](../release-notes.md){.internal-link target=_blank}.
+Вы можете посмотреть доступные версии (например, проверить последнюю на данный момент) в [Примечаниях к выпуску](../release-notes.md).
## О версиях { #about-versions }
@@ -66,7 +66,7 @@ fastapi>=0.45.0,<0.46.0
Вам следует добавить тесты для вашего приложения.
-С помощью **FastAPI** это очень просто (благодаря Starlette), см. документацию: [Тестирование](../tutorial/testing.md){.internal-link target=_blank}
+С помощью **FastAPI** это очень просто (благодаря Starlette), см. документацию: [Тестирование](../tutorial/testing.md)
После создания тестов вы можете обновить свою версию **FastAPI** до более новой. После этого следует убедиться, что ваш код работает корректно, запустив тесты.
diff --git a/docs/ru/docs/editor-support.md b/docs/ru/docs/editor-support.md
new file mode 100644
index 0000000000..0543e7162d
--- /dev/null
+++ b/docs/ru/docs/editor-support.md
@@ -0,0 +1,23 @@
+# Поддержка редактора кода { #editor-support }
+
+Официальное [расширение FastAPI](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) улучшает ваш процесс разработки на FastAPI за счет обнаружения и навигации по *операциям пути* (обработчикам пути), а также развертывания в FastAPI Cloud и потоковой передачи логов в реальном времени.
+
+Подробности о расширении смотрите в README в [репозитории GitHub](https://github.com/fastapi/fastapi-vscode).
+
+## Установка и настройка { #setup-and-installation }
+
+**Расширение FastAPI** доступно как для [VS Code](https://code.visualstudio.com/), так и для [Cursor](https://www.cursor.com/). Его можно установить напрямую из панели расширений в каждом редакторе кода, выполнив поиск по «FastAPI» и выбрав расширение от **FastAPI Labs**. Расширение также работает в браузерных редакторах кода, таких как [vscode.dev](https://vscode.dev) и [github.dev](https://github.dev).
+
+### Обнаружение приложения { #application-discovery }
+
+По умолчанию расширение автоматически обнаруживает приложения FastAPI в вашем рабочем пространстве, сканируя файлы, где создается экземпляр `FastAPI()`. Если авто-обнаружение не подходит для структуры вашего проекта, вы можете указать точку входа через `[tool.fastapi]` в `pyproject.toml` или настройку VS Code `fastapi.entryPoint`, используя модульную нотацию (например, `myapp.main:app`).
+
+## Возможности { #features }
+
+- **Обозреватель операций пути** — древовидное представление на боковой панели всех
*операций пути* вашего приложения. Нажмите, чтобы перейти к любому маршруту или определению роутера.
+- **Поиск маршрутов** — поиск по пути, методу или имени с помощью
Ctrl +
Shift +
E (на macOS:
Cmd +
Shift +
E).
+- **Навигация CodeLens** — кликабельные ссылки над вызовами тестового клиента (например, `client.get('/items')`), которые переходят к соответствующей *операции пути* для быстрой навигации между тестами и реализацией.
+- **Развернуть в FastAPI Cloud** — развертывание вашего приложения в один клик в [FastAPI Cloud](https://fastapicloud.com/).
+- **Поток логов приложения** — потоковая передача логов в реальном времени из вашего приложения, развернутого в FastAPI Cloud, с фильтрацией по уровню и текстовым поиском.
+
+Если вы хотите поверхностно ознакомиться с возможностями расширения, откройте палитру команд (
Ctrl +
Shift +
P или на macOS:
Cmd +
Shift +
P), выберите «Welcome: Open walkthrough...», а затем «Get started with FastAPI».
diff --git a/docs/ru/docs/environment-variables.md b/docs/ru/docs/environment-variables.md
index 759127420f..8db16d16c6 100644
--- a/docs/ru/docs/environment-variables.md
+++ b/docs/ru/docs/environment-variables.md
@@ -65,7 +65,7 @@ print(f"Hello {name} from Python")
/// tip | Совет
-Второй аргумент
`os.getenv()` - это возвращаемое по умолчанию значение.
+Второй аргумент [`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) - это возвращаемое по умолчанию значение.
Если значение не указано, то по умолчанию оно равно `None`. В данном случае мы указываем `«World»` в качестве значения по умолчанию.
@@ -153,7 +153,7 @@ Hello World from Python
/// tip | Совет
-Подробнее об этом можно прочитать на сайте
The Twelve-Factor App: Config.
+Подробнее об этом можно прочитать на сайте [The Twelve-Factor App: Config](https://12factor.net/config).
///
@@ -163,7 +163,7 @@ Hello World from Python
Это означает, что **любое значение**, считанное в Python из переменной окружения, **будет `str`**, и любое преобразование к другому типу или любая валидация должны быть выполнены в коде.
-Подробнее об использовании переменных окружения для работы с **настройками приложения** вы узнаете в [Расширенное руководство пользователя - Настройки и переменные среды](./advanced/settings.md){.internal-link target=_blank}.
+Подробнее об использовании переменных окружения для работы с **настройками приложения** вы узнаете в [Расширенное руководство пользователя - Настройки и переменные среды](./advanced/settings.md).
## Переменная окружения `PATH` { #path-environment-variable }
@@ -285,13 +285,13 @@ $ C:\opt\custompython\bin\python
////
-Эта информация будет полезна при изучении [Виртуальных окружений](virtual-environments.md){.internal-link target=_blank}.
+Эта информация будет полезна при изучении [Виртуальных окружений](virtual-environments.md).
## Вывод { #conclusion }
Благодаря этому вы должны иметь базовое представление о том, что такое **переменные окружения** и как использовать их в Python.
-Подробнее о них вы также можете прочитать в
статье о переменных окружения на википедии.
+Подробнее о них вы также можете прочитать в [статье о переменных окружения на википедии](https://en.wikipedia.org/wiki/Environment_variable).
Во многих случаях не всегда очевидно, как переменные окружения могут быть полезны и применимы. Но они постоянно появляются в различных сценариях разработки, поэтому знать о них полезно.
diff --git a/docs/ru/docs/fastapi-cli.md b/docs/ru/docs/fastapi-cli.md
index a46e0053ee..1dc558a8c1 100644
--- a/docs/ru/docs/fastapi-cli.md
+++ b/docs/ru/docs/fastapi-cli.md
@@ -1,15 +1,15 @@
# FastAPI CLI { #fastapi-cli }
-**FastAPI CLI** это программа командной строки, которую вы можете использовать для запуска вашего FastAPI приложения, для управления FastAPI-проектом, а также для многих других вещей.
+**FastAPI
CLI** - это программа командной строки, которую вы можете использовать, чтобы предоставлять доступ к вашему приложению FastAPI, управлять проектом FastAPI и т.д.
-`fastapi-cli` устанавливается вместе со стандартным пакетом FastAPI (при запуске команды `pip install "fastapi[standard]"`). Данный пакет предоставляет доступ к программе `fastapi` через терминал.
+При установке FastAPI (например, с помощью `pip install "fastapi[standard]"`) вместе с ним устанавливается программа командной строки, которую можно запускать в терминале.
-Чтобы запустить приложение FastAPI в режиме разработки, вы можете использовать команду `fastapi dev`:
+Чтобы запустить ваше приложение FastAPI в режиме разработки, используйте команду `fastapi dev`:
```console
-$
fastapi dev
main.py
+$
fastapi dev
FastAPI Starting development server 🚀
@@ -46,13 +46,66 @@ $
fastapi dev
Uvicorn, высокопроизводительный, готовый к работе в продакшн ASGI-сервер. 😎
+Кроме того, другие инструменты могут не найти его, например [Расширение VS Code](editor-support.md) или [FastAPI Cloud](https://fastapicloud.com), поэтому рекомендуется использовать `entrypoint` в `pyproject.toml`.
## `fastapi dev` { #fastapi-dev }
@@ -70,6 +123,6 @@ FastAPI CLI берет путь к вашей Python-программе (нап
/// tip | Подсказка
-Вы можете больше узнать об этом в [документации по развертыванию](deployment/index.md){.internal-link target=_blank}.
+Вы можете больше узнать об этом в [документации по развертыванию](deployment/index.md).
///
diff --git a/docs/ru/docs/features.md b/docs/ru/docs/features.md
index 0bc3dbb2d1..f779c798cc 100644
--- a/docs/ru/docs/features.md
+++ b/docs/ru/docs/features.md
@@ -6,8 +6,8 @@
### Основано на открытых стандартах { #based-on-open-standards }
-* OpenAPI для создания API, включая объявления операций пути, параметров, тел запросов, безопасности и т.д.
-* Автоматическая документация моделей данных с помощью JSON Schema (так как сама спецификация OpenAPI основана на JSON Schema).
+* [**OpenAPI**](https://github.com/OAI/OpenAPI-Specification) для создания API, включая объявления операций пути, параметров, тел запросов, безопасности и т.д.
+* Автоматическая документация моделей данных с помощью [**JSON Schema**](https://json-schema.org/) (так как сама спецификация OpenAPI основана на JSON Schema).
* Разработан вокруг этих стандартов, после тщательного их изучения. Это не дополнительная надстройка поверх.
* Это также позволяет использовать автоматическую **генерацию клиентского кода** на многих языках.
@@ -15,11 +15,11 @@
Интерактивная документация для API и исследовательские веб-интерфейсы. Поскольку фреймворк основан на OpenAPI, существует несколько вариантов документирования, 2 из них включены по умолчанию.
-* Swagger UI, с интерактивным исследованием, вызовом и тестированием вашего API прямо из браузера.
+* [**Swagger UI**](https://github.com/swagger-api/swagger-ui), с интерактивным исследованием, вызовом и тестированием вашего API прямо из браузера.
-* Альтернативная документация API в ReDoc.
+* Альтернативная документация API в [**ReDoc**](https://github.com/Rebilly/ReDoc).
@@ -27,7 +27,7 @@
Все основано на стандартных **аннотациях типов Python** (благодаря Pydantic). Не нужно изучать новый синтаксис. Только стандартный современный Python.
-Если вам нужно освежить знания о типах в Python (даже если вы не используете FastAPI), выделите 2 минуты и просмотрите краткое руководство: [Типы Python](python-types.md){.internal-link target=_blank}.
+Если вам нужно освежить знания о типах в Python (даже если вы не используете FastAPI), выделите 2 минуты и просмотрите краткое руководство: [Типы Python](python-types.md).
Вы пишете стандартный Python с типами:
@@ -75,7 +75,7 @@ my_second_user: User = User(**second_user_data)
Весь фреймворк был продуман так, чтобы быть простым и интуитивно понятным в использовании, все решения были проверены на множестве редакторов еще до начала разработки, чтобы обеспечить наилучшие условия при написании кода.
-В опросах Python‑разработчиков видно, что одной из самых часто используемых функций является «автозавершение».
+В опросах Python‑разработчиков видно, [что одной из самых часто используемых функций является «автозавершение»](https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features).
Вся структура **FastAPI** основана на удовлетворении этой возможности. Автозавершение работает везде.
@@ -83,11 +83,11 @@ my_second_user: User = User(**second_user_data)
Вот как ваш редактор может вам помочь:
-* в Visual Studio Code:
+* в [Visual Studio Code](https://code.visualstudio.com/):
-* в PyCharm:
+* в [PyCharm](https://www.jetbrains.com/pycharm/):
@@ -124,7 +124,7 @@ FastAPI имеет продуманные значения **по умолчан
Все схемы безопасности, определённые в OpenAPI, включая:
* HTTP Basic.
-* **OAuth2** (также с **токенами JWT**). Ознакомьтесь с руководством [OAuth2 с JWT](tutorial/security/oauth2-jwt.md){.internal-link target=_blank}.
+* **OAuth2** (также с **токенами JWT**). Ознакомьтесь с руководством [OAuth2 с JWT](tutorial/security/oauth2-jwt.md).
* Ключи API в:
* HTTP-заголовках.
* Параметрах запросов.
@@ -159,13 +159,13 @@ FastAPI включает в себя чрезвычайно простую в и
## Возможности Starlette { #starlette-features }
-**FastAPI** основан на Starlette и полностью совместим с ним. Так что любой дополнительный код Starlette, который у вас есть, также будет работать.
+**FastAPI** основан на [**Starlette**](https://www.starlette.dev/) и полностью совместим с ним. Так что любой дополнительный код Starlette, который у вас есть, также будет работать.
На самом деле, `FastAPI` — это подкласс `Starlette`. Таким образом, если вы уже знаете или используете Starlette, большая часть функционала будет работать так же.
С **FastAPI** вы получаете все возможности **Starlette** (так как FastAPI — это всего лишь Starlette на стероидах):
-* Серьёзно впечатляющая производительность. Это один из самых быстрых фреймворков на Python, наравне с **NodeJS** и **Go**.
+* Серьёзно впечатляющая производительность. Это [один из самых быстрых фреймворков на Python, наравне с **NodeJS** и **Go**](https://github.com/encode/starlette#performance).
* Поддержка **WebSocket**.
* Фоновые задачи в том же процессе.
* События запуска и выключения.
@@ -177,7 +177,7 @@ FastAPI включает в себя чрезвычайно простую в и
## Возможности Pydantic { #pydantic-features }
-**FastAPI** полностью совместим с (и основан на) Pydantic. Поэтому любой дополнительный код Pydantic, который у вас есть, также будет работать.
+**FastAPI** полностью совместим с (и основан на) [**Pydantic**](https://docs.pydantic.dev/). Поэтому любой дополнительный код Pydantic, который у вас есть, также будет работать.
Включая внешние библиотеки, также основанные на Pydantic, такие как ORM’ы, ODM’ы для баз данных.
diff --git a/docs/ru/docs/help-fastapi.md b/docs/ru/docs/help-fastapi.md
index 6bfabb96cb..1d274e96a2 100644
--- a/docs/ru/docs/help-fastapi.md
+++ b/docs/ru/docs/help-fastapi.md
@@ -12,7 +12,7 @@
## Подписаться на новостную рассылку { #subscribe-to-the-newsletter }
-Вы можете подписаться на редкую [новостную рассылку **FastAPI и его друзья**](newsletter.md){.internal-link target=_blank} и быть в курсе о:
+Вы можете подписаться на редкую [новостную рассылку **FastAPI и его друзья**](newsletter.md) и быть в курсе о:
* Новостях о FastAPI и его друзьях 🚀
* Руководствах 📝
@@ -22,17 +22,17 @@
## Подписаться на FastAPI в X (Twitter) { #follow-fastapi-on-x-twitter }
-Подписаться на @fastapi в **X (Twitter)** для получения наисвежайших новостей о **FastAPI**. 🐦
+[Подписаться на @fastapi в **X (Twitter)**](https://x.com/fastapi) для получения наисвежайших новостей о **FastAPI**. 🐦
## Добавить **FastAPI** звезду на GitHub { #star-fastapi-in-github }
-Вы можете добавить FastAPI "звезду" на GitHub (кликнув на кнопку звезды в правом верхнем углу): https://github.com/fastapi/fastapi. ⭐️
+Вы можете добавить FastAPI "звезду" на GitHub (кликнув на кнопку звезды в правом верхнем углу): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). ⭐️
Чем больше звёзд, тем легче другим пользователям найти проект и увидеть, что он уже оказался полезным для многих.
## Отслеживать свежие выпуски в репозитории на GitHub { #watch-the-github-repository-for-releases }
-Вы можете "отслеживать" FastAPI на GitHub (кликнув по кнопке "watch" наверху справа): https://github.com/fastapi/fastapi. 👀
+Вы можете "отслеживать" FastAPI на GitHub (кликнув по кнопке "watch" наверху справа): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀
Там же Вы можете выбрать "Releases only".
@@ -40,45 +40,45 @@
## Связаться с автором { #connect-with-the-author }
-Можно связаться со мной (Sebastián Ramírez / `tiangolo`), автором.
+Можно связаться со [мной (Sebastián Ramírez / `tiangolo`)](https://tiangolo.com), автором.
Вы можете:
-* Подписаться на меня на **GitHub**.
+* [Подписаться на меня на **GitHub**](https://github.com/tiangolo).
* Посмотреть другие мои проекты с открытым кодом, которые могут быть полезны Вам.
* Подписаться, чтобы видеть, когда я создаю новый проект с открытым кодом.
-* Подписаться на меня в **X (Twitter)** или в Mastodon.
+* [Подписаться на меня в **X (Twitter)**](https://x.com/tiangolo) или в [Mastodon](https://fosstodon.org/@tiangolo).
* Поделиться со мной, как Вы используете FastAPI (я обожаю это читать).
* Узнавать, когда я делаю объявления или выпускаю новые инструменты.
- * Вы также можете подписаться на @fastapi в X (Twitter) (это отдельный аккаунт).
-* Подписаться на меня в **LinkedIn**.
+ * Вы также можете [подписаться на @fastapi в X (Twitter)](https://x.com/fastapi) (это отдельный аккаунт).
+* [Подписаться на меня в **LinkedIn**](https://www.linkedin.com/in/tiangolo/).
* Узнавать, когда я делаю объявления или выпускаю новые инструменты (хотя чаще я использую X (Twitter) 🤷♂).
-* Читать, что я пишу (или подписаться на меня) на **Dev.to** или **Medium**.
+* Читать, что я пишу (или подписаться на меня) на [**Dev.to**](https://dev.to/tiangolo) или [**Medium**](https://medium.com/@tiangolo).
* Читать другие идеи, статьи и о созданных мной инструментах.
* Подписаться, чтобы читать, когда я публикую что-то новое.
## Оставить сообщение в X (Twitter) о **FastAPI** { #tweet-about-fastapi }
-Оставьте сообщение в X (Twitter) о **FastAPI** и позвольте мне и другим узнать, почему он Вам нравится. 🎉
+[Оставьте сообщение в X (Twitter) о **FastAPI**](https://x.com/compose/tweet?text=I'm loving @fastapi because... https://github.com/fastapi/fastapi) и позвольте мне и другим узнать, почему он Вам нравится. 🎉
Я люблю узнавать о том, как **FastAPI** используется, что Вам понравилось в нём, в каких проектах/компаниях Вы его используете и т.д.
## Оставить голос за FastAPI { #vote-for-fastapi }
-* Голосуйте за **FastAPI** в Slant.
-* Голосуйте за **FastAPI** в AlternativeTo.
-* Расскажите, что Вы используете **FastAPI** на StackShare.
+* [Голосуйте за **FastAPI** в Slant](https://www.slant.co/options/34241/~fastapi-review).
+* [Голосуйте за **FastAPI** в AlternativeTo](https://alternativeto.net/software/fastapi/about/).
+* [Расскажите, что Вы используете **FastAPI** на StackShare](https://stackshare.io/pypi-fastapi).
## Помочь другим с вопросами на GitHub { #help-others-with-questions-in-github }
Вы можете попробовать помочь другим с их вопросами в:
-* GitHub Discussions
-* GitHub Issues
+* [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered)
+* [GitHub Issues](https://github.com/fastapi/fastapi/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Aquestion+-label%3Aanswered+)
Во многих случаях Вы уже можете знать ответы на эти вопросы. 🤓
-Если Вы много помогаете людям с их вопросами, Вы станете официальным [Экспертом FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}. 🎉
+Если Вы много помогаете людям с их вопросами, Вы станете официальным [Экспертом FastAPI](fastapi-people.md#fastapi-experts). 🎉
Только помните, самое важное — постарайтесь быть добрыми. Люди приходят со своими разочарованиями и часто задают вопросы не лучшим образом, но постарайтесь, насколько можете, быть доброжелательными. 🤗
@@ -104,7 +104,7 @@
Во многих случаях предоставляют только фрагмент кода, но этого недостаточно, чтобы **воспроизвести проблему**.
-* Попросите предоставить минимальный воспроизводимый пример, который Вы сможете **скопировать-вставить** и запустить локально, чтобы увидеть ту же ошибку или поведение, или лучше понять их кейс.
+* Попросите предоставить [минимальный воспроизводимый пример](https://stackoverflow.com/help/minimal-reproducible-example), который Вы сможете **скопировать-вставить** и запустить локально, чтобы увидеть ту же ошибку или поведение, или лучше понять их кейс.
* Если чувствуете себя особенно великодушными, можете попытаться **создать такой пример** сами, основываясь только на описании проблемы. Просто помните, что это может занять много времени, и, возможно, сначала лучше попросить уточнить проблему.
@@ -124,7 +124,7 @@
## Отслеживать репозиторий на GitHub { #watch-the-github-repository }
-Вы можете "отслеживать" FastAPI на GitHub (кликнув по кнопке "watch" наверху справа): https://github.com/fastapi/fastapi. 👀
+Вы можете "отслеживать" FastAPI на GitHub (кликнув по кнопке "watch" наверху справа): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀
Если Вы выберете "Watching" вместо "Releases only", то будете получать уведомления, когда кто-либо создаёт новый вопрос или Issue. Вы также можете указать, что хотите получать уведомления только о новых Issues, или обсуждениях, или пулл-реквестах и т.д.
@@ -132,7 +132,7 @@
## Задать вопросы { #ask-questions }
-Вы можете создать новый вопрос в репозитории GitHub, например:
+Вы можете [создать новый вопрос](https://github.com/fastapi/fastapi/discussions/new?category=questions) в репозитории GitHub, например:
* Задать **вопрос** или спросить о **проблеме**.
* Предложить новую **возможность**.
@@ -195,12 +195,12 @@
## Создать пулл-реквест { #create-a-pull-request }
-Вы можете [сделать вклад](contributing.md){.internal-link target=_blank} в исходный код пулл-реквестами, например:
+Вы можете [сделать вклад](contributing.md) в исходный код пулл-реквестами, например:
* Исправить опечатку, найденную в документации.
-* Поделиться статьёй, видео или подкастом о FastAPI, которые Вы создали или нашли, изменив этот файл.
+* Поделиться статьёй, видео или подкастом о FastAPI, которые Вы создали или нашли, [изменив этот файл](https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml).
* Убедитесь, что добавили свою ссылку в начало соответствующего раздела.
-* Помочь с [переводом документации](contributing.md#translations){.internal-link target=_blank} на Ваш язык.
+* Помочь с [переводом документации](contributing.md#translations) на Ваш язык.
* Вы также можете проверять переводы, сделанные другими.
* Предложить новые разделы документации.
* Исправить существующую проблему/баг.
@@ -217,8 +217,8 @@
Основные задачи, которые Вы можете выполнить прямо сейчас:
-* [Помочь другим с вопросами на GitHub](#help-others-with-questions-in-github){.internal-link target=_blank} (смотрите секцию выше).
-* [Проверять пулл-реквесты](#review-pull-requests){.internal-link target=_blank} (смотрите секцию выше).
+* [Помочь другим с вопросами на GitHub](#help-others-with-questions-in-github) (смотрите секцию выше).
+* [Проверять пулл-реквесты](#review-pull-requests) (смотрите секцию выше).
Именно эти две задачи **забирают больше всего времени**. Это основная работа по поддержке FastAPI.
@@ -226,11 +226,11 @@
## Подключиться к чату { #join-the-chat }
-Подключайтесь к 👥 серверу чата в Discord 👥 и общайтесь с другими участниками сообщества FastAPI.
+Подключайтесь к 👥 [серверу чата в Discord](https://discord.gg/VQjSZaeJmf) 👥 и общайтесь с другими участниками сообщества FastAPI.
/// tip | Подсказка
-По вопросам — задавайте их в GitHub Discussions, так гораздо выше шанс, что Вы получите помощь от [Экспертов FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}.
+По вопросам — задавайте их в [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/new?category=questions), так гораздо выше шанс, что Вы получите помощь от [Экспертов FastAPI](fastapi-people.md#fastapi-experts).
Используйте чат только для прочих общих бесед.
@@ -242,13 +242,13 @@
На GitHub шаблон поможет Вам правильно сформулировать вопрос, чтобы Вам было легче получить хороший ответ или даже решить проблему самостоятельно ещё до того, как спросите. И на GitHub я могу следить за тем, чтобы всегда отвечать на всё, даже если это занимает время. А с чатами я не могу сделать этого лично. 😅
-Кроме того, переписка в чатах хуже ищется, чем на GitHub, поэтому вопросы и ответы могут теряться среди остальных сообщений. И только те, что на GitHub, учитываются для получения лычки [Эксперт FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}, так что вероятнее всего Вы получите больше внимания именно на GitHub.
+Кроме того, переписка в чатах хуже ищется, чем на GitHub, поэтому вопросы и ответы могут теряться среди остальных сообщений. И только те, что на GitHub, учитываются для получения лычки [Эксперт FastAPI](fastapi-people.md#fastapi-experts), так что вероятнее всего Вы получите больше внимания именно на GitHub.
С другой стороны, в чатах тысячи пользователей, так что почти всегда есть шанс найти там кого-то для разговора. 😄
## Спонсировать автора { #sponsor-the-author }
-Если Ваш **продукт/компания** зависят от **FastAPI** или связаны с ним и Вы хотите донести до пользователей информацию о себе, Вы можете спонсировать автора (меня) через GitHub Sponsors. В зависимости от уровня поддержки Вы можете получить дополнительные бонусы, например, бейдж в документации. 🎁
+Если Ваш **продукт/компания** зависят от **FastAPI** или связаны с ним и Вы хотите донести до пользователей информацию о себе, Вы можете спонсировать автора (меня) через [GitHub Sponsors](https://github.com/sponsors/tiangolo). В зависимости от уровня поддержки Вы можете получить дополнительные бонусы, например, бейдж в документации. 🎁
---
diff --git a/docs/ru/docs/history-design-future.md b/docs/ru/docs/history-design-future.md
index 5019157600..00969461dc 100644
--- a/docs/ru/docs/history-design-future.md
+++ b/docs/ru/docs/history-design-future.md
@@ -1,6 +1,6 @@
# История, проектирование и будущее { #history-design-and-future }
-Однажды, один из пользователей **FastAPI** задал вопрос:
+Однажды, [один из пользователей **FastAPI** задал вопрос](https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920):
> Какова история этого проекта? Создаётся впечатление, что он явился из ниоткуда и завоевал мир за несколько недель [...]
@@ -14,7 +14,7 @@
Во многом история **FastAPI** - история его предшественников.
-Как написано в разделе [Альтернативы](alternatives.md){.internal-link target=_blank}:
+Как написано в разделе [Альтернативы](alternatives.md):
@@ -44,7 +44,7 @@
Я проверил несколько идей на самых популярных редакторах кода: PyCharm, VS Code, редакторы на базе Jedi.
-Согласно последнему опросу Python-разработчиков, который охватывает около 80% пользователей.
+Согласно последнему [опросу Python-разработчиков](https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools), который охватывает около 80% пользователей.
Это означает, что **FastAPI** был специально проверен на редакторах, используемых 80% Python-разработчиками. И поскольку большинство других редакторов, как правило, работают аналогичным образом, все его преимущества должны работать практически для всех редакторов.
@@ -54,11 +54,11 @@
## Зависимости { #requirements }
-Протестировав несколько вариантов, я решил, что в качестве основы буду использовать **Pydantic** и его преимущества.
+Протестировав несколько вариантов, я решил, что в качестве основы буду использовать [**Pydantic**](https://docs.pydantic.dev/) и его преимущества.
По моим предложениям был изменён код этого фреймворка, чтобы сделать его полностью совместимым с JSON Schema, поддержать различные способы определения ограничений и улучшить поддержку в редакторах кода (проверки типов, автозавершение) на основе тестов в нескольких редакторах.
-Во время разработки я также внес вклад в **Starlette**, другую ключевую зависимость.
+Во время разработки я также внес вклад в [**Starlette**](https://www.starlette.dev/), другую ключевую зависимость.
## Разработка { #development }
@@ -76,4 +76,4 @@
У **FastAPI** великое будущее.
-И [ваш вклад в это](help-fastapi.md){.internal-link target=_blank} - очень ценен.
+И [ваша помощь](help-fastapi.md) очень ценится.
diff --git a/docs/ru/docs/how-to/authentication-error-status-code.md b/docs/ru/docs/how-to/authentication-error-status-code.md
index 596563c541..acbc18f336 100644
--- a/docs/ru/docs/how-to/authentication-error-status-code.md
+++ b/docs/ru/docs/how-to/authentication-error-status-code.md
@@ -2,7 +2,7 @@
До версии FastAPI `0.122.0`, когда встроенные утилиты безопасности возвращали ошибку клиенту после неудачной аутентификации, они использовали HTTP статус-код `403 Forbidden`.
-Начиная с версии FastAPI `0.122.0`, используется более подходящий HTTP статус-код `401 Unauthorized`, и в ответе возвращается имеющий смысл HTTP-заголовок `WWW-Authenticate` в соответствии со спецификациями HTTP, RFC 7235, RFC 9110.
+Начиная с версии FastAPI `0.122.0`, используется более подходящий HTTP статус-код `401 Unauthorized`, и в ответе возвращается имеющий смысл HTTP-заголовок `WWW-Authenticate` в соответствии со спецификациями HTTP, [RFC 7235](https://datatracker.ietf.org/doc/html/rfc7235#section-3.1), [RFC 9110](https://datatracker.ietf.org/doc/html/rfc9110#name-401-unauthorized).
Но если по какой-то причине ваши клиенты зависят от старого поведения, вы можете вернуть его, переопределив метод `make_not_authenticated_error` в ваших Security-классах.
diff --git a/docs/ru/docs/how-to/conditional-openapi.md b/docs/ru/docs/how-to/conditional-openapi.md
index 6efa30608e..5fece06c14 100644
--- a/docs/ru/docs/how-to/conditional-openapi.md
+++ b/docs/ru/docs/how-to/conditional-openapi.md
@@ -10,7 +10,7 @@
Если в вашем коде есть уязвимость, она всё равно останется.
-Сокрытие документации лишь усложняет понимание того, как взаимодействовать с вашим API, и может усложнить его отладку в продакшн. Это можно считать просто разновидностью безопасности через сокрытие.
+Сокрытие документации лишь усложняет понимание того, как взаимодействовать с вашим API, и может усложнить его отладку в продакшн. Это можно считать просто разновидностью [безопасности через сокрытие](https://en.wikipedia.org/wiki/Security_through_obscurity).
Если вы хотите обезопасить свой API, есть несколько более эффективных вещей, которые можно сделать, например:
diff --git a/docs/ru/docs/how-to/configure-swagger-ui.md b/docs/ru/docs/how-to/configure-swagger-ui.md
index f4f2a0e549..b57a086b6c 100644
--- a/docs/ru/docs/how-to/configure-swagger-ui.md
+++ b/docs/ru/docs/how-to/configure-swagger-ui.md
@@ -1,6 +1,6 @@
# Настройка Swagger UI { #configure-swagger-ui }
-Вы можете настроить дополнительные параметры Swagger UI.
+Вы можете настроить дополнительные [параметры Swagger UI](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/).
Чтобы настроить их, передайте аргумент `swagger_ui_parameters` при создании объекта приложения `FastAPI()` или в функцию `get_swagger_ui_html()`.
@@ -50,7 +50,7 @@ FastAPI включает некоторые параметры конфигур
## Другие параметры Swagger UI { #other-swagger-ui-parameters }
-Чтобы увидеть все остальные возможные настройки, прочитайте официальную документацию по параметрам Swagger UI.
+Чтобы увидеть все остальные возможные настройки, прочитайте официальную [документацию по параметрам Swagger UI](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/).
## Настройки только для JavaScript { #javascript-only-settings }
diff --git a/docs/ru/docs/how-to/custom-docs-ui-assets.md b/docs/ru/docs/how-to/custom-docs-ui-assets.md
index e3c31b32c5..b8398cdb08 100644
--- a/docs/ru/docs/how-to/custom-docs-ui-assets.md
+++ b/docs/ru/docs/how-to/custom-docs-ui-assets.md
@@ -54,7 +54,7 @@ Swagger UI сделает это за вас «за кулисами», но д
### Тестирование { #test-it }
-Теперь вы должны иметь возможность открыть свою документацию по адресу http://127.0.0.1:8000/docs и перезагрузить страницу — «ассеты» (статические файлы) будут загружаться с нового CDN.
+Теперь вы должны иметь возможность открыть свою документацию по адресу [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) и перезагрузить страницу — «ассеты» (статические файлы) будут загружаться с нового CDN.
## Самостоятельный хостинг JavaScript и CSS для документации { #self-hosting-javascript-and-css-for-docs }
@@ -93,12 +93,12 @@ Swagger UI сделает это за вас «за кулисами», но д
**Swagger UI** использует файлы:
-* `swagger-ui-bundle.js`
-* `swagger-ui.css`
+* [`swagger-ui-bundle.js`](https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js)
+* [`swagger-ui.css`](https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css)
А **ReDoc** использует файл:
-* `redoc.standalone.js`
+* [`redoc.standalone.js`](https://cdn.jsdelivr.net/npm/redoc@2/bundles/redoc.standalone.js)
После этого структура файлов может выглядеть так:
@@ -122,7 +122,7 @@ Swagger UI сделает это за вас «за кулисами», но д
### Протестируйте статические файлы { #test-the-static-files }
-Запустите своё приложение и откройте http://127.0.0.1:8000/static/redoc.standalone.js.
+Запустите своё приложение и откройте [http://127.0.0.1:8000/static/redoc.standalone.js](http://127.0.0.1:8000/static/redoc.standalone.js).
Вы должны увидеть очень длинный JavaScript-файл для **ReDoc**.
@@ -180,6 +180,6 @@ Swagger UI сделает это за вас «за кулисами», но д
### Тестирование UI со статическими файлами { #test-static-files-ui }
-Теперь вы можете отключить Wi‑Fi, открыть свою документацию по адресу http://127.0.0.1:8000/docs и перезагрузить страницу.
+Теперь вы можете отключить Wi‑Fi, открыть свою документацию по адресу [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) и перезагрузить страницу.
Даже без Интернета вы сможете видеть документацию к своему API и взаимодействовать с ним.
diff --git a/docs/ru/docs/how-to/custom-request-and-route.md b/docs/ru/docs/how-to/custom-request-and-route.md
index feef9670ad..1e3a608562 100644
--- a/docs/ru/docs/how-to/custom-request-and-route.md
+++ b/docs/ru/docs/how-to/custom-request-and-route.md
@@ -18,7 +18,7 @@
Некоторые сценарии:
-* Преобразование тел запросов, не в формате JSON, в JSON (например, `msgpack`).
+* Преобразование тел запросов, не в формате JSON, в JSON (например, [`msgpack`](https://msgpack.org/index.html)).
* Распаковка тел запросов, сжатых с помощью gzip.
* Автоматическое логирование всех тел запросов.
@@ -32,7 +32,7 @@
/// tip | Совет
-Это учебный пример, демонстрирующий принцип работы. Если вам нужна поддержка Gzip, вы можете использовать готовый [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware){.internal-link target=_blank}.
+Это учебный пример, демонстрирующий принцип работы. Если вам нужна поддержка Gzip, вы можете использовать готовый [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware).
///
@@ -66,7 +66,7 @@
Именно этих двух компонентов — `scope` и `receive` — достаточно, чтобы создать новый экземпляр `Request`.
-Чтобы узнать больше о `Request`, см. документацию Starlette о запросах.
+Чтобы узнать больше о `Request`, см. [документацию Starlette о запросах](https://www.starlette.dev/requests/).
///
@@ -82,7 +82,7 @@
/// tip | Совет
-Для решения этой задачи, вероятно, намного проще использовать `body` в пользовательском обработчике `RequestValidationError` ([Обработка ошибок](../tutorial/handling-errors.md#use-the-requestvalidationerror-body){.internal-link target=_blank}).
+Для решения этой задачи, вероятно, намного проще использовать `body` в пользовательском обработчике `RequestValidationError` ([Обработка ошибок](../tutorial/handling-errors.md#use-the-requestvalidationerror-body)).
Но этот пример всё равно актуален и показывает, как взаимодействовать с внутренними компонентами.
diff --git a/docs/ru/docs/how-to/extending-openapi.md b/docs/ru/docs/how-to/extending-openapi.md
index 197a1790a2..c1e369f5e5 100644
--- a/docs/ru/docs/how-to/extending-openapi.md
+++ b/docs/ru/docs/how-to/extending-openapi.md
@@ -37,7 +37,7 @@
Используя информацию выше, вы можете той же вспомогательной функцией сгенерировать схему OpenAPI и переопределить любые нужные части.
-Например, добавим расширение OpenAPI ReDoc для включения собственного логотипа.
+Например, добавим [расширение OpenAPI ReDoc для включения собственного логотипа](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo).
### Обычный **FastAPI** { #normal-fastapi }
@@ -75,6 +75,6 @@
### Проверьте { #check-it }
-Перейдите на http://127.0.0.1:8000/redoc — вы увидите, что используется ваш кастомный логотип (в этом примере — логотип **FastAPI**):
+Перейдите на [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) — вы увидите, что используется ваш кастомный логотип (в этом примере — логотип **FastAPI**):
diff --git a/docs/ru/docs/how-to/general.md b/docs/ru/docs/how-to/general.md
index 029ea1d274..886105eec4 100644
--- a/docs/ru/docs/how-to/general.md
+++ b/docs/ru/docs/how-to/general.md
@@ -4,36 +4,40 @@
## Фильтрация данных — Безопасность { #filter-data-security }
-Чтобы убедиться, что вы не возвращаете больше данных, чем следует, прочитайте документацию: [Руководство — Модель ответа — Возвращаемый тип](../tutorial/response-model.md){.internal-link target=_blank}.
+Чтобы убедиться, что вы не возвращаете больше данных, чем следует, прочитайте документацию: [Руководство — Модель ответа — Возвращаемый тип](../tutorial/response-model.md).
+
+## Оптимизация производительности ответа — Модель ответа — Возвращаемый тип { #optimize-response-performance-response-model-return-type }
+
+Чтобы оптимизировать производительность при возврате JSON-данных, используйте возвращаемый тип или модель ответа; таким образом Pydantic выполнит сериализацию в JSON на стороне Rust, без прохождения через Python. Подробнее читайте в документации: [Руководство — Модель ответа — Возвращаемый тип](../tutorial/response-model.md).
## Теги в документации — OpenAPI { #documentation-tags-openapi }
-Чтобы добавить теги к вашим *операциям пути* и группировать их в интерфейсе документации, прочитайте документацию: [Руководство — Конфигурации операций пути — Теги](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}.
+Чтобы добавить теги к вашим *операциям пути* и группировать их в интерфейсе документации, прочитайте документацию: [Руководство — Конфигурации операций пути — Теги](../tutorial/path-operation-configuration.md#tags).
## Краткое описание и описание в документации — OpenAPI { #documentation-summary-and-description-openapi }
-Чтобы добавить краткое описание и описание к вашим *операциям пути* и отобразить их в интерфейсе документации, прочитайте документацию: [Руководство — Конфигурации операций пути — Краткое описание и описание](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank}.
+Чтобы добавить краткое описание и описание к вашим *операциям пути* и отобразить их в интерфейсе документации, прочитайте документацию: [Руководство — Конфигурации операций пути — Краткое описание и описание](../tutorial/path-operation-configuration.md#summary-and-description).
## Описание ответа в документации — OpenAPI { #documentation-response-description-openapi }
-Чтобы задать описание ответа, отображаемое в интерфейсе документации, прочитайте документацию: [Руководство — Конфигурации операций пути — Описание ответа](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}.
+Чтобы задать описание ответа, отображаемое в интерфейсе документации, прочитайте документацию: [Руководство — Конфигурации операций пути — Описание ответа](../tutorial/path-operation-configuration.md#response-description).
## Документация — пометить операцию пути устаревшей — OpenAPI { #documentation-deprecate-a-path-operation-openapi }
-Чтобы пометить *операцию пути* как устаревшую и показать это в интерфейсе документации, прочитайте документацию: [Руководство — Конфигурации операций пути — Пометить операцию пути устаревшей](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}.
+Чтобы пометить *операцию пути* как устаревшую и показать это в интерфейсе документации, прочитайте документацию: [Руководство — Конфигурации операций пути — Пометить операцию пути устаревшей](../tutorial/path-operation-configuration.md#deprecate-a-path-operation).
## Преобразование любых данных к формату, совместимому с JSON { #convert-any-data-to-json-compatible }
-Чтобы преобразовать любые данные к формату, совместимому с JSON, прочитайте документацию: [Руководство — JSON-совместимый кодировщик](../tutorial/encoder.md){.internal-link target=_blank}.
+Чтобы преобразовать любые данные к формату, совместимому с JSON, прочитайте документацию: [Руководство — JSON-совместимый кодировщик](../tutorial/encoder.md).
## Метаданные OpenAPI — Документация { #openapi-metadata-docs }
-Чтобы добавить метаданные в вашу схему OpenAPI, включая лицензию, версию, контакты и т.д., прочитайте документацию: [Руководство — Метаданные и URL документации](../tutorial/metadata.md){.internal-link target=_blank}.
+Чтобы добавить метаданные в вашу схему OpenAPI, включая лицензию, версию, контакты и т.д., прочитайте документацию: [Руководство — Метаданные и URL документации](../tutorial/metadata.md).
## Пользовательский URL OpenAPI { #openapi-custom-url }
-Чтобы настроить URL OpenAPI (или удалить его), прочитайте документацию: [Руководство — Метаданные и URL документации](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}.
+Чтобы настроить URL OpenAPI (или удалить его), прочитайте документацию: [Руководство — Метаданные и URL документации](../tutorial/metadata.md#openapi-url).
## URL документации OpenAPI { #openapi-docs-urls }
-Чтобы изменить URL, используемые для автоматически сгенерированных пользовательских интерфейсов документации, прочитайте документацию: [Руководство — Метаданные и URL документации](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}.
+Чтобы изменить URL, используемые для автоматически сгенерированных пользовательских интерфейсов документации, прочитайте документацию: [Руководство — Метаданные и URL документации](../tutorial/metadata.md#docs-urls).
diff --git a/docs/ru/docs/how-to/graphql.md b/docs/ru/docs/how-to/graphql.md
index 9e28d61822..1829a211c1 100644
--- a/docs/ru/docs/how-to/graphql.md
+++ b/docs/ru/docs/how-to/graphql.md
@@ -18,18 +18,18 @@
Ниже приведены некоторые библиотеки **GraphQL** с поддержкой **ASGI**. Их можно использовать с **FastAPI**:
-* Strawberry 🍓
- * С документацией для FastAPI
-* Ariadne
- * С документацией для FastAPI
-* Tartiflette
- * С Tartiflette ASGI для интеграции с ASGI
-* Graphene
- * С starlette-graphene3
+* [Strawberry](https://strawberry.rocks/) 🍓
+ * С [документацией для FastAPI](https://strawberry.rocks/docs/integrations/fastapi)
+* [Ariadne](https://ariadnegraphql.org/)
+ * С [документацией для FastAPI](https://ariadnegraphql.org/docs/fastapi-integration)
+* [Tartiflette](https://tartiflette.io/)
+ * С [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) для интеграции с ASGI
+* [Graphene](https://graphene-python.org/)
+ * С [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3)
## GraphQL со Strawberry { #graphql-with-strawberry }
-Если вам нужно или хочется работать с **GraphQL**, **Strawberry** — **рекомендуемая** библиотека, так как её дизайн ближе всего к дизайну **FastAPI**, всё основано на **аннотациях типов**.
+Если вам нужно или хочется работать с **GraphQL**, [**Strawberry**](https://strawberry.rocks/) — **рекомендуемая** библиотека, так как её дизайн ближе всего к дизайну **FastAPI**, всё основано на **аннотациях типов**.
В зависимости от вашего сценария использования вы можете предпочесть другую библиотеку, но если бы вы спросили меня, я, скорее всего, предложил бы попробовать **Strawberry**.
@@ -37,24 +37,24 @@
{* ../../docs_src/graphql_/tutorial001_py310.py hl[3,22,25] *}
-Подробнее о Strawberry можно узнать в документации Strawberry.
+Подробнее о Strawberry можно узнать в [документации Strawberry](https://strawberry.rocks/).
-А также в документации по интеграции Strawberry с FastAPI.
+А также в документации по [интеграции Strawberry с FastAPI](https://strawberry.rocks/docs/integrations/fastapi).
## Устаревший `GraphQLApp` из Starlette { #older-graphqlapp-from-starlette }
-В предыдущих версиях Starlette был класс `GraphQLApp` для интеграции с Graphene.
+В предыдущих версиях Starlette был класс `GraphQLApp` для интеграции с [Graphene](https://graphene-python.org/).
-Он был объявлен устаревшим в Starlette, но если у вас есть код, который его использовал, вы можете легко **мигрировать** на starlette-graphene3, который решает ту же задачу и имеет **почти идентичный интерфейс**.
+Он был объявлен устаревшим в Starlette, но если у вас есть код, который его использовал, вы можете легко **мигрировать** на [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3), который решает ту же задачу и имеет **почти идентичный интерфейс**.
/// tip | Совет
-Если вам нужен GraphQL, я всё же рекомендую посмотреть Strawberry, так как он основан на аннотациях типов, а не на пользовательских классах и типах.
+Если вам нужен GraphQL, я всё же рекомендую посмотреть [Strawberry](https://strawberry.rocks/), так как он основан на аннотациях типов, а не на пользовательских классах и типах.
///
## Подробнее { #learn-more }
-Подробнее о **GraphQL** вы можете узнать в официальной документации GraphQL.
+Подробнее о **GraphQL** вы можете узнать в [официальной документации GraphQL](https://graphql.org/).
Также можно почитать больше о каждой из указанных выше библиотек по приведённым ссылкам.
diff --git a/docs/ru/docs/how-to/index.md b/docs/ru/docs/how-to/index.md
index 75e7fff265..23d95ba04c 100644
--- a/docs/ru/docs/how-to/index.md
+++ b/docs/ru/docs/how-to/index.md
@@ -8,6 +8,6 @@
/// tip | Совет
-Если вы хотите **изучить FastAPI** структурированно (рекомендуется), вместо этого читайте [Учебник — Руководство пользователя](../tutorial/index.md){.internal-link target=_blank} по главам.
+Если вы хотите **изучить FastAPI** структурированно (рекомендуется), вместо этого читайте [Учебник - Руководство пользователя](../tutorial/index.md) по главам.
///
diff --git a/docs/ru/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md b/docs/ru/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
index 2b47c08f67..46b4071da8 100644
--- a/docs/ru/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
+++ b/docs/ru/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
@@ -22,7 +22,7 @@ FastAPI 0.126.0 убрал поддержку Pydantic v1, при этом ещ
## Официальное руководство { #official-guide }
-У Pydantic есть официальное руководство по миграции с v1 на v2.
+У Pydantic есть официальное [руководство по миграции](https://docs.pydantic.dev/latest/migration/) с v1 на v2.
Там также описано, что изменилось, как валидации стали более корректными и строгими, возможные нюансы и т.д.
@@ -30,7 +30,7 @@ FastAPI 0.126.0 убрал поддержку Pydantic v1, при этом ещ
## Тесты { #tests }
-Убедитесь, что у вас есть [тесты](../tutorial/testing.md){.internal-link target=_blank} для вашего приложения и что вы запускаете их в системе непрерывной интеграции (CI).
+Убедитесь, что у вас есть [тесты](../tutorial/testing.md) для вашего приложения и что вы запускаете их в системе непрерывной интеграции (CI).
Так вы сможете выполнить обновление и убедиться, что всё работает как ожидается.
@@ -38,7 +38,7 @@ FastAPI 0.126.0 убрал поддержку Pydantic v1, при этом ещ
Во многих случаях, когда вы используете обычные Pydantic‑модели без пользовательских настроек, вы сможете автоматизировать большую часть процесса миграции с Pydantic v1 на Pydantic v2.
-Вы можете использовать `bump-pydantic` от той же команды Pydantic.
+Вы можете использовать [`bump-pydantic`](https://github.com/pydantic/bump-pydantic) от той же команды Pydantic.
Этот инструмент поможет автоматически изменить большую часть кода, который нужно изменить.
diff --git a/docs/ru/docs/how-to/testing-database.md b/docs/ru/docs/how-to/testing-database.md
index 18f4deeca5..09cd48fafd 100644
--- a/docs/ru/docs/how-to/testing-database.md
+++ b/docs/ru/docs/how-to/testing-database.md
@@ -1,7 +1,7 @@
# Тестирование базы данных { #testing-a-database }
-Вы можете изучить базы данных, SQL и SQLModel в документации SQLModel. 🤓
+Вы можете изучить базы данных, SQL и SQLModel в [документации SQLModel](https://sqlmodel.tiangolo.com/). 🤓
-Есть мини-руководство по использованию SQLModel с FastAPI. ✨
+Есть мини-[руководство по использованию SQLModel с FastAPI](https://sqlmodel.tiangolo.com/tutorial/fastapi/). ✨
-В этом руководстве есть раздел о тестировании SQL-баз данных. 😎
+В этом руководстве есть раздел о [тестировании SQL-баз данных](https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/). 😎
diff --git a/docs/ru/docs/index.md b/docs/ru/docs/index.md
index 877014a086..5694b9f29e 100644
--- a/docs/ru/docs/index.md
+++ b/docs/ru/docs/index.md
@@ -11,25 +11,25 @@
Фреймворк FastAPI: высокая производительность, прост в изучении, позволяет быстро писать код, готов к продакшн
-
+
-
+
-
+
-
+
---
-**Документация**: https://fastapi.tiangolo.com
+**Документация**: [https://fastapi.tiangolo.com](https://fastapi.tiangolo.com/ru)
-**Исходный код**: https://github.com/fastapi/fastapi
+**Исходный код**: [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi)
---
@@ -44,7 +44,7 @@ FastAPI — это современный, быстрый (высокопрои
* **Простота**: Разработан так, чтобы его было легко использовать и осваивать. Меньше времени на чтение документации.
* **Краткость**: Минимизируйте дублирование кода. Несколько возможностей из каждого объявления параметров. Меньше ошибок.
* **Надежность**: Получите код, готовый к продакшн. С автоматической интерактивной документацией.
-* **На основе стандартов**: Основан на открытых стандартах API и полностью совместим с ними: OpenAPI (ранее известный как Swagger) и JSON Schema.
+* **На основе стандартов**: Основан на открытых стандартах API и полностью совместим с ними: [OpenAPI](https://github.com/OAI/OpenAPI-Specification) (ранее известный как Swagger) и [JSON Schema](https://json-schema.org/).
* оценка на основе тестов внутренней команды разработчиков, создающих продакшн-приложения.
@@ -55,51 +55,51 @@ FastAPI — это современный, быстрый (высокопрои
### Ключевой-спонсор { #keystone-sponsor }
{% for sponsor in sponsors.keystone -%}
-
+
{% endfor -%}
### Золотые и серебряные спонсоры { #gold-and-silver-sponsors }
{% for sponsor in sponsors.gold -%}
-
+
{% endfor -%}
{%- for sponsor in sponsors.silver -%}
-
+
{% endfor %}
-Другие спонсоры
+[Другие спонсоры](https://fastapi.tiangolo.com/ru/fastapi-people/#sponsors)
## Мнения { #opinions }
"_[...] В последнее время я много где использую **FastAPI**. [...] На самом деле я планирую использовать его для всех **ML-сервисов моей команды в Microsoft**. Некоторые из них интегрируются в основной продукт **Windows**, а некоторые — в продукты **Office**._"
-Kabir Khan -
Microsoft (ref)Kabir Khan -
Microsoft (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Brian Okken -
Ведущий подкаста [Python Bytes](https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855) (ref)Timothy Crosley -
Создатель [Hug](https://github.com/hugapi/hug) (ref)Ines Montani - Matthew Honnibal -
Основатели [Explosion AI](https://explosion.ai) — создатели [spaCy](https://spacy.io) (ref) -
(ref)Deon Pillsbury -
Cisco (ref)Deon Pillsbury -
Cisco (ref)
@@ -199,7 +199,7 @@ async def read_item(item_id: int, q: str | None = None):
**Примечание**:
-Если не уверены, посмотрите раздел _«Нет времени?»_ о
`async` и `await` в документации.
+Если не уверены, посмотрите раздел _«Нет времени?»_ о [`async` и `await` в документации](https://fastapi.tiangolo.com/ru/async/#in-a-hurry).
@@ -210,7 +210,7 @@ async def read_item(item_id: int, q: str | None = None):
```console
-$ fastapi dev main.py
+$ fastapi dev
╭────────── FastAPI CLI - Development mode ───────────╮
│ │
@@ -235,19 +235,19 @@ INFO: Application startup complete.
-О команде fastapi dev main.py...
+О команде fastapi dev...
-Команда `fastapi dev` читает ваш файл `main.py`, находит в нём приложение **FastAPI** и запускает сервер с помощью Uvicorn.
+Команда `fastapi dev` читает ваш файл `main.py`, находит в нём приложение **FastAPI** и запускает сервер с помощью [Uvicorn](https://www.uvicorn.dev).
По умолчанию `fastapi dev` запускается с включённой авто-перезагрузкой для локальной разработки.
-Подробнее в документации по FastAPI CLI.
+Подробнее в [документации по FastAPI CLI](https://fastapi.tiangolo.com/ru/fastapi-cli/).
### Проверка { #check-it }
-Откройте браузер на
http://127.0.0.1:8000/items/5?q=somequery.
+Откройте браузер на [http://127.0.0.1:8000/items/5?q=somequery](http://127.0.0.1:8000/items/5?q=somequery).
Вы увидите JSON-ответ:
@@ -264,17 +264,17 @@ INFO: Application startup complete.
### Интерактивная документация API { #interactive-api-docs }
-Перейдите на
http://127.0.0.1:8000/docs.
+Перейдите на [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
-Вы увидите автоматическую интерактивную документацию API (предоставлена
Swagger UI):
+Вы увидите автоматическую интерактивную документацию API (предоставлена [Swagger UI](https://github.com/swagger-api/swagger-ui)):
### Альтернативная документация API { #alternative-api-docs }
-Теперь откройте
http://127.0.0.1:8000/redoc.
+Теперь откройте [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
-Вы увидите альтернативную автоматическую документацию (предоставлена
ReDoc):
+Вы увидите альтернативную автоматическую документацию (предоставлена [ReDoc](https://github.com/Rebilly/ReDoc)):
@@ -316,7 +316,7 @@ def update_item(item_id: int, item: Item):
### Обновление интерактивной документации API { #interactive-api-docs-upgrade }
-Перейдите на
http://127.0.0.1:8000/docs.
+Перейдите на [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
* Интерактивная документация API будет автоматически обновлена, включая новое тело запроса:
@@ -332,7 +332,7 @@ def update_item(item_id: int, item: Item):
### Обновление альтернативной документации API { #alternative-api-docs-upgrade }
-Теперь откройте
http://127.0.0.1:8000/redoc.
+Теперь откройте [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
* Альтернативная документация также отразит новый параметр запроса и тело запроса:
@@ -442,7 +442,7 @@ item: Item
* Очень мощную и простую в использовании систему **
внедрения зависимостей**.
* Безопасность и аутентификацию, включая поддержку **OAuth2** с **JWT токенами** и **HTTP Basic** аутентификацию.
* Более продвинутые (но столь же простые) приёмы объявления **глубоко вложенных JSON-моделей** (спасибо Pydantic).
-* Интеграцию **GraphQL** с
Strawberry и другими библиотеками.
+* Интеграцию **GraphQL** с [Strawberry](https://strawberry.rocks) и другими библиотеками.
* Множество дополнительных функций (благодаря Starlette), таких как:
* **WebSockets**
* чрезвычайно простые тесты на основе HTTPX и `pytest`
@@ -452,24 +452,10 @@ item: Item
### Разверните приложение (опционально) { #deploy-your-app-optional }
-При желании вы можете развернуть своё приложение FastAPI в
FastAPI Cloud, присоединяйтесь к списку ожидания, если ещё не сделали этого. 🚀
+При желании вы можете развернуть своё приложение FastAPI в [FastAPI Cloud](https://fastapicloud.com), присоединяйтесь к списку ожидания, если ещё не сделали этого. 🚀
Если у вас уже есть аккаунт **FastAPI Cloud** (мы пригласили вас из списка ожидания 😉), вы можете развернуть ваше приложение одной командой.
-Перед развертыванием убедитесь, что вы вошли в систему:
-
-
-
-```console
-$ fastapi login
-
-You are logged in to FastAPI Cloud 🚀
-```
-
-
-
-Затем разверните приложение:
-
```console
@@ -488,7 +474,7 @@ Deploying to FastAPI Cloud...
#### О FastAPI Cloud { #about-fastapi-cloud }
-**
FastAPI Cloud** создан тем же автором и командой, что и **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** создан тем же автором и командой, что и **FastAPI**.
Он упрощает процесс **создания образа**, **развертывания** и **доступа** к API при минимальных усилиях.
@@ -504,9 +490,9 @@ FastAPI — это open source и стандартизированный фре
## Производительность { #performance }
-Независимые бенчмарки TechEmpower показывают приложения **FastAPI**, работающие под управлением Uvicorn, как
один из самых быстрых доступных фреймворков Python, уступающий только самим Starlette и Uvicorn (используются внутри FastAPI). (*)
+Независимые бенчмарки TechEmpower показывают приложения **FastAPI**, работающие под управлением Uvicorn, как [один из самых быстрых доступных фреймворков Python](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7), уступающий только самим Starlette и Uvicorn (используются внутри FastAPI). (*)
-Чтобы узнать больше, см. раздел
Бенчмарки.
+Чтобы узнать больше, см. раздел [Бенчмарки](https://fastapi.tiangolo.com/ru/benchmarks/).
## Зависимости { #dependencies }
@@ -518,19 +504,19 @@ FastAPI зависит от Pydantic и Starlette.
Используется Pydantic:
-*
email-validator — для проверки адресов электронной почты.
+* [`email-validator`](https://github.com/JoshData/python-email-validator) — для проверки адресов электронной почты.
Используется Starlette:
-*
httpx — обязателен, если вы хотите использовать `TestClient`.
-*
jinja2 — обязателен, если вы хотите использовать конфигурацию шаблонов по умолчанию.
-*
python-multipart - обязателен, если вы хотите поддерживать
«парсинг» форм через `request.form()`.
+* [`httpx`](https://www.python-httpx.org) — обязателен, если вы хотите использовать `TestClient`.
+* [`jinja2`](https://jinja.palletsprojects.com) — обязателен, если вы хотите использовать конфигурацию шаблонов по умолчанию.
+* [`python-multipart`](https://github.com/Kludex/python-multipart) - обязателен, если вы хотите поддерживать
«парсинг» форм через `request.form()`.
Используется FastAPI:
-*
uvicorn — сервер, который загружает и «отдаёт» ваше приложение. Включает `uvicorn[standard]`, содержащий некоторые зависимости (например, `uvloop`), нужные для высокой производительности.
+* [`uvicorn`](https://www.uvicorn.dev) — сервер, который загружает и «отдаёт» ваше приложение. Включает `uvicorn[standard]`, содержащий некоторые зависимости (например, `uvloop`), нужные для высокой производительности.
* `fastapi-cli[standard]` — чтобы предоставить команду `fastapi`.
- * Включает `fastapi-cloud-cli`, который позволяет развернуть ваше приложение FastAPI в
FastAPI Cloud.
+ * Включает `fastapi-cloud-cli`, который позволяет развернуть ваше приложение FastAPI в [FastAPI Cloud](https://fastapicloud.com).
### Без зависимостей `standard` { #without-standard-dependencies }
@@ -546,13 +532,13 @@ FastAPI зависит от Pydantic и Starlette.
Дополнительные опциональные зависимости Pydantic:
-*
pydantic-settings — для управления настройками.
-*
pydantic-extra-types — дополнительные типы для использования с Pydantic.
+* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) — для управления настройками.
+* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) — дополнительные типы для использования с Pydantic.
Дополнительные опциональные зависимости FastAPI:
-*
orjson — обязателен, если вы хотите использовать `ORJSONResponse`.
-*
ujson — обязателен, если вы хотите использовать `UJSONResponse`.
+* [`orjson`](https://github.com/ijl/orjson) — обязателен, если вы хотите использовать `ORJSONResponse`.
+* [`ujson`](https://github.com/esnme/ultrajson) — обязателен, если вы хотите использовать `UJSONResponse`.
## Лицензия { #license }
diff --git a/docs/ru/docs/project-generation.md b/docs/ru/docs/project-generation.md
index 8155457e38..7a46b210d6 100644
--- a/docs/ru/docs/project-generation.md
+++ b/docs/ru/docs/project-generation.md
@@ -4,7 +4,7 @@
Вы можете использовать этот шаблон для старта: в нём уже сделана значительная часть начальной настройки, безопасность, база данных и несколько эндпоинтов API.
-Репозиторий GitHub:
Full Stack FastAPI Template
+Репозиторий GitHub: [Full Stack FastAPI Template](https://github.com/tiangolo/full-stack-fastapi-template)
## Шаблон Full Stack FastAPI — Технологический стек и возможности { #full-stack-fastapi-template-technology-stack-and-features }
diff --git a/docs/ru/docs/python-types.md b/docs/ru/docs/python-types.md
index 95153c3882..61219704c0 100644
--- a/docs/ru/docs/python-types.md
+++ b/docs/ru/docs/python-types.md
@@ -269,7 +269,7 @@ def some_function(data: Any):
## Pydantic-модели { #pydantic-models }
-
Pydantic — это библиотека Python для валидации данных.
+[Pydantic](https://docs.pydantic.dev/) — это библиотека Python для валидации данных.
Вы объявляете «форму» данных как классы с атрибутами.
@@ -285,13 +285,13 @@ def some_function(data: Any):
/// info | Информация
-Чтобы узнать больше о
Pydantic, ознакомьтесь с его документацией.
+Чтобы узнать больше о [Pydantic, ознакомьтесь с его документацией](https://docs.pydantic.dev/).
///
**FastAPI** целиком основан на Pydantic.
-Вы увидите намного больше всего этого на практике в [Учебник - Руководство пользователя](tutorial/index.md){.internal-link target=_blank}.
+Вы увидите намного больше всего этого на практике в [Учебник - Руководство пользователя](tutorial/index.md).
## Подсказки типов с аннотациями метаданных { #type-hints-with-metadata-annotations }
@@ -337,12 +337,12 @@ def some_function(data: Any):
* **Документирования** API с использованием OpenAPI:
* что затем используется пользовательскими интерфейсами автоматической интерактивной документации.
-Всё это может звучать абстрактно. Не волнуйтесь. Вы увидите всё это в действии в [Учебник - Руководство пользователя](tutorial/index.md){.internal-link target=_blank}.
+Всё это может звучать абстрактно. Не волнуйтесь. Вы увидите всё это в действии в [Учебник - Руководство пользователя](tutorial/index.md).
Важно то, что, используя стандартные типы Python в одном месте (вместо добавления дополнительных классов, декораторов и т.д.), **FastAPI** сделает за вас большую часть работы.
/// info | Информация
-Если вы уже прошли всё руководство и вернулись, чтобы узнать больше о типах, хорошим ресурсом будет
«шпаргалка» от `mypy`.
+Если вы уже прошли всё руководство и вернулись, чтобы узнать больше о типах, хорошим ресурсом будет [«шпаргалка» от `mypy`](https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html).
///
diff --git a/docs/ru/docs/tutorial/background-tasks.md b/docs/ru/docs/tutorial/background-tasks.md
index 9fa7a85029..22827b69f3 100644
--- a/docs/ru/docs/tutorial/background-tasks.md
+++ b/docs/ru/docs/tutorial/background-tasks.md
@@ -61,7 +61,7 @@
## Технические детали { #technical-details }
-Класс `BackgroundTasks` приходит напрямую из
`starlette.background`.
+Класс `BackgroundTasks` приходит напрямую из [`starlette.background`](https://www.starlette.dev/background/).
Он импортируется/включается прямо в FastAPI, чтобы вы могли импортировать его из `fastapi` и избежать случайного импорта альтернативного `BackgroundTask` (без `s` на конце) из `starlette.background`.
@@ -69,11 +69,11 @@
По‑прежнему можно использовать один `BackgroundTask` в FastAPI, но тогда вам нужно создать объект в своём коде и вернуть Starlette `Response`, включающий его.
-Подробнее см. в
официальной документации Starlette по фоновым задачам.
+Подробнее см. в [официальной документации Starlette по фоновым задачам](https://www.starlette.dev/background/).
## Предостережение { #caveat }
-Если вам нужно выполнять тяжелые вычисления в фоне, и при этом они не обязательно должны запускаться тем же процессом (например, вам не нужно делиться памятью, переменными и т.п.), вам могут подойти более мощные инструменты, такие как
Celery.
+Если вам нужно выполнять тяжелые вычисления в фоне, и при этом они не обязательно должны запускаться тем же процессом (например, вам не нужно делиться памятью, переменными и т.п.), вам могут подойти более мощные инструменты, такие как [Celery](https://docs.celeryq.dev).
Они обычно требуют более сложной конфигурации, менеджера очереди сообщений/заданий (например, RabbitMQ или Redis), но позволяют запускать фоновые задачи в нескольких процессах и, что особенно важно, на нескольких серверах.
diff --git a/docs/ru/docs/tutorial/bigger-applications.md b/docs/ru/docs/tutorial/bigger-applications.md
index 3fb36d5a22..972313559a 100644
--- a/docs/ru/docs/tutorial/bigger-applications.md
+++ b/docs/ru/docs/tutorial/bigger-applications.md
@@ -123,7 +123,7 @@ from app.routers import items
Для простоты мы воспользовались выдуманным заголовком.
-В реальных случаях для получения наилучших результатов используйте интегрированные [утилиты безопасности](security/index.md){.internal-link target=_blank}.
+В реальных случаях для получения наилучших результатов используйте интегрированные [утилиты безопасности](security/index.md).
///
@@ -169,7 +169,7 @@ async def read_item(item_id: str):
/// tip | Подсказка
-Обратите внимание, что так же, как и в случае с [зависимостями в декораторах *операций пути*](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, никакое значение не будет передано в вашу *функцию-обработчик пути*.
+Обратите внимание, что так же, как и в случае с [зависимостями в декораторах *операций пути*](dependencies/dependencies-in-path-operation-decorators.md), никакое значение не будет передано в вашу *функцию-обработчик пути*.
///
@@ -185,8 +185,8 @@ async def read_item(item_id: str):
* Все они будут включать предопределённые `responses`.
* Все эти *операции пути* будут иметь список `dependencies`, вычисляемых/выполняемых перед ними.
* Если вы также объявите зависимости в конкретной *операции пути*, **они тоже будут выполнены**.
- * Сначала выполняются зависимости маршрутизатора, затем [`dependencies` в декораторе](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, и затем обычные параметрические зависимости.
- * Вы также можете добавить [`Security`-зависимости с `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
+ * Сначала выполняются зависимости маршрутизатора, затем [`dependencies` в декораторе](dependencies/dependencies-in-path-operation-decorators.md), и затем обычные параметрические зависимости.
+ * Вы также можете добавить [`Security`-зависимости с `scopes`](../advanced/security/oauth2-scopes.md).
/// tip | Подсказка
@@ -303,7 +303,7 @@ from ...dependencies import get_token_header
Вы импортируете и создаёте класс `FastAPI` как обычно.
-И мы даже можем объявить [глобальные зависимости](dependencies/global-dependencies.md){.internal-link target=_blank}, которые будут объединены с зависимостями для каждого `APIRouter`:
+И мы даже можем объявить [глобальные зависимости](dependencies/global-dependencies.md), которые будут объединены с зависимостями для каждого `APIRouter`:
{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[1,3,7] title["app/main.py"] *}
@@ -353,7 +353,7 @@ from .routers import items, users
from app.routers import items, users
```
-Чтобы узнать больше о Python-пакетах и модулях, прочитайте
официальную документацию Python о модулях.
+Чтобы узнать больше о Python-пакетах и модулях, прочитайте [официальную документацию Python о модулях](https://docs.python.org/3/tutorial/modules.html).
///
@@ -465,6 +465,37 @@ from .routers.users import router
///
+## Настройка `entrypoint` в `pyproject.toml` { #configure-the-entrypoint-in-pyproject-toml }
+
+Так как ваш объект FastAPI `app` находится в `app/main.py`, вы можете настроить `entrypoint` в файле `pyproject.toml` следующим образом:
+
+```toml
+[tool.fastapi]
+entrypoint = "app.main:app"
+```
+
+это эквивалентно импорту:
+
+```python
+from app.main import app
+```
+
+Таким образом, команда `fastapi` будет знать, где найти ваше приложение.
+
+/// Note | Примечание
+
+Вы также можете передать путь в команду, например:
+
+```console
+$ fastapi dev app/main.py
+```
+
+Но вам придётся каждый раз помнить и указывать корректный путь при вызове команды `fastapi`.
+
+Кроме того, другие инструменты могут не суметь его найти, например [расширение VS Code](../editor-support.md) или [FastAPI Cloud](https://fastapicloud.com), поэтому рекомендуется использовать `entrypoint` в `pyproject.toml`.
+
+///
+
## Проверка автоматической документации API { #check-the-automatic-api-docs }
Теперь запустите приложение:
@@ -472,14 +503,14 @@ from .routers.users import router
```console
-$ fastapi dev app/main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-Откройте документацию по адресу
http://127.0.0.1:8000/docs.
+Откройте документацию по адресу [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Вы увидите автоматическую документацию API, включая пути из всех подмодулей, с использованием корректных путей (и префиксов) и корректных тегов:
diff --git a/docs/ru/docs/tutorial/body-nested-models.md b/docs/ru/docs/tutorial/body-nested-models.md
index 6610b209c2..fab025dbc9 100644
--- a/docs/ru/docs/tutorial/body-nested-models.md
+++ b/docs/ru/docs/tutorial/body-nested-models.md
@@ -95,7 +95,7 @@ my_list: list[str]
Помимо обычных простых типов, таких как `str`, `int`, `float` и т.д., вы можете использовать более сложные простые типы, которые наследуются от `str`.
-Чтобы увидеть все варианты, которые у вас есть, ознакомьтесь с
обзором типов Pydantic. Вы увидите некоторые примеры в следующей главе.
+Чтобы увидеть все варианты, которые у вас есть, ознакомьтесь с [обзором типов Pydantic](https://docs.pydantic.dev/latest/concepts/types/). Вы увидите некоторые примеры в следующей главе.
Например, так как в модели `Image` у нас есть поле `url`, то мы можем объявить его как тип `HttpUrl` из Pydantic вместо типа `str`:
diff --git a/docs/ru/docs/tutorial/body-updates.md b/docs/ru/docs/tutorial/body-updates.md
index 4a7adb2559..7d970a7a93 100644
--- a/docs/ru/docs/tutorial/body-updates.md
+++ b/docs/ru/docs/tutorial/body-updates.md
@@ -1,8 +1,8 @@
-# Body - Обновления { #body-updates }
+# Тело запроса - Обновления { #body-updates }
## Обновление с заменой при помощи `PUT` { #update-replacing-with-put }
-Чтобы обновить элемент, вы можете использовать операцию
HTTP `PUT`.
+Чтобы обновить элемент, вы можете использовать операцию [HTTP `PUT`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT).
Вы можете использовать `jsonable_encoder`, чтобы преобразовать входные данные в данные, которые можно сохранить как JSON (например, в NoSQL-базе данных). Например, преобразование `datetime` в `str`.
@@ -28,11 +28,11 @@
## Частичное обновление с помощью `PATCH` { #partial-updates-with-patch }
-Также можно использовать операцию
HTTP `PATCH` для *частичного* обновления данных.
+Также можно использовать операцию [HTTP `PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) для частичного обновления данных.
Это означает, что можно передавать только те данные, которые необходимо обновить, оставляя остальные нетронутыми.
-/// note | Технические детали
+/// note | Примечание
`PATCH` менее распространен и известен, чем `PUT`.
@@ -89,12 +89,12 @@
///
-/// note | Технические детали
+/// note | Примечание
Обратите внимание, что входная модель по-прежнему валидируется.
Таким образом, если вы хотите получать частичные обновления, в которых могут быть опущены все атрибуты, вам необходимо иметь модель, в которой все атрибуты помечены как необязательные (со значениями по умолчанию или `None`).
-Чтобы отличить модели со всеми необязательными значениями для **обновления** от моделей с обязательными значениями для **создания**, можно воспользоваться идеями, описанными в [Дополнительные модели](extra-models.md){.internal-link target=_blank}.
+Чтобы отличить модели со всеми необязательными значениями для обновления и модели с обязательными значениями для создания, можно воспользоваться идеями, описанными в [Дополнительные модели](extra-models.md).
///
diff --git a/docs/ru/docs/tutorial/body.md b/docs/ru/docs/tutorial/body.md
index 3e55607da5..8a67c8f51e 100644
--- a/docs/ru/docs/tutorial/body.md
+++ b/docs/ru/docs/tutorial/body.md
@@ -6,7 +6,7 @@
Ваш API почти всегда должен отправлять тело **ответа**. Но клиентам не обязательно всегда отправлять **тело запроса**: иногда они запрашивают только путь, возможно с некоторыми параметрами запроса, но без тела.
-Чтобы объявить тело **запроса**, используйте модели
Pydantic, со всей их мощью и преимуществами.
+Чтобы объявить тело **запроса**, используйте модели [Pydantic](https://docs.pydantic.dev/), со всей их мощью и преимуществами.
/// info | Информация
@@ -73,7 +73,7 @@
* Если данные некорректны, вернёт понятную и наглядную ошибку, указывающую, где именно и что было некорректно.
* Передаст полученные данные в параметр `item`.
* Поскольку внутри функции вы объявили его с типом `Item`, у вас будет поддержка со стороны редактора кода (автозавершение и т.п.) для всех атрибутов и их типов.
-* Сгенерирует определения
JSON Schema для вашей модели; вы можете использовать их и в других местах, если это имеет смысл для вашего проекта.
+* Сгенерирует определения [JSON Schema](https://json-schema.org) для вашей модели; вы можете использовать их и в других местах, если это имеет смысл для вашего проекта.
* Эти схемы будут частью сгенерированной схемы OpenAPI и будут использоваться автоматической документацией
UIs.
## Автоматическая документация { #automatic-docs }
@@ -102,15 +102,15 @@ JSON Schema ваших моделей будет частью сгенериро
В сам Pydantic даже были внесены некоторые изменения для поддержки этого.
-Предыдущие скриншоты сделаны в
Visual Studio Code.
+Предыдущие скриншоты сделаны в [Visual Studio Code](https://code.visualstudio.com).
-Но вы получите такую же поддержку редактора кода в
PyCharm и большинстве других редакторов Python:
+Но вы получите такую же поддержку редактора кода в [PyCharm](https://www.jetbrains.com/pycharm/) и большинстве других редакторов Python:
/// tip | Совет
-Если вы используете
PyCharm в качестве редактора кода, вы можете использовать плагин
Pydantic PyCharm Plugin.
+Если вы используете [PyCharm](https://www.jetbrains.com/pycharm/) в качестве редактора кода, вы можете использовать плагин [Pydantic PyCharm Plugin](https://github.com/koxudaxi/pydantic-pycharm-plugin/).
Он улучшает поддержку моделей Pydantic в редакторе кода, включая:
@@ -163,4 +163,4 @@ FastAPI понимает, что значение `q` не является об
## Без Pydantic { #without-pydantic }
-Если вы не хотите использовать модели Pydantic, вы также можете использовать параметры **Body**. См. раздел документации [Тело запроса - Несколько параметров: Единичные значения в теле](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
+Если вы не хотите использовать модели Pydantic, вы также можете использовать параметры **Body**. См. раздел документации [Тело запроса - Несколько параметров: Единичные значения в теле](body-multiple-params.md#singular-values-in-body).
diff --git a/docs/ru/docs/tutorial/cors.md b/docs/ru/docs/tutorial/cors.md
index feaa159683..b18b1ddf46 100644
--- a/docs/ru/docs/tutorial/cors.md
+++ b/docs/ru/docs/tutorial/cors.md
@@ -1,6 +1,6 @@
# CORS (Cross-Origin Resource Sharing) { #cors-cross-origin-resource-sharing }
-
Понятие CORS или "Cross-Origin Resource Sharing" относится к ситуациям, при которых запущенный в браузере фронтенд содержит JavaScript-код, который взаимодействует с бэкендом, находящимся на другом "источнике" ("origin").
+[CORS или "Cross-Origin Resource Sharing"](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) относится к ситуациям, при которых запущенный в браузере фронтенд содержит JavaScript-код, который взаимодействует с бэкендом, находящимся на другом "источнике" ("origin").
## Источник { #origin }
@@ -55,10 +55,10 @@
* `allow_origins` - Список источников, на которые разрешено выполнять кросс-доменные запросы. Например, `['https://example.org', 'https://www.example.org']`. Можно использовать `['*']`, чтобы разрешить любые источники.
* `allow_origin_regex` - Регулярное выражение для определения источников, на которые разрешено выполнять кросс-доменные запросы. Например, `'https://.*\.example\.org'`.
* `allow_methods` - Список HTTP-методов, которые разрешены для кросс-доменных запросов. По умолчанию `['GET']`. Можно использовать `['*']`, чтобы разрешить все стандартные методы.
-* `allow_headers` - Список HTTP-заголовков запроса, которые должны поддерживаться при кросс-доменных запросах. По умолчанию `[]`. Можно использовать `['*']`, чтобы разрешить все заголовки. Заголовки `Accept`, `Accept-Language`, `Content-Language` и `Content-Type` всегда разрешены для
простых CORS-запросов.
+* `allow_headers` - Список HTTP-заголовков запроса, которые должны поддерживаться при кросс-доменных запросах. По умолчанию `[]`. Можно использовать `['*']`, чтобы разрешить все заголовки. Заголовки `Accept`, `Accept-Language`, `Content-Language` и `Content-Type` всегда разрешены для [простых CORS-запросов](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests).
* `allow_credentials` - Указывает, что куки разрешены в кросс-доменных запросах. По умолчанию `False`.
- Ни один из параметров `allow_origins`, `allow_methods` и `allow_headers` не может быть установлен в `['*']`, если `allow_credentials` имеет значение `True`. Все они должны быть
указаны явно.
+ Ни один из параметров `allow_origins`, `allow_methods` и `allow_headers` не может быть установлен в `['*']`, если `allow_credentials` имеет значение `True`. Все они должны быть [указаны явно](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards).
* `expose_headers` - Указывает любые заголовки ответа, которые должны быть доступны браузеру. По умолчанию `[]`.
* `max_age` - Устанавливает максимальное время в секундах, в течение которого браузер кэширует CORS-ответы. По умолчанию `600`.
@@ -77,7 +77,7 @@
## Больше информации { #more-info }
-Для получения более подробной информации о
CORS обратитесь к
документации CORS от Mozilla.
+Для получения более подробной информации о
CORS обратитесь к [документации CORS от Mozilla](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS).
/// note | Технические детали
diff --git a/docs/ru/docs/tutorial/debugging.md b/docs/ru/docs/tutorial/debugging.md
index 483fe80869..330055be4d 100644
--- a/docs/ru/docs/tutorial/debugging.md
+++ b/docs/ru/docs/tutorial/debugging.md
@@ -74,7 +74,7 @@ from myapp import app
/// info | Информация
-Для получения дополнительной информации, ознакомьтесь с
официальной документацией Python.
+Для получения дополнительной информации, ознакомьтесь с [официальной документацией Python](https://docs.python.org/3/library/__main__.html).
///
diff --git a/docs/ru/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md b/docs/ru/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
index 4cfc4e699f..b4b7ce6314 100644
--- a/docs/ru/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
+++ b/docs/ru/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
@@ -32,11 +32,11 @@
В этом примере мы используем выдуманные пользовательские HTTP-заголовки `X-Key` и `X-Token`.
-Но в реальных проектах, при внедрении системы безопасности, вы получите больше пользы используя интегрированные [средства защиты (следующая глава)](../security/index.md){.internal-link target=_blank}.
+Но в реальных проектах, при внедрении системы безопасности, вы получите больше пользы используя интегрированные [средства защиты (следующая глава)](../security/index.md).
///
-## Исключения в Зависимостях и возвращаемые значения { #dependencies-errors-and-return-values }
+## Ошибки в зависимостях и возвращаемые значения { #dependencies-errors-and-return-values }
Вы можете использовать те же *функции* зависимостей, что и обычно.
@@ -62,7 +62,7 @@
## Зависимости для группы *операций путей* { #dependencies-for-a-group-of-path-operations }
-Позже, читая о том как структурировать большие приложения ([Большие приложения — несколько файлов](../../tutorial/bigger-applications.md){.internal-link target=_blank}), возможно, многофайловые, вы узнаете как объявить единый параметр `dependencies` для всей группы *операций путей*.
+Позже, читая о том как структурировать большие приложения ([Большие приложения — несколько файлов](../../tutorial/bigger-applications.md)), возможно, многофайловые, вы узнаете как объявить единый параметр `dependencies` для всей группы *операций путей*.
## Глобальные Зависимости { #global-dependencies }
diff --git a/docs/ru/docs/tutorial/dependencies/dependencies-with-yield.md b/docs/ru/docs/tutorial/dependencies/dependencies-with-yield.md
index 03a7c083c4..04c2c2da42 100644
--- a/docs/ru/docs/tutorial/dependencies/dependencies-with-yield.md
+++ b/docs/ru/docs/tutorial/dependencies/dependencies-with-yield.md
@@ -14,8 +14,8 @@ FastAPI поддерживает зависимости, которые выпо
Любая функция, с которой можно корректно использовать:
-*
`@contextlib.contextmanager` или
-*
`@contextlib.asynccontextmanager`
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) или
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
будет корректной для использования в качестве зависимости **FastAPI**.
@@ -87,7 +87,7 @@ FastAPI поддерживает зависимости, которые выпо
/// note | Технические детали
-Это работает благодаря
менеджерам контекста в Python.
+Это работает благодаря [менеджерам контекста](https://docs.python.org/3/library/contextlib.html) в Python.
**FastAPI** использует их внутренне для достижения этого.
@@ -111,7 +111,7 @@ FastAPI поддерживает зависимости, которые выпо
{* ../../docs_src/dependencies/tutorial008b_an_py310.py hl[18:22,31] *}
-Если вы хотите перехватывать исключения и формировать на их основе пользовательский ответ, создайте [Пользовательский обработчик исключений](../handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank}.
+Если вы хотите перехватывать исключения и формировать на их основе пользовательский ответ, создайте [Пользовательский обработчик исключений](../handling-errors.md#install-custom-exception-handlers).
## Зависимости с `yield` и `except` { #dependencies-with-yield-and-except }
@@ -233,14 +233,14 @@ participant operation as Функция-обработчик пути
Зависимости с `yield` со временем эволюционировали, чтобы покрыть разные сценарии и исправить некоторые проблемы.
-Если вы хотите посмотреть, что менялось в разных версиях FastAPI, вы можете прочитать об этом подробнее в продвинутом руководстве: [Продвинутые зависимости — зависимости с `yield`, `HTTPException`, `except` и фоновыми задачами](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks){.internal-link target=_blank}.
+Если вы хотите посмотреть, что менялось в разных версиях FastAPI, вы можете прочитать об этом подробнее в продвинутом руководстве: [Продвинутые зависимости — зависимости с `yield`, `HTTPException`, `except` и фоновыми задачами](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks).
## Контекстные менеджеры { #context-managers }
### Что такое «контекстные менеджеры» { #what-are-context-managers }
«Контекстные менеджеры» — это любые объекты Python, которые можно использовать в операторе `with`.
-Например,
можно использовать `with` для чтения файла:
+Например, [можно использовать `with` для чтения файла](https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files):
```Python
with open("./somefile.txt") as f:
@@ -264,7 +264,7 @@ with open("./somefile.txt") as f:
///
-В Python можно создавать менеджеры контекста,
создав класс с двумя методами: `__enter__()` и `__exit__()`.
+В Python можно создавать менеджеры контекста, [создав класс с двумя методами: `__enter__()` и `__exit__()`](https://docs.python.org/3/reference/datamodel.html#context-managers).
Их также можно использовать внутри зависимостей **FastAPI** с `yield`, применяя операторы
`with` или `async with` внутри функции зависимости:
@@ -275,8 +275,8 @@ with open("./somefile.txt") as f:
Другой способ создания менеджера контекста — с помощью:
-*
`@contextlib.contextmanager` или
-*
`@contextlib.asynccontextmanager`
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) или
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
оформив ими функцию с одним `yield`.
diff --git a/docs/ru/docs/tutorial/dependencies/global-dependencies.md b/docs/ru/docs/tutorial/dependencies/global-dependencies.md
index f488322a9e..1563d3e8fe 100644
--- a/docs/ru/docs/tutorial/dependencies/global-dependencies.md
+++ b/docs/ru/docs/tutorial/dependencies/global-dependencies.md
@@ -2,14 +2,14 @@
Для некоторых типов приложений может потребоваться добавить зависимости ко всему приложению.
-Подобно тому, как вы можете [добавлять `dependencies` (зависимости) в *декораторах операций пути*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, вы можете добавлять зависимости сразу ко всему `FastAPI` приложению.
+Подобно тому, как вы можете [добавлять `dependencies` (зависимости) в *декораторах операций пути*](dependencies-in-path-operation-decorators.md), вы можете добавлять зависимости сразу ко всему `FastAPI` приложению.
В этом случае они будут применяться ко всем *операциям пути* в приложении:
{* ../../docs_src/dependencies/tutorial012_an_py310.py hl[17] *}
-Все способы [добавления `dependencies` (зависимостей) в *декораторах операций пути*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} по-прежнему применимы, но в данном случае зависимости применяются ко всем *операциям пути* приложения.
+Все способы [добавления `dependencies` (зависимостей) в *декораторах операций пути*](dependencies-in-path-operation-decorators.md) по-прежнему применимы, но в данном случае зависимости применяются ко всем *операциям пути* приложения.
## Зависимости для групп *операций пути* { #dependencies-for-groups-of-path-operations }
-Позднее, читая о том, как структурировать более крупные приложения ([приложения, содержащие много файлов](../../tutorial/bigger-applications.md){.internal-link target=_blank}), возможно, состоящие из нескольких файлов, вы узнаете, как объявить один параметр `dependencies` для целой группы *операций пути*.
+Позднее, читая о том, как структурировать более крупные приложения ([Более крупные приложения - несколько файлов](../../tutorial/bigger-applications.md)), возможно, состоящие из нескольких файлов, вы узнаете, как объявить один параметр `dependencies` для целой группы *операций пути*.
diff --git a/docs/ru/docs/tutorial/dependencies/index.md b/docs/ru/docs/tutorial/dependencies/index.md
index 29f735ab61..4aed035541 100644
--- a/docs/ru/docs/tutorial/dependencies/index.md
+++ b/docs/ru/docs/tutorial/dependencies/index.md
@@ -14,7 +14,7 @@
* Обеспечить общую логику (один и тот же алгоритм снова и снова).
* Разделять соединения с базой данных.
-* Обеспечить безопасность, аутентификацию, требования к ролям и т. п.
+* Обеспечить безопасность, аутентификацию, требования к ролям и т.п.
* И многое другое...
Всё это при минимизации повторения кода.
@@ -57,7 +57,7 @@ FastAPI добавил поддержку `Annotated` (и начал реком
Если у вас более старая версия, вы получите ошибки при попытке использовать `Annotated`.
-Убедитесь, что вы [обновили версию FastAPI](../../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} как минимум до 0.95.1, прежде чем использовать `Annotated`.
+Убедитесь, что вы [обновили версию FastAPI](../../deployment/versions.md#upgrading-the-fastapi-versions) как минимум до 0.95.1, прежде чем использовать `Annotated`.
///
@@ -67,11 +67,11 @@ FastAPI добавил поддержку `Annotated` (и начал реком
### Объявите зависимость в «зависимом» { #declare-the-dependency-in-the-dependant }
-Точно так же, как вы используете `Body`, `Query` и т. д. с параметрами вашей *функции обработки пути*, используйте `Depends` с новым параметром:
+Точно так же, как вы используете `Body`, `Query` и т.д. с параметрами вашей *функции обработки пути*, используйте `Depends` с новым параметром:
{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[13,18] *}
-Хотя вы используете `Depends` в параметрах вашей функции так же, как `Body`, `Query` и т. д., `Depends` работает немного иначе.
+Хотя вы используете `Depends` в параметрах вашей функции так же, как `Body`, `Query` и т.д., `Depends` работает немного иначе.
В `Depends` вы передаёте только один параметр.
@@ -146,13 +146,13 @@ commons: Annotated[dict, Depends(common_parameters)]
Вы можете использовать `async def` или обычное `def`.
-И вы можете объявлять зависимости с `async def` внутри обычных *функций обработки пути* `def`, или зависимости `def` внутри *функций обработки пути* `async def` и т. д.
+И вы можете объявлять зависимости с `async def` внутри обычных *функций обработки пути* `def`, или зависимости `def` внутри *функций обработки пути* `async def` и т.д.
Это не важно. **FastAPI** знает, что делать.
/// note | Примечание
-Если вы не уверены, посмотрите раздел [Async: *"In a hurry?"*](../../async.md#in-a-hurry){.internal-link target=_blank} о `async` и `await` в документации.
+Если вы не уверены, посмотрите раздел [Async: «Нет времени?»](../../async.md#in-a-hurry) о `async` и `await` в документации.
///
diff --git a/docs/ru/docs/tutorial/encoder.md b/docs/ru/docs/tutorial/encoder.md
index 28e2a49c0a..f68b401cb4 100644
--- a/docs/ru/docs/tutorial/encoder.md
+++ b/docs/ru/docs/tutorial/encoder.md
@@ -12,7 +12,7 @@
Например, она не принимает объекты `datetime`, так как они не совместимы с JSON.
-В таком случае объект `datetime` следует преобразовать в строку, соответствующую
формату ISO.
+В таком случае объект `datetime` следует преобразовать в `str`, содержащую данные в [формате ISO](https://en.wikipedia.org/wiki/ISO_8601).
Точно так же эта база данных не может принять Pydantic-модель (объект с атрибутами), а только `dict`.
@@ -24,7 +24,7 @@
В данном примере она преобразует Pydantic-модель в `dict`, а `datetime` - в `str`.
-Результатом её вызова является объект, который может быть закодирован с помощью функции из стандартной библиотеки Python –
`json.dumps()`.
+Результатом её вызова является объект, который может быть закодирован с помощью функции из стандартной библиотеки Python – [`json.dumps()`](https://docs.python.org/3/library/json.html#json.dumps).
Функция не возвращает большой `str`, содержащий данные в формате JSON (в виде строки). Она возвращает стандартную структуру данных Python (например, `dict`) со значениями и подзначениями, которые совместимы с JSON.
diff --git a/docs/ru/docs/tutorial/extra-data-types.md b/docs/ru/docs/tutorial/extra-data-types.md
index 3b52b5d747..062c195742 100644
--- a/docs/ru/docs/tutorial/extra-data-types.md
+++ b/docs/ru/docs/tutorial/extra-data-types.md
@@ -36,7 +36,7 @@
* `datetime.timedelta`:
* Встроенный в Python `datetime.timedelta`.
* В запросах и ответах будет представлен в виде общего количества секунд типа `float`.
- * Pydantic также позволяет представить его как "Кодировку разницы во времени ISO 8601",
см. документацию для получения дополнительной информации.
+ * Pydantic также позволяет представить его как "Кодировку разницы во времени ISO 8601", [см. документацию для получения дополнительной информации](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
* `frozenset`:
* В запросах и ответах обрабатывается так же, как и `set`:
* В запросах будет прочитан список, исключены дубликаты и преобразован в `set`.
@@ -49,7 +49,7 @@
* `Decimal`:
* Встроенный в Python `Decimal`.
* В запросах и ответах обрабатывается так же, как и `float`.
-* Вы можете проверить все допустимые типы данных Pydantic здесь:
Типы данных Pydantic.
+* Вы можете проверить все допустимые типы данных Pydantic здесь: [Типы данных Pydantic](https://docs.pydantic.dev/latest/usage/types/types/).
## Пример { #example }
diff --git a/docs/ru/docs/tutorial/extra-models.md b/docs/ru/docs/tutorial/extra-models.md
index f9b63ca70e..becb76bc3f 100644
--- a/docs/ru/docs/tutorial/extra-models.md
+++ b/docs/ru/docs/tutorial/extra-models.md
@@ -12,7 +12,7 @@
Никогда не храните пароли пользователей в чистом виде. Всегда храните "безопасный хэш", который вы затем сможете проверить.
-Если вам это не знакомо, вы можете узнать про "хэш пароля" в [главах о безопасности](security/simple-oauth2.md#password-hashing){.internal-link target=_blank}.
+Если вам это не знакомо, вы можете узнать про "хэш пароля" в [главах о безопасности](security/simple-oauth2.md#password-hashing).
///
@@ -162,11 +162,11 @@ UserInDB(
Он будет определён в OpenAPI как `anyOf`.
-Для этого используйте стандартную аннотацию типов в Python
`typing.Union`:
+Для этого используйте стандартную аннотацию типов в Python [`typing.Union`](https://docs.python.org/3/library/typing.html#typing.Union):
/// note | Примечание
-При объявлении
`Union` сначала указывайте наиболее специфичный тип, затем менее специфичный. В примере ниже более специфичный `PlaneItem` стоит перед `CarItem` в `Union[PlaneItem, CarItem]`.
+При объявлении [`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions) сначала указывайте наиболее специфичный тип, затем менее специфичный. В примере ниже более специфичный `PlaneItem` стоит перед `CarItem` в `Union[PlaneItem, CarItem]`.
///
diff --git a/docs/ru/docs/tutorial/first-steps.md b/docs/ru/docs/tutorial/first-steps.md
index cee264ff46..7216d4cb79 100644
--- a/docs/ru/docs/tutorial/first-steps.md
+++ b/docs/ru/docs/tutorial/first-steps.md
@@ -11,7 +11,7 @@
```console
-$
fastapi dev
main.py
+$
fastapi dev
FastAPI Starting development server 🚀
@@ -58,7 +58,7 @@ INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
### Проверьте { #check-it }
-Откройте браузер по адресу:
http://127.0.0.1:8000.
+Откройте браузер по адресу: [http://127.0.0.1:8000](http://127.0.0.1:8000).
Вы увидите JSON-ответ вида:
@@ -68,17 +68,17 @@ INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
### Интерактивная документация API { #interactive-api-docs }
-Теперь перейдите по адресу:
http://127.0.0.1:8000/docs.
+Теперь перейдите по адресу: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
-Вы увидите автоматически сгенерированную интерактивную документацию по API (предоставлено
Swagger UI):
+Вы увидите автоматически сгенерированную интерактивную документацию по API (предоставлено [Swagger UI](https://github.com/swagger-api/swagger-ui)):
### Альтернативная документация API { #alternative-api-docs }
-И теперь перейдите по адресу
http://127.0.0.1:8000/redoc.
+И теперь перейдите по адресу [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
-Вы увидите альтернативную автоматически сгенерированную документацию (предоставлено
ReDoc):
+Вы увидите альтернативную автоматически сгенерированную документацию (предоставлено [ReDoc](https://github.com/Rebilly/ReDoc)):
@@ -92,15 +92,15 @@ INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
#### «Схема» API { #api-schema }
-В данном случае
OpenAPI — это спецификация, которая определяет, как описывать схему вашего API.
+В данном случае [OpenAPI](https://github.com/OAI/OpenAPI-Specification) — это спецификация, которая определяет, как описывать схему вашего API.
-Это определение схемы включает пути вашего API, возможные параметры, которые они принимают, и т. п.
+Это определение схемы включает пути вашего API, возможные параметры, которые они принимают, и т.п.
#### «Схема» данных { #data-schema }
Термин «схема» также может относиться к форме некоторых данных, например, к содержимому JSON.
-В таком случае это будут атрибуты JSON, их типы данных и т. п.
+В таком случае это будут атрибуты JSON, их типы данных и т.п.
#### OpenAPI и JSON Schema { #openapi-and-json-schema }
@@ -110,7 +110,7 @@ OpenAPI определяет схему API для вашего API. И эта
Если вам интересно, как выглядит исходная схема OpenAPI, FastAPI автоматически генерирует JSON (схему) с описанием всего вашего API.
-Вы можете посмотреть её напрямую по адресу:
http://127.0.0.1:8000/openapi.json.
+Вы можете посмотреть её напрямую по адресу: [http://127.0.0.1:8000/openapi.json](http://127.0.0.1:8000/openapi.json).
Вы увидите JSON, начинающийся примерно так:
@@ -143,9 +143,58 @@ OpenAPI определяет схему API для вашего API. И эта
Вы также можете использовать её для автоматической генерации кода для клиентов, которые взаимодействуют с вашим API. Например, для фронтенд-, мобильных или IoT-приложений.
+### Настройте app `entrypoint` в `pyproject.toml` { #configure-the-app-entrypoint-in-pyproject-toml }
+
+Вы можете указать расположение вашего приложения в файле `pyproject.toml`, например:
+
+```toml
+[tool.fastapi]
+entrypoint = "main:app"
+```
+
+Этот `entrypoint` подскажет команде `fastapi`, что приложение нужно импортировать так:
+
+```python
+from main import app
+```
+
+Если структура вашего кода выглядит так:
+
+```
+.
+├── backend
+│ ├── main.py
+│ ├── __init__.py
+```
+
+Тогда следует указать такой `entrypoint`:
+
+```toml
+[tool.fastapi]
+entrypoint = "backend.main:app"
+```
+
+что будет эквивалентно:
+
+```python
+from backend.main import app
+```
+
+### `fastapi dev` с путём { #fastapi-dev-with-path }
+
+Вы также можете передать путь к файлу в команду `fastapi dev`, и она попытается определить объект приложения FastAPI для использования:
+
+```console
+$ fastapi dev main.py
+```
+
+Но в этом случае вам придётся каждый раз помнить о передаче корректного пути при вызове команды `fastapi`.
+
+Кроме того, другие инструменты могут его не найти, например [Расширение VS Code](../editor-support.md) или [FastAPI Cloud](https://fastapicloud.com), поэтому рекомендуется использовать `entrypoint` в `pyproject.toml`.
+
### Разверните приложение (необязательно) { #deploy-your-app-optional }
-При желании вы можете развернуть своё приложение FastAPI в
FastAPI Cloud, перейдите и присоединитесь к списку ожидания, если ещё не сделали этого. 🚀
+При желании вы можете развернуть своё приложение FastAPI в [FastAPI Cloud](https://fastapicloud.com), перейдите и присоединитесь к списку ожидания, если ещё не сделали этого. 🚀
Если у вас уже есть аккаунт **FastAPI Cloud** (мы пригласили вас из списка ожидания 😉), вы можете развернуть приложение одной командой.
@@ -191,7 +240,7 @@ Deploying to FastAPI Cloud...
`FastAPI` — это класс, который напрямую наследуется от `Starlette`.
-Вы можете использовать весь функционал
Starlette и в `FastAPI`.
+Вы можете использовать весь функционал [Starlette](https://www.starlette.dev/) и в `FastAPI`.
///
@@ -336,7 +385,7 @@ https://example.com/items/foo
/// note | Примечание
-Если вы не знаете, в чём разница, посмотрите [Асинхронность: *"Нет времени?"*](../async.md#in-a-hurry){.internal-link target=_blank}.
+Если вы не знаете, в чём разница, посмотрите [Асинхронность: *"Нет времени?"*](../async.md#in-a-hurry).
///
@@ -348,15 +397,15 @@ https://example.com/items/foo
Также можно вернуть модели Pydantic (подробнее об этом позже).
-Многие другие объекты и модели будут автоматически преобразованы в JSON (включая ORM и т. п.). Попробуйте использовать те, что вам привычнее, с высокой вероятностью они уже поддерживаются.
+Многие другие объекты и модели будут автоматически преобразованы в JSON (включая ORM и т.п.). Попробуйте использовать те, что вам привычнее, с высокой вероятностью они уже поддерживаются.
### Шаг 6: разверните приложение { #step-6-deploy-it }
-Разверните приложение в **
FastAPI Cloud** одной командой: `fastapi deploy`. 🎉
+Разверните приложение в **[FastAPI Cloud](https://fastapicloud.com)** одной командой: `fastapi deploy`. 🎉
#### О FastAPI Cloud { #about-fastapi-cloud }
-**
FastAPI Cloud** создан тем же автором и командой, что и **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** создан тем же автором и командой, что и **FastAPI**.
Он упрощает процесс **создания образа**, **развертывания** и **доступа** к API с минимальными усилиями.
diff --git a/docs/ru/docs/tutorial/handling-errors.md b/docs/ru/docs/tutorial/handling-errors.md
index fbd82cf28a..fde188f09f 100644
--- a/docs/ru/docs/tutorial/handling-errors.md
+++ b/docs/ru/docs/tutorial/handling-errors.md
@@ -81,7 +81,7 @@
## Установка пользовательских обработчиков исключений { #install-custom-exception-handlers }
-Вы можете добавить пользовательские обработчики исключений с помощью
тех же утилит обработки исключений из Starlette.
+Вы можете добавить пользовательские обработчики исключений с помощью [тех же утилит обработки исключений из Starlette](https://www.starlette.dev/exceptions/).
Допустим, у вас есть пользовательское исключение `UnicornException`, которое вы (или используемая вами библиотека) можете `вызвать`.
diff --git a/docs/ru/docs/tutorial/index.md b/docs/ru/docs/tutorial/index.md
index 6674c6720f..eec217b75b 100644
--- a/docs/ru/docs/tutorial/index.md
+++ b/docs/ru/docs/tutorial/index.md
@@ -10,12 +10,12 @@
Все блоки кода можно копировать и использовать напрямую (это действительно протестированные файлы Python).
-Чтобы запустить любой из примеров, скопируйте код в файл `main.py` и запустите `fastapi dev` с:
+Чтобы запустить любой из примеров, скопируйте код в файл `main.py` и запустите `fastapi dev`:
```console
-$
fastapi dev
main.py
+$
fastapi dev
FastAPI Starting development server 🚀
@@ -62,7 +62,7 @@ $
fastapi dev
@@ -76,7 +76,7 @@ $ pip install "fastapi[standard]"
/// note | Примечание
-При установке с помощью `pip install "fastapi[standard]"` добавляются некоторые стандартные необязательные зависимости по умолчанию, включая `fastapi-cloud-cli`, который позволяет развернуть приложение на FastAPI Cloud.
+При установке с помощью `pip install "fastapi[standard]"` добавляются некоторые стандартные необязательные зависимости по умолчанию, включая `fastapi-cloud-cli`, который позволяет развернуть приложение на [FastAPI Cloud](https://fastapicloud.com).
Если вы не хотите иметь эти необязательные зависимости, установите просто `pip install fastapi`.
@@ -84,6 +84,12 @@ $ pip install "fastapi[standard]"
///
+/// tip | Совет
+
+У FastAPI есть [официальное расширение для VS Code](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (и Cursor), которое предоставляет множество функций, включая обзор операций пути, поиск операций пути, навигацию CodeLens в тестах (переход к определению из тестов), а также развертывание в FastAPI Cloud и просмотр логов - всё прямо из вашего редактора кода.
+
+///
+
## Продвинутое руководство пользователя { #advanced-user-guide }
Существует также **Продвинутое руководство пользователя**, которое вы сможете прочитать после **Учебник - Руководство пользователя**.
diff --git a/docs/ru/docs/tutorial/metadata.md b/docs/ru/docs/tutorial/metadata.md
index 221655aa5d..261cc43f50 100644
--- a/docs/ru/docs/tutorial/metadata.md
+++ b/docs/ru/docs/tutorial/metadata.md
@@ -14,7 +14,7 @@
| `version` | `string` | Версия API. Версия вашего собственного приложения, а не OpenAPI. К примеру `2.5.0`. |
| `terms_of_service` | `str` | Ссылка к условиям пользования API. Если указано, то это должен быть URL-адрес. |
| `contact` | `dict` | Контактная информация для открытого API. Может содержать несколько полей. поля contact
| Параметр | Тип | Описание |
|---|
name | str | Идентификационное имя контактного лица/организации. |
url | str | URL указывающий на контактную информацию. ДОЛЖЕН быть в формате URL. |
email | str | Email адрес контактного лица/организации. ДОЛЖЕН быть в формате email адреса. |
поля license_info
| Параметр | Тип | Описание |
|---|
name | str | ОБЯЗАТЕЛЬНО (если установлен параметр license_info). Название лицензии, используемой для API. |
identifier | str | Выражение лицензии SPDX для API. Поле identifier взаимоисключающее с полем url. Доступно начиная с OpenAPI 3.1.0, FastAPI 0.99.0. |
url | str | URL, указывающий на лицензию, используемую для API. ДОЛЖЕН быть в формате URL. |
поля license_info
| Параметр | Тип | Описание |
|---|
name | str | ОБЯЗАТЕЛЬНО (если установлен параметр license_info). Название лицензии, используемой для API. |
identifier | str | Выражение лицензии [SPDX](https://spdx.org/licenses/) для API. Поле identifier взаимоисключающее с полем url. Доступно начиная с OpenAPI 3.1.0, FastAPI 0.99.0. |
url | str | URL, указывающий на лицензию, используемую для API. ДОЛЖЕН быть в формате URL. |
gt, вместо ge, поскольку в таком случае вы можете, например, создать ограничение, чтобы значение было больше `0`, даже если оно меньше `1`.
+В этом случае становится важной возможность добавить ограничение gt, вместо ge, поскольку в таком случае вы можете, например, создать ограничение, чтобы значение было больше `0`, даже если оно меньше `1`.
Таким образом, `0.5` будет корректным значением. А `0.0` или `0` — нет.
-То же самое справедливо и для lt.
+То же самое справедливо и для lt.
{* ../../docs_src/path_params_numeric_validations/tutorial006_an_py310.py hl[13] *}
## Резюме { #recap }
-С помощью `Query`, `Path` (и других классов, которые мы пока не затронули) вы можете добавлять метаданные и строковую валидацию тем же способом, как и в главе [Query-параметры и валидация строк](query-params-str-validations.md){.internal-link target=_blank}.
+С помощью `Query`, `Path` (и других классов, которые мы пока не затронули) вы можете добавлять метаданные и строковую валидацию тем же способом, как и в главе [Query-параметры и валидация строк](query-params-str-validations.md).
А также вы можете добавить валидацию числовых данных:
diff --git a/docs/ru/docs/tutorial/path-params.md b/docs/ru/docs/tutorial/path-params.md
index 7295697487..79343a1588 100644
--- a/docs/ru/docs/tutorial/path-params.md
+++ b/docs/ru/docs/tutorial/path-params.md
@@ -6,7 +6,7 @@
Значение параметра пути `item_id` будет передано в функцию в качестве аргумента `item_id`.
-Если запустите этот пример и перейдёте по адресу: http://127.0.0.1:8000/items/foo, то увидите ответ:
+Если запустите этот пример и перейдёте по адресу: [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo), то увидите ответ:
```JSON
{"item_id":"foo"}
@@ -28,7 +28,7 @@
## Преобразование данных { #data-conversion }
-Если запустите этот пример и перейдёте по адресу: http://127.0.0.1:8000/items/3, то увидите ответ:
+Если запустите этот пример и перейдёте по адресу: [http://127.0.0.1:8000/items/3](http://127.0.0.1:8000/items/3), то увидите ответ:
```JSON
{"item_id":3}
@@ -44,7 +44,7 @@
## Валидация данных { #data-validation }
-Если откроете браузер по адресу http://127.0.0.1:8000/items/foo, то увидите интересную HTTP-ошибку:
+Если откроете браузер по адресу [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo), то увидите интересную HTTP-ошибку:
```JSON
{
@@ -64,7 +64,7 @@
из-за того, что параметр пути `item_id` имеет значение `"foo"`, которое не является типом `int`.
-Та же ошибка возникнет, если вместо `int` передать `float`, например: http://127.0.0.1:8000/items/4.2
+Та же ошибка возникнет, если вместо `int` передать `float`, например: [http://127.0.0.1:8000/items/4.2](http://127.0.0.1:8000/items/4.2)
/// check | Заметка
@@ -78,7 +78,7 @@
## Документация { #documentation }
-И теперь, когда откроете браузер по адресу: http://127.0.0.1:8000/docs, то увидите вот такую автоматически сгенерированную документацию API:
+И теперь, когда откроете браузер по адресу: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs), то увидите вот такую автоматически сгенерированную документацию API:
@@ -92,9 +92,9 @@
## Преимущества стандартизации, альтернативная документация { #standards-based-benefits-alternative-documentation }
-Поскольку сгенерированная схема соответствует стандарту OpenAPI, её можно использовать со множеством совместимых инструментов.
+Поскольку сгенерированная схема соответствует стандарту [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md), её можно использовать со множеством совместимых инструментов.
-Именно поэтому, **FastAPI** сам предоставляет альтернативную документацию API (используя ReDoc), которую можно получить по адресу: http://127.0.0.1:8000/redoc.
+Именно поэтому, **FastAPI** сам предоставляет альтернативную документацию API (используя ReDoc), которую можно получить по адресу: [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
@@ -102,7 +102,7 @@
## Pydantic { #pydantic }
-Вся проверка данных выполняется под капотом с помощью Pydantic. Поэтому вы можете быть уверены в качестве обработки данных.
+Вся проверка данных выполняется под капотом с помощью [Pydantic](https://docs.pydantic.dev/), поэтому вы получаете все его преимущества. И вы можете быть уверены, что находитесь в надёжных руках.
Вы можете использовать в аннотациях как простые типы данных, вроде `str`, `float`, `bool`, так и более сложные типы.
@@ -130,7 +130,7 @@
## Предопределенные значения { #predefined-values }
-Что если нам нужно заранее определить допустимые *параметры пути*, которые *операция пути* может принимать? В таком случае можно использовать стандартное перечисление `Enum` Python.
+Что если нам нужно заранее определить допустимые *параметры пути*, которые *операция пути* может принимать? В таком случае можно использовать стандартное перечисление `Enum` Python.
### Создание класса `Enum` { #create-an-enum-class }
diff --git a/docs/ru/docs/tutorial/query-params-str-validations.md b/docs/ru/docs/tutorial/query-params-str-validations.md
index 43cbcad03c..08a5e11a54 100644
--- a/docs/ru/docs/tutorial/query-params-str-validations.md
+++ b/docs/ru/docs/tutorial/query-params-str-validations.md
@@ -35,13 +35,13 @@ FastAPI поймёт, что значение `q` не обязательно,
Если у вас более старая версия, при попытке использовать `Annotated` вы получите ошибки.
-Убедитесь, что вы [обновили версию FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} как минимум до 0.95.1 перед использованием `Annotated`.
+Убедитесь, что вы [обновили версию FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions) как минимум до 0.95.1 перед использованием `Annotated`.
///
## Использовать `Annotated` в типе для параметра `q` { #use-annotated-in-the-type-for-the-q-parameter }
-Помните, я уже говорил, что `Annotated` можно использовать для добавления метаданных к параметрам в разделе [Введение в типы Python](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank}?
+Помните, я уже говорил, что `Annotated` можно использовать для добавления метаданных к параметрам в разделе [Введение в типы Python](../python-types.md#type-hints-with-metadata-annotations)?
Пришло время использовать его с FastAPI. 🚀
@@ -157,7 +157,7 @@ q: str = Query(default="rick")
Если вы не используете `Annotated`, а применяете **(устаревший) стиль со значением по умолчанию**, то при вызове этой функции без FastAPI в **других местах** вам нужно **помнить** о том, что надо передать аргументы, чтобы всё работало корректно, иначе значения будут не такими, как вы ожидаете (например, вместо `str` будет `QueryInfo` или что-то подобное). И ни редактор, ни Python не будут ругаться при самом вызове функции — ошибка проявится лишь при операциях внутри.
-Так как `Annotated` может содержать больше одной аннотации метаданных, теперь вы можете использовать ту же функцию и с другими инструментами, например с Typer. 🚀
+Так как `Annotated` может содержать больше одной аннотации метаданных, теперь вы можете использовать ту же функцию и с другими инструментами, например с [Typer](https://typer.tiangolo.com/). 🚀
## Больше валидаций { #add-more-validations }
@@ -369,11 +369,11 @@ http://127.0.0.1:8000/items/?item-query=foobaritems
В таких случаях можно использовать **кастомную функцию-валидатор**, которая применяется после обычной валидации (например, после проверки, что значение — это `str`).
-Этого можно добиться, используя `AfterValidator` Pydantic внутри `Annotated`.
+Этого можно добиться, используя [`AfterValidator` Pydantic](https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator) внутри `Annotated`.
/// tip | Совет
-В Pydantic также есть `BeforeValidator` и другие. 🤓
+В Pydantic также есть [`BeforeValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator) и другие. 🤓
///
@@ -389,7 +389,7 @@ http://127.0.0.1:8000/items/?item-query=foobaritems
/// tip | Совет
-Если вам нужна валидация, требующая общения с каким‑либо **внешним компонентом** — базой данных или другим API — вместо этого используйте **Зависимости FastAPI** (FastAPI Dependencies), вы познакомитесь с ними позже.
+Если вам нужна валидация, требующая общения с каким‑либо **внешним компонентом** — базой данных или другим API — вместо этого используйте **Зависимости FastAPI**, вы познакомитесь с ними позже.
Эти кастомные валидаторы предназначены для проверок, которые можно выполнить, имея **только** те же **данные**, что пришли в запросе.
diff --git a/docs/ru/docs/tutorial/query-params.md b/docs/ru/docs/tutorial/query-params.md
index cbacb129c5..99f2a98aeb 100644
--- a/docs/ru/docs/tutorial/query-params.md
+++ b/docs/ru/docs/tutorial/query-params.md
@@ -182,6 +182,6 @@ http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
/// tip | Подсказка
-Вы можете использовать класс `Enum` также, как ранее применяли его с [Path-параметрами](path-params.md#predefined-values){.internal-link target=_blank}.
+Вы можете использовать класс `Enum` также, как ранее применяли его с [Path-параметрами](path-params.md#predefined-values).
///
diff --git a/docs/ru/docs/tutorial/request-files.md b/docs/ru/docs/tutorial/request-files.md
index 41922333f8..e8500adbac 100644
--- a/docs/ru/docs/tutorial/request-files.md
+++ b/docs/ru/docs/tutorial/request-files.md
@@ -4,9 +4,9 @@
/// info | Дополнительная информация
-Чтобы получать загруженные файлы, сначала установите `python-multipart`.
+Чтобы получать загруженные файлы, сначала установите [`python-multipart`](https://github.com/Kludex/python-multipart).
-Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его, а затем установили пакет, например:
+Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md), активировали его, а затем установили пакет, например:
```console
$ pip install python-multipart
@@ -63,8 +63,8 @@ $ pip install python-multipart
* Файл, хранящийся в памяти до максимального предела размера, после преодоления которого он будет храниться на диске.
* Это означает, что он будет хорошо работать с большими файлами, такими как изображения, видео, большие бинарные файлы и т.д., не потребляя при этом всю память.
* Из загруженного файла можно получить метаданные.
-* Он реализует file-like `async` интерфейс.
-* Он предоставляет реальный объект Python `SpooledTemporaryFile` который вы можете передать непосредственно другим библиотекам, которые ожидают файл в качестве объекта.
+* Он реализует [file-like](https://docs.python.org/3/glossary.html#term-file-like-object) `async` интерфейс.
+* Он предоставляет реальный объект Python [`SpooledTemporaryFile`](https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile), который вы можете передать непосредственно другим библиотекам, которые ожидают файл в качестве объекта.
### `UploadFile` { #uploadfile }
@@ -72,7 +72,7 @@ $ pip install python-multipart
* `filename`: Строка `str` с исходным именем файла, который был загружен (например, `myimage.jpg`).
* `content_type`: Строка `str` с типом содержимого (MIME type / media type) (например, `image/jpeg`).
-* `file`: `SpooledTemporaryFile` (a file-like объект). Это фактический файл Python, который можно передавать непосредственно другим функциям или библиотекам, ожидающим файл в качестве объекта.
+* `file`: [`SpooledTemporaryFile`](https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile) (a [file-like](https://docs.python.org/3/glossary.html#term-file-like-object) объект). Это фактический файл Python, который можно передавать непосредственно другим функциям или библиотекам, ожидающим файл в качестве объекта.
`UploadFile` имеет следующие методы `async`. Все они вызывают соответствующие файловые методы (используя внутренний `SpooledTemporaryFile`).
@@ -120,9 +120,9 @@ contents = myfile.file.read()
Данные из форм обычно кодируются с использованием "media type" `application/x-www-form-urlencoded` когда он не включает файлы.
-Но когда форма включает файлы, она кодируется как multipart/form-data. Если вы используете `File`, **FastAPI** будет знать, что ему нужно получить файлы из нужной части тела.
+Но когда форма включает файлы, она кодируется как `multipart/form-data`. Если вы используете `File`, **FastAPI** будет знать, что ему нужно получить файлы из нужной части тела.
-Если вы хотите узнать больше об этих кодировках и полях форм, перейдите по ссылке MDN web docs for POST.
+Если вы хотите узнать больше об этих кодировках и полях форм, перейдите по ссылке [MDN web docs for `POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST).
///
diff --git a/docs/ru/docs/tutorial/request-form-models.md b/docs/ru/docs/tutorial/request-form-models.md
index f4411a27bc..c7f37c2baf 100644
--- a/docs/ru/docs/tutorial/request-form-models.md
+++ b/docs/ru/docs/tutorial/request-form-models.md
@@ -4,9 +4,9 @@
/// info | Дополнительная информация
-Чтобы использовать формы, сначала установите `python-multipart`.
+Чтобы использовать формы, сначала установите [`python-multipart`](https://github.com/Kludex/python-multipart).
-Убедитесь, что вы создали и активировали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, а затем установите пакет, например:
+Убедитесь, что вы создали и активировали [виртуальное окружение](../virtual-environments.md), а затем установите пакет, например:
```console
$ pip install python-multipart
diff --git a/docs/ru/docs/tutorial/request-forms-and-files.md b/docs/ru/docs/tutorial/request-forms-and-files.md
index 10836d74fd..f291d53479 100644
--- a/docs/ru/docs/tutorial/request-forms-and-files.md
+++ b/docs/ru/docs/tutorial/request-forms-and-files.md
@@ -4,9 +4,9 @@
/// info | Информация
-Чтобы получать загруженные файлы и/или данные форм, сначала установите `python-multipart`.
+Чтобы получать загруженные файлы и/или данные форм, сначала установите [`python-multipart`](https://github.com/Kludex/python-multipart).
-Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его, а затем установили пакет, например:
+Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md), активировали его, а затем установили пакет, например:
```console
$ pip install python-multipart
diff --git a/docs/ru/docs/tutorial/request-forms.md b/docs/ru/docs/tutorial/request-forms.md
index 01f71ac2fc..3760a8a3b9 100644
--- a/docs/ru/docs/tutorial/request-forms.md
+++ b/docs/ru/docs/tutorial/request-forms.md
@@ -4,9 +4,9 @@
/// info | Дополнительная информация
-Чтобы использовать формы, сначала установите `python-multipart`.
+Чтобы использовать формы, сначала установите [`python-multipart`](https://github.com/Kludex/python-multipart).
-Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его, а затем установили пакет, например:
+Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md), активировали его, а затем установили пакет, например:
```console
$ pip install python-multipart
@@ -56,7 +56,7 @@ $ pip install python-multipart
Но когда форма содержит файлы, она кодируется как `multipart/form-data`. О работе с файлами вы прочтёте в следующей главе.
-Если вы хотите узнать больше про эти кодировки и поля формы, обратитесь к MDN веб-документации для `POST`.
+Если вы хотите узнать больше про эти кодировки и поля формы, обратитесь к [MDN веб-документации для `POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST).
///
diff --git a/docs/ru/docs/tutorial/response-model.md b/docs/ru/docs/tutorial/response-model.md
index cd99ce28c7..510143d7b4 100644
--- a/docs/ru/docs/tutorial/response-model.md
+++ b/docs/ru/docs/tutorial/response-model.md
@@ -13,6 +13,7 @@ FastAPI будет использовать этот возвращаемый т
* Добавить **JSON Schema** для ответа в OpenAPI *операции пути*.
* Это будет использовано **автоматической документацией**.
* Это также будет использовано инструментами автоматической генерации клиентского кода.
+* **Сериализовать** возвращаемые данные в JSON с помощью Pydantic, который написан на **Rust**, поэтому это будет **намного быстрее**.
Но самое главное:
@@ -73,9 +74,9 @@ FastAPI будет использовать этот `response_model` для д
/// info | Информация
-Чтобы использовать `EmailStr`, сначала установите `email-validator`.
+Чтобы использовать `EmailStr`, сначала установите [`email-validator`](https://github.com/JoshData/python-email-validator).
-Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его, а затем установите пакет, например:
+Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md), активировали его, а затем установите пакет, например:
```console
$ pip install email-validator
@@ -181,7 +182,7 @@ FastAPI делает несколько вещей внутри вместе с
### Возврат Response напрямую { #return-a-response-directly }
-Самый распространённый случай — [возвращать Response напрямую, как описано далее в разделах документации для продвинутых](../advanced/response-directly.md){.internal-link target=_blank}.
+Самый распространённый случай — [возвращать Response напрямую, как описано далее в разделах документации для продвинутых](../advanced/response-directly.md).
{* ../../docs_src/response_model/tutorial003_02_py310.py hl[8,10:11] *}
@@ -201,7 +202,7 @@ FastAPI делает несколько вещей внутри вместе с
Но когда вы возвращаете произвольный объект, не являющийся валидным типом Pydantic (например, объект базы данных), и аннотируете его таким образом в функции, FastAPI попытается создать модель ответа Pydantic из этой аннотации типа и потерпит неудачу.
-То же произойдёт, если у вас будет что-то вроде union разных типов, где один или несколько не являются валидными типами Pydantic, например, это приведёт к ошибке 💥:
+То же произойдёт, если у вас будет что-то вроде объединение разных типов, где один или несколько не являются валидными типами Pydantic, например, это приведёт к ошибке 💥:
{* ../../docs_src/response_model/tutorial003_04_py310.py hl[8] *}
@@ -257,7 +258,7 @@ FastAPI делает несколько вещей внутри вместе с
* `response_model_exclude_defaults=True`
* `response_model_exclude_none=True`
-как описано в документации Pydantic для `exclude_defaults` и `exclude_none`.
+как описано в [документации Pydantic](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict) для `exclude_defaults` и `exclude_none`.
///
diff --git a/docs/ru/docs/tutorial/response-status-code.md b/docs/ru/docs/tutorial/response-status-code.md
index 13d982e803..f3144a33ab 100644
--- a/docs/ru/docs/tutorial/response-status-code.md
+++ b/docs/ru/docs/tutorial/response-status-code.md
@@ -20,7 +20,7 @@
/// info | Информация
-В качестве значения параметра `status_code` также может использоваться `IntEnum`, например, из библиотеки `http.HTTPStatus` в Python.
+В качестве значения параметра `status_code` также может использоваться `IntEnum`, например, из библиотеки [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus) в Python.
///
@@ -66,7 +66,7 @@ FastAPI знает об этом и создаст документацию Open
/// tip | Подсказка
-Чтобы узнать больше о HTTP кодах статуса и о том, для чего каждый из них предназначен, ознакомьтесь с MDN документацией об HTTP статус-кодах.
+Чтобы узнать больше о HTTP кодах статуса и о том, для чего каждый из них предназначен, ознакомьтесь с [MDN документацией об HTTP статус-кодах](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status).
///
@@ -98,4 +98,4 @@ FastAPI знает об этом и создаст документацию Open
## Изменение кода статуса по умолчанию { #changing-the-default }
-Позже, в [Руководстве для продвинутых пользователей](../advanced/response-change-status-code.md){.internal-link target=_blank}, вы узнаете, как возвращать HTTP статус-код, отличный от значения по умолчанию, которое вы объявляете здесь.
+Позже, в [Руководстве для продвинутых пользователей](../advanced/response-change-status-code.md), вы узнаете, как возвращать HTTP статус-код, отличный от значения по умолчанию, которое вы объявляете здесь.
diff --git a/docs/ru/docs/tutorial/schema-extra-example.md b/docs/ru/docs/tutorial/schema-extra-example.md
index c7381aae25..ee2f5b9913 100644
--- a/docs/ru/docs/tutorial/schema-extra-example.md
+++ b/docs/ru/docs/tutorial/schema-extra-example.md
@@ -12,7 +12,7 @@
Эта дополнительная информация будет добавлена как есть в выходную **JSON Schema** этой модели и будет использоваться в документации API.
-Вы можете использовать атрибут `model_config`, который принимает `dict`, как описано в Документации Pydantic: Конфигурация.
+Вы можете использовать атрибут `model_config`, который принимает `dict`, как описано в [Документация Pydantic: Конфигурация](https://docs.pydantic.dev/latest/api/config/).
Вы можете задать `"json_schema_extra"` с `dict`, содержащим любые дополнительные данные, которые вы хотите видеть в сгенерированной JSON Schema, включая `examples`.
@@ -145,12 +145,12 @@ OpenAPI 3.1.0 (используется начиная с FastAPI 0.99.0) доб
OpenAPI также добавила поля `example` и `examples` в другие части спецификации:
-* `Parameter Object` (в спецификации), которое использовалось в FastAPI:
+* [`Parameter Object` (в спецификации)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object), которое использовалось в FastAPI:
* `Path()`
* `Query()`
* `Header()`
* `Cookie()`
-* `Request Body Object`, в поле `content`, в `Media Type Object` (в спецификации), которое использовалось в FastAPI:
+* [`Request Body Object`, в поле `content`, в `Media Type Object` (в спецификации)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object), которое использовалось в FastAPI:
* `Body()`
* `File()`
* `Form()`
@@ -163,7 +163,7 @@ OpenAPI также добавила поля `example` и `examples` в друг
### Поле `examples` в JSON Schema { #json-schemas-examples-field }
-Позже в новой версии спецификации JSON Schema было добавлено поле `examples`.
+Позже в новой версии спецификации JSON Schema было добавлено поле [`examples`](https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.9.5).
А затем новый OpenAPI 3.1.0 был основан на последней версии (JSON Schema 2020-12), которая включала это новое поле `examples`.
diff --git a/docs/ru/docs/tutorial/security/first-steps.md b/docs/ru/docs/tutorial/security/first-steps.md
index 9b9673b842..c55e832f40 100644
--- a/docs/ru/docs/tutorial/security/first-steps.md
+++ b/docs/ru/docs/tutorial/security/first-steps.md
@@ -26,11 +26,11 @@
/// info | Дополнительная информация
-Пакет `python-multipart` автоматически устанавливается вместе с **FastAPI**, если вы запускаете команду `pip install "fastapi[standard]"`.
+Пакет [`python-multipart`](https://github.com/Kludex/python-multipart) автоматически устанавливается вместе с **FastAPI**, если вы запускаете команду `pip install "fastapi[standard]"`.
Однако, если вы используете команду `pip install fastapi`, пакет `python-multipart` по умолчанию не включается.
-Чтобы установить его вручную, убедитесь, что вы создали [виртуальное окружение](../../virtual-environments.md){.internal-link target=_blank}, активировали его и затем установили пакет:
+Чтобы установить его вручную, убедитесь, что вы создали [виртуальное окружение](../../virtual-environments.md), активировали его и затем установили пакет:
```console
$ pip install python-multipart
@@ -45,7 +45,7 @@ $ pip install python-multipart
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -54,7 +54,7 @@ $ fastapi dev main.py
## Проверка { #check-it }
-Перейдите к интерактивной документации по адресу:
http://127.0.0.1:8000/docs.
+Перейдите к интерактивной документации по адресу: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Вы увидите примерно следующее:
@@ -140,7 +140,7 @@ OAuth2 был спроектирован так, чтобы бэкенд или
Поскольку мы используем относительный URL, если ваш API расположен по адресу `https://example.com/`, то он будет ссылаться на `https://example.com/token`. А если ваш API расположен по адресу `https://example.com/api/v1/`, то он будет ссылаться на `https://example.com/api/v1/token`.
-Использование относительного URL важно для того, чтобы ваше приложение продолжало работать даже в таком продвинутом случае, как [За прокси-сервером](../../advanced/behind-a-proxy.md){.internal-link target=_blank}.
+Использование относительного URL важно для того, чтобы ваше приложение продолжало работать даже в таком продвинутом случае, как [За прокси-сервером](../../advanced/behind-a-proxy.md).
///
diff --git a/docs/ru/docs/tutorial/security/oauth2-jwt.md b/docs/ru/docs/tutorial/security/oauth2-jwt.md
index f7853d48f7..e3729dfc83 100644
--- a/docs/ru/docs/tutorial/security/oauth2-jwt.md
+++ b/docs/ru/docs/tutorial/security/oauth2-jwt.md
@@ -24,13 +24,13 @@ eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4
Через неделю срок действия токена истечет, пользователь не будет авторизован и ему придется заново входить в систему, чтобы получить новый токен. А если пользователь (или третье лицо) попытается модифицировать токен, чтобы изменить срок действия, вы сможете это обнаружить, поскольку подписи не будут совпадать.
-Если вы хотите поиграть с JWT-токенами и посмотреть, как они работают, посмотрите
https://jwt.io.
+Если вы хотите поиграть с JWT-токенами и посмотреть, как они работают, посмотрите [https://jwt.io](https://jwt.io/).
## Установка `PyJWT` { #install-pyjwt }
Нам необходимо установить `pyjwt` для генерации и проверки JWT-токенов на языке Python.
-Убедитесь, что вы создали [виртуальное окружение](../../virtual-environments.md){.internal-link target=_blank}, активируйте его, а затем установите `pyjwt`:
+Убедитесь, что вы создали [виртуальное окружение](../../virtual-environments.md), активируйте его, а затем установите `pyjwt`:
@@ -46,7 +46,7 @@ $ pip install pyjwt
Если вы планируете использовать алгоритмы цифровой подписи, такие как RSA или ECDSA, вам следует установить зависимость библиотеки криптографии `pyjwt[crypto]`.
-Подробнее об этом можно прочитать в
документации по установке PyJWT.
+Подробнее об этом можно прочитать в [документации по установке PyJWT](https://pyjwt.readthedocs.io/en/latest/installation.html).
///
@@ -72,7 +72,7 @@ pwdlib — это отличный пакет Python для работы с хэ
Рекомендуемый алгоритм — "Argon2".
-Убедитесь, что вы создали [виртуальное окружение](../../virtual-environments.md){.internal-link target=_blank}, активируйте его, и затем установите pwdlib вместе с Argon2:
+Убедитесь, что вы создали [виртуальное окружение](../../virtual-environments.md), активируйте его, и затем установите pwdlib вместе с Argon2:
@@ -200,7 +200,7 @@ JWT может использоваться и для других целей,
## Проверка в действии { #check-it }
-Запустите сервер и перейдите к документации:
http://127.0.0.1:8000/docs.
+Запустите сервер и перейдите к документации: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Вы увидите пользовательский интерфейс вида:
diff --git a/docs/ru/docs/tutorial/security/simple-oauth2.md b/docs/ru/docs/tutorial/security/simple-oauth2.md
index 4b86a40139..4ef5109e4f 100644
--- a/docs/ru/docs/tutorial/security/simple-oauth2.md
+++ b/docs/ru/docs/tutorial/security/simple-oauth2.md
@@ -137,7 +137,7 @@ UserInDB(
```
/// info | Дополнительная информация
-Более полное объяснение `**user_dict` можно найти в [документации к **Дополнительным моделям**](../extra-models.md#about-user-in-dict){.internal-link target=_blank}.
+Более полное объяснение `**user_dict` можно найти в [документации к **Дополнительным моделям**](../extra-models.md#about-user-in-dict).
///
## Возврат токена { #return-the-token }
@@ -200,7 +200,7 @@ UserInDB(
## Посмотрим, как это работает { #see-it-in-action }
-Откройте интерактивную документацию:
http://127.0.0.1:8000/docs.
+Откройте интерактивную документацию: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
### Аутентификация { #authenticate }
diff --git a/docs/ru/docs/tutorial/server-sent-events.md b/docs/ru/docs/tutorial/server-sent-events.md
new file mode 100644
index 0000000000..be6bd23665
--- /dev/null
+++ b/docs/ru/docs/tutorial/server-sent-events.md
@@ -0,0 +1,120 @@
+# События, отправляемые сервером (SSE) { #server-sent-events-sse }
+
+Вы можете передавать данные потоком клиенту, используя Server-Sent Events (SSE).
+
+Это похоже на [Стриминг JSON Lines](stream-json-lines.md), но использует формат `text/event-stream`, который нативно поддерживается браузерами через [`EventSource` API](https://developer.mozilla.org/en-US/docs/Web/API/EventSource).
+
+/// info | Информация
+
+Добавлено в FastAPI 0.135.0.
+
+///
+
+## Что такое Server-Sent Events? { #what-are-server-sent-events }
+
+SSE — это стандарт для потоковой передачи данных с сервера на клиента по HTTP.
+
+Каждое событие — это небольшой текстовый блок с «полями», такими как `data`, `event`, `id` и `retry`, разделёнными пустыми строками.
+
+Это выглядит так:
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+SSE часто используют для стриминга ответов ИИ в чатах, живых уведомлений, логов и наблюдаемости, а также в других случаях, когда сервер «проталкивает» обновления клиенту.
+
+/// tip | Совет
+
+Если вам нужно стримить бинарные данные, например видео или аудио, посмотрите расширенное руководство: [Stream Data](../advanced/stream-data.md).
+
+///
+
+## Стриминг SSE с FastAPI { #stream-sse-with-fastapi }
+
+Чтобы стримить SSE с FastAPI, используйте `yield` в своей функции-обработчике пути и укажите `response_class=EventSourceResponse`.
+
+Импортируйте `EventSourceResponse` из `fastapi.sse`:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+Каждый возвращаемый через `yield` элемент кодируется как JSON и отправляется в поле `data:` события SSE.
+
+Если вы объявите тип возврата как `AsyncIterable[Item]`, FastAPI будет использовать его, чтобы выполнить **валидацию**, добавить **документацию** и **сериализовать** данные с помощью Pydantic.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[10:12,23] *}
+
+/// tip | Совет
+
+Так как Pydantic будет сериализовать это на стороне **Rust**, вы получите значительно более высокую **производительность**, чем если не объявите тип возврата.
+
+///
+
+### Несинхронные функции-обработчики пути { #non-async-path-operation-functions }
+
+Вы также можете использовать обычные функции `def` (без `async`) и применять `yield` тем же образом.
+
+FastAPI проследит, чтобы выполнение прошло корректно и не блокировало цикл событий.
+
+Так как в этом случае функция не async, правильным типом возврата будет `Iterable[Item]`:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[28:31] hl[29] *}
+
+### Без объявленного типа возврата { #no-return-type }
+
+Вы также можете опустить тип возврата. FastAPI использует [`jsonable_encoder`](./encoder.md) для преобразования данных и их отправки.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+Если вам нужно задать поля SSE, такие как `event`, `id`, `retry` или `comment`, вы можете возвращать через `yield` объекты `ServerSentEvent` вместо обычных данных.
+
+Импортируйте `ServerSentEvent` из `fastapi.sse`:
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+Поле `data` всегда кодируется как JSON. Вы можете передавать любое значение, сериализуемое в JSON, включая Pydantic-модели.
+
+## Необработанные данные { #raw-data }
+
+Если нужно отправлять данные без JSON-кодирования, используйте `raw_data` вместо `data`.
+
+Это полезно для отправки заранее отформатированного текста, строк логов или специальных значений
«сентинель», например `[DONE]`.
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | Примечание
+
+`data` и `raw_data` взаимно исключают друг друга. В каждом `ServerSentEvent` можно задать только одно из них.
+
+///
+
+## Возобновление с `Last-Event-ID` { #resuming-with-last-event-id }
+
+Когда браузер переподключается после обрыва соединения, он отправляет последний полученный `id` в HTTP-заголовке `Last-Event-ID`.
+
+Вы можете прочитать его как параметр заголовка и использовать, чтобы возобновить поток с того места, где клиент остановился:
+
+{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}
+
+## SSE с POST { #sse-with-post }
+
+SSE работает с любым HTTP-методом, не только с `GET`.
+
+Это полезно для таких протоколов, как [MCP](https://modelcontextprotocol.io), которые стримят SSE по `POST`:
+
+{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}
+
+## Технические детали { #technical-details }
+
+FastAPI из коробки реализует некоторые лучшие практики для SSE.
+
+- Отправлять комментарий «ping» для поддержания соединения («keep alive») каждые 15 секунд, когда нет сообщений, чтобы предотвратить закрытие соединения некоторыми прокси, как рекомендовано в [HTML specification: Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes).
+- Устанавливать заголовок `Cache-Control: no-cache`, чтобы предотвратить кэширование потока.
+- Устанавливать специальный заголовок `X-Accel-Buffering: no`, чтобы предотвратить буферизацию в некоторых прокси, например Nginx.
+
+Вам не нужно ничего настраивать, это работает из коробки. 🤓
diff --git a/docs/ru/docs/tutorial/sql-databases.md b/docs/ru/docs/tutorial/sql-databases.md
index ed67739cc9..ae86373387 100644
--- a/docs/ru/docs/tutorial/sql-databases.md
+++ b/docs/ru/docs/tutorial/sql-databases.md
@@ -2,9 +2,9 @@
**FastAPI** не требует использовать SQL (реляционную) базу данных. Но вы можете использовать любую базу данных, которую хотите.
-Здесь мы рассмотрим пример с использованием
SQLModel.
+Здесь мы рассмотрим пример с использованием [SQLModel](https://sqlmodel.tiangolo.com/).
-**SQLModel** построен поверх
SQLAlchemy и Pydantic. Его создал тот же автор, что и **FastAPI**, чтобы он идеально подходил для приложений FastAPI, которым нужны **SQL базы данных**.
+**SQLModel** построен поверх [SQLAlchemy](https://www.sqlalchemy.org/) и Pydantic. Его создал тот же автор, что и **FastAPI**, чтобы он идеально подходил для приложений FastAPI, которым нужны **SQL базы данных**.
/// tip | Подсказка
@@ -26,15 +26,15 @@
/// tip | Подсказка
-Существует официальный генератор проектов на **FastAPI** и **PostgreSQL**, включающий frontend и другие инструменты:
https://github.com/fastapi/full-stack-fastapi-template
+Существует официальный генератор проектов на **FastAPI** и **PostgreSQL**, включающий frontend и другие инструменты: [https://github.com/fastapi/full-stack-fastapi-template](https://github.com/fastapi/full-stack-fastapi-template)
///
-Это очень простое и короткое руководство. Если вы хотите узнать больше о базах данных в целом, об SQL или о более продвинутых возможностях, обратитесь к
документации SQLModel.
+Это очень простое и короткое руководство. Если вы хотите узнать больше о базах данных в целом, об SQL или о более продвинутых возможностях, обратитесь к [документации SQLModel](https://sqlmodel.tiangolo.com/).
## Установка `SQLModel` { #install-sqlmodel }
-Сначала убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его и затем установили `sqlmodel`:
+Сначала убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md), активировали его и затем установили `sqlmodel`:
@@ -57,7 +57,7 @@ $ pip install sqlmodel
{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[1:11] hl[7:11] *}
-Класс `Hero` очень похож на модель Pydantic (фактически, под капотом, *это и есть модель Pydantic*).
+Класс `Hero` очень похож на модель Pydantic (фактически, под капотом, это и есть модель Pydantic).
Есть несколько отличий:
@@ -65,7 +65,7 @@ $ pip install sqlmodel
* `Field(primary_key=True)` сообщает SQLModel, что `id` — это **первичный ключ** в SQL базе данных (подробнее о первичных ключах SQL можно узнать в документации SQLModel).
- **Примечание:** Мы используем `int | None` для поля первичного ключа, чтобы в Python-коде можно было *создать объект без `id`* (`id=None`), предполагая, что база данных *сгенерирует его при сохранении*. SQLModel понимает, что база данных предоставит `id`, и *определяет столбец как `INTEGER` (не `NULL`)* в схеме базы данных. См.
документацию SQLModel о первичных ключах для подробностей.
+ **Примечание:** Мы используем `int | None` для поля первичного ключа, чтобы в Python-коде можно было *создать объект без `id`* (`id=None`), предполагая, что база данных *сгенерирует его при сохранении*. SQLModel понимает, что база данных предоставит `id`, и *определяет столбец как `INTEGER` (не `NULL`)* в схеме базы данных. См. [документацию SQLModel о первичных ключах](https://sqlmodel.tiangolo.com/tutorial/create-db-and-table/#primary-key-id) для подробностей.
* `Field(index=True)` сообщает SQLModel, что нужно создать **SQL индекс** для этого столбца, что позволит быстрее выполнять выборки при чтении данных, отфильтрованных по этому столбцу.
@@ -81,7 +81,7 @@ $ pip install sqlmodel
Параметр `check_same_thread=False` позволяет FastAPI использовать одну и ту же базу данных SQLite в разных потоках. Это необходимо, так как **один запрос** может использовать **больше одного потока** (например, в зависимостях).
-Не волнуйтесь, с такой структурой кода мы позже обеспечим использование **одной *сессии* SQLModel на запрос**, по сути именно этого и добивается `check_same_thread`.
+Не волнуйтесь, с такой структурой кода мы позже обеспечим использование **одной сессии SQLModel на запрос**, по сути именно этого и добивается `check_same_thread`.
### Создание таблиц { #create-the-tables }
@@ -111,7 +111,7 @@ $ pip install sqlmodel
/// tip | Подсказка
-В SQLModel появятся утилиты миграций - обёртки над Alembic, но пока вы можете использовать
Alembic напрямую.
+В SQLModel появятся утилиты миграций — обёртки над Alembic, но пока вы можете использовать [Alembic](https://alembic.sqlalchemy.org/en/latest/) напрямую.
///
@@ -152,7 +152,7 @@ $ pip install sqlmodel
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -337,7 +337,7 @@ $ fastapi dev main.py
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -352,6 +352,6 @@ $ fastapi dev main.py
## Резюме { #recap }
-Вы можете использовать
**SQLModel** для взаимодействия с SQL базой данных и упростить код с помощью *моделей данных* и *моделей-таблиц*.
+Вы можете использовать [**SQLModel**](https://sqlmodel.tiangolo.com/) для взаимодействия с SQL базой данных и упростить код с помощью *моделей данных* и *моделей-таблиц*.
-Гораздо больше вы можете узнать в документации **SQLModel**, там есть более подробное мини-
руководство по использованию SQLModel с **FastAPI**. 🚀
+Гораздо больше вы можете узнать в документации **SQLModel**, там есть более подробное мини-[руководство по использованию SQLModel с **FastAPI**](https://sqlmodel.tiangolo.com/tutorial/fastapi/). 🚀
diff --git a/docs/ru/docs/tutorial/static-files.md b/docs/ru/docs/tutorial/static-files.md
index 3b0cab8313..dfcc77b6fd 100644
--- a/docs/ru/docs/tutorial/static-files.md
+++ b/docs/ru/docs/tutorial/static-files.md
@@ -24,7 +24,7 @@
Это отличается от использования `APIRouter`, так как примонтированное приложение является полностью независимым.
OpenAPI и документация из вашего главного приложения не будут содержать ничего из примонтированного приложения, и т.д.
-Вы можете прочитать больше об этом в [Расширенном руководстве пользователя](../advanced/index.md){.internal-link target=_blank}.
+Вы можете прочитать больше об этом в [Расширенном руководстве пользователя](../advanced/index.md).
## Детали { #details }
@@ -38,4 +38,4 @@ OpenAPI и документация из вашего главного прил
## Больше информации { #more-info }
-Для получения дополнительной информации о деталях и настройках ознакомьтесь с
Документацией Starlette о статических файлах.
+Для получения дополнительной информации о деталях и настройках ознакомьтесь с [документацией Starlette о статических файлах](https://www.starlette.dev/staticfiles/).
diff --git a/docs/ru/docs/tutorial/stream-json-lines.md b/docs/ru/docs/tutorial/stream-json-lines.md
new file mode 100644
index 0000000000..d8bb9132b7
--- /dev/null
+++ b/docs/ru/docs/tutorial/stream-json-lines.md
@@ -0,0 +1,111 @@
+# Стриминг JSON Lines { #stream-json-lines }
+
+У вас может быть последовательность данных, которую вы хотите отправлять в «**потоке**». Это можно сделать с помощью **JSON Lines**.
+
+/// info | Информация
+
+Добавлено в FastAPI 0.134.0.
+
+///
+
+## Что такое поток? { #what-is-a-stream }
+
+«**Стриминг**» данных означает, что ваше приложение начнет отправлять элементы данных клиенту, не дожидаясь готовности всей последовательности.
+
+То есть оно отправит первый элемент, клиент его получит и начнет обрабатывать, а вы в это время можете все еще генерировать следующий элемент.
+
+```mermaid
+sequenceDiagram
+ participant App
+ participant Client
+
+ App->>App: Produce Item 1
+ App->>Client: Send Item 1
+ App->>App: Produce Item 2
+ Client->>Client: Process Item 1
+ App->>Client: Send Item 2
+ App->>App: Produce Item 3
+ Client->>Client: Process Item 2
+ App->>Client: Send Item 3
+ Client->>Client: Process Item 3
+ Note over App: Keeps producing...
+ Note over Client: Keeps consuming...
+```
+
+Это может быть даже бесконечный поток, когда вы продолжаете отправлять данные.
+
+## JSON Lines { #json-lines }
+
+В таких случаях часто отправляют «**JSON Lines**», это формат, в котором отправляется по одному JSON-объекту на строку.
+
+Ответ будет иметь тип содержимого `application/jsonl` (вместо `application/json`), а тело ответа будет примерно таким:
+
+```json
+{"name": "Plumbus", "description": "A multi-purpose household device."}
+{"name": "Portal Gun", "description": "A portal opening device."}
+{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
+```
+
+Это очень похоже на JSON-массив (эквивалент списка Python), но вместо того чтобы быть обернутым в `[]` и иметь `,` между элементами, здесь **один JSON-объект на строку**, они разделены символом новой строки.
+
+/// info | Информация
+
+Важный момент в том, что ваше приложение сможет по очереди производить каждую строку, пока клиент потребляет предыдущие строки.
+
+///
+
+/// note | Технические детали
+
+Так как каждый JSON-объект будет разделен новой строкой, в их содержимом не могут быть буквальные символы новой строки, но могут быть экранированные переводы строк (`\n`), что входит в стандарт JSON.
+
+Однако обычно об этом не нужно беспокоиться — всё делается автоматически, читайте дальше. 🤓
+
+///
+
+## Варианты использования { #use-cases }
+
+Вы можете использовать это для стриминга данных из сервиса **AI LLM**, из **логов** или **телеметрии**, или из других типов данных, которые можно структурировать в элементы **JSON**.
+
+/// tip | Совет
+
+Если вы хотите стримить бинарные данные, например видео или аудио, посмотрите расширенное руководство: [Потоковая передача данных](../advanced/stream-data.md).
+
+///
+
+## Стриминг JSON Lines с FastAPI { #stream-json-lines-with-fastapi }
+
+Чтобы стримить JSON Lines с FastAPI, вместо использования `return` в вашей *функции-обработчике пути* используйте `yield`, чтобы по очереди выдавать каждый элемент.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[24] *}
+
+Если каждый JSON-элемент, который вы хотите отправить обратно, имеет тип `Item` (Pydantic-модель), и это асинхронная функция, вы можете объявить тип возвращаемого значения как `AsyncIterable[Item]`:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[9:11,22] *}
+
+Если вы объявите тип возвращаемого значения, FastAPI будет использовать его, чтобы **валидировать** данные, **документировать** их в OpenAPI, **фильтровать** и **сериализовать** с помощью Pydantic.
+
+/// tip | Совет
+
+Так как Pydantic будет сериализовывать это на стороне **Rust**, вы получите значительно более высокую **производительность**, чем если бы вы не указывали тип возвращаемого значения.
+
+///
+
+### Неасинхронные функции-обработчики пути { #non-async-path-operation-functions }
+
+Вы также можете использовать обычные функции `def` (без `async`) и использовать `yield` таким же образом.
+
+FastAPI обеспечит корректное выполнение так, чтобы это не блокировало цикл событий.
+
+Поскольку в этом случае функция не асинхронная, подходящим типом возвращаемого значения будет `Iterable[Item]`:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[27:30] hl[28] *}
+
+### Без возвращаемого типа { #no-return-type }
+
+Вы также можете опустить тип возвращаемого значения. Тогда FastAPI использует [`jsonable_encoder`](./encoder.md), чтобы преобразовать данные к виду, который можно сериализовать в JSON, и затем отправит их как JSON Lines.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[33:36] hl[34] *}
+
+## События, отправляемые сервером (SSE) { #server-sent-events-sse }
+
+FastAPI также имеет полноценную поддержку Server-Sent Events (SSE), которые довольно похожи, но с парой дополнительных деталей. Вы можете узнать о них в следующей главе: [События, отправляемые сервером (SSE)](server-sent-events.md). 🤓
diff --git a/docs/ru/docs/tutorial/testing.md b/docs/ru/docs/tutorial/testing.md
index 6dd2fe579a..aef7b86ded 100644
--- a/docs/ru/docs/tutorial/testing.md
+++ b/docs/ru/docs/tutorial/testing.md
@@ -1,18 +1,18 @@
# Тестирование { #testing }
-Благодаря
Starlette, тестировать приложения **FastAPI** легко и приятно.
+Благодаря [Starlette](https://www.starlette.dev/testclient/), тестировать приложения **FastAPI** легко и приятно.
-Тестирование основано на библиотеке
HTTPX, которая в свою очередь основана на библиотеке Requests, так что все действия знакомы и интуитивно понятны.
+Тестирование основано на библиотеке [HTTPX](https://www.python-httpx.org), которая в свою очередь основана на библиотеке Requests, так что все действия знакомы и интуитивно понятны.
-Используя эти инструменты, Вы можете напрямую задействовать
pytest с **FastAPI**.
+Используя эти инструменты, Вы можете напрямую задействовать [pytest](https://docs.pytest.org/) с **FastAPI**.
## Использование класса `TestClient` { #using-testclient }
/// info | Информация
-Для использования класса `TestClient` сначала установите
`httpx`.
+Для использования класса `TestClient` сначала установите [`httpx`](https://www.python-httpx.org).
-Убедитесь, что Вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его, а затем установили пакет, например:
+Убедитесь, что Вы создали [виртуальное окружение](../virtual-environments.md), активировали его, а затем установили пакет, например:
```console
$ pip install httpx
@@ -52,7 +52,7 @@ $ pip install httpx
/// tip | Подсказка
-Если для тестирования Вам, помимо запросов к приложению FastAPI, необходимо вызывать асинхронные функции (например, для подключения к базе данных с помощью асинхронного драйвера), то ознакомьтесь со страницей [Асинхронное тестирование](../advanced/async-tests.md){.internal-link target=_blank} в расширенном руководстве.
+Если для тестирования Вам, помимо запросов к приложению FastAPI, необходимо вызывать асинхронные функции (например, для подключения к базе данных с помощью асинхронного драйвера), то ознакомьтесь со страницей [Асинхронное тестирование](../advanced/async-tests.md) в расширенном руководстве.
///
@@ -64,7 +64,7 @@ $ pip install httpx
### Файл приложения **FastAPI** { #fastapi-app-file }
-Допустим, структура файлов Вашего приложения похожа на ту, что описана на странице [Более крупные приложения](bigger-applications.md){.internal-link target=_blank}:
+Допустим, структура файлов Вашего приложения похожа на ту, что описана на странице [Более крупные приложения](bigger-applications.md):
```
.
@@ -80,7 +80,7 @@ $ pip install httpx
### Файл тестов { #testing-file }
-Также у Вас может быть файл `test_main.py` содержащий тесты. Можно разместить тестовый файл и файл приложения в одной директории (в директориях для Python-кода желательно размещать и файл `__init__.py`):
+Также у Вас может быть файл `test_main.py` содержащий тесты. Он может находиться в том же Python-пакете (в той же директории с файлом `__init__.py`):
``` hl_lines="5"
.
@@ -142,13 +142,13 @@ $ pip install httpx
* Для передачи *HTTP-заголовков*, передайте объект `dict` через параметр `headers`.
* Для передачи *cookies* также передайте `dict`, но через параметр `cookies`.
-Для получения дополнительной информации о передаче данных на бэкенд с помощью `httpx` или `TestClient` ознакомьтесь с
документацией HTTPX.
+Для получения дополнительной информации о передаче данных на бэкенд с помощью `httpx` или `TestClient` ознакомьтесь с [документацией HTTPX](https://www.python-httpx.org).
/// info | Информация
Обратите внимание, что `TestClient` принимает данные, которые можно конвертировать в JSON, но не модели Pydantic.
-Если в Ваших тестах есть модели Pydantic и Вы хотите отправить их в тестируемое приложение, то можете использовать функцию `jsonable_encoder`, описанную на странице [Кодировщик совместимый с JSON](encoder.md){.internal-link target=_blank}.
+Если в Ваших тестах есть модели Pydantic и Вы хотите отправить их в тестируемое приложение, то можете использовать функцию `jsonable_encoder`, описанную на странице [Кодировщик совместимый с JSON](encoder.md).
///
@@ -156,7 +156,7 @@ $ pip install httpx
Далее Вам нужно установить `pytest`.
-Убедитесь, что Вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его, а затем установили пакет, например:
+Убедитесь, что Вы создали [виртуальное окружение](../virtual-environments.md), активировали его, а затем установили пакет, например:
diff --git a/docs/ru/docs/virtual-environments.md b/docs/ru/docs/virtual-environments.md
index f931cc3c82..633137d09e 100644
--- a/docs/ru/docs/virtual-environments.md
+++ b/docs/ru/docs/virtual-environments.md
@@ -22,7 +22,7 @@
На этой странице вы узнаете, как пользоваться **виртуальными окружениями** и как они работают.
-Если вы готовы начать использовать **инструмент, который управляет всем** за вас (включая установку Python), попробуйте
uv.
+Если вы готовы начать использовать **инструмент, который управляет всем** за вас (включая установку Python), попробуйте [uv](https://github.com/astral-sh/uv).
///
@@ -86,7 +86,7 @@ $ python -m venv .venv
//// tab | `uv`
-Если у вас установлен
`uv`, вы можете использовать его для создания виртуального окружения.
+Если у вас установлен [`uv`](https://github.com/astral-sh/uv), вы можете использовать его для создания виртуального окружения.
@@ -150,7 +150,7 @@ $ .venv\Scripts\Activate.ps1
//// tab | Windows Bash
-Или если вы используете Bash для Windows (например,
Git Bash):
+Или если вы используете Bash для Windows (например, [Git Bash](https://gitforwindows.org/)):
@@ -216,7 +216,7 @@ C:\Users\user\code\awesome-project\.venv\Scripts\python
/// tip | Подсказка
-Если вы используете
`uv`, то для установки вы будете использовать его вместо `pip`, поэтому обновлять `pip` не нужно. 😎
+Если вы используете [`uv`](https://github.com/astral-sh/uv), то для установки вы будете использовать его вместо `pip`, поэтому обновлять `pip` не нужно. 😎
///
@@ -268,7 +268,7 @@ $ python -m ensurepip --upgrade
/// tip | Подсказка
-Если вы использовали
`uv` для создания виртуального окружения, он уже сделал это за вас — можно пропустить этот шаг. 😎
+Если вы использовали [`uv`](https://github.com/astral-sh/uv) для создания виртуального окружения, он уже сделал это за вас — можно пропустить этот шаг. 😎
///
@@ -340,7 +340,7 @@ $ pip install "fastapi[standard]"
//// tab | `uv`
-Если у вас установлен
`uv`:
+Если у вас установлен [`uv`](https://github.com/astral-sh/uv):
@@ -372,7 +372,7 @@ $ pip install -r requirements.txt
//// tab | `uv`
-Если у вас установлен
`uv`:
+Если у вас установлен [`uv`](https://github.com/astral-sh/uv):
@@ -416,8 +416,8 @@ Hello World
Например:
-*
VS Code
-*
PyCharm
+* [VS Code](https://code.visualstudio.com/docs/python/environments#_select-and-activate-an-environment)
+* [PyCharm](https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html)
/// tip | Подсказка
@@ -455,7 +455,7 @@ $ deactivate
## Зачем нужны виртуальные окружения { #why-virtual-environments }
-Чтобы работать с FastAPI, вам нужно установить
Python.
+Чтобы работать с FastAPI, вам нужно установить [Python](https://www.python.org/).
После этого вам нужно будет **установить** FastAPI и другие **пакеты**, которые вы хотите использовать.
@@ -564,7 +564,7 @@ $ pip install "fastapi[standard]"
-Будет загружен сжатый файл с кодом FastAPI, обычно с
PyPI.
+Будет загружен сжатый файл с кодом FastAPI, обычно с [PyPI](https://pypi.org/project/fastapi/).
Также будут **загружены** файлы для других пакетов, от которых зависит FastAPI.
@@ -627,7 +627,7 @@ $ .venv\Scripts\Activate.ps1
//// tab | Windows Bash
-Или если вы используете Bash для Windows (например,
Git Bash):
+Или если вы используете Bash для Windows (например, [Git Bash](https://gitforwindows.org/)):
@@ -639,13 +639,13 @@ $ source .venv/Scripts/activate
////
-Эта команда создаст или изменит некоторые [переменные окружения](environment-variables.md){.internal-link target=_blank}, которые будут доступны для следующих команд.
+Эта команда создаст или изменит некоторые [переменные окружения](environment-variables.md), которые будут доступны для следующих команд.
Одна из таких переменных — `PATH`.
/// tip | Подсказка
-Вы можете узнать больше о переменной окружения `PATH` в разделе [Переменные окружения](environment-variables.md#path-environment-variable){.internal-link target=_blank}.
+Вы можете узнать больше о переменной окружения `PATH` в разделе [Переменные окружения](environment-variables.md#path-environment-variable).
///
@@ -846,7 +846,7 @@ I solemnly swear 🐺
Существует много **альтернатив** для управления виртуальными окружениями, зависимостями (requirements), проектами.
-Когда вы будете готовы и захотите использовать инструмент для **управления всем проектом** — зависимостями пакетов, виртуальными окружениями и т. п., я бы предложил попробовать
uv.
+Когда вы будете готовы и захотите использовать инструмент для **управления всем проектом** — зависимостями пакетов, виртуальными окружениями и т.п., я бы предложил попробовать [uv](https://github.com/astral-sh/uv).
`uv` может многое:
diff --git a/docs/tr/docs/advanced/json-base64-bytes.md b/docs/tr/docs/advanced/json-base64-bytes.md
new file mode 100644
index 0000000000..68e1cba7aa
--- /dev/null
+++ b/docs/tr/docs/advanced/json-base64-bytes.md
@@ -0,0 +1,63 @@
+# JSON'da Bytes'i Base64 Olarak Kullanma { #json-with-bytes-as-base64 }
+
+Uygulamanız JSON veri alıp gönderiyorsa ve bunun içine ikili (binary) veri eklemeniz gerekiyorsa, veriyi base64 olarak encode edebilirsiniz.
+
+## Base64 ve Dosyalar { #base64-vs-files }
+
+İkili veriyi JSON içinde encode etmek yerine, yükleme için [Request Files](../tutorial/request-files.md) ve gönderim için [Custom Response - FileResponse](./custom-response.md#fileresponse--fileresponse-) kullanıp kullanamayacağınıza önce bir bakın.
+
+JSON sadece UTF-8 ile encode edilmiş string'ler içerebilir, dolayısıyla ham bytes içeremez.
+
+Base64 ikili veriyi string olarak encode edebilir, ancak bunu yapmak için orijinal ikili veriden daha fazla karakter kullanır; bu yüzden genellikle normal dosyalardan daha verimsiz olur.
+
+Base64'ü sadece gerçekten JSON içine ikili veri koymanız gerekiyorsa ve bunun için dosya kullanamıyorsanız tercih edin.
+
+## Pydantic `bytes` { #pydantic-bytes }
+
+`bytes` alanları olan bir Pydantic model tanımlayabilir, ardından model config'inde `val_json_bytes` kullanarak giriş JSON verisini base64 ile doğrulamasını (validate) söyleyebilirsiniz; bu doğrulamanın bir parçası olarak base64 string'i bytes'a decode eder.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
+
+`/docs`'a bakarsanız, `data` alanının base64 ile encode edilmiş bytes beklediğini görürsünüz:
+
+
+
+
+
+Şöyle bir request gönderebilirsiniz:
+
+```json
+{
+ "description": "Some data",
+ "data": "aGVsbG8="
+}
+```
+
+/// tip | İpucu
+
+`aGVsbG8=` değeri, `hello` kelimesinin base64 encoding'idir.
+
+///
+
+Sonrasında Pydantic base64 string'ini decode eder ve modelin `data` alanında size orijinal bytes'ı verir.
+
+Şöyle bir response alırsınız:
+
+```json
+{
+ "description": "Some data",
+ "content": "hello"
+}
+```
+
+## Çıkış Verisi için Pydantic `bytes` { #pydantic-bytes-for-output-data }
+
+Çıkış verisi için de model config'inde `ser_json_bytes` ile `bytes` alanları kullanabilirsiniz; Pydantic JSON response üretirken bytes'ı base64 olarak serialize eder.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,12:16,29,38:41] hl[16] *}
+
+## Giriş ve Çıkış Verisi için Pydantic `bytes` { #pydantic-bytes-for-input-and-output-data }
+
+Elbette, aynı modeli base64 kullanacak şekilde yapılandırıp hem girişte (*validate*) `val_json_bytes` ile hem de çıkışta (*serialize*) `ser_json_bytes` ile JSON veri alıp gönderirken kullanabilirsiniz.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,19:26,29,44:46] hl[23:26] *}
diff --git a/docs/tr/docs/advanced/stream-data.md b/docs/tr/docs/advanced/stream-data.md
new file mode 100644
index 0000000000..4310edc350
--- /dev/null
+++ b/docs/tr/docs/advanced/stream-data.md
@@ -0,0 +1,117 @@
+# Veri Akışı { #stream-data }
+
+Veriyi JSON olarak yapılandırabiliyorsanız, [JSON Lines Akışı](../tutorial/stream-json-lines.md) kullanın.
+
+Ancak saf ikili (binary) veri ya da string akıtmak istiyorsanız, bunu şöyle yapabilirsiniz.
+
+/// info | Bilgi
+
+FastAPI 0.134.0 ile eklendi.
+
+///
+
+## Kullanım Senaryoları { #use-cases }
+
+Doğrudan bir AI LLM (Büyük Dil Modeli) servisinin çıktısından saf string'leri akıtmak istediğinizde kullanabilirsiniz.
+
+Ayrıca **büyük ikili (binary) dosyaları** akıtmak için de kullanabilirsiniz; veriyi okurken her parçayı (chunk) sırayla gönderirsiniz, tamamını belleğe almak zorunda kalmazsınız.
+
+Bu şekilde **video** veya **ses** de akıtabilirsiniz; hatta işledikçe üretilip gönderilebilir.
+
+## `yield` ile bir `StreamingResponse` { #a-streamingresponse-with-yield }
+
+*Path operation function* içinde `response_class=StreamingResponse` belirtirseniz, her veri parçasını sırayla göndermek için `yield` kullanabilirsiniz.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[1:23] hl[20,23] *}
+
+FastAPI her veri parçasını olduğu gibi `StreamingResponse`'a verir; JSON'a ya da benzeri bir formata dönüştürmeye çalışmaz.
+
+### Async Olmayan Path Operation Function'lar { #non-async-path-operation-functions }
+
+Normal `def` fonksiyonlarını (yani `async` olmadan) da kullanabilir ve aynı şekilde `yield` yazabilirsiniz.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[26:29] hl[27] *}
+
+### Tip Annotasyonu Yok { #no-annotation }
+
+İkili (binary) veri akıtıyorsanız dönüş tipi annotasyonu belirtmeniz şart değildir.
+
+FastAPI veriyi Pydantic ile JSON'a çevirmeye veya herhangi bir şekilde serileştirmeye çalışmayacağı için, bu durumda tip annotasyonu sadece editörünüz ve araçlarınız içindir; FastAPI tarafından kullanılmaz.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[32:35] hl[33] *}
+
+Bu aynı zamanda `StreamingResponse` ile veriyi tam olarak ihtiyaç duyduğunuz biçimde üretme ve encode etme konusunda hem bir özgürlük hem de bir sorumluluk verdiği anlamına gelir; tip annotasyonlarından bağımsızdır. 🤓
+
+### Bytes Akışı { #stream-bytes }
+
+Başlıca kullanım senaryolarından biri string yerine `bytes` akıtmaktır; elbette bunu yapabilirsiniz.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[44:47] hl[47] *}
+
+## Özel bir `PNGStreamingResponse` { #a-custom-pngstreamingresponse }
+
+Yukarıdaki örneklerde veri baytları akıtıldı, ancak response'ta bir `Content-Type` header'ı yoktu; bu nedenle istemci hangi tür veriyi aldığını bilmiyordu.
+
+Akıttığınız veri türüne uygun `Content-Type` header'ını ayarlayan, `StreamingResponse`'tan türetilmiş özel bir alt sınıf (subclass) oluşturabilirsiniz.
+
+Örneğin, `media_type` özniteliğini kullanarak `Content-Type` header'ını `image/png` olarak ayarlayan bir `PNGStreamingResponse` oluşturabilirsiniz:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[6,19:20] hl[20] *}
+
+Ardından bu yeni sınıfı *path operation function* içinde `response_class=PNGStreamingResponse` olarak kullanabilirsiniz:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[23:27] hl[23] *}
+
+### Bir Dosyayı Simüle Etme { #simulate-a-file }
+
+Bu örnekte, yalnızca bellekte yaşayan ama aynı arayüzü kullanmamıza izin veren, dosya benzeri bir nesne olan `io.BytesIO` ile bir dosyayı simüle ediyoruz.
+
+Örneğin, bir dosyada yapabileceğimiz gibi, içeriğini tüketmek için üzerinde iterate edebiliriz.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[1:27] hl[3,12:13,25] *}
+
+/// note | Teknik Detaylar
+
+Diğer iki değişken olan `image_base64` ve `binary_image`, Base64 ile encode edilmiş bir görüntüdür; daha sonra bayt'lara çevrilip `io.BytesIO`'ya aktarılır.
+
+Sadece bu örnek aynı dosyada yaşayabilsin, kopyalayıp olduğu gibi çalıştırabilesiniz diye. 🥚
+
+///
+
+`with` bloğu kullanarak, jeneratör fonksiyonu (içinde `yield` olan fonksiyon) tamamlandığında dosya benzeri nesnenin kapandığından emin oluruz. Yani response gönderimi bittikten sonra.
+
+Bu özel örnekte o kadar da önemli değil, çünkü sahte ve bellekte (yani `io.BytesIO` ile). Ancak gerçek bir dosyada, onunla işiniz bittiğinde dosyanın kapandığından emin olmak önemlidir.
+
+### Dosyalar ve Async { #files-and-async }
+
+Çoğu durumda dosya benzeri nesneler, varsayılan olarak async ve await ile uyumlu değildir.
+
+Örneğin, `await file.read()` ya da `async for chunk in file` gibi şeyler yoktur.
+
+Ve birçok durumda, diskte ya da ağda okundukları için, okumak engelleyici (event loop'u bloke edebilen) bir işlem olabilir.
+
+/// info | Bilgi
+
+Yukarıdaki örnek aslında bir istisna; çünkü `io.BytesIO` nesnesi zaten bellekte, dolayısıyla onu okumak hiçbir şeyi bloke etmez.
+
+Ancak çoğu durumda bir dosyayı veya dosya benzeri bir nesneyi okumak bloke edicidir.
+
+///
+
+Event loop'u bloke etmemek için, *path operation function*'ı `async def` yerine normal `def` ile tanımlayabilirsiniz; böylece FastAPI ana döngüyü bloke etmemek için bunu bir thread pool worker (iş parçacığı havuzu çalışanı) üzerinde çalıştırır.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}
+
+/// tip | İpucu
+
+Async bir fonksiyonun içinden bloklayıcı kod çağırmanız ya da bloklayıcı bir fonksiyonun içinden async bir fonksiyon çağırmanız gerekirse, FastAPI'nin kardeş kütüphanesi olan [Asyncer](https://asyncer.tiangolo.com)'ı kullanabilirsiniz.
+
+///
+
+### `yield from` { #yield-from }
+
+Bir şeyin (ör. dosya benzeri bir nesne) üzerinde iterate ederken, her öğe için `yield` yapıyorsanız, `for` döngüsünü yazmak yerine `yield from` ile her öğeyi doğrudan yield edebilirsiniz.
+
+Bu FastAPI'ye özgü değildir, tamamen Python'dur, ama bilinmesi güzel bir püf noktasıdır. 😎
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[37:40] hl[40] *}
diff --git a/docs/tr/docs/advanced/strict-content-type.md b/docs/tr/docs/advanced/strict-content-type.md
new file mode 100644
index 0000000000..94716e31fa
--- /dev/null
+++ b/docs/tr/docs/advanced/strict-content-type.md
@@ -0,0 +1,88 @@
+# Sıkı Content-Type Kontrolü { #strict-content-type-checking }
+
+Varsayılan olarak FastAPI, JSON request body'leri için sıkı Content-Type header kontrolü uygular. Bu, JSON request'lerin body'lerinin JSON olarak parse edilebilmesi için geçerli bir Content-Type header'ı (örn. application/json) içermesi gerektiği anlamına gelir.
+
+## CSRF Riski { #csrf-risk }
+
+Bu varsayılan davranış, çok belirli bir senaryoda bir sınıf Cross-Site Request Forgery (CSRF) saldırılarına karşı koruma sağlar.
+
+Bu saldırılar, tarayıcıların aşağıdaki durumlarda herhangi bir CORS preflight kontrolü yapmadan script’lerin request göndermesine izin vermesinden faydalanır:
+
+- bir Content-Type header’ı yoksa (örn. body olarak Blob ile fetch() kullanıldığında)
+- ve herhangi bir kimlik doğrulama bilgisi gönderilmiyorsa.
+
+Bu tür saldırılar özellikle şu durumlarda önemlidir:
+
+- uygulama yerelde (örn. localhost’ta) veya dahili bir ağda çalışıyorsa
+- ve uygulamada hiç kimlik doğrulama yoksa, aynı ağdan gelen her request’in güvenilir olduğu varsayılıyorsa.
+
+## Örnek Saldırı { #example-attack }
+
+Yerelde çalışan bir AI agent’ı (yapay zeka ajanı) çalıştırmanın bir yolunu geliştirdiğinizi düşünün.
+
+Bir API sunuyor:
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Ayrıca bir frontend var:
+
+```
+http://localhost:8000
+```
+
+/// tip | İpucu
+
+İkisinin de host’u aynıdır.
+
+///
+
+Frontend’i kullanarak AI agent’a sizin adınıza işler yaptırabiliyorsunuz.
+
+Uygulama yerelde çalıştığı ve açık internette olmadığı için, sadece yerel ağa güvenip herhangi bir kimlik doğrulama kurmamaya karar verdiniz.
+
+Kullanıcılarınızdan biri de bunu indirip yerelde çalıştırabilir.
+
+Sonra kötü niyetli bir web sitesini açabilir, örneğin:
+
+```
+https://evilhackers.example.com
+```
+
+Ve bu kötü niyetli site, body olarak Blob kullanan fetch() ile yerel API’ye request’ler gönderebilir:
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Kötü niyetli sitenin host’u ile yerel uygulamanın host’u farklı olsa bile, tarayıcı şu nedenlerle bir CORS preflight isteği tetiklemez:
+
+- Herhangi bir kimlik doğrulama yoktur, bu nedenle credential göndermesi gerekmez.
+- Tarayıcı, Content-Type header’ı eksik olduğundan JSON gönderildiğini düşünmez.
+
+Böylece kötü niyetli site, yerel AI agent’ın kullanıcının eski patronuna sinirli mesajlar göndermesini sağlayabilir... ya da daha kötüsü. 😅
+
+## Açık İnternet { #open-internet }
+
+Uygulamanız açık internetteyse “ağa güvenmez” ve kimlik doğrulama olmadan kimsenin ayrıcalıklı request’ler göndermesine izin vermezsiniz.
+
+Saldırganlar tarayıcı etkileşimine ihtiyaç duymadan basitçe bir script çalıştırıp API’nize request gönderebilir, bu yüzden muhtemelen ayrıcalıklı endpoint’leri zaten güvenceye almışsınızdır.
+
+Bu durumda bu saldırı/riski sizler için geçerli değildir.
+
+Bu risk ve saldırı, esasen uygulama sadece yerel ağda çalıştığında ve tek koruma varsayımının bu olduğu durumlarda önemlidir.
+
+## Content-Type Olmadan Gelen Request’lere İzin Vermek { #allowing-requests-without-content-type }
+
+Content-Type header’ı göndermeyen client’ları desteklemeniz gerekiyorsa, strict kontrolü strict_content_type=False ayarıyla kapatabilirsiniz:
+
+{* ../../docs_src/strict_content_type/tutorial001_py310.py hl[4] *}
+
+Bu ayarla, Content-Type header’ı olmayan request’lerin body’si JSON olarak parse edilir. Bu, FastAPI’nin eski sürümlerindeki davranışla aynıdır.
+
+/// info | Bilgi
+
+Bu davranış ve yapılandırma FastAPI 0.132.0’da eklendi.
+
+///
diff --git a/docs/tr/docs/editor-support.md b/docs/tr/docs/editor-support.md
new file mode 100644
index 0000000000..47182834ed
--- /dev/null
+++ b/docs/tr/docs/editor-support.md
@@ -0,0 +1,23 @@
+# Editör Desteği { #editor-support }
+
+Resmi [FastAPI Extension](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode), FastAPI geliştirme akışınızı iyileştirir: *path operation* keşfi, gezinme, FastAPI Cloud’a deploy ve canlı log akışı.
+
+Daha fazla ayrıntı için, GitHub deposundaki README’ye bakın: [GitHub repository](https://github.com/fastapi/fastapi-vscode).
+
+## Kurulum ve Yükleme { #setup-and-installation }
+
+**FastAPI Extension**, hem [VS Code](https://code.visualstudio.com/) hem de [Cursor](https://www.cursor.com/) için mevcuttur. Her editörde Extensions panelinden "FastAPI" aratıp **FastAPI Labs** tarafından yayımlanan eklentiyi seçerek doğrudan kurabilirsiniz. Eklenti [vscode.dev](https://vscode.dev) ve [github.dev](https://github.dev) gibi tarayıcı tabanlı editörlerde de çalışır.
+
+### Uygulama Keşfi { #application-discovery }
+
+Varsayılan olarak, eklenti çalışma alanınızda `FastAPI()` örnekleyen dosyaları tarayarak FastAPI uygulamalarını otomatik olarak keşfeder. Proje yapınız nedeniyle otomatik algılama çalışmazsa, `pyproject.toml` içindeki `[tool.fastapi]` ile veya VS Code ayarı `fastapi.entryPoint` üzerinden modül gösterimiyle (ör. `myapp.main:app`) bir entrypoint belirtebilirsiniz.
+
+## Özellikler { #features }
+
+- **Path Operation Explorer** - Uygulamanızdaki tüm
*path operation*'lar için yan panelde bir ağaç görünümü. Herhangi bir route veya router tanımına tıklayarak atlayın.
+- **Route Search** -
Ctrl +
Shift +
E (macOS:
Cmd +
Shift +
E) ile path, method veya ada göre arama.
+- **CodeLens Navigation** - Test client çağrılarının (ör. `client.get('/items')`) üzerinde, ilgili *path operation*’a atlayan tıklanabilir bağlantılar; testlerle implementasyon arasında hızlı gezinme sağlar.
+- **Deploy to FastAPI Cloud** - Uygulamanızı tek tıkla [FastAPI Cloud](https://fastapicloud.com/)'a deploy edin.
+- **Stream Application Logs** - FastAPI Cloud’a deploy ettiğiniz uygulamadan, seviye filtreleme ve metin arama ile gerçek zamanlı log akışı.
+
+Eklentinin özelliklerine hızlıca aşina olmak isterseniz, Komut Paleti’ni açın (
Ctrl +
Shift +
P veya macOS:
Cmd +
Shift +
P), "Welcome: Open walkthrough..." öğesini seçin ve ardından "Get started with FastAPI" walkthrough’unu açın.
diff --git a/docs/tr/docs/tutorial/server-sent-events.md b/docs/tr/docs/tutorial/server-sent-events.md
new file mode 100644
index 0000000000..3855410125
--- /dev/null
+++ b/docs/tr/docs/tutorial/server-sent-events.md
@@ -0,0 +1,120 @@
+# Server-Sent Events (SSE) { #server-sent-events-sse }
+
+İstemciye veri akışını **Server-Sent Events** (SSE) ile sağlayabilirsiniz.
+
+Bu, [JSON Lines Akışı](stream-json-lines.md) ile benzerdir ancak tarayıcılar tarafından yerel olarak desteklenen [`EventSource` API'si](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) ile `text/event-stream` formatını kullanır.
+
+/// info | Bilgi
+
+FastAPI 0.135.0'da eklendi.
+
+///
+
+## Server-Sent Events Nedir? { #what-are-server-sent-events }
+
+SSE, HTTP üzerinden sunucudan istemciye veri akışı için bir standarttır.
+
+Her olay, aralarında boş satırlar bulunan ve `data`, `event`, `id` ve `retry` gibi "alanlar" içeren küçük bir metin bloğudur.
+
+Şuna benzer:
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+SSE; yapay zekâ sohbet akışı, canlı bildirimler, log ve gözlemlenebilirlik (observability) gibi senaryolarda ve sunucunun istemciye güncellemeleri ittiği diğer durumlarda yaygın olarak kullanılır.
+
+/// tip | İpucu
+
+İkili (binary) veri akışı yapmak istiyorsanız, gelişmiş kılavuza bakın: [Veri Akışı](../advanced/stream-data.md).
+
+///
+
+## FastAPI ile SSE Akışı { #stream-sse-with-fastapi }
+
+FastAPI ile SSE akışı yapmak için, *path operation function* içinde `yield` kullanın ve `response_class=EventSourceResponse` olarak ayarlayın.
+
+`EventSourceResponse`'u `fastapi.sse` içinden içe aktarın:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+Yield edilen her öğe JSON olarak kodlanır ve bir SSE olayının `data:` alanında gönderilir.
+
+Dönüş tipini `AsyncIterable[Item]` olarak bildirirseniz, FastAPI bunu Pydantic ile veriyi **doğrulamak**, **belgelemek** ve **serileştirmek** için kullanır.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[10:12,23] *}
+
+/// tip | İpucu
+
+Pydantic serileştirmeyi **Rust** tarafında yapacağından, dönüş tipi bildirmediğiniz duruma göre çok daha yüksek **performans** elde edersiniz.
+
+///
+
+### Async Olmayan Path Operation Fonksiyonları { #non-async-path-operation-functions }
+
+Normal `def` fonksiyonlarını (yani `async` olmadan) da kullanabilir ve aynı şekilde `yield` kullanabilirsiniz.
+
+FastAPI, event loop'u bloke etmeyecek şekilde doğru biçimde çalışmasını sağlar.
+
+Bu örnekte fonksiyon async olmadığı için doğru dönüş tipi `Iterable[Item]` olur:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[28:31] hl[29] *}
+
+### Dönüş Tipi Olmadan { #no-return-type }
+
+Dönüş tipini belirtmeyebilirsiniz. FastAPI, veriyi dönüştürmek ve göndermek için [`jsonable_encoder`](./encoder.md) kullanır.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+`event`, `id`, `retry` veya `comment` gibi SSE alanlarını ayarlamanız gerekirse, düz veri yerine `ServerSentEvent` nesneleri yield edebilirsiniz.
+
+`ServerSentEvent`'i `fastapi.sse` içinden içe aktarın:
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+`data` alanı her zaman JSON olarak kodlanır. Pydantic modelleri dâhil, JSON olarak serileştirilebilen herhangi bir değeri geçebilirsiniz.
+
+## Ham Veri { #raw-data }
+
+Veriyi JSON kodlaması olmadan göndermeniz gerekiyorsa, `data` yerine `raw_data` kullanın.
+
+Bu, önceden biçimlendirilmiş metin, log satırları veya `[DONE]` gibi özel
"işaretçi" değerleri göndermek için kullanışlıdır.
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | Not
+
+`data` ve `raw_data` birbirini dışlar. Her `ServerSentEvent` için bunlardan yalnızca birini ayarlayabilirsiniz.
+
+///
+
+## `Last-Event-ID` ile Devam Etme { #resuming-with-last-event-id }
+
+Bir tarayıcı bağlantı koptuktan sonra yeniden bağlandığında, son aldığı `id`'yi `Last-Event-ID` header'ında gönderir.
+
+Bunu bir header parametresi olarak okuyup, istemcinin kaldığı yerden akışı sürdürmek için kullanabilirsiniz:
+
+{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}
+
+## POST ile SSE { #sse-with-post }
+
+SSE, sadece `GET` değil, **tüm HTTP metodlarıyla** çalışır.
+
+Bu, SSE'yi `POST` üzerinden akıtan [MCP](https://modelcontextprotocol.io) gibi protokoller için kullanışlıdır:
+
+{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}
+
+## Teknik Detaylar { #technical-details }
+
+FastAPI, bazı SSE en iyi uygulamalarını kutudan çıktığı gibi uygular.
+
+- [HTML spesifikasyonu: Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes) önerisine uygun olarak, bazı proxy'lerin bağlantıyı kapatmasını önlemek için, 15 saniye boyunca hiç mesaj gelmezse **"keep alive" `ping` yorumu** gönderir.
+- Akışın **cache'lenmesini önlemek** için `Cache-Control: no-cache` header'ını ayarlar.
+- Nginx gibi bazı proxy'lerde **buffering'i önlemek** için özel `X-Accel-Buffering: no` header'ını ayarlar.
+
+Bunun için ekstra bir şey yapmanız gerekmez, doğrudan çalışır. 🤓
diff --git a/docs/tr/docs/tutorial/stream-json-lines.md b/docs/tr/docs/tutorial/stream-json-lines.md
new file mode 100644
index 0000000000..200689d71e
--- /dev/null
+++ b/docs/tr/docs/tutorial/stream-json-lines.md
@@ -0,0 +1,111 @@
+# JSON Lines Akışı { #stream-json-lines }
+
+Bir veri dizisini “akış” olarak göndermek istediğiniz durumlar olabilir; bunu **JSON Lines** ile yapabilirsiniz.
+
+/// info | Bilgi
+
+FastAPI 0.134.0 ile eklendi.
+
+///
+
+## Akış (Stream) Nedir? { #what-is-a-stream }
+
+Verileri “streaming” olarak göndermek, uygulamanızın tüm öğe dizisi hazır olmasını beklemeden, öğeleri istemciye göndermeye başlaması demektir.
+
+Yani ilk öğeyi gönderirsiniz, istemci onu alıp işlemeye başlar, bu sırada siz bir sonraki öğeyi üretmeye devam edebilirsiniz.
+
+```mermaid
+sequenceDiagram
+ participant App
+ participant Client
+
+ App->>App: Produce Item 1
+ App->>Client: Send Item 1
+ App->>App: Produce Item 2
+ Client->>Client: Process Item 1
+ App->>Client: Send Item 2
+ App->>App: Produce Item 3
+ Client->>Client: Process Item 2
+ App->>Client: Send Item 3
+ Client->>Client: Process Item 3
+ Note over App: Keeps producing...
+ Note over Client: Keeps consuming...
+```
+
+Hatta, sürekli veri gönderdiğiniz sonsuz bir akış da olabilir.
+
+## JSON Lines { #json-lines }
+
+Bu tür durumlarda, her satıra bir JSON nesnesi gönderdiğiniz bir biçim olan “**JSON Lines**” kullanmak yaygındır.
+
+Response’un `application/json` yerine `application/jsonl` içerik türü (Content-Type) olur ve body aşağıdaki gibi görünür:
+
+```json
+{"name": "Plumbus", "description": "A multi-purpose household device."}
+{"name": "Portal Gun", "description": "A portal opening device."}
+{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
+```
+
+Bir JSON dizisine (Python list eşdeğeri) çok benzer; ancak öğeler `[]` içine alınmak ve araya `,` konmak yerine, her satırda **bir JSON nesnesi** vardır; bunlar yeni satır karakteri ile ayrılır.
+
+/// info | Bilgi
+
+Önemli nokta, uygulamanız her satırı sırayla üretebilirken, istemcinin de önceki satırları tüketmeye devam edebilmesidir.
+
+///
+
+/// note | Teknik Detaylar
+
+Her JSON nesnesi yeni bir satırla ayrıldığı için, içeriklerinde gerçek yeni satır karakterleri bulunamaz; ancak JSON standardının bir parçası olan kaçışlı yeni satırlar (`\n`) bulunabilir.
+
+Genelde bununla sizin uğraşmanız gerekmez, otomatik olarak halledilir, okumaya devam edin. 🤓
+
+///
+
+## Kullanım Senaryoları { #use-cases }
+
+Bunu bir **AI LLM** servisinden, **loglar**dan veya **telemetri**den ya da **JSON** öğeleri halinde yapılandırılabilen başka tür verilerden akış yapmak için kullanabilirsiniz.
+
+/// tip | İpucu
+
+İkili (binary) veri akışı yapmak istiyorsanız, örneğin video veya ses, gelişmiş kılavuza bakın: [Veri Akışı](../advanced/stream-data.md).
+
+///
+
+## FastAPI ile JSON Lines Akışı { #stream-json-lines-with-fastapi }
+
+FastAPI ile JSON Lines akışı yapmak için, *path operation function* içinde `return` kullanmak yerine, her öğeyi sırayla üretmek için `yield` kullanabilirsiniz.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[24] *}
+
+Göndermek istediğiniz her JSON öğesi `Item` tipindeyse (bir Pydantic modeli) ve fonksiyon async ise, dönüş tipini `AsyncIterable[Item]` olarak belirtebilirsiniz:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[9:11,22] *}
+
+Dönüş tipini belirtirseniz, FastAPI bu tipi kullanarak veriyi **doğrular**, OpenAPI’de **dokümante** eder, **filtreler** ve Pydantic ile **serileştirir**.
+
+/// tip | İpucu
+
+Pydantic serileştirmeyi **Rust** tarafında yapacağı için, dönüş tipi belirtmediğiniz duruma göre çok daha yüksek **performans** elde edersiniz.
+
+///
+
+### Async Olmayan path operation function'lar { #non-async-path-operation-functions }
+
+`async` olmadan normal `def` fonksiyonları da kullanabilir ve aynı şekilde `yield` yazabilirsiniz.
+
+FastAPI, event loop’u bloklamayacak şekilde doğru çalışmasını garanti eder.
+
+Bu durumda fonksiyon async olmadığı için doğru dönüş tipi `Iterable[Item]` olur:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[27:30] hl[28] *}
+
+### Dönüş Tipi Olmadan { #no-return-type }
+
+Dönüş tipini belirtmeyebilirsiniz de. Bu durumda FastAPI, veriyi JSON’a serileştirilebilir bir yapıya dönüştürmek için [`jsonable_encoder`](./encoder.md)’ı kullanır ve ardından JSON Lines olarak gönderir.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[33:36] hl[34] *}
+
+## Server-Sent Events (SSE) { #server-sent-events-sse }
+
+FastAPI, Server-Sent Events (SSE) için de birinci sınıf destek sağlar; benzerlerdir ancak birkaç ekstra ayrıntı vardır. Bir sonraki bölümden öğrenebilirsiniz: [Server-Sent Events (SSE)](server-sent-events.md). 🤓
diff --git a/docs/uk/docs/_llm-test.md b/docs/uk/docs/_llm-test.md
index 0dbfaa3db4..2673fb3e9c 100644
--- a/docs/uk/docs/_llm-test.md
+++ b/docs/uk/docs/_llm-test.md
@@ -11,7 +11,7 @@
* Перевірте, чи все гаразд у перекладі.
* За потреби покращіть вашу мовно-специфічну підсказку, загальну підсказку або англійський документ.
* Потім вручну виправте решту проблем у перекладі, щоб він був якісним.
-* Перекладіть повторно, маючи якісний переклад на місці. Ідеальний результат - коли LLM більше не вносить змін до перекладу. Це означає, що загальна підсказка та ваша мовно-специфічна підсказка настільки добрі, наскільки це можливо (інколи він робитиме кілька, здавалося б, випадкових змін, причина в тому, що
LLM-и не є детерміністичними алгоритмами).
+* Перекладіть повторно, маючи якісний переклад на місці. Ідеальний результат - коли LLM більше не вносить змін до перекладу. Це означає, що загальна підсказка та ваша мовно-специфічна підсказка настільки добрі, наскільки це можливо (інколи він робитиме кілька, здавалося б, випадкових змін, причина в тому, що [LLM-и не є детерміністичними алгоритмами](https://doublespeak.chat/#/handbook#deterministic-output)).
Тести:
@@ -95,7 +95,7 @@ $
fastapi run
Зовнішнє посилання
-* Посилання на стиль
-* Посилання на скрипт
-* Посилання на зображення
+* [Внутрішнє посилання](index.md#installation)
+* [Зовнішнє посилання](https://sqlmodel.tiangolo.com/)
+* [Посилання на стиль](https://fastapi.tiangolo.com/css/styles.css)
+* [Посилання на скрипт](https://fastapi.tiangolo.com/js/logic.js)
+* [Посилання на зображення](https://fastapi.tiangolo.com/img/foo.jpg)
Текст посилання має бути перекладений, адреса посилання має вказувати на переклад:
-* Посилання на FastAPI
+* [Посилання на FastAPI](https://fastapi.tiangolo.com/uk/)
////
@@ -313,6 +313,7 @@ Some text
* тіло відповіді
* тіло JSON
* тіло форми
+* тіло файлу
* тіло функції
* параметр
diff --git a/docs/uk/docs/advanced/additional-responses.md b/docs/uk/docs/advanced/additional-responses.md
index 089967a51a..2d2005837f 100644
--- a/docs/uk/docs/advanced/additional-responses.md
+++ b/docs/uk/docs/advanced/additional-responses.md
@@ -243,5 +243,5 @@ new_dict = {**old_dict, "new key": "new value"}
Щоб побачити, що саме можна включати у відповіді, ознайомтеся з цими розділами специфікації OpenAPI:
-- Об'єкт відповідей OpenAPI, він включає `Response Object`.
-- Об'єкт відповіді OpenAPI, ви можете включити будь-що з цього безпосередньо в кожну відповідь у параметрі `responses`. Зокрема `description`, `headers`, `content` (усередині нього ви оголошуєте різні типи медіа та Схеми JSON) і `links`.
+- [Об'єкт відповідей OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object), він включає `Response Object`.
+- [Об'єкт відповіді OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object), ви можете включити будь-що з цього безпосередньо в кожну відповідь у параметрі `responses`. Зокрема `description`, `headers`, `content` (усередині нього ви оголошуєте різні типи медіа та Схеми JSON) і `links`.
diff --git a/docs/uk/docs/advanced/additional-status-codes.md b/docs/uk/docs/advanced/additional-status-codes.md
index afba933e20..26e2c14545 100644
--- a/docs/uk/docs/advanced/additional-status-codes.md
+++ b/docs/uk/docs/advanced/additional-status-codes.md
@@ -38,4 +38,4 @@
Якщо ви повертаєте додаткові коди статусу та відповіді безпосередньо, вони не будуть включені до схеми OpenAPI (документації API), адже FastAPI не має способу заздалегідь знати, що саме ви повернете.
-Але ви можете задокументувати це у своєму коді, використовуючи: [Додаткові відповіді](additional-responses.md){.internal-link target=_blank}.
+Але ви можете задокументувати це у своєму коді, використовуючи: [Додаткові відповіді](additional-responses.md).
diff --git a/docs/uk/docs/advanced/advanced-dependencies.md b/docs/uk/docs/advanced/advanced-dependencies.md
index 0c6f8cbb34..48a10ba4d4 100644
--- a/docs/uk/docs/advanced/advanced-dependencies.md
+++ b/docs/uk/docs/advanced/advanced-dependencies.md
@@ -132,7 +132,7 @@ checker(q="somequery")
Так сесія звільнить з'єднання з базою даних, і його зможуть використовувати інші запити.
-Якщо у вас інший сценарій, де потрібно раннє завершення залежності з `yield`, створіть, будь ласка, питання в обговореннях GitHub із вашим конкретним випадком і поясненням, чому вам корисне раннє закриття для залежностей з `yield`.
+Якщо у вас інший сценарій, де потрібно раннє завершення залежності з `yield`, створіть, будь ласка, [питання в обговореннях GitHub](https://github.com/fastapi/fastapi/discussions/new?category=questions) із вашим конкретним випадком і поясненням, чому вам корисне раннє закриття для залежностей з `yield`.
Якщо будуть переконливі приклади для раннього закриття в залежностях з `yield`, я розгляну додавання нового способу увімкнути раннє закриття.
@@ -144,7 +144,7 @@ checker(q="somequery")
### Фонові задачі та залежності з `yield`, технічні деталі { #background-tasks-and-dependencies-with-yield-technical-details }
-До **FastAPI** 0.106.0 піднімати винятки після `yield` було неможливо: завершальний код у залежностях з `yield` виконувався після надсилання відповіді, тож [обробники винятків](../tutorial/handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank} уже відпрацювали б.
+До **FastAPI** 0.106.0 піднімати винятки після `yield` було неможливо: завершальний код у залежностях з `yield` виконувався після надсилання відповіді, тож [обробники винятків](../tutorial/handling-errors.md#install-custom-exception-handlers) уже відпрацювали б.
Так було спроєктовано головно для того, щоб дозволити використовувати ті самі об'єкти, «віддані» залежностями через `yield`, усередині фонових задач, оскільки завершальний код виконувався після завершення фонових задач.
@@ -160,4 +160,4 @@ checker(q="somequery")
Якщо ви раніше покладалися на цю поведінку, тепер слід створювати ресурси для фонових задач усередині самої фонової задачі та використовувати всередині лише дані, що не залежать від ресурсів залежностей із `yield`.
-Наприклад, замість використання тієї самої сесії бази даних ви створюватимете нову сесію в самій фоновій задачі та отримуватимете об'єкти з бази даних, використовуючи цю нову сесію. І далі, замість передавання об'єкта з бази даних як параметра у функцію фонової задачі, ви передасте ідентифікатор цього об'єкта, а потім отримаєте об'єкт знову всередині функції фонової задачі.
+Наприклад, замість використання тієї самої сесії бази даних ви створюватимете нову сесію в самій фоновій задачі та отримуватимете об'єкти з бази даних, використовуючи Цю нову сесію. І далі, замість передавання об'єкта з бази даних як параметра у функцію фонової задачі, ви передасте ідентифікатор цього об'єкта, а потім отримаєте об'єкт знову всередині функції фонової задачі.
diff --git a/docs/uk/docs/advanced/async-tests.md b/docs/uk/docs/advanced/async-tests.md
index 51d0d57610..9f19bed14d 100644
--- a/docs/uk/docs/advanced/async-tests.md
+++ b/docs/uk/docs/advanced/async-tests.md
@@ -16,11 +16,11 @@
`TestClient` робить певну «магію» всередині, щоб викликати асинхронний застосунок FastAPI у ваших звичайних тестових функціях `def`, використовуючи стандартний pytest. Але ця «магія» більше не працює, коли ми використовуємо його всередині асинхронних функцій. Запускаючи тести асинхронно, ми більше не можемо використовувати `TestClient` у наших тестових функціях.
-`TestClient` побудований на основі HTTPX, і на щастя, ми можемо використовувати його безпосередньо для тестування API.
+`TestClient` побудований на основі [HTTPX](https://www.python-httpx.org), і на щастя, ми можемо використовувати його безпосередньо для тестування API.
## Приклад { #example }
-Для простого прикладу розгляньмо структуру файлів, подібну до описаної в [Більші застосунки](../tutorial/bigger-applications.md){.internal-link target=_blank} та [Тестування](../tutorial/testing.md){.internal-link target=_blank}:
+Для простого прикладу розгляньмо структуру файлів, подібну до описаної в [Більші застосунки](../tutorial/bigger-applications.md) та [Тестування](../tutorial/testing.md):
```
.
@@ -84,7 +84,7 @@ response = client.get('/')
/// warning | Попередження
-Якщо ваш застосунок залежить від подій тривалості життя, `AsyncClient` не ініціюватиме ці події. Щоб гарантувати їх ініціалізацію, використовуйте `LifespanManager` з florimondmanca/asgi-lifespan.
+Якщо ваш застосунок залежить від подій тривалості життя, `AsyncClient` не ініціюватиме ці події. Щоб гарантувати їх ініціалізацію, використовуйте `LifespanManager` з [florimondmanca/asgi-lifespan](https://github.com/florimondmanca/asgi-lifespan#usage).
///
@@ -94,6 +94,6 @@ response = client.get('/')
/// tip | Порада
-Якщо ви натрапили на `RuntimeError: Task attached to a different loop` під час інтеграції асинхронних викликів у ваші тести (наприклад, при використанні MongoDB's MotorClient), пам'ятайте створювати об'єкти, яким потрібен цикл подій, лише всередині асинхронних функцій, наприклад, у зворотному виклику `@app.on_event("startup")`.
+Якщо ви натрапили на `RuntimeError: Task attached to a different loop` під час інтеграції асинхронних викликів у ваші тести (наприклад, при використанні [MongoDB's MotorClient](https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop)), пам'ятайте створювати об'єкти, яким потрібен цикл подій, лише всередині асинхронних функцій, наприклад, у зворотному виклику `@app.on_event("startup")`.
///
diff --git a/docs/uk/docs/advanced/behind-a-proxy.md b/docs/uk/docs/advanced/behind-a-proxy.md
index 66bb4c0827..55fc248f9a 100644
--- a/docs/uk/docs/advanced/behind-a-proxy.md
+++ b/docs/uk/docs/advanced/behind-a-proxy.md
@@ -16,9 +16,9 @@
Заголовки представника:
-* X-Forwarded-For
-* X-Forwarded-Proto
-* X-Forwarded-Host
+* [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For)
+* [X-Forwarded-Proto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto)
+* [X-Forwarded-Host](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host)
///
@@ -60,7 +60,7 @@ https://mysuperapp.com/items/
/// tip | Порада
-Якщо хочете дізнатися більше про HTTPS, перегляньте посібник [Про HTTPS](../deployment/https.md){.internal-link target=_blank}.
+Якщо хочете дізнатися більше про HTTPS, перегляньте посібник [Про HTTPS](../deployment/https.md).
///
@@ -228,7 +228,7 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
Майте на увазі, що сервер (Uvicorn) не використовуватиме `root_path` ні для чого, окрім передачі його застосунку.
-Але якщо ви перейдете у вашому браузері на http://127.0.0.1:8000/app, ви побачите звичайну відповідь:
+Але якщо ви перейдете у вашому браузері на [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app), ви побачите звичайну відповідь:
```JSON
{
@@ -251,9 +251,9 @@ Uvicorn очікуватиме, що представник буде зверт
## Локальне тестування з Traefik { #testing-locally-with-traefik }
-Ви можете легко провести експеримент локально з вилученим префіксом шляху, використовуючи Traefik.
+Ви можете легко провести експеримент локально з вилученим префіксом шляху, використовуючи [Traefik](https://docs.traefik.io/).
-Завантажте Traefik, це один бінарний файл, ви можете розпакувати архів і запустити його безпосередньо з термінала.
+[Завантажте Traefik](https://github.com/containous/traefik/releases), це один бінарний файл, ви можете розпакувати архів і запустити його безпосередньо з термінала.
Потім створіть файл `traefik.toml` з таким вмістом:
@@ -330,7 +330,7 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
### Перевірте відповіді { #check-the-responses }
-Тепер, якщо ви перейдете за URL із портом Uvicorn: http://127.0.0.1:8000/app, ви побачите звичайну відповідь:
+Тепер, якщо ви перейдете за URL із портом Uvicorn: [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app), ви побачите звичайну відповідь:
```JSON
{
@@ -345,7 +345,7 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
///
-А тепер відкрийте URL із портом Traefik, включно з префіксом шляху: http://127.0.0.1:9999/api/v1/app.
+А тепер відкрийте URL із портом Traefik, включно з префіксом шляху: [http://127.0.0.1:9999/api/v1/app](http://127.0.0.1:9999/api/v1/app).
Ми отримуємо ту саму відповідь:
@@ -370,13 +370,13 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
«Офіційний» спосіб доступу до застосунку - через представника з префіксом шляху, який ми визначили. Тож, як і очікується, якщо ви спробуєте інтерфейс документації, який обслуговує безпосередньо Uvicorn без префікса шляху в URL, це не запрацює, оскільки він очікує доступу через представника.
-Ви можете перевірити це на http://127.0.0.1:8000/docs:
+Ви можете перевірити це на [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs):
Але якщо ми звернемося до інтерфейсу документації за «офіційним» URL, використовуючи представника з портом `9999`, за адресою `/api/v1/docs`, усе працює коректно! 🎉
-Ви можете перевірити це на http://127.0.0.1:9999/api/v1/docs:
+Ви можете перевірити це на [http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs):
@@ -433,7 +433,7 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
///
-В інтерфейсі документації за адресою http://127.0.0.1:9999/api/v1/docs це виглядатиме так:
+В інтерфейсі документації за адресою [http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs) це виглядатиме так:
@@ -461,6 +461,6 @@ $ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
## Монтування підзастосунку { #mounting-a-sub-application }
-Якщо вам потрібно змонтувати підзастосунок (як описано в [Підзастосунки - монтування](sub-applications.md){.internal-link target=_blank}), одночасно використовуючи представника з `root_path`, ви можете робити це звичайним чином, як і очікуєте.
+Якщо вам потрібно змонтувати підзастосунок (як описано в [Підзастосунки - монтування](sub-applications.md)), одночасно використовуючи представника з `root_path`, ви можете робити це звичайним чином, як і очікуєте.
FastAPI внутрішньо розумно використовуватиме `root_path`, тож усе просто працюватиме. ✨
diff --git a/docs/uk/docs/advanced/custom-response.md b/docs/uk/docs/advanced/custom-response.md
index ebd0ec24a1..4ed7616bf7 100644
--- a/docs/uk/docs/advanced/custom-response.md
+++ b/docs/uk/docs/advanced/custom-response.md
@@ -1,52 +1,36 @@
# Користувацька відповідь - HTML, стрім, файл, інше { #custom-response-html-stream-file-others }
-Типово **FastAPI** повертатиме відповіді, використовуючи `JSONResponse`.
+Типово **FastAPI** повертатиме JSON-відповіді.
-Ви можете переписати це, повернувши безпосередньо `Response`, як показано в [Повернути відповідь безпосередньо](response-directly.md){.internal-link target=_blank}.
+Ви можете переписати це, повернувши `Response` безпосередньо, як показано в [Повернути відповідь безпосередньо](response-directly.md).
-Але якщо ви повертаєте `Response` безпосередньо (або будь-який його підклас, як-от `JSONResponse`), дані не будуть автоматично конвертовані (навіть якщо ви оголосите `response_model`), і документація не буде автоматично згенерована (наприклад, із включенням конкретного «медіа-типу» в HTTP-заголовку `Content-Type` як частини згенерованого OpenAPI).
+Але якщо ви повертаєте `Response` безпосередньо (або будь-який його підклас, як-от `JSONResponse`), дані не будуть автоматично конвертовані (навіть якщо ви оголосите `response_model`), і документація не буде автоматично згенерована (наприклад, з включенням конкретного «медіа-типу» в HTTP-заголовку `Content-Type` як частини згенерованого OpenAPI).
Ви також можете оголосити `Response`, який слід використовувати (наприклад, будь-який підклас `Response`), у декораторі операції шляху через параметр `response_class`.
Вміст, який ви повертаєте з вашої функції операції шляху, буде поміщений усередину цього `Response`.
-І якщо цей `Response` має JSON медіа-тип (`application/json`), як у випадку з `JSONResponse` та `UJSONResponse`, дані, що повертаються, будуть автоматично перетворені (і відфільтровані) з урахуванням будь-якого Pydantic `response_model`, який ви оголосили в декораторі операції шляху.
-
/// note | Примітка
-Якщо ви використовуєте клас відповіді без медіа-типу, FastAPI очікуватиме, що у вашої відповіді не буде вмісту, тож формат відповіді не буде задокументовано в згенерованих OpenAPI-документах.
+Якщо ви використовуєте клас відповіді без медіа-типу, FastAPI очікуватиме, що у вашої відповіді не буде вмісту, тож формат відповіді не буде задокументовано в згенерованій документації OpenAPI.
///
-## Використовуйте `ORJSONResponse` { #use-orjsonresponse }
-
-Наприклад, якщо ви максимально оптимізуєте продуктивність, можете встановити та використовувати `orjson` і встановити відповідь як `ORJSONResponse`.
-
-Імпортуйте потрібний клас `Response` (підклас) і оголосіть його в декораторі операції шляху.
-
-Для великих відповідей повернення `Response` безпосередньо значно швидше, ніж повернення словника.
-
-Це тому, що за замовчуванням FastAPI перевірятиме кожен елемент усередині та переконуватиметься, що його можна серіалізувати як JSON, використовуючи той самий [Сумісний кодувальник JSON](../tutorial/encoder.md){.internal-link target=_blank}, описаний у навчальному посібнику. Саме це дозволяє повертати довільні об'єкти, наприклад моделі бази даних.
-
-Але якщо ви впевнені, що вміст, який повертається, серіалізується в JSON, ви можете передати його безпосередньо класу відповіді та уникнути додаткових витрат FastAPI на пропускання вашого вмісту через `jsonable_encoder` перед передаванням його класу відповіді.
+## JSON-відповіді { #json-responses }
-{* ../../docs_src/custom_response/tutorial001b_py310.py hl[2,7] *}
+Типово FastAPI повертає JSON-відповіді.
-/// info | Інформація
-
-Параметр `response_class` також визначатиме «медіа-тип» відповіді.
+Якщо ви оголосите [Модель відповіді](../tutorial/response-model.md), FastAPI використає її, щоб серіалізувати дані в JSON за допомогою Pydantic.
-У цьому випадку HTTP-заголовок `Content-Type` буде встановлено в `application/json`.
+Якщо ви не оголосите модель відповіді, FastAPI використає `jsonable_encoder`, пояснений у [Сумісний кодувальник JSON](../tutorial/encoder.md), і помістить результат у `JSONResponse`.
-І це буде задокументовано відповідно в OpenAPI.
+Якщо ви оголосите `response_class` з JSON медіа-типом (`application/json`), як у випадку з `JSONResponse`, дані, що повертаються, будуть автоматично перетворені (і відфільтровані) згідно з будь-якою Pydantic `response_model`, яку ви оголосили в декораторі операції шляху. Але дані не будуть серіалізовані в JSON-байти за допомогою Pydantic, натомість вони будуть перетворені з `jsonable_encoder`, а потім передані класу `JSONResponse`, який і серіалізує їх у байти, використовуючи стандартну JSON-бібліотеку в Python.
-///
+### Продуктивність JSON { #json-performance }
-/// tip | Порада
+Коротко: якщо вам потрібна максимальна продуктивність, використовуйте [Модель відповіді](../tutorial/response-model.md) і не оголошуйте `response_class` у декораторі операції шляху.
-`ORJSONResponse` доступний лише у FastAPI, не в Starlette.
-
-///
+{* ../../docs_src/response_model/tutorial001_01_py310.py ln[15:17] hl[16] *}
## HTML-відповідь { #html-response }
@@ -69,7 +53,7 @@
### Повернути `Response` { #return-a-response }
-Як показано в [Повернути відповідь безпосередньо](response-directly.md){.internal-link target=_blank}, ви також можете переписати відповідь безпосередньо у вашій операції шляху, просто повернувши її.
+Як показано в [Повернути відповідь безпосередньо](response-directly.md), ви також можете переписати відповідь безпосередньо у вашій операції шляху, просто повернувши її.
Той самий приклад вище, що повертає `HTMLResponse`, може виглядати так:
@@ -134,7 +118,7 @@
- `headers` - `dict` строк.
- `media_type` - `str`, що задає медіа-тип, напр. `"text/html"`.
-FastAPI (насправді Starlette) автоматично додасть заголовок Content-Length. Також буде додано заголовок Content-Type, на основі `media_type` з додаванням набору символів для текстових типів.
+FastAPI (насправді Starlette) автоматично додасть заголовок Content-Length. Також буде додано заголовок Content-Type на основі `media_type` з додаванням набору символів для текстових типів.
{* ../../docs_src/response_directly/tutorial002_py310.py hl[1,18] *}
@@ -154,37 +138,11 @@ FastAPI (насправді Starlette) автоматично додасть з
Це типова відповідь, яку використовує **FastAPI**, як зазначено вище.
-### `ORJSONResponse` { #orjsonresponse }
-
-Швидка альтернативна JSON-відповідь з використанням `orjson`, як описано вище.
-
-/// info | Інформація
-
-Потрібно встановити `orjson`, наприклад `pip install orjson`.
-
-///
-
-### `UJSONResponse` { #ujsonresponse }
-
-Альтернативна JSON-відповідь з використанням `ujson`.
-
-/// info | Інформація
-
-Потрібно встановити `ujson`, наприклад `pip install ujson`.
-
-///
-
-/// warning | Попередження
-
-`ujson` менш обережний, ніж вбудована реалізація Python, у поводженні з деякими крайніми випадками.
-
-///
-
-{* ../../docs_src/custom_response/tutorial001_py310.py hl[2,7] *}
+/// note | Технічні деталі
-/// tip | Порада
+Але якщо ви оголосите модель відповіді або тип, його буде використано безпосередньо для серіалізації даних у JSON, і відповідь з коректним медіа-типом для JSON буде повернута безпосередньо, без використання класу `JSONResponse`.
-Ймовірно, `ORJSONResponse` може бути швидшою альтернативою.
+Це ідеальний спосіб отримати найкращу продуктивність.
///
@@ -200,6 +158,7 @@ FastAPI (насправді Starlette) автоматично додасть з
Або ви можете використати його в параметрі `response_class`:
+
{* ../../docs_src/custom_response/tutorial006b_py310.py hl[2,7,9] *}
У такому разі ви можете повертати URL безпосередньо з вашої функції операції шляху.
@@ -214,31 +173,25 @@ FastAPI (насправді Starlette) автоматично додасть з
### `StreamingResponse` { #streamingresponse }
-Приймає async-генератор або звичайний генератор/ітератор і транслює тіло відповіді потоково.
-
-{* ../../docs_src/custom_response/tutorial007_py310.py hl[2,14] *}
-
-#### Використання `StreamingResponse` з об'єктами типу file-like { #using-streamingresponse-with-file-like-objects }
+Приймає async-генератор або звичайний генератор/ітератор (функцію з `yield`) і потоково передає тіло відповіді.
-Якщо у вас є file-like об'єкт (наприклад, об'єкт, що повертається `open()`), ви можете створити генераторну функцію для ітерації по цьому file-like об'єкту.
+{* ../../docs_src/custom_response/tutorial007_py310.py hl[3,16] *}
-Таким чином, вам не потрібно спочатку читати все в пам'ять, і ви можете передати цю генераторну функцію в `StreamingResponse` і повернути її.
-
-Сюди входить багато бібліотек для взаємодії з хмарними сховищами, обробки відео та інші.
+/// note | Технічні деталі
-{* ../../docs_src/custom_response/tutorial008_py310.py hl[2,10:12,14] *}
+Завдання `async` може бути скасовано лише тоді, коли воно досягає `await`. Якщо немає `await`, генератор (функція з `yield`) не може бути коректно скасований і може продовжувати працювати навіть після запиту на скасування.
-1. Це генераторна функція. Вона є «генераторною функцією», бо містить оператори `yield` усередині.
-2. Використовуючи блок `with`, ми гарантуємо, що file-like об'єкт буде закрито після завершення роботи генераторної функції. Тобто після того, як вона завершить надсилання відповіді.
-3. Цей `yield from` вказує функції ітеруватися по об'єкту з назвою `file_like`. А потім, для кожної ітерованої частини, повертати цю частину, ніби вона надходить з цієї генераторної функції (`iterfile`).
+Оскільки цьому невеликому прикладу не потрібні жодні оператори `await`, ми додаємо `await anyio.sleep(0)`, щоб надати циклу подій шанс обробити скасування.
- Тож це генераторна функція, яка всередині передає роботу «генерації» чомусь іншому.
+Це ще важливіше для великих або нескінченних потоків.
- Роблячи це таким чином, ми можемо помістити її в блок `with` і таким чином гарантувати, що file-like об'єкт буде закрито після завершення.
+///
/// tip | Порада
-Зверніть увагу, що тут ми використовуємо стандартний `open()`, який не підтримує `async` та `await`, тому ми оголошуємо операцію шляху звичайною `def`.
+Замість того щоб повертати `StreamingResponse` безпосередньо, імовірно, краще дотримуватися стилю в [Потокова передача даних](./stream-data.md), це значно зручніше та обробляє скасування «за лаштунками» для вас.
+
+Якщо ви транслюєте JSON Lines, дотримуйтесь навчального посібника [Потоки JSON Lines](../tutorial/stream-json-lines.md).
///
@@ -267,7 +220,7 @@ FastAPI (насправді Starlette) автоматично додасть з
Ви можете створити власний клас відповіді, успадкувавши його від `Response`, і використовувати його.
-Наприклад, скажімо, ви хочете використовувати `orjson`, але з деякими користувацькими налаштуваннями, які не використовуються у вбудованому класі `ORJSONResponse`.
+Наприклад, скажімо, ви хочете використовувати [`orjson`](https://github.com/ijl/orjson) з деякими налаштуваннями.
Припустімо, ви хочете, щоб повертався відформатований із відступами JSON, тож ви хочете використати опцію orjson `orjson.OPT_INDENT_2`.
@@ -291,13 +244,21 @@ FastAPI (насправді Starlette) автоматично додасть з
Звісно, ви, ймовірно, знайдете значно кращі способи скористатися цим, ніж просто форматування JSON. 😉
+### `orjson` або Модель відповіді { #orjson-or-response-model }
+
+Якщо ви шукаєте продуктивність, імовірно, краще використати [Модель відповіді](../tutorial/response-model.md), ніж відповідь `orjson`.
+
+З моделлю відповіді FastAPI використає Pydantic, щоб серіалізувати дані в JSON без проміжних кроків, як-от перетворення за допомогою `jsonable_encoder`, що відбувалося б в іншому випадку.
+
+І «під капотом» Pydantic використовує ті самі внутрішні механізми Rust, що й `orjson`, для серіалізації в JSON, тож ви вже отримаєте найкращу продуктивність із моделлю відповіді.
+
## Типова відповідь за замовчуванням { #default-response-class }
Створюючи екземпляр класу **FastAPI** або `APIRouter`, ви можете вказати, який клас відповіді використовувати за замовчуванням.
Параметр, що це визначає, - `default_response_class`.
-У прикладі нижче **FastAPI** використовуватиме `ORJSONResponse` за замовчуванням в усіх операціях шляху замість `JSONResponse`.
+У прикладі нижче **FastAPI** використовуватиме `HTMLResponse` за замовчуванням в усіх операціях шляху, замість JSON.
{* ../../docs_src/custom_response/tutorial010_py310.py hl[2,4] *}
@@ -309,4 +270,4 @@ FastAPI (насправді Starlette) автоматично додасть з
## Додаткова документація { #additional-documentation }
-Ви також можете оголосити медіа-тип і багато інших деталей в OpenAPI, використовуючи `responses`: [Додаткові відповіді в OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Ви також можете оголосити медіа-тип і багато інших деталей в OpenAPI, використовуючи `responses`: [Додаткові відповіді в OpenAPI](additional-responses.md).
diff --git a/docs/uk/docs/advanced/dataclasses.md b/docs/uk/docs/advanced/dataclasses.md
index a41e6e5890..1c91304b08 100644
--- a/docs/uk/docs/advanced/dataclasses.md
+++ b/docs/uk/docs/advanced/dataclasses.md
@@ -2,11 +2,11 @@
FastAPI побудовано поверх **Pydantic**, і я показував вам, як використовувати моделі Pydantic для оголошення запитів і відповідей.
-Але FastAPI також підтримує використання `dataclasses` таким самим чином:
+Але FastAPI також підтримує використання [`dataclasses`](https://docs.python.org/3/library/dataclasses.html) таким самим чином:
{* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}
-Це підтримується завдяки **Pydantic**, адже він має внутрішню підтримку `dataclasses`.
+Це підтримується завдяки **Pydantic**, адже він має [внутрішню підтримку `dataclasses`](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel).
Тож навіть із наведеним вище кодом, який явно не використовує Pydantic, FastAPI використовує Pydantic, щоб перетворити стандартні dataclasses у власний варіант dataclasses Pydantic.
@@ -18,7 +18,7 @@ FastAPI побудовано поверх **Pydantic**, і я показував
Це працює так само, як із моделями Pydantic. Насправді під капотом це також досягається за допомогою Pydantic.
-/// info | Інформація
+/// info
Майте на увазі, що dataclasses не можуть робити все те, що можуть моделі Pydantic.
@@ -64,7 +64,7 @@ Dataclass буде автоматично перетворено на dataclass
6. Тут ми повертаємо словник, що містить `items`, який є списком dataclass.
- FastAPI усе ще здатний серіалізувати дані до JSON.
+ FastAPI усе ще здатний серіалізувати дані до JSON.
7. Тут у `response_model` використано анотацію типу список dataclass `Author`.
@@ -74,7 +74,7 @@ Dataclass буде автоматично перетворено на dataclass
Як завжди, у FastAPI ви можете поєднувати `def` і `async def` за потреби.
- Якщо вам потрібне коротке нагадування, коли що використовувати, перегляньте розділ _«Поспішаєте?»_ у документації про [`async` та `await`](../async.md#in-a-hurry){.internal-link target=_blank}.
+ Якщо вам потрібне коротке нагадування, коли що використовувати, перегляньте розділ _«Поспішаєте?»_ у документації про [`async` та `await`](../async.md#in-a-hurry).
9. Ця *функція операції шляху* не повертає dataclasses (хоча могла б), а список словників із внутрішніми даними.
@@ -88,7 +88,7 @@ Dataclass буде автоматично перетворено на dataclass
Можна поєднувати `dataclasses` з іншими моделями Pydantic, наслідувати їх, включати у власні моделі тощо.
-Щоб дізнатися більше, перегляньте документацію Pydantic про dataclasses.
+Щоб дізнатися більше, перегляньте [документацію Pydantic про dataclasses](https://docs.pydantic.dev/latest/concepts/dataclasses/).
## Версія { #version }
diff --git a/docs/uk/docs/advanced/events.md b/docs/uk/docs/advanced/events.md
index 7c05ee4a4e..33f6314fe1 100644
--- a/docs/uk/docs/advanced/events.md
+++ b/docs/uk/docs/advanced/events.md
@@ -150,11 +150,11 @@ async with lifespan(app):
Невелика технічна деталь для допитливих нердів. 🤓
-Під капотом, у технічній специфікації ASGI, це частина Протоколу тривалості життя, і там визначені події `startup` і `shutdown`.
+Під капотом, у технічній специфікації ASGI, це частина [Протоколу тривалості життя](https://asgi.readthedocs.io/en/latest/specs/lifespan.html), і там визначені події `startup` і `shutdown`.
/// info | Інформація
-Ви можете прочитати більше про обробники `lifespan` у документації Starlette про Lifespan.
+Ви можете прочитати більше про обробники `lifespan` у [документації Starlette про Lifespan](https://www.starlette.dev/lifespan/).
Зокрема, як працювати зі станом тривалості життя, який можна використовувати в інших ділянках вашого коду.
@@ -162,4 +162,4 @@ async with lifespan(app):
## Підзастосунки { #sub-applications }
-🚨 Майте на увазі, що ці події тривалості життя (startup і shutdown) виконуються лише для головного застосунку, а не для [Підзастосунки - монтування](sub-applications.md){.internal-link target=_blank}.
+🚨 Майте на увазі, що ці події тривалості життя (startup і shutdown) виконуються лише для головного застосунку, а не для [Підзастосунки - монтування](sub-applications.md).
diff --git a/docs/uk/docs/advanced/generate-clients.md b/docs/uk/docs/advanced/generate-clients.md
index 66e9193ac3..257089c41a 100644
--- a/docs/uk/docs/advanced/generate-clients.md
+++ b/docs/uk/docs/advanced/generate-clients.md
@@ -8,11 +8,11 @@
## Генератори SDK з відкритим кодом { #open-source-sdk-generators }
-Універсальним варіантом є OpenAPI Generator, який підтримує **багато мов програмування** та може генерувати SDK з вашої специфікації OpenAPI.
+Універсальним варіантом є [OpenAPI Generator](https://openapi-generator.tech/), який підтримує **багато мов програмування** та може генерувати SDK з вашої специфікації OpenAPI.
-Для **клієнтів TypeScript** Hey API — спеціалізоване рішення, що надає оптимізований досвід для екосистеми TypeScript.
+Для **клієнтів TypeScript** [Hey API](https://heyapi.dev/) — спеціалізоване рішення, що надає оптимізований досвід для екосистеми TypeScript.
-Більше генераторів SDK ви можете знайти на OpenAPI.Tools.
+Більше генераторів SDK ви можете знайти на [OpenAPI.Tools](https://openapi.tools/#sdk).
/// tip | Порада
@@ -24,15 +24,15 @@ FastAPI автоматично генерує специфікації **OpenAPI
У цьому розділі представлено рішення від компаній, що спонсорують FastAPI: вони мають **венчурну підтримку** та **корпоративну підтримку**. Ці продукти надають **додаткові можливості** та **інтеграції** поверх високоякісно згенерованих SDK.
-Завдяки ✨ [**спонсорству FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨ ці компанії допомагають підтримувати фреймворк та його **екосистему** здоровими та **сталими**.
+Завдяки ✨ [**спонсорству FastAPI**](../help-fastapi.md#sponsor-the-author) ✨ ці компанії допомагають підтримувати фреймворк та його **екосистему** здоровими та **сталими**.
Їхня підтримка також демонструє сильну відданість **спільноті** FastAPI (вам), показуючи, що їм важливо не лише надавати **відмінний сервіс**, а й підтримувати **міцний і процвітаючий фреймворк**, FastAPI. 🙇
Наприклад, ви можете спробувати:
-* Speakeasy
-* Stainless
-* liblab
+* [Speakeasy](https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship)
+* [Stainless](https://www.stainless.com/?utm_source=fastapi&utm_medium=referral)
+* [liblab](https://developers.liblab.com/tutorials/sdk-for-fastapi?utm_source=fastapi)
Деякі з цих рішень також можуть бути з відкритим кодом або мати безкоштовні тарифи, тож ви можете спробувати їх без фінансових зобов'язань. Інші комерційні генератори SDK також доступні й їх можна знайти онлайн. 🤓
@@ -66,7 +66,7 @@ npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
Це згенерує TypeScript SDK у `./src/client`.
-Ви можете дізнатися, як встановити `@hey-api/openapi-ts`, і почитати про згенерований результат на їхньому сайті.
+Ви можете дізнатися, як [встановити `@hey-api/openapi-ts`](https://heyapi.dev/openapi-ts/get-started), і почитати про [згенерований результат](https://heyapi.dev/openapi-ts/output) на їхньому сайті.
### Використання SDK { #using-the-sdk }
diff --git a/docs/uk/docs/advanced/index.md b/docs/uk/docs/advanced/index.md
index 1cffe0cecd..d856c1e9e1 100644
--- a/docs/uk/docs/advanced/index.md
+++ b/docs/uk/docs/advanced/index.md
@@ -2,13 +2,13 @@
## Додаткові можливості { #additional-features }
-Основний [Навчальний посібник - Посібник користувача](../tutorial/index.md){.internal-link target=_blank} має бути достатнім, щоб провести вас через усі основні можливості **FastAPI**.
+Основний [Навчальний посібник - Посібник користувача](../tutorial/index.md) має бути достатнім, щоб провести вас через усі основні можливості **FastAPI**.
У наступних розділах ви побачите інші опції, конфігурації та додаткові можливості.
-/// tip | Порада
+/// tip
-Наступні розділи не обов'язково «просунуті».
+Наступні розділи **не обов'язково «просунуті»**.
І можливо, що рішення для вашого випадку використання може бути в одному з них.
@@ -16,6 +16,6 @@
## Спершу прочитайте навчальний посібник { #read-the-tutorial-first }
-Ви все ще можете використовувати більшість можливостей **FastAPI**, маючи знання з основного [Навчального посібника - Посібника користувача](../tutorial/index.md){.internal-link target=_blank}.
+Ви все ще можете використовувати більшість можливостей **FastAPI**, маючи знання з основного [Навчального посібника - Посібника користувача](../tutorial/index.md).
А в наступних розділах передбачається, що ви вже його прочитали і знайомі з основними ідеями.
diff --git a/docs/uk/docs/advanced/json-base64-bytes.md b/docs/uk/docs/advanced/json-base64-bytes.md
new file mode 100644
index 0000000000..2cb6461ec7
--- /dev/null
+++ b/docs/uk/docs/advanced/json-base64-bytes.md
@@ -0,0 +1,63 @@
+# JSON з байтами як Base64 { #json-with-bytes-as-base64 }
+
+Якщо ваш застосунок має отримувати і надсилати дані JSON, але потрібно включати туди двійкові дані, ви можете кодувати їх як base64.
+
+## Base64 проти файлів { #base64-vs-files }
+
+Насамперед розгляньте, чи можете ви використати [Файли запиту](../tutorial/request-files.md) для завантаження двійкових даних і [Користувацька відповідь - FileResponse](./custom-response.md#fileresponse--fileresponse-) для надсилання двійкових даних замість кодування їх у JSON.
+
+JSON може містити лише строки, закодовані в UTF-8, тому він не може містити «сирі» байти.
+
+Base64 може кодувати двійкові дані у строках, але для цього потрібно більше символів, ніж у початкових двійкових даних, тож зазвичай це менш ефективно, ніж звичайні файли.
+
+Використовуйте base64 лише якщо справді потрібно включати двійкові дані в JSON і ви не можете використати файли для цього.
+
+## Pydantic `bytes` { #pydantic-bytes }
+
+Ви можете оголосити модель Pydantic з полями `bytes`, а потім використати `val_json_bytes` у конфігурації моделі, щоб вказати їй використовувати base64 для перевірки вхідних даних JSON; як частина цієї перевірки, вона декодує строку base64 у байти.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
+
+Якщо ви перевірите `/docs`, там буде показано, що поле `data` очікує байти, закодовані в base64:
+
+
+
+
@@ -100,7 +100,7 @@ $ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.p
## Налаштування в іншому модулі { #settings-in-another-module }
-Ви можете розмістити ці налаштування в іншому модулі, як ви бачили в [Більші застосунки - кілька файлів](../tutorial/bigger-applications.md){.internal-link target=_blank}.
+Ви можете розмістити ці налаштування в іншому модулі, як ви бачили в [Більші застосунки - кілька файлів](../tutorial/bigger-applications.md).
Наприклад, у вас може бути файл `config.py` з:
@@ -112,7 +112,7 @@ $ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.p
/// tip | Порада
-Вам також знадобиться файл `__init__.py`, як ви бачили в [Більші застосунки - кілька файлів](../tutorial/bigger-applications.md){.internal-link target=_blank}.
+Вам також знадобиться файл `__init__.py`, як ви бачили в [Більші застосунки - кілька файлів](../tutorial/bigger-applications.md).
///
@@ -172,7 +172,7 @@ $ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.p
///
-Pydantic має підтримку читання з таких типів файлів за допомогою зовнішньої бібліотеки. Ви можете дізнатися більше тут:
Pydantic Settings: Dotenv (.env) support.
+Pydantic має підтримку читання з таких типів файлів за допомогою зовнішньої бібліотеки. Ви можете дізнатися більше тут: [Pydantic Settings: Dotenv (.env) support](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support).
/// tip | Порада
@@ -197,7 +197,7 @@ APP_NAME="ChimichangApp"
/// tip | Порада
-Атрибут `model_config` використовується лише для конфігурації Pydantic. Докладніше:
Pydantic: Concepts: Configuration.
+Атрибут `model_config` використовується лише для конфігурації Pydantic. Докладніше: [Pydantic: Concepts: Configuration](https://docs.pydantic.dev/latest/concepts/config/).
///
@@ -291,7 +291,7 @@ participant execute as Execute function
Таким чином, вона поводиться майже так само, якби це була просто глобальна змінна. Але оскільки використовується функція залежності, ми можемо легко переписати її для тестування.
-`@lru_cache` є частиною `functools`, що входить до стандартної бібліотеки Python, більше про це можна прочитати в
документації Python для `@lru_cache`.
+`@lru_cache` є частиною `functools`, що входить до стандартної бібліотеки Python, більше про це можна прочитати в [документації Python для `@lru_cache`](https://docs.python.org/3/library/functools.html#functools.lru_cache).
## Підсумок { #recap }
diff --git a/docs/uk/docs/advanced/stream-data.md b/docs/uk/docs/advanced/stream-data.md
new file mode 100644
index 0000000000..4f12132e06
--- /dev/null
+++ b/docs/uk/docs/advanced/stream-data.md
@@ -0,0 +1,117 @@
+# Потокова передача даних { #stream-data }
+
+Якщо ви хочете передавати потоком дані, які можна структурувати як JSON, див. [Потокова передача JSON Lines](../tutorial/stream-json-lines.md).
+
+Але якщо ви хочете передавати потоком чисті бінарні дані або строки, ось як це зробити.
+
+/// info | Інформація
+
+Додано у FastAPI 0.134.0.
+
+///
+
+## Варіанти використання { #use-cases }
+
+Це можна використовувати, якщо ви хочете передавати потоком чисті строки, наприклад безпосередньо з виводу сервісу AI LLM.
+
+Також це можна використати для потокової передачі великих бінарних файлів, коли ви надсилаєте кожний фрагмент даних під час читання, без потреби завантажувати все в пам'ять одразу.
+
+Так само можна стрімити відео чи аудіо; їх навіть можна генерувати під час обробки та надсилання.
+
+## `StreamingResponse` з `yield` { #a-streamingresponse-with-yield }
+
+Якщо ви оголосите `response_class=StreamingResponse` у вашій функції операції шляху, ви можете використовувати `yield`, щоб послідовно надсилати кожний фрагмент даних.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[1:23] hl[20,23] *}
+
+FastAPI передаватиме кожний фрагмент даних до `StreamingResponse` як є; він не намагатиметься перетворити його на JSON чи щось подібне.
+
+### Не-async функції операції шляху { #non-async-path-operation-functions }
+
+Можна також використовувати звичайні функції `def` (без `async`) і так само застосовувати `yield`.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[26:29] hl[27] *}
+
+### Без анотації { #no-annotation }
+
+Для потокової передачі бінарних даних немає потреби оголошувати анотацію типу, що повертається.
+
+Оскільки FastAPI не намагатиметься перетворювати дані на JSON за допомогою Pydantic чи серіалізувати їх іншим чином, у цьому випадку анотація типу потрібна лише для вашого редактора та інструментів; FastAPI її не використовуватиме.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[32:35] hl[33] *}
+
+Це також означає, що з `StreamingResponse` у вас є свобода і відповідальність формувати та кодувати байти даних саме так, як їх потрібно надіслати, незалежно від анотацій типів. 🤓
+
+### Потік байтів { #stream-bytes }
+
+Один з основних сценаріїв - передавати потоком `bytes` замість строк; це, звісно, підтримується.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[44:47] hl[47] *}
+
+## Користувацький `PNGStreamingResponse` { #a-custom-pngstreamingresponse }
+
+У наведених вище прикладах байти даних передавалися потоком, але у відповіді не було заголовка `Content-Type`, тому клієнт не знав, який тип даних він отримує.
+
+Можна створити власний підклас `StreamingResponse`, який встановлює заголовок `Content-Type` відповідно до типу даних, що ви стрімите.
+
+Наприклад, можна створити `PNGStreamingResponse`, який встановлює заголовок `Content-Type` у `image/png` за допомогою атрибута `media_type`:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[6,19:20] hl[20] *}
+
+Потім ви можете використати цей новий клас у `response_class=PNGStreamingResponse` у вашій функції операції шляху:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[23:27] hl[23] *}
+
+### Симулювати файл { #simulate-a-file }
+
+У цьому прикладі ми імітуємо файл за допомогою `io.BytesIO` - це об'єкт на кшталт файлу, який існує лише в пам'яті, але надає той самий інтерфейс.
+
+Наприклад, ми можемо ітеруватися по ньому, щоб зчитати вміст, так само як і з файлом.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[1:27] hl[3,12:13,25] *}
+
+/// note | Технічні деталі
+
+Інші дві змінні, `image_base64` та `binary_image`, - це зображення, закодоване в Base64, яке потім перетворюється на байти, щоб передати його в `io.BytesIO`.
+
+Лише для того, щоб усе містилося в одному файлі для цього прикладу, і ви могли скопіювати його та запустити як є. 🥚
+
+///
+
+Використовуючи блок `with`, ми гарантуємо, що об'єкт, подібний до файлу, буде закрито після завершення генераторної функції (функції з `yield`). Тобто після завершення надсилання відповіді.
+
+У цьому конкретному прикладі це не так важливо, адже це фальшивий файл у пам'яті (з `io.BytesIO`), але для справжнього файлу важливо переконатися, що файл закрито після завершення роботи з ним.
+
+### Файли та async { #files-and-async }
+
+У більшості випадків об'єкти, подібні до файлів, за замовчуванням несумісні з `async` та `await`.
+
+Наприклад, у них немає `await file.read()` або `async for chunk in file`.
+
+І часто їх читання є блокувальною операцією (що може блокувати цикл подій), адже дані зчитуються з диска або мережі.
+
+/// info | Інформація
+
+Наведений вище приклад - виняток, адже об'єкт `io.BytesIO` вже в пам'яті, тож читання нічого не блокує.
+
+Але в багатьох випадках читання файлу або схожого на файл об'єкта блокує виконання.
+
+///
+
+Щоб уникнути блокування циклу подій, просто оголосіть функцію операції шляху зі звичайним `def` замість `async def`. Тоді FastAPI виконуватиме її в працівнику пулу потоків, щоб не блокувати головний цикл.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}
+
+/// tip | Порада
+
+Якщо вам потрібно викликати блокувальний код усередині async-функції або async-функцію зсередини блокувальної функції, ви можете скористатися [Asyncer](https://asyncer.tiangolo.com) - спорідненою бібліотекою до FastAPI.
+
+///
+
+### `yield from` { #yield-from }
+
+Коли ви ітеруєтеся по чомусь, наприклад по об'єкту, подібному до файлу, і робите `yield` для кожного елемента, можна також використати `yield from`, щоб віддавати кожен елемент напряму і пропустити цикл `for`.
+
+Це не специфічно для FastAPI, це просто Python, але корисний трюк. 😎
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[37:40] hl[40] *}
diff --git a/docs/uk/docs/advanced/strict-content-type.md b/docs/uk/docs/advanced/strict-content-type.md
new file mode 100644
index 0000000000..a244ec9018
--- /dev/null
+++ b/docs/uk/docs/advanced/strict-content-type.md
@@ -0,0 +1,88 @@
+# Сувора перевірка Content-Type { #strict-content-type-checking }
+
+За замовчуванням **FastAPI** використовує сувору перевірку заголовка `Content-Type` для тіл запитів JSON, це означає, що запити JSON мають включати дійсний заголовок `Content-Type` (наприклад, `application/json`), щоб тіло було розібране як JSON.
+
+## Ризик CSRF { #csrf-risk }
+
+Ця поведінка за замовчуванням забезпечує захист від класу атак **Cross-Site Request Forgery (CSRF)** у дуже конкретному сценарії.
+
+Ці атаки використовують той факт, що браузери дозволяють скриптам надсилати запити без виконання перевірки CORS preflight, коли вони:
+
+* не мають заголовка `Content-Type` (наприклад, використовуючи `fetch()` з тілом типу `Blob`)
+* і не надсилають жодних облікових даних автентифікації.
+
+Такий тип атаки головним чином актуальний, коли:
+
+* застосунок працює локально (наприклад, на `localhost`) або у внутрішній мережі
+* і в застосунку немає жодної автентифікації, очікується, що будь-який запит з тієї ж мережі є надійним.
+
+## Приклад атаки { #example-attack }
+
+Уявіть, що ви створюєте спосіб запускати локального AI-агента.
+
+Він надає API за адресою
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Є також фронтенд за адресою
+
+```
+http://localhost:8000
+```
+
+/// tip | Порада
+
+Зауважте, що обидва мають один і той самий хост.
+
+///
+
+Використовуючи фронтенд, ви можете змушувати AI-агента виконувати дії від вашого імені.
+
+Оскільки він працює локально, а не у відкритому інтернеті, ви вирішуєте не налаштовувати жодної автентифікації, просто покладаючись на доступ до локальної мережі.
+
+Один із ваших користувачів може встановити його і запустити локально.
+
+Потім він може відкрити шкідливий вебсайт, напр. щось на кшталт
+
+```
+https://evilhackers.example.com
+```
+
+І цей шкідливий вебсайт надсилає запити, використовуючи `fetch()` з тілом типу `Blob`, до локального API за адресою
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Хоча хости шкідливого вебсайту та локального застосунку різні, браузер не запустить CORS preflight-запит, тому що:
+
+* Застосунок працює без будь-якої автентифікації, немає потреби надсилати облікові дані.
+* Браузер вважає, що він не надсилає JSON (через відсутній заголовок `Content-Type`).
+
+Тоді шкідливий вебсайт може змусити локального AI-агента надсилати злі повідомлення колишньому босу користувача... або щось гірше. 😅
+
+## Відкритий інтернет { #open-internet }
+
+Якщо ваш застосунок у відкритому інтернеті, ви не стали б «довіряти мережі» і дозволяти кому завгодно надсилати привілейовані запити без автентифікації.
+
+Зловмисники можуть просто запустити скрипт, щоб надсилати запити до вашого API, без будь-якої участі браузера, тож ви, ймовірно, вже захищаєте будь-які привілейовані ендпоїнти.
+
+У такому разі ця атака/ризик до вас не застосовується.
+
+Цей ризик і атака головним чином актуальні, коли застосунок працює в локальній мережі і це єдиний передбачуваний захист.
+
+## Дозволення запитів без Content-Type { #allowing-requests-without-content-type }
+
+Якщо вам потрібно підтримувати клієнтів, які не надсилають заголовок `Content-Type`, ви можете вимкнути сувору перевірку, встановивши `strict_content_type=False`:
+
+{* ../../docs_src/strict_content_type/tutorial001_py310.py hl[4] *}
+
+З цим налаштуванням запити без заголовка `Content-Type` матимуть тіло, розібране як JSON, що відповідає поведінці старіших версій FastAPI.
+
+/// info | Інформація
+
+Цю поведінку і конфігурацію додано у FastAPI 0.132.0.
+
+///
diff --git a/docs/uk/docs/advanced/sub-applications.md b/docs/uk/docs/advanced/sub-applications.md
index 5e611c6ff2..bc105824ee 100644
--- a/docs/uk/docs/advanced/sub-applications.md
+++ b/docs/uk/docs/advanced/sub-applications.md
@@ -30,25 +30,25 @@
### Перевірте автоматичну документацію API { #check-the-automatic-api-docs }
-Тепер запустіть команду `fastapi` з вашим файлом:
+Тепер запустіть команду `fastapi`:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-І відкрийте документацію за адресою
http://127.0.0.1:8000/docs.
+І відкрийте документацію за адресою [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Ви побачите автоматичну документацію API для головного застосунку, що містить лише його власні _операції шляху_:
-А потім відкрийте документацію для підзастосунку за адресою
http://127.0.0.1:8000/subapi/docs.
+А потім відкрийте документацію для підзастосунку за адресою [http://127.0.0.1:8000/subapi/docs](http://127.0.0.1:8000/subapi/docs).
Ви побачите автоматичну документацію API для підзастосунку, що містить лише його власні _операції шляху_, усі з правильним префіксом підшляху `/subapi`:
@@ -64,4 +64,4 @@ $ fastapi dev main.py
Підзастосунок також може мати власні змонтовані підзастосунки, і все працюватиме коректно, оскільки FastAPI автоматично обробляє всі ці `root_path`.
-Ви дізнаєтеся більше про `root_path` і як використовувати його явно в розділі [За представником](behind-a-proxy.md){.internal-link target=_blank}.
+Ви дізнаєтеся більше про `root_path` і як використовувати його явно в розділі [За представником](behind-a-proxy.md).
diff --git a/docs/uk/docs/advanced/templates.md b/docs/uk/docs/advanced/templates.md
index 9e1ce3709b..3d9f96e72f 100644
--- a/docs/uk/docs/advanced/templates.md
+++ b/docs/uk/docs/advanced/templates.md
@@ -8,7 +8,7 @@
## Встановіть залежності { #install-dependencies }
-Переконайтеся, що ви створили [віртуальне оточення](../virtual-environments.md){.internal-link target=_blank}, активували його та встановили `jinja2`:
+Переконайтеся, що ви створили [віртуальне оточення](../virtual-environments.md), активували його та встановили `jinja2`:
@@ -123,4 +123,4 @@ Item ID: 42
## Детальніше { #more-details }
-Докладніше, зокрема як тестувати шаблони, дивіться
документацію Starlette щодо шаблонів.
+Докладніше, зокрема як тестувати шаблони, дивіться [документацію Starlette щодо шаблонів](https://www.starlette.dev/templates/).
diff --git a/docs/uk/docs/advanced/testing-websockets.md b/docs/uk/docs/advanced/testing-websockets.md
index cec576fddf..717bffac32 100644
--- a/docs/uk/docs/advanced/testing-websockets.md
+++ b/docs/uk/docs/advanced/testing-websockets.md
@@ -8,6 +8,6 @@
/// note | Примітка
-Докладніше дивіться документацію Starlette з
тестування WebSocket.
+Докладніше дивіться документацію Starlette щодо [тестування WebSocket](https://www.starlette.dev/testclient/#testing-websocket-sessions).
///
diff --git a/docs/uk/docs/advanced/using-request-directly.md b/docs/uk/docs/advanced/using-request-directly.md
index 81b90f19b9..330a0b751e 100644
--- a/docs/uk/docs/advanced/using-request-directly.md
+++ b/docs/uk/docs/advanced/using-request-directly.md
@@ -14,7 +14,7 @@
## Деталі про об'єкт `Request` { #details-about-the-request-object }
-Оскільки під капотом **FastAPI** - це **Starlette** з шаром інструментів зверху, ви можете за потреби використовувати
об'єкт `Request` Starlette безпосередньо.
+Оскільки під капотом **FastAPI** - це **Starlette** з шаром інструментів зверху, ви можете за потреби використовувати об'єкт [`Request`](https://www.starlette.dev/requests/) Starlette безпосередньо.
Це також означає, що якщо ви отримуєте дані безпосередньо з об'єкта `Request` (наприклад, читаєте тіло), FastAPI не буде їх перевіряти, перетворювати або документувати (через OpenAPI для автоматичного інтерфейсу користувача API).
@@ -44,7 +44,7 @@
## Документація `Request` { #request-documentation }
-Докладніше про
об'єкт `Request` на офіційному сайті документації Starlette.
+Докладніше про [об'єкт [`Request`] на офіційному сайті документації Starlette](https://www.starlette.dev/requests/).
/// note | Технічні деталі
diff --git a/docs/uk/docs/advanced/websockets.md b/docs/uk/docs/advanced/websockets.md
index bb06ac00b7..aa290b3897 100644
--- a/docs/uk/docs/advanced/websockets.md
+++ b/docs/uk/docs/advanced/websockets.md
@@ -1,10 +1,10 @@
# WebSockets { #websockets }
-Ви можете використовувати
WebSockets з **FastAPI**.
+Ви можете використовувати [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) з **FastAPI**.
## Встановіть `websockets` { #install-websockets }
-Переконайтеся, що ви створили [віртуальне оточення](../virtual-environments.md){.internal-link target=_blank}, активували його та встановили `websockets` (бібліотеку Python, що полегшує використання протоколу «WebSocket»):
+Переконайтеся, що ви створили [віртуальне оточення](../virtual-environments.md), активували його та встановили `websockets` (бібліотеку Python, що полегшує використання протоколу «WebSocket»):
@@ -64,19 +64,19 @@ $ pip install websockets
## Спробуйте { #try-it }
-Якщо ваш файл називається `main.py`, запустіть ваш застосунок командою:
+Розмістіть код у файлі `main.py`, а потім запустіть ваш застосунок:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-Відкрийте у браузері
http://127.0.0.1:8000.
+Відкрийте у браузері [http://127.0.0.1:8000](http://127.0.0.1:8000).
Ви побачите просту сторінку на кшталт:
@@ -115,25 +115,25 @@ $ fastapi dev main.py
Оскільки це WebSocket, не має сенсу піднімати `HTTPException`, натомість ми піднімаємо `WebSocketException`.
-Ви можете використати код закриття з
чинних кодів, визначених у специфікації.
+Ви можете використати код закриття з [чинних кодів, визначених у специфікації](https://tools.ietf.org/html/rfc6455#section-7.4.1).
///
### Спробуйте WebSockets із залежностями { #try-the-websockets-with-dependencies }
-Якщо ваш файл називається `main.py`, запустіть ваш застосунок командою:
+Запустіть ваш застосунок:
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-Відкрийте у браузері
http://127.0.0.1:8000.
+Відкрийте у браузері [http://127.0.0.1:8000](http://127.0.0.1:8000).
Там ви можете встановити:
@@ -174,7 +174,7 @@ Client #1596980209979 left the chat
Але майте на увазі, що оскільки все обробляється в пам'яті, в одному списку, це працюватиме лише поки процес запущений, і лише з одним процесом.
-Якщо вам потрібне щось просте для інтеграції з FastAPI, але більш надійне, з підтримкою Redis, PostgreSQL чи інших, перегляньте
encode/broadcaster.
+Якщо вам потрібне щось просте для інтеграції з FastAPI, але більш надійне, з підтримкою Redis, PostgreSQL чи інших, перегляньте [encode/broadcaster](https://github.com/encode/broadcaster).
///
@@ -182,5 +182,5 @@ Client #1596980209979 left the chat
Щоб дізнатися більше про можливості, перегляньте документацію Starlette:
-*
Клас `WebSocket`.
-*
Обробка WebSocket на основі класів.
+* [Клас `WebSocket`](https://www.starlette.dev/websockets/).
+* [Обробка WebSocket на основі класів](https://www.starlette.dev/endpoints/#websocketendpoint).
diff --git a/docs/uk/docs/advanced/wsgi.md b/docs/uk/docs/advanced/wsgi.md
index 8969241350..84d4aa4609 100644
--- a/docs/uk/docs/advanced/wsgi.md
+++ b/docs/uk/docs/advanced/wsgi.md
@@ -1,6 +1,6 @@
# Підключення WSGI - Flask, Django та інші { #including-wsgi-flask-django-others }
-Ви можете монтувати застосунки WSGI, як ви бачили в [Підзастосунки - монтування](sub-applications.md){.internal-link target=_blank}, [За представником](behind-a-proxy.md){.internal-link target=_blank}.
+Ви можете монтувати застосунки WSGI, як ви бачили в [Підзастосунки - монтування](sub-applications.md), [За представником](behind-a-proxy.md).
Для цього ви можете використати `WSGIMiddleware` і обгорнути ним ваш застосунок WSGI, наприклад Flask, Django тощо.
@@ -36,13 +36,13 @@
А решта - **FastAPI**.
-Якщо ви запустите це й перейдете на
http://localhost:8000/v1/, ви побачите відповідь від Flask:
+Якщо ви запустите це й перейдете на [http://localhost:8000/v1/](http://localhost:8000/v1/), ви побачите відповідь від Flask:
```txt
Hello, World from Flask!
```
-А якщо ви перейдете на
http://localhost:8000/v2, ви побачите відповідь від FastAPI:
+А якщо ви перейдете на [http://localhost:8000/v2](http://localhost:8000/v2), ви побачите відповідь від FastAPI:
```JSON
{
diff --git a/docs/uk/docs/alternatives.md b/docs/uk/docs/alternatives.md
index 5dbf8a96ba..1e9d479da1 100644
--- a/docs/uk/docs/alternatives.md
+++ b/docs/uk/docs/alternatives.md
@@ -14,7 +14,7 @@
## Попередні інструменти { #previous-tools }
-###
Django { #django }
+### [Django](https://www.djangoproject.com/) { #django }
Це найпопулярніший фреймворк Python, який користується широкою довірою. Він використовується для створення таких систем, як Instagram.
@@ -22,7 +22,7 @@
Він був створений для створення HTML у серверній частині, а не для створення API, які використовуються сучасним інтерфейсом (як-от React, Vue.js і Angular) або іншими системами (як-от
IoT пристрої), які спілкуються з ним.
-###
Django REST Framework { #django-rest-framework }
+### [Django REST Framework](https://www.django-rest-framework.org/) { #django-rest-framework }
Фреймворк Django REST був створений як гнучкий інструментарій для створення веб-інтерфейсів API використовуючи Django в основі, щоб покращити його можливості API.
@@ -42,7 +42,7 @@ Django REST Framework створив Том Крісті. Той самий тв
///
-###
Flask { #flask }
+### [Flask](https://flask.palletsprojects.com) { #flask }
Flask — це «мікрофреймворк», він не включає інтеграцію бази даних, а також багато речей, які за замовчуванням є в Django.
@@ -64,7 +64,7 @@ Flask — це «мікрофреймворк», він не включає ін
///
-###
Requests { #requests }
+### [Requests](https://requests.readthedocs.io) { #requests }
**FastAPI** насправді не є альтернативою **Requests**. Сфера їх застосування дуже різна.
@@ -106,7 +106,7 @@ def read_url():
///
-###
Swagger /
OpenAPI { #swagger-openapi }
+### [Swagger](https://swagger.io/) / [OpenAPI](https://github.com/OAI/OpenAPI-Specification/) { #swagger-openapi }
Головною функцією, яку я хотів від Django REST Framework, була автоматична API документація.
@@ -124,8 +124,8 @@ def read_url():
Інтегрувати інструменти інтерфейсу на основі стандартів:
-*
Інтерфейс Swagger
-*
ReDoc
+* [Інтерфейс Swagger](https://github.com/swagger-api/swagger-ui)
+* [ReDoc](https://github.com/Rebilly/ReDoc)
Ці два було обрано через те, що вони досить популярні та стабільні, але, виконавши швидкий пошук, ви можете знайти десятки додаткових альтернативних інтерфейсів для OpenAPI (які можна використовувати з **FastAPI**).
@@ -135,9 +135,9 @@ def read_url():
Існує кілька фреймворків Flask REST, але, витративши час і роботу на їх дослідження, я виявив, що багато з них припинено або залишено, з кількома постійними проблемами, які зробили їх непридатними.
-###
Marshmallow { #marshmallow }
+### [Marshmallow](https://marshmallow.readthedocs.io/en/stable/) { #marshmallow }
-Однією з головних функцій, необхідних для систем API, є "
серіалізація", яка бере дані з коду (Python) і перетворює їх на щось, що можна надіслати через мережу. Наприклад, перетворення об’єкта, що містить дані з бази даних, на об’єкт JSON. Перетворення об’єктів `datetime` на строки тощо.
+Однією з головних функцій, необхідних для систем API, є «
серіалізація», яка бере дані з коду (Python) і перетворює їх на щось, що можна надіслати через мережу. Наприклад, перетворення об’єкта, що містить дані з бази даних, на об’єкт JSON. Перетворення об’єктів `datetime` на строки тощо.
Іншою важливою функцією, необхідною для API, є перевірка даних, яка забезпечує дійсність даних за певними параметрами. Наприклад, що деяке поле є `int`, а не деяка випадкова строка. Це особливо корисно для вхідних даних.
@@ -153,7 +153,7 @@ Marshmallow створено для забезпечення цих функці
///
-###
Webargs { #webargs }
+### [Webargs](https://webargs.readthedocs.io/en/latest/) { #webargs }
Іншою важливою функцією, необхідною для API, є
аналіз даних із вхідних запитів.
@@ -175,7 +175,7 @@ Webargs був створений тими ж розробниками Marshmall
///
-###
APISpec { #apispec }
+### [APISpec](https://apispec.readthedocs.io/en/stable/) { #apispec }
Marshmallow і Webargs забезпечують перевірку, аналіз і серіалізацію як плагіни.
@@ -205,7 +205,7 @@ APISpec був створений тими ж розробниками Marshmall
///
-###
Flask-apispec { #flask-apispec }
+### [Flask-apispec](https://flask-apispec.readthedocs.io/en/latest/) { #flask-apispec }
Це плагін Flask, який об’єднує Webargs, Marshmallow і APISpec.
@@ -219,11 +219,11 @@ APISpec був створений тими ж розробниками Marshmall
Її використання призвело до створення кількох генераторів повного стека Flask. Це основний стек, який я (та кілька зовнішніх команд) використовував досі:
-*
https://github.com/tiangolo/full-stack
-*
https://github.com/tiangolo/full-stack-flask-couchbase
-*
https://github.com/tiangolo/full-stack-flask-couchdb
+* [https://github.com/tiangolo/full-stack](https://github.com/tiangolo/full-stack)
+* [https://github.com/tiangolo/full-stack-flask-couchbase](https://github.com/tiangolo/full-stack-flask-couchbase)
+* [https://github.com/tiangolo/full-stack-flask-couchdb](https://github.com/tiangolo/full-stack-flask-couchdb)
-І ці самі генератори повного стеку були основою [**FastAPI** генераторів проектів](project-generation.md){.internal-link target=_blank}.
+І ці самі генератори повного стеку були основою [**FastAPI** генераторів проектів](project-generation.md).
/// info | Інформація
@@ -237,7 +237,7 @@ Flask-apispec був створений тими ж розробниками Mar
///
-###
NestJS (та
Angular) { #nestjs-and-angular }
+### [NestJS](https://nestjs.com/) (та [Angular](https://angular.io/)) { #nestjs-and-angular }
Це навіть не Python, NestJS — це фреймворк NodeJS JavaScript (TypeScript), натхненний Angular.
@@ -259,13 +259,13 @@ Flask-apispec був створений тими ж розробниками Mar
///
-###
Sanic { #sanic }
+### [Sanic](https://sanic.readthedocs.io/en/latest/) { #sanic }
Це був один із перших надзвичайно швидких фреймворків Python на основі `asyncio`. Він був дуже схожий на Flask.
/// note | Технічні деталі
-Він використовував
`uvloop` замість стандартного циклу Python `asyncio`. Ось що зробило його таким швидким.
+Він використовував [`uvloop`](https://github.com/MagicStack/uvloop) замість стандартного циклу Python `asyncio`. Ось що зробило його таким швидким.
Це явно надихнуло Uvicorn і Starlette, які зараз швидші за Sanic у відкритих тестах.
@@ -279,7 +279,7 @@ Flask-apispec був створений тими ж розробниками Mar
///
-###
Falcon { #falcon }
+### [Falcon](https://falconframework.org/) { #falcon }
Falcon — ще один високопродуктивний фреймворк Python, він розроблений як мінімальний і працює як основа інших фреймворків, таких як Hug.
@@ -297,7 +297,7 @@ Falcon — ще один високопродуктивний фреймворк
///
-###
Molten { #molten }
+### [Molten](https://moltenframework.com/) { #molten }
Я відкрив для себе Molten на перших етапах створення **FastAPI**. І він має досить схожі ідеї:
@@ -321,7 +321,7 @@ Falcon — ще один високопродуктивний фреймворк
///
-###
Hug { #hug }
+### [Hug](https://github.com/hugapi/hug) { #hug }
Hug був одним із перших фреймворків, який реалізував оголошення типів параметрів API за допомогою підказок типу Python. Це була чудова ідея, яка надихнула інші інструменти зробити те саме.
@@ -337,7 +337,7 @@ Hug був одним із перших фреймворків, який реа
/// info | Інформація
-Hug створив Тімоті Крослі, той самий творець
`isort`, чудовий інструмент для автоматичного сортування імпорту у файлах Python.
+Hug створив Тімоті Крослі, той самий творець [`isort`](https://github.com/timothycrosley/isort), чудовий інструмент для автоматичного сортування імпорту у файлах Python.
///
@@ -351,7 +351,7 @@ Hug надихнув **FastAPI** оголосити параметр `response`
///
-###
APIStar (<= 0,5) { #apistar-0-5 }
+### [APIStar](https://github.com/encode/apistar) (<= 0,5) { #apistar-0-5 }
Безпосередньо перед тим, як вирішити створити **FastAPI**, я знайшов сервер **APIStar**. Він мав майже все, що я шукав, і мав чудовий дизайн.
@@ -401,7 +401,7 @@ APIStar створив Том Крісті. Той самий хлопець, я
## Використовується **FastAPI** { #used-by-fastapi }
-###
Pydantic { #pydantic }
+### [Pydantic](https://docs.pydantic.dev/) { #pydantic }
Pydantic — це бібліотека для визначення перевірки даних, серіалізації та документації (за допомогою Схеми JSON) на основі підказок типу Python.
@@ -417,7 +417,7 @@ Pydantic — це бібліотека для визначення переві
///
-###
Starlette { #starlette }
+### [Starlette](https://www.starlette.dev/) { #starlette }
Starlette — це легкий фреймворк/набір інструментів
ASGI, який ідеально підходить для створення високопродуктивних asyncio сервісів.
@@ -462,7 +462,7 @@ ASGI — це новий «стандарт», який розробляєтьс
///
-###
Uvicorn { #uvicorn }
+### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }
Uvicorn — це блискавичний сервер ASGI, побудований на uvloop і httptools.
@@ -476,10 +476,10 @@ Uvicorn — це блискавичний сервер ASGI, побудован
Ви також можете використати параметр командного рядка `--workers`, щоб мати асинхронний багатопроцесний сервер.
-Додаткову інформацію див. у розділі [Розгортання](deployment/index.md){.internal-link target=_blank}.
+Додаткову інформацію див. у розділі [Розгортання](deployment/index.md).
///
## Орієнтири та швидкість { #benchmarks-and-speed }
-Щоб зрозуміти, порівняти та побачити різницю між Uvicorn, Starlette і FastAPI, перегляньте розділ про [Бенчмарки](benchmarks.md){.internal-link target=_blank}.
+Щоб зрозуміти, порівняти та побачити різницю між Uvicorn, Starlette і FastAPI, перегляньте розділ про [Бенчмарки](benchmarks.md).
diff --git a/docs/uk/docs/async.md b/docs/uk/docs/async.md
index baf4720542..95ecec21f1 100644
--- a/docs/uk/docs/async.md
+++ b/docs/uk/docs/async.md
@@ -141,7 +141,7 @@ def results():
/// info | Інформація
-Прекрасні ілюстрації від
Ketrina Thompson. 🎨
+Прекрасні ілюстрації від [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). 🎨
///
@@ -207,7 +207,7 @@ def results():
/// info | Інформація
-Прекрасні ілюстрації від
Ketrina Thompson. 🎨
+Прекрасні ілюстрації від [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). 🎨
///
@@ -215,7 +215,7 @@ def results():
У цьому сценарії паралельних бургерів ви - комп’ютер/програма 🤖 з двома процесорами (ви і ваша симпатія), які обидва чекають 🕙 і приділяють увагу ⏯ «очікуванню біля прилавка» 🕙 тривалий час.
-У закладу фастфуду 8 процесорів (касира/кухаря). У той час як у закладі з рівночасними бургерами могло бути лише 2 (один касир і один кухар).
+У закладу фастфуду 8 процесорів (касира/кухаря). У той час як у закладу з рівночасними бургерами могло бути лише 2 (один касир і один кухар).
Та все одно фінальний досвід не найкращий. 😞
@@ -251,7 +251,7 @@ def results():
І такий самий рівень продуктивності ви отримуєте з **FastAPI**.
-А оскільки можна мати паралелізм і асинхронність одночасно, ви отримуєте вищу продуктивність, ніж більшість протестованих фреймворків NodeJS, і на рівні з Go, який є компільованою мовою, ближчою до C
(усе завдяки Starlette).
+А оскільки можна мати паралелізм і асинхронність одночасно, ви отримуєте вищу продуктивність, ніж більшість протестованих фреймворків NodeJS, і на рівні з Go, який є компільованою мовою, ближчою до C [(усе завдяки Starlette)](https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1).
### Чи краща рівночасність за паралелізм? { #is-concurrency-better-than-parallelism }
@@ -298,7 +298,7 @@ def results():
Це, плюс простий факт, що Python є основною мовою для **Data Science**, машинного навчання і особливо глибокого навчання, робить FastAPI дуже вдалим вибором для веб API та застосунків Data Science / машинного навчання (серед багатьох інших).
-Щоб побачити, як досягти цього паралелізму у продакшні, див. розділ про [Розгортання](deployment/index.md){.internal-link target=_blank}.
+Щоб побачити, як досягти цього паралелізму у продакшні, див. розділ про [Розгортання](deployment/index.md).
## `async` і `await` { #async-and-await }
@@ -363,13 +363,13 @@ async def read_burgers():
### Пишемо свій власний async-код { #write-your-own-async-code }
-Starlette (і **FastAPI**) базуються на
AnyIO, що робить їх сумісними як зі стандартною бібліотекою Python
asyncio, так і з
Trio.
+Starlette (і **FastAPI**) базуються на [AnyIO](https://anyio.readthedocs.io/en/stable/), що робить їх сумісними як зі стандартною бібліотекою Python [asyncio](https://docs.python.org/3/library/asyncio-task.html), так і з [Trio](https://trio.readthedocs.io/en/stable/).
-Зокрема, ви можете безпосередньо використовувати
AnyIO для ваших просунутих сценаріїв рівночасності, що потребують складніших патернів у вашому коді.
+Зокрема, ви можете безпосередньо використовувати [AnyIO](https://anyio.readthedocs.io/en/stable/) для ваших просунутих сценаріїв рівночасності, що потребують складніших патернів у вашому коді.
-І навіть якщо ви не використовували FastAPI, ви могли б писати свої власні async-застосунки з
AnyIO, щоб мати високу сумісність і отримати його переваги (наприклад, *структурована рівночасність*).
+І навіть якщо ви не використовували FastAPI, ви могли б писати свої власні async-застосунки з [AnyIO](https://anyio.readthedocs.io/en/stable/), щоб мати високу сумісність і отримати його переваги (наприклад, *структурована рівночасність*).
-Я створив іншу бібліотеку поверх AnyIO, як тонкий шар, щоб дещо покращити анотації типів і отримати кращу **автодопомогу** (autocompletion), **вбудовані помилки** (inline errors) тощо. Вона також має дружній вступ і навчальний посібник, щоб допомогти вам **зрозуміти** і написати **власний async-код**:
Asyncer. Вона буде особливо корисною, якщо вам потрібно **поєднувати async-код зі звичайним** (блокуючим/синхронним) кодом.
+Я створив іншу бібліотеку поверх AnyIO, як тонкий шар, щоб дещо покращити анотації типів і отримати кращу **автодопомогу** (autocompletion), **вбудовані помилки** (inline errors) тощо. Вона також має дружній вступ і навчальний посібник, щоб допомогти вам **зрозуміти** і написати **власний async-код**: [Asyncer](https://asyncer.tiangolo.com/). Вона буде особливо корисною, якщо вам потрібно **поєднувати async-код зі звичайним** (блокуючим/синхронним) кодом.
### Інші форми асинхронного коду { #other-forms-of-asynchronous-code }
@@ -381,7 +381,7 @@ Starlette (і **FastAPI**) базуються на
Gevent. Але код набагато складніший для розуміння, налагодження і мислення про нього.
+У попередніх версіях Python ви могли використовувати потоки (threads) або [Gevent](https://www.gevent.org/). Але код набагато складніший для розуміння, налагодження і мислення про нього.
У попередніх версіях NodeJS/Browser JavaScript ви б використовували «callbacks», що призводить до «callback hell».
@@ -419,15 +419,15 @@ Starlette (і **FastAPI**) базуються на
I/O.
-Втім, у будь-якій ситуації є велика ймовірність, що **FastAPI** [все одно буде швидшим](index.md#performance){.internal-link target=_blank} (або принаймні порівнянним) за ваш попередній фреймворк.
+Втім, у будь-якій ситуації є велика ймовірність, що **FastAPI** [все одно буде швидшим](index.md#performance) (або принаймні порівнянним) за ваш попередній фреймворк.
### Залежності { #dependencies }
-Те саме стосується і [залежностей](tutorial/dependencies/index.md){.internal-link target=_blank}. Якщо залежність є стандартною функцією `def` замість `async def`, вона виконується у зовнішньому пулі потоків.
+Те саме стосується і [залежностей](tutorial/dependencies/index.md). Якщо залежність є стандартною функцією `def` замість `async def`, вона виконується у зовнішньому пулі потоків.
### Підзалежності { #sub-dependencies }
-Ви можете мати кілька залежностей і [підзалежностей](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank}, які вимагають одна одну (як параметри визначень функцій). Деякі з них можуть бути створені з `async def`, а деякі - зі звичайним `def`. Все працюватиме, і ті, що створені зі звичайним `def`, будуть викликані у зовнішньому потоці (з пулу потоків), а не «очікувані».
+Ви можете мати кілька залежностей і [підзалежностей](tutorial/dependencies/sub-dependencies.md), які вимагають одна одну (як параметри визначень функцій). Деякі з них можуть бути створені з `async def`, а деякі - зі звичайним `def`. Все працюватиме, і ті, що створені зі звичайним `def`, будуть викликані у зовнішньому потоці (з пулу потоків), а не «очікувані».
### Інші допоміжні функції { #other-utility-functions }
diff --git a/docs/uk/docs/benchmarks.md b/docs/uk/docs/benchmarks.md
index d53b7ee989..b55ef720fa 100644
--- a/docs/uk/docs/benchmarks.md
+++ b/docs/uk/docs/benchmarks.md
@@ -1,6 +1,6 @@
# Бенчмарки { #benchmarks }
-Незалежні бенчмарки TechEmpower показують, що застосунки FastAPI, запущені під керуванням Uvicorn, є одним із найшвидших доступних фреймворків Python, поступаючись лише самим Starlette і Uvicorn (використовуються FastAPI внутрішньо).
+Незалежні бенчмарки TechEmpower показують, що застосунки **FastAPI**, запущені під керуванням Uvicorn, є [одним із найшвидших доступних фреймворків Python](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7), поступаючись лише самим Starlette і Uvicorn (використовуються FastAPI внутрішньо).
Але переглядаючи бенчмарки та порівняння, майте на увазі таке.
@@ -14,20 +14,20 @@
Ієрархія приблизно така:
-* Uvicorn: сервер ASGI
- * Starlette: (використовує Uvicorn) веб-мікрофреймворк
- * FastAPI: (використовує Starlette) мікрофреймворк для API з низкою додаткових можливостей для створення API, з валідацією даних тощо.
+* **Uvicorn**: сервер ASGI
+ * **Starlette**: (використовує Uvicorn) веб-мікрофреймворк
+ * **FastAPI**: (використовує Starlette) мікрофреймворк для API з низкою додаткових можливостей для створення API, з валідацією даних тощо.
-* Uvicorn:
+* **Uvicorn**:
* Матиме найвищу продуктивність, адже майже не містить додаткового коду окрім власне сервера.
- * Ви не писатимете застосунок безпосередньо на Uvicorn. Це означало б, що ваш код мав би включати принаймні приблизно весь код, який надає Starlette (або FastAPI). І якщо зробити так, ваш кінцевий застосунок матиме ті самі накладні витрати, що й під час використання фреймворку, який мінімізує код застосунку та помилки.
+ * Ви не писатимете застосунок безпосередньо на Uvicorn. Це означало б, що ваш код мав би включати принаймні приблизно весь код, який надає Starlette (або **FastAPI**). І якщо зробити так, ваш кінцевий застосунок матиме ті самі накладні витрати, що й під час використання фреймворку, який мінімізує код застосунку та помилки.
* Якщо ви порівнюєте Uvicorn, порівнюйте його з Daphne, Hypercorn, uWSGI тощо. Сервери застосунків.
-* Starlette:
+* **Starlette**:
* Матиме наступну за швидкістю продуктивність після Uvicorn. Насправді Starlette використовує Uvicorn для запуску. Тож вона може бути «повільнішою» за Uvicorn лише через необхідність виконувати більше коду.
* Але надає інструменти для створення простих веб-застосунків із маршрутизацією на основі шляхів тощо.
* Якщо ви порівнюєте Starlette, порівнюйте її з Sanic, Flask, Django тощо. Веб-фреймворки (або мікрофреймворки).
-* FastAPI:
- * Аналогічно до того, як Starlette використовує Uvicorn і не може бути швидшою за нього, FastAPI використовує Starlette, тож не може бути швидшою за неї.
+* **FastAPI**:
+ * Аналогічно до того, як Starlette використовує Uvicorn і не може бути швидшою за нього, **FastAPI** використовує Starlette, тож не може бути швидшою за неї.
* FastAPI надає більше можливостей поверх Starlette. Можливості, які майже завжди потрібні під час створення API, як-от валідація та серіалізація даних. І, використовуючи його, ви безкоштовно отримуєте автоматичну документацію (автоматична документація навіть не додає накладних витрат під час роботи застосунку - вона генерується під час запуску).
* Якби ви не використовували FastAPI і застосували Starlette безпосередньо (або інший інструмент, наприклад Sanic, Flask, Responder тощо), вам довелося б самостійно реалізувати всю валідацію та серіалізацію даних. Тож ваш кінцевий застосунок усе одно мав би ті самі накладні витрати, ніби він був створений із використанням FastAPI. І в багатьох випадках саме ця валідація та серіалізація даних становить найбільший обсяг коду в застосунках.
* Отже, використовуючи FastAPI, ви заощаджуєте час розробки, зменшуєте кількість помилок і рядків коду та, ймовірно, отримуєте таку саму (або кращу) продуктивність, як і без нього (адже інакше вам довелося б реалізувати все це у власному коді).
diff --git a/docs/uk/docs/deployment/cloud.md b/docs/uk/docs/deployment/cloud.md
index a17aaf2591..97d972717f 100644
--- a/docs/uk/docs/deployment/cloud.md
+++ b/docs/uk/docs/deployment/cloud.md
@@ -6,7 +6,7 @@
## FastAPI Cloud { #fastapi-cloud }
-**
FastAPI Cloud** створено тим самим автором і командою, що стоять за **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** створено тим самим автором і командою, що стоять за **FastAPI**.
Воно спрощує процес **створення**, **розгортання** та **доступу** до API з мінімальними зусиллями.
@@ -16,9 +16,9 @@ FastAPI Cloud є основним спонсором і джерелом фін
## Хмарні постачальники - спонсори { #cloud-providers-sponsors }
-Деякі інші хмарні постачальники ✨ [**спонсорують FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨ також. 🙇
+Деякі інші хмарні постачальники ✨ [**спонсорують FastAPI**](../help-fastapi.md#sponsor-the-author) ✨ також. 🙇
Можливо, ви захочете розглянути їх, щоб дотримуватися їхніх інструкцій і спробувати їхні сервіси:
-*
Render
-*
Railway
+* [Render](https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi)
+* [Railway](https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi)
diff --git a/docs/uk/docs/deployment/concepts.md b/docs/uk/docs/deployment/concepts.md
index 07ad314405..a6a5bc80e0 100644
--- a/docs/uk/docs/deployment/concepts.md
+++ b/docs/uk/docs/deployment/concepts.md
@@ -25,7 +25,7 @@
## Безпека - HTTPS { #security-https }
-У [попередньому розділі про HTTPS](https.md){.internal-link target=_blank} ми дізналися, як HTTPS забезпечує шифрування для вашого API.
+У [попередньому розділі про HTTPS](https.md) ми дізналися, як HTTPS забезпечує шифрування для вашого API.
Ми також бачили, що HTTPS зазвичай надається компонентом, **зовнішнім** щодо вашого серверного застосунку, - **TLS Termination Proxy**.
@@ -190,9 +190,9 @@
### Процеси-працівники і порти { #worker-processes-and-ports }
-Пам'ятаєте з документації [Про HTTPS](https.md){.internal-link target=_blank}, що на сервері лише один процес може слухати певну комбінацію порту та IP-адреси?
+Пам'ятаєте з документації [Про HTTPS](https.md), що на сервері лише один процес може слухати певну комбінацію порту та IP-адреси?
-Це досі так.
+Это досі так.
Отже, щоб мати **кілька процесів** одночасно, має бути **єдиний процес, який слухає порт**, і який далі якимось чином передає комунікацію кожному процесу-працівнику.
@@ -243,7 +243,7 @@
Не хвилюйтеся, якщо деякі пункти про **контейнери**, Docker чи Kubernetes поки що не дуже зрозумілі.
-Я розповім більше про образи контейнерів, Docker, Kubernetes тощо в майбутньому розділі: [FastAPI у контейнерах - Docker](docker.md){.internal-link target=_blank}.
+Я розповім більше про образи контейнерів, Docker, Kubernetes тощо в майбутньому розділі: [FastAPI у контейнерах - Docker](docker.md).
///
@@ -281,7 +281,7 @@
/// tip | Порада
-Я наведу більш конкретні приклади для цього з контейнерами у майбутньому розділі: [FastAPI у контейнерах - Docker](docker.md){.internal-link target=_blank}.
+Я наведу більш конкретні приклади для цього з контейнерами у майбутньому розділі: [FastAPI у контейнерах - Docker](docker.md).
///
diff --git a/docs/uk/docs/deployment/docker.md b/docs/uk/docs/deployment/docker.md
index d6faacfe5e..9d9afc0d16 100644
--- a/docs/uk/docs/deployment/docker.md
+++ b/docs/uk/docs/deployment/docker.md
@@ -1,6 +1,6 @@
# FastAPI у контейнерах - Docker { #fastapi-in-containers-docker }
-Під час розгортання застосунків FastAPI поширений підхід - збирати образи контейнерів Linux. Зазвичай це робиться за допомогою
Docker. Потім ви можете розгорнути цей образ контейнера кількома різними способами.
+Під час розгортання застосунків FastAPI поширений підхід - збирати образи контейнерів Linux. Зазвичай це робиться за допомогою [Docker](https://www.docker.com/). Потім ви можете розгорнути цей образ контейнера кількома різними способами.
Використання контейнерів Linux має кілька переваг, зокрема безпека, відтворюваність, простота та інші.
@@ -60,16 +60,16 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"]
Docker був одним з основних інструментів для створення та керування образами контейнерів і контейнерами.
-Існує публічний
Docker Hub з готовими офіційними образами для багатьох інструментів, середовищ, баз даних і застосунків.
+Існує публічний [Docker Hub](https://hub.docker.com/) з готовими офіційними образами для багатьох інструментів, середовищ, баз даних і застосунків.
-Наприклад, є офіційний
образ Python.
+Наприклад, є офіційний [образ Python](https://hub.docker.com/_/python).
І є багато інших образів для різних речей, як-от бази даних, наприклад для:
-*
PostgreSQL
-*
MySQL
-*
MongoDB
-*
Redis тощо.
+* [PostgreSQL](https://hub.docker.com/_/postgres)
+* [MySQL](https://hub.docker.com/_/mysql)
+* [MongoDB](https://hub.docker.com/_/mongo)
+* [Redis](https://hub.docker.com/_/redis) тощо.
Використовуючи готовий образ контейнера, дуже легко поєднувати та використовувати різні інструменти. Наприклад, щоб випробувати нову базу даних. У більшості випадків ви можете використати офіційні образи та просто налаштувати їх змінними оточення.
@@ -111,7 +111,7 @@ Docker був одним з основних інструментів для с
Найпоширеніший спосіб - мати файл `requirements.txt` з назвами пакетів і їхніми версіями, по одному на рядок.
-Звісно, ви застосуєте ті самі ідеї з [Про версії FastAPI](versions.md){.internal-link target=_blank}, щоб задати діапазони версій.
+Звісно, ви застосуєте ті самі ідеї з [Про версії FastAPI](versions.md), щоб задати діапазони версій.
Наприклад, ваш `requirements.txt` може виглядати так:
@@ -238,7 +238,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"]
#### Використовуйте `CMD` - exec form { #use-cmd-exec-form }
-Інструкцію Docker
`CMD` можна записати у двох формах:
+Інструкцію Docker [`CMD`](https://docs.docker.com/reference/dockerfile/#cmd) можна записати у двох формах:
✅ Exec form:
@@ -254,11 +254,11 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"]
CMD fastapi run app/main.py --port 80
```
-Обов’язково завжди використовуйте exec form, щоб FastAPI міг коректно завершувати роботу та щоб були викликані [події тривалості життя](../advanced/events.md){.internal-link target=_blank}.
+Обов’язково завжди використовуйте exec form, щоб FastAPI міг коректно завершувати роботу та щоб були викликані [події тривалості життя](../advanced/events.md).
-Докладніше про це можна прочитати в
документації Docker про shell та exec form.
+Докладніше про це можна прочитати в [документації Docker про shell та exec form](https://docs.docker.com/reference/dockerfile/#shell-and-exec-form).
-Це може бути особливо помітно при використанні `docker compose`. Див. розділ FAQ Docker Compose для технічних деталей:
Чому мої сервіси потребують 10 секунд, щоб пересотворитися або зупинитися?.
+Це може бути особливо помітно при використанні `docker compose`. Див. розділ FAQ Docker Compose для технічних деталей: [Чому мої сервіси потребують 10 секунд, щоб пересотворитися або зупинитися?](https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop).
#### Структура директорій { #directory-structure }
@@ -352,7 +352,7 @@ $ docker run -d --name mycontainer -p 80:80 myimage
## Перевірте { #check-it }
-Ви маєте змогу перевірити це за URL вашого Docker-контейнера, наприклад:
http://192.168.99.100/items/5?q=somequery або
http://127.0.0.1/items/5?q=somequery (або еквівалент, використовуючи ваш Docker-хост).
+Ви маєте змогу перевірити це за URL вашого Docker-контейнера, наприклад: [http://192.168.99.100/items/5?q=somequery](http://192.168.99.100/items/5?q=somequery) або [http://127.0.0.1/items/5?q=somequery](http://127.0.0.1/items/5?q=somequery) (або еквівалент, використовуючи ваш Docker-хост).
Ви побачите щось таке:
@@ -362,17 +362,17 @@ $ docker run -d --name mycontainer -p 80:80 myimage
## Інтерактивна документація API { #interactive-api-docs }
-Тепер ви можете перейти на
http://192.168.99.100/docs або
http://127.0.0.1/docs (або еквівалент, використовуючи ваш Docker-хост).
+Тепер ви можете перейти на [http://192.168.99.100/docs](http://192.168.99.100/docs) або [http://127.0.0.1/docs](http://127.0.0.1/docs) (або еквівалент, використовуючи ваш Docker-хост).
-Ви побачите автоматичну інтерактивну документацію API (надається
Swagger UI):
+Ви побачите автоматичну інтерактивну документацію API (надається [Swagger UI](https://github.com/swagger-api/swagger-ui)):
## Альтернативна документація API { #alternative-api-docs }
-Також ви можете перейти на
http://192.168.99.100/redoc або
http://127.0.0.1/redoc (або еквівалент, використовуючи ваш Docker-хост).
+Також ви можете перейти на [http://192.168.99.100/redoc](http://192.168.99.100/redoc) або [http://127.0.0.1/redoc](http://127.0.0.1/redoc) (або еквівалент, використовуючи ваш Docker-хост).
-Ви побачите альтернативну автоматичну документацію (надається
ReDoc):
+Ви побачите альтернативну автоматичну документацію (надається [ReDoc](https://github.com/Rebilly/ReDoc)):
@@ -413,7 +413,7 @@ CMD ["fastapi", "run", "main.py", "--port", "80"]
## Концепції розгортання { #deployment-concepts }
-Поговорімо знову про деякі з тих самих [Концепцій розгортання](concepts.md){.internal-link target=_blank} у термінах контейнерів.
+Поговорімо знову про деякі з тих самих [Концепцій розгортання](concepts.md) у термінах контейнерів.
Контейнери - це переважно інструмент для спрощення процесу збирання та розгортання застосунку, але вони не нав’язують конкретний підхід до обробки цих концепцій розгортання, і існує кілька можливих стратегій.
@@ -432,7 +432,7 @@ CMD ["fastapi", "run", "main.py", "--port", "80"]
Якщо зосередитись лише на образі контейнера для застосунку FastAPI (а згодом на запущеному контейнері), HTTPS зазвичай обробляється зовнішнім іншим інструментом.
-Це може бути інший контейнер, наприклад з
Traefik, що обробляє HTTPS і автоматичне отримання сертифікатів.
+Це може бути інший контейнер, наприклад з [Traefik](https://traefik.io/), що обробляє HTTPS і автоматичне отримання сертифікатів.
/// tip | Порада
@@ -558,7 +558,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
/// info | Інформація
-Якщо ви використовуєте Kubernetes, це, ймовірно, буде
Init Container.
+Якщо ви використовуєте Kubernetes, це, ймовірно, буде [Init Container](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/).
///
@@ -570,7 +570,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
### Базовий образ Docker { #base-docker-image }
-Колись існував офіційний образ Docker для FastAPI:
tiangolo/uvicorn-gunicorn-fastapi. Але зараз він застарілий. ⛔️
+Колись існував офіційний образ Docker для FastAPI: [tiangolo/uvicorn-gunicorn-fastapi](https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker). Але зараз він застарілий. ⛔️
Ймовірно, вам не слід використовувати цей базовий образ Docker (або будь-який інший подібний).
@@ -600,7 +600,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
## Образ Docker з `uv` { #docker-image-with-uv }
-Якщо ви використовуєте
uv для встановлення та керування вашим проєктом, ви можете скористатися їхнім
посібником Docker для uv.
+Якщо ви використовуєте [uv](https://github.com/astral-sh/uv) для встановлення та керування вашим проєктом, ви можете скористатися їхнім [посібником Docker для uv](https://docs.astral.sh/uv/guides/integration/docker/).
## Підсумок { #recap }
diff --git a/docs/uk/docs/deployment/fastapicloud.md b/docs/uk/docs/deployment/fastapicloud.md
index 4b4f3e59be..63d9fa4595 100644
--- a/docs/uk/docs/deployment/fastapicloud.md
+++ b/docs/uk/docs/deployment/fastapicloud.md
@@ -1,6 +1,6 @@
# FastAPI Cloud { #fastapi-cloud }
-Ви можете розгорнути свій застосунок FastAPI на
FastAPI Cloud однією командою, приєднуйтесь до списку очікування, якщо ще ні. 🚀
+Ви можете розгорнути свій застосунок FastAPI на [FastAPI Cloud](https://fastapicloud.com) **однією командою**, приєднуйтесь до списку очікування, якщо ще ні. 🚀
## Вхід { #login }
@@ -20,7 +20,7 @@ You are logged in to FastAPI Cloud 🚀
## Розгортання { #deploy }
-Тепер розгорніть свій застосунок однією командою:
+Тепер розгорніть свій застосунок **однією командою**:
@@ -40,7 +40,7 @@ Deploying to FastAPI Cloud...
## Про FastAPI Cloud { #about-fastapi-cloud }
-**
FastAPI Cloud** створено тим самим автором і командою, що стоїть за **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** створено тим самим автором і командою, що стоїть за **FastAPI**.
Він спрощує процес **створення**, **розгортання** та **доступу** до API з мінімальними зусиллями.
diff --git a/docs/uk/docs/deployment/https.md b/docs/uk/docs/deployment/https.md
index 29329c88f0..439adf61e2 100644
--- a/docs/uk/docs/deployment/https.md
+++ b/docs/uk/docs/deployment/https.md
@@ -10,31 +10,31 @@
///
-Щоб вивчити основи HTTPS з точки зору споживача, перегляньте
https://howhttps.works/.
-
-Тепер, з точки зору розробника, ось кілька речей, які варто пам'ятати, розмірковуючи про HTTPS:
-
-* Для HTTPS сервер має мати «сертифікати», видані третьою стороною.
- * Насправді ці сертифікати «отримуються» у третьої сторони, а не «генеруються».
-* Сертифікати мають строк дії.
- * Їхній строк дії спливає.
- * І тоді їх потрібно поновити, знову отримавши у третьої сторони.
-* Шифрування з'єднання відбувається на рівні TCP.
- * Це один шар нижче від HTTP.
- * Тож обробка сертифіката та шифрування виконується до HTTP.
-* TCP не знає про «домени». Лише про IP-адреси.
- * Інформація про конкретний домен, який запитується, міститься в даних HTTP.
-* Сертифікати HTTPS «засвідчують» певний домен, але протокол і шифрування працюють на рівні TCP, до того як відомо, з яким доменом маємо справу.
-* Типово це означало б, що на одну IP-адресу можна мати лише один сертифікат HTTPS.
+Щоб **вивчити основи HTTPS** з точки зору споживача, перегляньте [https://howhttps.works/](https://howhttps.works/).
+
+Тепер, з **точки зору розробника**, ось кілька речей, які варто пам'ятати, розмірковуючи про HTTPS:
+
+* Для HTTPS **сервер** має **мати «сертифікати»**, видані **третьою стороною**.
+ * Насправді ці сертифікати **«отримуються»** у третьої сторони, а не **«генеруються»**.
+* Сертифікати мають **строк дії**.
+ * Їхній строк дії **спливає**.
+ * І тоді їх потрібно **поновити**, **знову отримавши** у третьої сторони.
+* Шифрування з'єднання відбувається на **рівні TCP**.
+ * Це один шар **нижче від HTTP**.
+ * Тож **обробка сертифіката та шифрування** виконується **до HTTP**.
+* **TCP не знає про «домени»**. Лише про IP-адреси.
+ * Інформація про **конкретний домен**, який запитується, міститься в **даних HTTP**.
+* **Сертифікати HTTPS** «засвідчують» **певний домен**, але протокол і шифрування працюють на рівні TCP, **до того як відомо**, з яким доменом маємо справу.
+* **Типово**, це означало б, що на одну IP-адресу можна мати **лише один сертифікат HTTPS**.
* Неважливо, наскільки великий ваш сервер або наскільки малий кожен застосунок на ньому.
- * Однак для цього є рішення.
-* Є розширення протоколу TLS (який обробляє шифрування на рівні TCP, до HTTP), що називається
SNI.
- * Це розширення SNI дозволяє одному серверу (з однією IP-адресою) мати кілька сертифікатів HTTPS і обслуговувати кілька доменів/застосунків по HTTPS.
- * Щоб це працювало, один-єдиний компонент (програма), що працює на сервері та слухає публічну IP-адресу, має мати всі сертифікати HTTPS на сервері.
-* Після отримання захищеного з'єднання протокол обміну все ще HTTP.
- * Вміст зашифровано, хоча він надсилається протоколом HTTP.
+ * Однак для цього є **рішення**.
+* Є **розширення** протоколу **TLS** (який обробляє шифрування на рівні TCP, до HTTP), що називається **[
SNI](https://en.wikipedia.org/wiki/Server_Name_Indication)**.
+ * Це розширення SNI дозволяє одному серверу (з **однією IP-адресою**) мати **кілька сертифікатів HTTPS** і обслуговувати **кілька доменів/застосунків через HTTPS**.
+ * Щоб це працювало, один-єдиний компонент (програма), що працює на сервері та слухає **публічну IP-адресу**, має мати **всі сертифікати HTTPS** на сервері.
+* **Після** отримання захищеного з'єднання протокол обміну **залишається HTTP**.
+ * Вміст **зашифровано**, хоча він надсилається з використанням **протоколу HTTP**.
-Поширена практика мати одну програму/HTTP-сервер, що працює на сервері (машині, хості тощо) і керує всіма частинами HTTPS: приймає зашифровані HTTPS-запити, надсилає розшифровані HTTP-запити до фактичного HTTP-застосунку, що працює на тому ж сервері (у нашому випадку застосунок FastAPI), отримує HTTP-відповідь від застосунку, шифрує її за допомогою відповідного сертифіката HTTPS і надсилає її назад клієнту через HTTPS. Такий сервер часто називають
TLS Termination Proxy.
+Поширена практика мати **одну програму/HTTP-сервер**, що працює на сервері (машині, хості тощо) і **керує всіма частинами HTTPS**: приймає **зашифровані HTTPS-запити**, надсилає **розшифровані HTTP-запити** до фактичного HTTP-застосунку, що працює на тому ж сервері (у нашому випадку застосунок **FastAPI**), отримує **HTTP-відповідь** від застосунку, **шифрує її** за допомогою відповідного **сертифіката HTTPS** і надсилає її назад клієнту через **HTTPS**. Такий сервер часто називають **[TLS Termination Proxy](https://en.wikipedia.org/wiki/TLS_termination_proxy)**.
Деякі варіанти, які ви можете використати як TLS Termination Proxy:
@@ -45,17 +45,17 @@
## Let's Encrypt { #lets-encrypt }
-До Let's Encrypt ці сертифікати HTTPS продавалися довіреними третіми сторонами.
+До Let's Encrypt ці **сертифікати HTTPS** продавалися довіреними третіми сторонами.
Процес отримання одного з таких сертифікатів був громіздким, вимагав чимало паперової роботи, а самі сертифікати були доволі дорогими.
-Але потім з'явився проєкт
Let's Encrypt.
+Але потім з'явився проєкт **[Let's Encrypt](https://letsencrypt.org/)**.
-Це проєкт Linux Foundation. Він надає сертифікати HTTPS безкоштовно, в автоматизований спосіб. Ці сертифікати використовують усі стандартні криптографічні механізми безпеки і є короткостроковими (близько 3 місяців), тож безпека насправді краща завдяки зменшеній тривалості життя.
+Це проєкт Linux Foundation. Він надає **сертифікати HTTPS безкоштовно**, в автоматизований спосіб. Ці сертифікати використовують усі стандартні криптографічні механізми безпеки і є короткостроковими (близько 3 місяців), тож **безпека насправді краща** завдяки зменшеній тривалості життя.
Домени безпечно перевіряються, а сертифікати генеруються автоматично. Це також дозволяє автоматизувати поновлення цих сертифікатів.
-Ідея полягає в автоматизації отримання та поновлення цих сертифікатів, щоб ви могли мати безпечний HTTPS безкоштовно та назавжди.
+Ідея полягає в автоматизації отримання та поновлення цих сертифікатів, щоб ви могли мати **безпечний HTTPS, безкоштовно і назавжди**.
## HTTPS для розробників { #https-for-developers }
@@ -63,11 +63,11 @@
### Доменне ім'я { #domain-name }
-Ймовірно, все почнеться з того, що ви придбаєте якесь доменне ім'я. Потім ви налаштуєте його на сервері DNS (можливо, у вашого ж хмарного провайдера).
+Ймовірно, все почнеться з того, що ви **придбаєте** якесь **доменне ім'я**. Потім ви налаштуєте його на сервері DNS (можливо, у вашого ж хмарного провайдера).
-Ви, скоріш за все, отримаєте хмарний сервер (віртуальну машину) або щось подібне, і він матиме
фіксовану публічну IP-адресу.
+Ви, скоріш за все, отримаєте хмарний сервер (віртуальну машину) або щось подібне, і він матиме
фіксовану **публічну IP-адресу**.
-На сервері(ах) DNS ви налаштуєте запис («`A record`»), щоб спрямувати ваш домен на публічну IP-адресу вашого сервера.
+На сервері(ах) DNS ви налаштуєте запис («`A record`»), щоб спрямувати **ваш домен** на публічну **IP-адресу вашого сервера**.
Ймовірно, ви зробите це лише один раз, уперше, коли все налаштовуватимете.
@@ -81,136 +81,136 @@
Тепер зосередьмося на всіх власне частинах HTTPS.
-Спочатку браузер звернеться до серверів DNS, щоб дізнатися, яка IP-адреса для домену, у цьому випадку `someapp.example.com`.
+Спочатку браузер звернеться до **DNS-серверів**, щоб дізнатися, яка **IP-адреса для домену**, у цьому випадку `someapp.example.com`.
-Сервери DNS повідомлять браузеру використати конкретну IP-адресу. Це буде публічна IP-адреса, яку використовує ваш сервер і яку ви налаштували на серверах DNS.
+Сервери DNS повідомлять браузеру використати конкретну **IP-адресу**. Це буде публічна IP-адреса, яку використовує ваш сервер і яку ви налаштували на серверах DNS.
### Початок TLS рукостискання { #tls-handshake-start }
-Потім браузер зв'яжеться з цією IP-адресою на порту 443 (порт HTTPS).
+Потім браузер зв'яжеться з цією IP-адресою на **порту 443** (порт HTTPS).
Перша частина комунікації - це просто встановлення з'єднання між клієнтом і сервером та узгодження криптографічних ключів тощо.
-Ця взаємодія між клієнтом і сервером для встановлення з'єднання TLS називається TLS рукостисканням.
+Ця взаємодія між клієнтом і сервером для встановлення з'єднання TLS називається **TLS рукостисканням**.
### TLS із розширенням SNI { #tls-with-sni-extension }
-Лише один процес на сервері може слухати конкретний порт на конкретній IP-адресі. Інші процеси можуть слухати інші порти на тій самій IP-адресі, але лише один для кожної комбінації IP-адреси та порту.
+**Лише один процес** на сервері може слухати конкретний **порт** на конкретній **IP-адресі**. Інші процеси можуть слухати інші порти на тій самій IP-адресі, але лише один для кожної комбінації IP-адреси та порту.
TLS (HTTPS) за замовчуванням використовує конкретний порт `443`. Отже, це порт, який нам потрібен.
-Оскільки лише один процес може слухати цей порт, процесом, що робитиме це, буде TLS Termination Proxy.
+Оскільки лише один процес може слухати цей порт, процесом, що робитиме це, буде **TLS Termination Proxy**.
-TLS Termination Proxy матиме доступ до одного або кількох сертифікатів TLS (сертифікатів HTTPS).
+TLS Termination Proxy матиме доступ до одного або кількох **сертифікатів TLS** (сертифікатів HTTPS).
-Використовуючи обговорене вище розширення SNI, TLS Termination Proxy перевірить, який із наявних сертифікатів TLS (HTTPS) слід використати для цього з'єднання, обравши той, що відповідає домену, очікуваному клієнтом.
+Використовуючи **розширення SNI**, обговорене вище, TLS Termination Proxy перевірить, який із наявних сертифікатів TLS (HTTPS) слід використати для цього з'єднання, обравши той, що відповідає домену, очікуваному клієнтом.
У цьому випадку він використає сертифікат для `someapp.example.com`.
-Клієнт уже довіряє сутності, яка видала цей сертифікат TLS (у цьому випадку Let's Encrypt, але про це згодом), тож він може перевірити, що сертифікат дійсний.
+Клієнт уже **довіряє** сутності, яка видала цей сертифікат TLS (у цьому випадку Let's Encrypt, але про це згодом), тож він може **перевірити**, що сертифікат дійсний.
-Потім, використовуючи сертифікат, клієнт і TLS Termination Proxy узгоджують, як шифрувати решту TCP-комунікації. На цьому частина TLS рукостискання завершується.
+Потім, використовуючи сертифікат, клієнт і TLS Termination Proxy **вирішать, як шифрувати** решту **TCP-комунікації**. На цьому частина **TLS рукостискання** завершується.
-Після цього клієнт і сервер мають зашифроване TCP-з'єднання - саме це надає TLS. І тоді вони можуть використати це з'єднання, щоб почати власне HTTP-комунікацію.
+Після цього клієнт і сервер мають **зашифроване TCP-з'єднання** - саме це надає TLS. І тоді вони можуть використати це з'єднання, щоб почати власне **HTTP-комунікацію**.
-І це і є HTTPS: це звичайний HTTP усередині захищеного TLS-з'єднання замість чистого (незашифрованого) TCP-з'єднання.
+І це і є **HTTPS**: це звичайний **HTTP** усередині **захищеного TLS-з'єднання** замість чистого (незашифрованого) TCP-з'єднання.
/// tip | Порада
-Зверніть увагу, що шифрування комунікації відбувається на рівні TCP, а не на рівні HTTP.
+Зверніть увагу, що шифрування комунікації відбувається на **рівні TCP**, а не на рівні HTTP.
///
### HTTPS-запит { #https-request }
-Тепер, коли клієнт і сервер (конкретно браузер і TLS Termination Proxy) мають зашифроване TCP-з'єднання, вони можуть почати HTTP-комунікацію.
+Тепер, коли клієнт і сервер (конкретно браузер і TLS Termination Proxy) мають **зашифроване TCP-з'єднання**, вони можуть почати **HTTP-комунікацію**.
-Отже, клієнт надсилає HTTPS-запит. Це просто HTTP-запит через зашифроване TLS-з'єднання.
+Отже, клієнт надсилає **HTTPS-запит**. Це просто HTTP-запит через зашифроване TLS-з'єднання.
### Розшифрування запиту { #decrypt-the-request }
-TLS Termination Proxy використає узгоджене шифрування, щоб розшифрувати запит, і передасть звичайний (розшифрований) HTTP-запит процесу, що запускає застосунок (наприклад, процесу з Uvicorn, який запускає застосунок FastAPI).
+TLS Termination Proxy використає узгоджене шифрування, щоб **розшифрувати запит**, і передасть **звичайний (розшифрований) HTTP-запит** процесу, що запускає застосунок (наприклад, процесу з Uvicorn, який запускає застосунок FastAPI).
### HTTP-відповідь { #http-response }
-Застосунок обробить запит і надішле звичайну (незашифровану) HTTP-відповідь TLS Termination Proxy.
+Застосунок обробить запит і надішле **звичайну (незашифровану) HTTP-відповідь** TLS Termination Proxy.
### HTTPS-відповідь { #https-response }
-Потім TLS Termination Proxy зашифрує відповідь, використовуючи попередньо узгоджену криптографію (що почалася із сертифіката для `someapp.example.com`), і надішле її назад у браузер.
+Потім TLS Termination Proxy **зашифрує відповідь**, використовуючи попередньо узгоджену криптографію (що почалася із сертифіката для `someapp.example.com`), і надішле її назад у браузер.
-Далі браузер перевірить, що відповідь дійсна й зашифрована правильним криптографічним ключем тощо. Потім він розшифрує відповідь і обробить її.
+Далі браузер перевірить, що відповідь дійсна й зашифрована правильним криптографічним ключем тощо. Потім він **розшифрує відповідь** і обробить її.
-Клієнт (браузер) знатиме, що відповідь надходить від правильного сервера, тому що використовується узгоджена раніше криптографія з використанням сертифіката HTTPS.
+Клієнт (браузер) знатиме, що відповідь надходить від правильного сервера, тому що використовується узгоджена раніше криптографія з використанням **сертифіката HTTPS**.
### Кілька застосунків { #multiple-applications }
-На тому самому сервері (або серверах) може бути кілька застосунків, наприклад інші програми API або база даних.
+На тому самому сервері (або серверах) може бути **кілька застосунків**, наприклад інші програми API або база даних.
-Лише один процес може обробляти конкретну IP-адресу і порт (TLS Termination Proxy у нашому прикладі), але інші застосунки/процеси також можуть працювати на сервері(ах), доки вони не намагаються використати ту саму комбінацію публічної IP-адреси й порту.
+Лише один процес може обробляти конкретну IP-адресу і порт (TLS Termination Proxy у нашому прикладі), але інші застосунки/процеси також можуть працювати на сервері(ах), доки вони не намагаються використати ту саму **комбінацію публічної IP-адреси й порту**.
-Таким чином, TLS Termination Proxy може обробляти HTTPS і сертифікати для кількох доменів, для кількох застосунків, а потім передавати запити до відповідного застосунку в кожному випадку.
+Таким чином, TLS Termination Proxy може обробляти HTTPS і сертифікати для **кількох доменів**, для кількох застосунків, а потім передавати запити до відповідного застосунку в кожному випадку.
### Поновлення сертифіката { #certificate-renewal }
-У певний момент у майбутньому строк дії кожного сертифіката спливе (приблизно через 3 місяці після його отримання).
+У певний момент у майбутньому строк дії кожного сертифіката **спливе** (приблизно через 3 місяці після його отримання).
Потім інша програма (в деяких випадках це інша програма, а в деяких - той самий TLS Termination Proxy) зв'яжеться з Let's Encrypt і поновить сертифікат(и).
-Сертифікати TLS пов'язані з доменним іменем, а не з IP-адресою.
+**Сертифікати TLS** пов'язані **з доменним іменем**, а не з IP-адресою.
-Тому, щоб поновити сертифікати, програма поновлення має довести авторитету (Let's Encrypt), що вона справді «володіє» і контролює цей домен.
+Тому, щоб поновити сертифікати, програма поновлення має **довести** авторитету (Let's Encrypt), що вона справді **«володіє» і контролює цей домен**.
Щоб зробити це й задовольнити різні потреби застосунків, є кілька способів. Деякі популярні:
-* Змінити деякі записи DNS.
+* **Змінити деякі записи DNS**.
* Для цього програма поновлення має підтримувати API провайдера DNS, тож залежно від того, якого провайдера DNS ви використовуєте, це може бути або не бути варіантом.
-* Запуститися як сервер (принаймні під час процесу отримання сертифіката) на публічній IP-адресі, пов'язаній із доменом.
+* **Запуститися як сервер** (принаймні під час процесу отримання сертифіката) на публічній IP-адресі, пов'язаній із доменом.
* Як ми казали вище, лише один процес може слухати конкретну IP-адресу та порт.
* Це одна з причин, чому дуже зручно, коли той самий TLS Termination Proxy також займається процесом поновлення сертифікатів.
* Інакше вам, можливо, доведеться на мить зупинити TLS Termination Proxy, запустити програму поновлення, щоб отримати сертифікати, потім налаштувати їх у TLS Termination Proxy і перезапустити TLS Termination Proxy. Це неідеально, оскільки ваші застосунки будуть недоступні під час вимкнення TLS Termination Proxy.
-Увесь цей процес поновлення, паралельно з обслуговуванням застосунку, - одна з головних причин, чому ви можете захотіти мати окрему систему для обробки HTTPS за допомогою TLS Termination Proxy замість того, щоб просто використовувати сертифікати TLS безпосередньо з сервером застосунку (наприклад, Uvicorn).
+Увесь цей процес поновлення, паралельно з обслуговуванням застосунку, - одна з головних причин, чому ви можете захотіти мати **окрему систему для обробки HTTPS** за допомогою TLS Termination Proxy замість того, щоб просто використовувати сертифікати TLS безпосередньо з сервером застосунку (наприклад, Uvicorn).
## Направлені заголовки проксі { #proxy-forwarded-headers }
-Коли ви використовуєте проксі для обробки HTTPS, ваш сервер застосунку (наприклад, Uvicorn через FastAPI CLI) нічого не знає про процес HTTPS, він спілкується звичайним HTTP із TLS Termination Proxy.
+Коли ви використовуєте проксі для обробки HTTPS, ваш **сервер застосунку** (наприклад, Uvicorn через FastAPI CLI) нічого не знає про процес HTTPS, він спілкується звичайним HTTP із **TLS Termination Proxy**.
-Цей проксі зазвичай динамічно встановлює деякі HTTP-заголовки перед передачею запиту серверу застосунку, щоб дати йому знати, що запит направляється проксі.
+Цей **проксі** зазвичай динамічно встановлює деякі HTTP-заголовки перед передачею запиту **серверу застосунку**, щоб дати йому знати, що запит **направляється** проксі.
/// note | Технічні деталі
Заголовки проксі:
-*
X-Forwarded-For
-*
X-Forwarded-Proto
-*
X-Forwarded-Host
+* [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For)
+* [X-Forwarded-Proto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto)
+* [X-Forwarded-Host](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host)
///
-Втім, оскільки сервер застосунку не знає, що він стоїть за довіреним проксі, за замовчуванням він не довірятиме цим заголовкам.
+Втім, оскільки **сервер застосунку** не знає, що він стоїть за довіреним **проксі**, за замовчуванням він не довірятиме цим заголовкам.
-Але ви можете налаштувати сервер застосунку, щоб довіряти направленим заголовкам, надісланим проксі. Якщо ви використовуєте FastAPI CLI, ви можете скористатися курсивною *опцією CLI* `--forwarded-allow-ips`, щоб повідомити, з яких IP-адрес слід довіряти цим направленим заголовкам.
+Але ви можете налаштувати **сервер застосунку**, щоб довіряти направленим заголовкам, надісланим **проксі**. Якщо ви використовуєте FastAPI CLI, ви можете скористатися курсивною *опцією CLI* `--forwarded-allow-ips`, щоб повідомити, з яких IP-адрес слід довіряти цим направленим заголовкам.
-Наприклад, якщо сервер застосунку отримує комунікацію лише від довіреного проксі, ви можете встановити `--forwarded-allow-ips="*"`, щоб довіряти всім вхідним IP-адресам, оскільки він отримуватиме запити лише з тієї IP-адреси, яку використовує проксі.
+Наприклад, якщо **сервер застосунку** отримує комунікацію лише від довіреного **проксі**, ви можете встановити `--forwarded-allow-ips="*"`, щоб довіряти всім вхідним IP-адресам, оскільки він отримуватиме запити лише з тієї IP-адреси, яку використовує **проксі**.
Так застосунок зможе знати свою публічну URL-адресу, чи використовує він HTTPS, домен тощо.
@@ -218,14 +218,14 @@ TLS Termination Proxy використає узгоджене шифруванн
/// tip | Порада
-Ви можете дізнатися більше про це в документації [За проксі - Увімкнути направлені заголовки проксі](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers){.internal-link target=_blank}
+Ви можете дізнатися більше про це в документації [За проксі - Увімкнути направлені заголовки проксі](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers)
///
## Підсумок { #recap }
-Наявність HTTPS дуже важлива і в більшості випадків критична. Більшість зусиль, які вам як розробнику доведеться докласти навколо HTTPS, полягають лише в розумінні цих концепцій і того, як вони працюють.
+Наявність **HTTPS** дуже важлива і в більшості випадків **критична**. Більшість зусиль, які вам як розробнику доведеться докласти навколо HTTPS, полягають лише в **розумінні цих концепцій** і того, як вони працюють.
-Але як тільки ви знаєте базову інформацію про HTTPS для розробників, ви можете легко комбінувати й налаштовувати різні інструменти, щоб керувати всім просто.
+Але як тільки ви знаєте базову інформацію про **HTTPS для розробників**, ви можете легко комбінувати й налаштовувати різні інструменти, щоб керувати всім просто.
-У деяких наступних розділах я покажу кілька конкретних прикладів налаштування HTTPS для застосунків FastAPI. 🔒
+У деяких наступних розділах я покажу кілька конкретних прикладів налаштування **HTTPS** для застосунків **FastAPI**. 🔒
diff --git a/docs/uk/docs/deployment/index.md b/docs/uk/docs/deployment/index.md
index 7386681397..aa9c1f1fdf 100644
--- a/docs/uk/docs/deployment/index.md
+++ b/docs/uk/docs/deployment/index.md
@@ -16,7 +16,7 @@
Ви можете розгорнути сервер самостійно, використовуючи комбінацію інструментів, можете скористатися **хмарним сервісом**, який виконує частину роботи за вас, або обрати інші варіанти.
-Наприклад, ми, команда, що стоїть за FastAPI, створили
**FastAPI Cloud**, щоб зробити розгортання застосунків FastAPI у хмарі якомога простішим і з тим самим досвідом розробки, що й під час роботи з FastAPI.
+Наприклад, ми, команда, що стоїть за FastAPI, створили [**FastAPI Cloud**](https://fastapicloud.com), щоб зробити розгортання застосунків FastAPI у хмарі якомога простішим і з тим самим досвідом розробки, що й під час роботи з FastAPI.
Я покажу вам кілька основних концепцій, про які, ймовірно, варто пам'ятати під час розгортання **FastAPI**-застосунку (хоча більшість із них стосується будь-яких інших типів веб-застосунків).
diff --git a/docs/uk/docs/deployment/manually.md b/docs/uk/docs/deployment/manually.md
index d70ec5d5d0..7ea2c78e39 100644
--- a/docs/uk/docs/deployment/manually.md
+++ b/docs/uk/docs/deployment/manually.md
@@ -52,11 +52,11 @@ FastAPI використовує стандарт для побудови Python
Є кілька альтернатив, зокрема:
-*
Uvicorn: високопродуктивний ASGI-сервер.
-*
Hypercorn: ASGI-сервер, сумісний з HTTP/2 і Trio, серед інших можливостей.
-*
Daphne: ASGI-сервер, створений для Django Channels.
-*
Granian: Rust HTTP-сервер для Python-застосунків.
-*
NGINX Unit: NGINX Unit - легке й універсальне середовище виконання вебзастосунків.
+* [Uvicorn](https://www.uvicorn.dev/): високопродуктивний ASGI-сервер.
+* [Hypercorn](https://hypercorn.readthedocs.io/): ASGI-сервер, сумісний з HTTP/2 і Trio, серед інших можливостей.
+* [Daphne](https://github.com/django/daphne): ASGI-сервер, створений для Django Channels.
+* [Granian](https://github.com/emmett-framework/granian): Rust HTTP-сервер для Python-застосунків.
+* [NGINX Unit](https://unit.nginx.org/howto/fastapi/): NGINX Unit - легке й універсальне середовище виконання вебзастосунків.
## Серверна машина і серверна програма { #server-machine-and-server-program }
@@ -74,7 +74,7 @@ FastAPI використовує стандарт для побудови Python
Але ви також можете встановити ASGI-сервер вручну.
-Переконайтеся, що ви створили [віртуальне оточення](../virtual-environments.md){.internal-link target=_blank}, активували його, після чого можете встановити серверну програму.
+Переконайтеся, що ви створили [віртуальне оточення](../virtual-environments.md), активували його, після чого можете встановити серверну програму.
Наприклад, щоб установити Uvicorn:
@@ -137,7 +137,7 @@ Uvicorn та інші сервери підтримують опцію `--reload
Опція `--reload` споживає значно більше ресурсів, є менш стабільною тощо.
-Вона дуже допомагає під час розробки, але її не слід використовувати в продакшні.
+Вона дуже допомагає під час **розробки**, але її **не слід** використовувати в **продакшні**.
///
diff --git a/docs/uk/docs/deployment/server-workers.md b/docs/uk/docs/deployment/server-workers.md
index 81a8bd2a4d..f165bb7079 100644
--- a/docs/uk/docs/deployment/server-workers.md
+++ b/docs/uk/docs/deployment/server-workers.md
@@ -5,7 +5,7 @@
- Безпека - HTTPS
- Запуск під час старту
- Перезапуски
-- Реплікація (кількість процесів, що виконуються)
+- **Реплікація (кількість процесів, що виконуються)**
- Пам'ять
- Попередні кроки перед запуском
@@ -13,13 +13,13 @@
Під час розгортання застосунків ви, найімовірніше, захочете мати реплікацію процесів, щоб використовувати кілька ядер і обробляти більше запитів.
-Як ви бачили в попередньому розділі про [Концепції розгортання](concepts.md){.internal-link target=_blank}, існує кілька стратегій, які можна використовувати.
+Як ви бачили в попередньому розділі про [Концепції розгортання](concepts.md), існує кілька стратегій, які можна використовувати.
Тут я покажу, як використовувати Uvicorn із процесами-працівниками за допомогою команди `fastapi` або безпосередньо команди `uvicorn`.
/// info | Інформація
-Якщо ви використовуєте контейнери, наприклад з Docker або Kubernetes, я розповім про це більше в наступному розділі: [FastAPI у контейнерах - Docker](docker.md){.internal-link target=_blank}.
+Якщо ви використовуєте контейнери, наприклад з Docker або Kubernetes, я розповім про це більше в наступному розділі: [FastAPI у контейнерах - Docker](docker.md).
Зокрема, під час запуску в Kubernetes вам, найімовірніше, не варто використовувати працівників, натомість запускати один процес Uvicorn на контейнер. Але про це я розповім пізніше в тому розділі.
@@ -117,16 +117,16 @@ $ uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
Із наведеного вище списку концепцій розгортання, використання працівників головним чином допоможе з частиною про реплікацію і трохи з перезапусками, але про інше все ще треба подбати:
-- Безпека - HTTPS
-- Запуск під час старту
+- **Безпека - HTTPS**
+- **Запуск під час старту**
- ***Перезапуски***
- Реплікація (кількість процесів, що виконуються)
-- Пам'ять
-- Попередні кроки перед запуском
+- **Пам'ять**
+- **Попередні кроки перед запуском**
## Контейнери і Docker { #containers-and-docker }
-У наступному розділі про [FastAPI у контейнерах - Docker](docker.md){.internal-link target=_blank} я поясню кілька стратегій, які ви можете використати для інших концепцій розгортання.
+У наступному розділі про [FastAPI у контейнерах - Docker](docker.md) я поясню кілька стратегій, які ви можете використати для інших концепцій розгортання.
Я покажу, як побудувати власний образ з нуля для запуску одного процесу Uvicorn. Це простий процес і, ймовірно, саме те, що потрібно при використанні розподіленої системи керування контейнерами, такої як Kubernetes.
diff --git a/docs/uk/docs/deployment/versions.md b/docs/uk/docs/deployment/versions.md
index 4f6d1b01a2..568ff40ee4 100644
--- a/docs/uk/docs/deployment/versions.md
+++ b/docs/uk/docs/deployment/versions.md
@@ -4,7 +4,7 @@
Нові можливості додаються часто, помилки регулярно виправляються, а код постійно поліпшується.
-Тому поточні версії все ще `0.x.x`, це відображає те, що кожна версія потенційно може містити несумісні зміни. Це відповідає правилам
Семантичного версіонування.
+Тому поточні версії все ще `0.x.x`, це відображає те, що кожна версія потенційно може містити несумісні зміни. Це відповідає правилам [Семантичного версіонування](https://semver.org/).
Ви можете створювати продакшн-застосунки з **FastAPI** вже зараз (і, ймовірно, робите це вже певний час), просто переконайтеся, що ви використовуєте версію, яка коректно працює з рештою вашого коду.
@@ -34,7 +34,7 @@ fastapi[standard]>=0.112.0,<0.113.0
## Доступні версії { #available-versions }
-Ви можете переглянути доступні версії (наприклад, щоб перевірити поточну останню) в [Примітках до випусків](../release-notes.md){.internal-link target=_blank}.
+Ви можете переглянути доступні версії (наприклад, щоб перевірити поточну останню) в [Примітках до випусків](../release-notes.md).
## Про версії { #about-versions }
@@ -66,7 +66,7 @@ fastapi>=0.45.0,<0.46.0
Ви повинні додати тести для вашого застосунку.
-З **FastAPI** це дуже легко (завдяки Starlette), перегляньте документацію: [Тестування](../tutorial/testing.md){.internal-link target=_blank}
+З **FastAPI** це дуже легко (завдяки Starlette), перегляньте документацію: [Тестування](../tutorial/testing.md)
Після того як у вас є тести, ви можете оновити версію **FastAPI** до новішої і переконатися, що весь ваш код працює правильно, запустивши тести.
diff --git a/docs/uk/docs/editor-support.md b/docs/uk/docs/editor-support.md
new file mode 100644
index 0000000000..f0edf62972
--- /dev/null
+++ b/docs/uk/docs/editor-support.md
@@ -0,0 +1,23 @@
+# Підтримка редакторів { #editor-support }
+
+Офіційне [FastAPI Extension](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) покращує ваш робочий процес розробки FastAPI завдяки виявленню й навігації по *операціях шляху*, а також розгортанню у FastAPI Cloud і потоковому передаванню журналів у реальному часі.
+
+Докладніше про розширення дивіться у README в [репозиторії GitHub](https://github.com/fastapi/fastapi-vscode).
+
+## Налаштування та встановлення { #setup-and-installation }
+
+**FastAPI Extension** доступне для [VS Code](https://code.visualstudio.com/) і [Cursor](https://www.cursor.com/). Його можна встановити безпосередньо з панелі Extensions у кожному редакторі, знайшовши «FastAPI» і вибравши розширення від **FastAPI Labs**. Розширення також працює у браузерних редакторах, таких як [vscode.dev](https://vscode.dev) і [github.dev](https://github.dev).
+
+### Виявлення застосунку { #application-discovery }
+
+Типово розширення автоматично виявляє застосунки FastAPI у вашому робочому просторі, скануючи файли, які створюють екземпляр `FastAPI()`. Якщо автовиявлення не працює для структури вашого проєкту, ви можете вказати точку входу через `[tool.fastapi]` у `pyproject.toml` або налаштування VS Code `fastapi.entryPoint`, використовуючи нотацію модуля (наприклад, `myapp.main:app`).
+
+## Можливості { #features }
+
+- **Провідник операцій шляху** - Бічне деревоподібне представлення всіх
*операцій шляху* у вашому застосунку. Натисніть, щоб перейти до будь-якого визначення маршруту або маршрутизатора.
+- **Пошук маршрутів** - Пошук за шляхом, методом або назвою за допомогою
Ctrl +
Shift +
E (на macOS:
Cmd +
Shift +
E).
+- **Навігація CodeLens** - Клікабельні посилання над викликами тестового клієнта (наприклад, `client.get('/items')`), які переходять до відповідної *операції шляху* для швидкої навігації між тестами та реалізацією.
+- **Розгортання у FastAPI Cloud** - Розгортання вашого застосунку у [FastAPI Cloud](https://fastapicloud.com/) в один клік.
+- **Потокове передавання журналів застосунку** - Потокове передавання журналів у реальному часі з вашого застосунку, розгорнутого у FastAPI Cloud, з фільтруванням за рівнем і пошуком по тексту.
+
+Щоб ознайомитися з можливостями розширення, відкрийте Палітру команд (
Ctrl +
Shift +
P або на macOS:
Cmd +
Shift +
P), виберіть «Welcome: Open walkthrough...», а потім «Get started with FastAPI».
diff --git a/docs/uk/docs/environment-variables.md b/docs/uk/docs/environment-variables.md
index b61fd011f6..7b5223bc21 100644
--- a/docs/uk/docs/environment-variables.md
+++ b/docs/uk/docs/environment-variables.md
@@ -65,7 +65,7 @@ print(f"Hello {name} from Python")
/// tip | Порада
-Другий аргумент до
`os.getenv()` - це значення за замовчуванням, яке буде повернено.
+Другий аргумент до [`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) - це значення за замовчуванням, яке буде повернено.
Якщо його не вказано, за замовчуванням це `None`. Тут ми надаємо `"World"` як значення за замовчуванням.
@@ -153,7 +153,7 @@ Hello World from Python
/// tip | Порада
-Докладніше про це можна прочитати у
The Twelve-Factor App: Config.
+Ви можете прочитати більше у [The Twelve-Factor App: Config](https://12factor.net/config).
///
@@ -163,7 +163,7 @@ Hello World from Python
Це означає, що будь-яке значення, прочитане в Python зі змінної оточення, буде `str`, а будь-яке перетворення до іншого типу або будь-яка перевірка має виконуватися в коді.
-Ви дізнаєтеся більше про використання змінних оточення для роботи з налаштуваннями застосунку в розділі [Просунутий посібник користувача - Налаштування і змінні оточення](./advanced/settings.md){.internal-link target=_blank}.
+Ви дізнаєтеся більше про використання змінних оточення для роботи з налаштуваннями застосунку в розділі [Просунутий посібник користувача - Налаштування і змінні оточення](./advanced/settings.md).
## Змінна оточення `PATH` { #path-environment-variable }
@@ -285,13 +285,13 @@ $ C:\opt\custompython\bin\python
////
-Ця інформація стане у пригоді під час вивчення [Віртуальних середовищ](virtual-environments.md){.internal-link target=_blank}.
+Ця інформація стане у пригоді під час вивчення [Віртуальних середовищ](virtual-environments.md).
## Висновок { #conclusion }
Тепер ви маєте базове розуміння того, що таке змінні оточення і як їх використовувати в Python.
-Також можна прочитати більше у
Вікіпедії про змінну оточення.
+Також можна прочитати більше у [Вікіпедії про змінну оточення](https://en.wikipedia.org/wiki/Environment_variable).
У багатьох випадках не одразу очевидно, як змінні оточення будуть корисними та застосовними. Але вони постійно з’являються в різних сценаріях під час розробки, тож варто про них знати.
diff --git a/docs/uk/docs/fastapi-cli.md b/docs/uk/docs/fastapi-cli.md
index eb55382302..1183c08c0f 100644
--- a/docs/uk/docs/fastapi-cli.md
+++ b/docs/uk/docs/fastapi-cli.md
@@ -1,15 +1,15 @@
# FastAPI CLI { #fastapi-cli }
-**FastAPI CLI** — це програма командного рядка, яку ви можете використовувати, щоб обслуговувати ваш застосунок FastAPI, керувати вашим проєктом FastAPI тощо.
+**FastAPI
CLI** — це програма командного рядка, яку ви можете використовувати, щоб обслуговувати ваш застосунок FastAPI, керувати вашим проєктом FastAPI тощо.
-Коли ви встановлюєте FastAPI (наприклад, за допомогою `pip install "fastapi[standard]"`), він включає пакет під назвою `fastapi-cli`, цей пакет надає команду `fastapi` у терміналі.
+Коли ви встановлюєте FastAPI (наприклад, за допомогою `pip install "fastapi[standard]"`), він постачається з програмою командного рядка, яку можна запускати в терміналі.
Щоб запустити ваш застосунок FastAPI для розробки, ви можете використати команду `fastapi dev`:
```console
-$
fastapi dev
main.py
+$
fastapi dev
FastAPI Starting development server 🚀
@@ -46,13 +46,66 @@ $
fastapi dev
Uvicorn, високопродуктивний, production-ready, ASGI сервер. 😎
+Крім того, інші інструменти можуть не знайти його, наприклад [Розширення VS Code](editor-support.md) або [FastAPI Cloud](https://fastapicloud.com), тому рекомендується використовувати `entrypoint` у `pyproject.toml`.
## `fastapi dev` { #fastapi-dev }
@@ -70,6 +123,6 @@ FastAPI CLI бере шлях до вашої Python-програми (напр
/// tip | Порада
-Ви можете дізнатися більше про це в [документації з розгортання](deployment/index.md){.internal-link target=_blank}.
+Ви можете дізнатися більше про це в [документації з розгортання](deployment/index.md).
///
diff --git a/docs/uk/docs/features.md b/docs/uk/docs/features.md
index db044bf947..0dee012cd5 100644
--- a/docs/uk/docs/features.md
+++ b/docs/uk/docs/features.md
@@ -6,8 +6,8 @@
### На основі відкритих стандартів { #based-on-open-standards }
-* OpenAPI для створення API, включаючи оголошення шляхів, операцій, параметрів, тіл запитів, безпеки тощо.
-* Автоматична документація моделей даних за допомогою JSON Schema (оскільки OpenAPI базується саме на JSON Schema).
+* [**OpenAPI**](https://github.com/OAI/OpenAPI-Specification) для створення API, включаючи оголошення шляхів операцій, параметрів, тіл запитів, безпеки тощо.
+* Автоматична документація моделей даних за допомогою [**JSON Schema**](https://json-schema.org/) (оскільки OpenAPI базується саме на JSON Schema).
* Розроблено на основі цих стандартів після ретельного аналізу, а не як додатковий рівень поверх основної архітектури.
* Це також дає змогу використовувати автоматичну **генерацію клієнтського коду** багатьма мовами.
@@ -15,11 +15,11 @@
Інтерактивна документація API та вебінтерфейси для його дослідження. Оскільки фреймворк базується на OpenAPI, є кілька варіантів, 2 з яких включені за замовчуванням.
-* Swagger UI — з інтерактивним дослідженням, викликом і тестуванням вашого API прямо з браузера.
+* [**Swagger UI**](https://github.com/swagger-api/swagger-ui) — з інтерактивним дослідженням, викликом і тестуванням вашого API прямо з браузера.
-* Альтернативна документація API за допомогою ReDoc.
+* Альтернативна документація API за допомогою [**ReDoc**](https://github.com/Rebilly/ReDoc).
@@ -27,7 +27,7 @@
Усе базується на стандартних оголошеннях **типів Python** (завдяки Pydantic). Жодного нового синтаксису для вивчення. Лише стандартний сучасний Python.
-Якщо вам потрібно 2-хвилинне нагадування про те, як використовувати типи Python (навіть якщо ви не використовуєте FastAPI), перегляньте короткий підручник: [Типи Python](python-types.md){.internal-link target=_blank}.
+Якщо вам потрібно 2-хвилинне нагадування про те, як використовувати типи Python (навіть якщо ви не використовуєте FastAPI), перегляньте короткий підручник: [Типи Python](python-types.md).
Ви пишете стандартний Python з типами:
@@ -71,11 +71,11 @@ my_second_user: User = User(**second_user_data)
///
-### Підтримка редакторів (IDE) { #editor-support }
+### Підтримка редакторів { #editor-support }
Увесь фреймворк спроєктовано так, щоб ним було легко та інтуїтивно користуватися; усі рішення тестувалися у кількох редакторах ще до початку розробки, щоб забезпечити найкращий досвід розробки.
-З опитувань розробників Python зрозуміло що однією з найуживаніших функцій є «автодоповнення».
+З опитувань розробників Python зрозуміло [що однією з найуживаніших функцій є «автодоповнення»](https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features).
Увесь фреймворк **FastAPI** побудований так, щоб це забезпечити. Автодоповнення працює всюди.
@@ -83,11 +83,11 @@ my_second_user: User = User(**second_user_data)
Ось як ваш редактор може вам допомогти:
-* у Visual Studio Code:
+* у [Visual Studio Code](https://code.visualstudio.com/):
-* у PyCharm:
+* у [PyCharm](https://www.jetbrains.com/pycharm/):
@@ -124,7 +124,7 @@ FastAPI має розумні **налаштування за замовчува
Підтримуються всі схеми безпеки, визначені в OpenAPI, включно з:
* HTTP Basic.
-* **OAuth2** (також із підтримкою **JWT tokens**). Перегляньте підручник: [OAuth2 із JWT](tutorial/security/oauth2-jwt.md){.internal-link target=_blank}.
+* **OAuth2** (також із підтримкою **JWT tokens**). Перегляньте підручник: [OAuth2 із JWT](tutorial/security/oauth2-jwt.md).
* Ключі API в:
* Заголовках.
* Параметрах запиту.
@@ -141,7 +141,7 @@ FastAPI містить надзвичайно просту у використа
* Навіть залежності можуть мати власні залежності, утворюючи ієрархію або **«граф» залежностей**.
* Усе **автоматично обробляється** фреймворком.
* Усі залежності можуть вимагати дані із запитів і **розширювати обмеження операції шляху** та автоматичну документацію.
-* **Автоматична валідація** навіть для параметрів *операції шляху*, визначених у залежностях.
+* **Автоматична валідація** навіть для *операції шляху*, визначених у залежностях.
* Підтримка складних систем автентифікації користувачів, **підключень до баз даних** тощо.
* **Жодних компромісів** із базами даних, фронтендами тощо. Але проста інтеграція з усіма ними.
@@ -159,13 +159,13 @@ FastAPI містить надзвичайно просту у використа
## Можливості Starlette { #starlette-features }
-**FastAPI** повністю сумісний із (та побудований на основі) Starlette. Тому будь-який додатковий код Starlette, який ви маєте, також працюватиме.
+**FastAPI** повністю сумісний із (та побудований на основі) [**Starlette**](https://www.starlette.dev/). Тому будь-який додатковий код Starlette, який ви маєте, також працюватиме.
`FastAPI` фактично є підкласом `Starlette`. Тому, якщо ви вже знайомі зі Starlette або використовуєте його, більшість функціональності працюватиме так само.
З **FastAPI** ви отримуєте всі можливості **Starlette** (адже FastAPI — це просто Starlette на стероїдах):
-* Разюча продуктивність. Це один із найшвидших доступних Python-фреймворків, на рівні з **NodeJS** і **Go**.
+* Разюча продуктивність. Це [один із найшвидших доступних Python-фреймворків, на рівні з **NodeJS** і **Go**](https://github.com/encode/starlette#performance).
* Підтримка **WebSocket**.
* Фонові задачі у процесі.
* Події запуску та завершення роботи.
@@ -177,7 +177,7 @@ FastAPI містить надзвичайно просту у використа
## Можливості Pydantic { #pydantic-features }
-**FastAPI** повністю сумісний із (та побудований на основі) Pydantic. Тому будь-який додатковий код Pydantic, який ви маєте, також працюватиме.
+**FastAPI** повністю сумісний із (та побудований на основі) [**Pydantic**](https://docs.pydantic.dev/). Тому будь-який додатковий код Pydantic, який ви маєте, також працюватиме.
Включно із зовнішніми бібліотеками, які також базуються на Pydantic, як-от ORM-и, ODM-и для баз даних.
diff --git a/docs/uk/docs/help-fastapi.md b/docs/uk/docs/help-fastapi.md
index a98e56c260..152bf2e291 100644
--- a/docs/uk/docs/help-fastapi.md
+++ b/docs/uk/docs/help-fastapi.md
@@ -12,7 +12,7 @@
## Підпишіться на розсилку { #subscribe-to-the-newsletter }
-Ви можете підписатися на (нечасту) розсилку [**FastAPI and friends**](newsletter.md){.internal-link target=_blank}, щоб бути в курсі:
+Ви можете підписатися на (нечасту) розсилку [**FastAPI and friends**](newsletter.md), щоб бути в курсі:
* Новин про FastAPI та друзів 🚀
* Посібників 📝
@@ -22,17 +22,17 @@
## Стежте за FastAPI в X (Twitter) { #follow-fastapi-on-x-twitter }
-Стежте за @fastapi в **X (Twitter)**, щоб отримувати найсвіжіші новини про **FastAPI**. 🐦
+[Стежте за @fastapi в **X (Twitter)**](https://x.com/fastapi), щоб отримувати найсвіжіші новини про **FastAPI**. 🐦
## Додайте зірочку **FastAPI** на GitHub { #star-fastapi-in-github }
-Ви можете «поставити зірочку» FastAPI на GitHub (натиснувши кнопку зірочки у верхньому правому куті): https://github.com/fastapi/fastapi. ⭐️
+Ви можете «поставити зірочку» FastAPI на GitHub (натиснувши кнопку зірочки у верхньому правому куті): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). ⭐️
Додавши зірочку, іншим користувачам буде легше його знайти і побачити, що він уже був корисним для інших.
## Стежте за випусками в репозиторії GitHub { #watch-the-github-repository-for-releases }
-Ви можете «спостерігати» за FastAPI на GitHub (натиснувши кнопку «watch» у верхньому правому куті): https://github.com/fastapi/fastapi. 👀
+Ви можете «спостерігати» за FastAPI на GitHub (натиснувши кнопку «watch» у верхньому правому куті): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀
Там ви можете вибрати «Releases only».
@@ -40,45 +40,45 @@
## Зв'яжіться з автором { #connect-with-the-author }
-Ви можете зв'язатися зі мною (Sebastián Ramírez / `tiangolo`), автором.
+Ви можете зв'язатися зі [мною (Sebastián Ramírez / `tiangolo`)](https://tiangolo.com), автором.
Ви можете:
-* Стежити за мною на **GitHub**.
+* [Стежити за мною на **GitHub**](https://github.com/tiangolo).
* Подивитися інші Open Source-проєкти, які я створив і які можуть вам допомогти.
* Стежити, щоб бачити, коли я створюю новий Open Source-проєкт.
-* Стежити за мною в **X (Twitter)** або Mastodon.
+* [Стежити за мною в **X (Twitter)**](https://x.com/tiangolo) або [Mastodon](https://fosstodon.org/@tiangolo).
* Розкажіть мені, як ви використовуєте FastAPI (мені дуже приємно це чути).
* Дізнаватися, коли я роблю оголошення або випускаю нові інструменти.
- * Також ви можете стежити за @fastapi в X (Twitter) (окремий акаунт).
-* Стежити за мною в **LinkedIn**.
+ * Також ви можете [стежити за @fastapi в X (Twitter)](https://x.com/fastapi) (окремий акаунт).
+* [Стежити за мною в **LinkedIn**](https://www.linkedin.com/in/tiangolo/).
* Дізнаватися, коли я роблю оголошення або випускаю нові інструменти (хоча X (Twitter) я використовую частіше 🤷♂).
-* Читати, що я пишу (або стежити за мною) на **Dev.to** або **Medium**.
+* Читати, що я пишу (або стежити за мною) на [**Dev.to**](https://dev.to/tiangolo) або [**Medium**](https://medium.com/@tiangolo).
* Читати інші ідеї, статті та про інструменти, які я створив.
* Стежити, щоб читати нове, коли я щось публікую.
## Твітніть про **FastAPI** { #tweet-about-fastapi }
-Твітніть про **FastAPI** і дайте мені та іншим знати, чому він вам подобається. 🎉
+[Твітніть про **FastAPI**](https://x.com/compose/tweet?text=I'm loving @fastapi because... https://github.com/fastapi/fastapi) і дайте мені та іншим знати, чому він вам подобається. 🎉
Мені дуже подобається дізнаватися, як використовують **FastAPI**, що вам у ньому сподобалося, у якому проєкті/компанії ви його застосовуєте тощо.
## Голосуйте за FastAPI { #vote-for-fastapi }
-* Проголосуйте за **FastAPI** на Slant.
-* Проголосуйте за **FastAPI** на AlternativeTo.
-* Повідомте, що ви використовуєте **FastAPI**, на StackShare.
+* [Проголосуйте за **FastAPI** на Slant](https://www.slant.co/options/34241/~fastapi-review).
+* [Проголосуйте за **FastAPI** на AlternativeTo](https://alternativeto.net/software/fastapi/about/).
+* [Повідомте, що ви використовуєте **FastAPI**, на StackShare](https://stackshare.io/pypi-fastapi).
## Допомагайте іншим з питаннями на GitHub { #help-others-with-questions-in-github }
Ви можете спробувати допомагати іншим з їхніми питаннями у:
-* GitHub Discussions
-* GitHub Issues
+* [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered)
+* [GitHub Issues](https://github.com/fastapi/fastapi/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Aquestion+-label%3Aanswered+)
У багатьох випадках ви вже можете знати відповідь на ці питання. 🤓
-Якщо ви багато допомагаєте людям із їхніми питаннями, ви станете офіційним [Експертом FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}. 🎉
+Якщо ви багато допомагаєте людям із їхніми питаннями, ви станете офіційним [Експертом FastAPI](fastapi-people.md#fastapi-experts). 🎉
Пам'ятайте, найважливіше: намагайтеся бути добрими. Люди приходять зі своєю фрустрацією і часто питають не найкращим чином, але постарайтеся бути якомога доброзичливішими. 🤗
@@ -104,7 +104,7 @@
Часто вони наводять лише фрагмент коду, але цього недостатньо, щоб **відтворити проблему**.
-* Ви можете попросити надати мінімальний, відтворюваний приклад, який ви зможете **скопіювати-вставити** і запустити локально, щоб побачити ту саму помилку або поведінку, яку бачать вони, або краще зрозуміти їхній варіант використання.
+* Ви можете попросити надати [мінімальний, відтворюваний приклад](https://stackoverflow.com/help/minimal-reproducible-example), який ви зможете **скопіювати-вставити** і запустити локально, щоб побачити ту саму помилку або поведінку, яку бачать вони, або краще зрозуміти їхній варіант використання.
* Якщо ви дуже щедрі, можете спробувати **створити такий приклад** самостійно, лише на основі опису проблеми. Просто майте на увазі, що це може зайняти багато часу, і краще спочатку попросити їх уточнити проблему.
@@ -125,7 +125,7 @@
## Стежте за репозиторієм GitHub { #watch-the-github-repository }
-Ви можете «спостерігати» за FastAPI на GitHub (натиснувши кнопку «watch» у верхньому правому куті): https://github.com/fastapi/fastapi. 👀
+Ви можете «спостерігати» за FastAPI на GitHub (натиснувши кнопку «watch» у верхньому правому куті): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀
Якщо вибрати «Watching» замість «Releases only», ви отримуватимете сповіщення, коли хтось створює нове issue або питання. Ви також можете вказати, що хочете отримувати сповіщення лише про нові issues, або discussions, або PR тощо.
@@ -133,7 +133,7 @@
## Ставте питання { #ask-questions }
-Ви можете створити нове питання у репозиторії GitHub, наприклад, щоб:
+Ви можете [створити нове питання](https://github.com/fastapi/fastapi/discussions/new?category=questions) у репозиторії GitHub, наприклад, щоб:
* Поставити **питання** або запитати про **проблему**.
* Запропонувати нову **можливість**.
@@ -170,7 +170,7 @@
* Потім залиште **коментар**, що ви це зробили, так я знатиму, що ви справді перевірили.
-/// info | Інформація
+/// info
На жаль, я не можу просто довіряти PR, які мають кілька схвалень.
@@ -196,12 +196,12 @@
## Створіть запит на витяг { #create-a-pull-request }
-Ви можете [зробити внесок](contributing.md){.internal-link target=_blank} у вихідний код із запитами на витяг, наприклад:
+Ви можете [зробити внесок](contributing.md) у вихідний код із запитами на витяг, наприклад:
* Щоб виправити описку, знайдену в документації.
-* Щоб поділитися статтею, відео або подкастом про FastAPI, який ви створили або знайшли, відредагувавши цей файл.
+* Щоб поділитися статтею, відео або подкастом про FastAPI, який ви створили або знайшли, [відредагувавши цей файл](https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml).
* Обов'язково додайте ваше посилання на початок відповідного розділу.
-* Щоб допомогти [перекласти документацію](contributing.md#translations){.internal-link target=_blank} вашою мовою.
+* Щоб допомогти [перекласти документацію](contributing.md#translations) вашою мовою.
* Ви також можете допомогти з переглядом перекладів, створених іншими.
* Щоб запропонувати нові розділи документації.
* Щоб виправити наявну проблему/помилку.
@@ -218,8 +218,8 @@
Основні завдання, які ви можете виконувати вже зараз:
-* [Допомагайте іншим з питаннями на GitHub](#help-others-with-questions-in-github){.internal-link target=_blank} (див. розділ вище).
-* [Переглядайте запити на витяг](#review-pull-requests){.internal-link target=_blank} (див. розділ вище).
+* [Допомагайте іншим з питаннями на GitHub](#help-others-with-questions-in-github) (див. розділ вище).
+* [Переглядайте запити на витяг](#review-pull-requests) (див. розділ вище).
Ці два завдання **найбільше споживають час**. Це основна робота з підтримки FastAPI.
@@ -227,11 +227,11 @@
## Долучайтеся до чату { #join-the-chat }
-Долучайтеся до 👥 серверу чату Discord 👥 і спілкуйтеся з іншими в спільноті FastAPI.
+Долучайтеся до 👥 [серверу чату Discord](https://discord.gg/VQjSZaeJmf) 👥 і спілкуйтеся з іншими в спільноті FastAPI.
-/// tip | Порада
+/// tip
-Для запитань ставте їх у GitHub Discussions, там значно вища ймовірність, що вам допоможуть [Експерти FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}.
+Для запитань ставте їх у [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/new?category=questions), там значно вища ймовірність, що вам допоможуть [Експерти FastAPI](fastapi-people.md#fastapi-experts).
Використовуйте чат лише для інших загальних розмов.
@@ -243,13 +243,13 @@
У GitHub шаблон підкаже вам, як написати правильне питання, щоб ви легше отримали хорошу відповідь, або навіть вирішили проблему самостійно ще до запиту. І в GitHub я можу гарантувати, що завжди на все відповім, навіть якщо це займе трохи часу. Особисто я не можу робити це в чатах. 😅
-Розмови в чатах також не так просто шукати, як у GitHub, тож питання та відповіді можуть загубитися. І лише ті, що в GitHub, зараховуються, щоб стати [Експертом FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}, тож швидше за все ви отримаєте більше уваги саме в GitHub.
+Розмови в чатах також не так просто шукати, як у GitHub, тож питання та відповіді можуть загубитися. І лише ті, що в GitHub, зараховуються, щоб стати [Експертом FastAPI](fastapi-people.md#fastapi-experts), тож швидше за все ви отримаєте більше уваги саме в GitHub.
З іншого боку, у чатах є тисячі користувачів, тож дуже ймовірно, що ви майже завжди знайдете там співрозмовника. 😄
## Спонсоруйте автора { #sponsor-the-author }
-Якщо ваш **продукт/компанія** залежить від **FastAPI** або пов'язана з ним і ви хочете охопити його користувачів, ви можете спонсорувати автора (мене) через GitHub sponsors. Залежно від рівня ви можете отримати додаткові переваги, наприклад значок у документації. 🎁
+Якщо ваш **продукт/компанія** залежить від **FastAPI** або пов'язана з ним і ви хочете охопити його користувачів, ви можете спонсорувати автора (мене) через [GitHub sponsors](https://github.com/sponsors/tiangolo). Залежно від рівня ви можете отримати додаткові переваги, наприклад значок у документації. 🎁
---
diff --git a/docs/uk/docs/history-design-future.md b/docs/uk/docs/history-design-future.md
index 1897807c84..621885904a 100644
--- a/docs/uk/docs/history-design-future.md
+++ b/docs/uk/docs/history-design-future.md
@@ -1,6 +1,6 @@
# Історія, проєктування і майбутнє { #history-design-and-future }
-Деякий час тому користувач **FastAPI** запитав:
+Деякий час тому [користувач **FastAPI** запитав](https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920):
> Яка історія цього проєкту? Здається, він нізвідки за кілька тижнів став чудовим [...]
@@ -14,7 +14,7 @@
Історія **FastAPI** значною мірою - це історія його попередників.
-Як сказано в розділі [Альтернативи](alternatives.md){.internal-link target=_blank}:
+Як сказано в розділі [Альтернативи](alternatives.md):
@@ -44,7 +44,7 @@
Я протестував кілька ідей у найпопулярніших Python-редакторах: PyCharm, VS Code, редакторах на основі Jedi.
-За даними Python Developer Survey, це охоплює близько 80% користувачів.
+За даними [Python Developer Survey](https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools), це охоплює близько 80% користувачів.
Це означає, що **FastAPI** спеціально тестувався з редакторами, якими користуються 80% розробників Python. І оскільки більшість інших редакторів працюють подібно, усі ці переваги мають працювати практично у всіх редакторах.
@@ -54,11 +54,11 @@
## Вимоги { #requirements }
-Після перевірки кількох альтернатив я вирішив використовувати **Pydantic** через його переваги.
+Після перевірки кількох альтернатив я вирішив використовувати [**Pydantic**](https://docs.pydantic.dev/) через його переваги.
Потім я зробив внески до нього, щоб зробити його повністю сумісним із Схемою JSON, додати підтримку різних способів оголошення обмежень і поліпшити підтримку редакторів (перевірки типів, автодоповнення) на основі тестів у кількох редакторах.
-Під час розробки я також зробив внески до **Starlette**, іншої ключової залежності.
+Під час розробки я також зробив внески до [**Starlette**](https://www.starlette.dev/), іншої ключової залежності.
## Розробка { #development }
@@ -76,4 +76,4 @@
**FastAPI** має велике майбутнє.
-І [ваша допомога](help-fastapi.md){.internal-link target=_blank} дуже цінується.
+І [ваша допомога](help-fastapi.md) дуже цінується.
diff --git a/docs/uk/docs/how-to/authentication-error-status-code.md b/docs/uk/docs/how-to/authentication-error-status-code.md
index 58016f261b..d670713711 100644
--- a/docs/uk/docs/how-to/authentication-error-status-code.md
+++ b/docs/uk/docs/how-to/authentication-error-status-code.md
@@ -2,7 +2,7 @@
До версії FastAPI `0.122.0`, коли інтегровані засоби безпеки повертали клієнту помилку після невдалої автентифікації, вони використовували HTTP код статусу `403 Forbidden`.
-Починаючи з версії FastAPI `0.122.0`, вони використовують більш доречний HTTP код статусу `401 Unauthorized` і повертають змістовний заголовок `WWW-Authenticate` у відповіді, відповідно до специфікацій HTTP, RFC 7235, RFC 9110.
+Починаючи з версії FastAPI `0.122.0`, вони використовують більш доречний HTTP код статусу `401 Unauthorized` і повертають змістовний заголовок `WWW-Authenticate` у відповіді, відповідно до специфікацій HTTP, [RFC 7235](https://datatracker.ietf.org/doc/html/rfc7235#section-3.1), [RFC 9110](https://datatracker.ietf.org/doc/html/rfc9110#name-401-unauthorized).
Але якщо з якоїсь причини ваші клієнти залежать від старої поведінки, ви можете повернутися до неї, переписавши метод `make_not_authenticated_error` у ваших класах безпеки.
diff --git a/docs/uk/docs/how-to/conditional-openapi.md b/docs/uk/docs/how-to/conditional-openapi.md
index f8bbaa6498..80c22eeb5d 100644
--- a/docs/uk/docs/how-to/conditional-openapi.md
+++ b/docs/uk/docs/how-to/conditional-openapi.md
@@ -4,13 +4,13 @@
## Про безпеку, API та документацію { #about-security-apis-and-docs }
-Приховування інтерфейсів документації у продукційному середовищі *не має* бути способом захисту вашого API.
+Приховування інтерфейсів документації у продукційному середовищі не має бути способом захисту вашого API.
-Це не додає жодної додаткової безпеки вашому API, *операції шляху* й надалі будуть доступні там, де вони є.
+Це не додає жодної додаткової безпеки вашому API, операції шляху й надалі будуть доступні там, де вони є.
Якщо у вашому коді є вразливість, вона залишиться.
-Приховування документації лише ускладнює розуміння того, як взаємодіяти з вашим API, і може ускладнити для вас його налагодження у продакшні. Це можна вважати просто формою Безпека через неясність.
+Приховування документації лише ускладнює розуміння того, як взаємодіяти з вашим API, і може ускладнити для вас його налагодження у продакшні. Це можна вважати просто формою [Безпека через неясність](https://en.wikipedia.org/wiki/Security_through_obscurity).
Якщо ви хочете захистити ваш API, є кілька кращих дій, які ви можете зробити, наприклад:
diff --git a/docs/uk/docs/how-to/configure-swagger-ui.md b/docs/uk/docs/how-to/configure-swagger-ui.md
index f8c4470dfa..5fe47d12e6 100644
--- a/docs/uk/docs/how-to/configure-swagger-ui.md
+++ b/docs/uk/docs/how-to/configure-swagger-ui.md
@@ -1,6 +1,6 @@
# Налаштуйте Swagger UI { #configure-swagger-ui }
-Ви можете налаштувати додаткові параметри Swagger UI.
+Ви можете налаштувати додаткові [параметри Swagger UI](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/).
Щоб їх налаштувати, передайте аргумент `swagger_ui_parameters` під час створення об’єкта додатка `FastAPI()` або до функції `get_swagger_ui_html()`.
@@ -50,7 +50,7 @@ FastAPI містить деякі параметри конфігурації з
## Інші параметри Swagger UI { #other-swagger-ui-parameters }
-Щоб побачити всі можливі налаштування, які ви можете використовувати, прочитайте офіційну документацію щодо параметрів Swagger UI.
+Щоб побачити всі можливі налаштування, які ви можете використовувати, прочитайте офіційну [документацію щодо параметрів Swagger UI](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/).
## Налаштування лише для JavaScript { #javascript-only-settings }
diff --git a/docs/uk/docs/how-to/custom-docs-ui-assets.md b/docs/uk/docs/how-to/custom-docs-ui-assets.md
index faea3ccc4a..f8a4f99662 100644
--- a/docs/uk/docs/how-to/custom-docs-ui-assets.md
+++ b/docs/uk/docs/how-to/custom-docs-ui-assets.md
@@ -54,7 +54,7 @@ Swagger UI впорається з цим «за лаштунками», але
### Перевірте { #test-it }
-Тепер ви маєте змогу відкрити документацію за http://127.0.0.1:8000/docs і перезавантажити сторінку, вона завантажить ці ресурси з нового CDN.
+Тепер ви маєте змогу відкрити документацію за [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) і перезавантажити сторінку, вона завантажить ці ресурси з нового CDN.
## Самохостинг JavaScript і CSS для документації { #self-hosting-javascript-and-css-for-docs }
@@ -93,12 +93,12 @@ Swagger UI впорається з цим «за лаштунками», але
**Swagger UI** використовує файли:
-- `swagger-ui-bundle.js`
-- `swagger-ui.css`
+- [`swagger-ui-bundle.js`](https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js)
+- [`swagger-ui.css`](https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css)
А **ReDoc** використовує файл:
-- `redoc.standalone.js`
+- [`redoc.standalone.js`](https://cdn.jsdelivr.net/npm/redoc@2/bundles/redoc.standalone.js)
Після цього ваша структура файлів може виглядати так:
@@ -122,7 +122,7 @@ Swagger UI впорається з цим «за лаштунками», але
### Перевірте статичні файли { #test-the-static-files }
-Запустіть ваш застосунок і перейдіть до http://127.0.0.1:8000/static/redoc.standalone.js.
+Запустіть ваш застосунок і перейдіть до [http://127.0.0.1:8000/static/redoc.standalone.js](http://127.0.0.1:8000/static/redoc.standalone.js).
Ви маєте побачити дуже довгий файл JavaScript для **ReDoc**.
@@ -180,6 +180,6 @@ Swagger UI впорається з цим «за лаштунками», але
### Перевірте UI зі статичними файлами { #test-static-files-ui }
-Тепер ви маєте змогу вимкнути WiFi, відкрити документацію за http://127.0.0.1:8000/docs і перезавантажити сторінку.
+Тепер ви маєте змогу вимкнути WiFi, відкрити документацію за [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) і перезавантажити сторінку.
І навіть без Інтернету ви зможете побачити документацію для вашого API і взаємодіяти з ним.
diff --git a/docs/uk/docs/how-to/custom-request-and-route.md b/docs/uk/docs/how-to/custom-request-and-route.md
index 9f21da7a86..6a46b57239 100644
--- a/docs/uk/docs/how-to/custom-request-and-route.md
+++ b/docs/uk/docs/how-to/custom-request-and-route.md
@@ -18,7 +18,7 @@
Деякі варіанти використання:
-- Перетворення не-JSON тіл запитів на JSON (наприклад, `msgpack`).
+- Перетворення не-JSON тіл запитів на JSON (наприклад, [`msgpack`](https://msgpack.org/index.html)).
- Розпакування тіл запитів, стиснених gzip.
- Автоматичне логування всіх тіл запитів.
@@ -32,7 +32,7 @@
/// tip | Порада
-Це навчальний приклад, щоб продемонструвати принцип роботи. Якщо вам потрібна підтримка Gzip, скористайтеся вбудованим [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware){.internal-link target=_blank}.
+Це навчальний приклад, щоб продемонструвати принцип роботи. Якщо вам потрібна підтримка Gzip, скористайтеся вбудованим [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware).
///
@@ -66,7 +66,7 @@
І саме ці дві сутності - `scope` та `receive` - потрібні для створення нового екземпляра `Request`.
-Щоб дізнатися більше про `Request`, перегляньте документацію Starlette про запити.
+Щоб дізнатися більше про `Request`, перегляньте [документацію Starlette про запити](https://www.starlette.dev/requests/).
///
@@ -82,7 +82,7 @@
/// tip | Порада
-Щоб розв’язати це саме завдання, скоріш за все, простіше використати `body` у користувацькому обробнику `RequestValidationError` ([Обробка помилок](../tutorial/handling-errors.md#use-the-requestvalidationerror-body){.internal-link target=_blank}).
+Щоб розв’язати це саме завдання, скоріш за все, простіше використати `body` у користувацькому обробнику `RequestValidationError` ([Обробка помилок](../tutorial/handling-errors.md#use-the-requestvalidationerror-body)).
Але цей приклад усе ще корисний і показує, як взаємодіяти з внутрішніми компонентами.
diff --git a/docs/uk/docs/how-to/extending-openapi.md b/docs/uk/docs/how-to/extending-openapi.md
index 1597cbc762..fcd0982a9d 100644
--- a/docs/uk/docs/how-to/extending-openapi.md
+++ b/docs/uk/docs/how-to/extending-openapi.md
@@ -37,7 +37,7 @@
Використовуючи наведене вище, ви можете скористатися тією ж утилітарною функцією для генерації схеми OpenAPI і переписати потрібні частини.
-Наприклад, додаймо розширення OpenAPI для ReDoc для додавання власного логотипа.
+Наприклад, додаймо [розширення OpenAPI ReDoc для додавання власного логотипа](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo).
### Звичайний **FastAPI** { #normal-fastapi }
@@ -75,6 +75,6 @@
### Перевірте { #check-it }
-Коли ви перейдете за адресою http://127.0.0.1:8000/redoc, побачите, що використовується ваш власний логотип (у цьому прикладі логотип **FastAPI**):
+Коли ви перейдете за адресою [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc), побачите, що використовується ваш власний логотип (у цьому прикладі логотип **FastAPI**):
diff --git a/docs/uk/docs/how-to/general.md b/docs/uk/docs/how-to/general.md
index f33ae195c6..75761dff53 100644
--- a/docs/uk/docs/how-to/general.md
+++ b/docs/uk/docs/how-to/general.md
@@ -4,36 +4,40 @@
## Фільтрування даних - Безпека { #filter-data-security }
-Щоб гарантувати, що ви не повертаєте більше даних, ніж слід, прочитайте документацію [Навчальний посібник - Модель відповіді - Тип повернення](../tutorial/response-model.md){.internal-link target=_blank}.
+Щоб гарантувати, що ви не повертаєте більше даних, ніж слід, прочитайте документацію [Навчальний посібник - Модель відповіді - Тип повернення](../tutorial/response-model.md).
+
+## Оптимізувати продуктивність відповіді - Модель відповіді - Тип повернення { #optimize-response-performance-response-model-return-type }
+
+Щоб оптимізувати продуктивність під час повернення даних JSON, використовуйте тип повернення або модель відповіді, таким чином Pydantic виконуватиме серіалізацію в JSON на боці Rust, без проходження через Python. Докладніше читайте в документації [Навчальний посібник - Модель відповіді - Тип повернення](../tutorial/response-model.md).
## Мітки документації - OpenAPI { #documentation-tags-openapi }
-Щоб додати мітки до ваших *операцій шляху* та згрупувати їх в інтерфейсі документації, прочитайте документацію [Навчальний посібник - Налаштування операції шляху - Мітки](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}.
+Щоб додати мітки до ваших *операцій шляху* та згрупувати їх в інтерфейсі документації, прочитайте документацію [Навчальний посібник - Налаштування операції шляху - Мітки](../tutorial/path-operation-configuration.md#tags).
## Короткий опис і опис - OpenAPI { #documentation-summary-and-description-openapi }
-Щоб додати короткий опис і опис до ваших *операцій шляху* і показати їх в інтерфейсі документації, прочитайте документацію [Навчальний посібник - Налаштування операції шляху - Короткий опис і опис](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank}.
+Щоб додати короткий опис і опис до ваших *операцій шляху* і показати їх в інтерфейсі документації, прочитайте документацію [Навчальний посібник - Налаштування операції шляху - Короткий опис і опис](../tutorial/path-operation-configuration.md#summary-and-description).
## Опис відповіді в документації - OpenAPI { #documentation-response-description-openapi }
-Щоб визначити опис відповіді, що відображається в інтерфейсі документації, прочитайте документацію [Навчальний посібник - Налаштування операції шляху - Опис відповіді](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}.
+Щоб визначити опис відповіді, що відображається в інтерфейсі документації, прочитайте документацію [Навчальний посібник - Налаштування операції шляху - Опис відповіді](../tutorial/path-operation-configuration.md#response-description).
## Позначити застарілою *операцію шляху* - OpenAPI { #documentation-deprecate-a-path-operation-openapi }
-Щоб позначити *операцію шляху* як застарілу і показати це в інтерфейсі документації, прочитайте документацію [Навчальний посібник - Налаштування операції шляху - Позначення як застаріле](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}.
+Щоб позначити *операцію шляху* як застарілу і показати це в інтерфейсі документації, прочитайте документацію [Навчальний посібник - Налаштування операції шляху - Позначення як застаріле](../tutorial/path-operation-configuration.md#deprecate-a-path-operation).
## Перетворити будь-які дані на сумісні з JSON { #convert-any-data-to-json-compatible }
-Щоб перетворити будь-які дані на сумісні з JSON, прочитайте документацію [Навчальний посібник - Кодувальник, сумісний з JSON](../tutorial/encoder.md){.internal-link target=_blank}.
+Щоб перетворити будь-які дані на сумісні з JSON, прочитайте документацію [Навчальний посібник - Кодувальник, сумісний з JSON](../tutorial/encoder.md).
## Метадані OpenAPI - Документація { #openapi-metadata-docs }
-Щоб додати метадані до вашої схеми OpenAPI, зокрема ліцензію, версію, контактні дані тощо, прочитайте документацію [Навчальний посібник - Метадані та URL документації](../tutorial/metadata.md){.internal-link target=_blank}.
+Щоб додати метадані до вашої схеми OpenAPI, зокрема ліцензію, версію, контактні дані тощо, прочитайте документацію [Навчальний посібник - Метадані та URL документації](../tutorial/metadata.md).
## Власний URL OpenAPI { #openapi-custom-url }
-Щоб налаштувати URL OpenAPI (або прибрати його), прочитайте документацію [Навчальний посібник - Метадані та URL документації](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}.
+Щоб налаштувати URL OpenAPI (або прибрати його), прочитайте документацію [Навчальний посібник - Метадані та URL документації](../tutorial/metadata.md#openapi-url).
## URL документації OpenAPI { #openapi-docs-urls }
-Щоб оновити URL, які використовуються для автоматично згенерованих інтерфейсів користувача документації, прочитайте документацію [Навчальний посібник - Метадані та URL документації](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}.
+Щоб оновити URL, які використовуються для автоматично згенерованих інтерфейсів користувача документації, прочитайте документацію [Навчальний посібник - Метадані та URL документації](../tutorial/metadata.md#docs-urls).
diff --git a/docs/uk/docs/how-to/graphql.md b/docs/uk/docs/how-to/graphql.md
index 2d0e355ea4..c070c7e0cd 100644
--- a/docs/uk/docs/how-to/graphql.md
+++ b/docs/uk/docs/how-to/graphql.md
@@ -18,18 +18,18 @@ GraphQL розв’язує деякі дуже специфічні сцена
Ось деякі бібліотеки GraphQL з підтримкою ASGI. Ви можете використовувати їх із FastAPI:
-* Strawberry 🍓
- * З документацією для FastAPI
-* Ariadne
- * З документацією для FastAPI
-* Tartiflette
- * З Tartiflette ASGI для інтеграції з ASGI
-* Graphene
- * З starlette-graphene3
+* [Strawberry](https://strawberry.rocks/) 🍓
+ * З [документацією для FastAPI](https://strawberry.rocks/docs/integrations/fastapi)
+* [Ariadne](https://ariadnegraphql.org/)
+ * З [документацією для FastAPI](https://ariadnegraphql.org/docs/fastapi-integration)
+* [Tartiflette](https://tartiflette.io/)
+ * З [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) для інтеграції з ASGI
+* [Graphene](https://graphene-python.org/)
+ * З [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3)
## GraphQL зі Strawberry { #graphql-with-strawberry }
-Якщо вам потрібен або ви хочете використовувати GraphQL, Strawberry - рекомендована бібліотека, адже її дизайн найближчий до дизайну FastAPI; усе базується на анотаціях типів.
+Якщо вам потрібен або ви хочете використовувати GraphQL, [Strawberry](https://strawberry.rocks/) - рекомендована бібліотека, адже її дизайн найближчий до дизайну FastAPI; усе базується на анотаціях типів.
Залежно від вашого сценарію використання ви можете надати перевагу іншій бібліотеці, але якби ви запитали мене, я, ймовірно, порадив би спробувати Strawberry.
@@ -37,24 +37,24 @@ GraphQL розв’язує деякі дуже специфічні сцена
{* ../../docs_src/graphql_/tutorial001_py310.py hl[3,22,25] *}
-Більше про Strawberry ви можете дізнатися в документації Strawberry.
+Більше про Strawberry ви можете дізнатися в [документації Strawberry](https://strawberry.rocks/).
-І також документацію про Strawberry з FastAPI.
+І також [документацію про Strawberry з FastAPI](https://strawberry.rocks/docs/integrations/fastapi).
## Застарілий `GraphQLApp` зі Starlette { #older-graphqlapp-from-starlette }
-Попередні версії Starlette містили клас `GraphQLApp` для інтеграції з Graphene.
+Попередні версії Starlette містили клас `GraphQLApp` для інтеграції з [Graphene](https://graphene-python.org/).
-Його вилучено з Starlette як застарілий, але якщо у вас є код, що його використовував, ви можете легко мігрувати на starlette-graphene3, який покриває той самий сценарій використання та має майже ідентичний інтерфейс.
+Його вилучено з Starlette як застарілий, але якщо у вас є код, що його використовував, ви можете легко мігрувати на [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3), який покриває той самий сценарій використання та має майже ідентичний інтерфейс.
/// tip | Порада
-Якщо вам потрібен GraphQL, я все ж рекомендую звернути увагу на Strawberry, адже він базується на анотаціях типів, а не на власних класах і типах.
+Якщо вам потрібен GraphQL, я все ж рекомендую звернути увагу на [Strawberry](https://strawberry.rocks/), адже він базується на анотаціях типів, а не на власних класах і типах.
///
## Дізнайтеся більше { #learn-more }
-Ви можете дізнатися більше про GraphQL в офіційній документації GraphQL.
+Ви можете дізнатися більше про GraphQL в [офіційній документації GraphQL](https://graphql.org/).
Також ви можете почитати більше про кожну з цих бібліотек за наведеними посиланнями.
diff --git a/docs/uk/docs/how-to/index.md b/docs/uk/docs/how-to/index.md
index ac2dd16eb9..db72181a35 100644
--- a/docs/uk/docs/how-to/index.md
+++ b/docs/uk/docs/how-to/index.md
@@ -8,6 +8,6 @@
/// tip | Порада
-Якщо ви хочете **вивчити FastAPI** у структурований спосіб (рекомендується), натомість прочитайте [Навчальний посібник - Посібник користувача](../tutorial/index.md){.internal-link target=_blank} розділ за розділом.
+Якщо ви хочете **вивчити FastAPI** у структурований спосіб (рекомендується), натомість прочитайте [Навчальний посібник - Посібник користувача](../tutorial/index.md) розділ за розділом.
///
diff --git a/docs/uk/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md b/docs/uk/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
index 0f5d1c924e..c5519b98d8 100644
--- a/docs/uk/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
+++ b/docs/uk/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
@@ -22,7 +22,7 @@ FastAPI 0.126.0 припинив підтримку Pydantic v1, водноча
## Офіційний посібник { #official-guide }
-У Pydantic є офіційний Посібник з міграції з v1 на v2.
+У Pydantic є офіційний [Посібник з міграції](https://docs.pydantic.dev/latest/migration/) з v1 на v2.
Там описано, що змінилося, як перевірки тепер стали коректнішими та суворішими, можливі застереження тощо.
@@ -30,7 +30,7 @@ FastAPI 0.126.0 припинив підтримку Pydantic v1, водноча
## Тести { #tests }
-Переконайтеся, що у вашій програмі є [тести](../tutorial/testing.md){.internal-link target=_blank} і що ви запускаєте їх у системі безперервної інтеграції (CI).
+Переконайтеся, що у вашій програмі є [тести](../tutorial/testing.md) і що ви запускаєте їх у системі безперервної інтеграції (CI).
Так ви зможете виконати оновлення і впевнитися, що все працює як очікується.
@@ -38,7 +38,7 @@ FastAPI 0.126.0 припинив підтримку Pydantic v1, водноча
У багатьох випадках, якщо ви використовуєте звичайні моделі Pydantic без налаштувань, більшу частину процесу міграції з Pydantic v1 на Pydantic v2 можна автоматизувати.
-Ви можете скористатися `bump-pydantic` від тієї ж команди Pydantic.
+Ви можете скористатися [`bump-pydantic`](https://github.com/pydantic/bump-pydantic) від тієї ж команди Pydantic.
Цей інструмент допоможе автоматично змінити більшість коду, який потрібно змінити.
diff --git a/docs/uk/docs/how-to/testing-database.md b/docs/uk/docs/how-to/testing-database.md
index 2e6b21ced0..0f12b9d529 100644
--- a/docs/uk/docs/how-to/testing-database.md
+++ b/docs/uk/docs/how-to/testing-database.md
@@ -1,7 +1,7 @@
# Тестування бази даних { #testing-a-database }
-Ви можете ознайомитися з базами даних, SQL і SQLModel у документації SQLModel. 🤓
+Ви можете ознайомитися з базами даних, SQL і SQLModel у [документації SQLModel](https://sqlmodel.tiangolo.com/). 🤓
-Є невеликий навчальний посібник про використання SQLModel з FastAPI. ✨
+Є невеликий [навчальний посібник про використання SQLModel з FastAPI](https://sqlmodel.tiangolo.com/tutorial/fastapi/). ✨
-Цей навчальний посібник містить розділ про тестування баз даних SQL. 😎
+Цей навчальний посібник містить розділ про [тестування баз даних SQL](https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/). 😎
diff --git a/docs/uk/docs/index.md b/docs/uk/docs/index.md
index 0a6788502a..06bf865d92 100644
--- a/docs/uk/docs/index.md
+++ b/docs/uk/docs/index.md
@@ -11,25 +11,25 @@
Фреймворк FastAPI - це висока продуктивність, легко вивчати, швидко писати код, готовий до продакшину
-
+
-
+
-
+
-
+
---
-**Документація**: https://fastapi.tiangolo.com
+**Документація**: [https://fastapi.tiangolo.com](https://fastapi.tiangolo.com/uk)
-**Вихідний код**: https://github.com/fastapi/fastapi
+**Вихідний код**: [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi)
---
@@ -44,7 +44,7 @@ FastAPI - це сучасний, швидкий (високопродуктив
* **Простий**: спроєктований так, щоб бути простим у використанні та вивченні. Менше часу на читання документації.
* **Короткий**: мінімізує дублювання коду. Кілька можливостей з кожного оголошення параметра. Менше помилок.
* **Надійний**: ви отримуєте код, готовий до продакшину. З автоматичною інтерактивною документацією.
-* **Заснований на стандартах**: базується на (і повністю сумісний з) відкритими стандартами для API: OpenAPI (раніше відомий як Swagger) та JSON Schema.
+* **Заснований на стандартах**: базується на (і повністю сумісний з) відкритими стандартами для API: [OpenAPI](https://github.com/OAI/OpenAPI-Specification) (раніше відомий як Swagger) та [JSON Schema](https://json-schema.org/).
* оцінка на основі тестів, проведених внутрішньою командою розробників, що створює продакшн-застосунки.
@@ -55,51 +55,51 @@ FastAPI - це сучасний, швидкий (високопродуктив
### Ключовий спонсор { #keystone-sponsor }
{% for sponsor in sponsors.keystone -%}
-
+
{% endfor -%}
### Золоті та срібні спонсори { #gold-and-silver-sponsors }
{% for sponsor in sponsors.gold -%}
-
+
{% endfor -%}
{%- for sponsor in sponsors.silver -%}
-
+
{% endfor %}
-Інші спонсори
+[Інші спонсори](https://fastapi.tiangolo.com/uk/fastapi-people/#sponsors)
## Враження { #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._"
-Kabir Khan -
Microsoft (ref)Kabir Khan -
Microsoft (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Brian Okken -
[Python Bytes](https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855) podcast host (ref)Timothy Crosley -
[Hug](https://github.com/hugapi/hug) creator (ref)Ines Montani - Matthew Honnibal -
[Explosion AI](https://explosion.ai) founders - [spaCy](https://spacy.io) creators (ref) -
(ref)Deon Pillsbury -
Cisco (ref)Deon Pillsbury -
Cisco (ref)
@@ -199,7 +199,7 @@ async def read_item(item_id: int, q: str | None = None):
**Примітка**:
-Якщо ви не знаєте, перегляньте розділ _"In a hurry?"_ про
`async` та `await` у документації.
+Якщо ви не знаєте, перегляньте розділ _"In a hurry?"_ про [`async` та `await` у документації](https://fastapi.tiangolo.com/uk/async/#in-a-hurry).
@@ -210,7 +210,7 @@ async def read_item(item_id: int, q: str | None = None):
```console
-$ fastapi dev main.py
+$ fastapi dev
╭────────── FastAPI CLI - Development mode ───────────╮
│ │
@@ -235,19 +235,19 @@ INFO: Application startup complete.
-Про команду fastapi dev main.py...
+Про команду fastapi dev...
-Команда `fastapi dev` читає ваш файл `main.py`, знаходить у ньому застосунок **FastAPI** і запускає сервер за допомогою Uvicorn.
+Команда `fastapi dev` автоматично читає ваш файл `main.py`, знаходить у ньому застосунок **FastAPI** і запускає сервер за допомогою [Uvicorn](https://www.uvicorn.dev).
За замовчуванням `fastapi dev` запускається з авто-перезавантаженням для локальної розробки.
-Докладніше читайте в документації FastAPI CLI.
+Докладніше читайте в [документації FastAPI CLI](https://fastapi.tiangolo.com/uk/fastapi-cli/).
### Перевірте { #check-it }
-Відкрийте браузер і перейдіть на
http://127.0.0.1:8000/items/5?q=somequery.
+Відкрийте браузер і перейдіть на [http://127.0.0.1:8000/items/5?q=somequery](http://127.0.0.1:8000/items/5?q=somequery).
Ви побачите JSON-відповідь:
@@ -264,17 +264,17 @@ INFO: Application startup complete.
### Інтерактивна документація API { #interactive-api-docs }
-Тепер перейдіть на
http://127.0.0.1:8000/docs.
+Тепер перейдіть на [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
-Ви побачите автоматичну інтерактивну документацію API (надану
Swagger UI):
+Ви побачите автоматичну інтерактивну документацію API (надану [Swagger UI](https://github.com/swagger-api/swagger-ui)):
### Альтернативна документація API { #alternative-api-docs }
-А тепер перейдіть на
http://127.0.0.1:8000/redoc.
+А тепер перейдіть на [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
-Ви побачите альтернативну автоматичну документацію (надану
ReDoc):
+Ви побачите альтернативну автоматичну документацію (надану [ReDoc](https://github.com/Rebilly/ReDoc)):
@@ -316,7 +316,7 @@ def update_item(item_id: int, item: Item):
### Оновлення інтерактивної документації API { #interactive-api-docs-upgrade }
-Тепер перейдіть на
http://127.0.0.1:8000/docs.
+Тепер перейдіть на [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
* Інтерактивна документація API буде автоматично оновлена, включно з новим тілом:
@@ -332,7 +332,7 @@ def update_item(item_id: int, item: Item):
### Оновлення альтернативної документації API { #alternative-api-docs-upgrade }
-А тепер перейдіть на
http://127.0.0.1:8000/redoc.
+А тепер перейдіть на [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
* Альтернативна документація також відобразить новий параметр запиту та тіло:
@@ -442,7 +442,7 @@ item: Item
* Дуже потужну і просту у використанні систему **
Впровадження залежностей**.
* Безпеку та автентифікацію, включно з підтримкою **OAuth2** з **JWT tokens** та **HTTP Basic** auth.
* Досконаліші (але однаково прості) техніки для оголошення **глибоко вкладених моделей JSON** (завдяки Pydantic).
-* Інтеграцію **GraphQL** з
Strawberry та іншими бібліотеками.
+* Інтеграцію **GraphQL** з [Strawberry](https://strawberry.rocks) та іншими бібліотеками.
* Багато додаткових можливостей (завдяки Starlette) як-от:
* **WebSockets**
* надзвичайно прості тести на основі HTTPX та `pytest`
@@ -452,24 +452,10 @@ item: Item
### Розгортання застосунку (необовʼязково) { #deploy-your-app-optional }
-За бажання ви можете розгорнути ваш застосунок FastAPI у
FastAPI Cloud, перейдіть і приєднайтеся до списку очікування, якщо ви ще цього не зробили. 🚀
+За бажання ви можете розгорнути ваш застосунок FastAPI у [FastAPI Cloud](https://fastapicloud.com), перейдіть і приєднайтеся до списку очікування, якщо ви ще цього не зробили. 🚀
Якщо у вас вже є обліковий запис **FastAPI Cloud** (ми запросили вас зі списку очікування 😉), ви можете розгорнути ваш застосунок однією командою.
-Перед розгортанням переконайтеся, що ви ввійшли в систему:
-
-
-
-```console
-$ fastapi login
-
-You are logged in to FastAPI Cloud 🚀
-```
-
-
-
-Потім розгорніть ваш застосунок:
-
```console
@@ -488,7 +474,7 @@ Deploying to FastAPI Cloud...
#### Про FastAPI Cloud { #about-fastapi-cloud }
-**
FastAPI Cloud** створено тим самим автором і командою, що стоять за **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** створено тим самим автором і командою, що стоять за **FastAPI**.
Він спрощує процес **створення**, **розгортання** та **доступу** до API з мінімальними зусиллями.
@@ -504,9 +490,9 @@ FastAPI - open source проект і базується на стандарта
## Продуктивність { #performance }
-Незалежні тести TechEmpower показують застосунки **FastAPI**, які працюють під керуванням Uvicorn, як
одні з найшвидших доступних Python-фреймворків, поступаючись лише Starlette та Uvicorn (які внутрішньо використовуються в FastAPI). (*)
+Незалежні тести TechEmpower показують застосунки **FastAPI**, які працюють під керуванням Uvicorn, як [одні з найшвидших доступних Python-фреймворків](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7), поступаючись лише Starlette та Uvicorn (які внутрішньо використовуються в FastAPI). (*)
-Щоб дізнатися більше, перегляньте розділ
Benchmarks.
+Щоб дізнатися більше, перегляньте розділ [Benchmarks](https://fastapi.tiangolo.com/uk/benchmarks/).
## Залежності { #dependencies }
@@ -518,19 +504,19 @@ FastAPI залежить від Pydantic і Starlette.
Використовується Pydantic:
-*
email-validator - для валідації електронної пошти.
+* [`email-validator`](https://github.com/JoshData/python-email-validator) - для валідації електронної пошти.
Використовується Starlette:
-*
httpx - потрібно, якщо ви хочете використовувати `TestClient`.
-*
jinja2 - потрібно, якщо ви хочете використовувати конфігурацію шаблонів за замовчуванням.
-*
python-multipart - потрібно, якщо ви хочете підтримувати форми з
«парсингом» через `request.form()`.
+* [`httpx`](https://www.python-httpx.org) - потрібно, якщо ви хочете використовувати `TestClient`.
+* [`jinja2`](https://jinja.palletsprojects.com) - потрібно, якщо ви хочете використовувати конфігурацію шаблонів за замовчуванням.
+* [`python-multipart`](https://github.com/Kludex/python-multipart) - потрібно, якщо ви хочете підтримувати форми з
«парсингом» через `request.form()`.
Використовується FastAPI:
-*
uvicorn - для сервера, який завантажує та обслуговує ваш застосунок. Це включає `uvicorn[standard]`, до якого входять деякі залежності (наприклад, `uvloop`), потрібні для високопродуктивної роботи сервера.
+* [`uvicorn`](https://www.uvicorn.dev) - для сервера, який завантажує та обслуговує ваш застосунок. Це включає `uvicorn[standard]`, до якого входять деякі залежності (наприклад, `uvloop`), потрібні для високопродуктивної роботи сервера.
* `fastapi-cli[standard]` - щоб надати команду `fastapi`.
- * Це включає `fastapi-cloud-cli`, який дозволяє розгортати ваш застосунок FastAPI у
FastAPI Cloud.
+ * Це включає `fastapi-cloud-cli`, який дозволяє розгортати ваш застосунок FastAPI у [FastAPI Cloud](https://fastapicloud.com).
### Без залежностей `standard` { #without-standard-dependencies }
@@ -546,13 +532,13 @@ FastAPI залежить від Pydantic і Starlette.
Додаткові необовʼязкові залежності Pydantic:
-*
pydantic-settings - для керування налаштуваннями.
-*
pydantic-extra-types - для додаткових типів, що можуть бути використані з Pydantic.
+* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) - для керування налаштуваннями.
+* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) - для додаткових типів, що можуть бути використані з Pydantic.
Додаткові необовʼязкові залежності FastAPI:
-*
orjson - потрібно, якщо ви хочете використовувати `ORJSONResponse`.
-*
ujson - потрібно, якщо ви хочете використовувати `UJSONResponse`.
+* [`orjson`](https://github.com/ijl/orjson) - потрібно, якщо ви хочете використовувати `ORJSONResponse`.
+* [`ujson`](https://github.com/esnme/ultrajson) - потрібно, якщо ви хочете використовувати `UJSONResponse`.
## Ліцензія { #license }
diff --git a/docs/uk/docs/project-generation.md b/docs/uk/docs/project-generation.md
index 4899090d42..6e3781740e 100644
--- a/docs/uk/docs/project-generation.md
+++ b/docs/uk/docs/project-generation.md
@@ -4,7 +4,7 @@
Ви можете використати цей шаблон для старту, адже в ньому вже виконано значну частину початкового налаштування, безпеки, роботи з базою даних і деяких кінцевих точок API.
-Репозиторій GitHub:
Шаблон Full Stack FastAPI
+Репозиторій GitHub: [Шаблон Full Stack FastAPI](https://github.com/tiangolo/full-stack-fastapi-template)
## Шаблон Full Stack FastAPI - стек технологій і можливості { #full-stack-fastapi-template-technology-stack-and-features }
diff --git a/docs/uk/docs/python-types.md b/docs/uk/docs/python-types.md
index deeeb2f9c5..274da80cec 100644
--- a/docs/uk/docs/python-types.md
+++ b/docs/uk/docs/python-types.md
@@ -269,7 +269,7 @@ def some_function(data: Any):
## Pydantic моделі { #pydantic-models }
-
Pydantic — це бібліотека Python для валідації даних.
+[Pydantic](https://docs.pydantic.dev/) — це бібліотека Python для валідації даних.
Ви оголошуєте «форму» даних як класи з атрибутами.
@@ -285,13 +285,13 @@ def some_function(data: Any):
/// info | Інформація
-Щоб дізнатись більше про
Pydantic, перегляньте його документацію.
+Щоб дізнатись більше про [Pydantic, перегляньте його документацію](https://docs.pydantic.dev/).
///
**FastAPI** повністю базується на Pydantic.
-Ви побачите набагато більше цього всього на практиці в [Навчальний посібник - Посібник користувача](tutorial/index.md){.internal-link target=_blank}.
+Ви побачите набагато більше цього всього на практиці в [Навчальний посібник - Посібник користувача](tutorial/index.md).
## Підказки типів з анотаціями метаданих { #type-hints-with-metadata-annotations }
@@ -337,12 +337,12 @@ def some_function(data: Any):
* **Документування** API за допомогою OpenAPI:
* який потім використовується для автоматичної інтерактивної документації користувальницьких інтерфейсів.
-Все це може здатися абстрактним. Не хвилюйтеся. Ви побачите все це в дії в [Навчальний посібник - Посібник користувача](tutorial/index.md){.internal-link target=_blank}.
+Все це може здатися абстрактним. Не хвилюйтеся. Ви побачите все це в дії в [Навчальний посібник - Посібник користувача](tutorial/index.md).
Важливо те, що за допомогою стандартних типів Python в одному місці (замість того, щоб додавати більше класів, декораторів тощо), **FastAPI** зробить багато роботи за вас.
/// info | Інформація
-Якщо ви вже пройшли весь навчальний посібник і повернулися, щоб дізнатися більше про типи, ось хороший ресурс:
«шпаргалка» від `mypy`.
+Якщо ви вже пройшли весь навчальний посібник і повернулися, щоб дізнатися більше про типи, ось хороший ресурс: [«шпаргалка» від `mypy`](https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html).
///
diff --git a/docs/uk/docs/tutorial/background-tasks.md b/docs/uk/docs/tutorial/background-tasks.md
index 71266a8b10..2894bd2d08 100644
--- a/docs/uk/docs/tutorial/background-tasks.md
+++ b/docs/uk/docs/tutorial/background-tasks.md
@@ -61,7 +61,7 @@
## Технічні деталі { #technical-details }
-Клас `BackgroundTasks` походить безпосередньо з
`starlette.background`.
+Клас `BackgroundTasks` походить безпосередньо з [`starlette.background`](https://www.starlette.dev/background/).
Він імпортується/включається безпосередньо у FastAPI, щоб ви могли імпортувати його з `fastapi` і випадково не імпортували альтернативний `BackgroundTask` (без `s` в кінці) з `starlette.background`.
@@ -69,11 +69,11 @@
Також можна використовувати `BackgroundTask` окремо в FastAPI, але для цього вам доведеться створити об'єкт у коді та повернути Starlette `Response`, включаючи його.
-Детальніше можна почитати в
офіційній документації Starlette про Background Tasks.
+Детальніше можна почитати в [офіційній документації Starlette про Background Tasks](https://www.starlette.dev/background/).
## Застереження { #caveat }
-Якщо вам потрібно виконувати складні фонові обчислення, і при цьому нема потреби запускати їх у тому ж процесі (наприклад, не потрібно спільного доступу до пам’яті чи змінних), можливо, варто скористатися більш потужними інструментами, такими як
Celery.
+Якщо вам потрібно виконувати складні фонові обчислення, і при цьому нема потреби запускати їх у тому ж процесі (наприклад, не потрібно спільного доступу до пам’яті чи змінних), можливо, варто скористатися більш потужними інструментами, такими як [Celery](https://docs.celeryq.dev).
Такі інструменти зазвичай потребують складнішої конфігурації та менеджера черги повідомлень/завдань, наприклад, RabbitMQ або Redis. Однак вони дозволяють виконувати фонові задачі в кількох процесах і особливо — на кількох серверах.
diff --git a/docs/uk/docs/tutorial/bigger-applications.md b/docs/uk/docs/tutorial/bigger-applications.md
index a75da2ac6d..7745509ddf 100644
--- a/docs/uk/docs/tutorial/bigger-applications.md
+++ b/docs/uk/docs/tutorial/bigger-applications.md
@@ -123,7 +123,7 @@ from app.routers import items
Ми використовуємо вигаданий заголовок, щоб спростити приклад.
-Але в реальних випадках ви отримаєте кращі результати, використовуючи інтегровані [засоби безпеки](security/index.md){.internal-link target=_blank}.
+Але в реальних випадках ви отримаєте кращі результати, використовуючи інтегровані [засоби безпеки](security/index.md).
///
@@ -169,7 +169,7 @@ async def read_item(item_id: str):
/// tip | Порада
-Зверніть увагу, що так само як і для [залежностей у декораторах *операцій шляху*](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, жодне значення не буде передано вашій *функції операції шляху*.
+Зверніть увагу, що так само як і для [залежностей у декораторах *операцій шляху*](dependencies/dependencies-in-path-operation-decorators.md), жодне значення не буде передано вашій *функції операції шляху*.
///
@@ -185,8 +185,8 @@ async def read_item(item_id: str):
* Усі вони включатимуть наперед визначені `responses`.
* Для всіх цих *операцій шляху* список `dependencies` буде оцінений/виконаний перед ними.
* Якщо ви також оголосите залежності в конкретній *операції шляху*, **вони також будуть виконані**.
- * Спочатку виконуються залежності router'а, потім [`dependencies` у декораторі](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, а потім звичайні параметричні залежності.
- * Ви також можете додати [`Security` залежності з `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
+ * Спочатку виконуються залежності router'а, потім [`dependencies` у декораторі](dependencies/dependencies-in-path-operation-decorators.md), а потім звичайні параметричні залежності.
+ * Ви також можете додати [`Security` залежності з `scopes`](../advanced/security/oauth2-scopes.md).
/// tip | Порада
@@ -303,7 +303,7 @@ from ...dependencies import get_token_header
Імпортуйте та створіть клас `FastAPI`, як зазвичай.
-І ми навіть можемо оголосити [глобальні залежності](dependencies/global-dependencies.md){.internal-link target=_blank}, які будуть поєднані із залежностями кожного `APIRouter`:
+І ми навіть можемо оголосити [глобальні залежності](dependencies/global-dependencies.md), які будуть поєднані із залежностями кожного `APIRouter`:
{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[1,3,7] title["app/main.py"] *}
@@ -353,7 +353,7 @@ from .routers import items, users
from app.routers import items, users
```
-Щоб дізнатися більше про пакети й модулі Python, прочитайте
офіційну документацію Python про модулі.
+Щоб дізнатися більше про пакети й модулі Python, прочитайте [офіційну документацію Python про модулі](https://docs.python.org/3/tutorial/modules.html).
///
@@ -465,6 +465,37 @@ from .routers.users import router
///
+## Налаштуйте `entrypoint` у `pyproject.toml` { #configure-the-entrypoint-in-pyproject-toml }
+
+Оскільки ваш об'єкт FastAPI `app` знаходиться в `app/main.py`, ви можете налаштувати `entrypoint` у файлі `pyproject.toml` так:
+
+```toml
+[tool.fastapi]
+entrypoint = "app.main:app"
+```
+
+це еквівалентно імпорту:
+
+```python
+from app.main import app
+```
+
+Таким чином команда `fastapi` знатиме, де знайти ваш застосунок.
+
+/// Note | Примітка
+
+Ви також могли б передати шлях команді, наприклад:
+
+```console
+$ fastapi dev app/main.py
+```
+
+Але тоді вам доведеться щоразу пам'ятати, щоб передавати правильний шлях, коли ви викликаєте команду `fastapi`.
+
+Крім того, інші інструменти можуть не знайти його, наприклад [розширення VS Code](../editor-support.md) або [FastAPI Cloud](https://fastapicloud.com), тому рекомендовано використовувати `entrypoint` у `pyproject.toml`.
+
+///
+
## Перевірте автоматичну документацію API { #check-the-automatic-api-docs }
Тепер запустіть ваш застосунок:
@@ -472,14 +503,14 @@ from .routers.users import router
```console
-$ fastapi dev app/main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
-І відкрийте документацію за адресою
http://127.0.0.1:8000/docs.
+І відкрийте документацію за адресою [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Ви побачите автоматичну документацію API, що включає шляхи з усіх підмодулів, з правильними шляхами (і префіксами) та правильними мітками:
diff --git a/docs/uk/docs/tutorial/body-nested-models.md b/docs/uk/docs/tutorial/body-nested-models.md
index a56ae484df..97fea36dc5 100644
--- a/docs/uk/docs/tutorial/body-nested-models.md
+++ b/docs/uk/docs/tutorial/body-nested-models.md
@@ -17,7 +17,7 @@
### Оголошення `list` з параметром типу { #declare-a-list-with-a-type-parameter }
Щоб оголосити типи з параметрами типу (внутрішніми типами), такими як `list`, `dict`, `tuple`,
-передайте внутрішні тип(и) як «параметри типу», використовуючи квадратні дужки: `[` and `]`
+передайте внутрішні тип(и) як «параметри типу», використовуючи квадратні дужки: `[` та `]`
```Python
my_list: list[str]
@@ -96,7 +96,7 @@ my_list: list[str]
Окрім звичайних типів, таких як `str`, `int`, `float`, та ін. ви можете використовувати складніші типи, які наслідують `str`.
-Щоб побачити всі доступні варіанти, ознайомтеся з оглядом
типів у Pydantic. Деякі приклади будуть у наступних розділах.
+Щоб побачити всі доступні варіанти, ознайомтеся з [Оглядом типів у Pydantic](https://docs.pydantic.dev/latest/concepts/types/). Деякі приклади будуть у наступному розділі.
Наприклад, у моделі `Image` є поле `url`, тому ми можемо оголосити його як `HttpUrl` від Pydantic замість `str`:
@@ -215,7 +215,7 @@ images: list[Image]
А також отримуєте всі переваги:
* Підтримка в редакторі (автодоповнення всюди!)
-* Конвертація даних (парсинг/сериалізація)
+* Конвертація даних (парсинг/серіалізація)
* Валідація даних
* Документація схем
* Автоматичне створення документації
diff --git a/docs/uk/docs/tutorial/body-updates.md b/docs/uk/docs/tutorial/body-updates.md
index 2ae68291ca..082bec1f03 100644
--- a/docs/uk/docs/tutorial/body-updates.md
+++ b/docs/uk/docs/tutorial/body-updates.md
@@ -2,7 +2,7 @@
## Оновлення із заміною за допомогою `PUT` { #update-replacing-with-put }
-Щоб оновити елемент, ви можете використати
HTTP `PUT` операцію.
+Щоб оновити елемент, ви можете використати [HTTP `PUT`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) операцію.
Ви можете використати `jsonable_encoder`, щоб перетворити вхідні дані на такі, які можна зберігати як JSON (наприклад, у NoSQL базі даних). Наприклад, перетворюючи `datetime` у `str`.
@@ -28,7 +28,7 @@
## Часткові оновлення з `PATCH` { #partial-updates-with-patch }
-Ви також можете використовувати операцію
HTTP `PATCH` для *часткового* оновлення даних.
+Ви також можете використовувати операцію [HTTP `PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) для *часткового* оновлення даних.
Це означає, що Ви можете надіслати лише ті дані, які хочете оновити, залишаючи інші без змін.
@@ -95,6 +95,6 @@
Тож, якщо Ви хочете отримувати часткові оновлення, які можуть пропускати всі атрибути, Вам потрібно мати модель, де всі атрибути позначені як необов’язкові (зі значеннями за замовчуванням або `None`).
-Щоб розрізняти моделі з усіма необов’язковими значеннями для **оновлення** і моделі з обов’язковими значеннями для **створення**, Ви можете скористатись ідеями, описаними у [Додаткові моделі](extra-models.md){.internal-link target=_blank}.
+Щоб розрізняти моделі з усіма необов’язковими значеннями для **оновлення** і моделі з обов’язковими значеннями для **створення**, Ви можете скористатись ідеями, описаними у [Додаткові моделі](extra-models.md).
///
diff --git a/docs/uk/docs/tutorial/body.md b/docs/uk/docs/tutorial/body.md
index 615f0274cc..91c4b42527 100644
--- a/docs/uk/docs/tutorial/body.md
+++ b/docs/uk/docs/tutorial/body.md
@@ -2,13 +2,13 @@
Коли вам потрібно надіслати дані з клієнта (скажімо, браузера) до вашого API, ви надсилаєте їх як **тіло запиту**.
-Тіло **запиту** — це дані, надіслані клієнтом до вашого API. Тіло **відповіді** — це дані, які ваш API надсилає клієнту.
+Тіло **запиту** - це дані, надіслані клієнтом до вашого API. Тіло **відповіді** - це дані, які ваш API надсилає клієнту.
Ваш API майже завжди має надсилати тіло **відповіді**. Але клієнтам не обов’язково потрібно постійно надсилати тіла **запитів** — інколи вони лише запитують шлях, можливо з деякими параметрами запиту, але не надсилають тіло.
-Щоб оголосити тіло **запиту**, ви використовуєте
Pydantic моделі з усією їх потужністю та перевагами.
+Щоб оголосити тіло **запиту**, ви використовуєте [Pydantic](https://docs.pydantic.dev/) моделі з усією їх потужністю та перевагами.
-/// info
+/// info | Інформація
Щоб надіслати дані, ви повинні використовувати один із: `POST` (більш поширений), `PUT`, `DELETE` або `PATCH`.
@@ -73,7 +73,7 @@
* Якщо дані недійсні, він поверне гарну та чітку помилку, вказуючи, де саме і які дані були неправильними.
* Надавати отримані дані у параметрі `item`.
* Оскільки ви оголосили його у функції як тип `Item`, ви також матимете всю підтримку редактора (автозаповнення, тощо) для всіх атрибутів та їх типів.
-* Генерувати визначення
Схеми JSON для вашої моделі, ви також можете використовувати їх де завгодно, якщо це має сенс для вашого проекту.
+* Генерувати визначення [Схеми JSON](https://json-schema.org) для вашої моделі, ви також можете використовувати їх де завгодно, якщо це має сенс для вашого проекту.
* Ці схеми будуть частиною згенерованої схеми OpenAPI і використовуватимуться автоматичною документацією
UIs.
## Автоматична документація { #automatic-docs }
@@ -102,15 +102,15 @@
Були навіть деякі зміни в самому Pydantic, щоб підтримати це.
-Попередні скріншоти були зроблені у
Visual Studio Code.
+Попередні скріншоти були зроблені у [Visual Studio Code](https://code.visualstudio.com).
-Але ви отримаєте ту саму підтримку редактора у
PyCharm та більшість інших редакторів Python:
+Але ви отримаєте ту саму підтримку редактора у [PyCharm](https://www.jetbrains.com/pycharm/) та більшість інших редакторів Python:
-/// tip
+/// tip | Порада
-Якщо ви використовуєте
PyCharm як ваш редактор, ви можете використати
Pydantic PyCharm Plugin.
+Якщо ви використовуєте [PyCharm](https://www.jetbrains.com/pycharm/) як ваш редактор, ви можете використати [Pydantic PyCharm Plugin](https://github.com/koxudaxi/pydantic-pycharm-plugin/).
Він покращує підтримку редакторів для моделей Pydantic за допомогою:
@@ -151,7 +151,7 @@
* Якщо параметр має **сингулярний тип** (наприклад, `int`, `float`, `str`, `bool` тощо), він буде інтерпретуватися як параметр **запиту**.
* Якщо параметр оголошується як тип **Pydantic моделі**, він інтерпретується як **тіло** **запиту**.
-/// note
+/// note | Примітка
FastAPI буде знати, що значення `q` не є обов'язковим через значення за замовчуванням `= None`.
@@ -163,4 +163,4 @@ FastAPI буде знати, що значення `q` не є обов'язко
## Без Pydantic { #without-pydantic }
-Якщо ви не хочете використовувати моделі Pydantic, ви також можете використовувати параметри **Body**. Перегляньте документацію для [Тіло - Кілька параметрів: Окремі значення в тілі](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
+Якщо ви не хочете використовувати моделі Pydantic, ви також можете використовувати параметри **Body**. Перегляньте документацію для [Тіло - Кілька параметрів: Окремі значення в тілі](body-multiple-params.md#singular-values-in-body).
diff --git a/docs/uk/docs/tutorial/cors.md b/docs/uk/docs/tutorial/cors.md
index 5c959cef18..993bf31f58 100644
--- a/docs/uk/docs/tutorial/cors.md
+++ b/docs/uk/docs/tutorial/cors.md
@@ -1,6 +1,6 @@
# CORS (Обмін ресурсами між різними джерелами) { #cors-cross-origin-resource-sharing }
-
CORS або «Cross-Origin Resource Sharing» є ситуація, коли фронтенд, що працює в браузері, містить JavaScript-код, який взаємодіє з бекендом, розташованим в іншому «джерелі» (origin).
+[CORS або «Cross-Origin Resource Sharing»](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) є ситуація, коли фронтенд, що працює в браузері, містить JavaScript-код, який взаємодіє з бекендом, розташованим в іншому «джерелі» (origin).
## Джерело (Origin) { #origin }
@@ -29,7 +29,7 @@
Можна також оголосити список як `"*"` (дика карта), що означає дозвіл для всіх джерел.
-Однак це дозволить лише певні типи комунікації, виключаючи все, що пов'язане з обліковими даними: Cookies, заголовки авторизації, як-от ті, що використовуються з токенами носія, тощо.
+Однак це дозволить лише певні типи комунікації, виключаючи все, що пов'язане з обліковими даними: кукі, заголовки авторизації, як-от ті, що використовуються з токенами носія, тощо.
Тому для коректної роботи краще явно вказувати дозволені джерела.
@@ -43,7 +43,7 @@
Також можна вказати, чи дозволяє ваш бекенд:
-* Облікові дані (заголовки авторизації, Cookies, тощо).
+* Облікові дані (заголовки авторизації, кукі, тощо).
* Конкретні HTTP-методи (`POST`, `PUT`) або всі за допомогою `"*"`
* Конкретні HTTP-заголовки або всі за допомогою `"*"`.
@@ -58,10 +58,10 @@
* `allow_origins` - Список джерел, яким дозволено здійснювати міждоменні запити. Наприклад `['https://example.org', 'https://www.example.org']`. Ви можете використовувати `['*']`, щоб дозволити будь-яке джерело.
* `allow_origin_regex` - Рядок регулярного виразу для відповідності джерелам, яким дозволено здійснювати міждоменні запити. Наприклад, `'https://.*\.example\.org'`.
* `allow_methods` - Список HTTP-методів, дозволених для міждоменних запитів. За замовчуванням `['GET']`. Ви можете використовувати `['*']`, щоб дозволити всі стандартні методи.
-* `allow_headers` - Список HTTP-заголовків запиту, які підтримуються для міждоменних запитів. За замовчуванням `[]`. Ви можете використовувати `['*']`, щоб дозволити всі заголовки. Заголовки `Accept`, `Accept-Language`, `Content-Language` і `Content-Type` завжди дозволені для
простих CORS-запитів.
-* `allow_credentials` - Визначає, чи повинні підтримуватися cookies для міждоменних запитів. За замовчуванням `False`.
+* `allow_headers` - Список HTTP-заголовків запиту, які підтримуються для міждоменних запитів. За замовчуванням `[]`. Ви можете використовувати `['*']`, щоб дозволити всі заголовки. Заголовки `Accept`, `Accept-Language`, `Content-Language` і `Content-Type` завжди дозволені для [простих CORS-запитів](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests).
+* `allow_credentials` - Визначає, чи повинні підтримуватися кукі для міждоменних запитів. За замовчуванням `False`.
- Жоден із параметрів `allow_origins`, `allow_methods` і `allow_headers` не можна встановлювати як `['*']`, якщо `allow_credentials` встановлено як `True`. Усі вони мають бути
явно вказані.
+ Жоден із параметрів `allow_origins`, `allow_methods` і `allow_headers` не можна встановлювати як `['*']`, якщо `allow_credentials` встановлено як `True`. Усі вони мають бути [явно вказані](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards).
* `expose_headers` - Вказує, які заголовки відповіді повинні бути доступні для браузера. За замовчуванням `[]`.
* `max_age` - Встановлює максимальний час (у секундах) для кешування CORS-відповідей у браузерах. За замовчуванням `600`.
@@ -72,20 +72,20 @@
Це будь-які `OPTIONS` - запити, що містять заголовки `Origin` та `Access-Control-Request-Method`.
-У такому випадку middleware перехопить вхідний запит і відповість відповідними CORS-заголовками, повертаючи або `200`, або `400` для інформаційних цілей.
+У такому випадку проміжне програмне забезпечення перехопить вхідний запит і відповість відповідними CORS-заголовками, повертаючи або `200`, або `400` для інформаційних цілей.
### Прості запити { #simple-requests }
-Будь-які запити із заголовком `Origin`. У цьому випадку middleware пропустить запит як звичайний, але додасть відповідні CORS-заголовки у відповідь.
+Будь-які запити із заголовком `Origin`. У цьому випадку проміжне програмне забезпечення пропустить запит як звичайний, але додасть відповідні CORS-заголовки у відповідь.
## Додаткова інформація { #more-info }
-Більше про
CORS можна дізнатися в
документації Mozilla про CORS.
+Більше про
CORS можна дізнатися в [документації Mozilla про CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS).
/// note | Технічні деталі
Також можна використовувати `from starlette.middleware.cors import CORSMiddleware`.
-**FastAPI** надає кілька middleware у `fastapi.middleware` для зручності розробників. Але більшість доступних middleware походять безпосередньо зі Starlette.
+**FastAPI** надає кілька проміжних програмних забезпечень у `fastapi.middleware` для зручності розробників. Але більшість доступного проміжного програмного забезпечення походить безпосередньо зі Starlette.
///
diff --git a/docs/uk/docs/tutorial/debugging.md b/docs/uk/docs/tutorial/debugging.md
index 679018cc2f..d0100587b8 100644
--- a/docs/uk/docs/tutorial/debugging.md
+++ b/docs/uk/docs/tutorial/debugging.md
@@ -59,7 +59,7 @@ $ python myapp.py
```Python
from myapp import app
-# Some more code
+# Ще трохи коду
```
у цьому випадку автоматично створена змінна `__name__` всередині `myapp.py` не матиме значення `"__main__"`.
@@ -72,9 +72,9 @@ from myapp import app
не буде виконано.
-/// info | Інформація
+/// info
-Для отримання додаткової інформації дивіться
офіційну документацію Python.
+Для отримання додаткової інформації дивіться [офіційну документацію Python](https://docs.python.org/3/library/__main__.html).
///
diff --git a/docs/uk/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md b/docs/uk/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
index 4614c626c5..a82461c8dc 100644
--- a/docs/uk/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
+++ b/docs/uk/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
@@ -32,7 +32,7 @@
У цьому прикладі ми використовуємо вигадані власні заголовки `X-Key` і `X-Token`.
-Але в реальних випадках, під час впровадження безпеки, ви отримаєте більше користі, використовуючи вбудовані [Інструменти безпеки (наступний розділ)](../security/index.md){.internal-link target=_blank}.
+Але в реальних випадках, під час впровадження безпеки, ви отримаєте більше користі, використовуючи вбудовані [Інструменти безпеки (наступний розділ)](../security/index.md).
///
@@ -62,7 +62,7 @@
## Залежності для групи операцій шляху { #dependencies-for-a-group-of-path-operations }
-Далі, читаючи про структурування великих застосунків ([Більші застосунки - декілька файлів](../../tutorial/bigger-applications.md){.internal-link target=_blank}), можливо з кількома файлами, ви дізнаєтеся, як оголосити один параметр `dependencies` для групи *операцій шляху*.
+Далі, читаючи про структурування великих застосунків ([Більші застосунки - декілька файлів](../../tutorial/bigger-applications.md)), можливо з кількома файлами, ви дізнаєтеся, як оголосити один параметр `dependencies` для групи *операцій шляху*.
## Глобальні залежності { #global-dependencies }
diff --git a/docs/uk/docs/tutorial/dependencies/dependencies-with-yield.md b/docs/uk/docs/tutorial/dependencies/dependencies-with-yield.md
index 70d4210a1c..53b49e61b6 100644
--- a/docs/uk/docs/tutorial/dependencies/dependencies-with-yield.md
+++ b/docs/uk/docs/tutorial/dependencies/dependencies-with-yield.md
@@ -1,6 +1,6 @@
# Залежності з yield { #dependencies-with-yield }
-FastAPI підтримує залежності, які виконують деякі
додаткові кроки після завершення.
+FastAPI підтримує залежності, які виконують деякі
додаткові кроки після завершення.
Щоб це зробити, використовуйте `yield` замість `return` і напишіть додаткові кроки (код) після нього.
@@ -14,8 +14,8 @@ FastAPI підтримує залежності, які виконують де
Будь-яка функція, яку можна використовувати з:
-*
`@contextlib.contextmanager` або
-*
`@contextlib.asynccontextmanager`
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) або
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
буде придатною як залежність у **FastAPI**.
@@ -87,7 +87,7 @@ FastAPI підтримує залежності, які виконують де
/// note | Технічні деталі
-Це працює завдяки
Менеджерам контексту Python.
+Це працює завдяки Python [Менеджерам контексту](https://docs.python.org/3/library/contextlib.html).
**FastAPI** використовує їх внутрішньо, щоб досягти цього.
@@ -111,7 +111,7 @@ FastAPI підтримує залежності, які виконують де
{* ../../docs_src/dependencies/tutorial008b_an_py310.py hl[18:22,31] *}
-Якщо ви хочете перехоплювати винятки та створювати на їх основі користувацьку відповідь, створіть [Користувацький обробник винятків](../handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank}.
+Якщо ви хочете перехоплювати винятки та створювати на їх основі користувацьку відповідь, створіть [Користувацький обробник винятків](../handling-errors.md#install-custom-exception-handlers).
## Залежності з `yield` та `except` { #dependencies-with-yield-and-except }
@@ -233,14 +233,14 @@ participant operation as Path Operation
Залежності з `yield` еволюціонували з часом, щоб покрити різні сценарії та виправити деякі проблеми.
-Якщо ви хочете дізнатися, що змінювалося в різних версіях FastAPI, прочитайте про це в просунутому посібнику користувача: [Розширені залежності - Залежності з `yield`, `HTTPException`, `except` і фоновими задачами](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks){.internal-link target=_blank}.
+Якщо ви хочете дізнатися, що змінювалося в різних версіях FastAPI, прочитайте про це в просунутому посібнику користувача: [Розширені залежності - Залежності з `yield`, `HTTPException`, `except` і фоновими задачами](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks).
## Менеджери контексту { #context-managers }
### Що таке «Менеджери контексту» { #what-are-context-managers }
«Менеджери контексту» - це будь-які Python-об'єкти, які можна використовувати в операторі `with`.
-Наприклад,
можна використати `with`, щоб прочитати файл:
+Наприклад, [можна використати `with`, щоб прочитати файл](https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files):
```Python
with open("./somefile.txt") as f:
@@ -264,7 +264,7 @@ with open("./somefile.txt") as f:
///
-У Python ви можете створювати Менеджери контексту,
створивши клас із двома методами: `__enter__()` і `__exit__()`.
+У Python ви можете створювати Менеджери контексту, [створивши клас із двома методами: `__enter__()` і `__exit__()`](https://docs.python.org/3/reference/datamodel.html#context-managers).
Ви також можете використовувати їх усередині залежностей **FastAPI** з `yield`, використовуючи
`with` або `async with` у середині функції залежності:
@@ -275,8 +275,8 @@ with open("./somefile.txt") as f:
Інший спосіб створити менеджер контексту:
-*
`@contextlib.contextmanager` або
-*
`@contextlib.asynccontextmanager`
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) або
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
використовуючи їх для декорування функції з одним `yield`.
diff --git a/docs/uk/docs/tutorial/dependencies/global-dependencies.md b/docs/uk/docs/tutorial/dependencies/global-dependencies.md
index 3cffa1752c..da8b08cdff 100644
--- a/docs/uk/docs/tutorial/dependencies/global-dependencies.md
+++ b/docs/uk/docs/tutorial/dependencies/global-dependencies.md
@@ -2,14 +2,14 @@
Для деяких типів застосунків ви можете захотіти додати залежності до всього застосунку.
-Подібно до того, як ви можете [додавати `dependencies` до *декораторів операцій шляху*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, ви можете додати їх до застосунку `FastAPI`.
+Подібно до того, як ви можете [додавати `dependencies` до *декораторів операцій шляху*](dependencies-in-path-operation-decorators.md), ви можете додати їх до застосунку `FastAPI`.
У такому разі вони будуть застосовані до всіх *операцій шляху* в застосунку:
{* ../../docs_src/dependencies/tutorial012_an_py310.py hl[17] *}
-Усі ідеї з розділу про [додавання `dependencies` до *декораторів операцій шляху*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} так само застосовні, але в цьому випадку - до всіх *операцій шляху* в застосунку.
+Усі ідеї з розділу про [додавання `dependencies` до *декораторів операцій шляху*](dependencies-in-path-operation-decorators.md) так само застосовні, але в цьому випадку - до всіх *операцій шляху* в застосунку.
## Залежності для груп *операцій шляху* { #dependencies-for-groups-of-path-operations }
-Пізніше, читаючи про структуру більших застосунків ([Більші застосунки - кілька файлів](../../tutorial/bigger-applications.md){.internal-link target=_blank}), можливо з кількома файлами, ви дізнаєтеся, як оголосити єдиний параметр `dependencies` для групи *операцій шляху*.
+Пізніше, читаючи про структуру більших застосунків ([Більші застосунки - кілька файлів](../../tutorial/bigger-applications.md)), можливо з кількома файлами, ви дізнаєтеся, як оголосити єдиний параметр `dependencies` для групи *операцій шляху*.
diff --git a/docs/uk/docs/tutorial/dependencies/index.md b/docs/uk/docs/tutorial/dependencies/index.md
index cbcf693077..bea5f598d6 100644
--- a/docs/uk/docs/tutorial/dependencies/index.md
+++ b/docs/uk/docs/tutorial/dependencies/index.md
@@ -57,7 +57,7 @@ FastAPI додав підтримку `Annotated` (і почав її реком
Якщо у вас старіша версія, ви отримаєте помилки при спробі використати `Annotated`.
-Переконайтеся, що ви [Оновіть версію FastAPI](../../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} щонайменше до 0.95.1 перед використанням `Annotated`.
+Переконайтеся, що ви [Оновіть версію FastAPI](../../deployment/versions.md#upgrading-the-fastapi-versions) щонайменше до 0.95.1 перед використанням `Annotated`.
///
@@ -152,7 +152,7 @@ commons: Annotated[dict, Depends(common_parameters)]
/// note | Примітка
-Якщо ви не впевнені, перегляньте розділ [Async: *"In a hurry?"*](../../async.md#in-a-hurry){.internal-link target=_blank} про `async` і `await` у документації.
+Якщо ви не впевнені, перегляньте розділ [Async: *"In a hurry?"*](../../async.md#in-a-hurry) про `async` і `await` у документації.
///
diff --git a/docs/uk/docs/tutorial/encoder.md b/docs/uk/docs/tutorial/encoder.md
index 1b403d5bba..7bbc45ef7b 100644
--- a/docs/uk/docs/tutorial/encoder.md
+++ b/docs/uk/docs/tutorial/encoder.md
@@ -12,7 +12,7 @@
Наприклад, вона не приймає об'єкти типу `datetime`, оскільки вони не сумісні з JSON.
-Отже, об'єкт типу `datetime` потрібно перетворити на `str`, який містить дані в
форматі ISO.
+Отже, об'єкт типу `datetime` потрібно перетворити на `str`, який містить дані в [форматі ISO](https://en.wikipedia.org/wiki/ISO_8601).
Так само ця база даних не прийматиме модель Pydantic (об'єкт з атрибутами), а лише `dict`.
@@ -24,7 +24,7 @@
У цьому прикладі вона конвертує модель Pydantic у `dict`, а `datetime` у `str`.
-Результат виклику цієї функції — це щось, що можна кодувати з використанням стандарту Python
`json.dumps()`.
+Результат виклику цієї функції — це щось, що можна кодувати з використанням стандарту Python [`json.dumps()`](https://docs.python.org/3/library/json.html#json.dumps).
Вона не повертає великий `str`, який містить дані у форматі JSON (як рядок). Вона повертає стандартну структуру даних Python (наприклад, `dict`) зі значеннями та підзначеннями, які є сумісними з JSON.
diff --git a/docs/uk/docs/tutorial/extra-data-types.md b/docs/uk/docs/tutorial/extra-data-types.md
index a3545e0746..26d7c306fe 100644
--- a/docs/uk/docs/tutorial/extra-data-types.md
+++ b/docs/uk/docs/tutorial/extra-data-types.md
@@ -36,7 +36,7 @@
* `datetime.timedelta`:
* Пайтонівський `datetime.timedelta`.
* У запитах та відповідях буде представлений як `float` загальної кількості секунд.
- * Pydantic також дозволяє представляти це як "ISO 8601 time diff encoding",
дивіться документацію для отримання додаткової інформації.
+ * Pydantic також дозволяє представляти це як "ISO 8601 time diff encoding", [дивіться документацію для отримання додаткової інформації](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
* `frozenset`:
* У запитах і відповідях це буде оброблено так само, як і `set`:
* У запитах список буде зчитано, дублікати буде видалено, і його буде перетворено на `set`.
@@ -49,7 +49,7 @@
* `Decimal`:
* Стандартний Пайтонівський `Decimal`.
* У запитах і відповідях це буде оброблено так само, як і `float`.
-* Ви можете перевірити всі дійсні типи даних Pydantic тут:
типи даних Pydantic.
+* Ви можете перевірити всі дійсні типи даних Pydantic тут: [типи даних Pydantic](https://docs.pydantic.dev/latest/usage/types/types/).
## Приклад { #example }
diff --git a/docs/uk/docs/tutorial/extra-models.md b/docs/uk/docs/tutorial/extra-models.md
index 25930b8c0b..271e553fd8 100644
--- a/docs/uk/docs/tutorial/extra-models.md
+++ b/docs/uk/docs/tutorial/extra-models.md
@@ -12,7 +12,7 @@
Ніколи не зберігайте паролі користувачів у відкритому вигляді. Завжди зберігайте «безпечний хеш», який потім можна перевірити.
-Якщо ви ще не знаєте, що таке «хеш пароля», ви дізнаєтесь у [розділах про безпеку](security/simple-oauth2.md#password-hashing){.internal-link target=_blank}.
+Якщо ви ще не знаєте, що таке «хеш пароля», ви дізнаєтесь у [розділах про безпеку](security/simple-oauth2.md#password-hashing).
///
@@ -108,7 +108,7 @@ UserInDB(**user_dict)
UserInDB(**user_in.model_dump())
```
-...тому що `user_in.model_dump()` повертає `dict`, а ми змушуємо Python «розпакувати» його, передаючи в `UserInDB` з префіксом `**`.
+...тому що `user_in.model_dump()` - це `dict`, а ми змушуємо Python «розпакувати» його, передаючи в `UserInDB` з префіксом `**`.
Тож ми отримуємо модель Pydantic з даних іншої моделі Pydantic.
@@ -162,11 +162,11 @@ UserInDB(
В OpenAPI це буде визначено як `anyOf`.
-Для цього використайте стандартну підказку типу Python
`typing.Union`:
+Для цього використайте стандартну підказку типу Python [`typing.Union`](https://docs.python.org/3/library/typing.html#typing.Union):
/// note | Примітка
-Під час визначення
`Union` спочатку вказуйте найконкретніший тип, а потім менш конкретний. У прикладі нижче більш конкретний `PlaneItem` стоїть перед `CarItem` у `Union[PlaneItem, CarItem]`.
+Під час визначення [`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions) спочатку вказуйте найконкретніший тип, а потім менш конкретний. У прикладі нижче більш конкретний `PlaneItem` стоїть перед `CarItem` у `Union[PlaneItem, CarItem]`.
///
diff --git a/docs/uk/docs/tutorial/first-steps.md b/docs/uk/docs/tutorial/first-steps.md
index f03a120a09..0f46890d9b 100644
--- a/docs/uk/docs/tutorial/first-steps.md
+++ b/docs/uk/docs/tutorial/first-steps.md
@@ -11,7 +11,7 @@
```console
-$
fastapi dev
main.py
+$
fastapi dev
FastAPI Starting development server 🚀
@@ -58,7 +58,7 @@ INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
### Перевірте { #check-it }
-Відкрийте браузер та введіть адресу
http://127.0.0.1:8000.
+Відкрийте браузер за адресою [http://127.0.0.1:8000](http://127.0.0.1:8000).
Ви побачите JSON-відповідь:
@@ -68,17 +68,17 @@ INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
### Інтерактивна API документація { #interactive-api-docs }
-Тепер перейдіть сюди
http://127.0.0.1:8000/docs.
+Тепер перейдіть сюди [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
-Ви побачите автоматичну інтерактивну API документацію (надається
Swagger UI):
+Ви побачите автоматичну інтерактивну API документацію (надається [Swagger UI](https://github.com/swagger-api/swagger-ui)):
### Альтернативна API документація { #alternative-api-docs }
-А тепер перейдіть сюди
http://127.0.0.1:8000/redoc.
+А тепер перейдіть сюди [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
-Ви побачите альтернативну автоматичну документацію (надається
ReDoc):
+Ви побачите альтернативну автоматичну документацію (надається [ReDoc](https://github.com/Rebilly/ReDoc)):
@@ -92,7 +92,7 @@ INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
#### API «схема» { #api-schema }
-У цьому випадку,
OpenAPI є специфікацією, яка визначає, як описати схему вашого API.
+У цьому випадку, [OpenAPI](https://github.com/OAI/OpenAPI-Specification) є специфікацією, яка визначає, як описати схему вашого API.
Це визначення схеми включає шляхи (paths) вашого API, можливі параметри, які вони приймають, тощо.
@@ -110,7 +110,7 @@ OpenAPI описує схему API для вашого API. І ця схема
Якщо вас цікавить, як виглядає «сирий» OpenAPI schema, FastAPI автоматично генерує JSON (schema) з описами всього вашого API.
-Ви можете побачити це напряму тут:
http://127.0.0.1:8000/openapi.json.
+Ви можете побачити це напряму тут: [http://127.0.0.1:8000/openapi.json](http://127.0.0.1:8000/openapi.json).
Ви побачите JSON, що починається приблизно так:
@@ -143,9 +143,58 @@ OpenAPI schema — це те, на чому працюють дві включе
Ви також можете використовувати його для автоматичної генерації коду для клієнтів, які взаємодіють з вашим API. Наприклад, для фронтенд-, мобільних або IoT-застосунків.
+### Налаштуйте `entrypoint` застосунку в `pyproject.toml` { #configure-the-app-entrypoint-in-pyproject-toml }
+
+Ви можете налаштувати, де знаходиться ваш застосунок, у файлі `pyproject.toml`, приблизно так:
+
+```toml
+[tool.fastapi]
+entrypoint = "main:app"
+```
+
+Цей `entrypoint` повідомить команді `fastapi`, що вона має імпортувати застосунок так:
+
+```python
+from main import app
+```
+
+Якщо структура вашого коду виглядала б так:
+
+```
+.
+├── backend
+│ ├── main.py
+│ ├── __init__.py
+```
+
+Тоді ви б задали `entrypoint` як:
+
+```toml
+[tool.fastapi]
+entrypoint = "backend.main:app"
+```
+
+що було б еквівалентно:
+
+```python
+from backend.main import app
+```
+
+### `fastapi dev` із шляхом { #fastapi-dev-with-path }
+
+Ви також можете передати шлях до файлу в команду `fastapi dev`, і вона вгадає обʼєкт FastAPI app, який слід використовувати:
+
+```console
+$ fastapi dev main.py
+```
+
+Але вам доведеться щоразу памʼятати передавати правильний шлях під час виклику команди `fastapi`.
+
+Крім того, інші інструменти можуть не знайти його, наприклад [Розширення VS Code](../editor-support.md) або [FastAPI Cloud](https://fastapicloud.com), тому рекомендується використовувати `entrypoint` у `pyproject.toml`.
+
### Розгорніть ваш застосунок (необовʼязково) { #deploy-your-app-optional }
-За бажанням ви можете розгорнути ваш FastAPI-застосунок у
FastAPI Cloud, перейдіть і приєднайтеся до списку очікування, якщо ви цього ще не зробили. 🚀
+За бажанням ви можете розгорнути ваш FastAPI-застосунок у [FastAPI Cloud](https://fastapicloud.com), перейдіть і приєднайтеся до списку очікування, якщо ви цього ще не зробили. 🚀
Якщо у вас вже є обліковий запис **FastAPI Cloud** (ми запросили вас зі списку очікування 😉), ви можете розгорнути ваш застосунок однією командою.
@@ -191,7 +240,7 @@ Deploying to FastAPI Cloud...
`FastAPI` — це клас, який успадковується безпосередньо від `Starlette`.
-Ви також можете використовувати всю функціональність
Starlette у `FastAPI`.
+Ви також можете використовувати всю функціональність [Starlette](https://www.starlette.dev/) у `FastAPI`.
///
@@ -336,7 +385,7 @@ https://example.com/items/foo
/// note
-Якщо ви не знаєте різницю, подивіться [Асинхронність: *«Поспішаєте?»*](../async.md#in-a-hurry){.internal-link target=_blank}.
+Якщо ви не знаєте різницю, подивіться [Асинхронність: *«Поспішаєте?»*](../async.md#in-a-hurry).
///
@@ -352,11 +401,11 @@ https://example.com/items/foo
### Крок 6: розгорніть його { #step-6-deploy-it }
-Розгорніть ваш застосунок у **
FastAPI Cloud** однією командою: `fastapi deploy`. 🎉
+Розгорніть ваш застосунок у **[FastAPI Cloud](https://fastapicloud.com)** однією командою: `fastapi deploy`. 🎉
#### Про FastAPI Cloud { #about-fastapi-cloud }
-**
FastAPI Cloud** створено тим самим автором і командою, які стоять за **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** створено тим самим автором і командою, які стоять за **FastAPI**.
Він спрощує процес **створення**, **розгортання** та **доступу** до API з мінімальними зусиллями.
diff --git a/docs/uk/docs/tutorial/handling-errors.md b/docs/uk/docs/tutorial/handling-errors.md
index 28a83127ff..262efa0e03 100644
--- a/docs/uk/docs/tutorial/handling-errors.md
+++ b/docs/uk/docs/tutorial/handling-errors.md
@@ -11,11 +11,11 @@
* Елемент, до якого він намагається отримати доступ, не існує.
* тощо.
-У таких випадках зазвичай повертається **HTTP статус-код** в діапазоні **400** (від 400 до 499).
+У таких випадках зазвичай повертається **код статусу HTTP** у діапазоні **400** (від 400 до 499).
-Це схоже на HTTP статус-коди 200 (від 200 до 299). Ці «200» статус-коди означають, що якимось чином запит був «успішним».
+Це схоже на коди статусу HTTP 200 (від 200 до 299). Ці «200» коди статусу означають, що якимось чином запит був «успішним».
-Статус-коди в діапазоні 400 означають, що сталася помилка з боку клієнта.
+Коди статусу в діапазоні 400 означають, що сталася помилка з боку клієнта.
Пам'ятаєте всі ці помилки **«404 Not Found»** (і жарти про них)?
@@ -29,7 +29,7 @@
### Згенеруйте `HTTPException` у своєму коді { #raise-an-httpexception-in-your-code }
-`HTTPException` — це звичайна помилка Python із додатковими даними, які стосуються API.
+`HTTPException` - це звичайна помилка Python із додатковими даними, які стосуються API.
Оскільки це помилка Python, ви не `return` її, а `raise` її.
@@ -37,13 +37,13 @@
Перевага генерації виключення замість повернення значення стане більш очевидною в розділі про залежності та безпеку.
-У цьому прикладі, коли клієнт запитує елемент за ID, якого не існує, згенеруйте виключення зі статус-кодом `404`:
+У цьому прикладі, коли клієнт запитує елемент за ID, якого не існує, згенеруйте виключення з кодом статусу `404`:
{* ../../docs_src/handling_errors/tutorial001_py310.py hl[11] *}
### Отримана відповідь { #the-resulting-response }
-Якщо клієнт робить запит за шляхом `http://example.com/items/foo` (де `item_id` `"foo"`), він отримає HTTP статус-код 200 і JSON відповідь:
+Якщо клієнт робить запит за шляхом `http://example.com/items/foo` (де `item_id` `"foo"`), він отримає код статусу HTTP 200 і JSON відповідь:
```JSON
{
@@ -51,7 +51,7 @@
}
```
-Але якщо клієнт робить запит на `http://example.com/items/bar` (де `item_id` має не існуюче значення `"bar"`), то отримає HTTP статус-код 404 (помилка «не знайдено») та JSON відповідь:
+Але якщо клієнт робить запит на `http://example.com/items/bar` (де `item_id` має не існуюче значення `"bar"`), то отримає код статусу HTTP 404 (помилка «не знайдено») та JSON відповідь:
```JSON
{
@@ -81,7 +81,7 @@
## Встановлення власних обробників виключень { #install-custom-exception-handlers }
-Ви можете додати власні обробники виключень за допомогою
тих самих утиліт для виключень зі Starlette.
+Ви можете додати власні обробники виключень за допомогою [тих самих утиліт для виключень зі Starlette](https://www.starlette.dev/exceptions/).
Припустімо, у вас є власне виключення `UnicornException`, яке ви (або бібліотека, яку ви використовуєте) можете `raise`.
@@ -95,7 +95,7 @@
Але вона буде оброблена функцією-обробником `unicorn_exception_handler`.
-Отже, ви отримаєте зрозумілу помилку зі HTTP-статусом `418` і JSON-вмістом:
+Отже, ви отримаєте зрозумілу помилку з кодом статусу HTTP `418` і JSON-вмістом:
```JSON
{"message": "Oops! yolo did something. There goes a rainbow..."}
diff --git a/docs/uk/docs/tutorial/index.md b/docs/uk/docs/tutorial/index.md
index ed53ac7728..629b71decc 100644
--- a/docs/uk/docs/tutorial/index.md
+++ b/docs/uk/docs/tutorial/index.md
@@ -1,4 +1,4 @@
-# Туторіал - Посібник користувача { #tutorial-user-guide }
+# Навчальний посібник - Посібник користувача { #tutorial-user-guide }
У цьому посібнику показано, як користуватися **FastAPI** з більшістю його функцій, крок за кроком.
@@ -10,12 +10,12 @@
Усі блоки коду можна скопіювати та використовувати безпосередньо (це фактично перевірені файли Python).
-Щоб запустити будь-який із прикладів, скопіюйте код у файл `main.py` і запустіть `fastapi dev` за допомогою:
+Щоб запустити будь-який із прикладів, скопіюйте код у файл `main.py`, і запустіть `fastapi dev`:
```console
-$
fastapi dev
main.py
+$
fastapi dev
FastAPI Starting development server 🚀
@@ -62,7 +62,7 @@ $
fastapi dev
@@ -76,7 +76,7 @@ $ pip install "fastapi[standard]"
/// note | Примітка
-Коли ви встановлюєте через `pip install "fastapi[standard]"`, він постачається з деякими типовими необов’язковими стандартними залежностями, включно з `fastapi-cloud-cli`, який дозволяє розгортати в FastAPI Cloud.
+Коли ви встановлюєте через `pip install "fastapi[standard]"`, він постачається з деякими типовими необов’язковими стандартними залежностями, включно з `fastapi-cloud-cli`, який дозволяє розгортати в [FastAPI Cloud](https://fastapicloud.com).
Якщо ви не хочете мати ці необов’язкові залежності, натомість можете встановити `pip install fastapi`.
@@ -84,12 +84,18 @@ $ pip install "fastapi[standard]"
///
+/// tip | Порада
+
+FastAPI має [офіційне розширення для VS Code](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (та Cursor), яке надає багато можливостей, включно з переглядачем операцій шляху, пошуком операцій шляху, навігацією CodeLens у тестах (перехід до визначення з тестів), а також розгортанням і журналами FastAPI Cloud — усе безпосередньо з вашого редактора.
+
+///
+
## Просунутий посібник користувача { #advanced-user-guide }
-Існує також **Просунутий посібник користувача**, який ви зможете прочитати пізніше після цього **Туторіал - Посібник користувача**.
+Існує також **Просунутий посібник користувача**, який ви зможете прочитати пізніше після цього **Навчальний посібник - Посібник користувача**.
**Просунутий посібник користувача** засновано на цьому, використовує ті самі концепції та навчає вас деяким додатковим функціям.
-Але вам слід спочатку прочитати **Туторіал - Посібник користувача** (те, що ви зараз читаєте).
+Але вам слід спочатку прочитати **Навчальний посібник - Посібник користувача** (те, що ви зараз читаєте).
-Він розроблений таким чином, що ви можете створити повну програму лише за допомогою **Туторіал - Посібник користувача**, а потім розширити її різними способами, залежно від ваших потреб, використовуючи деякі з додаткових ідей з **Просунутого посібника користувача**.
+Він розроблений таким чином, що ви можете створити повну програму лише за допомогою **Навчальний посібник - Посібник користувача**, а потім розширити її різними способами, залежно від ваших потреб, використовуючи деякі з додаткових ідей з **Просунутого посібника користувача**.
diff --git a/docs/uk/docs/tutorial/metadata.md b/docs/uk/docs/tutorial/metadata.md
index ebe8dc40e1..ee1fdaf6dd 100644
--- a/docs/uk/docs/tutorial/metadata.md
+++ b/docs/uk/docs/tutorial/metadata.md
@@ -14,7 +14,7 @@
| `version` | `string` | Версія API. Це версія Вашого додатка, а не OpenAPI. Наприклад, `2.5.0`. |
| `terms_of_service` | `str` | URL до умов використання API. Якщо вказано, має бути у форматі URL. |
| `contact` | `dict` | Інформація для контакту з опублікованим API. Може містити кілька полів. contact поля
| Параметр | Тип | Опис |
|---|
name | str | Ідентифікаційне ім'я контактної особи або організації. |
url | str | URL, що вказує на контактну інформацію. МАЄ бути у форматі URL. |
email | str | Адреса електронної пошти контактної особи або організації. МАЄ бути у форматі адреси електронної пошти. |
license_info поля
| Параметр | Тип | Опис |
|---|
name | str | ОБОВ'ЯЗКОВО (якщо встановлено license_info). Назва ліцензії для API. |
identifier | str | Ліцензійний вираз за SPDX для API. Поле identifier взаємовиключне з полем url. Доступно з OpenAPI 3.1.0, FastAPI 0.99.0. |
url | str | URL до ліцензії, яка використовується для API. МАЄ бути у форматі URL. |
license_info поля
| Параметр | Тип | Опис |
|---|
name | str | ОБОВ'ЯЗКОВО (якщо встановлено license_info). Назва ліцензії для API. |
identifier | str | Ліцензійний вираз за [SPDX](https://spdx.org/licenses/) для API. Поле identifier взаємовиключне з полем url. Доступно з OpenAPI 3.1.0, FastAPI 0.99.0. |
url | str | URL до ліцензії, яка використовується для API. МАЄ бути у форматі URL. |
POST.
+Якщо ви хочете дізнатися більше про ці типи кодування та формові поля, ознайомтеся з [MDN web docs для `POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST).
///
diff --git a/docs/uk/docs/tutorial/request-form-models.md b/docs/uk/docs/tutorial/request-form-models.md
index 86510be589..6f785016da 100644
--- a/docs/uk/docs/tutorial/request-form-models.md
+++ b/docs/uk/docs/tutorial/request-form-models.md
@@ -2,11 +2,11 @@
У FastAPI ви можете використовувати **Pydantic-моделі** для оголошення **полів форми**.
-/// info | Інформація
+/// info
-Щоб використовувати форми, спочатку встановіть `python-multipart`.
+Щоб використовувати форми, спочатку встановіть [`python-multipart`](https://github.com/Kludex/python-multipart).
-Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його, а потім встановили його, наприклад:
+Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md), активували його, а потім встановили його, наприклад:
```console
$ pip install python-multipart
@@ -14,7 +14,7 @@ $ pip install python-multipart
///
-/// note | Примітка
+/// note
Це підтримується, починаючи з FastAPI версії `0.113.0`. 🤓
@@ -40,7 +40,7 @@ $ pip install python-multipart
У деяких особливих випадках (ймовірно, не дуже поширених) ви можете **обмежити** поля форми лише тими, які були оголошені в Pydantic-моделі. І **заборонити** будь-які **додаткові** поля.
-/// note | Примітка
+/// note
Це підтримується, починаючи з FastAPI версії `0.114.0`. 🤓
diff --git a/docs/uk/docs/tutorial/request-forms-and-files.md b/docs/uk/docs/tutorial/request-forms-and-files.md
index 817769b714..c6d2548084 100644
--- a/docs/uk/docs/tutorial/request-forms-and-files.md
+++ b/docs/uk/docs/tutorial/request-forms-and-files.md
@@ -4,9 +4,9 @@
/// info | Інформація
-Щоб отримувати завантажені файли та/або дані форми, спочатку встановіть `python-multipart`.
+Щоб отримувати завантажені файли та/або дані форми, спочатку встановіть [`python-multipart`](https://github.com/Kludex/python-multipart).
-Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його, а потім встановили бібліотеку, наприклад:
+Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md), активували його, а потім встановили бібліотеку, наприклад:
```console
$ pip install python-multipart
diff --git a/docs/uk/docs/tutorial/request-forms.md b/docs/uk/docs/tutorial/request-forms.md
index 7f0c6e9bb3..d02b85068b 100644
--- a/docs/uk/docs/tutorial/request-forms.md
+++ b/docs/uk/docs/tutorial/request-forms.md
@@ -4,9 +4,9 @@
/// info | Інформація
-Щоб використовувати форми, спочатку встановіть `python-multipart`.
+Щоб використовувати форми, спочатку встановіть [`python-multipart`](https://github.com/Kludex/python-multipart).
-Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його, і потім встановили бібліотеку, наприклад:
+Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md), активували його, і потім встановили бібліотеку, наприклад:
```console
$ pip install python-multipart
@@ -56,7 +56,7 @@ HTML-форми (``) надсилають дані на серве
Але якщо форма містить файли, вона кодується як `multipart/form-data`. Ви дізнаєтеся про обробку файлів у наступному розділі.
-Якщо ви хочете дізнатися більше про ці кодування та поля форм, зверніться до MDN вебдокументації для POST.
+Якщо ви хочете дізнатися більше про ці кодування та поля форм, зверніться до [MDN вебдокументації для `POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST).
///
diff --git a/docs/uk/docs/tutorial/response-model.md b/docs/uk/docs/tutorial/response-model.md
index fcf765c9da..86f12bff44 100644
--- a/docs/uk/docs/tutorial/response-model.md
+++ b/docs/uk/docs/tutorial/response-model.md
@@ -13,6 +13,7 @@ FastAPI використовуватиме цей тип повернення,
* Додати **JSON Schema** для відповіді в OpenAPI *операції шляху*.
* Це буде використано в **автоматичній документації**.
* Це також буде використано інструментами, які автоматично генерують клієнтський код.
+* **Серіалізувати** повернені дані в JSON за допомогою Pydantic, який написаний мовою **Rust**, тому це буде **набагато швидше**.
Але найголовніше:
@@ -73,9 +74,9 @@ FastAPI використовуватиме цей `response_model` для вик
/// info | Інформація
-Щоб використовувати `EmailStr`, спочатку встановіть `email-validator`.
+Щоб використовувати `EmailStr`, спочатку встановіть [`email-validator`](https://github.com/JoshData/python-email-validator).
-Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його, а потім встановили пакет, наприклад:
+Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md), активували його, а потім встановили пакет, наприклад:
```console
$ pip install email-validator
@@ -101,7 +102,7 @@ $ pip install "pydantic[email]"
/// danger | Обережно
-Ніколи не зберігайте пароль користувача у відкритому вигляді та не надсилайте його у відповіді таким чином, якщо тільки ви не знаєте всіх застережень і точно розумієте, що робите.
+Ніколи не зберігайте пароль користувача у відкритому вигляді та не надсилайте його у відповіді таким чином, якщо тільки ви не знаєте всі застереження і точно розумієте, що робите.
///
@@ -181,7 +182,7 @@ FastAPI виконує кілька внутрішніх операцій з Pyd
### Повернути Response напряму { #return-a-response-directly }
-Найпоширенішим випадком буде [повернення Response напряму, як пояснюється пізніше у розширеній документації](../advanced/response-directly.md){.internal-link target=_blank}.
+Найпоширенішим випадком буде [повернення Response напряму, як пояснюється пізніше у розширеній документації](../advanced/response-directly.md).
{* ../../docs_src/response_model/tutorial003_02_py310.py hl[8,10:11] *}
@@ -257,7 +258,7 @@ FastAPI виконує кілька внутрішніх операцій з Pyd
* `response_model_exclude_defaults=True`
* `response_model_exclude_none=True`
-як описано в документації Pydantic для `exclude_defaults` та `exclude_none`.
+як описано в [документації Pydantic](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict) для `exclude_defaults` та `exclude_none`.
///
diff --git a/docs/uk/docs/tutorial/response-status-code.md b/docs/uk/docs/tutorial/response-status-code.md
index c9ceb8f508..d453510f92 100644
--- a/docs/uk/docs/tutorial/response-status-code.md
+++ b/docs/uk/docs/tutorial/response-status-code.md
@@ -20,7 +20,7 @@
/// info | Інформація
-`status_code` також може, як альтернативу, приймати `IntEnum`, наприклад, Python `http.HTTPStatus`.
+`status_code` також може, як альтернативу, приймати `IntEnum`, наприклад, Python [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus).
///
@@ -66,7 +66,7 @@ FastAPI знає про це і створить документацію OpenAP
/// tip | Порада
-Щоб дізнатися більше про кожен код статусу і для чого призначений кожен із них, перегляньте документацію MDN про HTTP коди статусу.
+Щоб дізнатися більше про кожен код статусу і для чого призначений кожен із них, перегляньте [документацію MDN про HTTP коди статусу](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status).
///
@@ -98,4 +98,4 @@ FastAPI знає про це і створить документацію OpenAP
## Зміна значення за замовчуванням { #changing-the-default }
-Пізніше, у [Посібнику для досвідчених користувачів](../advanced/response-change-status-code.md){.internal-link target=_blank}, ви побачите, як повертати інший код статусу, ніж значення за замовчуванням, яке ви оголошуєте тут.
+Пізніше, у [Просунутому посібнику користувача](../advanced/response-change-status-code.md), ви побачите, як повертати інший код статусу, ніж значення за замовчуванням, яке ви оголошуєте тут.
diff --git a/docs/uk/docs/tutorial/schema-extra-example.md b/docs/uk/docs/tutorial/schema-extra-example.md
index 38ce0eb303..742871e394 100644
--- a/docs/uk/docs/tutorial/schema-extra-example.md
+++ b/docs/uk/docs/tutorial/schema-extra-example.md
@@ -1,34 +1,34 @@
# Декларування прикладів вхідних даних { #declare-request-example-data }
-Ви можете задати приклади даних, які Ваш застосунок може отримувати.
+Ви можете задати приклади даних, які ваш застосунок може отримувати.
Ось кілька способів, як це зробити.
-## Додаткові дані JSON-схеми в моделях Pydantic { #extra-json-schema-data-in-pydantic-models }
+## Додаткові дані Схеми JSON у моделях Pydantic { #extra-json-schema-data-in-pydantic-models }
-Ви можете задати `examples` для моделі Pydantic, які буде додано до згенерованої JSON-схеми.
+Ви можете задати `examples` для моделі Pydantic, які буде додано до згенерованої Схеми JSON.
{* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}
-Ця додаткова інформація буде додана як є до **JSON-схеми** для цієї моделі, і вона буде використана в документації до API.
+Ця додаткова інформація буде додана як є до **Схеми JSON** для цієї моделі, і вона буде використана в документації до API.
-Ви можете використати атрибут `model_config`, який приймає `dict`, як описано в документації Pydantic: Configuration.
+Ви можете використати атрибут `model_config`, який приймає `dict`, як описано в [документації Pydantic: Configuration](https://docs.pydantic.dev/latest/api/config/).
-Ви можете встановити `"json_schema_extra"` як `dict`, що містить будь-які додаткові дані, які Ви хочете відобразити у згенерованій JSON-схемі, включаючи `examples`.
+Ви можете встановити `"json_schema_extra"` як `dict`, що містить будь-які додаткові дані, які ви хочете відобразити у згенерованій Схемі JSON, включаючи `examples`.
/// tip | Порада
-Ви можете використати ту ж техніку, щоб розширити JSON-схему і додати власну додаткову інформацію.
+Ви можете використати ту ж техніку, щоб розширити Схему JSON і додати власну додаткову інформацію.
-Наприклад, Ви можете використати її для додавання метаданих для інтерфейсу користувача на фронтенді тощо.
+Наприклад, ви можете використати її для додавання метаданих для інтерфейсу користувача на фронтенді тощо.
///
/// info | Інформація
-OpenAPI 3.1.0 (який використовується починаючи з FastAPI 0.99.0) додав підтримку `examples`, що є частиною стандарту **JSON-схеми**.
+OpenAPI 3.1.0 (який використовується починаючи з FastAPI 0.99.0) додав підтримку `examples`, що є частиною стандарту **Схеми JSON**.
-До цього підтримувався лише ключ `example` з одним прикладом. Він все ще підтримується в OpenAPI 3.1.0, але є застарілим і не входить до стандарту JSON Schema. Тому рекомендується перейти з `example` на `examples`. 🤓
+До цього підтримувався лише ключ `example` з одним прикладом. Він все ще підтримується в OpenAPI 3.1.0, але є застарілим і не входить до стандарту Схеми JSON. Тому рекомендується перейти з `example` на `examples`. 🤓
Більше про це можна прочитати в кінці цієї сторінки.
@@ -36,11 +36,11 @@ OpenAPI 3.1.0 (який використовується починаючи з F
## Додаткові аргументи `Field` { #field-additional-arguments }
-Коли ви використовуєте `Field()` у моделях Pydantic, Ви також можете вказати додаткові `examples`:
+Коли ви використовуєте `Field()` у моделях Pydantic, ви також можете вказати додаткові `examples`:
{* ../../docs_src/schema_extra_example/tutorial002_py310.py hl[2,8:11] *}
-## `examples` у JSON-схемі - OpenAPI { #examples-in-json-schema-openapi }
+## `examples` у Схемі JSON - OpenAPI { #examples-in-json-schema-openapi }
При використанні будь-кого з наступного:
@@ -52,7 +52,7 @@ OpenAPI 3.1.0 (який використовується починаючи з F
* `Form()`
* `File()`
-Ви також можете задати набір `examples` з додатковою інформацією, яка буде додана до їхніх **JSON-схем** у **OpenAPI**.
+ви також можете задати набір `examples` з додатковою інформацією, яка буде додана до їхніх **Схем JSON** у **OpenAPI**.
### `Body` з `examples` { #body-with-examples }
@@ -68,25 +68,25 @@ OpenAPI 3.1.0 (який використовується починаючи з F
### `Body` з кількома `examples` { #body-with-multiple-examples }
-Звичайно, Ви також можете передати кілька `examples`:
+Звичайно, ви також можете передати кілька `examples`:
{* ../../docs_src/schema_extra_example/tutorial004_an_py310.py hl[23:38] *}
-Коли Ви це робите, приклади будуть частиною внутрішньої **JSON-схеми** для цих даних тіла.
+Коли ви це робите, приклади будуть частиною внутрішньої **Схеми JSON** для цих даних тіла.
-Втім, на час написання цього, Swagger UI — інструмент, який відповідає за відображення UI документації — не підтримує показ кількох прикладів для даних у **JSON-схемі**. Але нижче можна прочитати про обхідний шлях.
+Втім, на час написання цього, Swagger UI - інструмент, який відповідає за відображення UI документації - не підтримує показ кількох прикладів для даних у **Схемі JSON**. Але нижче можна прочитати про обхідний шлях.
### Специфічні для OpenAPI `examples` { #openapi-specific-examples }
-Ще до того, як **JSON-схема** почала підтримувати `examples`, OpenAPI вже мала підтримку іншого поля, яке також називається `examples`.
+Ще до того, як **Схема JSON** почала підтримувати `examples`, OpenAPI вже мала підтримку іншого поля, яке також називається `examples`.
-Це **специфічне для OpenAPI** поле `examples` розміщується в іншому розділі специфікації OpenAPI. Воно розміщується в **деталях кожної *операції шляху***, а не всередині кожної JSON-схеми.
+Це **специфічне для OpenAPI** поле `examples` розміщується в іншому розділі специфікації OpenAPI. Воно розміщується в **деталях кожної *операції шляху***, а не всередині кожної Схеми JSON.
-І Swagger UI вже давно підтримує це поле `examples`. Тому Ви можете використовувати його, щоб **відображати** різні **приклади в UI документації**.
+І Swagger UI вже давно підтримує це поле `examples`. Тому ви можете використовувати його, щоб **відображати** різні **приклади в UI документації**.
-Форма цього специфічного для OpenAPI поля `examples` — це `dict` з **кількома прикладами** (а не `list`), кожен із яких має додаткову інформацію, яка також буде додана до **OpenAPI**.
+Форма цього специфічного для OpenAPI поля `examples` - це `dict` з **кількома прикладами** (а не `list`), кожен із яких має додаткову інформацію, яка також буде додана до **OpenAPI**.
-Воно не включається всередину кожної JSON-схеми, що міститься в OpenAPI, воно розміщується зовні, безпосередньо в *операції шляху*.
+Воно не включається всередину кожної Схеми JSON, що міститься в OpenAPI, воно розміщується зовні, безпосередньо в *операції шляху*.
### Використання параметра `openapi_examples` { #using-the-openapi-examples-parameter }
@@ -100,7 +100,7 @@ OpenAPI 3.1.0 (який використовується починаючи з F
* `Form()`
* `File()`
-Ключі `dict` ідентифікують кожен приклад, а кожне значення — це інший `dict`.
+Ключі `dict` ідентифікують кожен приклад, а кожне значення - це інший `dict`.
Кожен специфічний `dict` прикладу в `examples` може містити:
@@ -123,34 +123,34 @@ OpenAPI 3.1.0 (який використовується починаючи з F
/// tip | Порада
-Якщо Ви вже використовуєте **FastAPI** версії **0.99.0 або вище**, Ви, ймовірно, можете **пропустити** ці технічні деталі.
+Якщо ви вже використовуєте **FastAPI** версії **0.99.0 або вище**, ви, ймовірно, можете **пропустити** ці технічні деталі.
Вони більш актуальні для старих версій, до появи OpenAPI 3.1.0.
-Можна вважати це коротким **історичним екскурсом** у OpenAPI та JSON Schema. 🤓
+Можна вважати це коротким **історичним екскурсом** у OpenAPI та Схему JSON. 🤓
///
/// warning | Попередження
-Це дуже технічна інформація про стандарти **JSON Schema** і **OpenAPI**.
+Це дуже технічна інформація про стандарти **Схема JSON** і **OpenAPI**.
-Якщо вищезгадані ідеї вже працюють у Вас, цього може бути достатньо, і Вам, ймовірно, не потрібні ці деталі — можете пропустити.
+Якщо вищезгадані ідеї вже працюють у вас, цього може бути достатньо, і вам, ймовірно, не потрібні ці деталі - можете пропустити.
///
-До OpenAPI 3.1.0 OpenAPI використовував стару та модифіковану версію **JSON Schema**.
+До OpenAPI 3.1.0 OpenAPI використовував стару та модифіковану версію **Схеми JSON**.
-JSON Schema не мала `examples`, тож OpenAPI додала власне поле `example` до своєї модифікованої версії.
+Схема JSON не мала `examples`, тож OpenAPI додала власне поле `example` до своєї модифікованої версії.
OpenAPI також додала поля `example` і `examples` до інших частин специфікації:
-* `Parameter Object` (в специфікації), який використовувався утилітами FastAPI:
+* [`Parameter Object` (у специфікації)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object), який використовувався утилітами FastAPI:
* `Path()`
* `Query()`
* `Header()`
* `Cookie()`
-* `Request Body Object`, у полі `content`, у `Media Type Object` (в специфікації), який використовувався утилітами FastAPI:
+* [`Request Body Object`, у полі `content`, у `Media Type Object` (у специфікації)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object), який використовувався утилітами FastAPI:
* `Body()`
* `File()`
* `Form()`
@@ -161,19 +161,19 @@ OpenAPI також додала поля `example` і `examples` до інших
///
-### Поле `examples` у JSON Schema { #json-schemas-examples-field }
+### Поле `examples` у Схемі JSON { #json-schemas-examples-field }
-Пізніше JSON Schema додала поле `examples` у нову версію специфікації.
+Пізніше Схема JSON додала поле [`examples`](https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.9.5) у нову версію специфікації.
А потім новий OpenAPI 3.1.0 базувався на найновішій версії (JSON Schema 2020-12), яка включала це нове поле `examples`.
І тепер це нове поле `examples` має вищий пріоритет за старе одиночне (і кастомне) поле `example`, яке тепер є застарілим.
-Це нове поле `examples` у JSON Schema — це **просто `list`** прикладів, а не `dict` з додатковими метаданими, як в інших місцях OpenAPI (описаних вище).
+Це нове поле `examples` у Схемі JSON - це **просто `list`** прикладів, а не `dict` з додатковими метаданими, як в інших місцях OpenAPI (описаних вище).
/// info | Інформація
-Навіть після релізу OpenAPI 3.1.0 з цією новою простішою інтеграцією з JSON Schema, протягом певного часу Swagger UI, інструмент, який надає автоматичну документацію, не підтримував OpenAPI 3.1.0 (тепер підтримує, починаючи з версії 5.0.0 🎉).
+Навіть після релізу OpenAPI 3.1.0 з цією новою простішою інтеграцією зі Схемою JSON, протягом певного часу Swagger UI, інструмент, який надає автоматичну документацію, не підтримував OpenAPI 3.1.0 (тепер підтримує, починаючи з версії 5.0.0 🎉).
Через це версії FastAPI до 0.99.0 все ще використовували версії OpenAPI нижчі за 3.1.0.
@@ -181,22 +181,22 @@ OpenAPI також додала поля `example` і `examples` до інших
### `examples` у Pydantic і FastAPI { #pydantic-and-fastapi-examples }
-Коли Ви додаєте `examples` у модель Pydantic через `schema_extra` або `Field(examples=["something"])`, цей приклад додається до **JSON Schema** для цієї моделі Pydantic.
+Коли ви додаєте `examples` у модель Pydantic через `schema_extra` або `Field(examples=["something"])`, цей приклад додається до **Схеми JSON** для цієї моделі Pydantic.
-І ця **JSON Schema** Pydantic-моделі включається до **OpenAPI** Вашого API, а потім використовується в UI документації.
+І ця **Схема JSON** Pydantic-моделі включається до **OpenAPI** вашого API, а потім використовується в UI документації.
-У версіях FastAPI до 0.99.0 (0.99.0 і вище використовують новіший OpenAPI 3.1.0), коли Ви використовували `example` або `examples` з будь-якими іншими утилітами (`Query()`, `Body()` тощо), ці приклади не додавалися до JSON Schema, що описує ці дані (навіть не до власної версії JSON Schema в OpenAPI), натомість вони додавалися безпосередньо до декларації *операції шляху* в OpenAPI (поза межами частин OpenAPI, які використовують JSON Schema).
+У версіях FastAPI до 0.99.0 (0.99.0 і вище використовують новіший OpenAPI 3.1.0), коли ви використовували `example` або `examples` з будь-якими іншими утилітами (`Query()`, `Body()` тощо), ці приклади не додавалися до Схеми JSON, що описує ці дані (навіть не до власної версії Схеми JSON в OpenAPI), натомість вони додавалися безпосередньо до декларації *операції шляху* в OpenAPI (поза межами частин OpenAPI, які використовують Схему JSON).
-Але тепер, коли FastAPI 0.99.0 і вище використовує OpenAPI 3.1.0, який використовує JSON Schema 2020-12, і Swagger UI 5.0.0 і вище, все стало більш узгодженим, і приклади включаються до JSON Schema.
+Але тепер, коли FastAPI 0.99.0 і вище використовує OpenAPI 3.1.0, який використовує JSON Schema 2020-12, і Swagger UI 5.0.0 і вище, все стало більш узгодженим, і приклади включаються до Схеми JSON.
### Swagger UI та специфічні для OpenAPI `examples` { #swagger-ui-and-openapi-specific-examples }
-Оскільки Swagger UI не підтримував кілька прикладів JSON Schema (станом на 2023-08-26), користувачі не мали можливості показати кілька прикладів у документації.
+Оскільки Swagger UI не підтримував кілька прикладів Схеми JSON (станом на 2023-08-26), користувачі не мали можливості показати кілька прикладів у документації.
Щоб вирішити це, FastAPI `0.103.0` **додав підтримку** оголошення того самого старого **OpenAPI-специфічного** поля `examples` через новий параметр `openapi_examples`. 🤓
### Підсумок { #summary }
-Раніше я казав, що не дуже люблю історію... а тепер подивіться на мене — читаю «технічні історичні» лекції. 😅
+Раніше я казав, що не дуже люблю історію... а тепер подивіться на мене - читаю «технічні історичні» лекції. 😅
-Коротко: **оновіться до FastAPI 0.99.0 або вище** — і все стане значно **простішим, узгодженим та інтуїтивно зрозумілим**, і Вам не доведеться знати всі ці історичні деталі. 😎
+Коротко: **оновіться до FastAPI 0.99.0 або вище** - і все стане значно **простішим, узгодженим та інтуїтивно зрозумілим**, і вам не доведеться знати всі ці історичні деталі. 😎
diff --git a/docs/uk/docs/tutorial/security/first-steps.md b/docs/uk/docs/tutorial/security/first-steps.md
index 491328d865..bfe1962234 100644
--- a/docs/uk/docs/tutorial/security/first-steps.md
+++ b/docs/uk/docs/tutorial/security/first-steps.md
@@ -26,11 +26,11 @@
/// info | Інформація
-Пакет `python-multipart` автоматично встановлюється з **FastAPI**, коли ви виконуєте команду `pip install "fastapi[standard]"`.
+Пакет [`python-multipart`](https://github.com/Kludex/python-multipart) автоматично встановлюється з **FastAPI**, коли ви виконуєте команду `pip install "fastapi[standard]"`.
Однак, якщо ви використовуєте команду `pip install fastapi`, пакет `python-multipart` за замовчуванням не включено.
-Щоб встановити його вручну, переконайтеся, що ви створили [віртуальне оточення](../../virtual-environments.md){.internal-link target=_blank}, активували його, а потім встановили:
+Щоб встановити його вручну, переконайтеся, що ви створили [віртуальне оточення](../../virtual-environments.md), активували його, а потім встановили:
```console
$ pip install python-multipart
@@ -45,7 +45,7 @@ $ pip install python-multipart
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -54,7 +54,7 @@ $ fastapi dev main.py
## Перевірте { #check-it }
-Перейдіть до інтерактивної документації:
http://127.0.0.1:8000/docs.
+Перейдіть до інтерактивної документації: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Ви побачите щось подібне:
@@ -140,7 +140,7 @@ OAuth2 був спроєктований так, щоб backend або API мо
Тому, якщо ваш API розміщений на `https://example.com/`, це буде `https://example.com/token`. А якщо на `https://example.com/api/v1/`, тоді це буде `https://example.com/api/v1/token`.
-Використання відносної URL-адреси важливе, щоб ваша програма продовжувала працювати навіть у просунутому сценарії, як-от [Behind a Proxy](../../advanced/behind-a-proxy.md){.internal-link target=_blank}.
+Використання відносної URL-адреси важливе, щоб ваша програма продовжувала працювати навіть у просунутому сценарії, як-от [За представником](../../advanced/behind-a-proxy.md).
///
diff --git a/docs/uk/docs/tutorial/security/oauth2-jwt.md b/docs/uk/docs/tutorial/security/oauth2-jwt.md
index f94abb897b..64774af6d0 100644
--- a/docs/uk/docs/tutorial/security/oauth2-jwt.md
+++ b/docs/uk/docs/tutorial/security/oauth2-jwt.md
@@ -24,13 +24,13 @@ eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4
Через тиждень токен завершить термін дії, і користувач не буде авторизований та має знову увійти, щоб отримати новий токен. І якщо користувач (або третя сторона) намагатиметься змінити токен, щоб змінити термін дії, ви це виявите, бо підписи не співпадатимуть.
-Якщо хочете «погратися» з токенами JWT і побачити, як вони працюють, перегляньте
https://jwt.io.
+Якщо хочете «погратися» з токенами JWT і побачити, як вони працюють, перегляньте [https://jwt.io](https://jwt.io/).
## Встановіть `PyJWT` { #install-pyjwt }
Нам потрібно встановити `PyJWT`, щоб створювати та перевіряти токени JWT у Python.
-Переконайтеся, що ви створили [віртуальне оточення](../../virtual-environments.md){.internal-link target=_blank}, активували його і тоді встановіть `pyjwt`:
+Переконайтеся, що ви створили [віртуальне оточення](../../virtual-environments.md), активували його і тоді встановіть `pyjwt`:
@@ -46,7 +46,7 @@ $ pip install pyjwt
Якщо ви плануєте використовувати алгоритми цифрового підпису на кшталт RSA або ECDSA, слід встановити залежність криптобібліотеки `pyjwt[crypto]`.
-Докладніше про це можна прочитати у
документації з встановлення PyJWT.
+Докладніше про це можна прочитати у [документації з встановлення PyJWT](https://pyjwt.readthedocs.io/en/latest/installation.html).
///
@@ -72,7 +72,7 @@ pwdlib - це чудовий пакет Python для роботи з хешам
Рекомендований алгоритм - «Argon2».
-Переконайтеся, що ви створили [віртуальне оточення](../../virtual-environments.md){.internal-link target=_blank}, активували його і тоді встановіть pwdlib з Argon2:
+Переконайтеся, що ви створили [віртуальне оточення](../../virtual-environments.md), активували його і тоді встановіть pwdlib з Argon2:
@@ -200,7 +200,7 @@ JWT може використовуватися й для інших речей,
## Перевірте { #check-it }
-Запустіть сервер і перейдіть до документації:
http://127.0.0.1:8000/docs.
+Запустіть сервер і перейдіть до документації: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Ви побачите такий інтерфейс користувача:
diff --git a/docs/uk/docs/tutorial/security/simple-oauth2.md b/docs/uk/docs/tutorial/security/simple-oauth2.md
index 05f949738d..7c83e4c2a7 100644
--- a/docs/uk/docs/tutorial/security/simple-oauth2.md
+++ b/docs/uk/docs/tutorial/security/simple-oauth2.md
@@ -146,7 +146,7 @@ UserInDB(
/// info | Інформація
-Для повнішого пояснення `**user_dict` перегляньте [документацію для **Додаткових моделей**](../extra-models.md#about-user-in-dict){.internal-link target=_blank}.
+Для повнішого пояснення `**user_dict` перегляньте [документацію для **Додаткових моделей**](../extra-models.md#about-user-in-dict).
///
@@ -216,7 +216,7 @@ UserInDB(
## Подивіться в дії { #see-it-in-action }
-Відкрийте інтерактивну документацію:
http://127.0.0.1:8000/docs.
+Відкрийте інтерактивну документацію: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
### Автентифікація { #authenticate }
diff --git a/docs/uk/docs/tutorial/server-sent-events.md b/docs/uk/docs/tutorial/server-sent-events.md
new file mode 100644
index 0000000000..8234085cfa
--- /dev/null
+++ b/docs/uk/docs/tutorial/server-sent-events.md
@@ -0,0 +1,120 @@
+# Події, надіслані сервером (SSE) { #server-sent-events-sse }
+
+Ви можете транслювати дані клієнту за допомогою **Server-Sent Events** (SSE).
+
+Це подібно до [Потік JSON Lines](stream-json-lines.md), але використовує формат `text/event-stream`, який нативно підтримується браузерами через [API `EventSource`](https://developer.mozilla.org/en-US/docs/Web/API/EventSource).
+
+/// info | Інформація
+
+Додано у FastAPI 0.135.0.
+
+///
+
+## Що таке Server-Sent Events { #what-are-server-sent-events }
+
+SSE - це стандарт для трансляції даних із сервера до клієнта по HTTP.
+
+Кожна подія - це невеликий текстовий блок із «полями» на кшталт `data`, `event`, `id` та `retry`, розділений порожніми рядками.
+
+Виглядає так:
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+SSE часто використовують для стрімінгу чатів ШІ, живих сповіщень, логів і спостережуваності, а також інших випадків, коли сервер надсилає оновлення клієнту.
+
+/// tip | Порада
+
+Якщо ви хочете транслювати бінарні дані, наприклад відео чи аудіо, перегляньте просунутий посібник: [Потік даних](../advanced/stream-data.md).
+
+///
+
+## Стрімінг SSE у FastAPI { #stream-sse-with-fastapi }
+
+Щоб транслювати SSE з FastAPI, використовуйте `yield` у вашій *функції операції шляху* і встановіть `response_class=EventSourceResponse`.
+
+Імпортуйте `EventSourceResponse` з `fastapi.sse`:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+Кожен елемент, повернений через `yield`, кодується як JSON і надсилається в полі `data:` події SSE.
+
+Якщо ви оголосите тип повернення як `AsyncIterable[Item]`, FastAPI використає його, щоб **перевіряти**, **документувати** і **серіалізувати** дані за допомогою Pydantic.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[10:12,23] *}
+
+/// tip | Порада
+
+Оскільки Pydantic серіалізує це на боці **Rust**, ви отримаєте значно вищу **продуктивність**, ніж якби не оголошували тип повернення.
+
+///
+
+### Не-async *функції операцій шляху* { #non-async-path-operation-functions }
+
+Ви також можете використовувати звичайні функції `def` (без `async`) і використовувати `yield` так само.
+
+FastAPI подбає про коректне виконання, щоб воно не блокувало цикл подій.
+
+Оскільки в цьому випадку функція не async, коректним типом повернення буде `Iterable[Item]`:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[28:31] hl[29] *}
+
+### Без типу повернення { #no-return-type }
+
+Можна також опустити тип повернення. FastAPI використає [`jsonable_encoder`](./encoder.md), щоб конвертувати дані і надіслати їх.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+Якщо вам потрібно встановити поля SSE, такі як `event`, `id`, `retry` або `comment`, ви можете повертати через `yield` об'єкти `ServerSentEvent` замість звичайних даних.
+
+Імпортуйте `ServerSentEvent` з `fastapi.sse`:
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+Поле `data` завжди кодується як JSON. Ви можете передати будь-яке значення, яке можна серіалізувати в JSON, включно з моделями Pydantic.
+
+## Сирі дані { #raw-data }
+
+Якщо потрібно надіслати дані **без** кодування в JSON, використовуйте `raw_data` замість `data`.
+
+Це корисно для надсилання попередньо відформатованого тексту, рядків логів або спеціальних значень
«значення-сторож», як-от `[DONE]`.
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | Примітка
+
+`data` і `raw_data` взаємовиключні. У кожному `ServerSentEvent` ви можете встановити лише одне з них.
+
+///
+
+## Відновлення з `Last-Event-ID` { #resuming-with-last-event-id }
+
+Коли браузер перепідключається після розриву з'єднання, він надсилає останній отриманий `id` у заголовку `Last-Event-ID`.
+
+Ви можете прочитати його як параметр заголовка і використати, щоб відновити потік із місця, де клієнт зупинився:
+
+{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}
+
+## SSE з POST { #sse-with-post }
+
+SSE працює з **будь-яким HTTP-методом**, не лише з `GET`.
+
+Це корисно для протоколів на кшталт [MCP](https://modelcontextprotocol.io), які транслюють SSE через `POST`:
+
+{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}
+
+## Технічні деталі { #technical-details }
+
+FastAPI реалізує деякі найкращі практики SSE «з коробки».
+
+- Надсилати **коментар «keep alive» `ping`** кожні 15 секунд, коли не було жодного повідомлення, щоб запобігти закриттю з'єднання деякими проксі, як рекомендовано у [Специфікації HTML: Події, надіслані сервером](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes).
+- Встановити заголовок `Cache-Control: no-cache`, щоб **запобігти кешуванню** потоку.
+- Встановити спеціальний заголовок `X-Accel-Buffering: no`, щоб **запобігти буферизації** у деяких проксі, наприклад Nginx.
+
+Вам не потрібно нічого з цим робити, воно працює «з коробки». 🤓
diff --git a/docs/uk/docs/tutorial/sql-databases.md b/docs/uk/docs/tutorial/sql-databases.md
index 991d1e33aa..57b67226a0 100644
--- a/docs/uk/docs/tutorial/sql-databases.md
+++ b/docs/uk/docs/tutorial/sql-databases.md
@@ -2,9 +2,9 @@
**FastAPI** не вимагає від вас використовувати SQL (реляційну) базу даних. Але ви можете скористатися будь-якою базою даних, яку забажаєте.
-Тут ми розглянемо приклад з
SQLModel.
+Тут ми розглянемо приклад з [SQLModel](https://sqlmodel.tiangolo.com/).
-**SQLModel** побудовано поверх
SQLAlchemy та Pydantic. Її створив той самий автор, що і **FastAPI**, як ідеальну пару для застосунків FastAPI, яким потрібні **SQL бази даних**.
+**SQLModel** побудовано поверх [SQLAlchemy](https://www.sqlalchemy.org/) та Pydantic. Її створив той самий автор, що і **FastAPI**, як ідеальну пару для застосунків FastAPI, яким потрібні **SQL бази даних**.
/// tip | Порада
@@ -26,15 +26,15 @@
/// tip | Порада
-Існує офіційний генератор проєкту з **FastAPI** та **PostgreSQL**, включно з фронтендом та іншими інструментами:
https://github.com/fastapi/full-stack-fastapi-template
+Існує офіційний генератор проєкту з **FastAPI** та **PostgreSQL**, включно з фронтендом та іншими інструментами: [https://github.com/fastapi/full-stack-fastapi-template](https://github.com/fastapi/full-stack-fastapi-template)
///
-Це дуже простий і короткий навчальний посібник. Якщо ви хочете вивчити бази даних загалом, SQL або більш просунуті можливості, зверніться до
документації SQLModel.
+Це дуже простий і короткий навчальний посібник. Якщо ви хочете вивчити бази даних загалом, SQL або більш просунуті можливості, зверніться до [документації SQLModel](https://sqlmodel.tiangolo.com/).
## Встановіть `SQLModel` { #install-sqlmodel }
-Спочатку переконайтеся, що ви створили [віртуальне оточення](../virtual-environments.md){.internal-link target=_blank}, активували його та встановили `sqlmodel`:
+Спочатку переконайтеся, що ви створили [віртуальне оточення](../virtual-environments.md), активували його та встановили `sqlmodel`:
@@ -65,7 +65,7 @@ $ pip install sqlmodel
* `Field(primary_key=True)` каже SQLModel, що `id` - це **первинний ключ** у SQL базі даних (більше про первинні ключі в SQL див. у документації SQLModel).
- Примітка: Ми використовуємо `int | None` для поля первинного ключа, щоб у Python-коді можна було створити об’єкт без `id` (`id=None`), припускаючи, що база даних згенерує його під час збереження. SQLModel розуміє, що `id` надасть база даних, і визначає стовпець як ненульовий `INTEGER` у схемі бази даних. Докладніше див.
документацію SQLModel про первинні ключі.
+ Примітка: Ми використовуємо `int | None` для поля первинного ключа, щоб у Python-коді можна було створити об’єкт без `id` (`id=None`), припускаючи, що база даних згенерує його під час збереження. SQLModel розуміє, що `id` надасть база даних, і визначає стовпець як ненульовий `INTEGER` у схемі бази даних. Докладніше див. [документацію SQLModel про первинні ключі](https://sqlmodel.tiangolo.com/tutorial/create-db-and-table/#primary-key-id).
* `Field(index=True)` каже SQLModel створити **SQL-індекс** для цього стовпця, що дозволить швидше виконувати пошук у базі даних під час читання даних, відфільтрованих за цим стовпцем.
@@ -111,7 +111,7 @@ $ pip install sqlmodel
/// tip | Порада
-SQLModel матиме утиліти міграцій-обгортки над Alembic, але поки що ви можете використовувати
Alembic напряму.
+SQLModel матиме утиліти міграцій-обгортки над Alembic, але поки що ви можете використовувати [Alembic](https://alembic.sqlalchemy.org/en/latest/) напряму.
///
@@ -152,7 +152,7 @@ SQLModel матиме утиліти міграцій-обгортки над Al
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -337,7 +337,7 @@ $ fastapi dev main.py
```console
-$ fastapi dev main.py
+$ fastapi dev
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
@@ -352,6 +352,6 @@ $ fastapi dev main.py
## Підсумок { #recap }
-Ви можете використовувати
**SQLModel** для взаємодії з SQL базою даних і спростити код за допомогою «моделей даних» та «табличних моделей».
+Ви можете використовувати [**SQLModel**](https://sqlmodel.tiangolo.com/) для взаємодії з SQL базою даних і спростити код за допомогою «моделей даних» та «табличних моделей».
-Багато чого ще можна дізнатися в документації **SQLModel**, там є розширений міні-
навчальний посібник з використання SQLModel з **FastAPI**. 🚀
+Багато чого ще можна дізнатися в документації **SQLModel**, там є розширений міні-[навчальний посібник з використання SQLModel з **FastAPI**](https://sqlmodel.tiangolo.com/tutorial/fastapi/). 🚀
diff --git a/docs/uk/docs/tutorial/static-files.md b/docs/uk/docs/tutorial/static-files.md
index 7f45973df3..2141744c33 100644
--- a/docs/uk/docs/tutorial/static-files.md
+++ b/docs/uk/docs/tutorial/static-files.md
@@ -23,7 +23,7 @@
Це відрізняється від використання `APIRouter`, оскільки під'єднаний застосунок є повністю незалежним. OpenAPI та документація вашого основного застосунку не будуть знати нічого про ваш під'єднаний застосунок тощо.
-Ви можете дізнатися більше про це в [Посібнику для просунутих користувачів](../advanced/index.md){.internal-link target=_blank}.
+Ви можете дізнатися більше про це в [Посібнику для просунутих користувачів](../advanced/index.md).
## Деталі { #details }
@@ -37,4 +37,4 @@
## Додаткова інформація { #more-info }
-Детальніше про налаштування та можливості можна дізнатися в
документації Starlette про статичні файли.
+Детальніше про налаштування та можливості можна дізнатися в [документації Starlette про статичні файли](https://www.starlette.dev/staticfiles/).
diff --git a/docs/uk/docs/tutorial/stream-json-lines.md b/docs/uk/docs/tutorial/stream-json-lines.md
new file mode 100644
index 0000000000..f7be4a1b24
--- /dev/null
+++ b/docs/uk/docs/tutorial/stream-json-lines.md
@@ -0,0 +1,111 @@
+# Стрімінг JSON Lines { #stream-json-lines }
+
+У вас може бути послідовність даних, яку ви хочете надсилати у **«потоці»**, це можна зробити за допомогою **JSON Lines**.
+
+/// info | Інформація
+
+Додано в FastAPI 0.134.0.
+
+///
+
+## Що таке потік { #what-is-a-stream }
+
+«**Стрімінг**» даних означає, що ваш застосунок почне надсилати елементи даних клієнту, не чекаючи, доки буде готова вся послідовність елементів.
+
+Тобто він надішле перший елемент, клієнт його отримає і почне обробляти, а ви в цей час уже можете створювати наступний елемент.
+
+```mermaid
+sequenceDiagram
+ participant App
+ participant Client
+
+ App->>App: Produce Item 1
+ App->>Client: Send Item 1
+ App->>App: Produce Item 2
+ Client->>Client: Process Item 1
+ App->>Client: Send Item 2
+ App->>App: Produce Item 3
+ Client->>Client: Process Item 2
+ App->>Client: Send Item 3
+ Client->>Client: Process Item 3
+ Note over App: Keeps producing...
+ Note over Client: Keeps consuming...
+```
+
+Це може бути навіть нескінченний потік, у якому ви постійно надсилаєте дані.
+
+## JSON Lines { #json-lines }
+
+У таких випадках часто надсилають «**JSON Lines**» - формат, у якому ви надсилаєте по одному об’єкту JSON на рядок.
+
+Відповідь матиме тип вмісту `application/jsonl` (замість `application/json`), а тіло буде приблизно таким:
+
+```json
+{"name": "Plumbus", "description": "A multi-purpose household device."}
+{"name": "Portal Gun", "description": "A portal opening device."}
+{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
+```
+
+Це дуже схоже на масив JSON (еквівалент списку Python), але замість того, щоб бути загорнутим у `[]` і мати `,` між елементами, тут є **по одному об’єкту JSON на рядок**, вони розділені символом нового рядка.
+
+/// info | Інформація
+
+Важливо те, що ваш застосунок зможе по черзі створювати кожен рядок, поки клієнт споживає попередні рядки.
+
+///
+
+/// note | Технічні деталі
+
+Оскільки кожен об’єкт JSON буде розділено новим рядком, він не може містити буквальні символи нового рядка у своєму вмісті, але може містити екрановані нові рядки (`\n`), що є частиною стандарту JSON.
+
+Зазвичай про це не треба турбуватися, усе робиться автоматично, читайте далі. 🤓
+
+///
+
+## Випадки використання { #use-cases }
+
+Ви можете використовувати це, щоб стрімити дані зі служби **AI LLM**, із **логів** чи **телеметрії**, або з інших типів даних, які можна структурувати як елементи **JSON**.
+
+/// tip | Порада
+
+Якщо ви хочете стрімити бінарні дані, наприклад відео чи аудіо, перегляньте просунутий посібник: [Потокова передача даних](../advanced/stream-data.md).
+
+///
+
+## Стрімінг JSON Lines з FastAPI { #stream-json-lines-with-fastapi }
+
+Щоб стрімити JSON Lines з FastAPI, замість використання `return` у вашій *функції операції шляху* використовуйте `yield`, щоб по черзі створювати кожен елемент.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[24] *}
+
+Якщо кожен елемент JSON, який ви хочете надіслати у відповідь, має тип `Item` (модель Pydantic) і це async-функція, ви можете оголосити тип повернення як `AsyncIterable[Item]`:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[9:11,22] *}
+
+Якщо ви оголосите тип повернення, FastAPI використає його, щоб **перевіряти** дані, **документувати** їх в OpenAPI, **фільтрувати** їх і **серіалізувати** за допомогою Pydantic.
+
+/// tip | Порада
+
+Оскільки Pydantic серіалізуватиме це на боці **Rust**, ви отримаєте значно вищу **продуктивність**, ніж якби не оголошували тип повернення.
+
+///
+
+### Не-async *функції операцій шляху* { #non-async-path-operation-functions }
+
+Ви також можете використовувати звичайні функції `def` (без `async`) і використовувати `yield` так само.
+
+FastAPI подбає про коректне виконання, щоб це не блокувало цикл подій.
+
+Оскільки в цьому випадку функція не є async, правильним типом повернення буде `Iterable[Item]`:
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[27:30] hl[28] *}
+
+### Без типу повернення { #no-return-type }
+
+Ви також можете опустити тип повернення. Тоді FastAPI використає [`jsonable_encoder`](./encoder.md), щоб перетворити дані на щось, що можна серіалізувати в JSON, і потім надішле їх як JSON Lines.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[33:36] hl[34] *}
+
+## Події, надіслані сервером (SSE) { #server-sent-events-sse }
+
+FastAPI також має повноцінну підтримку Server-Sent Events (SSE), які досить схожі, але мають кілька додаткових деталей. Ви можете дізнатися про них у наступному розділі: [Події, надіслані сервером (SSE)](server-sent-events.md). 🤓
diff --git a/docs/uk/docs/tutorial/testing.md b/docs/uk/docs/tutorial/testing.md
index ff32e9fb66..ccae2303a4 100644
--- a/docs/uk/docs/tutorial/testing.md
+++ b/docs/uk/docs/tutorial/testing.md
@@ -1,18 +1,18 @@
# Тестування { #testing }
-Завдяки
Starlette тестувати застосунки **FastAPI** просто й приємно.
+Завдяки [Starlette](https://www.starlette.dev/testclient/), тестувати застосунки **FastAPI** просто й приємно.
-Воно базується на
HTTPX, який, своєю чергою, спроєктований на основі Requests, тож він дуже знайомий та інтуїтивно зрозумілий.
+Воно базується на [HTTPX](https://www.python-httpx.org), який, своєю чергою, спроєктований на основі Requests, тож він дуже знайомий та інтуїтивно зрозумілий.
-З його допомогою ви можете використовувати
pytest безпосередньо з **FastAPI**.
+З його допомогою ви можете використовувати [pytest](https://docs.pytest.org/) безпосередньо з **FastAPI**.
## Використання `TestClient` { #using-testclient }
/// info | Інформація
-Щоб використовувати `TestClient`, спочатку встановіть
`httpx`.
+Щоб використовувати `TestClient`, спочатку встановіть [`httpx`](https://www.python-httpx.org).
-Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його, а потім встановили `httpx`, наприклад:
+Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md), активували його, а потім встановили `httpx`, наприклад:
```console
$ pip install httpx
@@ -52,7 +52,7 @@ $ pip install httpx
/// tip | Порада
-Якщо ви хочете викликати `async`-функції у ваших тестах, окрім відправлення запитів до вашого застосунку FastAPI (наприклад, асинхронні функції роботи з базою даних), перегляньте [Async Tests](../advanced/async-tests.md){.internal-link target=_blank} у розширеному керівництві.
+Якщо ви хочете викликати `async`-функції у ваших тестах, окрім відправлення запитів до вашого застосунку FastAPI (наприклад, асинхронні функції роботи з базою даних), перегляньте [Async Tests](../advanced/async-tests.md) у розширеному керівництві.
///
@@ -64,7 +64,7 @@ $ pip install httpx
### Файл застосунку **FastAPI** { #fastapi-app-file }
-Припустимо, у вас є структура файлів, описана в розділі [Bigger Applications](bigger-applications.md){.internal-link target=_blank}:
+Припустимо, у вас є структура файлів, описана в розділі [Bigger Applications](bigger-applications.md):
```
.
@@ -142,13 +142,13 @@ $ pip install httpx
* Щоб передати заголовки *headers*, використовуйте `dict` у параметрі `headers`.
* Для *cookies* використовуйте `dict` у параметрі `cookies`.
-Докладніше про передачу даних у бекенд (за допомогою `httpx` або `TestClient`) можна знайти в
документації HTTPX.
+Докладніше про передачу даних у бекенд (за допомогою `httpx` або `TestClient`) можна знайти в [документації HTTPX](https://www.python-httpx.org).
/// info | Інформація
Зверніть увагу, що `TestClient` отримує дані, які можна конвертувати в JSON, а не Pydantic-моделі.
-Якщо у вас є Pydantic-модель у тесті, і ви хочете передати її дані в застосунок під час тестування, ви можете використати `jsonable_encoder`, описаний у розділі [JSON Compatible Encoder](encoder.md){.internal-link target=_blank}.
+Якщо у вас є Pydantic-модель у тесті, і ви хочете передати її дані в застосунок під час тестування, ви можете використати `jsonable_encoder`, описаний у розділі [JSON Compatible Encoder](encoder.md).
///
@@ -156,7 +156,7 @@ $ pip install httpx
Після цього вам потрібно встановити `pytest`.
-Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md){.internal-link target=_blank}, активували його і встановили необхідні пакети, наприклад:
+Переконайтеся, що ви створили [віртуальне середовище](../virtual-environments.md), активували його і встановили необхідні пакети, наприклад:
diff --git a/docs/uk/docs/virtual-environments.md b/docs/uk/docs/virtual-environments.md
index 78e7ab32f5..d7735b234f 100644
--- a/docs/uk/docs/virtual-environments.md
+++ b/docs/uk/docs/virtual-environments.md
@@ -22,7 +22,7 @@
На цій сторінці ви дізнаєтеся, як використовувати віртуальні середовища і як вони працюють.
-Якщо ви готові прийняти інструмент, що керує всім за вас (включно з установленням Python), спробуйте
uv.
+Якщо ви готові прийняти інструмент, що керує всім за вас (включно з установленням Python), спробуйте [uv](https://github.com/astral-sh/uv).
///
@@ -86,7 +86,7 @@ $ python -m venv .venv
//// tab | `uv`
-Якщо у вас встановлено
`uv`, ви можете використати його для створення віртуального середовища.
+Якщо у вас встановлено [`uv`](https://github.com/astral-sh/uv), ви можете використати його для створення віртуального середовища.
@@ -150,7 +150,7 @@ $ .venv\Scripts\Activate.ps1
//// tab | Windows Bash
-Або якщо ви використовуєте Bash для Windows (напр.,
Git Bash):
+Або якщо ви використовуєте Bash для Windows (напр., [Git Bash](https://gitforwindows.org/)):
@@ -216,7 +216,7 @@ C:\Users\user\code\awesome-project\.venv\Scripts\python
/// tip | Порада
-Якщо ви використовуєте
`uv`, ви використовуватимете його для встановлення замість `pip`, тож вам не потрібно оновлювати `pip`. 😎
+Якщо ви використовуєте [`uv`](https://github.com/astral-sh/uv), ви використовуватимете його для встановлення замість `pip`, тож вам не потрібно оновлювати `pip`. 😎
///
@@ -268,7 +268,7 @@ $ python -m ensurepip --upgrade
/// tip | Порада
-Якщо ви використали
`uv` для створення віртуального середовища, він уже зробив це за вас, можете пропустити цей крок. 😎
+Якщо ви використали [`uv`](https://github.com/astral-sh/uv) для створення віртуального середовища, він уже зробив це за вас, можете пропустити цей крок. 😎
///
@@ -340,7 +340,7 @@ $ pip install "fastapi[standard]"
//// tab | `uv`
-Якщо у вас є
`uv`:
+Якщо у вас є [`uv`](https://github.com/astral-sh/uv):
@@ -372,7 +372,7 @@ $ pip install -r requirements.txt
//// tab | `uv`
-Якщо у вас є
`uv`:
+Якщо у вас є [`uv`](https://github.com/astral-sh/uv):
@@ -416,8 +416,8 @@ Hello World
Наприклад:
-*
VS Code
-*
PyCharm
+* [VS Code](https://code.visualstudio.com/docs/python/environments#_select-and-activate-an-environment)
+* [PyCharm](https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html)
/// tip | Порада
@@ -453,7 +453,7 @@ $ deactivate
## Навіщо віртуальні середовища { #why-virtual-environments }
-Щоб працювати з FastAPI, вам потрібно встановити
Python.
+Щоб працювати з FastAPI, вам потрібно встановити [Python](https://www.python.org/).
Після цього вам потрібно буде встановити FastAPI та інші пакети, які ви хочете використовувати.
@@ -562,7 +562,7 @@ $ pip install "fastapi[standard]"
-Це завантажить стиснений файл з кодом FastAPI, зазвичай із
PyPI.
+Це завантажить стиснений файл з кодом FastAPI, зазвичай із [PyPI](https://pypi.org/project/fastapi/).
Також будуть завантажені файли для інших пакетів, від яких залежить FastAPI.
@@ -625,7 +625,7 @@ $ .venv\Scripts\Activate.ps1
//// tab | Windows Bash
-Або якщо ви використовуєте Bash для Windows (напр.,
Git Bash):
+Або якщо ви використовуєте Bash для Windows (напр., [Git Bash](https://gitforwindows.org/)):
@@ -637,13 +637,13 @@ $ source .venv/Scripts/activate
////
-Ця команда створить або змінить деякі [Змінні оточення](environment-variables.md){.internal-link target=_blank}, які будуть доступні для наступних команд.
+Ця команда створить або змінить деякі [Змінні оточення](environment-variables.md), які будуть доступні для наступних команд.
Однією з цих змінних є змінна `PATH`.
/// tip | Порада
-Ви можете дізнатися більше про змінну оточення `PATH` у розділі [Змінні оточення](environment-variables.md#path-environment-variable){.internal-link target=_blank}.
+Ви можете дізнатися більше про змінну оточення `PATH` у розділі [Змінні оточення](environment-variables.md#path-environment-variable).
///
@@ -844,7 +844,7 @@ I solemnly swear 🐺
Існує багато альтернатив керування віртуальними середовищами, залежностями пакетів (вимогами), проєктами.
-Коли будете готові й захочете використовувати інструмент для керування всім проєктом, залежностями пакетів, віртуальними середовищами тощо, я раджу спробувати
uv.
+Коли будете готові й захочете використовувати інструмент для керування всім проєктом, залежностями пакетів, віртуальними середовищами тощо, я раджу спробувати [uv](https://github.com/astral-sh/uv).
`uv` уміє багато чого, зокрема:
diff --git a/scripts/doc_parsing_utils.py b/scripts/doc_parsing_utils.py
index 1cd2299e66..88ff2c50bd 100644
--- a/scripts/doc_parsing_utils.py
+++ b/scripts/doc_parsing_utils.py
@@ -17,7 +17,7 @@ MARKDOWN_LINK_RE = re.compile(
r"(?P
[^)\s]+)" # url (no spaces and `)`)
r'(?:\s+["\'](?P.*?)["\'])?' # optional title in "" or ''
r"\)"
- r"(?:\s*\{(?P<attrs>[^}]*)\})?" # optional attributes in {}
+ r"(?:\{(?P<attrs>[^}]*)\})?" # optional attributes in {}
)
HTML_LINK_RE = re.compile(r"<a\s+[^>]*>.*?</a>")
diff --git a/scripts/translate.py b/scripts/translate.py
index ddcfa311d6..1bfa92f887 100644
--- a/scripts/translate.py
+++ b/scripts/translate.py
@@ -142,7 +142,6 @@ def translate_page(
continue # Retry if not reached max attempts
else: # Max retry attempts reached
print(f"Translation failed for {out_path} after {MAX_ATTEMPTS} attempts")
- raise typer.Exit(code=1)
print(f"Saving translation to {out_path}")
out_path.write_text(out_content, encoding="utf-8", newline="\n")