Sync fastapi docs from 50113da1 on 2026-09-11

2026-09-11 04:00:08 +00:00
parent 632909b5f6
commit 818066b271
739 changed files with 4974 additions and 17395 deletions
@@ -4,7 +4,7 @@

 これは比較的高度なトピックです。

-FastAPI を使い始めたばかりであれば、これは不要かもしれません。
+**FastAPI** を使い始めたばかりであれば、これは不要かもしれません。

 ///

@@ -22,7 +22,7 @@ FastAPI を使い始めたばかりであれば、これは不要かもしれま

 それぞれのレスポンス `dict` には、`response_model` と同様に Pydantic モデルを格納する `model` キーを含められます。

-FastAPI はそのモデルから JSON Schema を生成し、OpenAPI の適切な場所に含めます。
+**FastAPI** はそのモデルから JSON Schema を生成し、OpenAPI の適切な場所に含めます。

 例えば、ステータスコード `404` と Pydantic モデル `Message` を持つ別のレスポンスを宣言するには、次のように書けます:

@@ -38,14 +38,14 @@ FastAPI はそのモデルから JSON Schema を生成し、OpenAPI の適切な

 `model` キーは OpenAPI の一部ではありません。

-FastAPI はそこから Pydantic モデルを取得して JSON Schema を生成し、適切な場所に配置します。
+**FastAPI** はそこから Pydantic モデルを取得して JSON Schema を生成し、適切な場所に配置します。

 適切な場所は次のとおりです:

 - `content` キーの中。これは値として別の JSON オブジェクト（`dict`）を持ち、その中に次が含まれます:
    - メディアタイプ（例: `application/json`）をキーとし、値としてさらに別の JSON オブジェクトを持ち、その中に次が含まれます:
        - `schema` キー。値としてモデル由来の JSON Schema を持ち、ここが正しい配置場所です。
-            - FastAPI はここに、スキーマを直接埋め込む代わりに OpenAPI 内のグローバルな JSON Schema への参照を追加します。これにより、他のアプリケーションやクライアントがそれらの JSON Schema を直接利用し、より良いコード生成ツール等を提供できます。
+            - **FastAPI** はここに、スキーマを直接埋め込む代わりに OpenAPI 内のグローバルな JSON Schema への参照を追加します。これにより、他のアプリケーションやクライアントがそれらの JSON Schema を直接利用し、より良いコード生成ツール等を提供できます。

 ///

@@ -197,7 +197,7 @@ FastAPI はそこから Pydantic モデルを取得して JSON Schema を生成

 `response_model` を宣言し、デフォルトのステータスコード `200`（必要なら任意のコード）を使い、その同じレスポンスに対する追加情報を `responses` で OpenAPI スキーマに直接記述できます。

-FastAPI は `responses` にある追加情報を保持し、モデルの JSON Schema と結合します。
+**FastAPI** は `responses` にある追加情報を保持し、モデルの JSON Schema と結合します。

 例えば、Pydantic モデルを用い、独自の `description` を持つステータスコード `404` のレスポンスを宣言できます。

@@ -243,5 +243,5 @@ new_dict = {**old_dict, "new key": "new value"}

 レスポンスに正確に何を含められるかは、OpenAPI 仕様の次のセクションを参照してください:

- [OpenAPI の Responses Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object)、ここには `Response Object` が含まれます。
- [OpenAPI の Response Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object)、`responses` パラメータ内の各レスポンスに、ここで定義されている要素を直接含められます。`description`、`headers`、`content`（ここで異なるメディアタイプや JSON Schema を宣言します）、`links` など。
+- [OpenAPI の Responses Object](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#responses-object)、ここには `Response Object` が含まれます。
+- [OpenAPI の Response Object](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#response-object)、`responses` パラメータ内の各レスポンスに、ここで定義されている要素を直接含められます。`description`、`headers`、`content`（ここで異なるメディアタイプや JSON Schema を宣言します）、`links` など。
@@ -34,7 +34,7 @@

 {* ../../docs_src/async_tests/app_a_py310/main.py *}

-`test_main.py` は `main.py` のテストを持ち、次のようになります:
+`test_main.py` は `main.py` のテストを持ち、今は次のようになります:

 {* ../../docs_src/async_tests/app_a_py310/test_main.py *}

@@ -45,7 +45,7 @@
 <div class="termy">

 ```console
-$ pytest
+$ uv run pytest

 ---> 100%
 ```
@@ -60,7 +60,7 @@ $ pytest

 /// tip | 豆知識

-`TestClient` を使っていたときと異なり、テスト関数は `async def` ではなく `def` になっている点に注意してください。
+`TestClient` を使っていたときのように単なる `def` ではなく、テスト関数は `async def` になっている点に注意してください。

 ///

@@ -33,7 +33,7 @@ FastAPI CLI を *CLI オプション* `--forwarded-allow-ips` 付きで起動し
 <div class="termy">

 ```console
-$ fastapi run --forwarded-allow-ips="*"
+$ uv run fastapi run --forwarded-allow-ips="*"

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -170,7 +170,7 @@ IP `0.0.0.0` は、そのマシン/サーバーで利用可能なすべての IP
 <div class="termy">

 ```console
-$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
+$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -200,7 +200,7 @@ Hypercorn を使う場合も、同様に `--root-path` オプションがあり
 <div class="termy">

 ```console
-$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
+$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -253,7 +253,7 @@ Uvicorn は、プロキシが `http://127.0.0.1:8000/app` にアクセスして

 [Traefik](https://docs.traefik.io/) を使えば、パスプレフィックスを削除する構成をローカルで簡単に試せます。

-[Traefik をダウンロード](https://github.com/containous/traefik/releases) してください。単一バイナリなので、圧縮ファイルを展開して端末から直接実行できます。
+[Traefik をダウンロード](https://github.com/traefik/traefik/releases) してください。単一バイナリなので、圧縮ファイルを展開して端末から直接実行できます。

 次の内容で `traefik.toml` というファイルを作成します:

@@ -321,7 +321,7 @@ INFO[0000] Configuration loaded from file: /home/user/awesomeapi/traefik.toml
 <div class="termy">

 ```console
-$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
+$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -6,7 +6,7 @@ FastAPI は **Pydantic** の上に構築されており、これまでにリク

 {* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}

-これは **Pydantic** によって引き続きサポートされています。Pydantic には [`dataclasses` の内部サポート](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel) があるためです。
+これは **Pydantic** によって引き続きサポートされています。Pydantic には [`dataclasses` の内部サポート](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/#usage-of-stdlib-dataclasses-with-basemodel) があるためです。

 そのため、上記のように明示的に Pydantic を使っていないコードでも、FastAPI は標準の dataclass を Pydantic 独自の dataclass に変換するために Pydantic を使用しています。

@@ -88,7 +88,7 @@ dataclass は自動的に Pydantic の dataclass に変換されます。

 `dataclasses` を他の Pydantic モデルと組み合わせたり、継承したり、自分のモデルに含めたりもできます。

-詳しくは、[dataclasses に関する Pydantic ドキュメント](https://docs.pydantic.dev/latest/concepts/dataclasses/) を参照してください。
+詳しくは、[dataclasses に関する Pydantic ドキュメント](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/) を参照してください。

 ## バージョン { #version }

@@ -154,7 +154,7 @@ async with lifespan(app):

 /// note | 備考

-Starlette の `lifespan` ハンドラについては、[Starlette の Lifespan ドキュメント](https://www.starlette.dev/lifespan/)で詳しく読むことができます。
+Starlette の `lifespan` ハンドラについては、[Starlette の Lifespan ドキュメント](https://starlette.dev/lifespan/)で詳しく読むことができます。

 コードの他の領域で使える lifespan の状態をどのように扱うかも含まれています。

@@ -12,7 +12,7 @@

 **TypeScript クライアント**向けには、[Hey API](https://heyapi.dev/) が目的特化のソリューションで、TypeScript エコシステムに最適化された体験を提供します。

-他の SDK ジェネレータは [OpenAPI.Tools](https://openapi.tools/#sdk) でも見つけられます。
+他の SDK ジェネレータは [OpenAPI.Tools](https://openapi.tools/categories/sdk-generators) でも見つけられます。

 /// tip | 豆知識

@@ -74,7 +74,7 @@ HTTP Host Header 攻撃を防ぐため、すべての受信リクエストに正

 ## `GZipMiddleware` { #gzipmiddleware }

-`Accept-Encoding` ヘッダーに "gzip" を含むリクエストに対して GZip レスポンスを処理します。
+`Accept-Encoding` ヘッダーに `"gzip"` を含むリクエストに対して GZip レスポンスを処理します。

 このミドルウェアは、通常のレスポンスとストリーミングレスポンスの両方を処理します。

@@ -91,7 +91,7 @@ HTTP Host Header 攻撃を防ぐため、すべての受信リクエストに正

 例えば:

- [Uvicorn の `ProxyHeadersMiddleware`](https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py)
+- [Uvicorn の `ProxyHeadersMiddleware`](https://github.com/Kludex/uvicorn/blob/main/uvicorn/middleware/proxy_headers.py)
 - [MessagePack](https://github.com/florimondmanca/msgpack-asgi)

-他に利用可能なミドルウェアについては、[Starlette のミドルウェアドキュメント](https://www.starlette.dev/middleware/)や [ASGI Awesome List](https://github.com/florimondmanca/awesome-asgi) を参照してください。
+他に利用可能なミドルウェアについては、[Starlette のミドルウェアドキュメント](https://starlette.dev/middleware/)や [ASGI Awesome List](https://github.com/florimondmanca/awesome-asgi) を参照してください。
@@ -35,7 +35,7 @@

 /// tip | 豆知識

-`callback_url` クエリパラメータは、Pydantic の [Url](https://docs.pydantic.dev/latest/api/networks/) 型を使用します。
+`callback_url` クエリパラメータは、Pydantic の [Url](https://pydantic.dev/docs/validation/latest/api/pydantic/networks/) 型を使用します。

 ///

@@ -106,11 +106,11 @@ httpx.post(callback_url, json={"description": "Invoice paid", "paid": True})
 通常の *path operation* と異なる主な点が 2 つあります:

 * 実際のコードは不要です。あなたのアプリはこのコードを決して呼びません。これは *外部 API* をドキュメント化するためだけに使われます。したがって、関数本体は `pass` で構いません。
-* *パス* には、*あなたの API* に送られた元のリクエストのパラメータや一部を変数として使える [OpenAPI 3 の式](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression)（後述）を含められます。
+* *パス* には、*あなたの API* に送られた元のリクエストのパラメータや一部を変数として使える [OpenAPI 3 の式](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression)（後述）を含められます。

 ### コールバックのパス式 { #the-callback-path-expression }

-コールバックの *パス* には、*あなたの API* に送られた元のリクエストの一部を含められる [OpenAPI 3 の式](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression)を使用できます。
+コールバックの *パス* には、*あなたの API* に送られた元のリクエストの一部を含められる [OpenAPI 3 の式](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression)を使用できます。

 この例では、`str` は次のとおりです:

@@ -1,6 +1,5 @@
 # レスポンスの Cookie { #response-cookies }

-
 ## `Response` パラメータを使う { #use-a-response-parameter }

 *path operation 関数*で `Response` 型のパラメータを宣言できます。
@@ -49,4 +48,4 @@

 ///

-利用可能なすべてのパラメータやオプションについては、[Starlette のドキュメント](https://www.starlette.dev/responses/#set-cookie)を参照してください。
+利用可能なすべてのパラメータやオプションについては、[Starlette のドキュメント](https://starlette.dev/responses/#set-cookie)を参照してください。
@@ -1,6 +1,5 @@
 # レスポンスヘッダー { #response-headers }

-
 ## `Response` パラメータを使う { #use-a-response-parameter }

 （Cookie と同様に）*path operation 関数*で `Response` 型のパラメータを宣言できます。
@@ -39,4 +38,4 @@

 独自のカスタムヘッダーは、[`X-` プレフィックスを使って](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers)追加できることに注意してください。

-ただし、ブラウザのクライアントに見えるようにしたいカスタムヘッダーがある場合は、CORS 設定にそれらを追加する必要があります（[CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md) を参照）。このとき、[Starlette の CORS ドキュメント](https://www.starlette.dev/middleware/#corsmiddleware)に記載の `expose_headers` パラメータを使用します。
+ただし、ブラウザのクライアントに見えるようにしたいカスタムヘッダーがある場合は、CORS 設定にそれらを追加する必要があります（[CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md) を参照）。このとき、[Starlette の CORS ドキュメント](https://starlette.dev/middleware/#corsmiddleware)に記載の `expose_headers` パラメータを使用します。
@@ -6,9 +6,13 @@

 そのため、アプリケーションが読み取る環境変数で提供するのが一般的です。

+**環境変数**（**env var** とも呼ばれます）は、Python コードの外側、オペレーティングシステム内に存在する値で、アプリケーションや他のプログラムから読み取ることができます。
+
+コマンドを実行するときに、そのコマンド用の環境変数を作成できます。プラットフォーム固有のコマンドは以下で確認できます。
+
 /// tip | 豆知識

-環境変数について理解するには、[環境変数](../environment-variables.md)を参照してください。
+環境変数の仕組みの詳細な説明については、[Environment Variables guide](https://tiangolo.com/guides/environment-variables/)を参照してください。

 ///

@@ -20,16 +24,16 @@

 ## Pydantic の `Settings` { #pydantic-settings }

-幸いなことに、Pydantic には環境変数から来る設定を扱うための優れたユーティリティがあり、[Pydantic: Settings management](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) で提供されています。
+幸いなことに、Pydantic には環境変数から来る設定を扱うための優れたユーティリティがあり、[Pydantic: Settings management](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/) で提供されています。

 ### `pydantic-settings` のインストール { #install-pydantic-settings }

-まず、[仮想環境](../virtual-environments.md)を作成して有効化し、`pydantic-settings` パッケージをインストールします:
+`pydantic-settings` パッケージをプロジェクトに追加します:

 <div class="termy">

 ```console
-$ pip install pydantic-settings
+$ uv add pydantic-settings
 ---> 100%
 ```

@@ -40,7 +44,7 @@ $ pip install pydantic-settings
 <div class="termy">

 ```console
-$ pip install "fastapi[all]"
+$ uv add "fastapi[all]"
 ---> 100%
 ```

@@ -76,19 +80,39 @@ Pydantic モデルと同様に、型アノテーションと（必要なら）

 次に、設定を環境変数として渡してサーバーを実行します。たとえば、`ADMIN_EMAIL` と `APP_NAME` を次のように設定できます:

+//// tab | Linux, macOS, Windows Bash
+
 <div class="termy">

 ```console
-$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.py
+$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" uv run fastapi run main.py

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```

 </div>

+////
+
+//// tab | Windows PowerShell
+
+<div class="termy">
+
+```console
+$ $Env:ADMIN_EMAIL = "deadpool@example.com"
+$ $Env:APP_NAME = "ChimichangApp"
+$ uv run fastapi run main.py
+
+<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+</div>
+
+////
+
 /// tip | 豆知識

-1つのコマンドに複数の環境変数を設定するには、スペースで区切ってコマンドの前に並べます。
+Bash で1つのコマンドに複数の環境変数を設定するには、スペースで区切ってコマンドの前に並べます。

 ///

@@ -172,11 +196,11 @@ $ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.p

 ///

-Pydantic は外部ライブラリを使ってこの種のファイルからの読み込みをサポートしています。詳細は [Pydantic Settings: Dotenv (.env) support](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support) を参照してください。
+Pydantic は外部ライブラリを使ってこの種のファイルからの読み込みをサポートしています。詳細は [Pydantic Settings: Dotenv (.env) support](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/#dotenv-env-support) を参照してください。

 /// tip | 豆知識

-これを機能させるには、`pip install python-dotenv` が必要です。
+これを機能させるには、`uv add python-dotenv` で `python-dotenv` をプロジェクトに追加します。

 ///

@@ -197,7 +221,7 @@ APP_NAME="ChimichangApp"

 /// tip | 豆知識

-`model_config` 属性は Pydantic の設定専用です。詳しくは [Pydantic: Concepts: Configuration](https://docs.pydantic.dev/latest/concepts/config/) を参照してください。
+`model_config` 属性は Pydantic の設定専用です。詳しくは [Pydantic: Concepts: Configuration](https://pydantic.dev/docs/validation/latest/concepts/config/) を参照してください。

 ///

@@ -35,7 +35,7 @@
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -8,12 +8,12 @@ Starlette によって提供され、**FastAPI** アプリで直接使える、

 ## 依存関係のインストール { #install-dependencies }

-[仮想環境](../virtual-environments.md) を作成して有効化し、`jinja2` をインストールします:
+プロジェクトに `jinja2` を追加します:

 <div class="termy">

 ```console
-$ pip install jinja2
+$ uv add jinja2

 ---> 100%
 ```
@@ -24,7 +24,7 @@ $ pip install jinja2

 * `Jinja2Templates` をインポートします。
 * 後で再利用できる `templates` オブジェクトを作成します。
-* テンプレートを返す path operation に `Request` パラメータを宣言します。
+* テンプレートを返す *path operation* に `Request` パラメータを宣言します。
 * 作成した `templates` を使って `TemplateResponse` をレンダリングして返します。テンプレート名、リクエストオブジェクト、Jinja2 テンプレート内で使用するキーと値のペアからなる "context" の辞書を渡します。

 {* ../../docs_src/templates/tutorial001_py310.py hl[4,11,15:18] *}
@@ -85,7 +85,7 @@ Item ID: 42

 ### テンプレートの `url_for` の引数 { #template-url-for-arguments }

-テンプレート内でも `url_for()` を使用できます。引数には、対応する path operation 関数で使われるのと同じ引数を取ります。
+テンプレート内でも `url_for()` を使用できます。引数には、対応する *path operation 関数* で使われるのと同じ引数を取ります。

 したがって、次の部分は:

@@ -97,7 +97,7 @@ Item ID: 42

 {% endraw %}

-...path operation 関数 `read_item(id=id)` が処理するのと同じ URL へのリンクを生成します。
+...*path operation 関数* `read_item(id=id)` が処理するのと同じ URL へのリンクを生成します。

 例えば、ID が `42` の場合は次のようにレンダリングされます:

@@ -123,4 +123,4 @@ Item ID: 42

 ## さらに詳しく { #more-details }

-より詳しい内容（テンプレートのテスト方法など）については、[Starlette のテンプレートに関するドキュメント](https://www.starlette.dev/templates/)を参照してください。
+より詳しい内容（テンプレートのテスト方法など）については、[Starlette のテンプレートに関するドキュメント](https://starlette.dev/templates/)を参照してください。
@@ -4,7 +4,8 @@

 {* ../../docs_src/app_testing/tutorial004_py310.py hl[9:15,18,27:28,30:32,41:43] *}

-より詳しい内容は、[公式 Starlette ドキュメントの「テストでの lifespan の実行」](https://www.starlette.dev/lifespan/#running-lifespan-in-tests) を参照してください。
+
+[`公式 Starlette ドキュメントサイトの「テストでの lifespan の実行」`](https://starlette.dev/lifespan/#running-lifespan-in-tests) についての詳細を読むことができます。

 非推奨の `startup` および `shutdown` イベントについては、次のように `TestClient` を使用できます:

@@ -8,6 +8,6 @@ WebSocket をテストするのにも同じ `TestClient` を使用できます

 /// note | 備考

-詳細については、Starlette のドキュメント「[WebSocket のテスト](https://www.starlette.dev/testclient/#testing-websocket-sessions)」を参照してください。
+詳細については、Starlette のドキュメント「[WebSocket のテスト](https://starlette.dev/testclient/#testing-websocket-sessions)」を参照してください。

 ///
@@ -15,7 +15,7 @@

 ## `Request` オブジェクトの詳細 { #details-about-the-request-object }

-**FastAPI** は内部的には **Starlette** の上にいくつかのツール層を載せたものなので、必要に応じて Starlette の [`Request`](https://www.starlette.dev/requests/) オブジェクトを直接使えます。
+**FastAPI** は内部的には **Starlette** の上にいくつかのツール層を載せたものなので、必要に応じて Starlette の [`Request`](https://starlette.dev/requests/) オブジェクトを直接使えます。

 また、`Request` オブジェクトから直接データ（例: ボディ）を取得する場合、そのデータは FastAPI によって検証・変換・ドキュメント化（OpenAPI による自動 API ユーザーインターフェース向け）されません。

@@ -25,13 +25,13 @@

 ## `Request` オブジェクトを直接使う { #use-the-request-object-directly }

-たとえば、path operation 関数内でクライアントの IP アドレス／ホストを取得したいとします。
+たとえば、*path operation 関数*内でクライアントの IP アドレス／ホストを取得したいとします。

 そのためには、リクエストに直接アクセスする必要があります。

 {* ../../docs_src/using_request_directly/tutorial001_py310.py hl[1,7:8] *}

-path operation 関数の引数として `Request` 型のパラメータを宣言すると、**FastAPI** はその引数に `Request` を渡します。
+*path operation 関数*の引数として `Request` 型のパラメータを宣言すると、**FastAPI** はその引数に `Request` を渡します。

 /// tip | 豆知識

@@ -45,7 +45,7 @@ path operation 関数の引数として `Request` 型のパラメータを宣言

 ## `Request` のドキュメント { #request-documentation }

-より詳しくは、[公式 Starlette ドキュメントサイトの `Request` オブジェクト](https://www.starlette.dev/requests/)を参照してください。
+より詳しくは、[公式 Starlette ドキュメントサイトの `Request` オブジェクト](https://starlette.dev/requests/)を参照してください。

 /// note | 技術詳細

@@ -4,12 +4,12 @@

 ## `websockets`のインストール { #install-websockets }

-[仮想環境](../virtual-environments.md)を作成し、それを有効化してから、「WebSocket」プロトコルを簡単に使えるようにするPythonライブラリの`websockets`をインストールしてください。
+「WebSocket」プロトコルを簡単に使えるようにするPythonライブラリの`websockets`をプロジェクトに追加します:

 <div class="termy">

 ```console
-$ pip install websockets
+$ uv add websockets

 ---> 100%
 ```
@@ -36,19 +36,19 @@ $ pip install websockets

 本番環境では、上記の方法のいずれかの選択肢を採用することになるでしょう。

-しかし、これはWebSocketsのサーバーサイドに焦点を当て、動作する例を示す最も簡単な方法です。
+しかし、これはWebSocketsのサーバーサイドに焦点を当て、動作する例を示す最も簡単な方法です:

 {* ../../docs_src/websockets_/tutorial001_py310.py hl[2,6:38,41:43] *}

 ## `websocket` を作成する { #create-a-websocket }

-**FastAPI** アプリケーションで、`websocket` を作成します。
+**FastAPI** アプリケーションで、`websocket` を作成します:

 {* ../../docs_src/websockets_/tutorial001_py310.py hl[1,46:47] *}

 /// note | 技術詳細

-`from starlette.websockets import WebSocket` を使用しても構いません.
+`from starlette.websockets import WebSocket` を使用しても構いません。

 **FastAPI** は開発者の利便性のために、同じ `WebSocket` を提供します。しかし、こちらはStarletteから直接提供されるものです。

@@ -64,12 +64,12 @@ WebSocketルートでは、メッセージを待機して送信するために `

 ## 試してみる { #try-it }

-コードを `main.py` に入れて、アプリケーションを実行します。
+コードを `main.py` に入れて、アプリケーションを実行します:

 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -107,7 +107,7 @@ WebSocketエンドポイントでは、`fastapi` から以下をインポート
 * `Path`
 * `Query`

-これらは、他のFastAPI エンドポイント/*path operations* の場合と同じように機能します。
+これらは、他のFastAPI エンドポイント/*path operations* の場合と同じように機能します:

 {* ../../docs_src/websockets_/tutorial002_an_py310.py hl[68:69,82] *}

@@ -121,12 +121,12 @@ WebSocketエンドポイントでは、`fastapi` から以下をインポート

 ### 依存関係を用いてWebSocketsを試してみる { #try-the-websockets-with-dependencies }

-アプリケーションを実行します。
+アプリケーションを実行します:

 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -146,7 +146,7 @@ $ fastapi dev

 ///

-これにより、WebSocketに接続してメッセージを送受信できます。
+これにより、WebSocketに接続してメッセージを送受信できます:

 <img src="/img/tutorial/websockets/image05.png">

@@ -156,13 +156,13 @@ WebSocket接続が閉じられると、 `await websocket.receive_text()` は例

 {* ../../docs_src/websockets_/tutorial003_py310.py hl[79:81] *}

-試してみるには、
+試してみるには:

 * いくつかのブラウザタブでアプリを開きます。
 * それらのタブでメッセージを記入してください。
 * そして、タブのうち1つを閉じてください。

-これにより例外 `WebSocketDisconnect` が発生し、他のすべてのクライアントは次のようなメッセージを受信します。
+これにより例外 `WebSocketDisconnect` が発生し、他のすべてのクライアントは次のようなメッセージを受信します:

 ```
 Client #1596980209979 left the chat
@@ -182,5 +182,5 @@ FastAPIと簡単に統合できて、RedisやPostgreSQLなどでサポートさ

 オプションの詳細については、Starletteのドキュメントを確認してください。

-* [`WebSocket` クラス](https://www.starlette.dev/websockets/)。
-* [クラスベースのWebSocket処理](https://www.starlette.dev/endpoints/#websocketendpoint)。
+* [`WebSocket` クラス](https://starlette.dev/websockets/)。
+* [クラスベースのWebSocket処理](https://starlette.dev/endpoints/#websocketendpoint)。
@@ -9,7 +9,7 @@

 /// note | 備考

-これには `a2wsgi` のインストールが必要です。例: `pip install a2wsgi`。
+これにはプロジェクトに `a2wsgi` を追加する必要があります。例: `uv add a2wsgi`。

 ///

@@ -125,7 +125,7 @@ def read_url():
 そして、標準に基づくユーザーインターフェースツールを統合しています。

 * [Swagger UI](https://github.com/swagger-api/swagger-ui)
-* [ReDoc](https://github.com/Rebilly/ReDoc)
+* [ReDoc](https://github.com/Redocly/redoc)

 この二つは人気で安定したものとして選択されましたが、少し検索してみると、 (**FastAPI**と同時に使用できる) OpenAPIのための多くの代替となるツールを見つけることができます。

@@ -237,7 +237,7 @@ Flask-apispecはMarshmallowと同じ開発者により作成されました。

 ///

-### [NestJS](https://nestjs.com/) (と[Angular](https://angular.io/)) { #nestjs-and-angular }
+### [NestJS](https://nestjs.com/) (と[Angular](https://angular.dev/)) { #nestjs-and-angular }

 NestJSはAngularにインスパイアされたJavaScript (TypeScript) NodeJSフレームワークで、Pythonですらありません。

@@ -337,7 +337,7 @@ OpenAPIやJSON Schemaのような標準に基づいたものではありませ

 /// note | 備考

-HugはTimothy Crosleyにより作成されました。彼は[`isort`](https://github.com/timothycrosley/isort)など、Pythonのファイル内のインポートの並び替えを自動的に行う素晴らしいツールの開発者です。
+HugはTimothy Crosleyにより作成されました。彼は[`isort`](https://github.com/PyCQA/isort)など、Pythonのファイル内のインポートの並び替えを自動的に行う素晴らしいツールの開発者です。

 ///

@@ -401,7 +401,7 @@ APIStarはTom Christieにより開発されました。以下の開発者でも

 ## **FastAPI**が利用しているもの { #used-by-fastapi }

-### [Pydantic](https://docs.pydantic.dev/) { #pydantic }
+### [Pydantic](https://pydantic.dev/docs/) { #pydantic }

 Pydanticは、Pythonの型ヒントを元にデータのバリデーション、シリアライゼーション、 (JSON Schemaを使用した) ドキュメントを定義するライブラリです。

@@ -417,7 +417,7 @@ Marshmallowに匹敵しますが、ベンチマークではMarshmallowよりも

 ///

-### [Starlette](https://www.starlette.dev/) { #starlette }
+### [Starlette](https://starlette.dev/) { #starlette }

 Starletteは、軽量な<dfn title="非同期Python Webアプリケーションを構築するための新しい標準">ASGI</dfn>フレームワーク/ツールキットで、高性能な非同期サービスの構築に最適です。

@@ -462,7 +462,7 @@ webに関するコアな部分を全て扱います。その上に機能を追

 ///

-### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }
+### [Uvicorn](https://uvicorn.dev) { #uvicorn }

 Uvicornは非常に高速なASGIサーバーで、uvloopとhttptoolsにより構成されています。

@@ -105,36 +105,32 @@ FastAPI用の**Dockerイメージ**を、**公式Python**イメージに基づ

 ### パッケージ要件 { #package-requirements }

-アプリケーションの**パッケージ要件**は通常、何らかのファイルに記述されているはずです。
+`uv` でプロジェクトを管理している場合、直接の依存関係は `pyproject.toml` に宣言され、正確に解決されたバージョンは `uv.lock` に保存されます。

-パッケージ要件は主に**インストール**するために使用するツールに依存するでしょう。
-
-最も一般的な方法は、`requirements.txt` ファイルにパッケージ名とそのバージョンを 1 行ずつ書くことです。
-
-もちろん、[FastAPI バージョンについて](versions.md)で読んだのと同じアイデアを使用して、バージョンの範囲を設定します。
-
-例えば、`requirements.txt` は次のようになります：
-
-```
-fastapi[standard]>=0.113.0,<0.114.0
-pydantic>=2.7.0,<3.0.0
-```
-
-そして通常、例えば `pip` を使ってこれらのパッケージの依存関係をインストールします：
+アプリケーションに必要なパッケージは次のように追加できます：

 <div class="termy">

 ```console
-$ pip install -r requirements.txt
+$ uv add "fastapi[standard]" pydantic
 ---> 100%
-Successfully installed fastapi pydantic
 ```

 </div>

 /// note | 備考

-パッケージの依存関係を定義しインストールするためのフォーマットやツールは他にもあります。
+以下のDockerfileでは、コンテナ内で `pip` を使用します。uvプロジェクトからロックされた依存関係を、Dockerfileが想定する `requirements.txt` 形式にエクスポートできます：
+
+<div class="termy">
+
+```console
+$ uv export --format requirements-txt --no-dev --no-emit-project --output-file requirements.txt
+```
+
+</div>
+
+生成された `requirements.txt` はコンテナビルド用のエクスポートです。依存関係の管理は `uv add` で続け、`uv.lock` が変更されたら再生成してください。

 ///

@@ -374,7 +370,7 @@ Dockerコンテナの[http://192.168.99.100/items/5?q=somequery](http://192.168.

 また、[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](https://github.com/Rebilly/ReDoc)によって提供される）が表示されます：
+代替の自動ドキュメント（[ReDoc](https://github.com/Redocly/redoc)によって提供される）が表示されます：

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -544,13 +540,9 @@ Docker Composeで**単一サーバ**（クラスタではない）にデプロ

 コンテナごとに**単一のプロセスを実行する**と、それらのコンテナ（レプリケートされている場合は1つ以上）によって消費される多かれ少なかれ明確に定義された、安定し制限された量のメモリを持つことになります。

-そして、コンテナ管理システム（**Kubernetes**など）の設定で、同じメモリ制限と要件を設定することができます。
+そして、コンテナ管理システム（**Kubernetes**など）の設定で、同じメモリ制限と要件を設定することができます。そうすれば、コンテナが必要とするメモリ量とクラスタ内のマシンで利用可能なメモリ量を考慮して、**利用可能なマシン**に**コンテナをレプリケート**できるようになります。

-そうすれば、コンテナが必要とするメモリ量とクラスタ内のマシンで利用可能なメモリ量を考慮して、**利用可能なマシン**に**コンテナ**をレプリケートできるようになります。
-
-アプリケーションが**シンプル**なものであれば、これはおそらく**問題にはならない**でしょうし、ハードなメモリ制限を指定する必要はないかもしれないです。
-
-しかし、**多くのメモリを使用**している場合（たとえば**機械学習**モデルなど）、どれだけのメモリを消費しているかを確認し、**各マシンで実行するコンテナの数**を調整する必要があります（そしておそらくクラスタにマシンを追加します）。
+アプリケーションが**シンプル**なものであれば、これはおそらく**問題にはならない**でしょうし、ハードなメモリ制限を指定する必要はないかもしれないです。しかし、**多くのメモリを使用**している場合（たとえば**機械学習**モデルなど）、どれだけのメモリを消費しているかを確認し、**各マシンで実行するコンテナの数**を調整する必要があります（そしておそらくクラスタにマシンを追加します）。

 **コンテナごとに複数のプロセス**を実行する場合、起動するプロセスの数が**利用可能なメモリ以上に消費しない**ようにする必要があります。

@@ -5,7 +5,7 @@
 <div class="termy">

 ```console
-$ fastapi deploy
+$ uv run fastapi deploy

 Deploying to FastAPI Cloud...

@@ -52,7 +52,7 @@ FastAPI は、Python の Web フレームワークとサーバーのための標

 他にもいくつかの選択肢があります:

-* [Uvicorn](https://www.uvicorn.dev/): 高性能な ASGI サーバー。
+* [Uvicorn](https://uvicorn.dev): 高性能な ASGI サーバー。
 * [Hypercorn](https://hypercorn.readthedocs.io/): HTTP/2 や Trio に対応する ASGI サーバーなど。
 * [Daphne](https://github.com/django/daphne): Django Channels のために作られた ASGI サーバー。
 * [Granian](https://github.com/emmett-framework/granian): Python アプリケーション向けの Rust 製 HTTP サーバー。
@@ -73,14 +73,14 @@ FastAPI をインストールすると、本番サーバーの Uvicorn が同梱

 ただし、ASGI サーバーを手動でインストールすることもできます。

-[仮想環境](../virtual-environments.md)を作成して有効化し、サーバーアプリケーションをインストールしてください。
+サーバーアプリケーションをプロジェクトに追加してください。

 例として、Uvicorn をインストールするには:

 <div class="termy">

 ```console
-$ pip install "uvicorn[standard]"
+$ uv add "uvicorn[standard]"

 ---> 100%
 ```
@@ -95,7 +95,7 @@ $ pip install "uvicorn[standard]"

 その中には、`uvloop` も含まれます。これは `asyncio` の高性能なドロップイン代替で、大きな並行実行性能の向上をもたらします。

-`pip install "fastapi[standard]"` のように FastAPI をインストールした場合は、すでに `uvicorn[standard]` も含まれます。
+`uv add "fastapi[standard]"` のように FastAPI を追加した場合は、すでに `uvicorn[standard]` も含まれます。

 ///

@@ -106,7 +106,7 @@ ASGI サーバーを手動でインストールした場合、通常は FastAPI
 <div class="termy">

 ```console
-$ uvicorn main:app --host 0.0.0.0 --port 80
+$ uv run uvicorn main:app --host 0.0.0.0 --port 80

 <span style="color: green;">INFO</span>:     Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
 ```
@@ -17,7 +17,7 @@

 ここでは、`fastapi` コマンド、または `uvicorn` コマンドを直接使って、**ワーカープロセス**付きの **Uvicorn** を使う方法を紹介します。

-/// note
+/// note | 備考

 DockerやKubernetesなどのコンテナを使用している場合は、次の章で詳しく説明します： [コンテナ内のFastAPI - Docker](docker.md)。

@@ -86,7 +86,7 @@ $ <font color="#4E9A06">fastapi</font> run --workers 4 <u style="text-decoration
 <div class="termy">

 ```console
-$ uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
+$ uv run uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
 <font color="#A6E22E">INFO</font>:     Uvicorn running on <b>http://0.0.0.0:8080</b> (Press CTRL+C to quit)
 <font color="#A6E22E">INFO</font>:     Started parent process [<font color="#A1EFE4"><b>27365</b></font>]
 <font color="#A6E22E">INFO</font>:     Started server process [<font color="#A1EFE4">27368</font>]
@@ -1,298 +1,11 @@
 # 環境変数 { #environment-variables }

-/// tip | 豆知識
+**環境変数**（**env var** とも呼ばれます）とは、Pythonコードの外側、つまりオペレーティングシステムに存在する値で、アプリケーションや他のプログラムから読み取れます。

-もし「環境変数」とは何か、それをどう使うかを既に知っている場合は、このセクションをスキップして構いません。
+FastAPIアプリケーションでは、データベースURL、メール認証情報、シークレットキーなどの設定に環境変数をよく使用します。

-///
+アプリケーション設定での使い方については、[設定と環境変数](advanced/settings.md)で学べます。

-環境変数（「**env var**」とも呼ばれます）とは、Pythonコードの**外側**、つまり**オペレーティングシステム**に存在する変数で、Pythonコード（または他のプログラム）から読み取れます。
+## 詳細 { #learn-more }

-環境変数は、アプリケーションの**設定**の扱い、Pythonの**インストール**の一部などで役立ちます。
-
-## 環境変数の作成と使用 { #create-and-use-env-vars }
-
-環境変数は、Pythonを必要とせず、**シェル（ターミナル）**で**作成**して使用できます。
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// 環境変数 MY_NAME を作成する例
-$ export MY_NAME="Wade Wilson"
-
-// その後、他のプログラムで利用できます。例えば
-$ echo "Hello $MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// 環境変数 MY_NAME を作成
-$ $Env:MY_NAME = "Wade Wilson"
-
-// 他のプログラムで利用、例えば
-$ echo "Hello $Env:MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-## Pythonで環境変数を読み取る { #read-env-vars-in-python }
-
-環境変数はPythonの**外側**（ターミナル、またはその他の方法）で作成し、その後に**Pythonで読み取る**こともできます。
-
-例えば、以下のような`main.py`ファイルを用意します:
-
-```Python hl_lines="3"
-import os
-
-name = os.getenv("MY_NAME", "World")
-print(f"Hello {name} from Python")
-```
-
-/// tip | 豆知識
-
-[`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) の第2引数は、返されるデフォルト値です。
-
-指定しない場合、デフォルトは`None`ですが、ここでは使用するデフォルト値として`"World"`を指定しています。
-
-///
-
-次に、このPythonプログラムを呼び出します。
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// ここではまだ環境変数を設定していません
-$ python main.py
-
-// 環境変数を設定していないため、デフォルト値が使われます
-
-Hello World from Python
-
-// しかし、先に環境変数を作成すると
-$ export MY_NAME="Wade Wilson"
-
-// それからもう一度プログラムを実行すると
-$ python main.py
-
-// すると環境変数を読み取れます
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// ここではまだ環境変数を設定していません
-$ python main.py
-
-// 環境変数を設定していないため、デフォルト値が使われます
-
-Hello World from Python
-
-// しかし、先に環境変数を作成すると
-$ $Env:MY_NAME = "Wade Wilson"
-
-// それからもう一度プログラムを実行すると
-$ python main.py
-
-// すると環境変数を読み取れます
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-////
-
-環境変数はコードの外側で設定でき、コードから読み取れ、他のファイルと一緒に（`git`に）保存（コミット）する必要がないため、設定や**settings**に使うのが一般的です。
-
-また、**特定のプログラムの呼び出し**のためだけに、そのプログラムでのみ、実行中の間だけ利用できる環境変数を作成することもできます。
-
-そのためには、同じ行で、プログラム自体の直前に作成してください。
-
-<div class="termy">
-
-```console
-// このプログラム呼び出し用に同じ行で環境変数 MY_NAME を作成
-$ MY_NAME="Wade Wilson" python main.py
-
-// これで環境変数を読み取れます
-
-Hello Wade Wilson from Python
-
-// その後は環境変数は存在しません
-$ python main.py
-
-Hello World from Python
-```
-
-</div>
-
-/// tip | 豆知識
-
-詳しくは [The Twelve-Factor App: 設定](https://12factor.net/config) を参照してください。
-
-///
-
-## 型とバリデーション { #types-and-validation }
-
-これらの環境変数が扱えるのは**テキスト文字列**のみです。環境変数はPythonの外部にあり、他のプログラムやシステム全体（Linux、Windows、macOSなど異なるオペレーティングシステム間も）との互換性が必要になるためです。
-
-つまり、環境変数からPythonで読み取る**あらゆる値**は **`str`になり**、他の型への変換やバリデーションはコード内で行う必要があります。
-
-環境変数を使って**アプリケーション設定**を扱う方法については、[高度なユーザーガイド - 設定と環境変数](./advanced/settings.md)で詳しく学べます。
-
-## `PATH`環境変数 { #path-environment-variable }
-
-**`PATH`**という**特別な**環境変数があります。これはオペレーティングシステム（Linux、macOS、Windows）が実行するプログラムを見つけるために使用されます。
-
-変数`PATH`の値は長い文字列で、LinuxとmacOSではコロン`:`、Windowsではセミコロン`;`で区切られたディレクトリで構成されます。
-
-例えば、`PATH`環境変数は次のような文字列かもしれません:
-
-//// tab | Linux, macOS
-
-```plaintext
-/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-これは、システムが次のディレクトリでプログラムを探すことを意味します:
-
-* `/usr/local/bin`
-* `/usr/bin`
-* `/bin`
-* `/usr/sbin`
-* `/sbin`
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32
-```
-
-これは、システムが次のディレクトリでプログラムを探すことを意味します:
-
-* `C:\Program Files\Python312\Scripts`
-* `C:\Program Files\Python312`
-* `C:\Windows\System32`
-
-////
-
-ターミナル上で**コマンド**を入力すると、オペレーティングシステムは`PATH`環境変数に記載された**それぞれのディレクトリ**の中からプログラムを**探し**ます。
-
-例えば、ターミナルで`python`と入力すると、オペレーティングシステムはそのリストの**最初のディレクトリ**で`python`というプログラムを探します。
-
-見つかればそれを**使用**します。見つからなければ、**他のディレクトリ**を探し続けます。
-
-### Pythonのインストールと`PATH`の更新 { #installing-python-and-updating-the-path }
-
-Pythonのインストール時に、`PATH`環境変数を更新するかどうかを尋ねられるかもしれません。
-
-//// tab | Linux, macOS
-
-Pythonをインストールして、その結果`/opt/custompython/bin`というディレクトリに配置されたとします。
-
-`PATH`環境変数を更新することに同意すると、インストーラーは`PATH`環境変数に`/opt/custompython/bin`を追加します。
-
-例えば次のようになります:
-
-```plaintext
-/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin
-```
-
-このようにして、ターミナルで`python`と入力すると、システムは`/opt/custompython/bin`（最後のディレクトリ）にあるPythonプログラムを見つけ、それを使用します。
-
-////
-
-//// tab | Windows
-
-Pythonをインストールして、その結果`C:\opt\custompython\bin`というディレクトリに配置されたとします。
-
-`PATH`環境変数を更新することに同意すると、インストーラーは`PATH`環境変数に`C:\opt\custompython\bin`を追加します。
-
-```plaintext
-C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin
-```
-
-このようにして、ターミナルで`python`と入力すると、システムは`C:\opt\custompython\bin`（最後のディレクトリ）にあるPythonプログラムを見つけ、それを使用します。
-
-////
-
-つまり、ターミナルで次のように入力すると:
-
-<div class="termy">
-
-```console
-$ python
-```
-
-</div>
-
-//// tab | Linux, macOS
-
-システムは`/opt/custompython/bin`にある`python`プログラムを**見つけ**て実行します。
-
-これは、次のように入力するのとおおむね同等です:
-
-<div class="termy">
-
-```console
-$ /opt/custompython/bin/python
-```
-
-</div>
-
-////
-
-//// tab | Windows
-
-システムは`C:\opt\custompython\bin\python`にある`python`プログラムを**見つけ**て実行します。
-
-これは、次のように入力するのとおおむね同等です:
-
-<div class="termy">
-
-```console
-$ C:\opt\custompython\bin\python
-```
-
-</div>
-
-////
-
-この情報は、[仮想環境](virtual-environments.md)について学ぶ際にも役立ちます。
-
-## まとめ { #conclusion }
-
-これで、**環境変数**とは何か、Pythonでどのように使用するかについて、基本的な理解が得られたはずです。
-
-環境変数についての詳細は、[Wikipedia の環境変数](https://en.wikipedia.org/wiki/Environment_variable)も参照してください。
-
-多くの場合、環境変数がどのように役立ち、すぐに適用できるのかはあまり明確ではありません。しかし、開発中のさまざまなシナリオで何度も登場するため、知っておくとよいでしょう。
-
-例えば、次のセクションの[仮想環境](virtual-environments.md)でこの情報が必要になります。
+環境変数の作成方法や読み取り方法、`PATH`環境変数の仕組みなど、クロスプラットフォームでの詳しい説明については、[環境変数ガイド](https://tiangolo.com/guides/environment-variables/)を読んでください。
@@ -2,7 +2,7 @@

 **FastAPI <abbr title="command line interface - コマンドラインインターフェース">CLI</abbr>** は、FastAPI アプリの提供、FastAPI プロジェクトの管理などに使用できるコマンドラインプログラムです。

-FastAPI をインストールすると（例: `pip install "fastapi[standard]"`）、ターミナルで実行できるコマンドラインプログラムが付属します。
+FastAPI をプロジェクトに追加すると（例: `uv add "fastapi[standard]"`）、ターミナルで実行できるコマンドラインプログラムが付属します。

 開発用に FastAPI アプリを起動するには、`fastapi dev` コマンドを使用できます:

@@ -52,7 +52,7 @@ $ <font color="#4E9A06">fastapi</font> dev

 ///

-内部的には、**FastAPI CLI** は [Uvicorn](https://www.uvicorn.dev)（高性能で本番運用向けの ASGI サーバー）を使用します。😎
+内部的には、**FastAPI CLI** は [Uvicorn](https://uvicorn.dev)（高性能で本番運用向けの ASGI サーバー）を使用します。😎

 `fastapi` CLI は、実行する FastAPI アプリを自動検出しようとします。既定では、`main.py` の中にある `app` という名前のオブジェクト（ほかにもいくつかの変種）であると仮定します。

@@ -100,13 +100,13 @@ from backend.main import app
 `fastapi dev` コマンドにファイルパスを渡すこともでき、使用する FastAPI アプリオブジェクトを推測します:

 ```console
-$ fastapi dev main.py
+$ uv run fastapi dev main.py
 ```

 または、`fastapi dev` コマンドに `--entrypoint` オプションを渡すこともできます:

 ```console
-$ fastapi dev --entrypoint main:app
+$ uv run fastapi dev --entrypoint main:app
 ```

 ただし、そのたびに `fastapi` コマンドを呼び出す際に正しいパスや entrypoint を渡す必要があります。
@@ -119,9 +119,13 @@ $ fastapi dev --entrypoint main:app

 デフォルトでは、**auto-reload** が有効です。コードを変更するとサーバーが自動で再読み込みされます。これはリソースを多く消費し、無効時より安定性が低くなる可能性があります。開発時のみに使用してください。また、IP アドレス `127.0.0.1`（マシン自身のみと通信するための IP、`localhost`）で待ち受けます。

+アプリを import する前に、`fastapi dev` は `FASTAPI_ENV` 環境変数を `development` に設定します。`FASTAPI_ENV` がすでに設定されている場合、既存の値は保持されます。これにより、アプリ固有の環境（`staging` など）を指定できるようにしつつ、アプリの起動コードが開発向けの動作を選択できます。
+
+慣例的な `FASTAPI_ENV` の値は `development` と `production` です。`fastapi run` は現在 `FASTAPI_ENV` を変更しないため、アプリが本番モードを検出する必要がある場合は明示的に設定してください。
+
 ## `fastapi run` { #fastapi-run }

-`fastapi run` を実行すると、デフォルトで本番モードで起動します。
+`fastapi run` を実行すると、本番モードで FastAPI を起動します。

 デフォルトでは、**auto-reload** は無効です。また、IP アドレス `0.0.0.0`（利用可能なすべての IP アドレスを意味します）で待ち受けるため、そのマシンと通信できる任意のクライアントから公開アクセスが可能になります。これは、たとえばコンテナ内など、本番環境で一般的な実行方法です。

@@ -19,7 +19,7 @@

 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)

-* [**ReDoc**](https://github.com/Rebilly/ReDoc) による代替の API ドキュメント。
+* [**ReDoc**](https://github.com/Redocly/redoc) による代替の API ドキュメント。

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)

@@ -159,7 +159,7 @@ FastAPI には、非常に使いやすく、かつ非常に強力な <dfn title=

 ## Starletteの機能 { #starlette-features }

-**FastAPI** は [**Starlette**](https://www.starlette.dev/) と完全に互換性があり（かつそれに基づいています）。そのため、手元の Starlette の追加コードも動作します。
+**FastAPI** は [**Starlette**](https://starlette.dev/) と完全に互換性があり（かつそれに基づいています）。そのため、手元の Starlette の追加コードも動作します。

 `FastAPI` は実際には `Starlette` のサブクラスです。すでに Starlette を知っている、あるいは使っているなら、ほとんどの機能は同じように動作します。

@@ -177,7 +177,7 @@ FastAPI には、非常に使いやすく、かつ非常に強力な <dfn title=

 ## Pydanticの機能 { #pydantic-features }

-**FastAPI** は [**Pydantic**](https://docs.pydantic.dev/) と完全に互換性があり（かつそれに基づいています）。そのため、手元の Pydantic の追加コードも動作します。
+**FastAPI** は [**Pydantic**](https://pydantic.dev/docs/) と完全に互換性があり（かつそれに基づいています）。そのため、手元の Pydantic の追加コードも動作します。

 Pydantic に基づく外部ライブラリ（データベース用の <abbr title="Object-Relational Mapper - オブジェクト関係マッパー">ORM</abbr>、<abbr title="Object-Document Mapper - オブジェクトドキュメントマッパー">ODM</abbr> など）も含まれます。

@@ -46,20 +46,6 @@ GitHubでFastAPIを「Watch」できます（右上の「Watch」ボタンをク
 * [**Bluesky** の @tiangolo.com](https://bsky.app/profile/tiangolo.com)
 * [**LinkedIn** の @tiangolo](https://www.linkedin.com/in/tiangolo/)。

-## GitHubで質問に困っている人を助ける { #help-others-with-questions-in-github }
-
-[GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered) で、他の人の質問を手助けできます。
-
-多くの場合、その質問の答えをすでに知っているかもしれません。🤓
-
-多くの人の質問に答えて助けてくれたなら、あなたは公式の[FastAPI Expert](fastapi-people.md#fastapi-experts)になります。🎉
-
-最も大事なポイントは「親切であること」を心がけることです。🤗
-
-### 手助けの方法 { #how-to-help }
-
-こちらの[ヘルプの仕方ガイド](https://tiangolo.com/open-source/help/#help-others-with-questions-in-github)に従ってください。
-
 ## 質問する { #ask-questions }

 GitHubレポジトリで[新しい質問](https://github.com/fastapi/fastapi/discussions/new?category=questions)を作成できます。例えば:
@@ -69,7 +55,7 @@ GitHubレポジトリで[新しい質問](https://github.com/fastapi/fastapi/dis

 ## チャットに参加 { #join-the-chat }

-👥 [Discord チャットサーバー](https://discord.gg/VQjSZaeJmf) 👥 に参加し、FastAPI コミュニティのみんなと交流しましょう。
+👥 [Discord チャットサーバー](https://discord.com/invite/VQjSZaeJmf) 👥 に参加し、FastAPI コミュニティのみんなと交流しましょう。

 /// tip | 豆知識

@@ -86,3 +72,9 @@ GitHubレポジトリで[新しい質問](https://github.com/fastapi/fastapi/dis
 GitHub では、テンプレートが正しい形で質問を書くのを助けてくれるため、良い回答を得やすくなりますし、質問する前に自分で問題を解決できることもあります。

 また、チャットの会話は GitHub ほど検索しやすくなく、流れてしまいます。
+
+## FastAPI Cloud を試す { #try-fastapi-cloud }
+
+FastAPI とその仲間の主な資金源は、FastAPI アプリケーションをシンプルかつ高速に、単一のコマンド `fastapi deploy` でデプロイするためのプラットフォームである [**FastAPI Cloud**](https://fastapicloud.com) です。
+
+FastAPI Cloud は FastAPI を支える同じチームによって構築されています。試してみて、あなたのプロジェクトでの利用を検討できます。
@@ -54,11 +54,11 @@

 ## 要件 { #requirements }

-いくつかの代替手法を試したあと、私は[**Pydantic**](https://docs.pydantic.dev/)の強みを利用することを決めました。
+いくつかの代替手法を試したあと、私は[**Pydantic**](https://pydantic.dev/docs/)の強みを利用することを決めました。

 そして、JSON Schemaに完全に準拠するようにしたり、制約宣言を定義するさまざまな方法をサポートしたり、いくつかのエディターでのテストに基づいてエディターのサポート (型チェック、自動補完) を改善するために貢献しました。

-開発中、もう1つの重要な鍵となる[**Starlette**](https://www.starlette.dev/)にも貢献しました。
+開発中、もう1つの重要な鍵となる[**Starlette**](https://starlette.dev/)にも貢献しました。

 ## 開発 { #development }

@@ -66,7 +66,7 @@ gzip のリクエストを解凍するために、カスタムの `Request` サ

 そしてこの 2 つ（`scope` と `receive`）が、新しい `Request` インスタンスを作成するために必要なものです。

-`Request` について詳しくは、[Starlette の Requests に関するドキュメント](https://www.starlette.dev/requests/) を参照してください。
+`Request` について詳しくは、[Starlette の Requests に関するドキュメント](https://starlette.dev/requests/) を参照してください。

 ///

@@ -10,7 +10,7 @@

 `FastAPI` アプリケーション（インスタンス）には、OpenAPI スキーマを返すことが期待される `.openapi()` メソッドがあります。

-アプリケーションオブジェクトの作成時に、`/openapi.json`（または `openapi_url` に設定したパス）への path operation が登録されます。
+アプリケーションオブジェクトの作成時に、`/openapi.json`（または `openapi_url` に設定したパス）への *path operation* が登録されます。

 これは単に、アプリケーションの `.openapi()` メソッドの結果を含む JSON レスポンスを返します。

@@ -25,9 +25,9 @@
 - `openapi_version`: 使用する OpenAPI 仕様のバージョン。デフォルトは最新の `3.1.0`。
 - `summary`: API の短い概要。
 - `description`: API の説明。Markdown を含めることができ、ドキュメントに表示されます。
- `routes`: アプリケーションのルート。`app.routes` から取得されます。FastAPI はこれらを使用して、登録済みの path operation（取り込んだルーター由来のものも含む）を収集します。
+- `routes`: アプリケーションのルート。`app.routes` から取得されます。FastAPI はこれらを使用して、登録済みの *path operation*（取り込んだルーター由来のものも含む）を収集します。

-/// tip | 技術詳細
+/// tip | 豆知識

 `app.routes` はより低レベルなルートツリーです。最終的な `APIRoute` オブジェクトだけでなく、FastAPI が内部で使用する、取り込まれたルーター向けの候補ルートも含まれることがあります。

@@ -45,7 +45,7 @@

 上記の情報を使って、同じユーティリティ関数で OpenAPI スキーマを生成し、必要な部分を上書きできます。

-たとえば、[カスタムロゴを含めるための ReDoc の OpenAPI 拡張](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo)を追加してみましょう。
+たとえば、[カスタムロゴを含めるための ReDoc の OpenAPI 拡張](https://github.com/Redocly/redoc/blob/main/docs/redoc-vendor-extensions.md#x-logo)を追加してみましょう。

 ### 通常の **FastAPI** { #normal-fastapi }

@@ -22,7 +22,7 @@
 * [Strawberry](https://strawberry.rocks/) 🍓
    * [FastAPI 向けドキュメント](https://strawberry.rocks/docs/integrations/fastapi)あり
 * [Ariadne](https://ariadnegraphql.org/)
-    * [FastAPI 向けドキュメント](https://ariadnegraphql.org/docs/fastapi-integration)あり
+    * [FastAPI 向けドキュメント](https://ariadnegraphql.org/server/Integrations/fastapi-integration)あり
 * [Tartiflette](https://tartiflette.io/)
    * ASGI 連携用の [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) あり
 * [Graphene](https://graphene-python.org/)
@@ -24,7 +24,7 @@ Python の最新機能を使いたい場合は、Pydantic v2 を使用してい

 ## 公式ガイド { #official-guide }

-Pydantic には v1 から v2 への公式の [移行ガイド](https://docs.pydantic.dev/latest/migration/) があります。
+Pydantic には v1 から v2 への公式の [移行ガイド](https://pydantic.dev/docs/validation/latest/get-started/migration/) があります。

 変更点、検証がより正確で厳密になった点、注意事項などが含まれます。

@@ -32,7 +32,7 @@ include_yaml:

 ---

-**ドキュメント**: [https://fastapi.tiangolo.com/ja](https://fastapi.tiangolo.com/ja)
+**ドキュメント**: [https://fastapi.tiangolo.com](https://fastapi.tiangolo.com/ja)

 **ソースコード**: [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi)

@@ -105,19 +105,19 @@ FastAPI は、Python の標準である型ヒントに基づいて Python で AP
  </div>

  <div class="fastapi-opinions__panel" id="fo-panel-microsoft" role="tabpanel" aria-labelledby="fo-tab-microsoft" tabindex="0">
-    <blockquote class="fastapi-opinions__quote">「最近は **FastAPI** をたくさん使っています。実際、私のチームの **Microsoft の ML サービス** 全てで使用する予定です。そのいくつかはコアな **Windows** 製品や **Office** 製品に統合されつつあります。」</blockquote>
+    <blockquote class="fastapi-opinions__quote">「最近は <strong>FastAPI</strong> をたくさん使っています。実際、私のチームの <strong>Microsoft の ML サービス</strong> 全てで使用する予定です。そのいくつかはコアな <strong>Windows</strong> 製品や <strong>Office</strong> 製品に統合されつつあります。」</blockquote>
    <div class="fastapi-opinions__attr">— Kabir Khan, <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26">(ref)</a></div>
  </div>
  <div class="fastapi-opinions__panel" id="fo-panel-uber" role="tabpanel" aria-labelledby="fo-tab-uber" tabindex="0" hidden>
-    <blockquote class="fastapi-opinions__quote">「**FastAPI** ライブラリを採用し、クエリで **予測値** を取得できる **REST** サーバを構築しました。」<em>[for Ludwig]</em></blockquote>
-    <div class="fastapi-opinions__attr">— Piero Molino, Yaroslav Dudin, Sai Sumanth Miryala, <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/">(ref)</a></div>
+    <blockquote class="fastapi-opinions__quote">「<strong>FastAPI</strong> ライブラリを採用し、クエリで <strong>予測値</strong> を取得できる <strong>REST</strong> サーバを構築しました。」<em>[for Ludwig]</em></blockquote>
+    <div class="fastapi-opinions__attr">— Piero Molino, Yaroslav Dudin, Sai Sumanth Miryala, <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/">(ref)</a></div>
  </div>
  <div class="fastapi-opinions__panel" id="fo-panel-netflix" role="tabpanel" aria-labelledby="fo-tab-netflix" tabindex="0" hidden>
    <blockquote class="fastapi-opinions__quote">「<strong>Netflix</strong> は、私たちの <strong>危機管理</strong> オーケストレーションフレームワーク、<strong>Dispatch</strong> のオープンソースリリースを発表できることをうれしく思います！」<em>[built with FastAPI]</em></blockquote>
    <div class="fastapi-opinions__attr">— Kevin Glisson, Marc Vilanova, Forest Monsen, <strong>Netflix</strong> <a href="https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072">(ref)</a></div>
  </div>
  <div class="fastapi-opinions__panel" id="fo-panel-cisco" role="tabpanel" aria-labelledby="fo-tab-cisco" tabindex="0" hidden>
-    <blockquote class="fastapi-opinions__quote">「本番の Python API を構築したい方には、**FastAPI** を強くおすすめします。**美しく設計**され、**使いやすく**、**高いスケーラビリティ**があります。私たちの API ファースト開発戦略の **主要コンポーネント** となりました。」</blockquote>
+    <blockquote class="fastapi-opinions__quote">「本番の Python API を構築したい方には、<strong>FastAPI</strong> を強くおすすめします。<strong>美しく設計</strong>され、<strong>使いやすく</strong>、<strong>高いスケーラビリティ</strong>があります。私たちの API ファースト開発戦略の <strong>主要コンポーネント</strong> となりました。」</blockquote>
    <div class="fastapi-opinions__attr">— Deon Pillsbury, <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/">(ref)</a></div>
  </div>
 </div>
@@ -125,7 +125,7 @@ FastAPI は、Python の標準である型ヒントに基づいて Python で AP

 <div class="only-github" markdown="1">

-"_[...] 最近 **FastAPI** をたくさん使っています。 [...] 実際に私のチームの全ての **Microsoft の機械学習サービス** で使用する予定です。 そのうちのいくつかのコアな **Windows** 製品と **Office** 製品に統合されつつあります。_"
+"_[...] 最近 **FastAPI** をたくさん使っています。 [...] 実際に私のチームの全ての **Microsoft の ML サービス** で使用する予定です。 そのうちのいくつかのコアな **Windows** 製品と **Office** 製品に統合されつつあります。_"

 <div style="text-align: right; margin-right: 10%;">Kabir Khan - <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26"><small>(ref)</small></a></div>

@@ -133,7 +133,7 @@ FastAPI は、Python の標準である型ヒントに基づいて Python で AP

 "_FastAPIライブラリを採用し、クエリで **予測値** を取得できる **REST** サーバを構築しました。 [for Ludwig]_"

-<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/"><small>(ref)</small></a></div>

 ---

@@ -151,12 +151,6 @@ FastAPI は、Python の標準である型ヒントに基づいて Python で AP

 </div>

-## FastAPI Conf { #fastapi-conf }
-
-[**FastAPI Conf '26**](https://fastapiconf.com) は **2026 年 10 月 28 日** に **オランダ・アムステルダム** で開催されます。FastAPI のすべてを、ソースから直接。🎤
-
-<a class="fastapi-feature-banner" href="https://fastapiconf.com"><img src="https://fastapi.tiangolo.com/img/fastapi-conf.jpeg" alt="FastAPI Conf '26 - 2026年10月28日 - オランダ・アムステルダム"></a>
-
 ## FastAPI ミニドキュメンタリー { #fastapi-mini-documentary }

 2025 年末に公開された [FastAPI ミニドキュメンタリー](https://www.youtube.com/watch?v=mpR8ngthqiE)があります。オンラインで視聴できます:
@@ -173,19 +167,19 @@ Web API の代わりにターミナルで使用する <abbr title="Command Line

 ## 必要条件 { #requirements }

-FastAPI は巨人の肩の上に立っています。
+FastAPI は巨人の肩の上に立っています:

-* [Starlette](https://www.starlette.dev/)（Web 部分）
-* [Pydantic](https://docs.pydantic.dev/)（データ部分）
+* [Starlette](https://starlette.dev/) は Web 部分のため。
+* [Pydantic](https://pydantic.dev/docs/) はデータ部分のため。

 ## インストール { #installation }

-[仮想環境](https://fastapi.tiangolo.com/ja/virtual-environments/) を作成して有効化し、それから FastAPI をインストールします。
+まず、[`uv` をインストール](https://docs.astral.sh/uv/getting-started/installation/)し、その後 FastAPI をプロジェクトに追加します:

 <div class="termy">

 ```console
-$ pip install "fastapi[standard]"
+$ uv add "fastapi[standard]"

 ---> 100%
 ```
@@ -194,6 +188,8 @@ $ pip install "fastapi[standard]"

 **注**: すべてのターミナルで動作するように、`"fastapi[standard]"` は必ずクォートで囲んでください。

+`pip` を使いたい場合は、仮想環境内で `fastapi[standard]` をインストールしてください。代替手順については、[インストールガイド](tutorial/#install-fastapi) を参照してください。
+
 ## アプリケーション例 { #example }

 ### 作成 { #create-it }
@@ -250,7 +246,7 @@ async def read_item(item_id: int, q: str | None = None):
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
@@ -277,7 +273,7 @@ INFO:     Application startup complete.
 <details markdown="1">
 <summary><code>fastapi dev</code> コマンドについて...</summary>

-`fastapi dev` コマンドは `main.py` ファイルを自動的に読み取り、その中の **FastAPI** アプリを検出し、[Uvicorn](https://www.uvicorn.dev) を使用してサーバーを起動します。
+`fastapi dev` コマンドは `main.py` ファイルを自動的に読み取り、その中の **FastAPI** アプリを検出し、[Uvicorn](https://uvicorn.dev) を使用してサーバーを起動します。

 デフォルトでは、`fastapi dev` はローカル開発向けに自動リロードを有効にして起動します。

@@ -314,7 +310,7 @@ INFO:     Application startup complete.

 次に、[http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) にアクセスします。

-代替の自動ドキュメントが表示されます（[ReDoc](https://github.com/Rebilly/ReDoc) が提供しています）。
+代替の自動ドキュメントが表示されます（[ReDoc](https://github.com/Redocly/redoc) が提供しています）。

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -492,12 +488,12 @@ item: Item

 ### アプリをデプロイ（任意） { #deploy-your-app-optional }

-1 コマンドで FastAPI アプリを [FastAPI Cloud](https://fastapicloud.com) にデプロイできます。 🚀
+任意で、1 コマンドで FastAPI アプリを [FastAPI Cloud](https://fastapicloud.com) にデプロイできます。 🚀

 <div class="termy">

 ```console
-$ fastapi deploy
+$ uv run fastapi deploy

 Deploying to FastAPI Cloud...

@@ -540,7 +536,7 @@ FastAPI は Pydantic と Starlette に依存しています。

 ### `standard` 依存関係 { #standard-dependencies }

-FastAPI を `pip install "fastapi[standard]"` でインストールすると、`standard` グループのオプション依存関係が含まれます。
+FastAPI を `uv add "fastapi[standard]"` でインストールすると、`standard` グループのオプション依存関係が含まれます。

 Pydantic によって使用されるもの:

@@ -554,17 +550,17 @@ Starlette によって使用されるもの:

 FastAPI によって使用されるもの:

-* [`uvicorn`](https://www.uvicorn.dev) - アプリケーションをロードして提供するサーバーのため。これには `uvicorn[standard]` も含まれ、高性能なサービングに必要な依存関係（例: `uvloop`）が含まれます。
+* [`uvicorn`](https://uvicorn.dev) - アプリケーションをロードして提供するサーバーのため。これには `uvicorn[standard]` も含まれ、高性能なサービングに必要な依存関係（例: `uvloop`）が含まれます。
 * `fastapi-cli[standard]` - `fastapi` コマンドを提供します。
    * これには `fastapi-cloud-cli` が含まれ、FastAPI アプリケーションを [FastAPI Cloud](https://fastapicloud.com) にデプロイできます。

 ### `standard` 依存関係なし { #without-standard-dependencies }

-`standard` のオプション依存関係を含めたくない場合は、`pip install "fastapi[standard]"` の代わりに `pip install fastapi` でインストールできます。
+`standard` のオプション依存関係を含めたくない場合は、`uv add "fastapi[standard]"` の代わりに `uv add fastapi` でインストールできます。

 ### `fastapi-cloud-cli` なし { #without-fastapi-cloud-cli }

-標準の依存関係を含めつつ `fastapi-cloud-cli` を除外して FastAPI をインストールしたい場合は、`pip install "fastapi[standard-no-fastapi-cloud-cli]"` でインストールできます。
+標準の依存関係を含めつつ `fastapi-cloud-cli` を除外して FastAPI をインストールしたい場合は、`uv add "fastapi[standard-no-fastapi-cloud-cli]"` でインストールできます。

 ### 追加のオプション依存関係 { #additional-optional-dependencies }

@@ -572,13 +568,13 @@ FastAPI によって使用されるもの:

 追加のオプション 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 で使用する追加の型のため。
+* [`pydantic-settings`](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/) - 設定管理のため。
+* [`pydantic-extra-types`](https://github.com/pydantic/pydantic-extra-types) - Pydantic で使用する追加の型のため。

 追加のオプション FastAPI 依存関係:

 * [`orjson`](https://github.com/ijl/orjson) - `ORJSONResponse` を使用したい場合に必要です。
-* [`ujson`](https://github.com/esnme/ultrajson) - `UJSONResponse` を使用したい場合に必要です。
+* [`ujson`](https://github.com/ultrajson/ultrajson) - `UJSONResponse` を使用したい場合に必要です。

 ## ライセンス { #license }

@@ -4,13 +4,13 @@

 このテンプレートを使って開始できます。初期セットアップの多く、セキュリティ、データベース、いくつかのAPIエンドポイントがすでに用意されています。

-GitHubリポジトリ: [Full Stack FastAPI Template](https://github.com/tiangolo/full-stack-fastapi-template)
+GitHubリポジトリ: [Full Stack FastAPI Template](https://github.com/fastapi/full-stack-fastapi-template)

 ## Full Stack FastAPI テンプレート - 技術スタックと機能 { #full-stack-fastapi-template-technology-stack-and-features }

 - ⚡ PythonバックエンドAPI向けの [**FastAPI**](https://fastapi.tiangolo.com/ja)。
  - 🧰 PythonのSQLデータベース操作（ORM）向けの [SQLModel](https://sqlmodel.tiangolo.com)。
-  - 🔍 FastAPIで使用される、データバリデーションと設定管理向けの [Pydantic](https://docs.pydantic.dev)。
+  - 🔍 FastAPIで使用される、データバリデーションと設定管理向けの [Pydantic](https://pydantic.dev/docs/)。
  - 💾 SQLデータベースとしての [PostgreSQL](https://www.postgresql.org)。
 - 🚀 フロントエンド向けの [React](https://react.dev)。
  - 💃 TypeScript、hooks、Vite、その他のモダンなフロントエンドスタックの各要素を使用。
@@ -269,7 +269,7 @@ def some_function(data: Any):

 ## Pydantic のモデル { #pydantic-models }

-[Pydantic](https://docs.pydantic.dev/) はデータ検証を行うための Python ライブラリです。
+[Pydantic](https://pydantic.dev/docs/) はデータ検証を行うための Python ライブラリです。

 データの「形」を属性付きのクラスとして宣言します。

@@ -285,7 +285,7 @@ Pydantic の公式ドキュメントからの例:

 /// note | 備考

-[Pydantic の詳細はドキュメントを参照してください](https://docs.pydantic.dev/)。
+[Pydantic の詳細はドキュメントを参照してください](https://pydantic.dev/docs/)。

 ///

@@ -63,7 +63,7 @@

 ## 技術的な詳細 { #technical-details }

-`BackgroundTasks` クラスは、[`starlette.background`](https://www.starlette.dev/background/) から直接取得されます。
+`BackgroundTasks` クラスは、[`starlette.background`](https://starlette.dev/background/) から直接取得されます。

 これは、FastAPI に直接インポート/インクルードされるため、`fastapi` からインポートできる上に、`starlette.background`から別の `BackgroundTask` (末尾に `s` がない) を誤ってインポートすることを回避できます。

@@ -71,7 +71,7 @@

 それでも、FastAPI で `BackgroundTask` を単独で使用することは可能ですが、コード内でオブジェクトを作成し、それを含むStarlette `Response` を返す必要があります。

-詳細については、[Starlette のバックグラウンドタスクに関する公式ドキュメント](https://www.starlette.dev/background/)を参照して下さい。
+詳細については、[Starlette のバックグラウンドタスクに関する公式ドキュメント](https://starlette.dev/background/)を参照して下さい。

 ## 注意 { #caveat }

@@ -487,7 +487,7 @@ from app.main import app
 コマンドにパスを渡すこともできます。例えば:

 ```console
-$ fastapi dev app/main.py
+$ uv run fastapi dev app/main.py
 ```

 しかし、そのたびに `fastapi` コマンドを呼ぶ際、正しいパスを渡すのを忘れないようにする必要があります。
@@ -503,7 +503,7 @@ $ fastapi dev app/main.py
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -97,7 +97,7 @@ Pydanticモデルの各属性には型があります。

 `str`や`int`、`float`などの通常の単数型の他にも、`str`を継承したより複雑な単数型を使うこともできます。

-すべてのオプションをみるには、[Pydantic の型の概要](https://docs.pydantic.dev/latest/concepts/types/)を確認してください。次の章でいくつかの例をみることができます。
+すべてのオプションをみるには、[Pydantic の型の概要](https://pydantic.dev/docs/validation/latest/concepts/types/)を確認してください。次の章でいくつかの例をみることができます。

 例えば、`Image`モデルのように`url`フィールドがある場合、`str`の代わりにPydanticの`HttpUrl`のインスタンスとして宣言することができます:

@@ -1,13 +1,12 @@
 # リクエストボディ { #request-body }

-
 クライアント（例えばブラウザ）からAPIにデータを送信する必要がある場合、**リクエストボディ**として送信します。

 **リクエスト**ボディは、クライアントからAPIへ送信されるデータです。**レスポンス**ボディは、APIがクライアントに送信するデータです。

 APIはほとんどの場合 **レスポンス** ボディを送信する必要があります。しかしクライアントは、常に **リクエストボディ** を送信する必要があるとは限りません。場合によっては、クエリパラメータ付きのパスだけをリクエストして、ボディを送信しないこともあります。

-**リクエスト**ボディを宣言するには、[Pydantic](https://docs.pydantic.dev/) モデルを使用し、その強力な機能とメリットをすべて利用します。
+**リクエスト**ボディを宣言するには、[Pydantic](https://pydantic.dev/docs/) モデルを使用し、その強力な機能とメリットをすべて利用します。

 /// note | 備考

@@ -15,7 +15,7 @@ FastAPIアプリケーション上で、`uvicorn` を直接インポートして
 <div class="termy">

 ```console
-$ python myapp.py
+$ uv run python myapp.py
 ```

 </div>
@@ -35,7 +35,7 @@ from myapp import app
 <div class="termy">

 ```console
-$ python myapp.py
+$ uv run python myapp.py
 ```

 </div>
@@ -37,7 +37,7 @@
 * `datetime.timedelta`:
    * Pythonの`datetime.timedelta`です。
    * リクエストとレスポンスでは合計秒数の`float`で表現されます。
-    * Pydanticでは「ISO 8601 time diff encoding」として表現することも可能です。[詳細はドキュメントを参照してください](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers)。
+    * Pydanticでは「ISO 8601 time diff encoding」として表現することも可能です。[詳細はドキュメントを参照してください](https://pydantic.dev/docs/validation/latest/concepts/serialization/#custom-serializers)。
 * `frozenset`:
    * リクエストとレスポンスでは`set`と同じように扱われます:
        * リクエストでは、リストが読み込まれ、重複を排除して`set`に変換されます。
@@ -50,7 +50,7 @@
 * `Decimal`:
    * Pythonの標準的な`Decimal`です。
    * リクエストとレスポンスでは`float`と同じように扱われます。
-* 有効なPydanticのデータ型はここで確認できます: [Pydantic のデータ型](https://docs.pydantic.dev/latest/usage/types/types/)。
+* 有効なPydanticのデータ型はここで確認できます: [Pydantic のデータ型](https://pydantic.dev/docs/validation/latest/concepts/types/)。

 ## 例 { #example }

@@ -166,7 +166,7 @@ OpenAPIでは`anyOf`で定義されます。

 /// note | 備考

-[`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions)を定義する場合は、最も具体的な型を先に、その後により具体性の低い型を含めてください。以下の例では、より具体的な`PlaneItem`が`Union[PlaneItem, CarItem]`内で`CarItem`より前に来ています。
+[`Union`](https://pydantic.dev/docs/validation/latest/concepts/unions/)を定義する場合は、最も具体的な型を先に、その後により具体性の低い型を含めてください。以下の例では、より具体的な`PlaneItem`が`Union[PlaneItem, CarItem]`内で`CarItem`より前に来ています。

 ///

@@ -6,12 +6,18 @@

 これを`main.py`にコピーします。

+/// tip | 豆知識
+
+FastAPIには[VS Code向けの公式拡張機能](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode)（およびCursor）があります。path operation explorer、path operation search、テスト内のCodeLensナビゲーション（テストから定義へジャンプ）、FastAPI Cloudへのデプロイとログなど、多くの機能をすべてエディタから利用できます。
+
+///
+
 ライブサーバーを実行します:

 <div class="termy">

 ```console
-$ <font color="#4E9A06">fastapi</font> dev
+$ <font color="#4E9A06">uv run fastapi</font> dev

  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀

@@ -78,7 +84,7 @@ INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

 次に、[http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc)にアクセスします。

-代替の自動生成ドキュメントが表示されます（[ReDoc](https://github.com/Rebilly/ReDoc)によって提供）:
+代替の自動生成ドキュメントが表示されます（[ReDoc](https://github.com/Redocly/redoc)によって提供）:

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -185,13 +191,13 @@ from backend.main import app
 `fastapi dev`コマンドにファイルパスを渡すこともでき、使用すべきFastAPIのappオブジェクトを推測します:

 ```console
-$ fastapi dev main.py
+$ uv run fastapi dev main.py
 ```

 または、`fastapi dev`コマンドに`--entrypoint`オプションを渡すこともできます:

 ```console
-$ fastapi dev --entrypoint main:app
+$ uv run fastapi dev --entrypoint main:app
 ```

 ただし、その場合は毎回`fastapi`コマンドを呼ぶたびに正しいパスや`entrypoint`を渡すことを覚えておく必要があります。
@@ -205,7 +211,7 @@ $ fastapi dev --entrypoint main:app
 <div class="termy">

 ```console
-$ fastapi deploy
+$ uv run fastapi deploy

 Deploying to FastAPI Cloud...

@@ -232,7 +238,7 @@ CLIはFastAPIアプリケーションを自動検出してクラウドにデプ

 `FastAPI`は`Starlette`を直接継承するクラスです。

-`FastAPI`でも[Starlette](https://www.starlette.dev/)のすべての機能を利用可能です。
+`FastAPI`でも[Starlette](https://starlette.dev/)のすべての機能を利用可能です。

 ///

@@ -312,7 +318,7 @@ APIを構築するときは、通常、これらの特定のHTTPメソッドを
 `@app.get("/")`は直下の関数が下記のリクエストの処理を担当することを**FastAPI**に伝えます:

 * パス `/`
-* <dfn title="HTTP GET メソッド"><code>get</code> オペレーション</dfn>
+* <dfn title="HTTP GETメソッド"><code>get</code> オペレーション</dfn>を使用する

 /// note | `@decorator` 情報

@@ -52,7 +52,7 @@ npm run build

 {* ../../docs_src/frontend/tutorial002_py310.py hl[5] *}

-**FastAPI** は、このフォールバックをブラウザのナビゲーションに見える `GET` および `HEAD` リクエストにのみ使用します。JavaScript、CSS、画像などの存在しないファイルは引き続き `404` を返します。
+**FastAPI** は、このフォールバックを、通常のブラウザナビゲーションリクエストのように `Accept: text/html` または `Accept: application/xhtml+xml` で明示的に HTML を受け付ける `GET` および `HEAD` リクエストにのみ使用します。JavaScript、CSS、画像などの存在しないファイルは引き続き `404` を返します。

 `POST` や `PUT` など、他のメソッドのリクエストがフロントエンドのフォールバックにのみ一致するパスへ送られた場合も、`404` を返します。通常の **FastAPI** の *path operations* は、フロントエンドのルートよりも引き続き高い優先順位を持ちます。

@@ -106,11 +106,15 @@ npm run build

 ## ディレクトリのチェック { #check-directory }

-デフォルトでは、`app.frontend()` はアプリ作成時にディレクトリが存在することをチェックします。
+デフォルトでは、`app.frontend()` は `check_dir="auto"` を使います。

-これにより、設定エラーを早期に検出できます。たとえば、フロントエンドのビルド出力ディレクトリが存在しない場合、**FastAPI** は起動時にエラーを発生させます。
+`FASTAPI_ENV` 環境変数が `development` に設定されている場合、フロントエンドのビルド出力ディレクトリが存在しなくても、**FastAPI** は警告を表示するだけです。[`fastapi dev` コマンド](https://github.com/fastapi/fastapi-cli#fastapi-dev) は、この環境変数がまだ設定されていない場合に設定してくれます。これにより、開発中にフロントエンドをビルドまたは起動する前にバックエンドを起動できます。

-アプリオブジェクトの作成後に別のビルドステップなどでフロントエンドファイルが作成される場合は、`check_dir=False` を設定します。
+それ以外の環境では、**FastAPI** はアプリ作成時にエラーを発生させます。これにより、フロントエンドファイルなしでアプリをデプロイする前に、設定エラーを早期に検出できます。
+
+`check_dir=True` を設定して、アプリ作成時に常にディレクトリをチェックすることもできます。
+
+フロントエンドファイルが後で作成される場合、たとえばアプリオブジェクトの作成後に別のビルドステップで作成される場合は、`check_dir=False` を設定します。

 {* ../../docs_src/frontend/tutorial006_py310.py hl[5] *}

@@ -132,6 +136,8 @@ npm run build

 アプリ、`APIRouter`、および `include_router()` からの依存関係もフロントエンドのレスポンスに適用されます。これは、cookie 認証などでフロントエンドを保護する場合に役立ちます。

+依存関係は、通常の *path operations* と同様に、レスポンスヘッダーを変更したりバックグラウンドタスクを追加したりすることもできます。
+
 ## 静的ビルド出力のみ { #static-build-output-only }

 `app.frontend()` は、フロントエンドのビルドで既に生成されたファイルを配信します。
@@ -82,7 +82,7 @@ Pythonの例外なので、`return`ではなく、`raise`です。

 ## カスタム例外ハンドラのインストール { #install-custom-exception-handlers }

-カスタム例外ハンドラは[Starletteと同じ例外ユーティリティ](https://www.starlette.dev/exceptions/)を使用して追加することができます。
+カスタム例外ハンドラは[Starletteと同じ例外ユーティリティ](https://starlette.dev/exceptions/)を使用して追加することができます。

 あなた（または使用しているライブラリ）が`raise`するかもしれないカスタム例外`UnicornException`があるとしましょう。

@@ -1,6 +1,5 @@
 # チュートリアル - ユーザーガイド { #tutorial-user-guide }

-
 このチュートリアルでは、**FastAPI**のほとんどの機能を使う方法を段階的に紹介します。

 各セクションは前のセクションを踏まえた内容になっています。しかし、トピックごとに分割されているので、特定のAPIのニーズを満たすために、任意の特定のトピックに直接進めるようになっています。
@@ -11,12 +10,12 @@

 すべてのコードブロックをコピーして直接使用できます（実際にテストされたPythonファイルです）。

-いずれかの例を実行するには、コードを `main.py`ファイルにコピーし、次のように `fastapi dev` を起動します:
+いずれかの例を実行するには、コードを `main.py`ファイルにコピーし、`uv run` で `fastapi dev` を起動します:

 <div class="termy">

 ```console
-$ <font color="#4E9A06">fastapi</font> dev
+$ <font color="#4E9A06">uv run fastapi</font> dev

  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀

@@ -61,35 +60,75 @@ $ <font color="#4E9A06">fastapi</font> dev

 ## FastAPIをインストールする { #install-fastapi }

-最初のステップは、FastAPIのインストールです。
+最初のステップは、プロジェクトをセットアップして FastAPI を追加することです。

-[仮想環境](../virtual-environments.md) を作成して有効化し、それから **FastAPIをインストール** してください:
+[`uv`](https://docs.astral.sh/uv/getting-started/installation/) をインストールし、プロジェクトを作成して FastAPI を追加します:

 <div class="termy">

 ```console
-$ pip install "fastapi[standard]"
+$ uv init awesome-project --bare
+$ cd awesome-project
+$ uv add "fastapi[standard]"

 ---> 100%
 ```

 </div>

+`uv add` はプロジェクトの仮想環境を `.venv` に作成し、FastAPI を `pyproject.toml` に追加し、後で同じパッケージバージョンをインストールできるように `uv.lock` を作成します。
+
+/// details | これらのコマンドが行うこと
+
+* `uv init`: 新しい Python プロジェクトを作成します。
+* `awesome-project`: この名前の新しいディレクトリにプロジェクトを作成します。
+* `--bare`: サンプルの `main.py`、`README.md`、その他のファイルを生成せず、最小限の `pyproject.toml` ファイルだけを作成します。このチュートリアルの次のステップで、アプリケーションファイルは自分で作成します。
+
+その後、FastAPI を追加する前に `cd awesome-project` で新しいプロジェクトディレクトリに入ります。
+
+`uv` は、システムにすでにインストールされている互換性のある Python バージョンを使用するか、必要に応じてダウンロードします。
+
+`uv add` を実行すると、FastAPI と FastAPI が依存するすべてのパッケージの互換性のあるバージョンが選択されます。正確なバージョンは `uv.lock` に記録されるため、後で別のコンピューターやアプリケーションをデプロイするときに同じパッケージバージョンをインストールできます。
+
+このファイルを作成または更新することを、[プロジェクト依存関係を**ロック**すること](https://docs.astral.sh/uv/concepts/projects/sync/)と呼びます。`uv` はパッケージを追加するときにこれを自動的に行います。
+
+///
+
+/// details | FastAPI のインストールオプション
+
+`uv add "fastapi[standard]"` でインストールすると、`fastapi-cloud-cli` を含むいくつかのデフォルトのオプション標準依存関係が付属します。これにより、[FastAPI Cloud](https://fastapicloud.com) にデプロイできます。
+
+これらのオプション依存関係が不要な場合は、代わりに `uv add fastapi` をインストールできます。
+
+標準依存関係はインストールしたいが `fastapi-cloud-cli` は不要な場合は、`uv add "fastapi[standard-no-fastapi-cloud-cli]"` でインストールできます。
+
+///
+
+/// details | 代わりに `pip` を使用する
+
+仮想環境とパッケージを手動で管理したい場合は、仮想環境を作成して有効化し、それから `pip install "fastapi[standard]"` で FastAPI をインストールします。
+
+詳しい手順は [仮想環境ガイド](https://tiangolo.com/guides/virtual-environments/) を読んでください。
+
+///
+
+## AI Agent Skills { #ai-agent-skills }
+
+FastAPI には、AI coding agents 向けの公式スキルが含まれています。これはパッケージに同梱されているため、そのガイダンスはプロジェクトにインストールされている FastAPI のバージョンと一致し、FastAPI を更新すると一緒に更新されます。
+
+プロジェクトに FastAPI をインストールした後、<a href="https://library-skills.io">Library Skills</a> でスキルをインストールできます:
+
+```bash
+uvx library-skills
+```
+
 /// note | 備考

-`pip install "fastapi[standard]"` でインストールすると、`fastapi-cloud-cli` を含むいくつかのデフォルトのオプション標準依存関係が付属します。これにより、[FastAPI Cloud](https://fastapicloud.com) にデプロイできます。
-
-これらのオプション依存関係が不要な場合は、代わりに `pip install fastapi` をインストールできます。
-
-標準依存関係はインストールしたいが `fastapi-cloud-cli` は不要な場合は、`pip install "fastapi[standard-no-fastapi-cloud-cli]"` でインストールできます。
+`uvx` は `uv tool run` のエイリアスです。Library Skills がプロジェクトにインストールされたパッケージをスキャンする間、一時的で分離された環境で Library Skills を実行します。

 ///

-/// tip | 豆知識
-
-FastAPI には [VS Code の公式拡張機能](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode)（および Cursor）があります。path operation エクスプローラー、path operation 検索、テスト内の CodeLens ナビゲーション（テストから定義へジャンプ）、そして FastAPI Cloud へのデプロイやログなど、さまざまな機能をエディターから利用できます。
-
-///
+このスキルは Codex、Claude Code、Cursor、GitHub Copilot、Gemini CLI、Pi、OpenCode、およびその他ほとんどの coding agent と互換性があります。Claude Code の場合、スキルのインストール先を尋ねられたら `.claude/skills` を選択してください。

 ## 高度なユーザーガイド { #advanced-user-guide }

@@ -37,7 +37,7 @@

 カスタムの独自ヘッダーは [`X-` プレフィックスを使用](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers)して追加できる点に注意してください。

-ただし、ブラウザのクライアントに表示させたいカスタムヘッダーがある場合は、[CORS (Cross-Origin Resource Sharing)](cors.md) の設定に、[StarletteのCORSドキュメント](https://www.starlette.dev/middleware/#corsmiddleware)に記載されているパラメータ `expose_headers` を使用して、それらを追加する必要があります。
+ただし、ブラウザのクライアントに表示させたいカスタムヘッダーがある場合は、[CORS (Cross-Origin Resource Sharing)](cors.md) の設定に、[StarletteのCORSドキュメント](https://starlette.dev/middleware/#corsmiddleware)に記載されているパラメータ `expose_headers` を使用して、それらを追加する必要があります。

 ///

@@ -92,7 +92,7 @@ Pythonのformat文字列と同様のシンタックスで「パスパラメー

 ## 標準ベースのメリット、ドキュメンテーションの代替物 { #standards-based-benefits-alternative-documentation }

-また、生成されたスキーマが [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md) 標準に従っているので、互換性のあるツールが多数あります。
+また、生成されたスキーマが [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md) 標準に従っているので、互換性のあるツールが多数あります。

 このため、**FastAPI**自体が代替のAPIドキュメントを提供します（ReDocを使用）。これは、 [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) にアクセスすると確認できます。

@@ -102,7 +102,7 @@ Pythonのformat文字列と同様のシンタックスで「パスパラメー

 ## Pydantic { #pydantic }

-すべてのデータバリデーションは [Pydantic](https://docs.pydantic.dev/) によって内部で実行されるため、Pydanticの全てのメリットが得られます。そして、安心して利用することができます。
+すべてのデータバリデーションは [Pydantic](https://pydantic.dev/docs/) によって内部で実行されるため、Pydanticの全てのメリットが得られます。そして、安心して利用することができます。

 `str`、 `float` 、 `bool` および他の多くの複雑なデータ型を型宣言に使用できます。

@@ -370,11 +370,11 @@ http://127.0.0.1:8000/items/?item-query=foobaritems

 その場合、通常のバリデーション（例: 値が `str` であることの検証）の後に適用される **カスタムバリデータ関数** を使えます。

-これを行うには、`Annotated` の中で [Pydantic の `AfterValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator) を使います。
+これを行うには、`Annotated` の中で [Pydantic の `AfterValidator`](https://pydantic.dev/docs/validation/latest/concepts/validators/#field-after-validator) を使います。

 /// tip | 豆知識

-Pydantic には [`BeforeValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator) などもあります。 🤓
+Pydantic には [`BeforeValidator`](https://pydantic.dev/docs/validation/latest/concepts/validators/#field-before-validator) などもあります。 🤓

 ///

@@ -7,10 +7,10 @@

 アップロードされたファイルを受け取るには、まず [`python-multipart`](https://github.com/Kludex/python-multipart) をインストールします。

-[仮想環境](../virtual-environments.md)を作成して有効化し、次のようにインストールしてください:
+プロジェクトに追加してください:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 アップロードされたファイルは「form data」として送信されるためです。
@@ -6,10 +6,10 @@ FastAPI では、フォームフィールドを宣言するために **Pydantic

 フォームを使うには、まず [`python-multipart`](https://github.com/Kludex/python-multipart) をインストールします。

-まず [仮想環境](../virtual-environments.md) を作成して有効化し、そのうえでインストールしてください。例えば:
+プロジェクトに追加します:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 ///
@@ -54,9 +54,9 @@ Pydantic のモデル設定で、`extra` フィールドを `forbid` にでき

 例えば、クライアントが次のフォームフィールドを送ろうとした場合:

- `username`: `Rick`
- `password`: `Portal Gun`
- `extra`: `Mr. Poopybutthole`
+* `username`: `Rick`
+* `password`: `Portal Gun`
+* `extra`: `Mr. Poopybutthole`

 フィールド `extra` は許可されていない旨のエラーレスポンスが返されます:

@@ -4,12 +4,12 @@

 /// note | 備考

-アップロードされたファイルやフォームデータを受信するには、まず[`python-multipart`](https://github.com/Kludex/python-multipart)をインストールします。
+アップロードされたファイルおよび/またはフォームデータを受信するには、まず[`python-multipart`](https://github.com/Kludex/python-multipart)をインストールします。

-[仮想環境](../virtual-environments.md)を作成し、それを有効化してから、例えば次のようにインストールしてください:
+プロジェクトに追加します:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 ///
@@ -6,10 +6,10 @@ JSONの代わりにフィールドを受け取る場合は、`Form`を使用し

 フォームを使うためには、まず[`python-multipart`](https://github.com/Kludex/python-multipart)をインストールします。

-必ず[仮想環境](../virtual-environments.md)を作成して有効化してから、例えば次のようにインストールしてください:
+プロジェクトに追加します:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 ///
@@ -76,16 +76,16 @@ FastAPIはこの `response_model` を使って、データのドキュメント

 `EmailStr` を使用するには、最初に [`email-validator`](https://github.com/JoshData/python-email-validator) をインストールしてください。

-[仮想環境](../virtual-environments.md)を作成して有効化してから、例えば次のようにインストールしてください:
+プロジェクトに追加してください:

 ```console
-$ pip install email-validator
+$ uv add email-validator
 ```

 または次のようにします:

 ```console
-$ pip install "pydantic[email]"
+$ uv add "pydantic[email]"
 ```

 ///
@@ -258,7 +258,7 @@ Pydanticフィールドとして有効ではないものを返し、ツール（
 * `response_model_exclude_defaults=True`
 * `response_model_exclude_none=True`

-`exclude_defaults` と `exclude_none` については、[Pydanticのドキュメント](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict)で説明されている通りです。
+`exclude_defaults` と `exclude_none` については、[Pydanticのドキュメント](https://pydantic.dev/docs/validation/latest/concepts/serialization/#excluding-and-including-fields-based-on-their-value)で説明されている通りです。

 ///

@@ -13,7 +13,7 @@

 その追加情報は、そのモデルの出力**JSON Schema**にそのまま追加され、APIドキュメントで使用されます。

-[Pydanticのドキュメント: Configuration](https://docs.pydantic.dev/latest/api/config/)で説明されているように、`dict`を受け取る属性`model_config`を使用できます。
+[Pydanticのドキュメント: Configuration](https://pydantic.dev/docs/validation/latest/api/pydantic/config/)で説明されているように、`dict`を受け取る属性`model_config`を使用できます。

 生成されるJSON Schemaに表示したい追加データ（`examples`を含む）を含む`dict`を使って、`"json_schema_extra"`を設定できます。

@@ -26,14 +26,14 @@

 /// note | 備考

-[`python-multipart`](https://github.com/Kludex/python-multipart) パッケージは、`pip install "fastapi[standard]"` コマンドを実行すると **FastAPI** と一緒に自動的にインストールされます。
+[`python-multipart`](https://github.com/Kludex/python-multipart) パッケージは、`uv add "fastapi[standard]"` コマンドを実行すると **FastAPI** と一緒に自動的にインストールされます。

-しかし、`pip install fastapi` コマンドを使用する場合、`python-multipart` パッケージはデフォルトでは含まれません。
+しかし、`uv add fastapi` コマンドを使用する場合、`python-multipart` パッケージはデフォルトでは含まれません。

-手動でインストールするには、[仮想環境](../../virtual-environments.md)を作成して有効化し、次のコマンドでインストールしてください:
+手動でインストールするには、次のコマンドでプロジェクトに追加してください:

 ```console
-$ pip install python-multipart
+$ uv add python-multipart
 ```

 これは、**OAuth2**が `username` と `password` を送信するために、「フォームデータ」を使うからです。
@@ -45,7 +45,7 @@ $ pip install python-multipart
 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -30,12 +30,12 @@ JWT トークンを使って遊んでみたいという方は、[https://jwt.io]

 PythonでJWTトークンの生成と検証を行うために、`PyJWT`をインストールする必要があります。

-[仮想環境](../../virtual-environments.md)を作成し、アクティベートしてから、`pyjwt`をインストールしてください。
+プロジェクトに`pyjwt`を追加してください：

 <div class="termy">

 ```console
-$ pip install pyjwt
+$ uv add pyjwt

 ---> 100%
 ```
@@ -72,12 +72,12 @@ pwdlib は、パスワードのハッシュを処理するための優れたPyth

 推奨されるアルゴリズムは「Argon2」です。

-[仮想環境](../../virtual-environments.md)を作成し、アクティベートしてから、Argon2付きでpwdlibをインストールしてください。
+プロジェクトにArgon2付きで`pwdlib`を追加してください：

 <div class="termy">

 ```console
-$ pip install "pwdlib[argon2]"
+$ uv add "pwdlib[argon2]"

 ---> 100%
 ```
@@ -1,11 +1,10 @@
 # SQL（リレーショナル）データベース { #sql-relational-databases }

-
-FastAPI は SQL（リレーショナル）データベースの使用を必須にはしません。必要であれば、任意のデータベースを使用できます。
+**FastAPI** は SQL（リレーショナル）データベースの使用を必須にはしません。必要であれば、**任意のデータベース**を使用できます。

 ここでは [SQLModel](https://sqlmodel.tiangolo.com/) を使った例を見ていきます。

-SQLModel は [SQLAlchemy](https://www.sqlalchemy.org/) と Pydantic の上に構築されています。FastAPI と同じ作者により、SQL データベースを使う必要がある FastAPI アプリに最適になるように作られています。
+**SQLModel** は [SQLAlchemy](https://www.sqlalchemy.org/) と Pydantic の上に構築されています。**FastAPI** と同じ作者により、**SQL データベース**を使う必要がある FastAPI アプリに最適になるように作られています。

 /// tip | 豆知識

@@ -13,7 +12,7 @@ SQLModel は [SQLAlchemy](https://www.sqlalchemy.org/) と Pydantic の上に構

 ///

-SQLModel は SQLAlchemy をベースにしているため、SQLAlchemy がサポートする任意のデータベース（SQLModel からもサポートされます）を簡単に使えます。例えば:
+SQLModel は SQLAlchemy をベースにしているため、SQLAlchemy が**サポートする任意のデータベース**（SQLModel からもサポートされます）を簡単に使えます。例えば:

 * PostgreSQL
 * MySQL
@@ -21,26 +20,26 @@ SQLModel は SQLAlchemy をベースにしているため、SQLAlchemy がサポ
 * Oracle
 * Microsoft SQL Server など

-この例では、単一ファイルで動作し、Python に統合サポートがあるため、SQLite を使います。つまり、この例をそのままコピーして実行できます。
+この例では、単一ファイルで動作し、Python に統合サポートがあるため、**SQLite** を使います。つまり、この例をそのままコピーして実行できます。

-本番アプリでは、PostgreSQL のようなデータベースサーバーを使いたくなるかもしれません。
+本番アプリでは、**PostgreSQL** のようなデータベースサーバーを使いたくなるかもしれません。

 /// tip | 豆知識

-フロントエンドやその他のツールを含む、FastAPI と PostgreSQL の公式プロジェクトジェネレーターがあります: [https://github.com/fastapi/full-stack-fastapi-template](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 のドキュメント](https://sqlmodel.tiangolo.com/)をご覧ください。
+これはとてもシンプルで短いチュートリアルです。データベース一般や SQL、より高度な機能について学びたい場合は、[SQLModel のドキュメント](https://sqlmodel.tiangolo.com/)をご覧ください。

 ## `SQLModel` のインストール { #install-sqlmodel }

-まずは [仮想環境](../virtual-environments.md) を作成・有効化し、`sqlmodel` をインストールします:
+`sqlmodel` をプロジェクトに追加します:

 <div class="termy">

 ```console
-$ pip install sqlmodel
+$ uv add sqlmodel
 ---> 100%
 ```

@@ -48,9 +47,9 @@ $ pip install sqlmodel

 ## 単一モデルでアプリ作成 { #create-the-app-with-a-single-model }

-まずは最も簡単な、単一の SQLModel モデルだけを使うバージョンを作ります。
+まずは最も簡単な、単一の **SQLModel** モデルだけを使うバージョンを作ります。

-後で、下記のとおり複数モデルにしてセキュリティと汎用性を高めます。🤓
+後で、下記のとおり**複数モデル**にしてセキュリティと汎用性を高めます。🤓

 ### モデルの作成 { #create-models }

@@ -58,43 +57,43 @@ $ pip install sqlmodel

 {* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[1:11] hl[7:11] *}

-`Hero` クラスは Pydantic モデルによく似ています（実際には内部的に Pydantic モデルでもあります）。
+`Hero` クラスは Pydantic モデルによく似ています（実際には内部的に*Pydantic モデルでもあります*）。

 いくつかの違いがあります:

-* `table=True` は SQLModel に対して「これはテーブルモデルであり、SQL データベースのテーブルを表す。単なるデータモデル（通常の Pydantic クラス）ではない」と伝えます。
+* `table=True` は SQLModel に対して「これは*テーブルモデル*であり、SQL データベースの**テーブル**を表す。単なる*データモデル*（通常の Pydantic クラス）ではない」と伝えます。

-* `Field(primary_key=True)` は `id` が SQL データベースのプライマリキーであることを SQLModel に伝えます（SQL のプライマリキーについては SQLModel ドキュメントを参照してください）。
+* `Field(primary_key=True)` は `id` が SQL データベースの**プライマリキー**であることを SQLModel に伝えます（SQL のプライマリキーについては SQLModel ドキュメントを参照してください）。

-    注: プライマリキーのフィールドには `int | None` を使っています。これは Python コード内で `id=None` のように「`id` なしでオブジェクトを作成」し、保存時にデータベースが生成することを想定するためです。SQLModel はデータベースが `id` を提供することを理解し、スキーマでは「NULL 不可の `INTEGER` 列」を定義します。詳細は [SQLModel のプライマリキーに関するドキュメント](https://sqlmodel.tiangolo.com/tutorial/create-db-and-table/#primary-key-id) を参照してください。
+    **注:** プライマリキーのフィールドには `int | None` を使っています。これは Python コード内で `id=None` のように「`id` なしでオブジェクトを作成」し、保存時にデータベースが生成することを想定するためです。SQLModel はデータベースが `id` を提供することを理解し、スキーマでは「NULL 不可の `INTEGER` 列」を定義します。詳細は [SQLModel のプライマリキーに関するドキュメント](https://sqlmodel.tiangolo.com/tutorial/create-db-and-table/#primary-key-id) を参照してください。

-* `Field(index=True)` は、この列に対して SQL のインデックスを作成するよう SQLModel に指示します。これにより、この列でフィルタしてデータを読む場合に検索が高速になります。
+* `Field(index=True)` は、この列に対して **SQL インデックス**を作成するよう SQLModel に指示します。これにより、この列でフィルタしてデータを読む場合に検索が高速になります。

    `str` と宣言されたものは、SQL の `TEXT`（データベースによっては `VARCHAR`）型の列になることを SQLModel は理解します。

 ### Engine の作成 { #create-an-engine }

-SQLModel の `engine`（内部的には SQLAlchemy の `engine`）は、データベースへの接続を保持します。
+SQLModel の `engine`（内部的には SQLAlchemy の `engine`）は、データベースへの**接続を保持**します。

-同じデータベースに接続するために、コード全体で 1 つの `engine` オブジェクトを共有します。
+同じデータベースに接続するために、コード全体で**単一の `engine` オブジェクト**を共有します。

 {* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[14:18] hl[14:15,17:18] *}

-`check_same_thread=False` を使うと、FastAPI が異なるスレッドで同じ SQLite データベースを使えるようになります。これは、依存関係などにより 1 つのリクエストが複数スレッドを使う可能性があるため、必要です。
+`check_same_thread=False` を使うと、FastAPI が異なるスレッドで同じ SQLite データベースを使えるようになります。これは、**1 つのリクエスト**が**複数スレッド**を使う可能性があるため（例えば依存関係で）、必要です。

-心配はいりません。このコードの構成では、後で「1 リクエストにつき 1 つの SQLModel セッション」を確実に使うようにします。実際、`check_same_thread` はそれを実現しようとしています。
+心配はいりません。このコードの構成では、後で**1 リクエストにつき 1 つの SQLModel *session***を確実に使うようにします。実際、`check_same_thread` はそれを実現しようとしています。

 ### テーブルの作成 { #create-the-tables }

-`SQLModel.metadata.create_all(engine)` を使って、すべてのテーブルモデルのテーブルを作成する関数を追加します。
+`SQLModel.metadata.create_all(engine)` を使って、すべての*テーブルモデル*の**テーブルを作成**する関数を追加します。

 {* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[21:22] hl[21:22] *}

 ### Session 依存関係の作成 { #create-a-session-dependency }

-`Session` は、メモリ上でオブジェクトを保持して変更を追跡し、`engine` を使ってデータベースと通信します。
+**`Session`** は、**メモリ上でオブジェクトを保持**してデータに必要な変更を追跡し、`engine` を使ってデータベースと通信します。

-各リクエストごとに新しい `Session` を提供する、`yield` を使った FastAPI の依存関係を作成します。これにより、1 リクエストにつき 1 つのセッションを使うことが保証されます。🤓
+各リクエストごとに新しい `Session` を提供する、`yield` を使った FastAPI の**依存関係**を作成します。これにより、1 リクエストにつき 1 つのセッションを使うことが保証されます。🤓

 続いて、この依存関係を使うコードを簡潔にするために、`Annotated` による依存関係 `SessionDep` を作成します。

@@ -118,11 +117,11 @@ SQLModel は Alembic をラップしたマイグレーションユーティリ

 ### Hero の作成 { #create-a-hero }

-各 SQLModel モデルは Pydantic モデルでもあるため、Pydantic モデルと同じように型アノテーションで使えます。
+各 SQLModel モデルは Pydantic モデルでもあるため、Pydantic モデルと同じ**型アノテーション**で使えます。

-例えば、`Hero` 型のパラメータを宣言すると、JSON ボディから読み込まれます。
+例えば、`Hero` 型のパラメータを宣言すると、**JSON ボディ**から読み込まれます。

-同様に、関数の戻り値の型として宣言すると、そのデータ形状が自動 API ドキュメントの UI に表示されます。
+同様に、関数の**戻り値の型**として宣言すると、そのデータ形状が自動 API ドキュメントの UI に表示されます。

 {* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[40:45] hl[40:45] *}

@@ -130,37 +129,37 @@ SQLModel は Alembic をラップしたマイグレーションユーティリ

 ### Hero の取得 { #read-heroes }

-`select()` を使ってデータベースから `Hero` を取得できます。結果のページネーションのために `limit` と `offset` を含められます。
+`select()` を使ってデータベースから `Hero` を**取得**できます。結果のページネーションのために `limit` と `offset` を含められます。

 {* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[48:55] hl[51:52,54] *}

 ### 単一の Hero を取得 { #read-one-hero }

-単一の `Hero` を取得できます。
+単一の `Hero` を**取得**できます。

 {* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[58:63] hl[60] *}

 ### Hero の削除 { #delete-a-hero }

-`Hero` を削除することもできます。
+`Hero` を**削除**することもできます。

 {* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[66:73] hl[71] *}

 ### アプリの起動 { #run-the-app }

-アプリを起動します:
+アプリを起動できます:

 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```

 </div>

-その後 `/docs` の UI にアクセスすると、FastAPI がこれらのモデルを使って API をドキュメント化し、同時にデータのシリアライズとバリデーションにも使っていることがわかります。
+その後 `/docs` の UI にアクセスすると、**FastAPI** がこれらの**モデル**を使って API を**ドキュメント化**し、同時にデータの**シリアライズ**と**バリデーション**にも使っていることがわかります。

 <div class="screenshot">
 <img src="/img/tutorial/sql-databases/image01.png">
@@ -168,41 +167,41 @@ $ fastapi dev

 ## 複数モデルでアプリを更新 { #update-the-app-with-multiple-models }

-ここで、少しリファクタリングしてセキュリティと汎用性を高めましょう。
+ここで、少し**リファクタリング**して**セキュリティ**と**汎用性**を高めましょう。

-前のアプリでは、UI 上でクライアントが作成する `Hero` の `id` を自分で決められてしまいます。😱
+前のアプリを確認すると、UI 上で、現時点ではクライアントが作成する `Hero` の `id` を自分で決められてしまうことがわかります。😱

-それは許可すべきではありません。すでに DB で割り当て済みの `id` を上書きされる可能性があります。`id` の決定はクライアントではなく、バックエンドまたはデータベースが行うべきです。
+それは許可すべきではありません。すでに DB で割り当て済みの `id` を上書きされる可能性があります。`id` の決定は**クライアントではなく**、**バックエンド**または**データベース**が行うべきです。

-さらに、`secret_name` を作っていますが、現状ではそれをどこでも返してしまっています。これではあまり「シークレット」ではありません... 😅
+さらに、ヒーローの `secret_name` を作っていますが、現状ではそれをどこでも返してしまっています。これではあまり**シークレット**ではありません... 😅

-これらを、いくつかの追加モデルで修正します。ここで SQLModel の真価が発揮されます。✨
+これらを、いくつかの**追加モデル**で修正します。ここで SQLModel の真価が発揮されます。✨

 ### 複数モデルの作成 { #create-multiple-models }

-SQLModel では、`table=True` のあるモデルクラスがテーブルモデルです。
+**SQLModel** では、`table=True` のあるモデルクラスが**テーブルモデル**です。

-`table=True` のないモデルクラスはデータモデルで、実体は（小さな機能がいくつか追加された）Pydantic モデルです。🤓
+`table=True` のないモデルクラスは**データモデル**で、実体は（小さな機能がいくつか追加された）Pydantic モデルです。🤓

-SQLModel では継承を使って、あらゆるケースでフィールドの重複を避けられます。
+SQLModel では**継承**を使って、あらゆるケースでフィールドの**重複を避けられます**。

 #### `HeroBase` - ベースクラス { #herobase-the-base-class }

-まず、すべてのモデルで共有されるフィールドを持つ `HeroBase` モデルを作ります:
+まず、すべてのモデルで**共有されるフィールド**を持つ `HeroBase` モデルを作ります:

 * `name`
 * `age`

 {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:9] hl[7:9] *}

-#### `Hero` - テーブルモデル { #hero-the-table-model }
+#### `Hero` - *テーブルモデル* { #hero-the-table-model }

-次に、実際のテーブルモデルである `Hero` を作ります。他のモデルには常に含まれない追加フィールドを持ちます:
+次に、実際の*テーブルモデル*である `Hero` を作ります。他のモデルには常に含まれない**追加フィールド**を持ちます:

 * `id`
 * `secret_name`

-`Hero` は `HeroBase` を継承しているため、`HeroBase` で宣言されたフィールドも持ちます。つまり、`Hero` の全フィールドは次のとおりです:
+`Hero` は `HeroBase` を継承しているため、`HeroBase` で宣言された**フィールド**も持ちます。つまり、`Hero` の全フィールドは次のとおりです:

 * `id`
 * `name`
@@ -211,21 +210,21 @@ SQLModel では継承を使って、あらゆるケースでフィールドの

 {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:14] hl[12:14] *}

-#### `HeroPublic` - 公開用データモデル { #heropublic-the-public-data-model }
+#### `HeroPublic` - 公開用*データモデル* { #heropublic-the-public-data-model }

-次に、API のクライアントに返す `HeroPublic` モデルを作ります。
+次に、API のクライアントに**返す** `HeroPublic` モデルを作ります。

 これは `HeroBase` と同じフィールドを持つため、`secret_name` は含みません。

 これでヒーローの正体は守られます！🥷

-また、`id: int` を再宣言します。これにより、API クライアントとの間で「常に `id` が存在し、`int` である（`None` にはならない）」という契約を結びます。
+また、`id: int` を再宣言します。これにより、API クライアントとの間で「常に `id` が存在し、`int` である（`None` にはならない）」という**契約**を結びます。

 /// tip | 豆知識

 戻り値のモデルで、値が常に存在し常に `int`（`None` ではない）であることを保証すると、API クライアント側のコードははるかにシンプルに書けます。

-加えて、自動生成クライアントのインターフェースも簡潔になり、あなたの API とやり取りする開発者体験が向上します。😎
+加えて、**自動生成クライアント**のインターフェースも簡潔になり、あなたの API とやり取りする開発者体験が向上します。😎

 ///

@@ -237,19 +236,19 @@ SQLModel では継承を使って、あらゆるケースでフィールドの

 {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:18] hl[17:18] *}

-#### `HeroCreate` - 作成用データモデル { #herocreate-the-data-model-to-create-a-hero }
+#### `HeroCreate` - 作成用*データモデル* { #herocreate-the-data-model-to-create-a-hero }

-次に、クライアントからのデータをバリデートする `HeroCreate` モデルを作ります。
+次に、クライアントからのデータを**バリデート**する `HeroCreate` モデルを作ります。

 これは `HeroBase` と同じフィールドに加え、`secret_name` も持ちます。

-これで、クライアントが新しいヒーローを作成する際に `secret_name` を送信し、データベースに保存されますが、そのシークレット名は API ではクライアントに返されません。
+これで、クライアントが**新しいヒーローを作成**する際に `secret_name` を送信し、データベースに保存されますが、そのシークレット名は API ではクライアントに返されません。

 /// tip | 豆知識

-これはパスワードを扱う際の方法と同じです。受け取りますが、API では返しません。
+これは**パスワード**を扱う際の方法と同じです。受け取りますが、API では返しません。

-また、保存前にパスワードの値はハッシュ化し、平文のまま保存しないでください。
+また、保存前にパスワードの値は**ハッシュ化**し、**平文のまま保存しないでください**。

 ///

@@ -261,13 +260,13 @@ SQLModel では継承を使って、あらゆるケースでフィールドの

 {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:22] hl[21:22] *}

-#### `HeroUpdate` - 更新用データモデル { #heroupdate-the-data-model-to-update-a-hero }
+#### `HeroUpdate` - 更新用*データモデル* { #heroupdate-the-data-model-to-update-a-hero }

-前のバージョンのアプリにはヒーローを更新する方法がありませんでしたが、複数モデルを使えば可能です。🎉
+前のバージョンのアプリには**ヒーローを更新する**方法がありませんでしたが、**複数モデル**を使えば可能です。🎉

-`HeroUpdate` データモデルは少し特殊で、新しいヒーローを作成するのに必要なフィールドと同じフィールドをすべて持ちますが、すべてのフィールドがオプショナル（デフォルト値を持つ）です。これにより、更新時には変更したいフィールドだけを送れます。
+`HeroUpdate` *データモデル*は少し特殊で、新しいヒーローを作成するのに必要なフィールドと**同じフィールドをすべて**持ちますが、すべてのフィールドが**オプショナル**（デフォルト値を持つ）です。これにより、更新時には変更したいフィールドだけを送れます。

-すべてのフィールドの型が実質的に変わる（`None` を含み、デフォルト値が `None` になる）ため、フィールドは再宣言する必要があります。
+すべての**フィールドが実質的に変わる**（`None` を含み、デフォルト値が `None` になる）ため、フィールドは**再宣言**する必要があります。

 すべてのフィールドを再宣言するので、厳密には `HeroBase` を継承する必要はありません。一貫性のためにここでは継承していますが、必須ではありません。好みの問題です。🤷

@@ -283,41 +282,41 @@ SQLModel では継承を使って、あらゆるケースでフィールドの

 複数モデルが用意できたので、それらを使うようにアプリの部分を更新します。

-リクエストでは `HeroCreate` データモデルを受け取り、そこから `Hero` テーブルモデルを作成します。
+リクエストでは `HeroCreate` *データモデル*を受け取り、そこから `Hero` *テーブルモデル*を作成します。

-この新しいテーブルモデル `Hero` は、クライアントから送られたフィールドを持ち、データベースによって生成された `id` も持ちます。
+この新しい*テーブルモデル* `Hero` は、クライアントから送られたフィールドを持ち、データベースによって生成された `id` も持ちます。

-関数からはこのテーブルモデル `Hero` をそのまま返します。しかし `response_model` に `HeroPublic` データモデルを指定しているため、FastAPI が `HeroPublic` を使ってデータをバリデート・シリアライズします。
+関数からはこの*テーブルモデル* `Hero` をそのまま返します。しかし `response_model` に `HeroPublic` *データモデル*を指定しているため、**FastAPI** が `HeroPublic` を使ってデータをバリデート・シリアライズします。

 {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[56:62] hl[56:58] *}

 /// tip | 豆知識

-今回は返却値の型アノテーション `-> HeroPublic` の代わりに `response_model=HeroPublic` を使います。返している値は実際には `HeroPublic` ではないためです。
+今回は**返却値の型アノテーション** `-> HeroPublic` の代わりに `response_model=HeroPublic` を使います。返している値は実際には `HeroPublic` ではないためです。

 もし `-> HeroPublic` と宣言すると、エディタや Linter は（正しく）「`HeroPublic` ではなく `Hero` を返している」と警告します。

-`response_model` に指定することで、型アノテーションやエディタ等の補助を崩さずに、FastAPI にシリアライズの仕事を任せられます。
+`response_model` に指定することで、型アノテーションやエディタ等の補助を崩さずに、**FastAPI** にシリアライズの仕事を任せられます。

 ///

 ### `HeroPublic` で Hero を取得 { #read-heroes-with-heropublic }

-前と同様に `Hero` を取得できます。再び `response_model=list[HeroPublic]` を使って、データが正しくバリデート・シリアライズされることを保証します。
+前と同様に `Hero` を**取得**できます。再び `response_model=list[HeroPublic]` を使って、データが正しくバリデート・シリアライズされることを保証します。

 {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[65:72] hl[65] *}

 ### `HeroPublic` で単一の Hero を取得 { #read-one-hero-with-heropublic }

-単一のヒーローを取得します:
+単一のヒーローを**取得**します:

 {* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[75:80] hl[77] *}

 ### `HeroUpdate` で Hero を更新 { #update-a-hero-with-heroupdate }

-ヒーローを更新できます。ここでは HTTP の `PATCH` を使います。
+ヒーローを**更新**できます。ここでは HTTP の `PATCH` operation を使います。

-コードでは、クライアントが送ったデータのみ（デフォルト値として入ってくる値は除外）を持つ `dict` を取得します。これには `exclude_unset=True` を使います。これが主なコツです。🪄
+コードでは、クライアントが送ったすべてのデータ、つまり**クライアントが送ったデータのみ**（デフォルト値として入ってくる値は除外）を持つ `dict` を取得します。これには `exclude_unset=True` を使います。これが主なコツです。🪄

 その後、`hero_db.sqlmodel_update(hero_data)` を使って、`hero_db` を `hero_data` の内容で更新します。

@@ -325,7 +324,7 @@ SQLModel では継承を使って、あらゆるケースでフィールドの

 ### 再度 Hero を削除 { #delete-a-hero-again }

-ヒーローの削除はほとんど変わりません。
+ヒーローの**削除**はほとんど変わりません。

 ここはリファクタリング欲求を満たさないままにしておきます。😅

@@ -333,12 +332,12 @@ SQLModel では継承を使って、あらゆるケースでフィールドの

 ### アプリの再起動 { #run-the-app-again }

-アプリを再度起動します:
+アプリを再度起動できます:

 <div class="termy">

 ```console
-$ fastapi dev
+$ uv run fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -353,6 +352,6 @@ $ fastapi dev

 ## まとめ { #recap }

-[SQLModel](https://sqlmodel.tiangolo.com/) を使って SQL データベースとやり取りし、データモデルとテーブルモデルでコードを簡潔にできます。
+[**SQLModel**](https://sqlmodel.tiangolo.com/) を使って SQL データベースとやり取りし、*データモデル*と*テーブルモデル*でコードを簡潔にできます。

-さらに多くを学ぶには SQLModel のドキュメントをご覧ください。[FastAPI と SQLModel を使うチュートリアル](https://sqlmodel.tiangolo.com/tutorial/fastapi/) もあります。🚀
+さらに多くを学ぶには **SQLModel** のドキュメントをご覧ください。[**FastAPI** と SQLModel を使うチュートリアル](https://sqlmodel.tiangolo.com/tutorial/fastapi/) もあります。🚀
@@ -45,4 +45,4 @@

 ## より詳しい情報 { #more-info }

-詳細とオプションについては、[Starletteの静的ファイルに関するドキュメント](https://www.starlette.dev/staticfiles/)を確認してください。
+詳細とオプションについては、[Starletteの静的ファイルに関するドキュメント](https://starlette.dev/staticfiles/)を確認してください。
@@ -1,6 +1,6 @@
 # テスト { #testing }

-[Starlette](https://www.starlette.dev/testclient/) のおかげで、**FastAPI** アプリケーションのテストは簡単で楽しいものになっています。
+[Starlette](https://starlette.dev/testclient/) のおかげで、**FastAPI** アプリケーションのテストは簡単で楽しいものになっています。

 [HTTPX](https://www.python-httpx.org) がベースで、さらにその設計は Requests をベースにしているため、とても馴染みがあり直感的です。

@@ -12,10 +12,10 @@

 `TestClient` を使用するには、まず [`httpx`](https://www.python-httpx.org) をインストールします。

-[仮想環境](../virtual-environments.md) を作成し、それを有効化してから、例えば以下のようにインストールしてください:
+プロジェクトに追加します:

 ```console
-$ pip install httpx
+$ uv add httpx
 ```

 ///
@@ -156,12 +156,12 @@ FastAPIアプリケーションへのリクエストの送信とは別に、テ

 その後、`pytest` をインストールするだけです。

-[仮想環境](../virtual-environments.md) を作成し、それを有効化してから、例えば以下のようにインストールしてください:
+プロジェクトに追加します:

 <div class="termy">

 ```console
-$ pip install pytest
+$ uv add pytest

 ---> 100%
 ```
@@ -175,7 +175,7 @@ $ pip install pytest
 <div class="termy">

 ```console
-$ pytest
+$ uv run pytest

 ================ test session starts ================
 platform linux -- Python 3.6.9, pytest-5.3.5, py-1.8.1, pluggy-0.13.1
@@ -1,854 +1,35 @@
 # 仮想環境 { #virtual-environments }

-Pythonプロジェクトの作業では、**仮想環境**（または類似の仕組み）を使用し、プロジェクトごとにインストールするパッケージを分離するべきでしょう。
+Pythonプロジェクトで作業する際は、プロジェクトごとにインストールされるパッケージを分離するために**仮想環境**を使用するべきです。

-/// note | 備考
-
-もし、仮想環境の概要や作成方法、使用方法について既にご存知なら、このセクションをスキップした方がよいかもしれません。🤓
-
-///
-
-/// tip | 豆知識
-
-**仮想環境**は、**環境変数**とは異なります。
-
-**環境変数**は、プログラムが使用できるシステム内の変数です。
-
-**仮想環境**は、ファイルをまとめたディレクトリのことです。
-
-///
-
-/// note | 備考
-
-このページでは、**仮想環境**の使用方法と、そのはたらきについて説明します。
-
-もし**すべてを管理するツール**（Pythonのインストールも含む）を導入する準備ができているなら、[uv](https://github.com/astral-sh/uv) をお試しください。
-
-///
+FastAPIプロジェクトでは、プロジェクト、その依存関係、仮想環境を管理するために [uv](https://docs.astral.sh/uv/) を使用することをおすすめします。

 ## プロジェクトの作成 { #create-a-project }

-まず、プロジェクト用のディレクトリを作成します。
-
-私は通常 home/user ディレクトリの中に `code` というディレクトリを用意していて、プロジェクトごとに1つのディレクトリをその中に作成しています。
+[公式インストールガイド](https://docs.astral.sh/uv/getting-started/installation/)に従って `uv` をインストールし、プロジェクトを作成します:

 <div class="termy">

 ```console
-// ホームディレクトリに移動
-$ cd
-// すべてのコードプロジェクト用のディレクトリを作成
-$ mkdir code
-// その code ディレクトリに入る
-$ cd code
-// このプロジェクト用のディレクトリを作成
-$ mkdir awesome-project
-// そのプロジェクトディレクトリに入る
+$ uv init awesome-project --bare
 $ cd awesome-project
+$ uv add "fastapi[standard]"
 ```

 </div>

-## 仮想環境の作成 { #create-a-virtual-environment }
+`uv` はプロジェクトの仮想環境を自動的に作成します。自分で作成したり有効化したりする必要はありません。

-Pythonプロジェクトでの**初めての**作業を開始する際には、**<dfn title="他の選択肢もありますが、これはシンプルなガイドラインです">プロジェクト内</dfn>**に仮想環境を作成してください。
-
-/// tip | 豆知識
-
-これを行うのは、**プロジェクトごとに1回だけ**です。作業のたびに行う必要はありません。
-
-///
-
-//// tab | `venv`
-
-仮想環境を作成するには、Pythonに付属している `venv` モジュールを使用できます。
+プロジェクト環境内でコマンドを実行するには、例えば次のように `uv run` を使用します:

 <div class="termy">

 ```console
-$ python -m venv .venv
+$ uv run fastapi dev
 ```

 </div>

-/// details | このコマンドの意味
+## さらに学ぶ { #learn-more }

-* `python`: `python` というプログラムを呼び出します
-* `-m`: モジュールをスクリプトとして呼び出します。どのモジュールを呼び出すのか、この次に指定します
-* `venv`: 通常Pythonに付随してインストールされる `venv`モジュールを使用します
-* `.venv`: 仮想環境を`.venv`という新しいディレクトリに作成します
-
-///
-
-////
-
-//// tab | `uv`
-
-もし [`uv`](https://github.com/astral-sh/uv) をインストール済みなら、仮想環境を作成するために `uv` を使うこともできます。
-
-<div class="termy">
-
-```console
-$ uv venv
-```
-
-</div>
-
-/// tip | 豆知識
-
-デフォルトでは、 `uv` は `.venv` というディレクトリに仮想環境を作成します。
-
-ただし、追加の引数にディレクトリ名を与えてカスタマイズすることもできます。
-
-///
-
-////
-
-このコマンドは `.venv` というディレクトリに新しい仮想環境を作成します。
-
-/// details | `.venv` またはその他の名前
-
-仮想環境を別のディレクトリに作成することも可能ですが、 `.venv` と名付けるのが一般的な慣習です。
-
-///
-
-## 仮想環境の有効化 { #activate-the-virtual-environment }
-
-実行されるPythonコマンドやインストールされるパッケージが新しく作成した仮想環境を使用するよう、その仮想環境を有効化しましょう。
-
-/// tip | 豆知識
-
-そのプロジェクトの作業で**新しいターミナルセッション**を開始する際には、**毎回**有効化してください。
-
-///
-
-//// tab | Linux, macOS
-
-<div class="termy">
-
-```console
-$ source .venv/bin/activate
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ .venv\Scripts\Activate.ps1
-```
-
-</div>
-
-////
-
-//// tab | Windows Bash
-
-もしWindowsでBashを使用している場合 ([Git Bash](https://gitforwindows.org/)など):
-
-<div class="termy">
-
-```console
-$ source .venv/Scripts/activate
-```
-
-</div>
-
-////
-
-/// tip | 豆知識
-
-**新しいパッケージ**を仮想環境にインストールするたびに、環境をもう一度**有効化**してください。
-
-こうすることで、そのパッケージがインストールした**ターミナル（<abbr title="command line interface - コマンドラインインターフェース">CLI</abbr>）プログラム**を使用する場合に、仮想環境内のものが確実に使われ、グローバル環境にインストールされている別のもの（おそらく必要なものとは異なるバージョン）を誤って使用することを防ぎます。
-
-///
-
-## 仮想環境が有効であることを確認する { #check-the-virtual-environment-is-active }
-
-仮想環境が有効である（前のコマンドが正常に機能した）ことを確認します。
-
-/// tip | 豆知識
-
-これは**任意**ですが、すべてが期待通りに機能し、意図した仮想環境を使用していることを**確認する**良い方法です。
-
-///
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-$ which python
-
-/home/user/code/awesome-project/.venv/bin/python
-```
-
-</div>
-
-`.venv/bin/python` にある `python` バイナリが、プロジェクト（この場合は `awesome-project` ）内に表示されていれば、正常に動作しています 🎉。
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ Get-Command python
-
-C:\Users\user\code\awesome-project\.venv\Scripts\python
-```
-
-</div>
-
-`.venv\Scripts\python` にある `python` バイナリが、プロジェクト（この場合は `awesome-project` ）内に表示されていれば、正常に動作しています 🎉。
-
-////
-
-## `pip` をアップグレードする { #upgrade-pip }
-
-/// tip | 豆知識
-
-もし [`uv`](https://github.com/astral-sh/uv) を使用している場合は、 `pip` の代わりに `uv` を使ってインストールを行うため、 `pip` をアップグレードする必要はありません 😎。
-
-///
-
-もしパッケージのインストールに `pip`（Pythonに標準で付属しています）を使用しているなら、 `pip` を最新バージョンに**アップグレード**しましょう。
-
-パッケージのインストール中に発生する想定外のエラーの多くは、最初に `pip` をアップグレードしておくだけで解決されます。
-
-/// tip | 豆知識
-
-通常、これは仮想環境を作成した直後に**一度だけ**実行します。
-
-///
-
-仮想環境が有効であることを（上で説明したコマンドで）確認し、アップグレードを実行しましょう：
-
-<div class="termy">
-
-```console
-$ python -m pip install --upgrade pip
-
---> 100%
-```
-
-</div>
-
-/// tip | 豆知識
-
-ときどき、pip をアップグレードしようとすると **`No module named pip`** エラーが表示されることがあります。
-
-その場合は、以下のコマンドで pip をインストールしてアップグレードしてください:
-
-<div class="termy">
-
-```console
-$ python -m ensurepip --upgrade
-
---> 100%
-```
-
-</div>
-
-このコマンドは、pip がまだインストールされていなければ pip をインストールし、また、インストールされる pip のバージョンが `ensurepip` で利用可能なもの以上に新しいことも保証します。
-
-///
-
-## `.gitignore` を追加する { #add-gitignore }
-
-**Git**を使用している場合（使用するべきでしょう）、 `.gitignore` ファイルを追加して、 `.venv` 内のあらゆるファイルをGitの管理対象から除外します。
-
-/// tip | 豆知識
-
-もし [`uv`](https://github.com/astral-sh/uv) を使用して仮想環境を作成した場合、すでにこの作業は済んでいるので、この手順をスキップできます 😎。
-
-///
-
-/// tip | 豆知識
-
-これも、仮想環境を作成した直後に**一度だけ**実行します。
-
-///
-
-<div class="termy">
-
-```console
-$ echo "*" > .venv/.gitignore
-```
-
-</div>
-
-/// details | このコマンドの意味
-
-* `echo "*"`: ターミナルに `*` というテキストを「表示」しようとします。（次の部分によってその動作が少し変わります）
-* `>`: `>` の左側のコマンドがターミナルに表示しようとする内容を、ターミナルには表示せず、 `>` の右側のファイルに書き込みます。
-* `.gitignore`: `*` を書き込むファイル名。
-
-ここで、Gitにおける `*` は「すべて」を意味するので、このコマンドによって `.venv` ディレクトリ内のすべてがGitに無視されるようになります。
-
-このコマンドは以下のテキストを持つ `.gitignore` ファイルを作成します：
-
-```gitignore
-*
-```
-
-///
-
-## パッケージのインストール { #install-packages }
-
-仮想環境を有効化した後、その中でパッケージをインストールできます。
-
-/// tip | 豆知識
-
-プロジェクトに必要なパッケージをインストールまたはアップグレードする場合、これを**一度**実行します。
-
-もし新しいパッケージを追加したり、バージョンをアップグレードする必要がある場合は、もう**一度この手順を繰り返し**ます。
-
-///
-
-### パッケージを直接インストールする { #install-packages-directly }
-
-急いでいて、プロジェクトのパッケージ要件を宣言するファイルを使いたくない場合、パッケージを直接インストールできます。
-
-/// tip | 豆知識
-
-プログラムが必要とするパッケージとバージョンをファイル（例えば `requirements.txt` や `pyproject.toml` ）に記載しておくのは、（とても）良い考えです。
-
-///
-
-//// tab | `pip`
-
-<div class="termy">
-
-```console
-$ pip install "fastapi[standard]"
-
---> 100%
-```
-
-</div>
-
-////
-
-//// tab | `uv`
-
-もし [`uv`](https://github.com/astral-sh/uv) を使用できるなら:
-
-<div class="termy">
-
-```console
-$ uv pip install "fastapi[standard]"
---> 100%
-```
-
-</div>
-
-////
-
-### `requirements.txt` からインストールする { #install-from-requirements-txt }
-
-もし `requirements.txt` があるなら、パッケージのインストールに使用できます。
-
-//// tab | `pip`
-
-<div class="termy">
-
-```console
-$ pip install -r requirements.txt
---> 100%
-```
-
-</div>
-
-////
-
-//// tab | `uv`
-
-もし [`uv`](https://github.com/astral-sh/uv) を使用できるなら:
-
-<div class="termy">
-
-```console
-$ uv pip install -r requirements.txt
---> 100%
-```
-
-</div>
-
-////
-
-/// details | `requirements.txt`
-
-パッケージが記載された `requirements.txt` は以下のようになっています:
-
-```requirements.txt
-fastapi[standard]==0.113.0
-pydantic==2.8.0
-```
-
-///
-
-## プログラムを実行する { #run-your-program }
-
-仮想環境を有効化した後、プログラムを実行できます。この際、仮想環境内のPythonと、そこにインストールしたパッケージが使用されます。
-
-<div class="termy">
-
-```console
-$ python main.py
-
-Hello World
-```
-
-</div>
-
-## エディタの設定 { #configure-your-editor }
-
-プロジェクトではおそらくエディタを使用するでしょう。コード補完やインラインエラーの表示ができるように、作成した仮想環境をエディタでも使えるよう設定してください。（多くの場合、自動検出されます）
-
-設定例:
-
-* [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 | 豆知識
-
-この設定は通常、仮想環境を作成した際に**一度だけ**行います。
-
-///
-
-## 仮想環境の無効化 { #deactivate-the-virtual-environment }
-
-プロジェクトの作業が終了したら、その仮想環境を**無効化**できます。
-
-<div class="termy">
-
-```console
-$ deactivate
-```
-
-</div>
-
-これにより、 `python` コマンドを実行しても、そのプロジェクト用（のパッケージがインストールされた）仮想環境から `python` プログラムを呼び出そうとはしなくなります。
-
-## 作業準備完了 { #ready-to-work }
-
-これで、プロジェクトの作業を始める準備が整いました。
-
-
-
-/// tip | 豆知識
-
-上記の内容を理解したいですか？
-
-もしそうなら、以下を読み進めてください。👇🤓
-
-///
-
-## なぜ仮想環境？ { #why-virtual-environments }
-
-FastAPIを使った作業をするには、[Python](https://www.python.org/) のインストールが必要です。
-
-それから、FastAPIや、使用したいその他の**パッケージ**を**インストール**する必要があります。
-
-パッケージをインストールするには、通常、Python に付属する `pip` コマンド (または同様の代替コマンド) を使用します。
-
-ただし、`pip` を直接使用すると、パッケージは**グローバルなPython環境**（OS全体にインストールされたPython環境）にインストールされます。
-
-### 問題点 { #the-problem }
-
-では、グローバルPython環境にパッケージをインストールすることの問題点は何でしょうか？
-
-ある時点で、あなたは**異なるパッケージ**に依存する多くのプログラムを書くことになるでしょう。そして、これらの中には同じパッケージの**異なるバージョン**に依存するものも出てくるでしょう。😱
-
-例えば、 `philosophers-stone` （賢者の石）というプロジェクトを作成するとします。このプログラムは **`harry` （ハリー）というパッケージのバージョン `1`**に依存しています。そのため、 `harry` （ハリー）をインストールする必要があります。
-
-```mermaid
-flowchart LR
-    stone(philosophers-stone) -->|requires| harry-1[harry v1]
-```
-
-それから、 `prisoner-of-azkaban` （アズカバンの囚人）という別のプロジェクトを作成したとします。このプロジェクトも `harry` （ハリー）に依存していますが、**`harry` （ハリー）のバージョン `3`**が必要です。
-
-```mermaid
-flowchart LR
-    azkaban(prisoner-of-azkaban) --> |requires| harry-3[harry v3]
-```
-
-しかし、ここで問題になるのは、もしローカルの**仮想環境**ではなくグローバル（環境）にパッケージをインストールするなら、 `harry` （ハリー）のどのバージョンをインストールするか選ばないといけないことです。
-
-例えば、 `philosophers-stone` （賢者の石）を実行するには、まず `harry` （ハリー）のバージョン `1` をインストールする必要があります：
-
-<div class="termy">
-
-```console
-$ pip install "harry==1"
-```
-
-</div>
-
-これにより、`harry` （ハリー）バージョン1がグローバルなPython環境にインストールされます。
-
-```mermaid
-flowchart LR
-    subgraph global[global env]
-        harry-1[harry v1]
-    end
-    subgraph stone-project[philosophers-stone project]
-        stone(philosophers-stone) -->|requires| harry-1
-    end
-```
-
-しかし、 `prisoner-of-azkaban` （アズカバンの囚人）を実行したい場合は、`harry` （ハリー）のバージョン `1` をアンインストールし、`harry` （ハリー）のバージョン `3` をインストールし直す必要があります。（あるいは、単に`harry` （ハリー）のバージョン `3` をインストールすることで、自動的にバージョン `1` がアンインストールされます）
-
-<div class="termy">
-
-```console
-$ pip install "harry==3"
-```
-
-</div>
-
-このようにして、グローバル環境への `harry` （ハリー）のバージョン `3` のインストールが完了します。
-
-それから、 `philosophers-stone` （賢者の石）を再び実行しようとすると、このプログラムは `harry` （ハリー）のバージョン `1` が必要なため、**動作しなくなる**可能性があります。
-
-```mermaid
-flowchart LR
-    subgraph global[global env]
-        harry-1[<strike>harry v1</strike>]
-        style harry-1 fill:#ccc,stroke-dasharray: 5 5
-        harry-3[harry v3]
-    end
-    subgraph stone-project[philosophers-stone project]
-        stone(philosophers-stone) -.-x|⛔️| harry-1
-    end
-    subgraph azkaban-project[prisoner-of-azkaban project]
-        azkaban(prisoner-of-azkaban) --> |requires| harry-3
-    end
-```
-
-/// tip | 豆知識
-
-Pythonのパッケージでは、**新しいバージョン**で**互換性を損なう変更を避ける**よう努めるのが一般的ですが、それでも注意が必要です。すべてが正常に動作することをテストで確認してから、意図的に指定して新しいバージョンをインストールするのが良いでしょう。
-
-///
-
-あなたのすべての**プロジェクトが依存している**、**多数の**他の**パッケージ**が上記の問題を抱えていると想像してください。これは管理が非常に困難です。そして、**互換性のないバージョン**のパッケージを使ってプロジェクトを実行し、なぜ動作しないのか分からなくなるでしょう。
-
-また、使用しているOS（Linux、Windows、macOS など）によっては、Pythonがすでにインストールされていることがあります。この場合、特定のバージョンのパッケージが**OSの動作に必要である**ことがあります。グローバル環境にパッケージをインストールすると、OSに付属するプログラムを**壊してしまう**可能性があります。
-
-## パッケージのインストール先 { #where-are-packages-installed }
-
-Pythonをインストールしたとき、ファイルを含んだいくつかのディレクトリが作成されます。
-
-これらの中には、インストールされたパッケージを保存するためのものもあります。
-
-以下のコマンドを実行したとき：
-
-<div class="termy">
-
-```console
-// 今は実行しないでください。これは単なる例です 🤓
-$ pip install "fastapi[standard]"
---> 100%
-```
-
-</div>
-
-FastAPIのコードを含む圧縮ファイルが、通常は [PyPI](https://pypi.org/project/fastapi/) からダウンロードされます。
-
-また、FastAPIが依存する他のパッケージも**ダウンロード**されます。
-
-それから、これらのファイルは**解凍**され、コンピュータのあるディレクトリに配置されます。
-
-デフォルトでは、これらのファイルはPythonのインストール時に作成されるディレクトリ、つまり**グローバル環境**に配置されます。
-
-## 仮想環境とは { #what-are-virtual-environments }
-
-すべてのパッケージをグローバル環境に配置することによって生じる問題の解決策は、作業する**プロジェクトごとの仮想環境**を使用することです。
-
-仮想環境は**ディレクトリ**であり、グローバル環境と非常に似ていて、一つのプロジェクトで使う特定のパッケージ群をインストールできる場所です。
-
-このようにして、それぞれのプロジェクトが独自の仮想環境（`.venv` ディレクトリ）に独自のパッケージ群を持つことができます。
-
-```mermaid
-flowchart TB
-    subgraph stone-project[philosophers-stone project]
-        stone(philosophers-stone) --->|requires| harry-1
-        subgraph venv1[.venv]
-            harry-1[harry v1]
-        end
-    end
-    subgraph azkaban-project[prisoner-of-azkaban project]
-        azkaban(prisoner-of-azkaban) --->|requires| harry-3
-        subgraph venv2[.venv]
-            harry-3[harry v3]
-        end
-    end
-    stone-project ~~~ azkaban-project
-```
-
-## 仮想環境の有効化とは { #what-does-activating-a-virtual-environment-mean }
-
-仮想環境を有効にしたとき、例えば次のコマンドを実行した場合を考えます：
-
-//// tab | Linux, macOS
-
-<div class="termy">
-
-```console
-$ source .venv/bin/activate
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ .venv\Scripts\Activate.ps1
-```
-
-</div>
-
-////
-
-//// tab | Windows Bash
-
-あるいは、WindowsでBashを使用している場合 ([Git Bash](https://gitforwindows.org/)など):
-
-<div class="termy">
-
-```console
-$ source .venv/Scripts/activate
-```
-
-</div>
-
-////
-
-これによって、いくつかの [環境変数](environment-variables.md) が作成・修正され、次に実行されるコマンドで使用できるようになります。
-
-これらの環境変数のひとつに、 `PATH` 変数があります。
-
-/// tip | 豆知識
-
-`PATH` 変数についての詳細は [環境変数](environment-variables.md#path-environment-variable) を参照してください。
-
-///
-
-仮想環境を有効にすると、その仮想環境のパス `.venv/bin` （LinuxとmacOS）、あるいは `.venv\Scripts` （Windows）が `PATH` 変数に追加されます。
-
-その環境を有効にする前の `PATH` 変数が次のようになっているとします。
-
-//// tab | Linux, macOS
-
-```plaintext
-/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-これは、OSが以下のディレクトリ中でプログラムを探すことを意味します：
-
-* `/usr/bin`
-* `/bin`
-* `/usr/sbin`
-* `/sbin`
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Windows\System32
-```
-
-これは、OSが以下のディレクトリ中でプログラムを探すことを意味します：
-
-* `C:\Windows\System32`
-
-////
-
-仮想環境を有効にすると、 `PATH` 変数は次のようになります。
-
-//// tab | Linux, macOS
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin:/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-これは、OSが他のディレクトリを探すより前に、最初に以下のディレクトリ中でプログラムを探し始めることを意味します：
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin
-```
-
-そのため、ターミナルで `python` と入力した際に、OSはPythonプログラムを以下のパスで発見し、使用します。
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin/python
-```
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts;C:\Windows\System32
-```
-
-これは、OSが他のディレクトリを探すより前に、最初に以下のディレクトリ中でプログラムを探し始めることを意味します：
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts
-```
-
-そのため、ターミナルで `python` と入力した際に、OSはPythonプログラムを以下のパスで発見し、使用します。
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts\python
-```
-
-////
-
-重要な点は、仮想環境のパスを `PATH` 変数の**先頭**に配置することです。OSは利用可能な他のPythonを見つけるより**前に**、この仮想環境のPythonを見つけるようになります。このようにして、 `python` を実行したときに、他の `python` （例えばグローバル環境の `python` ）ではなく、**その仮想環境の**Pythonを使用するようになります。
-
-仮想環境を有効にして変更されることは他にもありますが、これが最も重要な変更のひとつです。
-
-## 仮想環境の確認 { #checking-a-virtual-environment }
-
-仮想環境が有効かどうか、例えば次のように確認できます。：
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-$ which python
-
-/home/user/code/awesome-project/.venv/bin/python
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ Get-Command python
-
-C:\Users\user\code\awesome-project\.venv\Scripts\python
-```
-
-</div>
-
-////
-
-これは、使用される `python` プログラムが**その仮想環境の**ものであることを意味します。
-
-LinuxやmacOSでは `which` を、Windows PowerShellでは `Get-Command` を使用します。
-
-このコマンドの動作は、 `PATH`変数に設定された**それぞれのパスを順に**確認していき、呼ばれている `python` プログラムを探します。そして、見つかり次第そのプログラムへの**パスを表示します**。
-
-最も重要なことは、 `python` が呼ばれたときに、まさにこのコマンドで確認した "`python`" が実行されることです。
-
-こうして、自分が想定通りの仮想環境にいるかを確認できます。
-
-/// tip | 豆知識
-
-ある仮想環境を有効にし、そのPythonを使用したまま**他のプロジェクトに移動して**しまうことは簡単に起こり得ます。
-
-そして、その第二のプロジェクトは動作しないでしょう。なぜなら別のプロジェクトの仮想環境の**誤ったPython**を使用しているからです。
-
-そのため、どの `python` が使用されているのか確認できることは役立ちます。🤓
-
-///
-
-## なぜ仮想環境を無効化するのか { #why-deactivate-a-virtual-environment }
-
-例えば、`philosophers-stone` （賢者の石）というプロジェクトで作業をしていて、**その仮想環境を有効にし**、必要なパッケージをインストールしてその環境内で作業を進めているとします。
-
-それから、**別のプロジェクト**、 `prisoner-of-azkaban` （アズカバンの囚人）に取り掛かろうとします。
-
-そのプロジェクトディレクトリへ移動します：
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-```
-
-</div>
-
-もし `philosophers-stone` （賢者の石）の仮想環境を無効化していないと、`python` を実行したとき、 ターミナルは `philosophers-stone` （賢者の石）のPythonを使用しようとします。
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-
-$ python main.py
-
-// sirius のインポートエラー。インストールされていません 😱
-Traceback (most recent call last):
-    File "main.py", line 1, in <module>
-        import sirius
-```
-
-</div>
-
-しかし、その仮想環境を無効化し、 `prisoner-of-azkaban` のための新しい仮想環境を有効にすれば、 `python` を実行したときに `prisoner-of-azkaban` （アズカバンの囚人）の仮想環境の Python が使用されるようになります。
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-
-// 無効化のために古いディレクトリにいる必要はありません。どこにいても、他のプロジェクトに移動した後でも実行できます 😎
-$ deactivate
-
-// prisoner-of-azkaban/.venv の仮想環境を有効化する 🚀
-$ source .venv/bin/activate
-
-// これで python を実行すると、この仮想環境にインストールされた sirius パッケージが見つかります ✨
-$ python main.py
-
-I solemnly swear 🐺
-```
-
-</div>
-
-## 代替手段 { #alternatives }
-
-これは、あらゆる仕組みを**根本から**学ぶためのシンプルな入門ガイドです。
-
-仮想環境、パッケージの依存関係（requirements）、プロジェクトの管理には、多くの**代替手段**があります。
-
-準備が整い、パッケージの依存関係、仮想環境など**プロジェクト全体の管理**ツールを使いたいと考えたら、[uv](https://github.com/astral-sh/uv) を試してみることをおすすめします。
-
-`uv` では以下のような多くのことができます：
-
-* 異なるバージョンも含めた**Python のインストール**
-* プロジェクトごとの**仮想環境**の管理
-* **パッケージ**のインストール
-* プロジェクトのパッケージの**依存関係やバージョン**の管理
-* パッケージとそのバージョンの、依存関係を含めた**厳密な**組み合わせを保持し、これによって、本番環境で、開発環境と全く同じようにプロジェクトを実行できる（これは**locking**と呼ばれます）
-* その他のさまざまな機能
-
-## まとめ { #conclusion }
-
-ここまで読みすべて理解したなら、世間の多くの開発者と比べて、仮想環境について**あなたはより多くのことを知っています**。🤓
-
-これらの詳細を知ることは、将来、複雑に見える何かのデバッグにきっと役立つでしょう。しかし、その頃には、あなたは**そのすべての動作を根本から**理解しているでしょう。😎
+仮想環境の内部的な仕組み（有効化や、代替となる `python -m venv` と `pip` のワークフローを含む）については、[仮想環境ガイド](https://tiangolo.com/guides/virtual-environments/)を読んでください。