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
@@ -24,7 +24,7 @@ Chacun de ces `dict` de réponse peut avoir une clé `model`, contenant un modè

 **FastAPI** prendra ce modèle, générera son schéma JSON et l'inclura au bon endroit dans OpenAPI.

-Par exemple, pour déclarer une autre réponse avec un code HTTP `404` et un modèle Pydantic `Message`, vous pouvez écrire :
+Par exemple, pour déclarer une autre réponse avec un code HTTP `404` et un modèle Pydantic `Message`, vous pouvez écrire :

 {* ../../docs_src/additional_responses/tutorial001_py310.py hl[18,22] *}

@@ -42,14 +42,14 @@ La clé `model` ne fait pas partie d'OpenAPI.

 Le bon endroit est :

-* Dans la clé `content`, qui a pour valeur un autre objet JSON (`dict`) qui contient :
-    * Une clé avec le type de support, par ex. `application/json`, qui contient comme valeur un autre objet JSON, qui contient :
+* Dans la clé `content`, qui a pour valeur un autre objet JSON (`dict`) qui contient :
+    * Une clé avec le type de support, par ex. `application/json`, qui contient comme valeur un autre objet JSON, qui contient :
        * Une clé `schema`, qui a pour valeur le schéma JSON du modèle, voici le bon endroit.
            * **FastAPI** ajoute ici une référence aux schémas JSON globaux à un autre endroit de votre OpenAPI au lieu de l'inclure directement. De cette façon, d'autres applications et clients peuvent utiliser ces schémas JSON directement, fournir de meilleurs outils de génération de code, etc.

 ///

-Les réponses générées au format OpenAPI pour ce *chemin d'accès* seront :
+Les réponses générées au format OpenAPI pour ce *chemin d'accès* seront :

 ```JSON hl_lines="3-12"
 {
@@ -88,7 +88,7 @@ Les réponses générées au format OpenAPI pour ce *chemin d'accès* seront :
 }
 ```

-Les schémas sont référencés à un autre endroit du modèle OpenAPI :
+Les schémas sont référencés à un autre endroit du modèle OpenAPI :

 ```JSON hl_lines="4-16"
 {
@@ -173,7 +173,7 @@ Les schémas sont référencés à un autre endroit du modèle OpenAPI :

 Vous pouvez utiliser ce même paramètre `responses` pour ajouter différents types de médias pour la même réponse principale.

-Par exemple, vous pouvez ajouter un type de média supplémentaire `image/png`, en déclarant que votre *chemin d'accès* peut renvoyer un objet JSON (avec le type de média `application/json`) ou une image PNG :
+Par exemple, vous pouvez ajouter un type de média supplémentaire `image/png`, en déclarant que votre *chemin d'accès* peut renvoyer un objet JSON (avec le type de média `application/json`) ou une image PNG :

 {* ../../docs_src/additional_responses/tutorial002_py310.py hl[17:22,26] *}

@@ -201,19 +201,19 @@ Vous pouvez déclarer un `response_model`, en utilisant le code HTTP par défaut

 Par exemple, vous pouvez déclarer une réponse avec un code HTTP `404` qui utilise un modèle Pydantic et a une `description` personnalisée.

-Et une réponse avec un code HTTP `200` qui utilise votre `response_model`, mais inclut un `example` personnalisé :
+Et une réponse avec un code HTTP `200` qui utilise votre `response_model`, mais inclut un `example` personnalisé :

 {* ../../docs_src/additional_responses/tutorial003_py310.py hl[20:31] *}

-Tout sera combiné et inclus dans votre OpenAPI, et affiché dans la documentation de l'API :
+Tout sera combiné et inclus dans votre OpenAPI, et affiché dans la documentation de l'API :

 <img src="/img/tutorial/additional-responses/image01.png">

-## Combinez les réponses prédéfinies et les réponses personnalisées { #combine-predefined-responses-and-custom-ones }
+## Combiner les réponses prédéfinies et les réponses personnalisées { #combine-predefined-responses-and-custom-ones }

 Vous voulez peut-être avoir des réponses prédéfinies qui s'appliquent à de nombreux *chemins d'accès*, mais vous souhaitez les combiner avec des réponses personnalisées nécessaires à chaque *chemin d'accès*.

-Dans ces cas, vous pouvez utiliser la technique Python « unpacking » d'un `dict` avec `**dict_to_unpack` :
+Dans ces cas, vous pouvez utiliser la technique Python « unpacking » d'un `dict` avec `**dict_to_unpack` :

 ```Python
 old_dict = {
@@ -223,7 +223,7 @@ old_dict = {
 new_dict = {**old_dict, "new key": "new value"}
 ```

-Ici, `new_dict` contiendra toutes les paires clé-valeur de `old_dict` plus la nouvelle paire clé-valeur :
+Ici, `new_dict` contiendra toutes les paires clé-valeur de `old_dict` plus la nouvelle paire clé-valeur :

 ```Python
 {
@@ -235,13 +235,13 @@ Ici, `new_dict` contiendra toutes les paires clé-valeur de `old_dict` plus la n

 Vous pouvez utiliser cette technique pour réutiliser certaines réponses prédéfinies dans vos *chemins d'accès* et les combiner avec des réponses personnalisées supplémentaires.

-Par exemple:
+Par exemple :

 {* ../../docs_src/additional_responses/tutorial004_py310.py hl[11:15,24] *}

 ## Plus d'informations sur les réponses OpenAPI { #more-information-about-openapi-responses }

-Pour voir exactement ce que vous pouvez inclure dans les réponses, vous pouvez consulter ces sections dans la spécification OpenAPI :
+Pour voir exactement ce que vous pouvez inclure dans les réponses, vous pouvez consulter ces sections dans la spécification OpenAPI :

-* [Objet Responses de OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object), il inclut le `Response Object`.
-* [Objet Response de OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object), vous pouvez inclure n'importe quoi directement dans chaque réponse à l'intérieur de votre paramètre `responses`. Y compris `description`, `headers`, `content` (à l'intérieur de cela, vous déclarez différents types de médias et schémas JSON) et `links`.
+* [Objet Responses de OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#responses-object), il inclut le `Response Object`.
+* [Objet Response de OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#response-object), vous pouvez inclure n'importe quoi directement dans chaque réponse à l'intérieur de votre paramètre `responses`. Y compris `description`, `headers`, `content` (à l'intérieur de cela, vous déclarez différents types de médias et schémas JSON) et `links`.
@@ -45,7 +45,7 @@ Vous pouvez lancer vos tests comme d'habitude via :
 <div class="termy">

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

 ---> 100%
 ```
@@ -24,7 +24,7 @@ Les en-têtes du proxy sont :

 ### Activer les en-têtes transférés par le proxy { #enable-proxy-forwarded-headers }

-Vous pouvez démarrer FastAPI CLI avec l'option de CLI `--forwarded-allow-ips` et fournir les adresses IP à considérer comme fiables pour lire ces en‑têtes transférés.
+Vous pouvez démarrer FastAPI CLI avec l'*option de CLI* `--forwarded-allow-ips` et fournir les adresses IP à considérer comme fiables pour lire ces en‑têtes transférés.

 Si vous la définissez à `--forwarded-allow-ips="*"`, elle fera confiance à toutes les IP entrantes.

@@ -33,7 +33,7 @@ Si votre **serveur** est derrière un **proxy** de confiance et que seul le prox
 <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)
 ```
@@ -48,7 +48,7 @@ Par exemple, disons que vous définissez un *chemin d'accès* `/items/` :

 Si le client essaie d'aller à `/items`, par défaut, il sera redirigé vers `/items/`.

-Mais avant de définir l'option de CLI `--forwarded-allow-ips`, il pourrait rediriger vers `http://localhost:8000/items/`.
+Mais avant de définir l'*option de CLI* `--forwarded-allow-ips`, il pourrait rediriger vers `http://localhost:8000/items/`.

 Mais peut‑être que votre application est hébergée à `https://mysuperapp.com`, et la redirection devrait être vers `https://mysuperapp.com/items/`.

@@ -170,7 +170,7 @@ Pour y parvenir, vous pouvez utiliser l'option de ligne de commande `--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)
 ```
@@ -200,7 +200,7 @@ Ensuite, si vous démarrez Uvicorn avec :
 <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 @@ Dans un cas comme celui‑ci (sans préfixe de chemin supprimé), le proxy écou

 Vous pouvez facilement faire l'expérience en local avec un préfixe de chemin supprimé en utilisant [Traefik](https://docs.traefik.io/).

-[Téléchargez Traefik](https://github.com/containous/traefik/releases) ; c'est un binaire unique, vous pouvez extraire le fichier compressé et l'exécuter directement depuis le terminal.
+[Téléchargez Traefik](https://github.com/traefik/traefik/releases), c'est un binaire unique, vous pouvez extraire le fichier compressé et l'exécuter directement depuis le terminal.

 Créez ensuite un fichier `traefik.toml` avec :

@@ -321,7 +321,7 @@ Et démarrez maintenant votre application, en utilisant l'option `--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)
 ```
@@ -6,7 +6,7 @@ Mais FastAPI prend aussi en charge l'utilisation de [`dataclasses`](https://docs

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

-C'est toujours pris en charge grâce à **Pydantic**, qui offre une [prise en charge interne des `dataclasses`](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel).
+C'est toujours pris en charge grâce à **Pydantic**, qui offre une [prise en charge interne des `dataclasses`](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/#usage-of-stdlib-dataclasses-with-basemodel).

 Ainsi, même avec le code ci‑dessus qui n'emploie pas explicitement Pydantic, FastAPI utilise Pydantic pour convertir ces dataclasses standard en la variante de dataclasses de Pydantic.

@@ -36,7 +36,7 @@ Vous pouvez aussi utiliser `dataclasses` dans le paramètre `response_model` :

 La dataclass sera automatiquement convertie en dataclass Pydantic.

-Ainsi, son schéma apparaîtra dans l'interface utilisateur de la documentation de l'API :
+Ainsi, son schéma apparaîtra dans l'interface utilisateur des documents de l'API :

 <img src="/img/tutorial/dataclasses/image01.png">

@@ -74,7 +74,7 @@ Dans ce cas, vous pouvez simplement remplacer les `dataclasses` standard par `py

    Comme toujours, avec FastAPI vous pouvez combiner `def` et `async def` selon vos besoins.

-    Si vous avez besoin d'un rappel sur quand utiliser l'un ou l'autre, consultez la section _« In a hurry? »_ dans la documentation à propos de [`async` et `await`](../async.md#in-a-hurry).
+    Si vous avez besoin d'un rappel sur quand utiliser l'un ou l'autre, consultez la section _« Vous êtes pressé ? »_ dans les documents à propos de [`async` et `await`](../async.md#in-a-hurry).

 9. Cette *fonction de chemin d'accès* ne renvoie pas des dataclasses (même si elle le pourrait), mais une liste de dictionnaires contenant des données internes.

@@ -82,13 +82,13 @@ Dans ce cas, vous pouvez simplement remplacer les `dataclasses` standard par `py

 Vous pouvez combiner `dataclasses` avec d'autres annotations de type, selon de nombreuses combinaisons, pour former des structures de données complexes.

-Reportez‑vous aux annotations dans le code ci‑dessus pour voir plus de détails spécifiques.
+Reportez‑vous aux astuces d'annotation dans le code ci‑dessus pour voir plus de détails spécifiques.

 ## En savoir plus { #learn-more }

 Vous pouvez aussi combiner `dataclasses` avec d'autres modèles Pydantic, en hériter, les inclure dans vos propres modèles, etc.

-Pour en savoir plus, consultez la [documentation Pydantic sur les dataclasses](https://docs.pydantic.dev/latest/concepts/dataclasses/).
+Pour en savoir plus, consultez les [documents Pydantic sur les dataclasses](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/).

 ## Version { #version }

@@ -154,7 +154,7 @@ Sous le capot, dans la spécification technique ASGI, cela fait partie du [proto

 /// note | Remarque

-Vous pouvez en lire plus sur les gestionnaires `lifespan` de Starlette dans la [documentation « Lifespan » de Starlette](https://www.starlette.dev/lifespan/).
+Vous pouvez en lire plus sur les gestionnaires `lifespan` de Starlette dans les [documents « Lifespan » de Starlette](https://starlette.dev/lifespan/).

 Y compris comment gérer l'état de cycle de vie qui peut être utilisé dans d'autres parties de votre code.

@@ -12,7 +12,7 @@ Une option polyvalente est le [OpenAPI Generator](https://openapi-generator.tech

 Pour les **clients TypeScript**, [Hey API](https://heyapi.dev/) est une solution dédiée, offrant une expérience optimisée pour l’écosystème TypeScript.

-Vous pouvez découvrir davantage de générateurs de SDK sur [OpenAPI.Tools](https://openapi.tools/#sdk).
+Vous pouvez découvrir davantage de générateurs de SDK sur [OpenAPI.Tools](https://openapi.tools/categories/sdk-generators).

 /// tip | Astuce

@@ -14,7 +14,7 @@ Un middleware n'a pas besoin d'être conçu pour FastAPI ou Starlette pour fonct

 En général, les middlewares ASGI sont des classes qui s'attendent à recevoir une application ASGI en premier argument.

-Ainsi, dans la documentation de middlewares ASGI tiers, on vous indiquera probablement de faire quelque chose comme :
+Ainsi, dans la documentation de middlewares ASGI tiers, on vous indiquera probablement de faire quelque chose comme :

 ```Python
 from unicorn import UnicornMiddleware
@@ -65,10 +65,10 @@ Impose que toutes les requêtes entrantes aient un en-tête `Host` correctement

 {* ../../docs_src/advanced_middleware/tutorial002_py310.py hl[2,6:8] *}

-Les arguments suivants sont pris en charge :
+Les arguments suivants sont pris en charge :

- `allowed_hosts` - Une liste de noms de domaine autorisés comme noms d'hôte. Les domaines génériques tels que `*.example.com` sont pris en charge pour faire correspondre les sous-domaines. Pour autoriser n'importe quel nom d'hôte, utilisez `allowed_hosts=["*"]` ou omettez le middleware.
- `www_redirect` - Si défini à `True`, les requêtes vers les versions sans www des hôtes autorisés seront redirigées vers leurs équivalents avec www. Valeur par défaut : `True`.
+* `allowed_hosts` - Une liste de noms de domaine autorisés comme noms d'hôte. Les domaines génériques tels que `*.example.com` sont pris en charge pour faire correspondre les sous-domaines. Pour autoriser n'importe quel nom d'hôte, utilisez `allowed_hosts=["*"]` ou omettez le middleware.
+* `www_redirect` - Si défini à True, les requêtes vers les versions sans www des hôtes autorisés seront redirigées vers leurs équivalents avec www. Valeur par défaut : `True`.

 Si une requête entrante n'est pas valide, une réponse `400` sera envoyée.

@@ -80,18 +80,18 @@ Le middleware gérera les réponses standard et en streaming.

 {* ../../docs_src/advanced_middleware/tutorial003_py310.py hl[2,6] *}

-Les arguments suivants sont pris en charge :
+Les arguments suivants sont pris en charge :

- `minimum_size` - Ne pas compresser en GZip les réponses dont la taille est inférieure à ce minimum en octets. Valeur par défaut : `500`.
- `compresslevel` - Utilisé pendant la compression GZip. Entier compris entre 1 et 9. Valeur par défaut : `9`. Une valeur plus faible entraîne une compression plus rapide mais des fichiers plus volumineux, tandis qu'une valeur plus élevée entraîne une compression plus lente mais des fichiers plus petits.
+* `minimum_size` - Ne pas compresser en GZip les réponses dont la taille est inférieure à ce minimum en octets. Valeur par défaut : `500`.
+* `compresslevel` - Utilisé pendant la compression GZip. Entier compris entre 1 et 9. Valeur par défaut : `9`. Une valeur plus faible entraîne une compression plus rapide mais des fichiers plus volumineux, tandis qu'une valeur plus élevée entraîne une compression plus lente mais des fichiers plus petits.

 ## Autres middlewares { #other-middlewares }

 Il existe de nombreux autres middlewares ASGI.

-Par exemple :
+Par exemple :

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

-Pour voir d'autres middlewares disponibles, consultez la [documentation des middlewares de Starlette](https://www.starlette.dev/middleware/) et la [liste ASGI Awesome](https://github.com/florimondmanca/awesome-asgi).
+Pour voir d'autres middlewares disponibles, consultez la [documentation des middlewares de Starlette](https://starlette.dev/middleware/) et la [liste ASGI Awesome](https://github.com/florimondmanca/awesome-asgi).
@@ -35,7 +35,7 @@ Cette partie est assez normale, la plupart du code vous est probablement déjà

 /// tip | Astuce

-Le paramètre de requête `callback_url` utilise un type Pydantic [Url](https://docs.pydantic.dev/latest/api/networks/).
+Le paramètre de requête `callback_url` utilise un type Pydantic [Url](https://pydantic.dev/docs/validation/latest/api/pydantic/networks/).

 ///

@@ -106,11 +106,11 @@ Il devrait ressembler exactement à un *chemin d'accès* FastAPI normal :
 Il y a 2 principales différences par rapport à un *chemin d'accès* normal :

 * Il n’a pas besoin d’avoir de code réel, car votre application n’appellera jamais ce code. Il sert uniquement à documenter l’*API externe*. La fonction peut donc simplement contenir `pass`.
-* Le *chemin* peut contenir une [expression OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) (voir plus bas) où il peut utiliser des variables avec des paramètres et des parties de la requête originale envoyée à *votre API*.
+* Le *chemin* peut contenir une [expression OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression) (voir plus bas) où il peut utiliser des variables avec des paramètres et des parties de la requête originale envoyée à *votre API*.

 ### L’expression du chemin de callback { #the-callback-path-expression }

-Le *chemin* du callback peut contenir une [expression OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) qui peut inclure des parties de la requête originale envoyée à *votre API*.
+Le *chemin* du callback peut contenir une [expression OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression) qui peut inclure des parties de la requête originale envoyée à *votre API*.

 Dans ce cas, c’est la `str` :

@@ -177,10 +177,10 @@ Remarquez que vous ne passez pas le routeur lui-même (`invoices_callback_router

 ///

-### Vérifier la documentation { #check-the-docs }
+### Vérifier les documents { #check-the-docs }

 Vous pouvez maintenant démarrer votre application et aller sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).

-Vous verrez votre documentation incluant une section « Callbacks » pour votre *chemin d'accès* qui montre à quoi l’*API externe* devrait ressembler :
+Vous verrez vos documents incluant une section « Callbacks » pour votre *chemin d'accès* qui montre à quoi l’*API externe* devrait ressembler :

 <img src="/img/tutorial/openapi-callbacks/image01.png">
@@ -1,6 +1,5 @@
 # Cookies de réponse { #response-cookies }

-
 ## Utiliser un paramètre `Response` { #use-a-response-parameter }

 Vous pouvez déclarer un paramètre de type `Response` dans votre *fonction de chemin d'accès*.
@@ -49,4 +48,4 @@ Et comme `Response` peut être utilisé fréquemment pour définir des en-têtes

 ///

-Pour voir tous les paramètres et options disponibles, consultez la [documentation de Starlette](https://www.starlette.dev/responses/#set-cookie).
+Pour voir tous les paramètres et options disponibles, consultez la [documentation de Starlette](https://starlette.dev/responses/#set-cookie).
@@ -38,4 +38,4 @@ Et comme `Response` peut être utilisée fréquemment pour définir des en-tête

 Gardez à l'esprit que des en-têtes propriétaires personnalisés peuvent être ajoutés [en utilisant le préfixe `X-`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).

-Mais si vous avez des en-têtes personnalisés que vous voulez qu'un client dans un navigateur puisse voir, vous devez les ajouter à vos configurations CORS (en savoir plus dans [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md)), en utilisant le paramètre `expose_headers` documenté dans [la documentation CORS de Starlette](https://www.starlette.dev/middleware/#corsmiddleware).
+Mais si vous avez des en-têtes personnalisés que vous voulez qu'un client dans un navigateur puisse voir, vous devez les ajouter à vos configurations CORS (en savoir plus dans [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md)), en utilisant le paramètre `expose_headers` documenté dans [la documentation CORS de Starlette](https://starlette.dev/middleware/#corsmiddleware).
@@ -6,41 +6,45 @@ La plupart de ces paramètres sont variables (peuvent changer), comme les URL de

 C'est pourquoi il est courant de les fournir via des variables d'environnement lues par l'application.

+Une **variable d'environnement** (aussi appelée **env var**) est une valeur qui vit en dehors du code Python, dans le système d'exploitation, et qui peut être lue par votre application et d'autres programmes.
+
+Vous pouvez créer une variable d'environnement pour une commande lorsque vous l'exécutez. Vous verrez les commandes spécifiques à chaque plateforme ci-dessous.
+
 /// tip | Astuce

-Pour comprendre les variables d'environnement, vous pouvez lire [Variables d'environnement](../environment-variables.md).
+Lisez le [guide des variables d'environnement](https://tiangolo.com/guides/environment-variables/) pour une explication détaillée du fonctionnement des variables d'environnement.

 ///

 ## Types et validation { #types-and-validation }

-Ces variables d'environnement ne gèrent que des chaînes de texte, car elles sont externes à Python et doivent être compatibles avec d'autres programmes et le reste du système (et même avec différents systèmes d'exploitation, comme Linux, Windows, macOS).
+Ces variables d'environnement ne gèrent que des chaînes de texte, car elles sont externes à Python et doivent être compatibles avec d'autres programmes et le reste du système (et même avec différents systèmes d'exploitation, comme Linux, Windows et macOS).

 Cela signifie que toute valeur lue en Python depuis une variable d'environnement sera une `str`, et toute conversion vers un autre type ou toute validation doit être effectuée dans le code.

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

-Heureusement, Pydantic fournit un excellent utilitaire pour gérer ces paramètres provenant des variables d'environnement avec [Pydantic : gestion des paramètres](https://docs.pydantic.dev/latest/concepts/pydantic_settings/).
+Heureusement, Pydantic fournit un excellent utilitaire pour gérer ces paramètres provenant des variables d'environnement avec [Pydantic : gestion des paramètres](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/).

 ### Installer `pydantic-settings` { #install-pydantic-settings }

-D'abord, vous devez créer votre [environnement virtuel](../virtual-environments.md), l'activer, puis installer le paquet `pydantic-settings` :
+Ajoutez le paquet `pydantic-settings` à votre projet :

 <div class="termy">

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

 </div>

-Il est également inclus lorsque vous installez les extras `all` avec :
+Il est aussi inclus lorsque vous installez les extras `all` avec :

 <div class="termy">

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

@@ -62,7 +66,7 @@ Si vous voulez quelque chose à copier-coller rapidement, n'utilisez pas cet exe

 ///

-Ensuite, lorsque vous créez une instance de cette classe `Settings` (dans ce cas, l'objet `settings`), Pydantic lira les variables d'environnement de manière insensible à la casse, donc une variable en majuscules `APP_NAME` sera tout de même lue pour l'attribut `app_name`.
+Ensuite, lorsque vous créez une instance de cette classe `Settings` (dans ce cas, dans l'objet `settings`), Pydantic lira les variables d'environnement de manière insensible à la casse, donc une variable en majuscules `APP_NAME` sera tout de même lue pour l'attribut `app_name`.

 Il convertira ensuite et validera les données. Ainsi, lorsque vous utilisez cet objet `settings`, vous aurez des données des types que vous avez déclarés (par exemple, `items_per_user` sera un `int`).

@@ -74,33 +78,53 @@ Vous pouvez ensuite utiliser le nouvel objet `settings` dans votre application :

 ### Exécuter le serveur { #run-the-server }

-Ensuite, vous exécutez le serveur en passant les configurations comme variables d'environnement ; par exemple, vous pouvez définir un `ADMIN_EMAIL` et `APP_NAME` avec :
+Ensuite, vous exécuteriez le serveur en passant les configurations comme variables d'environnement ; par exemple, vous pourriez définir un `ADMIN_EMAIL` et `APP_NAME` avec :
+
+//// 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 | Astuce

-Pour définir plusieurs variables d'environnement pour une seule commande, séparez-les simplement par un espace et placez-les toutes avant la commande.
+Dans Bash, pour définir plusieurs env vars pour une seule commande, séparez-les par un espace et placez-les toutes avant la commande.

 ///

-Ainsi, le paramètre `admin_email` sera défini sur « deadpool@example.com ».
+Et alors le paramètre `admin_email` serait défini sur `"deadpool@example.com"`.

-Le `app_name` sera « ChimichangApp ».
+Le `app_name` serait `"ChimichangApp"`.

-Et `items_per_user` conservera sa valeur par défaut de `50`.
+Et `items_per_user` conserverait sa valeur par défaut de `50`.

 ## Paramètres dans un autre module { #settings-in-another-module }

-Vous pouvez placer ces paramètres dans un autre module comme vous l'avez vu dans [Applications plus grandes - Plusieurs fichiers](../tutorial/bigger-applications.md).
+Vous pouvez placer ces paramètres dans un autre fichier de module comme vous l'avez vu dans [Applications plus grandes - Plusieurs fichiers](../tutorial/bigger-applications.md).

 Par exemple, vous pourriez avoir un fichier `config.py` avec :

@@ -160,7 +184,7 @@ Nous pouvons ensuite tester qu'il est bien utilisé.

 ## Lire un fichier `.env` { #reading-a-env-file }

-Si vous avez de nombreux paramètres susceptibles de beaucoup changer, peut-être selon les environnements, il peut être utile de les placer dans un fichier, puis de les lire comme s'il s'agissait de variables d'environnement.
+Si vous avez de nombreux paramètres susceptibles de beaucoup changer, peut-être dans différents environnements, il peut être utile de les placer dans un fichier, puis de les lire depuis celui-ci comme s'il s'agissait de variables d'environnement.

 Cette pratique est suffisamment courante pour avoir un nom ; ces variables d'environnement sont fréquemment placées dans un fichier `.env`, et le fichier est appelé un « dotenv ».

@@ -172,11 +196,11 @@ Mais un fichier dotenv n'a pas forcément exactement ce nom de fichier.

 ///

-Pydantic prend en charge la lecture depuis ce type de fichiers en utilisant une bibliothèque externe. Vous pouvez en lire davantage ici : [Pydantic Settings : prise en charge de Dotenv (.env)](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support).
+Pydantic prend en charge la lecture depuis ce type de fichiers en utilisant une bibliothèque externe. Vous pouvez en lire davantage ici : [Pydantic Settings : prise en charge de Dotenv (.env)](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/#dotenv-env-support).

 /// tip | Astuce

-Pour que cela fonctionne, vous devez exécuter `pip install python-dotenv`.
+Pour que cela fonctionne, ajoutez `python-dotenv` à votre projet avec `uv add python-dotenv`.

 ///

@@ -197,7 +221,7 @@ Puis mettre à jour votre `config.py` avec :

 /// tip | Astuce

-L'attribut `model_config` est utilisé uniquement pour la configuration Pydantic. Vous pouvez en lire davantage ici : [Pydantic : Concepts : Configuration](https://docs.pydantic.dev/latest/concepts/config/).
+L'attribut `model_config` est utilisé uniquement pour la configuration Pydantic. Vous pouvez en lire davantage ici : [Pydantic : Concepts : Configuration](https://pydantic.dev/docs/validation/latest/concepts/config/).

 ///

@@ -298,5 +322,5 @@ De cette façon, elle se comporte presque comme s'il s'agissait simplement d'une
 Vous pouvez utiliser Pydantic Settings pour gérer les paramètres ou configurations de votre application, avec toute la puissance des modèles Pydantic.

 * En utilisant une dépendance, vous pouvez simplifier les tests.
-* Vous pouvez utiliser des fichiers `.env`.
+* Vous pouvez utiliser des fichiers `.env` avec.
 * Utiliser `@lru_cache` vous permet d'éviter de relire le fichier dotenv à chaque requête, tout en vous permettant de le surcharger pendant les tests.
@@ -35,7 +35,7 @@ Exécutez maintenant la commande `fastapi` :
 <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 @@ Il existe des utilitaires pour le configurer facilement que vous pouvez utiliser

 ## Installer les dépendances { #install-dependencies }

-Vous devez créer un [environnement virtuel](../virtual-environments.md), l'activer, puis installer `jinja2` :
+Ajoutez `jinja2` à votre projet :

 <div class="termy">

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

 ---> 100%
 ```
@@ -22,10 +22,10 @@ $ pip install jinja2

 ## Utiliser `Jinja2Templates` { #using-jinja2templates }

- Importez `Jinja2Templates`.
- Créez un objet `templates` que vous pourrez réutiliser par la suite.
- Déclarez un paramètre `Request` dans le *chemin d'accès* qui renverra un template.
- Utilisez l'objet `templates` que vous avez créé pour rendre et retourner une `TemplateResponse`, en transmettant le nom du template, l'objet de requête et un dictionnaire de « context » avec des paires clé-valeur à utiliser dans le template Jinja2.
+* Importez `Jinja2Templates`.
+* Créez un objet `templates` que vous pourrez réutiliser par la suite.
+* Déclarez un paramètre `Request` dans le *chemin d'accès* qui renverra un template.
+* Utilisez l'objet `templates` que vous avez créé pour rendre et retourner une `TemplateResponse`, en transmettant le nom du template, l'objet de requête et un dictionnaire de « context » avec des paires clé-valeur à utiliser dans le template Jinja2.

 {* ../../docs_src/templates/tutorial001_py310.py hl[4,11,15:18] *}

@@ -123,4 +123,4 @@ Et comme vous utilisez `StaticFiles`, ce fichier CSS est servi automatiquement p

 ## En savoir plus { #more-details }

-Pour plus de détails, y compris sur la façon de tester des templates, consultez [la documentation de Starlette sur les templates](https://www.starlette.dev/templates/).
+Pour plus de détails, y compris sur la façon de tester des templates, consultez [la documentation de Starlette sur les templates](https://starlette.dev/templates/).
@@ -4,7 +4,8 @@ Lorsque vous avez besoin d'exécuter `lifespan` dans vos tests, vous pouvez util

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

-Vous pouvez lire plus de détails dans [« Exécuter lifespan dans les tests sur le site de documentation officiel de Starlette. »](https://www.starlette.dev/lifespan/#running-lifespan-in-tests)
+
+Vous pouvez lire plus de détails dans [« Exécuter lifespan dans les tests sur le site de documentation officiel de Starlette. »](https://starlette.dev/lifespan/#running-lifespan-in-tests)

 Pour les événements dépréciés `startup` et `shutdown`, vous pouvez utiliser le `TestClient` comme suit :

@@ -8,6 +8,6 @@ Pour cela, vous utilisez `TestClient` dans une instruction `with`, en vous conne

 /// note | Remarque

-Pour plus de détails, consultez la documentation de Starlette sur le [test des WebSockets](https://www.starlette.dev/testclient/#testing-websocket-sessions).
+Pour plus de détails, consultez la documentation de Starlette sur le [test des WebSockets](https://starlette.dev/testclient/#testing-websocket-sessions).

 ///
@@ -15,7 +15,7 @@ Mais il existe des situations où vous pouvez avoir besoin d'accéder directemen

 ## Détails sur l'objet `Request` { #details-about-the-request-object }

-Comme **FastAPI** est en fait **Starlette** en dessous, avec une couche de plusieurs outils au-dessus, vous pouvez utiliser directement l'objet [`Request`](https://www.starlette.dev/requests/) de Starlette lorsque vous en avez besoin.
+Comme **FastAPI** est en fait **Starlette** en dessous, avec une couche de plusieurs outils au-dessus, vous pouvez utiliser directement l'objet [`Request`](https://starlette.dev/requests/) de Starlette lorsque vous en avez besoin.

 Cela signifie aussi que si vous récupérez des données directement à partir de l'objet `Request` (par exemple, lire le corps), elles ne seront pas validées, converties ni documentées (avec OpenAPI, pour l'interface utilisateur automatique de l'API) par FastAPI.

@@ -25,13 +25,13 @@ Mais il existe des cas spécifiques où il est utile d'obtenir l'objet `Request`

 ## Utiliser l'objet `Request` directement { #use-the-request-object-directly }

-Imaginons que vous souhaitiez obtenir l'adresse IP/l'hôte du client dans votre fonction de chemin d'accès.
+Imaginons que vous souhaitiez obtenir l'adresse IP/l'hôte du client dans votre *fonction de chemin d'accès*.

 Pour cela, vous devez accéder directement à la requête.

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

-En déclarant un paramètre de fonction de chemin d'accès de type `Request`, **FastAPI** saura passer la `Request` dans ce paramètre.
+En déclarant un paramètre de *fonction de chemin d'accès* de type `Request`, **FastAPI** saura passer la `Request` dans ce paramètre.

 /// tip | Astuce

@@ -45,7 +45,7 @@ De la même façon, vous pouvez déclarer tout autre paramètre normalement, et

 ## Documentation de `Request` { #request-documentation }

-Vous pouvez lire plus de détails sur [l'objet `Request` sur le site de documentation officiel de Starlette](https://www.starlette.dev/requests/).
+Vous pouvez lire plus de détails sur [l'objet `Request` sur le site de documentation officiel de Starlette](https://starlette.dev/requests/).

 /// note | Détails techniques

@@ -4,12 +4,12 @@ Vous pouvez utiliser [WebSockets](https://developer.mozilla.org/en-US/docs/Web/A

 ## Installer `websockets` { #install-websockets }

-Vous devez créer un [environnement virtuel](../virtual-environments.md), l'activer, et installer `websockets` (une bibliothèque Python qui facilite l'utilisation du protocole « WebSocket ») :
+Ajoutez `websockets` (une bibliothèque Python qui facilite l'utilisation du protocole « WebSocket ») à votre projet :

 <div class="termy">

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

 ---> 100%
 ```
@@ -69,7 +69,7 @@ Mettez votre code dans un fichier `main.py` puis exécutez votre application :
 <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)
 ```
@@ -126,7 +126,7 @@ Exécutez votre application :
 <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)
 ```
@@ -182,5 +182,5 @@ Si vous avez besoin de quelque chose de facile à intégrer avec FastAPI mais pl

 Pour en savoir plus sur les options, consultez la documentation de Starlette concernant :

-* [La classe `WebSocket`](https://www.starlette.dev/websockets/).
-* [Gestion des WebSocket basée sur des classes](https://www.starlette.dev/endpoints/#websocketendpoint).
+* [La classe `WebSocket`](https://starlette.dev/websockets/).
+* [Gestion des WebSocket basée sur des classes](https://starlette.dev/endpoints/#websocketendpoint).
@@ -9,7 +9,7 @@ Pour cela, vous pouvez utiliser `WSGIMiddleware` et l'utiliser pour envelopper v

 /// note | Remarque

-Cela nécessite l'installation de `a2wsgi`, par exemple avec `pip install a2wsgi`.
+Cela nécessite d'ajouter `a2wsgi` à votre projet, par exemple avec `uv add a2wsgi`.

 ///

@@ -27,7 +27,7 @@ Auparavant, il était recommandé d'utiliser `WSGIMiddleware` depuis `fastapi.mi

 Il est conseillé d'utiliser le package `a2wsgi` à la place. L'utilisation reste la même.

-Assurez-vous simplement que le package `a2wsgi` est installé et importez `WSGIMiddleware` correctement depuis `a2wsgi`.
+Vous devez simplement vous assurer que le package `a2wsgi` est installé et importer `WSGIMiddleware` correctement depuis `a2wsgi`.

 ///

@@ -135,7 +135,7 @@ Adopter et utiliser une norme ouverte pour les spécifications des API, au lieu
 Et intégrer des outils d'interface utilisateur basés sur des normes :

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

 Ces deux-là ont été choisis parce qu'ils sont populaires et stables, mais en faisant une recherche rapide, vous pourriez trouver des dizaines d'interfaces utilisateur alternatives pour OpenAPI (que vous pouvez utiliser avec **FastAPI**).

@@ -254,7 +254,7 @@ Générer le schéma OpenAPI automatiquement, à partir du même code qui défin

 ///

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

 Ce n'est même pas du Python, NestJS est un framework JavaScript (TypeScript) NodeJS inspiré d'Angular.

@@ -362,7 +362,7 @@ Comme il est basé sur l'ancienne norme pour les frameworks web Python synchrone

 /// note | Remarque

-Hug a été créé par Timothy Crosley, le même créateur de [`isort`](https://github.com/timothycrosley/isort), un excellent outil pour trier automatiquement les imports dans les fichiers Python.
+Hug a été créé par Timothy Crosley, le même créateur de [`isort`](https://github.com/PyCQA/isort), un excellent outil pour trier automatiquement les imports dans les fichiers Python.

 ///

@@ -429,7 +429,7 @@ Je considère **FastAPI** comme un « successeur spirituel » d'APIStar, tout en

 ## Utilisés par **FastAPI** { #used-by-fastapi }

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

 Pydantic est une bibliothèque permettant de définir la validation, la sérialisation et la documentation des données (à l'aide de JSON Schema) en se basant sur les annotations de type Python.

@@ -446,7 +446,7 @@ Gérer toute la validation des données, leur sérialisation et la documentation

 ///

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

 Starlette est un framework/toolkit léger <dfn title="La nouvelle norme pour créer des applications web Python asynchrones">ASGI</dfn>, qui est idéal pour construire des services asyncio performants.

@@ -491,7 +491,7 @@ Ainsi, tout ce que vous pouvez faire avec Starlette, vous pouvez le faire direct

 ///

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

 Uvicorn est un serveur ASGI rapide comme l'éclair, basé sur uvloop et httptools.

@@ -105,36 +105,32 @@ C'est ce que vous voudrez faire dans **la plupart des cas**, par exemple :

 ### Dépendances des paquets { #package-requirements }

-Vous aurez normalement les **dépendances des paquets** de votre application dans un fichier.
+Lorsque vous gérez votre projet avec `uv`, ses dépendances directes sont déclarées dans `pyproject.toml` et les versions exactes résolues sont stockées dans `uv.lock`.

-Cela dépendra principalement de l'outil que vous utilisez pour **installer** ces dépendances.
-
-La manière la plus courante consiste à avoir un fichier `requirements.txt` avec les noms des paquets et leurs versions, un par ligne.
-
-Vous utiliserez bien sûr les mêmes idées que vous avez lues dans [À propos des versions de FastAPI](versions.md) pour définir les plages de versions.
-
-Par exemple, votre `requirements.txt` pourrait ressembler à :
-
-```
-fastapi[standard]>=0.113.0,<0.114.0
-pydantic>=2.7.0,<3.0.0
-```
-
-Et vous installerez normalement ces dépendances de paquets avec `pip`, par exemple :
+Vous pouvez ajouter les paquets dont votre application a besoin avec :

 <div class="termy">

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

 </div>

 /// note | Remarque

-Il existe d'autres formats et outils pour définir et installer des dépendances de paquets.
+Le Dockerfile ci-dessous utilise `pip` à l'intérieur du conteneur. Vous pouvez exporter les dépendances verrouillées de votre projet uv vers le format `requirements.txt` qu'il attend :
+
+<div class="termy">
+
+```console
+$ uv export --format requirements-txt --no-dev --no-emit-project --output-file requirements.txt
+```
+
+</div>
+
+Le `requirements.txt` généré est un export pour la construction du conteneur. Continuez à gérer les dépendances avec `uv add` et régénérez-le lorsque `uv.lock` change.

 ///

@@ -372,7 +368,7 @@ Vous verrez la documentation interactive automatique de l'API (fournie par [Swag

 Et vous pouvez aussi aller sur [http://192.168.99.100/redoc](http://192.168.99.100/redoc) ou [http://127.0.0.1/redoc](http://127.0.0.1/redoc) (ou équivalent, en utilisant votre hôte Docker).

-Vous verrez la documentation automatique alternative (fournie par [ReDoc](https://github.com/Rebilly/ReDoc)) :
+Vous verrez la documentation automatique alternative (fournie par [ReDoc](https://github.com/Redocly/redoc)) :

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

@@ -5,7 +5,7 @@ Vous pouvez déployer votre application FastAPI sur [FastAPI Cloud](https://fast
 <div class="termy">

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

 Deploying to FastAPI Cloud...

@@ -52,7 +52,7 @@ La principale chose dont vous avez besoin pour exécuter une application **FastA

 Il existe plusieurs alternatives, notamment :

-* [Uvicorn](https://www.uvicorn.dev/) : un serveur ASGI haute performance.
+* [Uvicorn](https://uvicorn.dev) : un serveur ASGI haute performance.
 * [Hypercorn](https://hypercorn.readthedocs.io/) : un serveur ASGI compatible avec HTTP/2 et Trio entre autres fonctionnalités.
 * [Daphne](https://github.com/django/daphne) : le serveur ASGI conçu pour Django Channels.
 * [Granian](https://github.com/emmett-framework/granian) : un serveur HTTP Rust pour les applications Python.
@@ -73,14 +73,14 @@ Lorsque vous installez FastAPI, il est fourni avec un serveur de production, Uvi

 Mais vous pouvez également installer un serveur ASGI manuellement.

-Vous devez créer un [environnement virtuel](../virtual-environments.md), l'activer, puis vous pouvez installer l'application serveur.
+Ajoutez l'application serveur à votre projet.

 Par exemple, pour installer Uvicorn :

 <div class="termy">

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

 ---> 100%
 ```
@@ -91,11 +91,11 @@ Un processus similaire s'appliquerait à tout autre programme de serveur ASGI.

 /// tip | Astuce

-En ajoutant `standard`, Uvicorn va installer et utiliser quelques dépendances supplémentaires recommandées.
+En ajoutant le `standard`, Uvicorn va installer et utiliser quelques dépendances supplémentaires recommandées.

 Cela inclut `uvloop`, le remplaçant hautes performances de `asyncio`, qui fournit le gros gain de performance en matière de concurrence.

-Lorsque vous installez FastAPI avec quelque chose comme `pip install "fastapi[standard]"`, vous obtenez déjà `uvicorn[standard]` aussi.
+Lorsque vous ajoutez FastAPI avec quelque chose comme `uv add "fastapi[standard]"`, vous obtenez déjà `uvicorn[standard]` aussi.

 ///

@@ -106,7 +106,7 @@ Si vous avez installé un serveur ASGI manuellement, vous devrez normalement pas
 <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)
 ```
@@ -9,13 +9,13 @@ Reprenons ces concepts de déploiement vus précédemment :
 * Mémoire
 * Étapes préalables avant le démarrage

-Jusqu'à présent, avec tous les tutoriels dans les documents, vous avez probablement exécuté un programme serveur, par exemple avec la commande `fastapi`, qui lance Uvicorn en exécutant un seul processus.
+Jusqu'à présent, avec tous les tutoriels dans les documents, vous avez probablement exécuté un **programme serveur**, par exemple avec la commande `fastapi`, qui lance Uvicorn, en exécutant un **seul processus**.

-Lors du déploiement d'applications, vous voudrez probablement avoir une réplication de processus pour tirer parti de plusieurs cœurs et pouvoir gérer davantage de requêtes.
+Lors du déploiement d'applications, vous voudrez probablement avoir une **réplication de processus** pour tirer parti de **plusieurs cœurs** et pouvoir gérer davantage de requêtes.

 Comme vous l'avez vu dans le chapitre précédent sur les [Concepts de déploiement](concepts.md), il existe plusieurs stratégies possibles.

-Ici, je vais vous montrer comment utiliser Uvicorn avec des processus workers en utilisant la commande `fastapi` ou directement la commande `uvicorn`.
+Ici, je vais vous montrer comment utiliser **Uvicorn** avec des **processus workers** en utilisant la commande `fastapi` ou directement la commande `uvicorn`.

 /// note | Remarque

@@ -86,7 +86,7 @@ Si vous préférez utiliser directement la commande `uvicorn` :
 <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>]
@@ -113,9 +113,9 @@ Vous pouvez aussi voir qu'il affiche le **PID** de chaque processus, `27365` pou

 ## Concepts de déploiement { #deployment-concepts }

-Ici, vous avez vu comment utiliser plusieurs workers pour paralléliser l'exécution de l'application, tirer parti de plusieurs cœurs du CPU et être en mesure de servir davantage de requêtes.
+Ici, vous avez vu comment utiliser plusieurs **workers** pour **paralléliser** l'exécution de l'application, tirer parti de **plusieurs cœurs** du CPU et être en mesure de servir **davantage de requêtes**.

-Dans la liste des concepts de déploiement ci-dessus, l'utilisation de workers aide principalement à la partie réplication, et un peu aux redémarrages, mais vous devez toujours vous occuper des autres :
+Dans la liste des concepts de déploiement ci-dessus, l'utilisation de workers aide principalement à la partie **réplication**, et un peu aux **redémarrages**, mais vous devez toujours vous occuper des autres :

 * **Sécurité - HTTPS**
 * **Exécution au démarrage**
@@ -128,12 +128,12 @@ Dans la liste des concepts de déploiement ci-dessus, l'utilisation de workers a

 Dans le prochain chapitre sur [FastAPI dans des conteneurs - Docker](docker.md), j'expliquerai quelques stratégies que vous pourriez utiliser pour gérer les autres **concepts de déploiement**.

-Je vous montrerai comment créer votre propre image à partir de zéro pour exécuter un seul processus Uvicorn. C'est un processus simple et c'est probablement ce que vous voudrez faire lorsque vous utilisez un système distribué de gestion de conteneurs comme **Kubernetes**.
+Je vous montrerai comment **créer votre propre image à partir de zéro** pour exécuter un seul processus Uvicorn. C'est un processus simple et c'est probablement ce que vous voudrez faire lorsque vous utilisez un système distribué de gestion de conteneurs comme **Kubernetes**.

 ## Récapitulatif { #recap }

 Vous pouvez utiliser plusieurs processus workers avec l'option CLI `--workers` des commandes `fastapi` ou `uvicorn` pour tirer parti des **CPU multicœurs**, et exécuter **plusieurs processus en parallèle**.

-Vous pourriez utiliser ces outils et idées si vous mettez en place votre propre système de déploiement tout en prenant vous-même en charge les autres concepts de déploiement.
+Vous pourriez utiliser ces outils et idées si vous mettez en place **votre propre système de déploiement** tout en prenant vous-même en charge les autres concepts de déploiement.

 Consultez le prochain chapitre pour en savoir plus sur **FastAPI** avec des conteneurs (par exemple Docker et Kubernetes). Vous verrez que ces outils offrent aussi des moyens simples de résoudre les autres **concepts de déploiement**. ✨
@@ -1,298 +1,11 @@
 # Variables d'environnement { #environment-variables }

-/// tip | Astuce
+Une **variable d'environnement** (également appelée **env var**) est une valeur qui vit en dehors de votre code Python, dans le système d'exploitation, et qui peut être lue par votre application et d'autres programmes.

-Si vous savez déjà ce que sont les « variables d'environnement » et comment les utiliser, vous pouvez passer cette section.
+Les applications FastAPI utilisent couramment les variables d'environnement pour la configuration, comme les URL de bases de données, les identifiants de messagerie et les clés secrètes.

-///
+Vous apprendrez à les utiliser pour la configuration d'application dans [Paramètres et variables d'environnement](advanced/settings.md).

-Une variable d'environnement (également appelée « **env var** ») est une variable qui vit **en dehors** du code Python, dans le **système d'exploitation**, et qui peut être lue par votre code Python (ou par d'autres programmes également).
+## En savoir plus { #learn-more }

-Les variables d'environnement peuvent être utiles pour gérer des **paramètres** d'application, dans le cadre de l'**installation** de Python, etc.
-
-## Créer et utiliser des variables d'environnement { #create-and-use-env-vars }
-
-Vous pouvez **créer** et utiliser des variables d'environnement dans le **shell (terminal)**, sans avoir besoin de Python :
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// Vous pouvez créer une variable d'environnement MY_NAME avec
-$ export MY_NAME="Wade Wilson"
-
-// Vous pouvez ensuite l'utiliser avec d'autres programmes, par exemple
-$ echo "Hello $MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// Créer une variable d'environnement MY_NAME
-$ $Env:MY_NAME = "Wade Wilson"
-
-// L'utiliser avec d'autres programmes, par exemple
-$ echo "Hello $Env:MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-## Lire des variables d'environnement en Python { #read-env-vars-in-python }
-
-Vous pouvez également créer des variables d'environnement **en dehors** de Python, dans le terminal (ou par tout autre moyen), puis les **lire en Python**.
-
-Par exemple, vous pouvez avoir un fichier `main.py` contenant :
-
-```Python hl_lines="3"
-import os
-
-name = os.getenv("MY_NAME", "World")
-print(f"Hello {name} from Python")
-```
-
-/// tip | Astuce
-
-Le deuxième argument de [`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) est la valeur par défaut à retourner.
-
-S'il n'est pas fourni, c'est `None` par défaut ; ici, nous fournissons `"World"` comme valeur par défaut à utiliser.
-
-///
-
-Vous pouvez ensuite exécuter ce programme Python :
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// Ici, nous ne définissons pas encore la variable d'environnement
-$ python main.py
-
-// Comme nous ne l'avons pas définie, nous obtenons la valeur par défaut
-
-Hello World from Python
-
-// Mais si nous créons d'abord une variable d'environnement
-$ export MY_NAME="Wade Wilson"
-
-// Puis que nous relançons le programme
-$ python main.py
-
-// Il peut maintenant lire la variable d'environnement
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// Ici, nous ne définissons pas encore la variable d'environnement
-$ python main.py
-
-// Comme nous ne l'avons pas définie, nous obtenons la valeur par défaut
-
-Hello World from Python
-
-// Mais si nous créons d'abord une variable d'environnement
-$ $Env:MY_NAME = "Wade Wilson"
-
-// Puis que nous relançons le programme
-$ python main.py
-
-// Il peut maintenant lire la variable d'environnement
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-////
-
-Comme les variables d'environnement peuvent être définies en dehors du code, mais lues par le code, et qu'elles n'ont pas besoin d'être stockées (validées dans `git`) avec le reste des fichiers, il est courant de les utiliser pour les configurations ou les **paramètres**.
-
-Vous pouvez également créer une variable d'environnement uniquement pour l'**invocation d'un programme spécifique**, qui ne sera disponible que pour ce programme et uniquement pendant sa durée d'exécution.
-
-Pour cela, créez-la juste avant le programme, sur la même ligne :
-
-<div class="termy">
-
-```console
-// Créer en ligne une variable d'environnement MY_NAME pour cet appel de programme
-$ MY_NAME="Wade Wilson" python main.py
-
-// Il peut maintenant lire la variable d'environnement
-
-Hello Wade Wilson from Python
-
-// La variable d'environnement n'existe plus ensuite
-$ python main.py
-
-Hello World from Python
-```
-
-</div>
-
-/// tip | Astuce
-
-Vous pouvez en lire davantage sur [The Twelve-Factor App : Config](https://12factor.net/config).
-
-///
-
-## Gérer les types et la validation { #types-and-validation }
-
-Ces variables d'environnement ne peuvent gérer que des **chaînes de texte**, car elles sont externes à Python et doivent être compatibles avec les autres programmes et le reste du système (et même avec différents systèmes d'exploitation, comme Linux, Windows et macOS).
-
-Cela signifie que **toute valeur** lue en Python à partir d'une variable d'environnement **sera une `str`**, et que toute conversion vers un autre type ou toute validation doit être effectuée dans le code.
-
-Vous en apprendrez davantage sur l'utilisation des variables d'environnement pour gérer les **paramètres d'application** dans le [Guide utilisateur avancé - Paramètres et variables d'environnement](./advanced/settings.md).
-
-## Variable d'environnement `PATH` { #path-environment-variable }
-
-Il existe une variable d'environnement **spéciale** appelée **`PATH`** qui est utilisée par les systèmes d'exploitation (Linux, macOS, Windows) pour trouver les programmes à exécuter.
-
-La valeur de la variable `PATH` est une longue chaîne composée de répertoires séparés par deux-points `:` sous Linux et macOS, et par point-virgule `;` sous Windows.
-
-Par exemple, la variable d'environnement `PATH` peut ressembler à ceci :
-
-//// tab | Linux, macOS
-
-```plaintext
-/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-Cela signifie que le système doit rechercher les programmes dans les répertoires :
-
-* `/usr/local/bin`
-* `/usr/bin`
-* `/bin`
-* `/usr/sbin`
-* `/sbin`
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32
-```
-
-Cela signifie que le système doit rechercher les programmes dans les répertoires :
-
-* `C:\Program Files\Python312\Scripts`
-* `C:\Program Files\Python312`
-* `C:\Windows\System32`
-
-////
-
-Lorsque vous tapez une **commande** dans le terminal, le système d'exploitation **cherche** le programme dans **chacun de ces répertoires** listés dans la variable d'environnement `PATH`.
-
-Par exemple, lorsque vous tapez `python` dans le terminal, le système d'exploitation cherche un programme nommé `python` dans le **premier répertoire** de cette liste.
-
-S'il le trouve, alors il **l'utilise**. Sinon, il continue à chercher dans les **autres répertoires**.
-
-### Installer Python et mettre à jour `PATH` { #installing-python-and-updating-the-path }
-
-Lorsque vous installez Python, il est possible que l'on vous demande si vous souhaitez mettre à jour la variable d'environnement `PATH`.
-
-//// tab | Linux, macOS
-
-Supposons que vous installiez Python et qu'il se retrouve dans un répertoire `/opt/custompython/bin`.
-
-Si vous acceptez de mettre à jour la variable d'environnement `PATH`, l'installateur ajoutera `/opt/custompython/bin` à la variable d'environnement `PATH`.
-
-Cela pourrait ressembler à ceci :
-
-```plaintext
-/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin
-```
-
-Ainsi, lorsque vous tapez `python` dans le terminal, le système trouvera le programme Python dans `/opt/custompython/bin` (le dernier répertoire) et utilisera celui-là.
-
-////
-
-//// tab | Windows
-
-Supposons que vous installiez Python et qu'il se retrouve dans un répertoire `C:\opt\custompython\bin`.
-
-Si vous acceptez de mettre à jour la variable d'environnement `PATH`, l'installateur ajoutera `C:\opt\custompython\bin` à la variable d'environnement `PATH`.
-
-```plaintext
-C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin
-```
-
-Ainsi, lorsque vous tapez `python` dans le terminal, le système trouvera le programme Python dans `C:\opt\custompython\bin` (le dernier répertoire) et utilisera celui-là.
-
-////
-
-Ainsi, si vous tapez :
-
-<div class="termy">
-
-```console
-$ python
-```
-
-</div>
-
-//// tab | Linux, macOS
-
-Le système va **trouver** le programme `python` dans `/opt/custompython/bin` et l'exécuter.
-
-Cela reviendrait à peu près à taper :
-
-<div class="termy">
-
-```console
-$ /opt/custompython/bin/python
-```
-
-</div>
-
-////
-
-//// tab | Windows
-
-Le système va **trouver** le programme `python` dans `C:\opt\custompython\bin\python` et l'exécuter.
-
-Cela reviendrait à peu près à taper :
-
-<div class="termy">
-
-```console
-$ C:\opt\custompython\bin\python
-```
-
-</div>
-
-////
-
-Ces informations vous seront utiles lors de l'apprentissage des [Environnements virtuels](virtual-environments.md).
-
-## Conclusion { #conclusion }
-
-Avec cela, vous devriez avoir une compréhension de base de ce que sont les **variables d'environnement** et de la façon de les utiliser en Python.
-
-Vous pouvez également en lire davantage sur la [page Wikipédia dédiée aux variables d'environnement](https://en.wikipedia.org/wiki/Environment_variable).
-
-Dans de nombreux cas, il n'est pas évident de voir immédiatement en quoi les variables d'environnement seraient utiles et applicables. Mais elles réapparaissent dans de nombreux scénarios lorsque vous développez, il est donc bon de les connaître.
-
-Par exemple, vous aurez besoin de ces informations dans la section suivante, sur les [Environnements virtuels](virtual-environments.md).
+Lisez le [guide des variables d'environnement](https://tiangolo.com/guides/environment-variables/) pour une explication détaillée et multiplateforme, incluant la façon de créer et de lire des variables d'environnement et le fonctionnement de la variable d'environnement `PATH`.
@@ -2,7 +2,7 @@

 **FastAPI <abbr title="command line interface - interface en ligne de commande">CLI</abbr>** est un programme en ligne de commande que vous pouvez utiliser pour servir votre application FastAPI, gérer votre projet FastAPI, et plus encore.

-Lorsque vous installez FastAPI (par exemple avec `pip install "fastapi[standard]"`), il est fourni avec un programme en ligne de commande que vous pouvez exécuter dans le terminal.
+Lorsque vous ajoutez FastAPI à votre projet (par exemple avec `uv add "fastapi[standard]"`), il est fourni avec un programme en ligne de commande que vous pouvez exécuter dans le terminal.

 Pour exécuter votre application FastAPI en développement, vous pouvez utiliser la commande `fastapi dev` :

@@ -52,7 +52,7 @@ Pour la production, utilisez `fastapi run` plutôt que `fastapi dev`. 🚀

 ///

-En interne, **FastAPI CLI** utilise [Uvicorn](https://www.uvicorn.dev), un serveur ASGI haute performance, prêt pour la production. 😎
+En interne, **FastAPI CLI** utilise [Uvicorn](https://uvicorn.dev), un serveur ASGI haute performance, prêt pour la production. 😎

 La CLI `fastapi` tentera de détecter automatiquement l’application FastAPI à exécuter, en supposant qu’il s’agit d’un objet nommé `app` dans un fichier `main.py` (ou quelques autres variantes).

@@ -100,13 +100,13 @@ from backend.main import app
 Vous pouvez également passer le chemin du fichier à la commande `fastapi dev`, et elle devinera l’objet d’application FastAPI à utiliser :

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

 Ou bien, vous pouvez aussi passer l’option `--entrypoint` à la commande `fastapi dev` :

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

 Mais vous devez vous rappeler de passer le bon chemin\entrypoint à chaque fois que vous appelez la commande `fastapi`.
@@ -119,9 +119,13 @@ L’exécution de `fastapi dev` lance le mode développement.

 Par défaut, l’**auto-reload** est activé et recharge automatiquement le serveur lorsque vous modifiez votre code. Cela consomme des ressources et peut être moins stable que lorsqu’il est désactivé. Vous devez l’utiliser uniquement pour le développement. Il écoute aussi sur l’adresse IP `127.0.0.1`, qui est l’adresse IP permettant à votre machine de communiquer uniquement avec elle‑même (`localhost`).

+Avant d’importer votre application, `fastapi dev` définit la variable d’environnement `FASTAPI_ENV` à `development`. Si `FASTAPI_ENV` est déjà définie, sa valeur existante est conservée. Cela permet au code de démarrage de l’application de choisir un comportement adapté au développement tout en vous permettant de fournir un environnement spécifique à l’application, comme `staging`.
+
+Les valeurs conventionnelles de `FASTAPI_ENV` sont `development` et `production`. `fastapi run` laisse actuellement `FASTAPI_ENV` inchangée, donc définissez-la explicitement si votre application doit détecter le mode production.
+
 ## `fastapi run` { #fastapi-run }

-Exécuter `fastapi run` démarre FastAPI en mode production par défaut.
+Exécuter `fastapi run` démarre FastAPI en mode production.

 Par défaut, l’**auto-reload** est désactivé. Il écoute aussi sur l’adresse IP `0.0.0.0`, ce qui signifie toutes les adresses IP disponibles ; de cette manière, il sera accessible publiquement à toute personne pouvant communiquer avec la machine. C’est ainsi que vous l’exécutez normalement en production, par exemple dans un conteneur.

@@ -19,7 +19,7 @@ Documentation d'API interactive et interfaces web d'exploration. Comme le framew

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

-* Documentation d'API alternative avec [**ReDoc**](https://github.com/Rebilly/ReDoc).
+* Documentation d'API alternative avec [**ReDoc**](https://github.com/Redocly/redoc).

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

@@ -159,7 +159,7 @@ Toute intégration est conçue pour être si simple à utiliser (avec des dépen

 ## Fonctionnalités de Starlette { #starlette-features }

-**FastAPI** est entièrement compatible avec (et basé sur) [**Starlette**](https://www.starlette.dev/). Donc, tout code Starlette additionnel que vous avez fonctionnera aussi.
+**FastAPI** est entièrement compatible avec (et basé sur) [**Starlette**](https://starlette.dev/). Donc, tout code Starlette additionnel que vous avez fonctionnera aussi.

 `FastAPI` est en fait une sous-classe de `Starlette`. Ainsi, si vous connaissez ou utilisez déjà Starlette, la plupart des fonctionnalités fonctionneront de la même manière.

@@ -177,9 +177,9 @@ Avec **FastAPI** vous obtenez toutes les fonctionnalités de **Starlette** (puis

 ## Fonctionnalités de Pydantic { #pydantic-features }

-**FastAPI** est entièrement compatible avec (et basé sur) [**Pydantic**](https://docs.pydantic.dev/). Donc, tout code Pydantic additionnel que vous avez fonctionnera aussi.
+**FastAPI** est entièrement compatible avec (et basé sur) [**Pydantic**](https://pydantic.dev/docs/). Donc, tout code Pydantic additionnel que vous avez fonctionnera aussi.

-Y compris des bibliothèques externes également basées sur Pydantic, servant d’<abbr title="Object-Relational Mapper - Mappeur objet-relationnel">ORM</abbr>, d’<abbr title="Object-Document Mapper - Mappeur objet-document">ODM</abbr> pour les bases de données.
+Y compris des bibliothèques externes également basées sur Pydantic, telles que des <abbr title="Object-Relational Mapper - Mappeur objet-relationnel">ORM</abbr> et des <abbr title="Object-Document Mapper - Mappeur objet-document">ODM</abbr> pour les bases de données.

 Cela signifie également que, dans de nombreux cas, vous pouvez passer l'objet que vous recevez d'une requête **directement à la base de données**, puisque tout est validé automatiquement.

@@ -190,7 +190,7 @@ Avec **FastAPI** vous obtenez toutes les fonctionnalités de **Pydantic** (puisq
 * **Pas de prise de tête** :
    * Pas de micro-langage de définition de schéma à apprendre.
    * Si vous connaissez les types Python vous savez utiliser Pydantic.
-* Fonctionne bien avec votre **<abbr title="Integrated Development Environment - Environnement de développement intégré: similaire à un éditeur de code">IDE</abbr>/<dfn title="Programme qui vérifie les erreurs de code">linter</dfn>/cerveau** :
+* Fonctionne bien avec votre **<abbr title="Integrated Development Environment - Environnement de développement intégré : similaire à un éditeur de code">IDE</abbr>/<dfn title="Programme qui vérifie les erreurs de code">linter</dfn>/cerveau** :
    * Parce que les structures de données de Pydantic sont simplement des instances de classes que vous définissez ; l'autocomplétion, le linting, mypy et votre intuition devraient tous bien fonctionner avec vos données validées.
 * Valider des **structures complexes** :
    * Utilisation de modèles Pydantic hiérarchiques, de `List` et `Dict` du `typing` Python, etc.
@@ -46,20 +46,6 @@ Vous pouvez suivre [moi (Sebastián Ramírez / `tiangolo`)](https://tiangolo.com
 * [@tiangolo.com sur **Bluesky**](https://bsky.app/profile/tiangolo.com)
 * [@tiangolo sur **LinkedIn**](https://www.linkedin.com/in/tiangolo/).

-## Aider les autres avec des questions sur GitHub { #help-others-with-questions-in-github }
-
-Vous pouvez essayer d'aider les autres avec leurs questions dans [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered).
-
-Dans de nombreux cas, vous connaissez peut-être déjà la réponse à ces questions. 🤓
-
-Si vous aidez beaucoup de personnes avec leurs questions, vous deviendrez un [Expert FastAPI](fastapi-people.md#fastapi-experts) officiel. 🎉
-
-N'oubliez pas, le point le plus important est : essayez d'être aimable. 🤗
-
-### Comment aider { #how-to-help }
-
-Suivez le [guide sur la manière d'aider](https://tiangolo.com/open-source/help/#help-others-with-questions-in-github) ici.
-
 ## Poser des questions { #ask-questions }

 Vous pouvez [créer une nouvelle question](https://github.com/fastapi/fastapi/discussions/new?category=questions) dans le dépôt GitHub, par exemple pour :
@@ -69,7 +55,7 @@ Vous pouvez [créer une nouvelle question](https://github.com/fastapi/fastapi/di

 ## Rejoindre le chat { #join-the-chat }

-Rejoignez le 👥 [serveur Discord](https://discord.gg/VQjSZaeJmf) 👥 et échangez avec d'autres membres de la communauté FastAPI.
+Rejoignez le 👥 [serveur Discord](https://discord.com/invite/VQjSZaeJmf) 👥 et échangez avec d'autres membres de la communauté FastAPI.

 /// tip | Astuce

@@ -86,3 +72,9 @@ Gardez à l'esprit que, comme les chats permettent une « conversation libre »,
 Sur GitHub, le modèle vous guidera pour rédiger la bonne question afin que vous puissiez plus facilement obtenir une bonne réponse, ou même résoudre le problème vous‑même avant de demander.

 Les conversations dans les systèmes de chat ne sont pas non plus aussi facilement recherchables que sur GitHub, elles se perdent.
+
+## Essayer FastAPI Cloud { #try-fastapi-cloud }
+
+Le financement principal de FastAPI et de ses amis provient de [**FastAPI Cloud**](https://fastapicloud.com), une plateforme pour déployer des applications FastAPI de manière simple et rapide, avec une seule commande, `fastapi deploy`.
+
+FastAPI Cloud est construit par la même équipe derrière FastAPI. Vous pouvez l'essayer et l'envisager pour vos projets.
@@ -54,11 +54,11 @@ Le tout de manière à offrir la meilleure expérience de développement à tous

 ## Exigences { #requirements }

-Après avoir testé plusieurs alternatives, j'ai décidé que j'allais utiliser [**Pydantic**](https://docs.pydantic.dev/) pour ses avantages.
+Après avoir testé plusieurs alternatives, j'ai décidé que j'allais utiliser [**Pydantic**](https://pydantic.dev/docs/) pour ses avantages.

 J'y ai ensuite contribué, pour le rendre entièrement compatible avec JSON Schema, pour supporter différentes manières de définir les déclarations de contraintes, et pour améliorer le support des éditeurs (vérifications de type, autocomplétion) sur la base des tests effectués dans plusieurs éditeurs.

-Pendant le développement, j'ai également contribué à [**Starlette**](https://www.starlette.dev/), l'autre exigence clé.
+Pendant le développement, j'ai également contribué à [**Starlette**](https://starlette.dev/), l'autre exigence clé.

 ## Développement { #development }

@@ -66,7 +66,7 @@ Le `dict` `scope` et la fonction `receive` font tous deux partie de la spécific

 Et ces deux éléments, `scope` et `receive`, sont ce dont on a besoin pour créer une nouvelle instance de `Request`.

-Pour en savoir plus sur `Request`, consultez [les documents de Starlette sur les requêtes](https://www.starlette.dev/requests/).
+Pour en savoir plus sur `Request`, consultez [les documents de Starlette sur les requêtes](https://starlette.dev/requests/).

 ///

@@ -24,7 +24,7 @@ Et cette fonction `get_openapi()` reçoit comme paramètres :
 * `version` : La version de votre API, p. ex. `2.5.0`.
 * `openapi_version` : La version de la spécification OpenAPI utilisée. Par défaut, la plus récente : `3.1.0`.
 * `summary` : Un court résumé de l'API.
-* `description` : La description de votre API ; elle peut inclure du markdown et sera affichée dans la documentation.
+* `description` : La description de votre API ; elle peut inclure du markdown et sera affichée dans les documents.
 * `routes` : Les routes de l'application, extraites de `app.routes`. FastAPI les utilise pour collecter les *chemins d'accès* enregistrés, y compris ceux provenant des routeurs inclus.

 /// tip | Détails techniques
@@ -45,7 +45,7 @@ Le paramètre `summary` est disponible à partir d'OpenAPI 3.1.0, pris en charge

 En vous appuyant sur les informations ci-dessus, vous pouvez utiliser la même fonction utilitaire pour générer le schéma OpenAPI et remplacer chaque partie dont vous avez besoin.

-Par exemple, ajoutons [l’extension OpenAPI de ReDoc pour inclure un logo personnalisé](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo).
+Par exemple, ajoutons [l’extension OpenAPI de ReDoc pour inclure un logo personnalisé](https://github.com/Redocly/redoc/blob/main/docs/redoc-vendor-extensions.md#x-logo).

 ### **FastAPI** normal { #normal-fastapi }

@@ -21,7 +21,7 @@ Voici quelques bibliothèques **GraphQL** qui prennent en charge **ASGI**. Vous
 * [Strawberry](https://strawberry.rocks/) 🍓
    * Avec [les documents pour FastAPI](https://strawberry.rocks/docs/integrations/fastapi)
 * [Ariadne](https://ariadnegraphql.org/)
-    * Avec [les documents pour FastAPI](https://ariadnegraphql.org/docs/fastapi-integration)
+    * Avec [les documents pour FastAPI](https://ariadnegraphql.org/server/Integrations/fastapi-integration)
 * [Tartiflette](https://tartiflette.io/)
    * Avec [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) pour fournir l'intégration ASGI
 * [Graphene](https://graphene-python.org/)
@@ -24,7 +24,7 @@ Si vous avez une ancienne application FastAPI avec Pydantic v1, je vais vous mon

 ## Guide officiel { #official-guide }

-Pydantic propose un [Guide de migration](https://docs.pydantic.dev/latest/migration/) officiel de la v1 à la v2.
+Pydantic propose un [Guide de migration](https://pydantic.dev/docs/validation/latest/get-started/migration/) officiel de la v1 à la v2.

 Il inclut aussi ce qui a changé, comment les validations sont désormais plus correctes et strictes, les pièges possibles, etc.

@@ -110,7 +110,7 @@ Les principales fonctionnalités sont :
  </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">« Nous avons adopté la bibliothèque <strong>FastAPI</strong> pour lancer un serveur <strong>REST</strong> qui peut être interrogé pour obtenir des <strong>prédictions</strong>. » <em>[pour 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>
+    <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> est heureux d’annoncer la publication en open source de notre framework d’orchestration de <strong>gestion de crise</strong> : <strong>Dispatch</strong> ! » <em>[construit avec FastAPI]</em></blockquote>
@@ -133,7 +133,7 @@ Les principales fonctionnalités sont :

 « _Nous avons adopté la bibliothèque **FastAPI** pour lancer un serveur **REST** qui peut être interrogé pour obtenir des **prédictions**. [pour Ludwig]_ »

-<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, et 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, et 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 @@ Les principales fonctionnalités sont :

 </div>

-## FastAPI Conf { #fastapi-conf }
-
-[**FastAPI Conf '26**](https://fastapiconf.com) aura lieu le **28 octobre 2026** à **Amsterdam, NL**. Tout sur FastAPI, à la source. 🎤
-
-<a class="fastapi-feature-banner" href="https://fastapiconf.com"><img src="https://fastapi.tiangolo.com/img/fastapi-conf.jpeg" alt="FastAPI Conf '26 - 28 octobre 2026 - Amsterdam, NL"></a>
-
 ## Mini documentaire FastAPI { #fastapi-mini-documentary }

 Un [mini documentaire FastAPI](https://www.youtube.com/watch?v=mpR8ngthqiE) est sorti fin 2025, vous pouvez le regarder en ligne :
@@ -175,17 +169,17 @@ Si vous construisez une application <abbr title="Command Line Interface - Interf

 FastAPI repose sur les épaules de géants :

-* [Starlette](https://www.starlette.dev/) pour les parties web.
-* [Pydantic](https://docs.pydantic.dev/) pour les parties données.
+* [Starlette](https://starlette.dev/) pour les parties web.
+* [Pydantic](https://pydantic.dev/docs/) pour les parties données.

 ## Installation { #installation }

-Créez et activez un [environnement virtuel](https://fastapi.tiangolo.com/fr/virtual-environments/) puis installez FastAPI :
+Tout d'abord, [installez `uv`](https://docs.astral.sh/uv/getting-started/installation/), puis ajoutez FastAPI à votre projet :

 <div class="termy">

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

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

 **Remarque** : Vous devez vous assurer de mettre `"fastapi[standard]"` entre guillemets pour garantir que cela fonctionne dans tous les terminaux.

+Si vous préférez utiliser `pip`, installez `fastapi[standard]` dans un environnement virtuel. Consultez le [guide d'installation](tutorial/#install-fastapi) pour les étapes alternatives.
+
 ## Exemple { #example }

 ### Créer { #create-it }
@@ -250,7 +246,7 @@ Lancez le serveur avec :
 <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>À propos de la commande <code>fastapi dev</code>...</summary>

-La commande `fastapi dev` lit automatiquement votre fichier `main.py`, détecte l'application **FastAPI** qu'il contient et lance un serveur avec [Uvicorn](https://www.uvicorn.dev).
+La commande `fastapi dev` lit automatiquement votre fichier `main.py`, détecte l'application **FastAPI** qu'il contient et lance un serveur avec [Uvicorn](https://uvicorn.dev).

 Par défaut, `fastapi dev` démarre avec le rechargement automatique activé pour le développement local.

@@ -314,7 +310,7 @@ Vous verrez la documentation interactive automatique de l'API (fournie par [Swag

 Et maintenant, rendez-vous sur [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).

-Vous verrez la documentation alternative automatique (fournie par [ReDoc](https://github.com/Rebilly/ReDoc)) :
+Vous verrez la documentation alternative automatique (fournie par [ReDoc](https://github.com/Redocly/redoc)) :

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

@@ -497,7 +493,7 @@ Vous pouvez, si vous le souhaitez, déployer votre application FastAPI sur [Fast
 <div class="termy">

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

 Deploying to FastAPI Cloud...

@@ -540,7 +536,7 @@ FastAPI dépend de Pydantic et Starlette.

 ### Dépendances `standard` { #standard-dependencies }

-Lorsque vous installez FastAPI avec `pip install "fastapi[standard]"`, il inclut le groupe `standard` de dépendances optionnelles :
+Lorsque vous installez FastAPI avec `uv add "fastapi[standard]"`, il inclut le groupe `standard` de dépendances optionnelles :

 Utilisées par Pydantic :

@@ -554,17 +550,17 @@ Utilisées par Starlette :

 Utilisées par FastAPI :

-* [`uvicorn`](https://www.uvicorn.dev) - pour le serveur qui charge et sert votre application. Cela inclut `uvicorn[standard]`, qui comprend certaines dépendances (par ex. `uvloop`) nécessaires pour une haute performance.
+* [`uvicorn`](https://uvicorn.dev) - pour le serveur qui charge et sert votre application. Cela inclut `uvicorn[standard]`, qui comprend certaines dépendances (par ex. `uvloop`) nécessaires pour une haute performance.
 * `fastapi-cli[standard]` - pour fournir la commande `fastapi`.
    * Cela inclut `fastapi-cloud-cli`, qui vous permet de déployer votre application FastAPI sur [FastAPI Cloud](https://fastapicloud.com).

 ### Sans les dépendances `standard` { #without-standard-dependencies }

-Si vous ne souhaitez pas inclure les dépendances optionnelles `standard`, vous pouvez installer avec `pip install fastapi` au lieu de `pip install "fastapi[standard]"`.
+Si vous ne souhaitez pas inclure les dépendances optionnelles `standard`, vous pouvez installer avec `uv add fastapi` au lieu de `uv add "fastapi[standard]"`.

 ### Sans `fastapi-cloud-cli` { #without-fastapi-cloud-cli }

-Si vous souhaitez installer FastAPI avec les dépendances standard mais sans `fastapi-cloud-cli`, vous pouvez installer avec `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
+Si vous souhaitez installer FastAPI avec les dépendances standard mais sans `fastapi-cloud-cli`, vous pouvez installer avec `uv add "fastapi[standard-no-fastapi-cloud-cli]"`.

 ### Dépendances optionnelles supplémentaires { #additional-optional-dependencies }

@@ -572,13 +568,13 @@ Il existe des dépendances supplémentaires que vous pourriez vouloir installer.

 Dépendances optionnelles supplémentaires pour Pydantic :

-* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) - pour la gestion des paramètres.
-* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) - pour des types supplémentaires à utiliser avec Pydantic.
+* [`pydantic-settings`](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/) - pour la gestion des paramètres.
+* [`pydantic-extra-types`](https://github.com/pydantic/pydantic-extra-types) - pour des types supplémentaires à utiliser avec Pydantic.

 Dépendances optionnelles supplémentaires pour FastAPI :

 * [`orjson`](https://github.com/ijl/orjson) - Obligatoire si vous souhaitez utiliser `ORJSONResponse`.
-* [`ujson`](https://github.com/esnme/ultrajson) - Obligatoire si vous souhaitez utiliser `UJSONResponse`.
+* [`ujson`](https://github.com/ultrajson/ultrajson) - Obligatoire si vous souhaitez utiliser `UJSONResponse`.

 ## Licence { #license }

@@ -5,13 +5,13 @@ Les modèles, bien qu'ils soient généralement livrés avec une configuration s

 Vous pouvez utiliser ce modèle pour démarrer, car il inclut une grande partie de la configuration initiale, la sécurité, la base de données et quelques endpoints d'API déjà prêts pour vous.

-Dépôt GitHub : [Modèle Full Stack FastAPI](https://github.com/tiangolo/full-stack-fastapi-template)
+Dépôt GitHub : [Modèle Full Stack FastAPI](https://github.com/fastapi/full-stack-fastapi-template)

 ## Modèle Full Stack FastAPI - Pile technologique et fonctionnalités { #full-stack-fastapi-template-technology-stack-and-features }

 - ⚡ [**FastAPI**](https://fastapi.tiangolo.com/fr) pour l'API backend Python.
  - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) pour les interactions avec la base de données SQL en Python (ORM).
-  - 🔍 [Pydantic](https://docs.pydantic.dev), utilisé par FastAPI, pour la validation des données et la gestion des paramètres.
+  - 🔍 [Pydantic](https://pydantic.dev/docs/), utilisé par FastAPI, pour la validation des données et la gestion des paramètres.
  - 💾 [PostgreSQL](https://www.postgresql.org) comme base de données SQL.
 - 🚀 [React](https://react.dev) pour le frontend.
  - 💃 Utilisation de TypeScript, des hooks, de Vite et d'autres éléments d'un stack frontend moderne.
@@ -2,7 +2,7 @@

 Python prend en charge des « annotations de type » (aussi appelées « type hints ») facultatives.

-Ces **« annotations de type »** sont une syntaxe spéciale qui permet de déclarer le <dfn title="par exemple : str, int, float, bool">type</dfn> d'une variable.
+Ces **« annotations de type »**, ou annotations, sont une syntaxe spéciale qui permet de déclarer le <dfn title="par exemple : str, int, float, bool">type</dfn> d'une variable.

 En déclarant les types de vos variables, les éditeurs et outils peuvent vous offrir un meilleur support.

@@ -269,7 +269,7 @@ Cela ne signifie pas « `one_person` est la **classe** appelée `Person` ».

 ## Modèles Pydantic { #pydantic-models }

-[Pydantic](https://docs.pydantic.dev/) est une bibliothèque Python pour effectuer de la validation de données.
+[Pydantic](https://pydantic.dev/docs/) est une bibliothèque Python pour effectuer de la validation de données.

 Vous déclarez la « forme » de la donnée sous forme de classes avec des attributs.

@@ -285,7 +285,7 @@ Un exemple tiré des documents officiels de Pydantic :

 /// note | Remarque

-Pour en savoir plus à propos de [Pydantic, consultez ses documents](https://docs.pydantic.dev/).
+Pour en savoir plus à propos de [Pydantic, consultez ses documents](https://pydantic.dev/docs/).

 ///

@@ -23,11 +23,11 @@ Pour commencer, importez `BackgroundTasks` et définissez un paramètre dans vot

 Créez une fonction à exécuter comme tâche d'arrière-plan.

-Une fonction à exécuter comme tâche d'arrière-plan est juste une fonction standard qui peut recevoir des paramètres.
+C'est simplement une fonction standard qui peut recevoir des paramètres.

 Elle peut être une fonction asynchrone (`async def`) ou une fonction normale (`def`), **FastAPI** saura la gérer correctement.

-Dans cet exemple, la fonction de tâche écrira dans un fichier (afin de simuler un envoi d'email).
+Dans ce cas, la fonction de tâche écrira dans un fichier (afin de simuler un envoi d'email).

 L'opération d'écriture n'utilisant ni `async` ni `await`, on définit la fonction avec un `def` normal.

@@ -35,15 +35,15 @@ L'opération d'écriture n'utilisant ni `async` ni `await`, on définit la fonct

 ## Ajouter une tâche d'arrière-plan { #add-the-background-task }

-Dans votre *fonction de chemin d'accès*, passez votre fonction de tâche à l'objet de type `BackgroundTasks` (`background_tasks` ici) grâce à la méthode `.add_task()` :
+Dans votre *fonction de chemin d'accès*, passez votre fonction de tâche à l'objet *tâches d'arrière-plan* avec la méthode `.add_task()` :

 {* ../../docs_src/background_tasks/tutorial001_py310.py hl[14] *}

 `.add_task()` reçoit comme arguments :

 * Une fonction de tâche à exécuter en arrière-plan (`write_notification`).
-* Les arguments positionnels à passer à la fonction de tâche dans l'ordre (`email`).
-* Les arguments nommés à passer à la fonction de tâche (`message="some notification"`).
+* Toute séquence d'arguments à passer à la fonction de tâche dans l'ordre (`email`).
+* Tous les arguments nommés à passer à la fonction de tâche (`message="some notification"`).

 ## Injection de dépendances { #dependency-injection }

@@ -51,34 +51,36 @@ Utiliser `BackgroundTasks` fonctionne aussi avec le système d'injection de dép

 **FastAPI** sait quoi faire dans chaque cas et comment réutiliser le même objet, afin que toutes les tâches d'arrière-plan soient fusionnées et que les tâches soient ensuite exécutées en arrière-plan :

+
 {* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}

-Dans cet exemple, les messages seront écrits dans le fichier `log.txt` après que la réponse soit envoyée.
+
+Dans cet exemple, les messages seront écrits dans le fichier `log.txt` *après* l'envoi de la réponse.

 S'il y avait un paramètre de requête dans la requête, alors il sera écrit dans le journal via une tâche d'arrière-plan.

-Et ensuite une autre tâche d'arrière-plan (générée dans la *fonction de chemin d'accès*) écrira un message comprenant le paramètre de chemin `email`.
+Et ensuite une autre tâche d'arrière-plan (générée dans la *fonction de chemin d'accès*) écrira un message en utilisant le paramètre de chemin `email`.

 ## Détails techniques { #technical-details }

-La classe `BackgroundTasks` provient directement de [`starlette.background`](https://www.starlette.dev/background/).
+La classe `BackgroundTasks` provient directement de [`starlette.background`](https://starlette.dev/background/).

-Elle est importée/incluse directement dans **FastAPI** pour que vous puissiez l'importer depuis `fastapi` et éviter d'importer accidentellement `BackgroundTask` (sans `s` à la fin) depuis `starlette.background`.
+Elle est importée/incluse directement dans FastAPI pour que vous puissiez l'importer depuis `fastapi` et éviter d'importer accidentellement l'alternative `BackgroundTask` (sans `s` à la fin) depuis `starlette.background`.

 En utilisant seulement `BackgroundTasks` (et non `BackgroundTask`), il est possible de l'utiliser en tant que paramètre de *fonction de chemin d'accès* et de laisser **FastAPI** gérer le reste pour vous, comme en utilisant l'objet `Request` directement.

-Il est tout de même possible d'utiliser `BackgroundTask` seul dans **FastAPI**, mais dans ce cas il faut créer l'objet dans le code et renvoyer une `Response` Starlette l'incluant.
+Il est tout de même possible d'utiliser `BackgroundTask` seul dans FastAPI, mais dans ce cas il faut créer l'objet dans le code et renvoyer une `Response` Starlette l'incluant.

-Plus de détails sont disponibles dans [la documentation officielle de Starlette sur les tâches d'arrière-plan](https://www.starlette.dev/background/).
+Plus de détails sont disponibles dans [la documentation officielle de Starlette sur les tâches d'arrière-plan](https://starlette.dev/background/).

 ## Avertissement { #caveat }

-Si vous avez besoin de réaliser des traitements lourds en tâche d'arrière-plan et que vous n'avez pas besoin que ces traitements aient lieu dans le même process (par exemple, pas besoin de partager la mémoire, les variables, etc.), il peut s'avérer profitable d'utiliser des outils plus importants tels que [Celery](https://docs.celeryq.dev).
+Si vous avez besoin de réaliser des calculs lourds en tâche d'arrière-plan et que vous n'avez pas nécessairement besoin que ces calculs aient lieu dans le même process (par exemple, pas besoin de partager la mémoire, les variables, etc.), il peut s'avérer profitable d'utiliser des outils plus importants tels que [Celery](https://docs.celeryq.dev).

-Ces outils nécessitent généralement des configurations plus complexes ainsi qu'un gestionnaire de queue de message, comme RabbitMQ ou Redis, mais ils permettent d'exécuter des tâches d'arrière-plan dans différents process, et surtout, sur plusieurs serveurs.
+Ces outils nécessitent généralement des configurations plus complexes ainsi qu'un gestionnaire de queue de messages/jobs, comme RabbitMQ ou Redis, mais ils permettent d'exécuter des tâches d'arrière-plan dans différents process, et surtout, sur plusieurs serveurs.

 Mais si vous avez besoin d'accéder aux variables et objets de la même application **FastAPI**, ou si vous avez besoin d'effectuer de petites tâches d'arrière-plan (comme envoyer des notifications par email), vous pouvez simplement vous contenter d'utiliser `BackgroundTasks`.

 ## Résumé { #recap }

-Importez et utilisez `BackgroundTasks` grâce aux paramètres de *fonction de chemin d'accès* et les dépendances pour ajouter des tâches d'arrière-plan.
+Importez et utilisez `BackgroundTasks` avec des paramètres dans les *fonctions de chemin d'accès* et les dépendances pour ajouter des tâches d'arrière-plan.
@@ -180,7 +180,7 @@ Le résultat final est que les chemins d'item sont désormais :

 ... comme prévu.

-* Ils seront marqués avec une liste de tags qui contient une seule chaîne « items ».
+* Ils seront marqués avec une liste de tags qui contient une seule chaîne `"items"`.
    * Ces « tags » sont particulièrement utiles pour les systèmes de documentation interactive automatique (utilisant OpenAPI).
 * Ils incluront tous les `responses` prédéfinies.
 * Tous ces *chemins d'accès* auront la liste des `dependencies` évaluées/exécutées avant eux.
@@ -487,7 +487,7 @@ De cette façon, la commande `fastapi` saura où trouver votre app.
 Vous pourriez aussi passer le chemin à la commande, comme :

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

 Mais vous devez vous rappeler de passer le bon chemin à chaque fois que vous appelez la commande `fastapi`.
@@ -503,7 +503,7 @@ Maintenant, exécutez votre application :
 <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)
 ```
@@ -96,7 +96,7 @@ Là encore, avec cette simple déclaration, avec **FastAPI** vous obtenez :

 Outre les types singuliers normaux comme `str`, `int`, `float`, etc. vous pouvez utiliser des types singuliers plus complexes qui héritent de `str`.

-Pour voir toutes les options dont vous disposez, consultez [l’aperçu des types de Pydantic](https://docs.pydantic.dev/latest/concepts/types/). Vous verrez quelques exemples au chapitre suivant.
+Pour voir toutes les options dont vous disposez, consultez [l’aperçu des types de Pydantic](https://pydantic.dev/docs/validation/latest/concepts/types/). Vous verrez quelques exemples au chapitre suivant.

 Par exemple, comme dans le modèle `Image` nous avons un champ `url`, nous pouvons le déclarer comme instance de `HttpUrl` de Pydantic au lieu de `str` :

@@ -6,7 +6,7 @@ Le corps d'une **requête** est de la donnée envoyée par le client à votre AP

 Votre API aura presque toujours à envoyer un corps de **réponse**. Mais un client n'a pas toujours à envoyer un **corps de la requête** : parfois il demande seulement un chemin, peut-être avec quelques paramètres de requête, mais n'envoie pas de corps.

-Pour déclarer un corps de **requête**, on utilise les modèles de [Pydantic](https://docs.pydantic.dev/) en profitant de tous leurs avantages et fonctionnalités.
+Pour déclarer un corps de **requête**, on utilise les modèles de [Pydantic](https://pydantic.dev/docs/) avec toute leur puissance et leurs avantages.

 /// note | Remarque

@@ -14,7 +14,7 @@ Pour envoyer de la donnée, vous devez utiliser l'une de ces méthodes : `POST`

 Envoyer un corps dans une requête `GET` a un comportement non défini dans les spécifications, cela est néanmoins supporté par FastAPI, seulement pour des cas d'utilisation très complexes/extrêmes.

-Ceci étant découragé, la documentation interactive générée par Swagger UI ne montrera pas de documentation pour le corps d'une requête `GET`, et les proxys intermédiaires risquent de ne pas le supporter.
+Ceci étant découragé, la documentation interactive avec Swagger UI ne montrera pas de documentation pour le corps d'une requête `GET`, et les proxys intermédiaires risquent de ne pas le supporter.

 ///

@@ -67,7 +67,7 @@ Pour l'ajouter à votre *chemin d'accès*, déclarez-le comme vous déclareriez

 En utilisant uniquement les déclarations de type Python, **FastAPI** réussit à :

-* Lire le contenu de la requête en tant que JSON.
+* Lire le corps de la requête en tant que JSON.
 * Convertir les types correspondants (si nécessaire).
 * Valider la donnée.
    * Si la donnée est invalide, une erreur propre et claire sera renvoyée, indiquant exactement où et quelle était la donnée incorrecte.
@@ -163,4 +163,4 @@ Mais ajouter ces annotations de type permettra à votre éditeur de vous offrir

 ## Sans Pydantic { #without-pydantic }

-Si vous ne voulez pas utiliser des modèles Pydantic, vous pouvez aussi utiliser des paramètres de **Body**. Pour cela, allez voir la documentation sur [Corps de la requête - Paramètres multiples : Valeurs singulières dans le corps](body-multiple-params.md#singular-values-in-body).
+Si vous ne voulez pas utiliser des modèles Pydantic, vous pouvez aussi utiliser des paramètres de **Body**. Consultez les documents pour [Corps de la requête - Paramètres multiples : Valeurs singulières dans le corps](body-multiple-params.md#singular-values-in-body).
@@ -15,7 +15,7 @@ Le but principal de `__name__ == "__main__"` est d'avoir du code qui est exécut
 <div class="termy">

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

 </div>
@@ -35,7 +35,7 @@ Si vous l'exécutez avec :
 <div class="termy">

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

 </div>
@@ -54,7 +54,7 @@ va s'exécuter.

 Cela ne se produira pas si vous importez ce module (fichier).

-Par exemple, si vous avez un autre fichier `importer.py` qui contient :
+Donc, si vous avez un autre fichier `importer.py` avec :

 ```Python
 from myapp import app
@@ -88,7 +88,7 @@ Par exemple, dans Visual Studio Code, vous pouvez :

 * Allez dans le panneau « Debug ».
 * « Add configuration... ».
-* Sélectionnez « Python ».
+* Sélectionnez « Python »
 * Lancez le <abbr title="En anglais: debugger">débogueur</abbr> avec l'option « `Python: Current File (Integrated Terminal)` ».

 Il démarrera alors le serveur avec votre code **FastAPI**, s'arrêtera à vos points d'arrêt, etc.
@@ -36,7 +36,7 @@ Voici quelques types de données supplémentaires que vous pouvez utiliser :
 * `datetime.timedelta` :
    * Un `datetime.timedelta` Python.
    * Dans les requêtes et les réponses, il sera représenté sous forme de `float` de secondes totales.
-    * Pydantic permet aussi de le représenter sous la forme d'un « encodage de différence de temps ISO 8601 », [voir les documents pour plus d'informations](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
+    * Pydantic permet aussi de le représenter sous la forme d'un « encodage de différence de temps ISO 8601 », [voir les documents pour plus d'informations](https://pydantic.dev/docs/validation/latest/concepts/serialization/#custom-serializers).
 * `frozenset` :
    * Dans les requêtes et les réponses, traité de la même manière qu'un `set` :
        * Dans les requêtes, une liste sera lue, les doublons éliminés, puis convertie en `set`.
@@ -49,7 +49,7 @@ Voici quelques types de données supplémentaires que vous pouvez utiliser :
 * `Decimal` :
    * `Decimal` Python standard.
    * Dans les requêtes et les réponses, géré de la même manière qu'un `float`.
-* Vous pouvez consulter tous les types de données Pydantic valides ici : [Types de données Pydantic](https://docs.pydantic.dev/latest/usage/types/types/).
+* Vous pouvez consulter tous les types de données Pydantic valides ici : [Types de données Pydantic](https://pydantic.dev/docs/validation/latest/concepts/types/).

 ## Exemple { #example }

@@ -166,7 +166,7 @@ Pour ce faire, utilisez l'annotation de type Python standard [`typing.Union`](ht

 /// note | Remarque

-Lors de la définition d'une [`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions), incluez d'abord le type le plus spécifique, suivi du type le moins spécifique. Dans l'exemple ci-dessous, le type le plus spécifique `PlaneItem` précède `CarItem` dans `Union[PlaneItem, CarItem]`.
+Lors de la définition d'une [`Union`](https://pydantic.dev/docs/validation/latest/concepts/unions/), incluez d'abord le type le plus spécifique, suivi du type le moins spécifique. Dans l'exemple ci-dessous, le type le plus spécifique `PlaneItem` précède `CarItem` dans `Union[PlaneItem, CarItem]`.

 ///

@@ -6,12 +6,18 @@ Le fichier **FastAPI** le plus simple possible pourrait ressembler à ceci :

 Copiez cela dans un fichier `main.py`.

+/// tip | Astuce
+
+FastAPI a une [extension officielle pour VS Code](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (et Cursor), qui fournit de nombreuses fonctionnalités, notamment un explorateur de chemins d’accès, la recherche de chemins d’accès, la navigation CodeLens dans les tests (aller à la définition depuis les tests), ainsi que le déploiement et les logs FastAPI Cloud, le tout depuis votre éditeur.
+
+///
+
 Démarrez le serveur en direct :

 <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 @@ Vous verrez la documentation interactive de l’API générée automatiquement (

 Et maintenant, allez sur [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).

-Vous verrez la documentation automatique alternative (fournie par [ReDoc](https://github.com/Rebilly/ReDoc)) :
+Vous verrez la documentation automatique alternative (fournie par [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
 Vous pouvez également passer le chemin du fichier à la commande `fastapi dev`, et elle devinera l’objet d’application FastAPI à utiliser :

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

 Ou bien, vous pouvez aussi passer l’option `--entrypoint` à la commande `fastapi dev` :

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

 Mais vous devez vous souvenir de passer le chemin\entrypoint correct à chaque exécution de la commande `fastapi`.
@@ -205,7 +211,7 @@ Vous pouvez éventuellement déployer votre application FastAPI sur [FastAPI Clo
 <div class="termy">

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

 Deploying to FastAPI Cloud...

@@ -232,7 +238,7 @@ C’est tout ! Vous pouvez maintenant accéder à votre application à cette URL

 `FastAPI` est une classe qui hérite directement de `Starlette`.

-Vous pouvez donc aussi utiliser toutes les fonctionnalités de [Starlette](https://www.starlette.dev/) avec `FastAPI`.
+Vous pouvez donc aussi utiliser toutes les fonctionnalités de [Starlette](https://starlette.dev/) avec `FastAPI`.

 ///

@@ -52,7 +52,7 @@ Pour cela, utilisez `fallback="index.html"` :

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

-**FastAPI** utilise ce fallback uniquement pour les requêtes `GET` et `HEAD` qui ressemblent à une navigation de navigateur. Les fichiers manquants comme JavaScript, CSS et les images renvoient toujours `404`.
+**FastAPI** utilise ce fallback uniquement pour les requêtes `GET` et `HEAD` qui acceptent explicitement HTML avec `Accept: text/html` ou `Accept: application/xhtml+xml`, comme le font normalement les requêtes de navigation de navigateur. Les fichiers manquants comme JavaScript, CSS et les images renvoient toujours `404`.

 Les requêtes avec d'autres méthodes, comme `POST` ou `PUT`, vers des chemins qui ne correspondent qu'au fallback frontend renvoient également `404`. Les *chemins d'accès* **FastAPI** réguliers ont toujours une priorité plus élevée que les routes frontend.

@@ -106,15 +106,19 @@ Les chemins frontend manquants renvoient alors le `404` normal.

 ## Vérifier le répertoire { #check-directory }

-Par défaut, `app.frontend()` vérifie que le répertoire existe lorsque l'application est créée.
+Par défaut, `app.frontend()` utilise `check_dir="auto"`.

-Cela permet de détecter tôt les erreurs de configuration. Par exemple, si le répertoire de sortie du build frontend est manquant, **FastAPI** lèvera une erreur au démarrage.
+Lorsque la variable d'environnement `FASTAPI_ENV` est définie sur `development`, **FastAPI** affiche seulement un avertissement si le répertoire de sortie du build frontend est manquant. La [commande `fastapi dev`](https://github.com/fastapi/fastapi-cli#fastapi-dev) définit cette variable d'environnement pour vous si elle n'est pas déjà définie. Cela vous permet de démarrer le backend avant de build ou de démarrer le frontend pendant le développement.
+
+Dans tout autre environnement, **FastAPI** lève une erreur lorsque l'application est créée. Cela aide à détecter tôt les erreurs de configuration avant de déployer une application sans ses fichiers frontend.
+
+Vous pouvez également définir `check_dir=True` pour toujours vérifier le répertoire lorsque l'application est créée.

 Si vos fichiers frontend sont créés plus tard, par exemple par une étape de build séparée après la création de l'objet app, définissez `check_dir=False` :

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

-Avec `check_dir=False`, **FastAPI** ne vérifiera pas le répertoire lorsque l'application est créée. Si le répertoire configuré est toujours manquant lorsqu'une requête est traitée, **FastAPI** lèvera alors une erreur.
+Avec `check_dir=False`, **FastAPI** ne vérifie pas le répertoire lorsque l'application est créée. Si le répertoire configuré est toujours manquant lorsqu'une requête est traitée, **FastAPI** lèvera alors une erreur.

 ## L'utiliser avec `APIRouter` { #use-it-with-apirouter }

@@ -132,6 +136,8 @@ Les réponses frontend s'exécutent au sein de l'application **FastAPI** normale

 Les dépendances de l'application, d'un `APIRouter` et de `include_router()` s'appliquent également aux réponses frontend. Cela peut être utile pour protéger un frontend avec une authentification par cookie ou similaire.

+Les dépendances peuvent également modifier les headers de réponse et ajouter des tâches d'arrière-plan, comme avec les *chemins d'accès* normaux.
+
 ## Sortie de build statique uniquement { #static-build-output-only }

 `app.frontend()` sert des fichiers déjà générés par votre build frontend.
@@ -33,7 +33,7 @@ Pour renvoyer au client des réponses HTTP avec des erreurs, vous utilisez `HTTP

 Comme il s'agit d'une exception Python, vous ne la `return` pas, vous la `raise`.

-Cela signifie aussi que si vous êtes dans une fonction utilitaire appelée depuis votre fonction de chemin d'accès, et que vous levez la `HTTPException` à l'intérieur de cette fonction utilitaire, le reste du code de la fonction de chemin d'accès ne s'exécutera pas : la requête sera immédiatement interrompue et l'erreur HTTP issue de la `HTTPException` sera envoyée au client.
+Cela signifie aussi que si vous êtes dans une fonction utilitaire appelée depuis votre *fonction de chemin d'accès*, et que vous levez la `HTTPException` à l'intérieur de cette fonction utilitaire, le reste du code de la *fonction de chemin d'accès* ne s'exécutera pas : la requête sera immédiatement interrompue et l'erreur HTTP issue de la `HTTPException` sera envoyée au client.

 L'avantage de lever une exception plutôt que de retourner une valeur apparaîtra plus clairement dans la section sur les Dépendances et la Sécurité.

@@ -81,7 +81,7 @@ Mais si vous en aviez besoin pour un scénario avancé, vous pouvez ajouter des

 ## Installer des gestionnaires d'exception personnalisés { #install-custom-exception-handlers }

-Vous pouvez ajouter des gestionnaires d'exception personnalisés avec [les mêmes utilitaires d'exception de Starlette](https://www.starlette.dev/exceptions/).
+Vous pouvez ajouter des gestionnaires d'exception personnalisés avec [les mêmes utilitaires d'exception de Starlette](https://starlette.dev/exceptions/).

 Supposons que vous ayez une exception personnalisée `UnicornException` que vous (ou une bibliothèque que vous utilisez) pourriez `raise`.

@@ -91,7 +91,7 @@ Vous pouvez ajouter un gestionnaire d'exception personnalisé avec `@app.excepti

 {* ../../docs_src/handling_errors/tutorial003_py310.py hl[5:7,13:18,24] *}

-Ici, si vous appelez `/unicorns/yolo`, le chemin d'accès va `raise` une `UnicornException`.
+Ici, si vous appelez `/unicorns/yolo`, le *chemin d'accès* va `raise` une `UnicornException`.

 Mais elle sera gérée par `unicorn_exception_handler`.

@@ -11,12 +11,12 @@ Il est également conçu pour servir de référence ultérieure, afin que vous p

 Tous les blocs de code peuvent être copiés et utilisés directement (il s'agit en fait de fichiers Python testés).

-Pour exécuter l'un de ces exemples, copiez le code dans un fichier `main.py`, et démarrez `fastapi dev` :
+Pour exécuter l'un de ces exemples, copiez le code dans un fichier `main.py`, et démarrez `fastapi dev` avec `uv run` :

 <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 +61,75 @@ L'utiliser dans votre éditeur est ce qui vous montre vraiment les avantages de

 ## Installer FastAPI { #install-fastapi }

-La première étape consiste à installer FastAPI.
+La première étape consiste à configurer votre projet et à ajouter FastAPI.

-Assurez-vous de créer un [environnement virtuel](../virtual-environments.md), de l'activer, puis **d'installer FastAPI** :
+Installez [`uv`](https://docs.astral.sh/uv/getting-started/installation/), puis créez un projet et ajoutez 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` crée l'environnement virtuel du projet dans `.venv`, ajoute FastAPI à `pyproject.toml`, et crée `uv.lock` afin que les mêmes versions de packages puissent être installées plus tard.
+
+/// details | Ce que font ces commandes
+
+* `uv init` : crée un nouveau projet Python.
+* `awesome-project` : crée le projet dans un nouveau répertoire portant ce nom.
+* `--bare` : crée uniquement le fichier `pyproject.toml` minimal, sans générer d'exemple `main.py`, `README.md` ou d'autres fichiers. Vous créerez vous-même les fichiers de l'application dans les prochaines étapes de ce tutoriel.
+
+Ensuite, `cd awesome-project` entre dans le nouveau répertoire du projet avant d'ajouter FastAPI.
+
+`uv` utilisera une version compatible de Python déjà installée sur votre système, ou en téléchargera une si nécessaire.
+
+Lorsque vous exécutez `uv add`, il sélectionne des versions compatibles de FastAPI et de tous les packages dont FastAPI dépend. Il enregistre les versions exactes dans `uv.lock`, ce qui permet d'installer les mêmes versions de packages plus tard sur un autre ordinateur ou lors du déploiement de l'application.
+
+La création ou la mise à jour de ce fichier est appelée [**verrouillage** des dépendances du projet](https://docs.astral.sh/uv/concepts/projects/sync/). `uv` le fait automatiquement lorsque vous ajoutez un package.
+
+///
+
+/// details | Options d'installation de FastAPI
+
+Lorsque vous installez avec `uv add "fastapi[standard]"`, cela inclut des dépendances standards optionnelles par défaut, y compris `fastapi-cloud-cli`, qui vous permet de déployer sur [FastAPI Cloud](https://fastapicloud.com).
+
+Si vous ne souhaitez pas avoir ces dépendances optionnelles, vous pouvez à la place installer `uv add fastapi`.
+
+Si vous souhaitez installer les dépendances standard mais sans `fastapi-cloud-cli`, vous pouvez installer avec `uv add "fastapi[standard-no-fastapi-cloud-cli]"`.
+
+///
+
+/// details | Utiliser `pip` à la place
+
+Si vous préférez gérer manuellement un environnement virtuel et les packages, créez et activez un environnement virtuel, puis installez FastAPI avec `pip install "fastapi[standard]"`.
+
+Lisez le [guide sur les environnements virtuels](https://tiangolo.com/guides/virtual-environments/) pour les étapes détaillées.
+
+///
+
+## Skills des agents IA { #ai-agent-skills }
+
+FastAPI inclut une skill officielle pour les agents de codage IA. Elle est fournie avec le package, donc ses indications restent alignées avec la version de FastAPI installée dans votre projet et se mettent à jour lorsque vous mettez à niveau FastAPI.
+
+Après avoir installé FastAPI dans votre projet, vous pouvez installer la skill avec <a href="https://library-skills.io">Library Skills</a> :
+
+```bash
+uvx library-skills
+```
+
 /// note | Remarque

-Lorsque vous installez avec `pip install "fastapi[standard]"`, cela inclut des dépendances standards optionnelles par défaut, y compris `fastapi-cloud-cli`, qui vous permet de déployer sur [FastAPI Cloud](https://fastapicloud.com).
-
-Si vous ne souhaitez pas avoir ces dépendances optionnelles, vous pouvez à la place installer `pip install fastapi`.
-
-Si vous souhaitez installer les dépendances standard mais sans `fastapi-cloud-cli`, vous pouvez installer avec `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
+`uvx` est un alias pour `uv tool run`. Il exécute Library Skills dans un environnement temporaire et isolé pendant que Library Skills analyse les packages installés dans votre projet.

 ///

-/// tip | Astuce
-
-FastAPI dispose d'une [extension officielle pour VS Code](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (et Cursor), qui fournit de nombreuses fonctionnalités, notamment un explorateur de chemins d'accès, une recherche de chemins d'accès, la navigation CodeLens dans les tests (aller à la définition depuis les tests), ainsi que le déploiement et les journaux FastAPI Cloud, le tout depuis votre éditeur.
-
-///
+La skill est compatible avec Codex, Claude Code, Cursor, GitHub Copilot, Gemini CLI, Pi, OpenCode, et la plupart des autres agents de codage. Pour Claude Code, sélectionnez `.claude/skills` lorsqu'il vous est demandé où installer la skill.

 ## Guide d'utilisation avancé { #advanced-user-guide }

@@ -37,7 +37,7 @@ La fonction de middleware reçoit :

 Gardez à l’esprit que des en-têtes propriétaires personnalisés peuvent être ajoutés [en utilisant le préfixe `X-`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).

-Mais si vous avez des en-têtes personnalisés que vous voulez rendre visibles pour un client dans un navigateur, vous devez les ajouter à votre configuration CORS ([CORS (Partage des ressources entre origines)](cors.md)) en utilisant le paramètre `expose_headers` documenté dans [la documentation CORS de Starlette](https://www.starlette.dev/middleware/#corsmiddleware).
+Mais si vous avez des en-têtes personnalisés que vous voulez rendre visibles pour un client dans un navigateur, vous devez les ajouter à votre configuration CORS ([CORS (Partage des ressources entre origines)](cors.md)) en utilisant le paramètre `expose_headers` documenté dans [la documentation CORS de Starlette](https://starlette.dev/middleware/#corsmiddleware).

 ///

@@ -67,9 +67,9 @@ Ici, nous utilisons [`time.perf_counter()`](https://docs.python.org/3/library/ti

 ## Ordre d’exécution de plusieurs middlewares { #multiple-middleware-execution-order }

-Quand vous ajoutez plusieurs middlewares en utilisant soit le décorateur `@app.middleware()`, soit la méthode `app.add_middleware()`, chaque nouveau middleware enveloppe l’application, formant une pile. Le dernier middleware ajouté est le plus externe, et le premier est le plus interne.
+Quand vous ajoutez plusieurs middlewares en utilisant soit le décorateur `@app.middleware()`, soit la méthode `app.add_middleware()`, chaque nouveau middleware enveloppe l’application, formant une pile. Le dernier middleware ajouté est le *plus externe*, et le premier est le *plus interne*.

-Sur le chemin de la requête, le plus externe s’exécute en premier.
+Sur le chemin de la requête, le *plus externe* s’exécute en premier.

 Sur le chemin de la réponse, il s’exécute en dernier.

@@ -90,6 +90,6 @@ Ce comportement d’empilement garantit que les middlewares s’exécutent dans

 ## Autres middlewares { #other-middlewares }

-Vous pouvez en lire davantage sur d’autres middlewares dans le [Guide de l’utilisateur avancé : Middleware avancé](../advanced/middleware.md).
+Vous pouvez plus tard en lire davantage sur d’autres middlewares dans le [Guide de l’utilisateur avancé : Middleware avancé](../advanced/middleware.md).

 Vous verrez comment gérer <abbr title="Cross-Origin Resource Sharing - Partage des ressources entre origines">CORS</abbr> avec un middleware dans la section suivante.
@@ -36,7 +36,7 @@ Si vous exécutez cet exemple et ouvrez votre navigateur sur [http://127.0.0.1:8

 /// tip | Astuce

-Remarquez que la valeur reçue par votre fonction (et renvoyée) est `3`, en tant qu'entier (`int`) Python, pas la chaîne de caractères « 3 ».
+Remarquez que la valeur reçue par votre fonction (et renvoyée) est `3`, en tant qu'entier (`int`) Python, pas une chaîne de caractères `"3"`.

 Ainsi, avec cette déclaration de type, **FastAPI** vous fournit automatiquement le <dfn title="conversion de la chaîne de caractères provenant d'une requête HTTP en données Python">« parsing »</dfn> de la requête.

@@ -62,7 +62,7 @@ Mais si vous allez dans le navigateur sur [http://127.0.0.1:8000/items/foo](http
 }
 ```

-car le paramètre de chemin `item_id` a pour valeur « foo », qui n'est pas un `int`.
+car le paramètre de chemin `item_id` a pour valeur `"foo"`, qui n'est pas un `int`.

 La même erreur apparaîtrait si vous fournissiez un `float` au lieu d'un `int`, comme ici : [http://127.0.0.1:8000/items/4.2](http://127.0.0.1:8000/items/4.2)

@@ -92,7 +92,7 @@ Remarquez que le paramètre de chemin est déclaré comme entier.

 ## Les avantages d'une norme, documentation alternative { #standards-based-benefits-alternative-documentation }

-Et comme le schéma généré suit la norme [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md), il existe de nombreux outils compatibles.
+Et comme le schéma généré suit la norme [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md), il existe de nombreux outils compatibles.

 Grâce à cela, **FastAPI** fournit lui-même une documentation d'API alternative (utilisant ReDoc), accessible sur [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) :

@@ -102,7 +102,7 @@ De la même façon, il existe de nombreux outils compatibles, y compris des outi

 ## Pydantic { #pydantic }

-Toute la validation de données est effectuée sous le capot par [Pydantic](https://docs.pydantic.dev/), vous en bénéficiez donc pleinement. Vous savez ainsi que vous êtes entre de bonnes mains.
+Toute la validation de données est effectuée sous le capot par [Pydantic](https://pydantic.dev/docs/), vous en bénéficiez donc pleinement. Vous savez ainsi que vous êtes entre de bonnes mains.

 Vous pouvez utiliser les mêmes déclarations de type avec `str`, `float`, `bool` et de nombreux autres types de données complexes.

@@ -120,7 +120,7 @@ Comme les *chemins d'accès* sont évalués dans l'ordre, vous devez vous assure

 {* ../../docs_src/path_params/tutorial003_py310.py hl[6,11] *}

-Sinon, le chemin `/users/{user_id}` correspondrait aussi à `/users/me`, « pensant » qu'il reçoit un paramètre `user_id` avec la valeur « me ».
+Sinon, le chemin `/users/{user_id}` correspondrait aussi à `/users/me`, « pensant » qu'il reçoit un paramètre `user_id` avec la valeur `"me"`.

 De même, vous ne pouvez pas redéfinir un chemin d'accès :

@@ -154,7 +154,7 @@ Créez ensuite un *paramètre de chemin* avec une annotation de type utilisant l

 {* ../../docs_src/path_params/tutorial005_py310.py hl[16] *}

-### Consulter la documentation { #check-the-docs }
+### Consultez les documents { #check-the-docs }

 Comme les valeurs disponibles pour le *paramètre de chemin* sont prédéfinies, la documentation interactive peut les afficher clairement :

@@ -178,7 +178,7 @@ Vous pouvez obtenir la valeur réelle (une `str` dans ce cas) avec `model_name.v

 /// tip | Astuce

-Vous pouvez aussi accéder à la valeur « lenet » avec `ModelName.lenet.value`.
+Vous pouvez aussi accéder à la valeur `"lenet"` avec `ModelName.lenet.value`.

 ///

@@ -205,7 +205,7 @@ Disons que vous avez un *chemin d'accès* avec un chemin `/files/{file_path}`.

 Mais vous avez besoin que `file_path` lui-même contienne un *chemin*, comme `home/johndoe/myfile.txt`.

-Ainsi, l'URL pour ce fichier serait : `/files/home/johndoe/myfile.txt`.
+Ainsi, l'URL pour ce fichier serait quelque chose comme : `/files/home/johndoe/myfile.txt`.

 ### Support d'OpenAPI { #openapi-support }

@@ -244,7 +244,7 @@ Avec **FastAPI**, en utilisant des déclarations de type Python courtes, intuiti
 * Support de l'éditeur : vérifications d'erreurs, autocomplétion, etc.
 * Données « <dfn title="conversion de la chaîne de caractères provenant d'une requête HTTP en données Python">parsing</dfn> »
 * Validation de données
-* Annotations d'API et documentation automatique
+* Annotation d'API et documentation automatique

 Et vous n'avez besoin de les déclarer qu'une seule fois.

@@ -133,7 +133,7 @@ Par exemple, ceci n’est pas autorisé :
 q: Annotated[str, Query(default="rick")] = "morty"
 ```

-... parce qu’il n’est pas clair si la valeur par défaut doit être « rick » ou « morty ».
+... parce qu’il n’est pas clair si la valeur par défaut doit être `"rick"` ou `"morty"`.

 Donc, vous utiliseriez (de préférence) :

@@ -185,7 +185,7 @@ Désormais, vous savez que, lorsque vous en aurez besoin, vous pourrez les utili

 Vous pouvez, bien sûr, utiliser des valeurs par défaut autres que `None`.

-Disons que vous voulez déclarer le paramètre de requête `q` avec un `min_length` de `3`, et avec une valeur par défaut de « fixedquery » :
+Disons que vous voulez déclarer le paramètre de requête `q` avec un `min_length` de `3`, et avec une valeur par défaut de `"fixedquery"` :

 {* ../../docs_src/query_params_str_validations/tutorial005_an_py310.py hl[9] *}

@@ -369,15 +369,15 @@ Il peut y avoir des cas où vous devez faire une **validation personnalisée** q

 Dans ces cas, vous pouvez utiliser une **fonction de validation personnalisée** qui est appliquée après la validation normale (par ex. après avoir validé que la valeur est une `str`).

-Vous pouvez y parvenir en utilisant [`AfterValidator` de Pydantic](https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator) à l’intérieur de `Annotated`.
+Vous pouvez y parvenir en utilisant [`AfterValidator` de Pydantic](https://pydantic.dev/docs/validation/latest/concepts/validators/#field-after-validator) à l’intérieur de `Annotated`.

 /// tip | Astuce

-Pydantic a aussi [`BeforeValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator) et d’autres. 🤓
+Pydantic a aussi [`BeforeValidator`](https://pydantic.dev/docs/validation/latest/concepts/validators/#field-before-validator) et d’autres. 🤓

 ///

-Par exemple, ce validateur personnalisé vérifie que l’ID d’item commence par `isbn-` pour un numéro de livre <abbr title="International Standard Book Number - Numéro international normalisé du livre">ISBN</abbr> ou par `imdb-` pour un ID d’URL de film <abbr title="Internet Movie Database - Base de données de films sur Internet: un site web contenant des informations sur les films">IMDB</abbr> :
+Par exemple, ce validateur personnalisé vérifie que l’ID d’item commence par `isbn-` pour un numéro de livre <abbr title="International Standard Book Number - Numéro international normalisé du livre">ISBN</abbr> ou par `imdb-` pour un ID d’URL de film <abbr title="Internet Movie Database - Base de données de films sur Internet : un site web contenant des informations sur les films">IMDB</abbr> :

 {* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}

@@ -7,10 +7,10 @@ Vous pouvez définir des fichiers à téléverser par le client en utilisant `Fi

 Pour recevoir des fichiers téléversés, installez d'abord [`python-multipart`](https://github.com/Kludex/python-multipart).

-Assurez-vous de créer un [environnement virtuel](../virtual-environments.md), de l'activer, puis d'installer le paquet, par exemple :
+Ajoutez-le à votre projet :

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

 C'est parce que les fichiers téléversés sont envoyés en « données de formulaire ».
@@ -174,4 +174,4 @@ Et de la même manière que précédemment, vous pouvez utiliser `File()` pour d

 ## Récapitulatif { #recap }

-Utilisez `File`, `bytes` et `UploadFile` pour déclarer des fichiers à téléverser dans la requête, envoyés en « données de formulaire ».
+Utilisez `File`, `bytes` et `UploadFile` pour déclarer des fichiers à téléverser dans la requête, envoyés en données de formulaire.
@@ -6,10 +6,10 @@ Vous pouvez utiliser des **modèles Pydantic** pour déclarer des **champs de fo

 Pour utiliser les formulaires, installez d'abord [`python-multipart`](https://github.com/Kludex/python-multipart).

-Assurez-vous de créer un [environnement virtuel](../virtual-environments.md), de l'activer, puis d'installer le paquet, par exemple :
+Ajoutez-le à votre projet :

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

 ///
@@ -38,7 +38,7 @@ Vous pouvez le vérifier dans l'interface des documents à `/docs` :

 ## Interdire les champs de formulaire supplémentaires { #forbid-extra-form-fields }

-Dans certains cas d'utilisation particuliers (probablement peu courants), vous pourriez vouloir **restreindre** les champs de formulaire à ceux déclarés dans le modèle Pydantic, et **interdire** tout champ **supplémentaire**.
+Dans certains cas d'utilisation particuliers (probablement peu courants), vous pourriez vouloir **restreindre** les champs de formulaire à ceux déclarés dans le modèle Pydantic. Et **interdire** tout champ **supplémentaire**.

 /// note | Remarque

@@ -6,10 +6,10 @@ Vous pouvez définir des fichiers et des champs de formulaire en même temps à

 Pour recevoir des fichiers téléversés et/ou des données de formulaire, installez d'abord [`python-multipart`](https://github.com/Kludex/python-multipart).

-Vous devez créer un [environnement virtuel](../virtual-environments.md), l'activer, puis installer ce paquet, par exemple :
+Ajoutez-le à votre projet :

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

 ///
@@ -24,7 +24,7 @@ Créez des paramètres de fichier et de formulaire de la même manière que pour

 {* ../../docs_src/request_forms_and_files/tutorial001_an_py310.py hl[10:12] *}

-Les fichiers et les champs de formulaire seront téléversés en tant que données de formulaire et vous les recevrez.
+Les fichiers et les champs de formulaire seront téléversés en tant que données de formulaire et vous recevrez les fichiers et les champs de formulaire.

 Et vous pouvez déclarer certains fichiers comme `bytes` et d'autres comme `UploadFile`.

@@ -6,10 +6,10 @@ Lorsque vous devez recevoir des champs de formulaire au lieu de JSON, vous pouve

 Pour utiliser les formulaires, installez d'abord [`python-multipart`](https://github.com/Kludex/python-multipart).

-Vous devez créer un [environnement virtuel](../virtual-environments.md), l'activer, puis installer le paquet, par exemple :
+Ajoutez-le à votre projet :

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

 ///
@@ -76,16 +76,16 @@ Ici, nous déclarons un modèle `UserIn`, il contiendra un mot de passe en clair

 Pour utiliser `EmailStr`, installez d'abord [`email-validator`](https://github.com/JoshData/python-email-validator).

-Assurez-vous de créer un [environnement virtuel](../virtual-environments.md), de l'activer, puis de l'installer, par exemple :
+Ajoutez-le à votre projet :

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

 ou avec :

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

 ///
@@ -258,7 +258,7 @@ Vous pouvez également utiliser :
 * `response_model_exclude_defaults=True`
 * `response_model_exclude_none=True`

-comme décrit dans [la documentation Pydantic](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict) pour `exclude_defaults` et `exclude_none`.
+comme décrit dans [les documents Pydantic](https://pydantic.dev/docs/validation/latest/concepts/serialization/#excluding-and-including-fields-based-on-their-value) pour `exclude_defaults` et `exclude_none`.

 ///

@@ -12,7 +12,7 @@ Vous pouvez déclarer `examples` pour un modèle Pydantic qui seront ajoutés au

 Ces informations supplémentaires seront ajoutées telles quelles au **JSON Schema** de sortie pour ce modèle, et elles seront utilisées dans les documents de l'API.

-Vous pouvez utiliser l'attribut `model_config` qui accepte un `dict` comme décrit dans [documents de Pydantic : Configuration](https://docs.pydantic.dev/latest/api/config/).
+Vous pouvez utiliser l'attribut `model_config` qui accepte un `dict` comme décrit dans [documents de Pydantic : Configuration](https://pydantic.dev/docs/validation/latest/api/pydantic/config/).

 Vous pouvez définir `"json_schema_extra"` avec un `dict` contenant toutes les données supplémentaires que vous souhaitez voir apparaître dans le JSON Schema généré, y compris `examples`.

@@ -26,26 +26,26 @@ Copiez l'exemple dans un fichier `main.py` :

 /// note | Remarque

-Le package [`python-multipart`](https://github.com/Kludex/python-multipart) est installé automatiquement avec **FastAPI** lorsque vous exécutez la commande `pip install "fastapi[standard]"`.
+Le package [`python-multipart`](https://github.com/Kludex/python-multipart) est installé automatiquement avec **FastAPI** lorsque vous exécutez la commande `uv add "fastapi[standard]"`.

-Cependant, si vous utilisez la commande `pip install fastapi`, le package `python-multipart` n'est pas inclus par défaut.
+Cependant, si vous utilisez la commande `uv add fastapi`, le package `python-multipart` n'est pas inclus par défaut.

-Pour l'installer manuellement, vous devez vous assurer de créer un [environnement virtuel](../../virtual-environments.md), de l'activer, puis de l'installer avec :
+Pour l'installer manuellement, ajoutez-le à votre projet avec :

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

 Cela est dû au fait que **OAuth2** utilise des « form data » pour envoyer le `username` et le `password`.

 ///

-Exécutez l'exemple avec :
+Exécutez l'exemple avec :

 <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)
 ```
@@ -54,9 +54,9 @@ $ fastapi dev

 ## Vérifier { #check-it }

-Allez aux documents interactifs à l'adresse : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
+Allez aux documents interactifs à l'adresse : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).

-Vous verrez quelque chose comme ceci :
+Vous verrez quelque chose comme ceci :

 <img src="/img/tutorial/security/image01.png">

@@ -68,7 +68,7 @@ Et votre *chemin d'accès* a un petit cadenas dans le coin supérieur droit sur

 ///

-Et si vous cliquez dessus, vous obtenez un petit formulaire d'autorisation pour saisir un `username` et un `password` (et d'autres champs optionnels) :
+Et si vous cliquez dessus, vous obtenez un petit formulaire d'autorisation pour saisir un `username` et un `password` (et d'autres champs optionnels) :

 <img src="/img/tutorial/security/image02.png">

@@ -96,7 +96,7 @@ OAuth2 a été conçu pour que le backend ou l'API puisse être indépendant du

 Mais dans ce cas, la même application **FastAPI** gérera l'API et l'authentification.

-Voyons cela selon ce point de vue simplifié :
+Voyons cela selon ce point de vue simplifié :

 * L'utilisateur saisit le `username` et le `password` dans le frontend, puis appuie sur Entrée.
 * Le frontend (exécuté dans le navigateur de l'utilisateur) envoie ce `username` et ce `password` vers une URL spécifique de notre API (déclarée avec `tokenUrl="token"`).
@@ -110,7 +110,7 @@ Voyons cela selon ce point de vue simplifié :
 * Le frontend doit récupérer d'autres données depuis l'API.
    * Mais cela nécessite une authentification pour cet endpoint spécifique.
    * Donc, pour s'authentifier auprès de notre API, il envoie un en-tête `Authorization` avec une valeur `Bearer ` suivie du token.
-    * Si le token contient `foobar`, le contenu de l'en-tête `Authorization` serait : `Bearer foobar`.
+    * Si le token contient `foobar`, le contenu de l'en-tête `Authorization` serait : `Bearer foobar`.

 ## Le `OAuth2PasswordBearer` de **FastAPI** { #fastapis-oauth2passwordbearer }

@@ -158,7 +158,7 @@ C'est parce qu'il utilise le même nom que dans la spécification OpenAPI. Ainsi

 La variable `oauth2_scheme` est une instance de `OAuth2PasswordBearer`, mais c'est aussi un « callable ».

-Elle pourrait être appelée ainsi :
+Elle pourrait être appelée ainsi :

 ```Python
 oauth2_scheme(some, parameters)
@@ -192,7 +192,7 @@ S'il ne voit pas d'en-tête `Authorization`, ou si la valeur n'a pas de token `B

 Vous n'avez même pas à vérifier si le token existe pour renvoyer une erreur. Vous pouvez être sûr que si votre fonction est exécutée, elle aura une `str` dans ce token.

-Vous pouvez déjà l'essayer dans les documents interactifs :
+Vous pouvez déjà l'essayer dans les documents interactifs :

 <img src="/img/tutorial/security/image03.png">

@@ -30,12 +30,12 @@ Si vous voulez expérimenter avec des jetons JWT et voir comment ils fonctionnen

 Nous devons installer `PyJWT` pour générer et vérifier les jetons JWT en Python.

-Assurez-vous de créer un [environnement virtuel](../../virtual-environments.md), de l'activer, puis d'installer `pyjwt` :
+Ajoutez `pyjwt` à votre projet :

 <div class="termy">

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

 ---> 100%
 ```
@@ -72,12 +72,12 @@ Il prend en charge de nombreux algorithmes de hachage sécurisés et des utilita

 L'algorithme recommandé est « Argon2 ».

-Assurez-vous de créer un [environnement virtuel](../../virtual-environments.md), de l'activer, puis d'installer pwdlib avec Argon2 :
+Ajoutez `pwdlib` avec Argon2 à votre projet :

 <div class="termy">

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

 ---> 100%
 ```
@@ -34,12 +34,12 @@ Il s'agit d'un tutoriel très simple et court ; si vous souhaitez apprendre sur

 ## Installer `SQLModel` { #install-sqlmodel }

-D'abord, assurez-vous de créer votre [environnement virtuel](../virtual-environments.md), de l'activer, puis d'installer `sqlmodel` :
+Ajoutez `sqlmodel` à votre projet :

 <div class="termy">

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

@@ -152,7 +152,7 @@ Vous pouvez exécuter l'application :
 <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)
 ```
@@ -337,7 +337,7 @@ Vous pouvez exécuter l'application à nouveau :
 <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)
 ```
@@ -352,6 +352,6 @@ Si vous allez sur l'UI `/docs` de l'API, vous verrez qu'elle est maintenant à j

 ## Récapitulatif { #recap }

-Vous pouvez utiliser [**SQLModel**](https://sqlmodel.tiangolo.com/) pour interagir avec une base SQL et simplifier le code avec des *modèles de données* et des *modèles de table*.
+Vous pouvez utiliser [**SQLModel**](https://sqlmodel.tiangolo.com/) pour interagir avec une base SQL et simplifier le code avec des *modèles de données*  et des *modèles de table*.

 Vous pouvez en apprendre beaucoup plus dans les documents de **SQLModel**, il y a un mini [tutoriel plus long sur l'utilisation de SQLModel avec **FastAPI**](https://sqlmodel.tiangolo.com/tutorial/fastapi/). 🚀
@@ -12,8 +12,8 @@ Si vous devez héberger un frontend, utilisez plutôt `app.frontend()`, lisez-en

 ## Utiliser `StaticFiles` { #use-staticfiles }

- Importer `StaticFiles`.
- « Mount » une instance `StaticFiles()` sur un chemin spécifique.
+* Importer `StaticFiles`.
+* « Mount » une instance `StaticFiles()` sur un chemin spécifique.

 {* ../../docs_src/static_files/tutorial001_py310.py hl[2,6] *}

@@ -45,4 +45,4 @@ Tous ces paramètres peuvent être différents de « `static` », adaptez-les au

 ## Plus d'informations { #more-info }

-Pour plus de détails et d'options, consultez la [documentation de Starlette sur les fichiers statiques](https://www.starlette.dev/staticfiles/).
+Pour plus de détails et d'options, consultez la [documentation de Starlette sur les fichiers statiques](https://starlette.dev/staticfiles/).
@@ -1,6 +1,6 @@
 # Tester { #testing }

-Grâce à [Starlette](https://www.starlette.dev/testclient/), tester des applications **FastAPI** est simple et agréable.
+Grâce à [Starlette](https://starlette.dev/testclient/), tester des applications **FastAPI** est simple et agréable.

 C’est basé sur [HTTPX](https://www.python-httpx.org), dont la conception s’inspire de Requests, ce qui le rend très familier et intuitif.

@@ -12,10 +12,10 @@ Avec cela, vous pouvez utiliser [pytest](https://docs.pytest.org/) directement a

 Pour utiliser `TestClient`, installez d’abord [`httpx`](https://www.python-httpx.org).

-Vous devez vous assurer de créer un [environnement virtuel](../virtual-environments.md), de l’activer, puis d’y installer le paquet, par exemple :
+Ajoutez-le à votre projet :

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

 ///
@@ -95,7 +95,7 @@ Comme ce fichier se trouve dans le même package, vous pouvez utiliser des impor
 {* ../../docs_src/app_testing/app_a_py310/test_main.py hl[3] *}


-… et avoir le code des tests comme précédemment.
+... et avoir le code des tests comme précédemment.

 ## Tester : exemple étendu { #testing-extended-example }

@@ -119,7 +119,7 @@ Il a une opération `GET` qui pourrait renvoyer une erreur.

 Il a une opération `POST` qui pourrait renvoyer plusieurs erreurs.

-Les deux chemins d’accès requièrent un en-tête `X-Token`.
+Les deux *chemins d’accès* requièrent un en-tête `X-Token`.

 {* ../../docs_src/app_testing/app_b_an_py310/main.py *}

@@ -156,12 +156,12 @@ Si vous avez un modèle Pydantic dans votre test et que vous souhaitez envoyer s

 Après cela, vous avez simplement besoin d’installer `pytest`.

-Vous devez vous assurer de créer un [environnement virtuel](../virtual-environments.md), de l’activer, puis d’y installer le paquet, par exemple :
+Ajoutez-le à votre projet :

 <div class="termy">

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

 ---> 100%
 ```
@@ -175,7 +175,7 @@ Exécutez les tests avec :
 <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,864 +1,35 @@
 # Environnements virtuels { #virtual-environments }

-Lorsque vous travaillez sur des projets Python, vous devriez probablement utiliser un **environnement virtuel** (ou un mécanisme similaire) pour isoler les packages que vous installez pour chaque projet.
+Lorsque vous travaillez sur des projets Python, vous devez utiliser un **environnement virtuel** pour isoler les packages installés pour chaque projet.

-/// note | Remarque
-
-Si vous connaissez déjà les environnements virtuels, comment les créer et les utiliser, vous pouvez passer cette section. 🤓
-
-///
-
-/// tip | Astuce
-
-Un **environnement virtuel** est différent d’une **variable d’environnement**.
-
-Une **variable d’environnement** est une variable du système qui peut être utilisée par des programmes.
-
-Un **environnement virtuel** est un répertoire contenant certains fichiers.
-
-///
-
-/// note | Remarque
-
-Cette page vous apprendra à utiliser les **environnements virtuels** et à comprendre leur fonctionnement.
-
-Si vous êtes prêt à adopter un **outil qui gère tout** pour vous (y compris l’installation de Python), essayez [uv](https://github.com/astral-sh/uv).
-
-///
+Pour les projets FastAPI, je recommande d’utiliser [uv](https://docs.astral.sh/uv/) pour gérer le projet, ses dépendances et son environnement virtuel.

 ## Créer un projet { #create-a-project }

-Commencez par créer un répertoire pour votre projet.
-
-Ce que je fais généralement, c’est créer un répertoire nommé `code` dans mon répertoire personnel/utilisateur.
-
-Et à l’intérieur, je crée un répertoire par projet.
+Installez `uv` en utilisant le [guide d’installation officiel](https://docs.astral.sh/uv/getting-started/installation/), puis créez un projet :

 <div class="termy">

 ```console
-// Aller au répertoire personnel
-$ cd
-// Créer un répertoire pour tous vos projets de code
-$ mkdir code
-// Entrer dans ce répertoire code
-$ cd code
-// Créer un répertoire pour ce projet
-$ mkdir awesome-project
-// Entrer dans ce répertoire de projet
+$ uv init awesome-project --bare
 $ cd awesome-project
+$ uv add "fastapi[standard]"
 ```

 </div>

-## Créer un environnement virtuel { #create-a-virtual-environment }
+`uv` crée automatiquement un environnement virtuel pour le projet. Vous n’avez pas besoin d’en créer ou d’en activer un vous-même.

-Lorsque vous commencez à travailler sur un projet Python **pour la première fois**, créez un environnement virtuel **<dfn title="il existe d'autres options, il s'agit d'une simple recommandation">dans votre projet</dfn>**.
-
-/// tip | Astuce
-
-Vous n’avez besoin de faire cela qu’**une seule fois par projet**, pas à chaque fois que vous travaillez.
-
-///
-
-//// tab | `venv`
-
-Pour créer un environnement virtuel, vous pouvez utiliser le module `venv` fourni avec Python.
+Exécutez les commandes dans l’environnement du projet avec `uv run`, par exemple :

 <div class="termy">

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

 </div>

-/// details | Que signifie cette commande
+## En savoir plus { #learn-more }

-* `python` : utiliser le programme nommé `python`
-* `-m` : appeler un module comme un script, nous préciserons ensuite quel module
-* `venv` : utiliser le module nommé `venv` qui est normalement installé avec Python
-* `.venv` : créer l’environnement virtuel dans le nouveau répertoire `.venv`
-
-///
-
-////
-
-//// tab | `uv`
-
-Si vous avez installé [`uv`](https://github.com/astral-sh/uv), vous pouvez l’utiliser pour créer un environnement virtuel.
-
-<div class="termy">
-
-```console
-$ uv venv
-```
-
-</div>
-
-/// tip | Astuce
-
-Par défaut, `uv` créera un environnement virtuel dans un répertoire appelé `.venv`.
-
-Mais vous pouvez le personnaliser en passant un argument supplémentaire avec le nom du répertoire.
-
-///
-
-////
-
-Cette commande crée un nouvel environnement virtuel dans un répertoire appelé `.venv`.
-
-/// details | `.venv` ou autre nom
-
-Vous pourriez créer l’environnement virtuel dans un autre répertoire, mais il est d’usage de l’appeler `.venv`.
-
-///
-
-## Activer l’environnement virtuel { #activate-the-virtual-environment }
-
-Activez le nouvel environnement virtuel afin que toute commande Python que vous exécutez ou tout package que vous installez l’utilise.
-
-/// tip | Astuce
-
-Faites cela **chaque fois** que vous démarrez une **nouvelle session de terminal** pour travailler sur le projet.
-
-///
-
-//// 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
-
-Ou si vous utilisez Bash pour Windows (par exemple [Git Bash](https://gitforwindows.org/)) :
-
-<div class="termy">
-
-```console
-$ source .venv/Scripts/activate
-```
-
-</div>
-
-////
-
-/// tip | Astuce
-
-Chaque fois que vous installez un **nouveau package** dans cet environnement, **activez** de nouveau l’environnement.
-
-Vous vous assurez ainsi que si vous utilisez un **programme de terminal (<abbr title="command line interface - interface en ligne de commande">CLI</abbr>)** installé par ce package, vous utilisez celui de votre environnement virtuel et non un autre qui pourrait être installé globalement, probablement avec une version différente de celle dont vous avez besoin.
-
-///
-
-## Vérifier que l’environnement virtuel est actif { #check-the-virtual-environment-is-active }
-
-Vérifiez que l’environnement virtuel est actif (la commande précédente a fonctionné).
-
-/// tip | Astuce
-
-C’est **facultatif**, mais c’est une bonne manière de **vérifier** que tout fonctionne comme prévu et que vous utilisez l’environnement virtuel voulu.
-
-///
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-$ which python
-
-/home/user/code/awesome-project/.venv/bin/python
-```
-
-</div>
-
-S’il affiche le binaire `python` à `.venv/bin/python`, dans votre projet (dans cet exemple `awesome-project`), alors cela a fonctionné. 🎉
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ Get-Command python
-
-C:\Users\user\code\awesome-project\.venv\Scripts\python
-```
-
-</div>
-
-S’il affiche le binaire `python` à `.venv\Scripts\python`, dans votre projet (dans cet exemple `awesome-project`), alors cela a fonctionné. 🎉
-
-////
-
-## Mettre à niveau `pip` { #upgrade-pip }
-
-/// tip | Astuce
-
-Si vous utilisez [`uv`](https://github.com/astral-sh/uv), vous l’utiliserez pour installer des éléments à la place de `pip`, vous n’avez donc pas besoin de mettre `pip` à niveau. 😎
-
-///
-
-Si vous utilisez `pip` pour installer des packages (il est fourni par défaut avec Python), vous devez le **mettre à niveau** vers la dernière version.
-
-Beaucoup d’erreurs exotiques lors de l’installation d’un package se résolvent simplement en mettant d’abord `pip` à niveau.
-
-/// tip | Astuce
-
-Vous feriez normalement cela **une seule fois**, juste après avoir créé l’environnement virtuel.
-
-///
-
-Vous devez vous assurer que l’environnement virtuel est actif (avec la commande ci-dessus), puis exécuter :
-
-<div class="termy">
-
-```console
-$ python -m pip install --upgrade pip
-
---> 100%
-```
-
-</div>
-
-/// tip | Astuce
-
-Parfois, vous pourriez obtenir une erreur **`No module named pip`** en essayant de mettre à niveau pip.
-
-Si cela arrive, installez et mettez à niveau pip avec la commande ci-dessous :
-
-<div class="termy">
-
-```console
-$ python -m ensurepip --upgrade
-
---> 100%
-```
-
-</div>
-
-Cette commande installera pip s’il n’est pas déjà installé et garantit aussi que la version de pip installée est au moins aussi récente que celle disponible dans `ensurepip`.
-
-///
-
-## Ajouter `.gitignore` { #add-gitignore }
-
-Si vous utilisez **Git** (vous devriez), ajoutez un fichier `.gitignore` pour exclure tout ce qui se trouve dans votre `.venv` de Git.
-
-/// tip | Astuce
-
-Si vous avez utilisé [`uv`](https://github.com/astral-sh/uv) pour créer l’environnement virtuel, il l’a déjà fait pour vous, vous pouvez passer cette étape. 😎
-
-///
-
-/// tip | Astuce
-
-Faites cela **une seule fois**, juste après avoir créé l’environnement virtuel.
-
-///
-
-<div class="termy">
-
-```console
-$ echo "*" > .venv/.gitignore
-```
-
-</div>
-
-/// details | Que signifie cette commande
-
-* `echo "*"` : va « afficher » le texte `*` dans le terminal (la partie suivante change un peu cela)
-* `>` : tout ce qui est affiché dans le terminal par la commande à gauche de `>` ne doit pas être affiché mais écrit dans le fichier à droite de `>`
-* `.gitignore` : le nom du fichier dans lequel le texte doit être écrit
-
-Et `*` signifie pour Git « tout ». Ainsi, il ignorera tout dans le répertoire `.venv`.
-
-Cette commande créera un fichier `.gitignore` avec le contenu :
-
-```gitignore
-*
-```
-
-///
-
-## Installer des packages { #install-packages }
-
-Après avoir activé l’environnement, vous pouvez y installer des packages.
-
-/// tip | Astuce
-
-Faites cela **une seule fois** lorsque vous installez ou mettez à niveau les packages nécessaires à votre projet.
-
-Si vous devez mettre à niveau une version ou ajouter un nouveau package, vous le **referez**.
-
-///
-
-### Installer des packages directement { #install-packages-directly }
-
-Si vous êtes pressé et ne souhaitez pas utiliser un fichier pour déclarer les dépendances de packages de votre projet, vous pouvez les installer directement.
-
-/// tip | Astuce
-
-C’est une (très) bonne idée de placer les packages et leurs versions nécessaires à votre programme dans un fichier (par exemple `requirements.txt` ou `pyproject.toml`).
-
-///
-
-//// tab | `pip`
-
-<div class="termy">
-
-```console
-$ pip install "fastapi[standard]"
-
---> 100%
-```
-
-</div>
-
-////
-
-//// tab | `uv`
-
-Si vous avez [`uv`](https://github.com/astral-sh/uv) :
-
-<div class="termy">
-
-```console
-$ uv pip install "fastapi[standard]"
---> 100%
-```
-
-</div>
-
-////
-
-### Installer depuis `requirements.txt` { #install-from-requirements-txt }
-
-Si vous avez un `requirements.txt`, vous pouvez maintenant l’utiliser pour installer ses packages.
-
-//// tab | `pip`
-
-<div class="termy">
-
-```console
-$ pip install -r requirements.txt
---> 100%
-```
-
-</div>
-
-////
-
-//// tab | `uv`
-
-Si vous avez [`uv`](https://github.com/astral-sh/uv) :
-
-<div class="termy">
-
-```console
-$ uv pip install -r requirements.txt
---> 100%
-```
-
-</div>
-
-////
-
-/// details | `requirements.txt`
-
-Un `requirements.txt` avec quelques packages pourrait ressembler à :
-
-```requirements.txt
-fastapi[standard]==0.113.0
-pydantic==2.8.0
-```
-
-///
-
-## Exécuter votre programme { #run-your-program }
-
-Après avoir activé l’environnement virtuel, vous pouvez exécuter votre programme, et il utilisera le Python de votre environnement virtuel avec les packages que vous y avez installés.
-
-<div class="termy">
-
-```console
-$ python main.py
-
-Hello World
-```
-
-</div>
-
-## Configurer votre éditeur { #configure-your-editor }
-
-Vous utiliserez probablement un éditeur, assurez-vous de le configurer pour utiliser le même environnement virtuel que vous avez créé (il le détectera probablement automatiquement) afin d’avoir l’autocomplétion et les erreurs inline.
-
-Par exemple :
-
-* [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 | Astuce
-
-Vous devez normalement faire cela seulement **une fois**, lorsque vous créez l’environnement virtuel.
-
-///
-
-## Désactiver l’environnement virtuel { #deactivate-the-virtual-environment }
-
-Une fois que vous avez fini de travailler sur votre projet, vous pouvez **désactiver** l’environnement virtuel.
-
-<div class="termy">
-
-```console
-$ deactivate
-```
-
-</div>
-
-Ainsi, lorsque vous exécutez `python`, il n’essaiera pas de l’exécuter depuis cet environnement virtuel avec les packages qui y sont installés.
-
-## Prêt à travailler { #ready-to-work }
-
-Vous êtes maintenant prêt à commencer à travailler sur votre projet.
-
-
-
-/// tip | Astuce
-
-Voulez-vous comprendre tout ce qui précède ?
-
-Continuez la lecture. 👇🤓
-
-///
-
-## Pourquoi des environnements virtuels { #why-virtual-environments }
-
-Pour travailler avec FastAPI, vous devez installer [Python](https://www.python.org/).
-
-Ensuite, vous devez **installer** FastAPI et tout autre **package** que vous souhaitez utiliser.
-
-Pour installer des packages, vous utiliseriez normalement la commande `pip` fournie avec Python (ou des alternatives similaires).
-
-Néanmoins, si vous utilisez simplement `pip` directement, les packages seraient installés dans votre **environnement Python global** (l’installation globale de Python).
-
-### Le problème { #the-problem }
-
-Alors, quel est le problème d’installer des packages dans l’environnement Python global ?
-
-À un moment donné, vous finirez probablement par écrire de nombreux programmes différents qui dépendent de **packages différents**. Et certains de ces projets sur lesquels vous travaillez dépendront de **versions différentes** du même package. 😱
-
-Par exemple, vous pourriez créer un projet appelé `philosophers-stone`, ce programme dépend d’un autre package appelé **`harry`, en version `1`**. Vous devez donc installer `harry`.
-
-```mermaid
-flowchart LR
-    stone(philosophers-stone) -->|requires| harry-1[harry v1]
-```
-
-Puis, plus tard, vous créez un autre projet appelé `prisoner-of-azkaban`, et ce projet dépend aussi de `harry`, mais il a besoin de **`harry` en version `3`**.
-
-```mermaid
-flowchart LR
-    azkaban(prisoner-of-azkaban) --> |requires| harry-3[harry v3]
-```
-
-Mais maintenant, le problème est que, si vous installez les packages globalement (dans l’environnement global) au lieu de dans un **environnement virtuel** local, vous devrez choisir quelle version de `harry` installer.
-
-Si vous voulez exécuter `philosophers-stone`, vous devrez d’abord installer `harry` en version `1`, par exemple avec :
-
-<div class="termy">
-
-```console
-$ pip install "harry==1"
-```
-
-</div>
-
-Et vous vous retrouverez avec `harry` en version `1` installé dans votre environnement Python global.
-
-```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
-```
-
-Mais si vous voulez ensuite exécuter `prisoner-of-azkaban`, vous devrez désinstaller `harry` version `1` et installer `harry` version `3` (ou bien installer la version `3` désinstallerait automatiquement la version `1`).
-
-<div class="termy">
-
-```console
-$ pip install "harry==3"
-```
-
-</div>
-
-Et vous vous retrouverez alors avec `harry` version `3` installé dans votre environnement Python global.
-
-Et si vous essayez d’exécuter à nouveau `philosophers-stone`, il y a une chance que cela **ne fonctionne pas** car il a besoin de `harry` version `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 | Astuce
-
-Il est très courant que les packages Python fassent de leur mieux pour **éviter les changements cassants** dans les **nouvelles versions**, mais il vaut mieux jouer la sécurité et installer de nouvelles versions intentionnellement et lorsque vous pouvez exécuter les tests pour vérifier que tout fonctionne correctement.
-
-///
-
-Maintenant, imaginez cela avec **beaucoup** d’autres **packages** dont tous vos **projets dépendent**. C’est très difficile à gérer. Et vous finiriez probablement par exécuter certains projets avec des **versions incompatibles** des packages, sans savoir pourquoi quelque chose ne fonctionne pas.
-
-De plus, selon votre système d’exploitation (par exemple Linux, Windows, macOS), il se peut qu’il soit livré avec Python déjà installé. Et dans ce cas, il avait probablement des packages préinstallés avec des versions spécifiques **nécessaires à votre système**. Si vous installez des packages dans l’environnement Python global, vous pourriez finir par **casser** certains des programmes fournis avec votre système d’exploitation.
-
-## Où les packages sont-ils installés { #where-are-packages-installed }
-
-Lorsque vous installez Python, il crée des répertoires avec des fichiers sur votre ordinateur.
-
-Certains de ces répertoires sont chargés de contenir tous les packages que vous installez.
-
-Lorsque vous exécutez :
-
-<div class="termy">
-
-```console
-// Ne l’exécutez pas maintenant, c’est juste un exemple 🤓
-$ pip install "fastapi[standard]"
---> 100%
-```
-
-</div>
-
-Cela téléchargera un fichier compressé avec le code de FastAPI, normalement depuis [PyPI](https://pypi.org/project/fastapi/).
-
-Il **téléchargera** également des fichiers pour d’autres packages dont FastAPI dépend.
-
-Ensuite, il **extraira** tous ces fichiers et les placera dans un répertoire de votre ordinateur.
-
-Par défaut, il placera ces fichiers téléchargés et extraits dans le répertoire fourni avec votre installation de Python, c’est l’**environnement global**.
-
-## Qu’est-ce qu’un environnement virtuel { #what-are-virtual-environments }
-
-La solution aux problèmes posés par le fait d’avoir tous les packages dans l’environnement global est d’utiliser un **environnement virtuel pour chaque projet** sur lequel vous travaillez.
-
-Un environnement virtuel est un **répertoire**, très similaire à celui global, où vous pouvez installer les packages pour un projet.
-
-De cette manière, chaque projet aura son propre environnement virtuel (répertoire `.venv`) avec ses propres packages.
-
-```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
-```
-
-## Que signifie activer un environnement virtuel { #what-does-activating-a-virtual-environment-mean }
-
-Lorsque vous activez un environnement virtuel, par exemple avec :
-
-//// 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
-
-Ou si vous utilisez Bash pour Windows (par exemple [Git Bash](https://gitforwindows.org/)) :
-
-<div class="termy">
-
-```console
-$ source .venv/Scripts/activate
-```
-
-</div>
-
-////
-
-Cette commande créera ou modifiera certaines [variables d’environnement](environment-variables.md) qui seront disponibles pour les prochaines commandes.
-
-L’une de ces variables est la variable `PATH`.
-
-/// tip | Astuce
-
-Vous pouvez en savoir plus sur la variable d’environnement `PATH` dans la section [Variables d’environnement](environment-variables.md#path-environment-variable).
-
-///
-
-Activer un environnement virtuel ajoute son chemin `.venv/bin` (sur Linux et macOS) ou `.venv\Scripts` (sur Windows) à la variable d’environnement `PATH`.
-
-Disons qu’avant d’activer l’environnement, la variable `PATH` ressemblait à ceci :
-
-//// tab | Linux, macOS
-
-```plaintext
-/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-Cela signifie que le système chercherait des programmes dans :
-
-* `/usr/bin`
-* `/bin`
-* `/usr/sbin`
-* `/sbin`
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Windows\System32
-```
-
-Cela signifie que le système chercherait des programmes dans :
-
-* `C:\Windows\System32`
-
-////
-
-Après avoir activé l’environnement virtuel, la variable `PATH` ressemblerait à quelque chose comme ceci :
-
-//// tab | Linux, macOS
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin:/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-Cela signifie que le système commencera maintenant par chercher des programmes dans :
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin
-```
-
-avant de chercher dans les autres répertoires.
-
-Ainsi, lorsque vous tapez `python` dans le terminal, le système trouvera le programme Python dans
-
-```plaintext
-/home/user/code/awesome-project/.venv/bin/python
-```
-
-et utilisera celui-ci.
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts;C:\Windows\System32
-```
-
-Cela signifie que le système commencera maintenant par chercher des programmes dans :
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts
-```
-
-avant de chercher dans les autres répertoires.
-
-Ainsi, lorsque vous tapez `python` dans le terminal, le système trouvera le programme Python dans
-
-```plaintext
-C:\Users\user\code\awesome-project\.venv\Scripts\python
-```
-
-et utilisera celui-ci.
-
-////
-
-Un détail important est qu’il placera le chemin de l’environnement virtuel au **début** de la variable `PATH`. Le système le trouvera **avant** de trouver tout autre Python disponible. Ainsi, lorsque vous exécutez `python`, il utilisera le Python **de l’environnement virtuel** au lieu de tout autre `python` (par exemple, un `python` d’un environnement global).
-
-Activer un environnement virtuel change aussi deux ou trois autres choses, mais c’est l’un des points les plus importants.
-
-## Vérifier un environnement virtuel { #checking-a-virtual-environment }
-
-Lorsque vous vérifiez si un environnement virtuel est actif, par exemple avec :
-
-//// 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>
-
-////
-
-Cela signifie que le programme `python` qui sera utilisé est celui **dans l’environnement virtuel**.
-
-Vous utilisez `which` sous Linux et macOS et `Get-Command` sous Windows PowerShell.
-
-La façon dont cette commande fonctionne est qu’elle va vérifier la variable d’environnement `PATH`, en parcourant **chaque chemin dans l’ordre**, à la recherche du programme nommé `python`. Une fois trouvé, elle vous **affichera le chemin** vers ce programme.
-
-La partie la plus importante est que lorsque vous appelez `python`, c’est exactement « `python` » qui sera exécuté.
-
-Ainsi, vous pouvez confirmer si vous êtes dans le bon environnement virtuel.
-
-/// tip | Astuce
-
-Il est facile d’activer un environnement virtuel, d’obtenir un Python, puis d’**aller vers un autre projet**.
-
-Et le second projet **ne fonctionnerait pas** parce que vous utilisez le **Python incorrect**, provenant d’un environnement virtuel d’un autre projet.
-
-Il est utile de pouvoir vérifier quel `python` est utilisé. 🤓
-
-///
-
-## Pourquoi désactiver un environnement virtuel { #why-deactivate-a-virtual-environment }
-
-Par exemple, vous pourriez travailler sur un projet `philosophers-stone`, **activer cet environnement virtuel**, installer des packages et travailler avec cet environnement.
-
-Puis vous souhaitez travailler sur **un autre projet** `prisoner-of-azkaban`.
-
-Vous allez vers ce projet :
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-```
-
-</div>
-
-Si vous ne désactivez pas l’environnement virtuel de `philosophers-stone`, lorsque vous exécutez `python` dans le terminal, il essaiera d’utiliser le Python de `philosophers-stone`.
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-
-$ python main.py
-
-// Erreur lors de l'import de sirius, il n'est pas installé 😱
-Traceback (most recent call last):
-    File "main.py", line 1, in <module>
-        import sirius
-```
-
-</div>
-
-Mais si vous désactivez l’environnement virtuel et activez le nouveau pour `prisoner-of-azkaban`, alors lorsque vous exécuterez `python`, il utilisera le Python de l’environnement virtuel de `prisoner-of-azkaban`.
-
-<div class="termy">
-
-```console
-$ cd ~/code/prisoner-of-azkaban
-
-// Vous n’avez pas besoin d’être dans l’ancien répertoire pour désactiver, vous pouvez le faire où que vous soyez, même après être allé dans l’autre projet 😎
-$ deactivate
-
-// Activer l’environnement virtuel dans prisoner-of-azkaban/.venv 🚀
-$ source .venv/bin/activate
-
-// Maintenant, lorsque vous exécutez python, il trouvera le package sirius installé dans cet environnement virtuel ✨
-$ python main.py
-
-I solemnly swear 🐺
-```
-
-</div>
-
-## Alternatives { #alternatives }
-
-Ceci est un guide simple pour vous lancer et vous montrer comment tout fonctionne **en dessous**.
-
-Il existe de nombreuses **alternatives** pour gérer les environnements virtuels, les dépendances de packages (requirements), les projets.
-
-Lorsque vous êtes prêt et souhaitez utiliser un outil pour **gérer l’ensemble du projet**, les dépendances de packages, les environnements virtuels, etc., je vous suggère d’essayer [uv](https://github.com/astral-sh/uv).
-
-`uv` peut faire beaucoup de choses, il peut :
-
-* **Installer Python** pour vous, y compris différentes versions
-* Gérer l’**environnement virtuel** pour vos projets
-* Installer des **packages**
-* Gérer les **dépendances et versions** de packages pour votre projet
-* Vous assurer d’avoir un ensemble **exact** de packages et de versions à installer, y compris leurs dépendances, afin que vous puissiez être certain d’exécuter votre projet en production exactement comme sur votre ordinateur pendant le développement, cela s’appelle le **locking**
-* Et bien d’autres choses
-
-## Conclusion { #conclusion }
-
-Si vous avez lu et compris tout cela, vous en savez maintenant **bien plus** sur les environnements virtuels que beaucoup de développeurs. 🤓
-
-Connaître ces détails vous sera très probablement utile à l’avenir lorsque vous déboguerez quelque chose qui semble complexe, mais vous saurez **comment tout fonctionne en dessous**. 😎
+Lisez le [guide sur les environnements virtuels](https://tiangolo.com/guides/virtual-environments/) pour apprendre comment les environnements virtuels fonctionnent en dessous, y compris l’activation et le workflow alternatif avec `python -m venv` et `pip`.