+
-## Combinez les réponses prédéfinies et les réponses personnalisées
+## Combinez 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 *paramètre de chemin*, mais vous souhaitez les combiner avec des réponses personnalisées nécessaires à chaque *opération de chemin*.
+Vous voulez peut-être avoir des réponses prédéfinies qui s'appliquent à de nombreuses *opérations de chemin*, mais vous souhaitez les combiner avec des réponses personnalisées nécessaires à chaque *opération de chemin*.
-Dans ces cas, vous pouvez utiliser la technique Python "d'affection par décomposition" (appelé _unpacking_ en anglais) d'un `dict` avec `**dict_to_unpack` :
+Dans ces cas, vous pouvez utiliser la technique Python «d'affection par décomposition» (appelé _unpacking_ en anglais) d'un `dict` avec `**dict_to_unpack` :
```Python
old_dict = {
@@ -233,15 +233,15 @@ 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 *paramètres de chemin* et les combiner avec des réponses personnalisées supplémentaires.
+Vous pouvez utiliser cette technique pour réutiliser certaines réponses prédéfinies dans vos *opérations de chemin* et les combiner avec des réponses personnalisées supplémentaires.
Par exemple:
-{* ../../docs_src/additional_responses/tutorial004.py hl[13:17,26] *}
+{* ../../docs_src/additional_responses/tutorial004_py310.py hl[11:15,24] *}
-## Plus d'informations sur les réponses OpenAPI
+## 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 :
-* Objet Responses de OpenAPI , il inclut le `Response Object`.
-* Objet Response de OpenAPI , 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, il inclut le `Response Object`.
+* Objet Response de OpenAPI, 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`.
diff --git a/docs/fr/docs/advanced/additional-status-codes.md b/docs/fr/docs/advanced/additional-status-codes.md
index dde6b9a63..cd34a4f8a 100644
--- a/docs/fr/docs/advanced/additional-status-codes.md
+++ b/docs/fr/docs/advanced/additional-status-codes.md
@@ -1,20 +1,20 @@
-# Codes HTTP supplémentaires
+# Codes HTTP supplémentaires { #additional-status-codes }
-Par défaut, **FastAPI** renverra les réponses à l'aide d'une structure de données `JSONResponse`, en plaçant la réponse de votre *chemin d'accès* à l'intérieur de cette `JSONResponse`.
+Par défaut, **FastAPI** renverra les réponses à l'aide d'une structure de données `JSONResponse`, en plaçant la réponse de votre *opération de chemin* à l'intérieur de cette `JSONResponse`.
-Il utilisera le code HTTP par défaut ou celui que vous avez défini dans votre *chemin d'accès*.
+Il utilisera le code HTTP par défaut ou celui que vous avez défini dans votre *opération de chemin*.
-## Codes HTTP supplémentaires
+## Codes HTTP supplémentaires { #additional-status-codes_1 }
Si vous souhaitez renvoyer des codes HTTP supplémentaires en plus du code principal, vous pouvez le faire en renvoyant directement une `Response`, comme une `JSONResponse`, et en définissant directement le code HTTP supplémentaire.
-Par exemple, disons que vous voulez avoir un *chemin d'accès* qui permet de mettre à jour les éléments et renvoie les codes HTTP 200 "OK" en cas de succès.
+Par exemple, disons que vous voulez avoir une *opération de chemin* qui permet de mettre à jour les éléments et renvoie les codes HTTP 200 «OK» en cas de succès.
-Mais vous voulez aussi qu'il accepte de nouveaux éléments. Et lorsque les éléments n'existaient pas auparavant, il les crée et renvoie un code HTTP de 201 "Créé".
+Mais vous voulez aussi qu'il accepte de nouveaux éléments. Et lorsque les éléments n'existaient pas auparavant, il les crée et renvoie un code HTTP de 201 «Créé».
Pour y parvenir, importez `JSONResponse` et renvoyez-y directement votre contenu, en définissant le `status_code` que vous souhaitez :
-{* ../../docs_src/additional_status_codes/tutorial001.py hl[4,25] *}
+{* ../../docs_src/additional_status_codes/tutorial001_an_py310.py hl[4,25] *}
/// warning | Attention
@@ -22,7 +22,7 @@ Lorsque vous renvoyez une `Response` directement, comme dans l'exemple ci-dessus
Elle ne sera pas sérialisée avec un modèle.
-Assurez-vous qu'il contient les données souhaitées et que les valeurs soient dans un format JSON valides (si vous utilisez une `JSONResponse`).
+Assurez-vous qu'elle contient les données souhaitées et que les valeurs soient dans un format JSON valides (si vous utilisez une `JSONResponse`).
///
@@ -30,12 +30,12 @@ Assurez-vous qu'il contient les données souhaitées et que les valeurs soient d
Vous pouvez également utiliser `from starlette.responses import JSONResponse`.
-Pour plus de commodités, **FastAPI** fournit les objets `starlette.responses` sous forme d'un alias accessible par `fastapi.responses`. Mais la plupart des réponses disponibles proviennent directement de Starlette. Il en est de même avec l'objet `statut`.
+Pour plus de commodités, **FastAPI** fournit les objets `starlette.responses` sous forme d'un alias accessible par `fastapi.responses`. Mais la plupart des réponses disponibles proviennent directement de Starlette. Il en est de même avec `status`.
///
-## Documents OpenAPI et API
+## OpenAPI et documentation de l'API { #openapi-and-api-docs }
Si vous renvoyez directement des codes HTTP et des réponses supplémentaires, ils ne seront pas inclus dans le schéma OpenAPI (la documentation de l'API), car FastAPI n'a aucun moyen de savoir à l'avance ce que vous allez renvoyer.
-Mais vous pouvez documenter cela dans votre code, en utilisant : [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Mais vous pouvez documenter cela dans votre code, en utilisant : [Réponses supplémentaires](additional-responses.md){.internal-link target=_blank}.
diff --git a/docs/fr/docs/advanced/index.md b/docs/fr/docs/advanced/index.md
index d9d8ad8e6..ba3f4b001 100644
--- a/docs/fr/docs/advanced/index.md
+++ b/docs/fr/docs/advanced/index.md
@@ -1,27 +1,21 @@
-# Guide de l'utilisateur avancé
+# Guide de l'utilisateur avancé { #advanced-user-guide }
-## Caractéristiques supplémentaires
+## Caractéristiques supplémentaires { #additional-features }
Le [Tutoriel - Guide de l'utilisateur](../tutorial/index.md){.internal-link target=_blank} devrait suffire à vous faire découvrir toutes les fonctionnalités principales de **FastAPI**.
Dans les sections suivantes, vous verrez des options, configurations et fonctionnalités supplémentaires.
-/// note | Remarque
+/// tip | Astuce
-Les sections de ce chapitre ne sont **pas nécessairement "avancées"**.
+Les sections de ce chapitre ne sont **pas nécessairement «avancées»**.
Et il est possible que pour votre cas d'utilisation, la solution se trouve dans l'un d'entre eux.
///
-## Lisez d'abord le didacticiel
+## Lisez d'abord le didacticiel { #read-the-tutorial-first }
Vous pouvez utiliser la plupart des fonctionnalités de **FastAPI** grâce aux connaissances du [Tutoriel - Guide de l'utilisateur](../tutorial/index.md){.internal-link target=_blank}.
Et les sections suivantes supposent que vous l'avez lu et que vous en connaissez les idées principales.
-
-## Cours TestDriven.io
-
-Si vous souhaitez suivre un cours pour débutants avancés pour compléter cette section de la documentation, vous pouvez consulter : Développement piloté par les tests avec FastAPI et Docker par **TestDriven.io**.
-
-10 % de tous les bénéfices de ce cours sont reversés au développement de **FastAPI**. 🎉 😄
diff --git a/docs/fr/docs/advanced/path-operation-advanced-configuration.md b/docs/fr/docs/advanced/path-operation-advanced-configuration.md
index 7daf0fc65..b98730c30 100644
--- a/docs/fr/docs/advanced/path-operation-advanced-configuration.md
+++ b/docs/fr/docs/advanced/path-operation-advanced-configuration.md
@@ -1,106 +1,108 @@
-# Configuration avancée des paramètres de chemin
+# Configuration avancée des opérations de chemin { #path-operation-advanced-configuration }
-## ID d'opération OpenAPI
+## ID d'opération OpenAPI { #openapi-operationid }
/// warning | Attention
-Si vous n'êtes pas un "expert" en OpenAPI, vous n'en avez probablement pas besoin.
+Si vous n'êtes pas un «expert» d'OpenAPI, vous n'en avez probablement pas besoin.
///
-Dans OpenAPI, les chemins sont des ressources, tels que /users/ ou /items/, exposées par votre API, et les opérations sont les méthodes HTTP utilisées pour manipuler ces chemins, telles que GET, POST ou DELETE. Les operationId sont des chaînes uniques facultatives utilisées pour identifier une opération d'un chemin. Vous pouvez définir l'OpenAPI `operationId` à utiliser dans votre *opération de chemin* avec le paramètre `operation_id`.
+Vous pouvez définir l'OpenAPI `operationId` à utiliser dans votre *opération de chemin* avec le paramètre `operation_id`.
-Vous devez vous assurer qu'il est unique pour chaque opération.
+Vous devrez vous assurer qu'il soit unique pour chaque opération.
-{* ../../docs_src/path_operation_advanced_configuration/tutorial001.py hl[6] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial001_py39.py hl[6] *}
-### Utilisation du nom *path operation function* comme operationId
+### Utiliser le nom de la *fonction d'opération de chemin* comme operationId { #using-the-path-operation-function-name-as-the-operationid }
-Si vous souhaitez utiliser les noms de fonction de vos API comme `operationId`, vous pouvez les parcourir tous et remplacer chaque `operation_id` de l'*opération de chemin* en utilisant leur `APIRoute.name`.
+Si vous souhaitez utiliser les noms de fonction de vos API comme `operationId`, vous pouvez les parcourir tous et remplacer chaque `operation_id` de l’*opération de chemin* en utilisant leur `APIRoute.name`.
-Vous devriez le faire après avoir ajouté toutes vos *paramètres de chemin*.
+Vous devriez le faire après avoir ajouté toutes vos *opérations de chemin*.
-{* ../../docs_src/path_operation_advanced_configuration/tutorial002.py hl[2,12:21,24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial002_py39.py hl[2, 12:21, 24] *}
/// tip | Astuce
-Si vous appelez manuellement `app.openapi()`, vous devez mettre à jour les `operationId` avant.
+Si vous appelez manuellement `app.openapi()`, vous devez mettre à jour les `operationId` avant cela.
///
/// warning | Attention
-Pour faire cela, vous devez vous assurer que chacun de vos *chemin* ait un nom unique.
+Si vous faites cela, vous devez vous assurer que chacune de vos *fonctions d'opération de chemin* a un nom unique.
-Même s'ils se trouvent dans des modules différents (fichiers Python).
+Même si elles se trouvent dans des modules différents (fichiers Python).
///
-## Exclusion d'OpenAPI
+## Exclure d'OpenAPI { #exclude-from-openapi }
-Pour exclure un *chemin* du schéma OpenAPI généré (et donc des systèmes de documentation automatiques), utilisez le paramètre `include_in_schema` et assignez-lui la valeur `False` :
+Pour exclure une *opération de chemin* du schéma OpenAPI généré (et donc des systèmes de documentation automatiques), utilisez le paramètre `include_in_schema` et assignez-lui la valeur `False` :
-{* ../../docs_src/path_operation_advanced_configuration/tutorial003.py hl[6] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial003_py39.py hl[6] *}
-## Description avancée de docstring
+## Description avancée depuis la docstring { #advanced-description-from-docstring }
-Vous pouvez limiter le texte utilisé de la docstring d'une *fonction de chemin* qui sera affiché sur OpenAPI.
+Vous pouvez limiter les lignes utilisées de la docstring d'une *fonction d'opération de chemin* pour OpenAPI.
-L'ajout d'un `\f` (un caractère d'échappement "form feed") va permettre à **FastAPI** de tronquer la sortie utilisée pour OpenAPI à ce stade.
+L'ajout d'un `\f` (un caractère d'échappement «form feed») fait que **FastAPI** tronque la sortie utilisée pour OpenAPI à cet endroit.
-Il n'apparaîtra pas dans la documentation, mais d'autres outils (tel que Sphinx) pourront utiliser le reste.
+Cela n'apparaîtra pas dans la documentation, mais d'autres outils (tels que Sphinx) pourront utiliser le reste.
-{* ../../docs_src/path_operation_advanced_configuration/tutorial004.py hl[19:29] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
-## Réponses supplémentaires
+## Réponses supplémentaires { #additional-responses }
Vous avez probablement vu comment déclarer le `response_model` et le `status_code` pour une *opération de chemin*.
-Cela définit les métadonnées sur la réponse principale d'une *opération de chemin*.
+Cela définit les métadonnées de la réponse principale d'une *opération de chemin*.
Vous pouvez également déclarer des réponses supplémentaires avec leurs modèles, codes de statut, etc.
-Il y a un chapitre entier ici dans la documentation à ce sujet, vous pouvez le lire sur [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Il y a un chapitre entier dans la documentation à ce sujet, vous pouvez le lire dans [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
-## OpenAPI supplémentaire
+## OpenAPI supplémentaire { #openapi-extra }
-Lorsque vous déclarez un *chemin* dans votre application, **FastAPI** génère automatiquement les métadonnées concernant ce *chemin* à inclure dans le schéma OpenAPI.
+Lorsque vous déclarez une *opération de chemin* dans votre application, **FastAPI** génère automatiquement les métadonnées pertinentes concernant cette *opération de chemin* à inclure dans le schéma OpenAPI.
/// note | Détails techniques
-La spécification OpenAPI appelle ces métadonnées des Objets d'opération.
+Dans la spécification OpenAPI, cela s'appelle l’Objet d'opération.
///
-Il contient toutes les informations sur le *chemin* et est utilisé pour générer automatiquement la documentation.
+Il contient toutes les informations sur l’*opération de chemin* et est utilisé pour générer automatiquement la documentation.
Il inclut les `tags`, `parameters`, `requestBody`, `responses`, etc.
-Ce schéma OpenAPI spécifique aux *operations* est normalement généré automatiquement par **FastAPI**, mais vous pouvez également l'étendre.
+Ce schéma OpenAPI spécifique à l’*opération de chemin* est normalement généré automatiquement par **FastAPI**, mais vous pouvez également l'étendre.
/// tip | Astuce
-Si vous avez seulement besoin de déclarer des réponses supplémentaires, un moyen plus pratique de le faire est d'utiliser les [réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Ceci est un point d'extension de bas niveau.
+
+Si vous avez seulement besoin de déclarer des réponses supplémentaires, un moyen plus pratique de le faire est d'utiliser [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
///
Vous pouvez étendre le schéma OpenAPI pour une *opération de chemin* en utilisant le paramètre `openapi_extra`.
-### Extensions OpenAPI
+### Extensions OpenAPI { #openapi-extensions }
-Cet `openapi_extra` peut être utile, par exemple, pour déclarer [OpenAPI Extensions](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions) :
+Cet `openapi_extra` peut être utile, par exemple, pour déclarer des [OpenAPI Extensions](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions) :
-{* ../../docs_src/path_operation_advanced_configuration/tutorial005.py hl[6] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial005_py39.py hl[6] *}
-Si vous ouvrez la documentation automatique de l'API, votre extension apparaîtra au bas du *chemin* spécifique.
+Si vous ouvrez la documentation automatique de l'API, votre extension apparaîtra en bas de l’*opération de chemin* spécifique.
-Et dans le fichier openapi généré (`/openapi.json`), vous verrez également votre extension dans le cadre du *chemin* spécifique :
+Et si vous regardez l’OpenAPI résultant (à `/openapi.json` dans votre API), vous verrez également votre extension dans le cadre de l’*opération de chemin* spécifique :
```JSON hl_lines="22"
{
- "openapi": "3.0.2",
+ "openapi": "3.1.0",
"info": {
"title": "FastAPI",
"version": "0.1.0"
@@ -127,44 +129,44 @@ Et dans le fichier openapi généré (`/openapi.json`), vous verrez également v
}
```
-### Personnalisation du Schéma OpenAPI pour un chemin
+### Schéma OpenAPI personnalisé pour une *opération de chemin* { #custom-openapi-path-operation-schema }
-Le dictionnaire contenu dans la variable `openapi_extra` sera fusionné avec le schéma OpenAPI généré automatiquement pour l'*opération de chemin*.
+Le dictionnaire dans `openapi_extra` sera fusionné en profondeur avec le schéma OpenAPI généré automatiquement pour l’*opération de chemin*.
Ainsi, vous pouvez ajouter des données supplémentaires au schéma généré automatiquement.
-Par exemple, vous pouvez décider de lire et de valider la requête avec votre propre code, sans utiliser les fonctionnalités automatiques de validation proposée par Pydantic, mais vous pouvez toujours définir la requête dans le schéma OpenAPI.
+Par exemple, vous pourriez décider de lire et de valider la requête avec votre propre code, sans utiliser les fonctionnalités automatiques de FastAPI avec Pydantic, mais vous pourriez quand même vouloir définir la requête dans le schéma OpenAPI.
Vous pouvez le faire avec `openapi_extra` :
-{* ../../docs_src/path_operation_advanced_configuration/tutorial006.py hl[20:37,39:40] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial006_py39.py hl[19:36, 39:40] *}
-Dans cet exemple, nous n'avons déclaré aucun modèle Pydantic. En fait, le corps de la requête n'est même pas parsé en tant que JSON, il est lu directement en tant que `bytes`, et la fonction `magic_data_reader()` serait chargé de l'analyser d'une manière ou d'une autre.
+Dans cet exemple, nous n'avons déclaré aucun modèle Pydantic. En fait, le corps de la requête n'est même pas parsé en tant que JSON, il est lu directement en tant que `bytes`, et la fonction `magic_data_reader()` serait chargée de l'analyser d'une manière ou d'une autre.
Néanmoins, nous pouvons déclarer le schéma attendu pour le corps de la requête.
-### Type de contenu OpenAPI personnalisé
+### Type de contenu OpenAPI personnalisé { #custom-openapi-content-type }
-En utilisant cette même astuce, vous pouvez utiliser un modèle Pydantic pour définir le schéma JSON qui est ensuite inclus dans la section de schéma OpenAPI personnalisée pour le *chemin* concerné.
+En utilisant cette même astuce, vous pourriez utiliser un modèle Pydantic pour définir le JSON Schema qui est ensuite inclus dans la section de schéma OpenAPI personnalisée pour l’*opération de chemin*.
-Et vous pouvez le faire même si le type de données dans la requête n'est pas au format JSON.
+Et vous pourriez le faire même si le type de données dans la requête n'est pas du JSON.
-Dans cet exemple, nous n'utilisons pas les fonctionnalités de FastAPI pour extraire le schéma JSON des modèles Pydantic ni la validation automatique pour JSON. En fait, nous déclarons le type de contenu de la requête en tant que YAML, et non JSON :
+Par exemple, dans cette application nous n'utilisons pas la fonctionnalité intégrée de FastAPI pour extraire le JSON Schema des modèles Pydantic ni la validation automatique pour JSON. En fait, nous déclarons le type de contenu de la requête comme YAML, et non JSON :
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[17:22,24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[15:20, 22] *}
-Néanmoins, bien que nous n'utilisions pas la fonctionnalité par défaut, nous utilisons toujours un modèle Pydantic pour générer manuellement le schéma JSON pour les données que nous souhaitons recevoir en YAML.
+Néanmoins, bien que nous n'utilisions pas la fonctionnalité intégrée par défaut, nous utilisons toujours un modèle Pydantic pour générer manuellement le JSON Schema pour les données que nous souhaitons recevoir en YAML.
-Ensuite, nous utilisons directement la requête et extrayons son contenu en tant qu'octets. Cela signifie que FastAPI n'essaiera même pas d'analyser le payload de la requête en tant que JSON.
+Ensuite, nous utilisons directement la requête et extrayons son corps en tant que `bytes`. Cela signifie que FastAPI n'essaiera même pas d'analyser le payload de la requête en tant que JSON.
-Et nous analysons directement ce contenu YAML, puis nous utilisons à nouveau le même modèle Pydantic pour valider le contenu YAML :
+Et puis, dans notre code, nous analysons directement ce contenu YAML, puis nous utilisons à nouveau le même modèle Pydantic pour valider le contenu YAML :
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[26:33] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}
/// tip | Astuce
Ici, nous réutilisons le même modèle Pydantic.
-Mais nous aurions pu tout aussi bien pu le valider d'une autre manière.
+Mais de la même manière, nous aurions tout aussi bien pu le valider autrement.
///
diff --git a/docs/fr/docs/advanced/response-directly.md b/docs/fr/docs/advanced/response-directly.md
index 4ff883c77..ac2730ec0 100644
--- a/docs/fr/docs/advanced/response-directly.md
+++ b/docs/fr/docs/advanced/response-directly.md
@@ -1,6 +1,6 @@
-# Renvoyer directement une réponse
+# Renvoyer directement une réponse { #return-a-response-directly }
-Lorsque vous créez une *opération de chemins* **FastAPI**, vous pouvez normalement retourner n'importe quelle donnée : un `dict`, une `list`, un modèle Pydantic, un modèle de base de données, etc.
+Lorsque vous créez une *opération de chemin* **FastAPI**, vous pouvez normalement retourner n'importe quelle donnée : un `dict`, une `list`, un modèle Pydantic, un modèle de base de données, etc.
Par défaut, **FastAPI** convertirait automatiquement cette valeur de retour en JSON en utilisant le `jsonable_encoder` expliqué dans [JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank}.
@@ -10,11 +10,11 @@ Mais vous pouvez retourner une `JSONResponse` directement à partir de vos *opé
Cela peut être utile, par exemple, pour retourner des en-têtes personnalisés ou des cookies.
-## Renvoyer une `Response`
+## Renvoyer une `Response` { #return-a-response }
En fait, vous pouvez retourner n'importe quelle `Response` ou n'importe quelle sous-classe de celle-ci.
-/// note | Remarque
+/// tip | Astuce
`JSONResponse` est elle-même une sous-classe de `Response`.
@@ -26,15 +26,15 @@ Elle ne fera aucune conversion de données avec les modèles Pydantic, elle ne c
Cela vous donne beaucoup de flexibilité. Vous pouvez retourner n'importe quel type de données, surcharger n'importe quelle déclaration ou validation de données.
-## Utiliser le `jsonable_encoder` dans une `Response`
+## Utiliser le `jsonable_encoder` dans une `Response` { #using-the-jsonable-encoder-in-a-response }
-Parce que **FastAPI** n'apporte aucune modification à une `Response` que vous retournez, vous devez vous assurer que son contenu est prêt à être utilisé (sérialisable).
+Parce que **FastAPI** n'apporte aucune modification à une `Response` que vous retournez, vous devez vous assurer que son contenu est prêt à être utilisé.
Par exemple, vous ne pouvez pas mettre un modèle Pydantic dans une `JSONResponse` sans d'abord le convertir en un `dict` avec tous les types de données (comme `datetime`, `UUID`, etc.) convertis en types compatibles avec JSON.
Pour ces cas, vous pouvez spécifier un appel à `jsonable_encoder` pour convertir vos données avant de les passer à une réponse :
-{* ../../docs_src/response_directly/tutorial001.py hl[6:7,21:22] *}
+{* ../../docs_src/response_directly/tutorial001_py310.py hl[5:6,20:21] *}
/// note | Détails techniques
@@ -44,7 +44,7 @@ Vous pouvez aussi utiliser `from starlette.responses import JSONResponse`.
///
-## Renvoyer une `Response` personnalisée
+## Renvoyer une `Response` personnalisée { #returning-a-custom-response }
L'exemple ci-dessus montre toutes les parties dont vous avez besoin, mais il n'est pas encore très utile, car vous auriez pu retourner l'`item` directement, et **FastAPI** l'aurait mis dans une `JSONResponse` pour vous, en le convertissant en `dict`, etc. Tout cela par défaut.
@@ -54,9 +54,9 @@ Disons que vous voulez retourner une réponse étant l'un des frameworks Python les plus rapides disponibles, seulement inférieur à Starlette et Uvicorn (tous deux utilisés au cœur de FastAPI). (*)
+Des tests de performance indépendants de TechEmpower montrent que les applications **FastAPI** exécutées sous Uvicorn sont parmi les frameworks Python les plus rapides disponibles, seulement derrière Starlette et Uvicorn eux‑mêmes (tous deux utilisés en interne par FastAPI).
-Mais en prêtant attention aux tests de performance et aux comparaisons, il faut tenir compte de ce qu'il suit.
+Mais lorsque vous examinez les tests de performance et les comparaisons, vous devez garder les points suivants à l'esprit.
-## Tests de performance et rapidité
+## Tests de performance et rapidité { #benchmarks-and-speed }
-Lorsque vous vérifiez les tests de performance, il est commun de voir plusieurs outils de différents types comparés comme équivalents.
+Lorsque vous vérifiez les tests de performance, il est courant de voir plusieurs outils de types différents comparés comme équivalents.
-En particulier, on voit Uvicorn, Starlette et FastAPI comparés (parmi de nombreux autres outils).
+En particulier, on voit Uvicorn, Starlette et FastAPI comparés ensemble (parmi de nombreux autres outils).
-Plus le problème résolu par un outil est simple, mieux seront les performances obtenues. Et la plupart des tests de performance ne prennent pas en compte les fonctionnalités additionnelles fournies par les outils.
+Plus le problème résolu par l’outil est simple, meilleures seront ses performances. Et la plupart des tests de performance ne testent pas les fonctionnalités additionnelles fournies par l’outil.
La hiérarchie est la suivante :
* **Uvicorn** : un serveur ASGI
- * **Starlette** : (utilise Uvicorn) un micro-framework web
- * **FastAPI**: (utilise Starlette) un micro-framework pour API disposant de fonctionnalités additionnelles pour la création d'API, avec la validation des données, etc.
+ * **Starlette** : (utilise Uvicorn) un microframework web
+ * **FastAPI** : (utilise Starlette) un microframework d’API avec plusieurs fonctionnalités supplémentaires pour créer des API, notamment la validation des données, etc.
* **Uvicorn** :
- * A les meilleures performances, étant donné qu'il n'a pas beaucoup de code mis-à-part le serveur en lui-même.
- * On n'écrit pas une application avec uniquement Uvicorn. Cela signifie que le code devrait inclure plus ou moins, au minimum, tout le code offert par Starlette (ou **FastAPI**). Et si on fait cela, l'application finale apportera les mêmes complications que si on avait utilisé un framework et que l'on avait minimisé la quantité de code et de bugs.
- * Si on compare Uvicorn, il faut le comparer à d'autre applications de serveurs comme Daphne, Hypercorn, uWSGI, etc.
+ * Aura la meilleure performance, car il n’a pas beaucoup de code supplémentaire en dehors du serveur lui‑même.
+ * Vous n’écririez pas une application directement avec Uvicorn. Cela signifierait que votre code devrait inclure, plus ou moins, au minimum, tout le code fourni par Starlette (ou **FastAPI**). Et si vous faisiez cela, votre application finale aurait la même surcharge que si vous aviez utilisé un framework, tout en minimisant le code de votre application et les bugs.
+ * Si vous comparez Uvicorn, comparez‑le à Daphne, Hypercorn, uWSGI, etc. Des serveurs d’applications.
* **Starlette** :
- * A les seconde meilleures performances après Uvicorn. Starlette utilise en réalité Uvicorn. De ce fait, il ne peut qu’être plus "lent" qu'Uvicorn car il requiert l'exécution de plus de code.
- * Cependant il nous apporte les outils pour construire une application web simple, avec un routage basé sur des chemins, etc.
- * Si on compare Starlette, il faut le comparer à d'autres frameworks web (ou micorframework) comme Sanic, Flask, Django, etc.
+ * Aura la deuxième meilleure performance, après Uvicorn. En fait, Starlette utilise Uvicorn pour s’exécuter. Donc, il ne peut probablement être que «plus lent» qu’Uvicorn, puisqu’il doit exécuter plus de code.
+ * Mais il fournit les outils pour construire des applications web simples, avec un routage basé sur les chemins, etc.
+ * Si vous comparez Starlette, comparez‑le à Sanic, Flask, Django, etc. Des frameworks web (ou microframeworks).
* **FastAPI** :
- * Comme Starlette, FastAPI utilise Uvicorn et ne peut donc pas être plus rapide que ce dernier.
- * FastAPI apporte des fonctionnalités supplémentaires à Starlette. Des fonctionnalités qui sont nécessaires presque systématiquement lors de la création d'une API, comme la validation des données, la sérialisation. En utilisant FastAPI, on obtient une documentation automatiquement (qui ne requiert aucune manipulation pour être mise en place).
- * Si on n'utilisait pas FastAPI mais directement Starlette (ou un outil équivalent comme Sanic, Flask, Responder, etc) il faudrait implémenter la validation des données et la sérialisation par nous-même. Le résultat serait donc le même dans les deux cas mais du travail supplémentaire serait à réaliser avec Starlette, surtout en considérant que la validation des données et la sérialisation représentent la plus grande quantité de code à écrire dans une application.
- * De ce fait, en utilisant FastAPI on minimise le temps de développement, les bugs, le nombre de lignes de code, et on obtient les mêmes performances (si ce n'est de meilleurs performances) que l'on aurait pu avoir sans ce framework (en ayant à implémenter de nombreuses fonctionnalités importantes par nous-mêmes).
- * Si on compare FastAPI, il faut le comparer à d'autres frameworks web (ou ensemble d'outils) qui fournissent la validation des données, la sérialisation et la documentation, comme Flask-apispec, NestJS, Molten, etc.
+ * De la même manière que Starlette utilise Uvicorn et ne peut pas être plus rapide que lui, **FastAPI** utilise Starlette, il ne peut donc pas être plus rapide que lui.
+ * FastAPI apporte davantage de fonctionnalités au‑dessus de Starlette. Des fonctionnalités dont vous avez presque toujours besoin lors de la création d’API, comme la validation des données et la sérialisation. Et en l’utilisant, vous obtenez gratuitement une documentation automatique (la documentation automatique n’ajoute même pas de surcharge aux applications en cours d’exécution, elle est générée au démarrage).
+ * Si vous n’utilisiez pas FastAPI et utilisiez directement Starlette (ou un autre outil, comme Sanic, Flask, Responder, etc.), vous devriez implémenter vous‑même toute la validation et la sérialisation des données. Ainsi, votre application finale aurait tout de même la même surcharge que si elle avait été construite avec FastAPI. Et, dans de nombreux cas, cette validation et cette sérialisation des données représentent la plus grande quantité de code écrite dans les applications.
+ * Donc, en utilisant FastAPI, vous gagnez du temps de développement, réduisez les bugs, diminuez le nombre de lignes de code, et vous obtiendrez probablement les mêmes performances (ou de meilleures) que si vous ne l’utilisiez pas (car vous auriez à tout implémenter dans votre code).
+ * Si vous comparez FastAPI, comparez‑le à un framework (ou un ensemble d’outils) d’applications web qui fournit la validation des données, la sérialisation et la documentation, comme Flask‑apispec, NestJS, Molten, etc. Des frameworks avec validation des données, sérialisation et documentation automatiques intégrées.
diff --git a/docs/fr/docs/deployment/docker.md b/docs/fr/docs/deployment/docker.md
index 05b597a2d..e3d1012bf 100644
--- a/docs/fr/docs/deployment/docker.md
+++ b/docs/fr/docs/deployment/docker.md
@@ -1,74 +1,151 @@
-# Déployer avec Docker
+# FastAPI dans des conteneurs - Docker { #fastapi-in-containers-docker }
-Dans cette section, vous verrez des instructions et des liens vers des guides pour savoir comment :
+Lors du déploiement d'applications FastAPI, une approche courante consiste à construire une **image de conteneur Linux**. C'est généralement fait avec **Docker**. Vous pouvez ensuite déployer cette image de conteneur de plusieurs manières possibles.
-* Faire de votre application **FastAPI** une image/conteneur Docker avec une performance maximale. En environ **5 min**.
-* (Optionnellement) comprendre ce que vous, en tant que développeur, devez savoir sur HTTPS.
-* Configurer un cluster en mode Docker Swarm avec HTTPS automatique, même sur un simple serveur à 5 dollars US/mois. En environ **20 min**.
-* Générer et déployer une application **FastAPI** complète, en utilisant votre cluster Docker Swarm, avec HTTPS, etc. En environ **10 min**.
-
-Vous pouvez utiliser **Docker** pour le déploiement. Il présente plusieurs avantages comme la sécurité, la réplicabilité, la simplicité de développement, etc.
-
-Si vous utilisez Docker, vous pouvez utiliser l'image Docker officielle :
-
-## tiangolo/uvicorn-gunicorn-fastapi
-
-Cette image est dotée d'un mécanisme d'"auto-tuning", de sorte qu'il vous suffit d'ajouter votre code pour obtenir automatiquement des performances très élevées. Et sans faire de sacrifices.
-
-Mais vous pouvez toujours changer et mettre à jour toutes les configurations avec des variables d'environnement ou des fichiers de configuration.
+L'utilisation de conteneurs Linux présente plusieurs avantages, notamment la **sécurité**, la **réplicabilité**, la **simplicité**, et d'autres.
/// tip | Astuce
-Pour voir toutes les configurations et options, rendez-vous sur la page de l'image Docker : tiangolo/uvicorn-gunicorn-fastapi.
+Pressé et vous connaissez déjà tout ça ? Passez au [`Dockerfile` ci-dessous 👇](#build-a-docker-image-for-fastapi).
///
-## Créer un `Dockerfile`
-
-* Allez dans le répertoire de votre projet.
-* Créez un `Dockerfile` avec :
+
+
+### Début de la poignée de main TLS { #tls-handshake-start }
+
+Le navigateur communiquerait ensuite avec cette adresse IP sur le **port 443** (le port HTTPS).
+
+La première partie de la communication consiste simplement à établir la connexion entre le client et le serveur et à décider des clés cryptographiques qu'ils utiliseront, etc.
+
+
+
+Cette interaction entre le client et le serveur pour établir la connexion TLS est appelée la **poignée de main TLS**.
+
+### TLS avec extension SNI { #tls-with-sni-extension }
+
+**Un seul processus** sur le serveur peut être à l'écoute d'un **port** spécifique sur une **adresse IP** spécifique. Il pourrait y avoir d'autres processus à l'écoute d'autres ports sur la même adresse IP, mais un seul pour chaque combinaison adresse IP/port.
+
+TLS (HTTPS) utilise par défaut le port spécifique `443`. C'est donc le port dont nous aurions besoin.
+
+Comme un seul processus peut écouter sur ce port, le processus qui le ferait serait le **proxy de terminaison TLS**.
+
+Le proxy de terminaison TLS aurait accès à un ou plusieurs **certificats TLS** (certificats HTTPS).
+
+En utilisant l'**extension SNI** évoquée ci-dessus, le proxy de terminaison TLS vérifierait lequel des certificats TLS (HTTPS) disponibles il doit utiliser pour cette connexion, en utilisant celui qui correspond au domaine attendu par le client.
+
+Dans ce cas, il utiliserait le certificat pour `someapp.example.com`.
+
+
+
+Le client **fait déjà confiance** à l'entité qui a généré ce certificat TLS (dans ce cas Let's Encrypt, mais nous verrons cela plus tard), il peut donc **vérifier** que le certificat est valide.
+
+Ensuite, en utilisant le certificat, le client et le proxy de terminaison TLS **décident comment chiffrer** le reste de la **communication TCP**. Cela complète la partie **poignée de main TLS**.
+
+Après cela, le client et le serveur ont une **connexion TCP chiffrée**, c'est ce que fournit TLS. Ils peuvent ensuite utiliser cette connexion pour démarrer la **communication HTTP** réelle.
+
+Et c'est ce qu'est **HTTPS** : c'est simplement du **HTTP** ordinaire à l'intérieur d'une **connexion TLS sécurisée** au lieu d'une connexion TCP pure (non chiffrée).
+
+/// tip | Astuce
+
+Remarquez que le chiffrement de la communication se fait au **niveau TCP**, pas au niveau HTTP.
+
+///
+
+### Requête HTTPS { #https-request }
+
+Maintenant que le client et le serveur (spécifiquement le navigateur et le proxy de terminaison TLS) ont une **connexion TCP chiffrée**, ils peuvent démarrer la **communication HTTP**.
+
+Ainsi, le client envoie une **requête HTTPS**. Il s'agit simplement d'une requête HTTP à travers une connexion TLS chiffrée.
+
+
+
+### Déchiffrer la requête { #decrypt-the-request }
+
+Le proxy de terminaison TLS utiliserait le chiffrement convenu pour **décrypter la requête**, et transmettrait la **requête HTTP en clair (décryptée)** au processus exécutant l'application (par exemple un processus avec Uvicorn exécutant l'application FastAPI).
+
+
+
+### Réponse HTTP { #http-response }
+
+L'application traiterait la requête et enverrait une **réponse HTTP en clair (non chiffrée)** au proxy de terminaison TLS.
+
+
+
+### Réponse HTTPS { #https-response }
+
+Le proxy de terminaison TLS **chiffrerait ensuite la réponse** en utilisant la cryptographie convenue précédemment (qui a commencé avec le certificat pour `someapp.example.com`), et la renverrait au navigateur.
+
+Ensuite, le navigateur vérifierait que la réponse est valide et chiffrée avec la bonne clé cryptographique, etc. Il **décrypterait la réponse** et la traiterait.
+
+
+
+Le client (navigateur) saura que la réponse provient du bon serveur parce qu'elle utilise la cryptographie convenue précédemment à l'aide du **certificat HTTPS**.
+
+### Applications multiples { #multiple-applications }
+
+Sur le même serveur (ou des serveurs), il peut y avoir **plusieurs applications**, par exemple d'autres programmes d'API ou une base de données.
+
+Un seul processus peut gérer l'IP et le port spécifiques (le proxy de terminaison TLS dans notre exemple), mais les autres applications/processus peuvent également s'exécuter sur le ou les serveurs, tant qu'ils n'essaient pas d'utiliser la même **combinaison d'IP publique et de port**.
+
+
+
+De cette façon, le proxy de terminaison TLS pourrait gérer HTTPS et les certificats pour **plusieurs domaines**, pour plusieurs applications, puis transmettre les requêtes à la bonne application dans chaque cas.
+
+### Renouvellement des certificats { #certificate-renewal }
+
+À un moment donné dans le futur, chaque certificat **expirera** (environ 3 mois après son acquisition).
+
+Ensuite, un autre programme (dans certains cas c'est un autre programme, dans d'autres cas cela peut être le même proxy de terminaison TLS) communiquerait avec Let's Encrypt et renouvellerait le ou les certificats.
+
+
+
+Les **certificats TLS** sont **associés à un nom de domaine**, pas à une adresse IP.
+
+Donc, pour renouveler les certificats, le programme de renouvellement doit **prouver** à l'autorité (Let's Encrypt) qu'il **«possède» et contrôle ce domaine**.
+
+Pour ce faire, et pour s'adapter aux différents besoins des applications, il existe plusieurs manières de procéder. Parmi les méthodes populaires :
+
+* **Modifier certains enregistrements DNS**.
+ * Pour cela, le programme de renouvellement doit prendre en charge les API du fournisseur DNS ; selon le fournisseur DNS que vous utilisez, cela peut être ou non une option.
+* **S'exécuter comme un serveur** (au moins pendant le processus d'acquisition du certificat) sur l'adresse IP publique associée au domaine.
+ * Comme nous l'avons dit plus haut, un seul processus peut écouter sur une adresse IP et un port spécifiques.
+ * C'est l'une des raisons pour lesquelles il est très utile que le même proxy de terminaison TLS s'occupe également du processus de renouvellement des certificats.
+ * Sinon, vous pourriez devoir arrêter momentanément le proxy de terminaison TLS, démarrer le programme de renouvellement pour acquérir les certificats, puis les configurer avec le proxy de terminaison TLS, et redémarrer ensuite le proxy de terminaison TLS. Ce n'est pas idéal, car votre/vos application(s) ne seront pas disponibles pendant le temps où le proxy de terminaison TLS est arrêté.
+
+Tout ce processus de renouvellement, tout en continuant à servir l'application, est l'une des principales raisons pour lesquelles vous voudriez avoir un **système séparé pour gérer HTTPS** avec un proxy de terminaison TLS au lieu d'utiliser directement les certificats TLS avec le serveur d'application (par ex. Uvicorn).
+
+## En-têtes transférés par le proxy { #proxy-forwarded-headers }
+
+Lorsque vous utilisez un proxy pour gérer HTTPS, votre **serveur d'application** (par exemple Uvicorn via FastAPI CLI) ne connaît rien du processus HTTPS, il communique en HTTP simple avec le **proxy de terminaison TLS**.
+
+Ce **proxy** définirait normalement certains en-têtes HTTP à la volée avant de transmettre la requête au **serveur d'application**, pour informer le serveur d'application que la requête est **transférée** par le proxy.
+
+/// note | Détails techniques
+
+Les en-têtes du proxy sont :
+
+* X-Forwarded-For
+* X-Forwarded-Proto
+* X-Forwarded-Host
+
+///
+
+Néanmoins, comme le **serveur d'application** ne sait pas qu'il est derrière un **proxy** de confiance, par défaut, il ne ferait pas confiance à ces en-têtes.
+
+Mais vous pouvez configurer le **serveur d'application** pour faire confiance aux en-têtes transférés envoyés par le **proxy**. Si vous utilisez FastAPI CLI, vous pouvez utiliser l’*option de CLI* `--forwarded-allow-ips` pour lui indiquer depuis quelles IP il doit faire confiance à ces en-têtes transférés.
+
+Par exemple, si le **serveur d'application** ne reçoit des communications que du **proxy** de confiance, vous pouvez définir `--forwarded-allow-ips="*"` pour le faire faire confiance à toutes les IP entrantes, puisqu'il ne recevra des requêtes que depuis l'IP utilisée par le **proxy**.
+
+Ainsi, l'application pourra savoir quelle est sa propre URL publique, si elle utilise HTTPS, le domaine, etc.
+
+Cela serait utile par exemple pour gérer correctement les redirections.
+
+/// tip | Astuce
+
+Vous pouvez en apprendre davantage dans la documentation [Derrière un proxy - Activer les en-têtes transférés par le proxy](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers){.internal-link target=_blank}
+
+///
+
+## Récapitulatif { #recap }
+
+Avoir **HTTPS** est très important, et assez **critique** dans la plupart des cas. La majeure partie de l'effort que vous, en tant que développeur, avez à fournir autour de HTTPS consiste simplement à **comprendre ces concepts** et leur fonctionnement.
+
+Mais une fois que vous connaissez les informations de base de **HTTPS pour les développeurs**, vous pouvez facilement combiner et configurer différents outils pour vous aider à tout gérer simplement.
+
+Dans certains des prochains chapitres, je vous montrerai plusieurs exemples concrets de configuration de **HTTPS** pour des applications **FastAPI**. 🔒
diff --git a/docs/fr/docs/deployment/index.md b/docs/fr/docs/deployment/index.md
index e2014afe9..bff632d15 100644
--- a/docs/fr/docs/deployment/index.md
+++ b/docs/fr/docs/deployment/index.md
@@ -1,28 +1,23 @@
-# Déploiement
+# Déploiement { #deployment }
Le déploiement d'une application **FastAPI** est relativement simple.
-## Que signifie le déploiement
+## Que signifie le déploiement { #what-does-deployment-mean }
-**Déployer** une application signifie effectuer les étapes nécessaires pour la rendre **disponible pour les
-utilisateurs**.
+**Déployer** une application signifie effectuer les étapes nécessaires pour la rendre **disponible pour les utilisateurs**.
-Pour une **API Web**, cela implique normalement de la placer sur une **machine distante**, avec un **programme serveur**
-qui offre de bonnes performances, une bonne stabilité, _etc._, afin que vos **utilisateurs** puissent **accéder** à
-l'application efficacement et sans interruption ni problème.
+Pour une **API Web**, cela implique normalement de la placer sur une **machine distante**, avec un **programme serveur** qui offre de bonnes performances, une bonne stabilité, _etc._, afin que vos **utilisateurs** puissent **accéder** à l'application efficacement et sans interruption ni problème.
-Ceci contraste avec les étapes de **développement**, où vous êtes constamment en train de modifier le code, de le casser
-et de le réparer, d'arrêter et de redémarrer le serveur de développement, _etc._
+Ceci contraste avec les étapes de **développement**, où vous êtes constamment en train de modifier le code, de le casser et de le réparer, d'arrêter et de redémarrer le serveur de développement, _etc._
-## Stratégies de déploiement
+## Stratégies de déploiement { #deployment-strategies }
-Il existe plusieurs façons de procéder, en fonction de votre cas d'utilisation spécifique et des outils que vous
-utilisez.
+Il existe plusieurs façons de procéder, en fonction de votre cas d'utilisation spécifique et des outils que vous utilisez.
-Vous pouvez **déployer un serveur** vous-même en utilisant une combinaison d'outils, vous pouvez utiliser un **service
-cloud** qui fait une partie du travail pour vous, ou encore d'autres options possibles.
+Vous pouvez **déployer un serveur** vous-même en utilisant une combinaison d'outils, vous pouvez utiliser un **service cloud** qui fait une partie du travail pour vous, ou encore d'autres options possibles.
-Je vais vous montrer certains des principaux concepts que vous devriez probablement avoir à l'esprit lors du déploiement
-d'une application **FastAPI** (bien que la plupart de ces concepts s'appliquent à tout autre type d'application web).
+Par exemple, nous, l'équipe derrière FastAPI, avons créé **FastAPI Cloud**, pour rendre le déploiement d'applications FastAPI dans le cloud aussi simple que possible, avec la même expérience développeur que lorsque vous travaillez avec FastAPI.
+
+Je vais vous montrer certains des principaux concepts que vous devriez probablement avoir à l'esprit lors du déploiement d'une application **FastAPI** (bien que la plupart de ces concepts s'appliquent à tout autre type d'application web).
Vous verrez plus de détails à avoir en tête et certaines des techniques pour le faire dans les sections suivantes. ✨
diff --git a/docs/fr/docs/deployment/versions.md b/docs/fr/docs/deployment/versions.md
index 9d84274e2..ce196438d 100644
--- a/docs/fr/docs/deployment/versions.md
+++ b/docs/fr/docs/deployment/versions.md
@@ -1,4 +1,4 @@
-# À propos des versions de FastAPI
+# À propos des versions de FastAPI { #about-fastapi-versions }
**FastAPI** est déjà utilisé en production dans de nombreuses applications et systèmes. Et la couverture de test est maintenue à 100 %. Mais son développement est toujours aussi rapide.
@@ -11,46 +11,46 @@ target="_blank">versionnage sémantique.
Vous pouvez créer des applications de production avec **FastAPI** dès maintenant (et vous le faites probablement depuis un certain temps), vous devez juste vous assurer que vous utilisez une version qui fonctionne correctement avec le reste de votre code.
-## Épinglez votre version de `fastapi`
+## Épinglez votre version de `fastapi` { #pin-your-fastapi-version }
-Tout d'abord il faut "épingler" la version de **FastAPI** que vous utilisez à la dernière version dont vous savez
+Tout d'abord il faut «épingler» la version de **FastAPI** que vous utilisez à la dernière version dont vous savez
qu'elle fonctionne correctement pour votre application.
-Par exemple, disons que vous utilisez la version `0.45.0` dans votre application.
+Par exemple, disons que vous utilisez la version `0.112.0` dans votre application.
Si vous utilisez un fichier `requirements.txt`, vous pouvez spécifier la version avec :
```txt
-fastapi==0.45.0
+fastapi[standard]==0.112.0
```
-ce qui signifierait que vous utiliseriez exactement la version `0.45.0`.
+ce qui signifierait que vous utiliseriez exactement la version `0.112.0`.
Ou vous pourriez aussi l'épingler avec :
```txt
-fastapi>=0.45.0,<0.46.0
+fastapi[standard]>=0.112.0,<0.113.0
```
-cela signifierait que vous utiliseriez les versions `0.45.0` ou supérieures, mais inférieures à `0.46.0`, par exemple, une version `0.45.2` serait toujours acceptée.
+cela signifierait que vous utiliseriez les versions `0.112.0` ou supérieures, mais inférieures à `0.113.0`, par exemple, une version `0.112.2` serait toujours acceptée.
-Si vous utilisez un autre outil pour gérer vos installations, comme Poetry, Pipenv, ou autres, ils ont tous un moyen que vous pouvez utiliser pour définir des versions spécifiques pour vos paquets.
+Si vous utilisez un autre outil pour gérer vos installations, comme `uv`, Poetry, Pipenv, ou autres, ils ont tous un moyen que vous pouvez utiliser pour définir des versions spécifiques pour vos paquets.
-## Versions disponibles
+## Versions disponibles { #available-versions }
Vous pouvez consulter les versions disponibles (par exemple, pour vérifier quelle est la dernière version en date) dans les [Notes de version](../release-notes.md){.internal-link target=_blank}.
-## À propos des versions
+## À propos des versions { #about-versions }
Suivant les conventions de versionnage sémantique, toute version inférieure à `1.0.0` peut potentiellement ajouter
des changements non rétrocompatibles.
-FastAPI suit également la convention que tout changement de version "PATCH" est pour des corrections de bogues et
+FastAPI suit également la convention que tout changement de version «PATCH» est pour des corrections de bogues et
des changements rétrocompatibles.
/// tip | Astuce
-Le "PATCH" est le dernier chiffre, par exemple, dans `0.2.3`, la version PATCH est `3`.
+Le «PATCH» est le dernier chiffre, par exemple, dans `0.2.3`, la version PATCH est `3`.
///
@@ -60,26 +60,26 @@ Donc, vous devriez être capable d'épingler une version comme suit :
fastapi>=0.45.0,<0.46.0
```
-Les changements non rétrocompatibles et les nouvelles fonctionnalités sont ajoutés dans les versions "MINOR".
+Les changements non rétrocompatibles et les nouvelles fonctionnalités sont ajoutés dans les versions «MINOR».
/// tip | Astuce
-Le "MINOR" est le numéro au milieu, par exemple, dans `0.2.3`, la version MINOR est `2`.
+Le «MINOR» est le numéro au milieu, par exemple, dans `0.2.3`, la version MINOR est `2`.
///
-## Mise à jour des versions FastAPI
+## Mettre à niveau les versions de FastAPI { #upgrading-the-fastapi-versions }
-Vous devriez tester votre application.
+Vous devriez ajouter des tests pour votre application.
-Avec **FastAPI** c'est très facile (merci à Starlette), consultez la documentation : [Testing](../tutorial/testing.md){.internal-link target=_blank}
+Avec **FastAPI** c'est très facile (merci à Starlette), consultez la documentation : [Tests](../tutorial/testing.md){.internal-link target=_blank}
-Après avoir effectué des tests, vous pouvez mettre à jour la version **FastAPI** vers une version plus récente, et vous assurer que tout votre code fonctionne correctement en exécutant vos tests.
+Après avoir effectué des tests, vous pouvez mettre à niveau la version de **FastAPI** vers une version plus récente, et vous assurer que tout votre code fonctionne correctement en exécutant vos tests.
Si tout fonctionne, ou après avoir fait les changements nécessaires, et que tous vos tests passent, vous pouvez
épingler votre version de `fastapi` à cette nouvelle version récente.
-## À propos de Starlette
+## À propos de Starlette { #about-starlette }
Vous ne devriez pas épingler la version de `starlette`.
@@ -87,15 +87,15 @@ Différentes versions de **FastAPI** utiliseront une version spécifique plus r
Ainsi, vous pouvez simplement laisser **FastAPI** utiliser la bonne version de Starlette.
-## À propos de Pydantic
+## À propos de Pydantic { #about-pydantic }
Pydantic inclut des tests pour **FastAPI** avec ses propres tests, ainsi les nouvelles versions de Pydantic (au-dessus
de `1.0.0`) sont toujours compatibles avec **FastAPI**.
-Vous pouvez épingler Pydantic à toute version supérieure à `1.0.0` qui fonctionne pour vous et inférieure à `2.0.0`.
+Vous pouvez épingler Pydantic à toute version supérieure à `1.0.0` qui fonctionne pour vous.
Par exemple :
```txt
-pydantic>=1.2.0,<2.0.0
+pydantic>=2.7.0,<3.0.0
```
diff --git a/docs/fr/docs/index.md b/docs/fr/docs/index.md
index 99ea8dda1..f02c37e13 100644
--- a/docs/fr/docs/index.md
+++ b/docs/fr/docs/index.md
@@ -1,11 +1,11 @@
-# FastAPI
+# FastAPI { #fastapi }
-
+
Framework FastAPI, haute performance, facile à apprendre, rapide à coder, prêt pour la production
@@ -27,134 +27,132 @@
---
-**Documentation** : https://fastapi.tiangolo.com
+**Documentation** : https://fastapi.tiangolo.com/fr
-**Code Source** : https://github.com/fastapi/fastapi
+**Code source** : https://github.com/fastapi/fastapi
---
-FastAPI est un framework web moderne et rapide (haute performance) pour la création d'API avec Python, basé sur les annotations de type standard de Python.
+FastAPI est un framework web moderne et rapide (haute performance) pour la création d’API avec Python, basé sur les annotations de type standard de Python.
Les principales fonctionnalités sont :
-* **Rapidité** : De très hautes performances, au niveau de **NodeJS** et **Go** (grâce à Starlette et Pydantic). [L'un des frameworks Python les plus rapides](#performance).
-* **Rapide à coder** : Augmente la vitesse de développement des fonctionnalités d'environ 200 % à 300 %. *
-* **Moins de bugs** : Réduit d'environ 40 % les erreurs induites par le développeur. *
-* **Intuitif** : Excellente compatibilité avec les IDE. Complétion complète. Moins de temps passé à déboguer.
+* **Rapide** : Très hautes performances, au niveau de **NodeJS** et **Go** (grâce à Starlette et Pydantic). [L’un des frameworks Python les plus rapides](#performance).
+* **Rapide à coder** : Augmente la vitesse de développement des fonctionnalités d’environ 200 % à 300 %. *
+* **Moins de bugs** : Réduit d’environ 40 % les erreurs induites par le développeur. *
+* **Intuitif** : Excellente prise en charge par les éditeurs. Complétion partout. Moins de temps passé à déboguer.
* **Facile** : Conçu pour être facile à utiliser et à apprendre. Moins de temps passé à lire la documentation.
-* **Concis** : Diminue la duplication de code. De nombreuses fonctionnalités liées à la déclaration de chaque paramètre. Moins de bugs.
-* **Robuste** : Obtenez un code prêt pour la production. Avec une documentation interactive automatique.
-* **Basé sur des normes** : Basé sur (et entièrement compatible avec) les standards ouverts pour les APIs : OpenAPI (précédemment connu sous le nom de Swagger) et JSON Schema.
+* **Concis** : Minimise la duplication de code. Plusieurs fonctionnalités à partir de chaque déclaration de paramètre. Moins de bugs.
+* **Robuste** : Obtenez du code prêt pour la production. Avec une documentation interactive automatique.
+* **Basé sur des standards** : Basé sur (et entièrement compatible avec) les standards ouverts pour les API : OpenAPI (anciennement connu sous le nom de Swagger) et JSON Schema.
-* estimation basée sur des tests d'une équipe de développement interne, construisant des applications de production.
+* estimation basée sur des tests d’une équipe de développement interne, construisant des applications de production.
-## Sponsors
+## Sponsors { #sponsors }
-{% if sponsors %}
+### Sponsor clé de voûte { #keystone-sponsor }
+
+{% for sponsor in sponsors.keystone -%}
+
+{% endfor -%}
+
+### Sponsors Or et Argent { #gold-and-silver-sponsors }
+
{% for sponsor in sponsors.gold -%}
{% endfor -%}
{%- for sponsor in sponsors.silver -%}
{% endfor %}
-{% endif %}
-Other sponsors
+Autres sponsors
-## Opinions
+## Opinions { #opinions }
-"_[...] J'utilise beaucoup **FastAPI** ces derniers temps. [...] Je prévois de l'utiliser dans mon équipe pour tous les **services de ML chez Microsoft**. Certains d'entre eux seront intégrés dans le coeur de **Windows** et dans certains produits **Office**._"
+«_[...] J’utilise beaucoup **FastAPI** ces derniers temps. [...] Je prévois de l’utiliser dans mon équipe pour tous les **services de ML chez Microsoft**. Certains d’entre eux seront intégrés dans le cœur de **Windows** et dans certains produits **Office**._»
-Si vous souhaitez construire une application CLI utilisable dans un terminal au lieu d'une API web, regardez **Typer**.
+Si vous souhaitez construire une application CLI utilisable dans un terminal au lieu d’une API web, regardez **Typer**.
-**Typer** est le petit frère de FastAPI. Et il est destiné à être le **FastAPI des CLI**. ⌨️ 🚀
+**Typer** est le petit frère de FastAPI. Et il est destiné à être le **FastAPI des CLI**. ⌨️ 🚀
-## Prérequis
+## Prérequis { #requirements }
FastAPI repose sur les épaules de géants :
* Starlette pour les parties web.
* Pydantic pour les parties données.
-## Installation
+## Installation { #installation }
+
+Créez et activez un environnement virtuel puis installez FastAPI :
async def ...async def...uvicorn main:app --reload ...fastapi dev main.py...email-validator - pour la validation des adresses email.
+### Dépendances `standard` { #standard-dependencies }
+
+Lorsque vous installez FastAPI avec `pip install "fastapi[standard]"`, cela inclut le groupe `standard` de dépendances optionnelles :
+
+Utilisées par Pydantic :
+
+* email-validator — pour la validation des adresses email.
Utilisées par Starlette :
-* requests - Obligatoire si vous souhaitez utiliser `TestClient`.
-* jinja2 - Obligatoire si vous souhaitez utiliser la configuration de template par défaut.
-* python-multipart - Obligatoire si vous souhaitez supporter le "décodage" de formulaire avec `request.form()`.
-* itsdangerous - Obligatoire pour la prise en charge de `SessionMiddleware`.
-* pyyaml - Obligatoire pour le support `SchemaGenerator` de Starlette (vous n'en avez probablement pas besoin avec FastAPI).
+* httpx — requis si vous souhaitez utiliser `TestClient`.
+* jinja2 — requis si vous souhaitez utiliser la configuration de template par défaut.
+* python-multipart — requis si vous souhaitez prendre en charge l’«décodage» de formulaires avec `request.form()`.
-Utilisées par FastAPI / Starlette :
+Utilisées par FastAPI :
-* uvicorn - Pour le serveur qui charge et sert votre application.
-* orjson - Obligatoire si vous voulez utiliser `ORJSONResponse`.
-* ujson - Obligatoire si vous souhaitez utiliser `UJSONResponse`.
+* uvicorn — pour le serveur qui charge et sert votre application. Cela inclut `uvicorn[standard]`, qui comprend certaines dépendances (par ex. `uvloop`) nécessaires pour un service à 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.
-Vous pouvez tout installer avec `pip install fastapi[all]`.
+### Sans dépendances `standard` { #without-standard-dependencies }
-## Licence
+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]"`.
+
+### 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]"`.
+
+### Autres dépendances optionnelles { #additional-optional-dependencies }
+
+Il existe des dépendances supplémentaires que vous pourriez vouloir installer.
+
+Dépendances optionnelles supplémentaires pour Pydantic :
+
+* pydantic-settings — pour la gestion des paramètres.
+* pydantic-extra-types — pour des types supplémentaires à utiliser avec Pydantic.
+
+Dépendances optionnelles supplémentaires pour FastAPI :
+
+* orjson — requis si vous souhaitez utiliser `ORJSONResponse`.
+* ujson — requis si vous souhaitez utiliser `UJSONResponse`.
+
+## Licence { #license }
Ce projet est soumis aux termes de la licence MIT.
diff --git a/docs/fr/docs/learn/index.md b/docs/fr/docs/learn/index.md
index 46fc095dc..e74a53985 100644
--- a/docs/fr/docs/learn/index.md
+++ b/docs/fr/docs/learn/index.md
@@ -1,4 +1,4 @@
-# Apprendre
+# Apprendre { #learn }
Voici les sections introductives et les tutoriels pour apprendre **FastAPI**.
diff --git a/docs/fr/docs/project-generation.md b/docs/fr/docs/project-generation.md
index 4c04dc167..9a614f640 100644
--- a/docs/fr/docs/project-generation.md
+++ b/docs/fr/docs/project-generation.md
@@ -1,84 +1,28 @@
-# Génération de projets - Modèle
+# Modèle Full Stack FastAPI { #full-stack-fastapi-template }
-Vous pouvez utiliser un générateur de projet pour commencer, qui réalisera pour vous la mise en place de bases côté architecture globale, sécurité, base de données et premières routes d'API.
+Bien qu'ils soient généralement livrés avec une configuration spécifique, les modèles sont conçus pour être flexibles et personnalisables. Cela vous permet de les modifier et de les adapter aux besoins de votre projet, ce qui en fait un excellent point de départ. 🏁
-Un générateur de projet fera toujours une mise en place très subjective que vous devriez modifier et adapter suivant vos besoins, mais cela reste un bon point de départ pour vos projets.
+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.
-## Full Stack FastAPI PostgreSQL
+Dépôt GitHub : Full Stack FastAPI Template
-GitHub : https://github.com/tiangolo/full-stack-fastapi-postgresql
+## Modèle Full Stack FastAPI - Stack technologique et fonctionnalités { #full-stack-fastapi-template-technology-stack-and-features }
-### Full Stack FastAPI PostgreSQL - Fonctionnalités
-
-* Intégration **Docker** complète (basée sur Docker).
-* Déploiement Docker en mode Swarm
-* Intégration **Docker Compose** et optimisation pour développement local.
-* Serveur web Python **prêt au déploiement** utilisant Uvicorn et Gunicorn.
-* Backend Python **FastAPI** :
- * **Rapide** : Très hautes performances, comparables à **NodeJS** ou **Go** (grâce à Starlette et Pydantic).
- * **Intuitif** : Excellent support des éditeurs. Complétion partout. Moins de temps passé à déboguer.
- * **Facile** : Fait pour être facile à utiliser et apprendre. Moins de temps passé à lire de la documentation.
- * **Concis** : Minimise la duplication de code. Plusieurs fonctionnalités à chaque déclaration de paramètre.
- * **Robuste** : Obtenez du code prêt pour être utilisé en production. Avec de la documentation automatique interactive.
- * **Basé sur des normes** : Basé sur (et totalement compatible avec) les normes ouvertes pour les APIs : OpenAPI et JSON Schema.
- * **Et bien d'autres fonctionnalités** comme la validation automatique, la sérialisation, l'authentification avec OAuth2 JWT tokens, etc.
-* Hashage de **mots de passe sécurisé** par défaut.
-* Authentification par **jetons JWT**.
-* Modèles **SQLAlchemy** (indépendants des extensions Flask, afin qu'ils puissent être utilisés directement avec des *workers* Celery).
-* Modèle de démarrages basiques pour les utilisateurs (à modifier et supprimer au besoin).
-* Migrations **Alembic**.
-* **CORS** (partage des ressources entre origines multiples, ou *Cross Origin Resource Sharing*).
-* *Worker* **Celery** pouvant importer et utiliser les modèles et le code du reste du backend.
-* Tests du backend REST basés sur **Pytest**, intégrés dans Docker, pour que vous puissiez tester toutes les interactions de l'API indépendamment de la base de données. Étant exécutés dans Docker, les tests peuvent utiliser un nouvel entrepôt de données créé de zéro à chaque fois (vous pouvez donc utiliser ElasticSearch, MongoDB, CouchDB, etc. et juste tester que l'API fonctionne).
-* Intégration Python facile avec **Jupyter Kernels** pour le développement à distance ou intra-Docker avec des extensions comme Atom Hydrogen ou Visual Studio Code Jupyter.
-* Frontend **Vue** :
- * Généré avec Vue CLI.
- * Gestion de l'**Authentification JWT**.
- * Page de connexion.
- * Après la connexion, page de tableau de bord principal.
- * Tableau de bord principal avec création et modification d'utilisateurs.
- * Modification de ses propres caractéristiques utilisateur.
- * **Vuex**.
- * **Vue-router**.
- * **Vuetify** pour de magnifiques composants *material design*.
- * **TypeScript**.
- * Serveur Docker basé sur **Nginx** (configuré pour être facilement manipulé avec Vue-router).
- * Utilisation de *Docker multi-stage building*, pour ne pas avoir besoin de sauvegarder ou *commit* du code compilé.
- * Tests frontend exécutés à la compilation (pouvant être désactivés).
- * Fait aussi modulable que possible, pour pouvoir fonctionner comme tel, tout en pouvant être utilisé qu'en partie grâce à Vue CLI.
-* **PGAdmin** pour les bases de données PostgreSQL, facilement modifiable pour utiliser PHPMYAdmin ou MySQL.
-* **Flower** pour la surveillance de tâches Celery.
-* Équilibrage de charge entre le frontend et le backend avec **Traefik**, afin de pouvoir avoir les deux sur le même domaine, séparés par chemins, mais servis par différents conteneurs.
-* Intégration Traefik, comprenant la génération automatique de certificat **HTTPS** Let's Encrypt.
-* GitLab **CI** (intégration continue), comprenant des tests pour le frontend et le backend.
-
-## Full Stack FastAPI Couchbase
-
-GitHub : https://github.com/tiangolo/full-stack-fastapi-couchbase
-
-⚠️ **ATTENTION** ⚠️
-
-Si vous démarrez un nouveau projet de zéro, allez voir les alternatives au début de cette page.
-
-Par exemple, le générateur de projet Full Stack FastAPI PostgreSQL peut être une meilleure alternative, étant activement maintenu et utilisé et comprenant toutes les nouvelles fonctionnalités et améliorations.
-
-Vous êtes toujours libre d'utiliser le générateur basé sur Couchbase si vous le voulez, cela devrait probablement fonctionner correctement, et si vous avez déjà un projet généré en utilisant ce dernier, cela devrait fonctionner aussi (et vous l'avez déjà probablement mis à jour suivant vos besoins).
-
-Vous pouvez en apprendre plus dans la documentation du dépôt GithHub.
-
-## Full Stack FastAPI MongoDB
-
-...viendra surement plus tard, suivant le temps que j'ai. 😅 🎉
-
-## Modèles d'apprentissage automatique avec spaCy et FastAPI
-
-GitHub : https://github.com/microsoft/cookiecutter-spacy-fastapi
-
-## Modèles d'apprentissage automatique avec spaCy et FastAPI - Fonctionnalités
-
-* Intégration d'un modèle NER **spaCy**.
-* Formatage de requête pour **Azure Cognitive Search**.
-* Serveur Python web **prêt à utiliser en production** utilisant Uvicorn et Gunicorn.
-* Déploiement CI/CD Kubernetes pour **Azure DevOps** (AKS).
-* **Multilangues**. Choisissez facilement l'une des langues intégrées à spaCy durant la mise en place du projet.
-* **Facilement généralisable** à d'autres bibliothèques similaires (Pytorch, Tensorflow), et non juste spaCy.
+- ⚡ [**FastAPI**](https://fastapi.tiangolo.com/fr) pour l'API backend Python.
+ - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) pour les interactions Python avec la base de données SQL (ORM).
+ - 🔍 [Pydantic](https://docs.pydantic.dev), 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'une stack frontend moderne.
+ - 🎨 [Tailwind CSS](https://tailwindcss.com) et [shadcn/ui](https://ui.shadcn.com) pour les composants frontend.
+ - 🤖 Un client frontend généré automatiquement.
+ - 🧪 [Playwright](https://playwright.dev) pour les tests de bout en bout.
+ - 🦇 Prise en charge du mode sombre.
+- 🐋 [Docker Compose](https://www.docker.com) pour le développement et la production.
+- 🔒 Hachage sécurisé des mots de passe par défaut.
+- 🔑 Authentification JWT (JSON Web Token).
+- 📫 Récupération de mot de passe par e-mail.
+- ✅ Tests avec [Pytest](https://pytest.org).
+- 📞 [Traefik](https://traefik.io) comme proxy inverse / équilibreur de charge.
+- 🚢 Instructions de déploiement avec Docker Compose, y compris la configuration d'un proxy Traefik en frontal pour gérer les certificats HTTPS automatiques.
+- 🏭 CI (intégration continue) et CD (déploiement continu) basées sur GitHub Actions.
diff --git a/docs/fr/docs/python-types.md b/docs/fr/docs/python-types.md
index 99ca90827..a4155b4b1 100644
--- a/docs/fr/docs/python-types.md
+++ b/docs/fr/docs/python-types.md
@@ -1,70 +1,68 @@
-# Introduction aux Types Python
+# Introduction aux types Python { #python-types-intro }
-Python supporte des annotations de type (ou *type hints*) optionnelles.
+Python prend en charge des «type hints» (également appelées «annotations de type») optionnels.
-Ces annotations de type constituent une syntaxe spéciale qui permet de déclarer le type d'une variable.
+Ces **«type hints»** ou annotations sont une syntaxe spéciale qui permet de déclarer le type d'une variable.
-En déclarant les types de vos variables, cela permet aux différents outils comme les éditeurs de texte d'offrir un meilleur support.
+En déclarant des types pour vos variables, les éditeurs et les outils peuvent vous offrir un meilleur support.
-Ce chapitre n'est qu'un **tutoriel rapide / rappel** sur les annotations de type Python.
-Seulement le minimum nécessaire pour les utiliser avec **FastAPI** sera couvert... ce qui est en réalité très peu.
+Il s'agit d'un **tutoriel rapide / rappel** sur les «type hints» Python. Il ne couvre que le minimum nécessaire pour les utiliser avec **FastAPI** ... ce qui est en réalité très peu.
-**FastAPI** est totalement basé sur ces annotations de type, qui lui donnent de nombreux avantages.
+**FastAPI** est entièrement basé sur ces «type hints», qui lui apportent de nombreux avantages et bénéfices.
-Mais même si vous n'utilisez pas ou n'utiliserez jamais **FastAPI**, vous pourriez bénéficier d'apprendre quelques choses sur ces dernières.
+Mais même si vous n'utilisez jamais **FastAPI**, vous auriez intérêt à en apprendre un peu à leur sujet.
-/// note
+/// note | Remarque
-Si vous êtes un expert Python, et que vous savez déjà **tout** sur les annotations de type, passez au chapitre suivant.
+Si vous êtes un expert Python et que vous savez déjà tout sur les «type hints», passez au chapitre suivant.
///
-## Motivations
+## Motivation { #motivation }
-Prenons un exemple simple :
+Commençons par un exemple simple :
-{*../../docs_src/python_types/tutorial001.py*}
+{* ../../docs_src/python_types/tutorial001_py39.py *}
-Exécuter ce programe affiche :
+Exécuter ce programme affiche :
```
John Doe
```
-La fonction :
+La fonction fait ce qui suit :
* Prend un `first_name` et un `last_name`.
-* Convertit la première lettre de chaque paramètre en majuscules grâce à `title()`.
-* Concatène les résultats avec un espace entre les deux.
+* Convertit la première lettre de chacun en majuscule avec `title()`.
+* Concatène les deux avec un espace au milieu.
-{*../../docs_src/python_types/tutorial001.py hl[2] *}
+{* ../../docs_src/python_types/tutorial001_py39.py hl[2] *}
-### Limitations
+### Modifiez-le { #edit-it }
C'est un programme très simple.
-Mais maintenant imaginez que vous l'écriviez de zéro.
+Mais maintenant, imaginez que vous l'écriviez à partir de zéro.
-À un certain point vous auriez commencé la définition de la fonction, vous aviez les paramètres prêts.
+À un certain moment, vous auriez commencé la définition de la fonction, vous aviez les paramètres prêts...
-Mais vous aviez besoin de "cette méthode qui convertit la première lettre en majuscule".
+Mais ensuite, vous devez appeler «cette méthode qui convertit la première lettre en majuscule».
-Était-ce `upper` ? `uppercase` ? `first_uppercase` ? `capitalize` ?
+Était-ce `upper` ? Était-ce `uppercase` ? `first_uppercase` ? `capitalize` ?
-Vous essayez donc d'utiliser le vieil ami du programmeur, l'auto-complétion de l'éditeur.
+Alors, vous essayez l'ami de toujours du programmeur : l'autocomplétion de l'éditeur.
-Vous écrivez le premier paramètre, `first_name`, puis un point (`.`) et appuyez sur `Ctrl+Espace` pour déclencher l'auto-complétion.
+Vous saisissez le premier paramètre de la fonction, `first_name`, puis un point (`.`) et appuyez sur `Ctrl+Espace` pour déclencher l'autocomplétion.
-Mais malheureusement, rien d'utile n'en résulte :
+Mais, malheureusement, vous n'obtenez rien d'utile :
-### Ajouter des types
+### Ajouter des types { #add-types }
-Modifions une seule ligne de la version précédente.
-
-Nous allons changer seulement cet extrait, les paramètres de la fonction, de :
+Modifions une seule ligne par rapport à la version précédente.
+Nous allons changer exactement ce fragment, les paramètres de la fonction, de :
```Python
first_name, last_name
@@ -78,222 +76,389 @@ Nous allons changer seulement cet extrait, les paramètres de la fonction, de :
C'est tout.
-Ce sont des annotations de types :
+Ce sont les «type hints» :
-{*../../docs_src/python_types/tutorial002.py hl[1] *}
+{* ../../docs_src/python_types/tutorial002_py39.py hl[1] *}
-À ne pas confondre avec la déclaration de valeurs par défaut comme ici :
+Ce n'est pas la même chose que de déclarer des valeurs par défaut comme on le ferait avec :
```Python
first_name="john", last_name="doe"
```
-C'est une chose différente.
+C'est différent.
-On utilise un deux-points (`:`), et pas un égal (`=`).
+Nous utilisons des deux-points (`:`), pas des signes égal (`=`).
-Et ajouter des annotations de types ne crée normalement pas de différence avec le comportement qui aurait eu lieu si elles n'étaient pas là.
+Et ajouter des «type hints» ne change normalement pas ce qui se passe par rapport à ce qui se passerait sans eux.
-Maintenant, imaginez que vous êtes en train de créer cette fonction, mais avec des annotations de type cette fois.
+Mais maintenant, imaginez que vous êtes à nouveau en train de créer cette fonction, mais avec des «type hints».
-Au même moment que durant l'exemple précédent, vous essayez de déclencher l'auto-complétion et vous voyez :
+Au même moment, vous essayez de déclencher l'autocomplétion avec `Ctrl+Espace` et vous voyez :
-Vous pouvez donc dérouler les options jusqu'à trouver la méthode à laquelle vous pensiez.
+Avec cela, vous pouvez faire défiler, voir les options, jusqu'à trouver celle qui «vous dit quelque chose» :
-## Plus de motivations
+## Plus de motivations { #more-motivation }
-Cette fonction possède déjà des annotations de type :
+Regardez cette fonction, elle a déjà des «type hints» :
-{*../../docs_src/python_types/tutorial003.py hl[1] *}
+{* ../../docs_src/python_types/tutorial003_py39.py hl[1] *}
-Comme l'éditeur connaît le type des variables, vous n'avez pas seulement l'auto-complétion, mais aussi de la détection d'erreurs :
+Comme l'éditeur connaît les types des variables, vous n'obtenez pas seulement l'autocomplétion, vous bénéficiez également de vérifications d'erreurs :
-Maintenant que vous avez connaissance du problème, convertissez `age` en chaîne de caractères grâce à `str(age)` :
+Maintenant vous savez qu'il faut corriger, convertir `age` en chaîne avec `str(age)` :
-{*../../docs_src/python_types/tutorial004.py hl[2] *}
+{* ../../docs_src/python_types/tutorial004_py39.py hl[2] *}
-## Déclarer des types
+## Déclarer des types { #declaring-types }
-Vous venez de voir là où les types sont généralement déclarés : dans les paramètres de fonctions.
+Vous venez de voir l'endroit principal où déclarer des «type hints» : en tant que paramètres de fonctions.
-C'est aussi ici que vous les utiliseriez avec **FastAPI**.
+C'est aussi l'endroit principal où vous les utiliserez avec **FastAPI**.
-### Types simples
+### Types simples { #simple-types }
-Vous pouvez déclarer tous les types de Python, pas seulement `str`.
+Vous pouvez déclarer tous les types standards de Python, pas seulement `str`.
-Comme par exemple :
+Vous pouvez utiliser, par exemple :
* `int`
* `float`
* `bool`
* `bytes`
-{*../../docs_src/python_types/tutorial005.py hl[1] *}
+{* ../../docs_src/python_types/tutorial005_py39.py hl[1] *}
-### Types génériques avec des paramètres de types
+### Types génériques avec paramètres de type { #generic-types-with-type-parameters }
-Il existe certaines structures de données qui contiennent d'autres valeurs, comme `dict`, `list`, `set` et `tuple`. Et les valeurs internes peuvent elles aussi avoir leurs propres types.
+Il existe des structures de données qui peuvent contenir d'autres valeurs, comme `dict`, `list`, `set` et `tuple`. Et les valeurs internes peuvent, elles aussi, avoir leur propre type.
-Pour déclarer ces types et les types internes, on utilise le module standard de Python `typing`.
+Ces types qui ont des types internes sont appelés types «génériques». Et il est possible de les déclarer, même avec leurs types internes.
-Il existe spécialement pour supporter ces annotations de types.
+Pour déclarer ces types et leurs types internes, vous pouvez utiliser le module standard Python `typing`. Il existe précisément pour prendre en charge ces «type hints».
-#### `List`
+#### Versions plus récentes de Python { #newer-versions-of-python }
-Par exemple, définissons une variable comme `list` de `str`.
+La syntaxe utilisant `typing` est compatible avec toutes les versions, de Python 3.6 aux plus récentes, y compris Python 3.9, Python 3.10, etc.
-Importez `List` (avec un `L` majuscule) depuis `typing`.
+Au fur et à mesure que Python évolue, les versions plus récentes offrent un meilleur support pour ces annotations de type et, dans de nombreux cas, vous n'aurez même pas besoin d'importer et d'utiliser le module `typing` pour déclarer les annotations de type.
-{*../../docs_src/python_types/tutorial006.py hl[1] *}
+Si vous pouvez choisir une version plus récente de Python pour votre projet, vous pourrez profiter de cette simplicité supplémentaire.
-Déclarez la variable, en utilisant la syntaxe des deux-points (`:`).
+Dans toute la documentation, il y a des exemples compatibles avec chaque version de Python (lorsqu'il y a une différence).
-Et comme type, mettez `List`.
+Par exemple, «Python 3.6+» signifie que c'est compatible avec Python 3.6 ou supérieur (y compris 3.7, 3.8, 3.9, 3.10, etc.). Et «Python 3.9+» signifie que c'est compatible avec Python 3.9 ou supérieur (y compris 3.10, etc.).
-Les listes étant un type contenant des types internes, mettez ces derniers entre crochets (`[`, `]`) :
+Si vous pouvez utiliser les dernières versions de Python, utilisez les exemples de la dernière version, ils auront la meilleure et la plus simple syntaxe, par exemple, «Python 3.10+».
-{*../../docs_src/python_types/tutorial006.py hl[4] *}
+#### List { #list }
-/// tip | Astuce
+Par exemple, définissons une variable comme étant une `list` de `str`.
-Ces types internes entre crochets sont appelés des "paramètres de type".
+Déclarez la variable, en utilisant la même syntaxe avec les deux-points (`:`).
-Ici, `str` est un paramètre de type passé à `List`.
+Comme type, mettez `list`.
+
+Comme la liste est un type qui contient des types internes, mettez-les entre crochets :
+
+{* ../../docs_src/python_types/tutorial006_py39.py hl[1] *}
+
+/// info
+
+Ces types internes entre crochets sont appelés «paramètres de type».
+
+Dans ce cas, `str` est le paramètre de type passé à `list`.
///
-Ce qui signifie : "la variable `items` est une `list`, et chacun de ses éléments a pour type `str`.
+Cela signifie : «la variable `items` est une `list`, et chacun des éléments de cette liste est un `str`».
-En faisant cela, votre éditeur pourra vous aider, même pendant que vous traitez des éléments de la liste.
+En faisant cela, votre éditeur peut vous offrir du support même pendant le traitement des éléments de la liste :
-Sans types, c'est presque impossible à réaliser.
+Sans types, c'est presque impossible à atteindre.
-Vous remarquerez que la variable `item` n'est qu'un des éléments de la list `items`.
+Notez que la variable `item` est l'un des éléments de la liste `items`.
-Et pourtant, l'éditeur sait qu'elle est de type `str` et pourra donc vous aider à l'utiliser.
+Et pourtant, l'éditeur sait que c'est un `str` et fournit le support correspondant.
-#### `Tuple` et `Set`
+#### Tuple et Set { #tuple-and-set }
-C'est le même fonctionnement pour déclarer un `tuple` ou un `set` :
+Vous feriez la même chose pour déclarer des `tuple` et des `set` :
-{*../../docs_src/python_types/tutorial007.py hl[1,4] *}
+{* ../../docs_src/python_types/tutorial007_py39.py hl[1] *}
-Dans cet exemple :
+Cela signifie :
-* La variable `items_t` est un `tuple` avec 3 éléments, un `int`, un deuxième `int`, et un `str`.
+* La variable `items_t` est un `tuple` avec 3 éléments, un `int`, un autre `int`, et un `str`.
* La variable `items_s` est un `set`, et chacun de ses éléments est de type `bytes`.
-#### `Dict`
+#### Dict { #dict }
-Pour définir un `dict`, il faut lui passer 2 paramètres, séparés par une virgule (`,`).
+Pour définir un `dict`, vous passez 2 paramètres de type, séparés par des virgules.
-Le premier paramètre de type est pour les clés et le second pour les valeurs du dictionnaire (`dict`).
+Le premier paramètre de type est pour les clés du `dict`.
-{*../../docs_src/python_types/tutorial008.py hl[1,4] *}
+Le deuxième paramètre de type est pour les valeurs du `dict` :
-Dans cet exemple :
+{* ../../docs_src/python_types/tutorial008_py39.py hl[1] *}
-* La variable `prices` est de type `dict` :
- * Les clés de ce dictionnaire sont de type `str`.
- * Les valeurs de ce dictionnaire sont de type `float`.
+Cela signifie :
-#### `Optional`
+* La variable `prices` est un `dict` :
+ * Les clés de ce `dict` sont de type `str` (disons, le nom de chaque article).
+ * Les valeurs de ce `dict` sont de type `float` (disons, le prix de chaque article).
-Vous pouvez aussi utiliser `Optional` pour déclarer qu'une variable a un type, comme `str` mais qu'il est "optionnel" signifiant qu'il pourrait aussi être `None`.
+#### Union { #union }
-{*../../docs_src/python_types/tutorial009.py hl[1,4] *}
+Vous pouvez déclarer qu'une variable peut être n'importe lequel de plusieurs types, par exemple, un `int` ou un `str`.
-Utiliser `Optional[str]` plutôt que `str` permettra à l'éditeur de vous aider à détecter les erreurs où vous supposeriez qu'une valeur est toujours de type `str`, alors qu'elle pourrait aussi être `None`.
+En Python 3.6 et supérieur (y compris Python 3.10), vous pouvez utiliser le type `Union` de `typing` et mettre entre crochets les types possibles à accepter.
-#### Types génériques
+En Python 3.10, il existe également une **nouvelle syntaxe** dans laquelle vous pouvez indiquer les types possibles séparés par une barre verticale (`|`).
-Les types qui peuvent contenir des paramètres de types entre crochets, comme :
+//// tab | Python 3.10+
-* `List`
-* `Tuple`
-* `Set`
-* `Dict`
+```Python hl_lines="1"
+{!> ../../docs_src/python_types/tutorial008b_py310.py!}
+```
+
+////
+
+//// tab | Python 3.9+
+
+```Python hl_lines="1 4"
+{!> ../../docs_src/python_types/tutorial008b_py39.py!}
+```
+
+////
+
+Dans les deux cas, cela signifie que `item` peut être un `int` ou un `str`.
+
+#### Éventuellement `None` { #possibly-none }
+
+Vous pouvez déclarer qu'une valeur peut avoir un type, comme `str`, mais qu'elle peut aussi être `None`.
+
+En Python 3.6 et supérieur (y compris Python 3.10), vous pouvez le déclarer en important et en utilisant `Optional` depuis le module `typing`.
+
+```Python hl_lines="1 4"
+{!../../docs_src/python_types/tutorial009_py39.py!}
+```
+
+Utiliser `Optional[str]` au lieu de simplement `str` permettra à l'éditeur de vous aider à détecter les erreurs où vous pourriez supposer qu'une valeur est toujours un `str`, alors qu'elle pourrait en fait être `None`.
+
+`Optional[Something]` est en réalité un raccourci pour `Union[Something, None]`, c'est équivalent.
+
+Cela signifie aussi qu'en Python 3.10, vous pouvez utiliser `Something | None` :
+
+//// tab | Python 3.10+
+
+```Python hl_lines="1"
+{!> ../../docs_src/python_types/tutorial009_py310.py!}
+```
+
+////
+
+//// tab | Python 3.9+
+
+```Python hl_lines="1 4"
+{!> ../../docs_src/python_types/tutorial009_py39.py!}
+```
+
+////
+
+//// tab | Python 3.9+ alternative
+
+```Python hl_lines="1 4"
+{!> ../../docs_src/python_types/tutorial009b_py39.py!}
+```
+
+////
+
+#### Utiliser `Union` ou `Optional` { #using-union-or-optional }
+
+Si vous utilisez une version de Python inférieure à 3.10, voici un conseil de mon point de vue très **subjectif** :
+
+* 🚨 Évitez d'utiliser `Optional[SomeType]`
+* À la place, ✨ **utilisez `Union[SomeType, None]`** ✨.
+
+Les deux sont équivalents et, en interne, c'est la même chose, mais je recommanderais `Union` plutôt que `Optional` parce que le mot «optional» semble impliquer que la valeur est optionnelle, alors qu'il signifie en réalité «elle peut être `None`», même si elle n'est pas optionnelle et reste requise.
+
+Je pense que `Union[SomeType, None]` est plus explicite quant à ce que cela signifie.
+
+Il ne s'agit que de mots et de noms. Mais ces mots peuvent influencer la manière dont vous et vos coéquipiers pensez au code.
+
+Par exemple, prenons cette fonction :
+
+{* ../../docs_src/python_types/tutorial009c_py39.py hl[1,4] *}
+
+Le paramètre `name` est défini comme `Optional[str]`, mais il n'est pas optionnel, vous ne pouvez pas appeler la fonction sans le paramètre :
+
+```Python
+say_hi() # Oh, non, cela lève une erreur ! 😱
+```
+
+Le paramètre `name` est toujours requis (pas optionnel) parce qu'il n'a pas de valeur par défaut. Néanmoins, `name` accepte `None` comme valeur :
+
+```Python
+say_hi(name=None) # Cela fonctionne, None est valide 🎉
+```
+
+La bonne nouvelle, c'est qu'une fois sur Python 3.10, vous n'aurez plus à vous en soucier, car vous pourrez simplement utiliser `|` pour définir des unions de types :
+
+{* ../../docs_src/python_types/tutorial009c_py310.py hl[1,4] *}
+
+Et vous n'aurez plus à vous préoccuper de noms comme «Optional» et «Union». 😎
+
+#### Types génériques { #generic-types }
+
+Ces types qui prennent des paramètres de type entre crochets sont appelés **types génériques** ou **Generics**, par exemple :
+
+//// tab | Python 3.10+
+
+Vous pouvez utiliser les mêmes types intégrés comme génériques (avec des crochets et des types à l'intérieur) :
+
+* `list`
+* `tuple`
+* `set`
+* `dict`
+
+Et, comme avec les versions précédentes de Python, ceux du module `typing` :
+
+* `Union`
* `Optional`
-* ...et d'autres.
+* ... et d'autres.
-sont appelés des **types génériques** ou **Generics**.
+En Python 3.10, comme alternative à l'utilisation des génériques `Union` et `Optional`, vous pouvez utiliser la barre verticale (`|`) pour déclarer des unions de types, c'est bien mieux et plus simple.
-### Classes en tant que types
+////
-Vous pouvez aussi déclarer une classe comme type d'une variable.
+//// tab | Python 3.9+
-Disons que vous avez une classe `Person`, avec une variable `name` :
+Vous pouvez utiliser les mêmes types intégrés comme génériques (avec des crochets et des types à l'intérieur) :
-{*../../docs_src/python_types/tutorial010.py hl[1:3] *}
+* `list`
+* `tuple`
+* `set`
+* `dict`
+Et les génériques du module `typing` :
+
+* `Union`
+* `Optional`
+* ... et d'autres.
+
+////
+
+### Classes comme types { #classes-as-types }
+
+Vous pouvez également déclarer une classe comme type d'une variable.
+
+Disons que vous avez une classe `Person`, avec un nom :
+
+{* ../../docs_src/python_types/tutorial010_py39.py hl[1:3] *}
Vous pouvez ensuite déclarer une variable de type `Person` :
-{*../../docs_src/python_types/tutorial010.py hl[6] *}
+{* ../../docs_src/python_types/tutorial010_py39.py hl[6] *}
-Et vous aurez accès, encore une fois, au support complet offert par l'éditeur :
+Et là encore, vous obtenez tout le support de l'éditeur :
-## Les modèles Pydantic
+Notez que cela signifie que «`one_person` est une **instance** de la classe `Person`».
-Pydantic est une bibliothèque Python pour effectuer de la validation de données.
+Cela ne signifie pas «`one_person` est la **classe** appelée `Person`».
-Vous déclarez la forme de la donnée avec des classes et des attributs.
+## Modèles Pydantic { #pydantic-models }
-Chaque attribut possède un type.
+Pydantic est une bibliothèque Python pour effectuer la validation de données.
-Puis vous créez une instance de cette classe avec certaines valeurs et **Pydantic** validera les valeurs, les convertira dans le type adéquat (si c'est nécessaire et possible) et vous donnera un objet avec toute la donnée.
+Vous déclarez la «forme» des données sous forme de classes avec des attributs.
-Ainsi, votre éditeur vous offrira un support adapté pour l'objet résultant.
+Et chaque attribut a un type.
-Extrait de la documentation officielle de **Pydantic** :
+Ensuite, vous créez une instance de cette classe avec certaines valeurs et elle validera les valeurs, les convertira dans le type approprié (le cas échéant) et vous donnera un objet avec toutes les données.
-{*../../docs_src/python_types/tutorial011.py*}
+Et vous bénéficiez de tout le support de l'éditeur avec cet objet résultant.
+
+Un exemple tiré de la documentation officielle de Pydantic :
+
+{* ../../docs_src/python_types/tutorial011_py310.py *}
/// info
-Pour en savoir plus à propos de Pydantic, allez jeter un coup d'oeil à sa documentation.
+Pour en savoir plus à propos de Pydantic, consultez sa documentation.
///
-**FastAPI** est basé entièrement sur **Pydantic**.
+**FastAPI** est entièrement basé sur Pydantic.
-Vous verrez bien plus d'exemples de son utilisation dans [Tutoriel - Guide utilisateur](tutorial/index.md){.internal-link target=_blank}.
+Vous verrez beaucoup plus de tout cela en pratique dans le [Tutoriel - Guide utilisateur](tutorial/index.md){.internal-link target=_blank}.
-## Les annotations de type dans **FastAPI**
+/// tip | Astuce
-**FastAPI** utilise ces annotations pour faire différentes choses.
+Pydantic a un comportement particulier lorsque vous utilisez `Optional` ou `Union[Something, None]` sans valeur par défaut. Vous pouvez en lire davantage dans la documentation Pydantic à propos des champs Optional requis.
-Avec **FastAPI**, vous déclarez des paramètres grâce aux annotations de types et vous obtenez :
+///
-* **du support de l'éditeur**
-* **de la vérification de types**
+## Annotations de type avec métadonnées { #type-hints-with-metadata-annotations }
-...et **FastAPI** utilise ces mêmes déclarations pour :
+Python propose aussi une fonctionnalité qui permet d'ajouter des **métadonnées supplémentaires** dans ces «type hints» en utilisant `Annotated`.
-* **Définir les prérequis** : depuis les paramètres de chemins des requêtes, les entêtes, les corps, les dépendances, etc.
-* **Convertir des données** : depuis la requête vers les types requis.
-* **Valider des données** : venant de chaque requête :
- * Générant automatiquement des **erreurs** renvoyées au client quand la donnée est invalide.
+Depuis Python 3.9, `Annotated` fait partie de la bibliothèque standard, vous pouvez donc l'importer depuis `typing`.
+
+{* ../../docs_src/python_types/tutorial013_py39.py hl[1,4] *}
+
+Python lui-même ne fait rien avec cet `Annotated`. Et pour les éditeurs et autres outils, le type est toujours `str`.
+
+Mais vous pouvez utiliser cet espace dans `Annotated` pour fournir à **FastAPI** des métadonnées supplémentaires sur la façon dont vous souhaitez que votre application se comporte.
+
+L'important à retenir est que **le premier paramètre de type** que vous passez à `Annotated` est le **type réel**. Le reste n'est que des métadonnées pour d'autres outils.
+
+Pour l'instant, vous avez seulement besoin de savoir que `Annotated` existe et que c'est du Python standard. 😎
+
+Plus tard, vous verrez à quel point cela peut être **puissant**.
+
+/// tip | Astuce
+
+Le fait que ce soit du **Python standard** signifie que vous aurez toujours la **meilleure expérience développeur possible** dans votre éditeur, avec les outils que vous utilisez pour analyser et refactoriser votre code, etc. ✨
+
+Et aussi que votre code sera très compatible avec de nombreux autres outils et bibliothèques Python. 🚀
+
+///
+
+## Les annotations de type dans **FastAPI** { #type-hints-in-fastapi }
+
+**FastAPI** tire parti de ces «type hints» pour faire plusieurs choses.
+
+Avec **FastAPI**, vous déclarez des paramètres avec des «type hints» et vous obtenez :
+
+* **du support de l'éditeur**.
+* **des vérifications de type**.
+
+... et **FastAPI** utilise les mêmes déclarations pour :
+
+* **Définir les prérequis** : depuis les paramètres de chemin des requêtes, les paramètres de requête, les en-têtes, les corps, les dépendances, etc.
+* **Convertir les données** : depuis la requête vers le type requis.
+* **Valider les données** : provenant de chaque requête :
+ * Générer des **erreurs automatiques** renvoyées au client lorsque les données sont invalides.
* **Documenter** l'API avec OpenAPI :
- * ce qui ensuite utilisé par les interfaces utilisateur automatiques de documentation interactive.
+ * ce qui est ensuite utilisé par les interfaces utilisateur de documentation interactive automatiques.
-Tout cela peut paraître bien abstrait, mais ne vous inquiétez pas, vous verrez tout ça en pratique dans [Tutoriel - Guide utilisateur](tutorial/index.md){.internal-link target=_blank}.
+Tout cela peut sembler abstrait. Ne vous inquiétez pas. Vous verrez tout cela en action dans le [Tutoriel - Guide utilisateur](tutorial/index.md){.internal-link target=_blank}.
-Ce qu'il faut retenir c'est qu'en utilisant les types standard de Python, à un seul endroit (plutôt que d'ajouter plus de classes, de décorateurs, etc.), **FastAPI** fera une grande partie du travail pour vous.
+L'important, c'est qu'en utilisant les types standard de Python, en un seul endroit (au lieu d'ajouter davantage de classes, de décorateurs, etc.), **FastAPI** fera une grande partie du travail pour vous.
/// info
-Si vous avez déjà lu le tutoriel et êtes revenus ici pour voir plus sur les types, une bonne ressource est la "cheat sheet" de `mypy`.
+Si vous avez déjà parcouru tout le tutoriel et êtes revenu pour en savoir plus sur les types, une bonne ressource est l'aide-mémoire de `mypy`.
///
diff --git a/docs/fr/docs/tutorial/background-tasks.md b/docs/fr/docs/tutorial/background-tasks.md
index 6efd16e07..e1a1111d4 100644
--- a/docs/fr/docs/tutorial/background-tasks.md
+++ b/docs/fr/docs/tutorial/background-tasks.md
@@ -1,84 +1,86 @@
-# Tâches d'arrière-plan
+# Tâches d'arrière-plan { #background-tasks }
Vous pouvez définir des tâches d'arrière-plan qui seront exécutées après avoir retourné une réponse.
-Ceci est utile pour les opérations qui doivent avoir lieu après une requête, mais où le client n'a pas réellement besoin d'attendre que l'opération soit terminée pour recevoir une réponse.
+Ceci est utile pour les opérations qui doivent avoir lieu après une requête, mais où le client n'a pas vraiment à attendre que l'opération soit terminée pour recevoir la réponse.
Cela comprend, par exemple :
* Les notifications par email envoyées après l'exécution d'une action :
- * Étant donné que se connecter à un serveur et envoyer un email a tendance à être «lent» (plusieurs secondes), vous pouvez retourner la réponse directement et envoyer la notification en arrière-plan.
+ * Étant donné que se connecter à un serveur email et envoyer un email a tendance à être «lent» (plusieurs secondes), vous pouvez retourner la réponse directement et envoyer la notification par email en arrière-plan.
* Traiter des données :
- * Par exemple, si vous recevez un fichier qui doit passer par un traitement lent, vous pouvez retourner une réponse «Accepted» (HTTP 202) puis faire le traitement en arrière-plan.
+ * Par exemple, disons que vous recevez un fichier qui doit passer par un processus lent, vous pouvez retourner une réponse «Accepted» (HTTP 202) et traiter le fichier en arrière-plan.
+## Utiliser `BackgroundTasks` { #using-backgroundtasks }
-## Utiliser `BackgroundTasks`
+Pour commencer, importez `BackgroundTasks` et définissez un paramètre dans votre *fonction de chemin* avec `BackgroundTasks` comme type déclaré :
-Pour commencer, importez `BackgroundTasks` et définissez un paramètre dans votre *fonction de chemin* avec `BackgroundTasks` comme type déclaré.
-
-{* ../../docs_src/background_tasks/tutorial001.py hl[1,13] *}
+{* ../../docs_src/background_tasks/tutorial001_py39.py hl[1,13] *}
**FastAPI** créera l'objet de type `BackgroundTasks` pour vous et le passera comme paramètre.
-## Créer une fonction de tâche
+## Créer une fonction de tâche { #create-a-task-function }
-Une fonction à exécuter comme tâche d'arrière-plan est juste une fonction standard qui peut recevoir des paramètres.
+Créez une fonction à exécuter comme tâche d'arrière-plan.
+
+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).
-L'opération d'écriture n'utilisant ni `async` ni `await`, on définit la fonction avec un `def` normal.
+Et comme l'opération d'écriture n'utilise ni `async` ni `await`, nous définissons la fonction avec un `def` normal :
-{* ../../docs_src/background_tasks/tutorial001.py hl[6:9] *}
+{* ../../docs_src/background_tasks/tutorial001_py39.py hl[6:9] *}
-## Ajouter une tâche d'arrière-plan
+## Ajouter la tâche d'arrière-plan { #add-the-background-task }
-Dans votre *fonction de chemin*, 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*, passez votre fonction de tâche à l'objet de tâches d'arrière-plan grâce à la méthode `.add_task()` :
-
-{* ../../docs_src/background_tasks/tutorial001.py hl[14] *}
+{* ../../docs_src/background_tasks/tutorial001_py39.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
+## Injection de dépendances { #dependency-injection }
-Utiliser `BackgroundTasks` fonctionne aussi avec le système d'injection de dépendances. Vous pouvez déclarer un paramètre de type `BackgroundTasks` à différents niveaux : dans une *fonction de chemin*, dans une dépendance, dans une sous-dépendance...
+Utiliser `BackgroundTasks` fonctionne aussi avec le système d'injection de dépendances, vous pouvez déclarer un paramètre de type `BackgroundTasks` à plusieurs niveaux : dans une *fonction de chemin*, dans une dépendance (dependable), dans une sous-dépendance, etc.
-**FastAPI** sait quoi faire dans chaque cas et comment réutiliser le même objet, afin que tous les paramètres de type `BackgroundTasks` soient fusionnés et que les tâches soient exécutées en arrière-plan :
+**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 exécutées ensuite en arrière-plan :
+
+
+{* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}
-{* ../../docs_src/background_tasks/tutorial002.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.
-S'il y avait une `query` (paramètre nommé `q`) dans la requête, alors elle sera écrite dans `log.txt` via une tâche d'arrière-plan.
+S'il y avait un paramètre de requête dans la requête, il sera écrit dans le log via une tâche d'arrière-plan.
-Et ensuite une autre tâche d'arrière-plan (générée dans les paramètres de la *la fonction de chemin*) écrira un message dans `log.txt` comprenant le paramètre de chemin `email`.
+Ensuite, une autre tâche d'arrière-plan générée dans la *fonction de chemin* écrira un message utilisant le paramètre de chemin `email`.
-## Détails techniques
+## Détails techniques { #technical-details }
La classe `BackgroundTasks` provient directement de `starlette.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 afin que vous puissiez l'importer depuis `fastapi` et éviter d'importer par accident l'alternative `BackgroundTask` (sans le `s` final) 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* et de laisser **FastAPI** gérer le reste pour vous, comme en utilisant l'objet `Request` directement.
+En utilisant seulement `BackgroundTasks` (et non `BackgroundTask`), il est possible de l'utiliser en tant que paramètre de *fonction de chemin* et de laisser **FastAPI** gérer le reste pour vous, comme lorsque vous utilisez 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 toujours possible d'utiliser `BackgroundTask` seul dans FastAPI, mais vous devez créer l'objet dans votre code et renvoyer une `Response` Starlette qui l'inclut.
-Plus de détails sont disponibles dans la documentation officielle de Starlette sur les tâches d'arrière-plan (via leurs classes `BackgroundTasks`et `BackgroundTask`).
+Vous pouvez voir plus de détails dans la documentation officielle de Starlette sur les tâches d'arrière-plan.
-## Avertissement
+## 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.
+Si vous avez besoin d'effectuer des calculs lourds en arrière-plan et que vous n'avez pas nécessairement besoin qu'ils soient exécutés par le même processus (par exemple, vous n'avez pas besoin de partager la mémoire, les variables, etc.), vous pourriez bénéficier d'utiliser des outils plus importants comme Celery.
-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 potentiellement, sur plusieurs serveurs.
+Ils nécessitent généralement des configurations plus complexes, un gestionnaire de file de messages/jobs, comme RabbitMQ ou Redis, mais ils permettent d'exécuter des tâches d'arrière-plan dans plusieurs processus, 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`.
+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 une notification par email), vous pouvez simplement utiliser `BackgroundTasks`.
-## Résumé
+## Résumé { #recap }
-Importez et utilisez `BackgroundTasks` grâce aux paramètres de *fonction de chemin* 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* et les dépendances pour ajouter des tâches d'arrière-plan.
diff --git a/docs/fr/docs/tutorial/body-multiple-params.md b/docs/fr/docs/tutorial/body-multiple-params.md
index 0541acc74..53fae8ea0 100644
--- a/docs/fr/docs/tutorial/body-multiple-params.md
+++ b/docs/fr/docs/tutorial/body-multiple-params.md
@@ -1,8 +1,8 @@
-# Body - Paramètres multiples
+# Body - Paramètres multiples { #body-multiple-parameters }
-Maintenant que nous avons vu comment manipuler `Path` et `Query`, voyons comment faire pour le corps d'une requête, communément désigné par le terme anglais "body".
+Maintenant que nous avons vu comment utiliser `Path` et `Query`, voyons des utilisations plus avancées des déclarations du corps de la requête.
-## Mélanger les paramètres `Path`, `Query` et body
+## Mélanger les paramètres `Path`, `Query` et body { #mix-path-query-and-body-parameters }
Tout d'abord, sachez que vous pouvez mélanger les déclarations des paramètres `Path`, `Query` et body, **FastAPI** saura quoi faire.
@@ -10,15 +10,15 @@ Vous pouvez également déclarer des paramètres body comme étant optionnels, e
{* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}
-/// note
+/// note | Remarque
-Notez que, dans ce cas, le paramètre `item` provenant du `Body` est optionnel (sa valeur par défaut est `None`).
+Notez que, dans ce cas, le paramètre `item` provenant du body est optionnel. Sa valeur par défaut est `None`.
///
-## Paramètres multiples du body
+## Paramètres multiples du body { #multiple-body-parameters }
-Dans l'exemple précédent, les opérations de routage attendaient un body JSON avec les attributs d'un `Item`, par exemple :
+Dans l'exemple précédent, les *opérations de chemin* attendaient un body JSON avec les attributs d'un `Item`, par exemple :
```JSON
{
@@ -29,13 +29,13 @@ Dans l'exemple précédent, les opérations de routage attendaient un body JSON
}
```
-Mais vous pouvez également déclarer plusieurs paramètres provenant de body, par exemple `item` et `user` simultanément :
+Mais vous pouvez également déclarer plusieurs paramètres provenant de body, par exemple `item` et `user` :
{* ../../docs_src/body_multiple_params/tutorial002_py310.py hl[20] *}
-Dans ce cas, **FastAPI** détectera qu'il y a plus d'un paramètre dans le body (chacun correspondant à un modèle Pydantic).
+Dans ce cas, **FastAPI** détectera qu'il y a plus d'un paramètre body dans la fonction (il y a deux paramètres qui sont des modèles Pydantic).
-Il utilisera alors les noms des paramètres comme clés, et s'attendra à recevoir quelque chose de semblable à :
+Il utilisera alors les noms des paramètres comme clés (noms de champs) dans le body, et s'attendra à recevoir un body semblable à :
```JSON
{
@@ -52,23 +52,23 @@ Il utilisera alors les noms des paramètres comme clés, et s'attendra à recevo
}
```
-/// note
+/// note | Remarque
-"Notez que, bien que nous ayons déclaré le paramètre `item` de la même manière que précédemment, il est maintenant associé à la clé `item` dans le corps de la requête."`.
+Notez que, bien que `item` ait été déclaré de la même manière qu'auparavant, il est maintenant attendu dans le body sous la clé `item`.
///
-**FastAPI** effectue la conversion de la requête de façon transparente, de sorte que les objets `item` et `user` se trouvent correctement définis.
+**FastAPI** effectue la conversion automatique à partir de la requête, de sorte que le paramètre `item` reçoive son contenu spécifique, et de même pour `user`.
-Il effectue également la validation des données (même imbriquées les unes dans les autres), et permet de les documenter correctement (schéma OpenAPI et documentation auto-générée).
+Il effectuera la validation des données composées et les documentera ainsi dans le schéma OpenAPI et la documentation automatique.
-## Valeurs scalaires dans le body
+## Valeurs scalaires dans le body { #singular-values-in-body }
De la même façon qu'il existe `Query` et `Path` pour définir des données supplémentaires pour les paramètres query et path, **FastAPI** fournit un équivalent `Body`.
Par exemple, en étendant le modèle précédent, vous pouvez vouloir ajouter un paramètre `importance` dans le même body, en plus des paramètres `item` et `user`.
-Si vous le déclarez tel quel, comme c'est une valeur [scalaire](https://docs.github.com/fr/graphql/reference/scalars), **FastAPI** supposera qu'il s'agit d'un paramètre de requête (`Query`).
+Si vous le déclarez tel quel, comme c'est une valeur scalaire, **FastAPI** supposera qu'il s'agit d'un paramètre de requête.
Mais vous pouvez indiquer à **FastAPI** de la traiter comme une variable de body en utilisant `Body` :
@@ -92,13 +92,13 @@ Dans ce cas, **FastAPI** s'attendra à un body semblable à :
}
```
-Encore une fois, cela convertira les types de données, les validera, permettra de générer la documentation, etc...
+Encore une fois, cela convertira les types de données, les validera, permettra de générer la documentation, etc.
-## Paramètres multiples body et query
+## Paramètres multiples body et query { #multiple-body-params-and-query }
-Bien entendu, vous pouvez déclarer autant de paramètres que vous le souhaitez, en plus des paramètres body déjà déclarés.
+Bien entendu, vous pouvez également déclarer des paramètres de requête supplémentaires quand vous en avez besoin, en plus de tout paramètre body.
-Par défaut, les valeurs [scalaires](https://docs.github.com/fr/graphql/reference/scalars) sont interprétées comme des paramètres query, donc inutile d'ajouter explicitement `Query`. Vous pouvez juste écrire :
+Comme, par défaut, les valeurs scalaires sont interprétées comme des paramètres query, vous n'avez pas besoin d'ajouter explicitement `Query`. Vous pouvez simplement écrire :
```Python
q: Union[str, None] = None
@@ -112,7 +112,7 @@ q: str | None = None
Par exemple :
-{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[27] *}
+{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *}
/// info
@@ -120,13 +120,13 @@ Par exemple :
///
-## Inclure un paramètre imbriqué dans le body
+## Inclure un seul paramètre body { #embed-a-single-body-parameter }
Disons que vous avez seulement un paramètre `item` dans le body, correspondant à un modèle Pydantic `Item`.
Par défaut, **FastAPI** attendra sa déclaration directement dans le body.
-Cependant, si vous souhaitez qu'il interprête correctement un JSON avec une clé `item` associée au contenu du modèle, comme cela serait le cas si vous déclariez des paramètres body additionnels, vous pouvez utiliser le paramètre spécial `embed` de `Body` :
+Cependant, si vous souhaitez qu'il interprète correctement un JSON avec une clé `item` associée au contenu du modèle, comme cela serait le cas si vous déclariez des paramètres body additionnels, vous pouvez utiliser le paramètre spécial `embed` de `Body` :
```Python
item: Item = Body(embed=True)
@@ -160,12 +160,12 @@ au lieu de :
}
```
-## Pour résumer
+## Pour résumer { #recap }
-Vous pouvez ajouter plusieurs paramètres body dans votre fonction de routage, même si une requête ne peut avoir qu'un seul body.
+Vous pouvez ajouter plusieurs paramètres body à votre *fonction de chemin*, même si une requête ne peut avoir qu'un seul body.
-Cependant, **FastAPI** se chargera de faire opérer sa magie, afin de toujours fournir à votre fonction des données correctes, les validera et documentera le schéma associé.
+Cependant, **FastAPI** s'en chargera, vous fournira les bonnes données dans votre fonction, et validera et documentera le schéma correct dans l'*opération de chemin*.
-Vous pouvez également déclarer des valeurs [scalaires](https://docs.github.com/fr/graphql/reference/scalars) à recevoir dans le body.
+Vous pouvez également déclarer des valeurs scalaires à recevoir dans le body.
-Et vous pouvez indiquer à **FastAPI** d'inclure le body dans une autre variable, même lorsqu'un seul paramètre est déclaré.
+Et vous pouvez indiquer à **FastAPI** d'inclure le body dans une clé, même lorsqu'un seul paramètre est déclaré.
diff --git a/docs/fr/docs/tutorial/body.md b/docs/fr/docs/tutorial/body.md
index 760b6d80a..d09b33152 100644
--- a/docs/fr/docs/tutorial/body.md
+++ b/docs/fr/docs/tutorial/body.md
@@ -1,40 +1,40 @@
-# Corps de la requête
+# Corps de la requête { #request-body }
-Quand vous avez besoin d'envoyer de la donnée depuis un client (comme un navigateur) vers votre API, vous l'envoyez en tant que **corps de requête**.
+Quand vous avez besoin d'envoyer des données depuis un client (par exemple, un navigateur) vers votre API, vous les envoyez en tant que **corps de requête**.
-Le corps d'une **requête** est de la donnée envoyée par le client à votre API. Le corps d'une **réponse** est la donnée envoyée par votre API au client.
+Le corps d'une **requête** est la donnée envoyée par le client à votre API. Le corps d'une **réponse** est la donnée que votre API envoie au client.
-Votre API aura presque toujours à envoyer un corps de **réponse**. Mais un client n'a pas toujours à envoyer un corps de **requête**.
+Votre API doit presque toujours envoyer un corps de **réponse**. Mais les clients n'ont pas forcément besoin d'envoyer des **corps de requête** tout le temps, parfois ils ne demandent qu'un chemin, peut-être avec quelques paramètres de requête, mais n'envoient pas de corps.
-Pour déclarer un corps de **requête**, on utilise les modèles de Pydantic en profitant de tous leurs avantages et fonctionnalités.
+Pour déclarer un corps de **requête**, vous utilisez des modèles Pydantic avec toute leur puissance et leurs avantages.
/// info
-Pour envoyer de la donnée, vous devriez utiliser : `POST` (le plus populaire), `PUT`, `DELETE` ou `PATCH`.
+Pour envoyer des données, vous devriez utiliser l'une de ces méthodes : `POST` (la plus courante), `PUT`, `DELETE` ou `PATCH`.
-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.
+Envoyer un corps avec une requête `GET` a un comportement non défini dans les spécifications ; néanmoins, c'est 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.
+Comme c'est découragé, la documentation interactive avec Swagger UI n'affichera pas la documentation pour le corps lors de l'utilisation de `GET`, et des proxys intermédiaires pourraient ne pas le supporter.
///
-## Importez le `BaseModel` de Pydantic
+## Importer `BaseModel` de Pydantic { #import-pydantics-basemodel }
-Commencez par importer la classe `BaseModel` du module `pydantic` :
+Commencez par importer la classe `BaseModel` depuis `pydantic` :
-{* ../../docs_src/body/tutorial001.py hl[4] *}
+{* ../../docs_src/body/tutorial001_py310.py hl[2] *}
-## Créez votre modèle de données
+## Créer votre modèle de données { #create-your-data-model }
Déclarez ensuite votre modèle de données en tant que classe qui hérite de `BaseModel`.
-Utilisez les types Python standard pour tous les attributs :
+Utilisez les types Python standards pour tous les attributs :
-{* ../../docs_src/body/tutorial001.py hl[7:11] *}
+{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
-Tout comme pour la déclaration de paramètres de requête, quand un attribut de modèle a une valeur par défaut, il n'est pas nécessaire. Sinon, cet attribut doit être renseigné dans le corps de la requête. Pour rendre ce champ optionnel simplement, utilisez `None` comme valeur par défaut.
+Comme pour la déclaration de paramètres de requête, lorsqu'un attribut de modèle a une valeur par défaut, il n'est pas requis. Sinon, il est requis. Utilisez `None` pour le rendre simplement optionnel.
-Par exemple, le modèle ci-dessus déclare un "objet" JSON (ou `dict` Python) tel que :
+Par exemple, le modèle ci-dessus déclare un «`object`» JSON (ou `dict` Python) tel que :
```JSON
{
@@ -45,7 +45,7 @@ Par exemple, le modèle ci-dessus déclare un "objet" JSON (ou `dict` Python) te
}
```
-...`description` et `tax` étant des attributs optionnels (avec `None` comme valeur par défaut), cet "objet" JSON serait aussi valide :
+... comme `description` et `tax` sont optionnels (avec une valeur par défaut de `None`), cet «`object`» JSON serait aussi valide :
```JSON
{
@@ -54,109 +54,111 @@ Par exemple, le modèle ci-dessus déclare un "objet" JSON (ou `dict` Python) te
}
```
-## Déclarez-le comme paramètre
+## Le déclarer comme paramètre { #declare-it-as-a-parameter }
-Pour l'ajouter à votre *opération de chemin*, déclarez-le comme vous déclareriez des paramètres de chemin ou de requête :
+Pour l'ajouter à votre *opération de chemin*, déclarez-le de la même manière que vous déclarez des paramètres de chemin et de requête :
-{* ../../docs_src/body/tutorial001.py hl[18] *}
+{* ../../docs_src/body/tutorial001_py310.py hl[16] *}
-...et déclarez que son type est le modèle que vous avez créé : `Item`.
+... et déclarez son type comme étant le modèle que vous avez créé, `Item`.
-## Résultats
+## Résultats { #results }
-En utilisant uniquement les déclarations de type Python, **FastAPI** réussit à :
+Avec cette seule déclaration de type Python, **FastAPI** va :
-* 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ù était la donnée incorrecte.
-* Passer la donnée reçue dans le paramètre `item`.
- * Ce paramètre ayant été déclaré dans la fonction comme étant de type `Item`, vous aurez aussi tout le support offert par l'éditeur (auto-complétion, etc.) pour tous les attributs de ce paramètre et les types de ces attributs.
-* Générer des définitions JSON Schema pour votre modèle, qui peuvent être utilisées où vous en avez besoin dans votre projet ensuite.
-* Ces schémas participeront à la constitution du schéma généré OpenAPI, et seront donc utilisés par les documentations automatiquement générées.
+ * Si la donnée est invalide, renvoyer une erreur claire et explicite, indiquant exactement où et quelle donnée est incorrecte.
+* Vous fournir la donnée reçue dans le paramètre `item`.
+ * Comme vous l'avez déclaré dans la fonction comme étant de type `Item`, vous aurez aussi tout le support de l'éditeur (autocomplétion, etc.) pour tous ses attributs et leurs types.
+* Générer des définitions JSON Schema pour votre modèle ; vous pouvez aussi les utiliser ailleurs si cela a du sens pour votre projet.
+* Ces schémas feront partie du schéma OpenAPI généré et seront utilisés par la documentation automatique UIs.
-## Documentation automatique
+## Documentation automatique { #automatic-docs }
-Les schémas JSON de vos modèles seront intégrés au schéma OpenAPI global de votre application, et seront donc affichés dans la documentation interactive de l'API :
+Les schémas JSON de vos modèles feront partie du schéma OpenAPI généré et seront affichés dans la documentation interactive de l'API :
-Et seront aussi utilisés dans chaque *opération de chemin* de la documentation utilisant ces modèles :
+Ils seront aussi utilisés dans chaque *opération de chemin* de la documentation qui en a besoin :
-## Support de l'éditeur
+## Support de l'éditeur { #editor-support }
-Dans votre éditeur, vous aurez des annotations de types et de l'auto-complétion partout dans votre fonction (ce qui n'aurait pas été le cas si vous aviez utilisé un classique `dict` plutôt qu'un modèle Pydantic) :
+Dans votre éditeur, à l'intérieur de votre fonction, vous obtiendrez des annotations de type et de l'autocomplétion partout (ce qui n'arriverait pas si vous receviez un `dict` au lieu d'un modèle Pydantic) :
-Et vous obtenez aussi de la vérification d'erreur pour les opérations incorrectes de types :
+Vous obtenez aussi des vérifications d'erreurs pour les opérations incorrectes sur les types :
-Ce n'est pas un hasard, ce framework entier a été bâti avec ce design comme objectif.
+Ce n'est pas un hasard, tout le framework a été construit autour de ce design.
-Et cela a été rigoureusement testé durant la phase de design, avant toute implémentation, pour s'assurer que cela fonctionnerait avec tous les éditeurs.
+Et il a été rigoureusement testé lors de la phase de conception, avant toute implémentation, pour s'assurer qu'il fonctionne avec tous les éditeurs.
-Des changements sur Pydantic ont même été faits pour supporter cela.
+Des changements ont même été apportés à Pydantic lui‑même pour le supporter.
-Les captures d'écrans précédentes ont été prises sur Visual Studio Code.
+Les captures d'écran précédentes ont été prises avec Visual Studio Code.
-Mais vous auriez le même support de l'éditeur avec PyCharm et la majorité des autres éditeurs de code Python.
+Mais vous obtiendrez le même support de l'éditeur avec PyCharm et la plupart des autres éditeurs Python :
/// tip | Astuce
-Si vous utilisez PyCharm comme éditeur, vous pouvez utiliser le Plugin Pydantic PyCharm Plugin.
+Si vous utilisez PyCharm comme éditeur, vous pouvez utiliser le plug-in Pydantic pour PyCharm.
-Ce qui améliore le support pour les modèles Pydantic avec :
+Il améliore le support des modèles Pydantic avec :
-* de l'auto-complétion
-* des vérifications de type
-* du "refactoring" (ou remaniement de code)
-* de la recherche
-* de l'inspection
+* autocomplétion
+* vérifications de type
+* refactoring
+* recherche
+* inspections
///
-## Utilisez le modèle
+## Utiliser le modèle { #use-the-model }
-Dans la fonction, vous pouvez accéder à tous les attributs de l'objet du modèle directement :
+Dans la fonction, vous pouvez accéder directement à tous les attributs de l'objet du modèle :
-{* ../../docs_src/body/tutorial002.py hl[21] *}
+{* ../../docs_src/body/tutorial002_py310.py *}
-## Corps de la requête + paramètres de chemin
+## Corps de la requête + paramètres de chemin { #request-body-path-parameters }
-Vous pouvez déclarer des paramètres de chemin et un corps de requête pour la même *opération de chemin*.
+Vous pouvez déclarer des paramètres de chemin et un corps de requête en même temps.
-**FastAPI** est capable de reconnaître que les paramètres de la fonction qui correspondent aux paramètres de chemin doivent être **récupérés depuis le chemin**, et que les paramètres de fonctions déclarés comme modèles Pydantic devraient être **récupérés depuis le corps de la requête**.
+**FastAPI** reconnaîtra que les paramètres de la fonction qui correspondent aux paramètres de chemin doivent être **récupérés depuis le chemin**, et que les paramètres de fonction déclarés comme modèles Pydantic doivent être **récupérés depuis le corps de la requête**.
-{* ../../docs_src/body/tutorial003.py hl[17:18] *}
+{* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
-## Corps de la requête + paramètres de chemin et de requête
+## Corps de la requête + paramètres de chemin et de requête { #request-body-path-query-parameters }
-Vous pouvez aussi déclarer un **corps**, et des paramètres de **chemin** et de **requête** dans la même *opération de chemin*.
+Vous pouvez aussi déclarer des paramètres de **corps**, de **chemin** et de **requête**, tous en même temps.
-**FastAPI** saura reconnaître chacun d'entre eux et récupérer la bonne donnée au bon endroit.
+**FastAPI** reconnaîtra chacun d'entre eux et récupérera la donnée au bon endroit.
-{* ../../docs_src/body/tutorial004.py hl[18] *}
+{* ../../docs_src/body/tutorial004_py310.py hl[16] *}
-Les paramètres de la fonction seront reconnus comme tel :
+Les paramètres de la fonction seront reconnus comme suit :
* Si le paramètre est aussi déclaré dans le **chemin**, il sera utilisé comme paramètre de chemin.
* Si le paramètre est d'un **type singulier** (comme `int`, `float`, `str`, `bool`, etc.), il sera interprété comme un paramètre de **requête**.
-* Si le paramètre est déclaré comme ayant pour type un **modèle Pydantic**, il sera interprété comme faisant partie du **corps** de la requête.
+* Si le paramètre est déclaré comme étant du type d'un **modèle Pydantic**, il sera interprété comme faisant partie du **corps** de la requête.
-/// note
+/// note | Remarque
-**FastAPI** saura que la valeur de `q` n'est pas requise grâce à la valeur par défaut `=None`.
+FastAPI saura que la valeur de `q` n'est pas requise grâce à la valeur par défaut `= None`.
-Le type `Optional` dans `Optional[str]` n'est pas utilisé par **FastAPI**, mais sera utile à votre éditeur pour améliorer le support offert par ce dernier et détecter plus facilement des erreurs de type.
+L'annotation de type `str | None` (Python 3.10+) ou `Union` dans `Union[str, None]` (Python 3.9+) n'est pas utilisée par FastAPI pour déterminer que la valeur n'est pas requise, il le saura parce qu'il y a une valeur par défaut `= None`.
+
+Mais ajouter des annotations de type permettra à votre éditeur de vous offrir un meilleur support et de détecter des erreurs.
///
-## Sans Pydantic
+## Sans Pydantic { #without-pydantic }
-Si vous ne voulez pas utiliser des modèles Pydantic, vous pouvez aussi utiliser des paramètres de **Corps**. Pour cela, allez voir la partie de la documentation sur [Corps de la requête - Paramètres multiples](body-multiple-params.md){.internal-link target=_blank}.
+Si vous ne voulez pas utiliser des modèles Pydantic, vous pouvez aussi utiliser des paramètres **Body**. Voir 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){.internal-link target=_blank}.
diff --git a/docs/fr/docs/tutorial/debugging.md b/docs/fr/docs/tutorial/debugging.md
index ab00fbdeb..37f718cab 100644
--- a/docs/fr/docs/tutorial/debugging.md
+++ b/docs/fr/docs/tutorial/debugging.md
@@ -1,14 +1,14 @@
-# Débogage
+# Débogage { #debugging }
Vous pouvez connecter le débogueur dans votre éditeur, par exemple avec Visual Studio Code ou PyCharm.
-## Faites appel à `uvicorn`
+## Faites appel à `uvicorn` { #call-uvicorn }
Dans votre application FastAPI, importez et exécutez directement `uvicorn` :
-{* ../../docs_src/debugging/tutorial001.py hl[1,15] *}
+{* ../../docs_src/debugging/tutorial001_py39.py hl[1,15] *}
-### À propos de `__name__ == "__main__"`
+### À propos de `__name__ == "__main__"` { #about-name-main }
Le but principal de `__name__ == "__main__"` est d'avoir du code qui est exécuté lorsque votre fichier est appelé avec :
@@ -26,7 +26,7 @@ mais qui n'est pas appelé lorsqu'un autre fichier l'importe, comme dans :
from myapp import app
```
-#### Pour davantage de détails
+#### Pour davantage de détails { #more-details }
Imaginons que votre fichier s'appelle `myapp.py`.
@@ -78,7 +78,7 @@ Pour plus d'informations, consultez débogueur
+## Exécutez votre code avec votre débogueur { #run-your-code-with-your-debugger }
Parce que vous exécutez le serveur Uvicorn directement depuis votre code, vous pouvez appeler votre programme Python (votre application FastAPI) directement depuis le débogueur.
@@ -86,10 +86,10 @@ Parce que vous exécutez le serveur Uvicorn directement depuis votre code, vous
Par exemple, dans Visual Studio Code, vous pouvez :
-- Cliquer sur l'onglet "Debug" de la barre d'activités de Visual Studio Code.
-- "Add configuration...".
-- Sélectionnez "Python".
-- Lancez le débogueur avec l'option "`Python: Current File (Integrated Terminal)`".
+* Aller au panneau «Debug».
+* «Add configuration ...».
+* Sélectionnez «Python»
+* Lancez le débogueur 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.
@@ -101,10 +101,10 @@ Voici à quoi cela pourrait ressembler :
Si vous utilisez Pycharm, vous pouvez :
-- Ouvrir le menu "Run".
-- Sélectionnez l'option "Debug...".
-- Un menu contextuel s'affiche alors.
-- Sélectionnez le fichier à déboguer (dans ce cas, `main.py`).
+* Ouvrez le menu «Run».
+* Sélectionnez l'option «Debug ...».
+* Un menu contextuel s'affiche alors.
+* Sélectionnez le fichier à déboguer (dans ce cas, `main.py`).
Il démarrera alors le serveur avec votre code **FastAPI**, s'arrêtera à vos points d'arrêt, etc.
diff --git a/docs/fr/docs/tutorial/first-steps.md b/docs/fr/docs/tutorial/first-steps.md
index 96ea56e62..ceaf0fad5 100644
--- a/docs/fr/docs/tutorial/first-steps.md
+++ b/docs/fr/docs/tutorial/first-steps.md
@@ -1,107 +1,122 @@
-# Démarrage
+# Premiers pas { #first-steps }
-Le fichier **FastAPI** le plus simple possible pourrait ressembler à cela :
+Le fichier FastAPI le plus simple possible pourrait ressembler à ceci :
-{* ../../docs_src/first_steps/tutorial001.py *}
+{* ../../docs_src/first_steps/tutorial001_py39.py *}
-Copiez ce code dans un fichier nommé `main.py`.
+Copiez cela dans un fichier `main.py`.
-Démarrez le serveur :
+Lancez le serveur de développement :
get
+* en utilisant une opération get
/// info | `@décorateur` Info
-Cette syntaxe `@something` en Python est appelée un "décorateur".
+Cette syntaxe `@something` en Python est appelée un «décorateur».
-Vous la mettez au dessus d'une fonction. Comme un joli chapeau décoratif (j'imagine que ce terme vient de là 🤷🏻♂).
+Vous la placez au-dessus d’une fonction. Comme un joli chapeau décoratif (je suppose que c’est de là que vient le terme 🤷🏻♂).
-Un "décorateur" prend la fonction en dessous et en fait quelque chose.
+Un «décorateur» prend la fonction en dessous et fait quelque chose avec.
-Dans notre cas, ce décorateur dit à **FastAPI** que la fonction en dessous correspond au **chemin** `/` avec l'**opération** `get`.
+Dans notre cas, ce décorateur indique à **FastAPI** que la fonction en dessous correspond au **chemin** `/` avec l’**opération** `get`.
-C'est le "**décorateur d'opération de chemin**".
+C’est le «décorateur d’opération de chemin».
///
-Vous pouvez aussi utiliser les autres opérations :
+Vous pouvez aussi utiliser les autres opérations :
* `@app.post()`
* `@app.put()`
* `@app.delete()`
-Tout comme celles les plus exotiques :
+Et les plus exotiques :
* `@app.options()`
* `@app.head()`
@@ -278,58 +302,79 @@ Tout comme celles les plus exotiques :
/// tip | Astuce
-Vous êtes libres d'utiliser chaque opération (méthode HTTP) comme vous le désirez.
+Vous êtes libre d’utiliser chaque opération (méthode HTTP) comme vous le souhaitez.
-**FastAPI** n'impose pas de sens spécifique à chacune d'elle.
+**FastAPI** n’impose aucune signification spécifique.
-Les informations qui sont présentées ici forment une directive générale, pas des obligations.
+Les informations ici sont présentées comme des lignes directrices, pas comme une exigence.
-Par exemple, quand l'on utilise **GraphQL**, toutes les actions sont effectuées en utilisant uniquement des opérations `POST`.
+Par exemple, lorsque vous utilisez GraphQL, vous effectuez normalement toutes les actions en utilisant uniquement des opérations `POST`.
///
-### Étape 4 : définir la **fonction de chemin**.
+### Étape 4 : définir la **fonction d’opération de chemin** { #step-4-define-the-path-operation-function }
-Voici notre "**fonction de chemin**" (ou fonction d'opération de chemin) :
+Voici notre «fonction d’opération de chemin» :
* **chemin** : `/`.
* **opération** : `get`.
-* **fonction** : la fonction sous le "décorateur" (sous `@app.get("/")`).
+* **fonction** : la fonction sous le «décorateur» (sous `@app.get("/")`).
-{* ../../docs_src/first_steps/tutorial001.py hl[7] *}
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[7] *}
-C'est une fonction Python.
+C’est une fonction Python.
-Elle sera appelée par **FastAPI** quand une requête sur l'URL `/` sera reçue via une opération `GET`.
+Elle sera appelée par **FastAPI** chaque fois qu’il reçoit une requête vers l’URL «`/`» en utilisant une opération `GET`.
-Ici, c'est une fonction asynchrone (définie avec `async def`).
+Dans ce cas, c’est une fonction `async`.
---
-Vous pourriez aussi la définir comme une fonction classique plutôt qu'avec `async def` :
+Vous pourriez aussi la définir comme une fonction normale au lieu de `async def` :
-{* ../../docs_src/first_steps/tutorial003.py hl[7] *}
+{* ../../docs_src/first_steps/tutorial003_py39.py hl[7] *}
-/// note
+/// note | Remarque
-Si vous ne connaissez pas la différence, allez voir la section [Concurrence : *"Vous êtes pressés ?"*](../async.md#vous-etes-presses){.internal-link target=_blank}.
+Si vous ne connaissez pas la différence, consultez [Asynchrone : *«Pressé ?»*](../async.md#in-a-hurry){.internal-link target=_blank}.
///
-### Étape 5 : retourner le contenu
+### Étape 5 : retourner le contenu { #step-5-return-the-content }
-{* ../../docs_src/first_steps/tutorial001.py hl[8] *}
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[8] *}
-Vous pouvez retourner un dictionnaire (`dict`), une liste (`list`), des valeurs seules comme des chaines de caractères (`str`) et des entiers (`int`), etc.
+Vous pouvez retourner un `dict`, une `list`, des valeurs simples comme `str`, `int`, etc.
-Vous pouvez aussi retourner des models **Pydantic** (qui seront détaillés plus tard).
+Vous pouvez également retourner des modèles Pydantic (vous en verrez plus à ce sujet plus tard).
-Il y a de nombreux autres objets et modèles qui seront automatiquement convertis en JSON. Essayez d'utiliser vos favoris, il est fort probable qu'ils soient déjà supportés.
+Il existe de nombreux autres objets et modèles qui seront automatiquement convertis en JSON (y compris des ORM, etc.). Essayez d’utiliser vos préférés, il est très probable qu’ils soient déjà pris en charge.
-## Récapitulatif
+### Étape 6 : la déployer { #step-6-deploy-it }
+
+Déployez votre application sur **FastAPI Cloud** avec une seule commande : `fastapi deploy`. 🎉
+
+#### À propos de FastAPI Cloud { #about-fastapi-cloud }
+
+**FastAPI Cloud** est développé par le même auteur et la même équipe derrière **FastAPI**.
+
+Il rationalise le processus de **construction**, **déploiement** et **accès** à une API avec un effort minimal.
+
+Il apporte la même **expérience développeur** que pour la création d’applications avec FastAPI au **déploiement** dans le cloud. 🎉
+
+FastAPI Cloud est le sponsor principal et le financeur des projets open source *FastAPI and friends*. ✨
+
+#### Déployer sur d’autres fournisseurs cloud { #deploy-to-other-cloud-providers }
+
+FastAPI est open source et basé sur des standards. Vous pouvez déployer des applications FastAPI chez n’importe quel fournisseur cloud de votre choix.
+
+Suivez les guides de votre fournisseur cloud pour y déployer des applications FastAPI. 🤓
+
+## Récapitulatif { #recap }
* Importez `FastAPI`.
-* Créez une instance d'`app`.
-* Ajoutez une **décorateur d'opération de chemin** (tel que `@app.get("/")`).
-* Ajoutez une **fonction de chemin** (telle que `def root(): ...` comme ci-dessus).
-* Lancez le serveur de développement (avec `uvicorn main:app --reload`).
+* Créez une instance `app`.
+* Écrivez un **décorateur d’opération de chemin** avec des décorateurs comme `@app.get("/")`.
+* Définissez une **fonction d’opération de chemin** ; par exemple, `def root(): ...`.
+* Lancez le serveur de développement avec la commande `fastapi dev`.
+* Déployez éventuellement votre application avec `fastapi deploy`.
diff --git a/docs/fr/docs/tutorial/index.md b/docs/fr/docs/tutorial/index.md
index 83cc5f9e8..7492e14a7 100644
--- a/docs/fr/docs/tutorial/index.md
+++ b/docs/fr/docs/tutorial/index.md
@@ -1,29 +1,53 @@
-# Tutoriel - Guide utilisateur - Introduction
+# Tutoriel - Guide d'utilisation { #tutorial-user-guide }
Ce tutoriel vous montre comment utiliser **FastAPI** avec la plupart de ses fonctionnalités, étape par étape.
Chaque section s'appuie progressivement sur les précédentes, mais elle est structurée de manière à séparer les sujets, afin que vous puissiez aller directement à l'un d'entre eux pour résoudre vos besoins spécifiques en matière d'API.
-Il est également conçu pour fonctionner comme une référence future.
+Il est également conçu pour servir de référence future afin que vous puissiez revenir et voir exactement ce dont vous avez besoin.
-Vous pouvez donc revenir et voir exactement ce dont vous avez besoin.
-
-## Exécuter le code
+## Exécuter le code { #run-the-code }
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 commencez `uvicorn` avec :
+Pour exécuter l'un des exemples, copiez le code dans un fichier `main.py`, et lancez `fastapi dev` avec :
kwargs. Même s'ils n'ont pas de valeur par défaut.
-{* ../../docs_src/path_params_numeric_validations/tutorial003.py hl[7] *}
+{* ../../docs_src/path_params_numeric_validations/tutorial003_py39.py hl[7] *}
-# Avec `Annotated`
+### Mieux avec `Annotated` { #better-with-annotated }
Gardez à l'esprit que si vous utilisez `Annotated`, comme vous n'utilisez pas les valeurs par défaut des paramètres de fonction, vous n'aurez pas ce problème, et vous n'aurez probablement pas besoin d'utiliser `*`.
{* ../../docs_src/path_params_numeric_validations/tutorial003_an_py39.py hl[10] *}
-## Validations numériques : supérieur ou égal
+## Validations numériques : supérieur ou égal { #number-validations-greater-than-or-equal }
Avec `Query` et `Path` (et d'autres que vous verrez plus tard) vous pouvez déclarer des contraintes numériques.
-Ici, avec `ge=1`, `item_id` devra être un nombre entier "`g`reater than or `e`qual" à `1`.
+Ici, avec `ge=1`, `item_id` devra être un nombre entier «`g`reater than or `e`qual» à `1`.
{* ../../docs_src/path_params_numeric_validations/tutorial004_an_py39.py hl[10] *}
-## Validations numériques : supérieur ou égal et inférieur ou égal
-
-La même chose s'applique pour :
-
-* `gt` : `g`reater `t`han
-* `le` : `l`ess than or `e`qual
-
-{* ../../docs_src/path_params_numeric_validations/tutorial004_an_py39.py hl[10] *}
-
-## Validations numériques : supérieur et inférieur ou égal
+## Validations numériques : supérieur et inférieur ou égal { #number-validations-greater-than-and-less-than-or-equal }
La même chose s'applique pour :
@@ -117,7 +108,7 @@ La même chose s'applique pour :
{* ../../docs_src/path_params_numeric_validations/tutorial005_an_py39.py hl[10] *}
-## Validations numériques : flottants, supérieur et inférieur
+## Validations numériques : flottants, supérieur et inférieur { #number-validations-floats-greater-than-and-less-than }
Les validations numériques fonctionnent également pour les valeurs `float`.
@@ -129,7 +120,7 @@ Et la même chose pour lt.
{* ../../docs_src/path_params_numeric_validations/tutorial006_an_py39.py hl[13] *}
-## Pour résumer
+## Pour résumer { #recap }
Avec `Query`, `Path` (et d'autres que vous verrez plus tard) vous pouvez déclarer des métadonnées et des validations de chaînes de la même manière qu'avec les [Paramètres de requête et validations de chaînes](query-params-str-validations.md){.internal-link target=_blank}.
diff --git a/docs/fr/docs/tutorial/path-params.md b/docs/fr/docs/tutorial/path-params.md
index 71c96b18e..fd6a76933 100644
--- a/docs/fr/docs/tutorial/path-params.md
+++ b/docs/fr/docs/tutorial/path-params.md
@@ -1,37 +1,32 @@
-# Paramètres de chemin
+# Paramètres de chemin { #path-parameters }
-Vous pouvez déclarer des "paramètres" ou "variables" de chemin avec la même syntaxe que celle utilisée par le
-formatage de chaîne Python :
+Vous pouvez déclarer des «paramètres» ou «variables» de chemin avec la même syntaxe que celle utilisée par les chaînes de formatage Python :
+{* ../../docs_src/path_params/tutorial001_py39.py hl[6:7] *}
-{* ../../docs_src/path_params/tutorial001.py hl[6:7] *}
+La valeur du paramètre de chemin `item_id` sera transmise à la fonction dans l'argument `item_id`.
-La valeur du paramètre `item_id` sera transmise à la fonction dans l'argument `item_id`.
-
-Donc, si vous exécutez cet exemple et allez sur http://127.0.0.1:8000/items/foo,
-vous verrez comme réponse :
+Donc, si vous exécutez cet exemple et allez sur http://127.0.0.1:8000/items/foo, vous verrez comme réponse :
```JSON
{"item_id":"foo"}
```
-## Paramètres de chemin typés
+## Paramètres de chemin typés { #path-parameters-with-types }
-Vous pouvez déclarer le type d'un paramètre de chemin dans la fonction, en utilisant les annotations de type Python :
+Vous pouvez déclarer le type d'un paramètre de chemin dans la fonction, en utilisant les annotations de type Python standard :
-
-{* ../../docs_src/path_params/tutorial002.py hl[7] *}
+{* ../../docs_src/path_params/tutorial002_py39.py hl[7] *}
Ici, `item_id` est déclaré comme `int`.
/// check | vérifier
-Ceci vous permettra d'obtenir des fonctionnalités de l'éditeur dans votre fonction, telles
-que des vérifications d'erreur, de l'auto-complétion, etc.
+Ceci vous permettra d'obtenir des fonctionnalités de l'éditeur dans votre fonction, telles que des vérifications d'erreurs, de l'autocomplétion, etc.
///
-## Conversion de données
+## Conversion de données { #data-conversion }
Si vous exécutez cet exemple et allez sur http://127.0.0.1:8000/items/3, vous aurez comme réponse :
@@ -42,38 +37,37 @@ Si vous exécutez cet exemple et allez sur "parsing" automatique.
+Donc, avec cette déclaration de type, **FastAPI** vous fournit un «parsing» de la requête automatique.
///
-## Validation de données
+## Validation de données { #data-validation }
Si vous allez sur http://127.0.0.1:8000/items/foo, vous aurez une belle erreur HTTP :
```JSON
{
- "detail": [
- {
- "loc": [
- "path",
- "item_id"
- ],
- "msg": "value is not a valid integer",
- "type": "type_error.integer"
- }
- ]
+ "detail": [
+ {
+ "type": "int_parsing",
+ "loc": [
+ "path",
+ "item_id"
+ ],
+ "msg": "Input should be a valid integer, unable to parse string as an integer",
+ "input": "foo"
+ }
+ ]
}
```
-car le paramètre de chemin `item_id` possède comme valeur `"foo"`, qui ne peut pas être convertie en entier (`int`).
+car le paramètre de chemin `item_id` possède comme valeur «foo», qui n'est pas un `int`.
La même erreur se produira si vous passez un nombre flottant (`float`) et non un entier, comme ici
http://127.0.0.1:8000/items/4.2.
-
/// check | vérifier
Donc, avec ces mêmes déclarations de type Python, **FastAPI** vous fournit de la validation de données.
@@ -84,24 +78,24 @@ Ce qui est incroyablement utile au moment de développer et débugger du code qu
///
-## Documentation
+## Documentation { #documentation }
Et quand vous vous rendez sur http://127.0.0.1:8000/docs, vous verrez la
documentation générée automatiquement et interactive :
-/// info
+/// check | vérifier
-À nouveau, en utilisant uniquement les déclarations de type Python, **FastAPI** vous fournit automatiquement une documentation interactive (via Swagger UI).
+À nouveau, en utilisant uniquement les déclarations de type Python, **FastAPI** vous fournit automatiquement une documentation interactive (intégrant Swagger UI).
On voit bien dans la documentation que `item_id` est déclaré comme entier.
///
-## Les avantages d'avoir une documentation basée sur une norme, et la documentation alternative.
+## Les avantages d'avoir une documentation basée sur une norme, et la documentation alternative { #standards-based-benefits-alternative-documentation }
-Le schéma généré suivant la norme OpenAPI,
+Le schéma généré suivant la norme OpenAPI,
il existe de nombreux outils compatibles.
Grâce à cela, **FastAPI** lui-même fournit une documentation alternative (utilisant ReDoc), qui peut être lue
@@ -112,92 +106,96 @@ sur
De la même façon, il existe bien d'autres outils compatibles, y compris des outils de génération de code
pour de nombreux langages.
-## Pydantic
+## Pydantic { #pydantic }
-Toute la validation de données est effectué en arrière-plan avec Pydantic,
+Toute la validation de données est effectuée en arrière-plan avec Pydantic,
dont vous bénéficierez de tous les avantages. Vous savez donc que vous êtes entre de bonnes mains.
-## L'ordre importe
+Vous pouvez utiliser les mêmes déclarations de type avec `str`, `float`, `bool` et de nombreux autres types de données complexes.
-Quand vous créez des *fonctions de chemins*, vous pouvez vous retrouver dans une situation où vous avez un chemin fixe.
+Plusieurs d'entre eux sont explorés dans les prochains chapitres du tutoriel.
+
+## L'ordre importe { #order-matters }
+
+Quand vous créez des *opérations de chemin*, vous pouvez vous retrouver dans une situation où vous avez un chemin fixe.
Tel que `/users/me`, disons pour récupérer les données sur l'utilisateur actuel.
Et vous avez un second chemin : `/users/{user_id}` pour récupérer de la donnée sur un utilisateur spécifique grâce à son identifiant d'utilisateur
-Les *fonctions de chemin* étant évaluées dans l'ordre, il faut s'assurer que la fonction correspondant à `/users/me` est déclarée avant celle de `/users/{user_id}` :
+Les *opérations de chemin* étant évaluées dans l'ordre, il faut s'assurer que la fonction correspondant à `/users/me` est déclarée avant celle de `/users/{user_id}` :
-{* ../../docs_src/path_params/tutorial003.py hl[6,11] *}
+{* ../../docs_src/path_params/tutorial003_py39.py hl[6,11] *}
-Sinon, le chemin `/users/{user_id}` correspondrait aussi à `/users/me`, la fonction "croyant" qu'elle a reçu un paramètre `user_id` avec pour valeur `"me"`.
+Sinon, le chemin `/users/{user_id}` correspondrait aussi à `/users/me`, la fonction «croyant» qu'elle a reçu un paramètre `user_id` avec pour valeur «me».
-## Valeurs prédéfinies
+De même, vous ne pouvez pas redéfinir une opération de chemin :
-Si vous avez une *fonction de chemin* qui reçoit un *paramètre de chemin*, mais que vous voulez que les valeurs possibles des paramètres soient prédéfinies, vous pouvez utiliser les `Enum` de Python.
+{* ../../docs_src/path_params/tutorial003b_py39.py hl[6,11] *}
-### Création d'un `Enum`
+La première sera toujours utilisée car le chemin correspond d'abord.
-Importez `Enum` et créez une sous-classe qui hérite de `str` et `Enum`.
+## Valeurs prédéfinies { #predefined-values }
-En héritant de `str` la documentation sera capable de savoir que les valeurs doivent être de type `string` et pourra donc afficher cette `Enum` correctement.
+Si vous avez une *opération de chemin* qui reçoit un *paramètre de chemin*, mais que vous voulez que les valeurs possibles des paramètres soient prédéfinies, vous pouvez utiliser les `Enum` de Python.
+
+### Créer une classe `Enum` { #create-an-enum-class }
+
+Importez `Enum` et créez une sous-classe qui hérite de `str` et de `Enum`.
+
+En héritant de `str`, la documentation de l'API saura que les valeurs doivent être de type `string` et pourra donc l'afficher correctement.
Créez ensuite des attributs de classe avec des valeurs fixes, qui seront les valeurs autorisées pour cette énumération.
-{* ../../docs_src/path_params/tutorial005.py hl[1,6:9] *}
-
-/// info
-
-Les énumérations (ou enums) sont disponibles en Python depuis la version 3.4.
-
-///
+{* ../../docs_src/path_params/tutorial005_py39.py hl[1,6:9] *}
/// tip | Astuce
-Pour ceux qui se demandent, "AlexNet", "ResNet", et "LeNet" sont juste des noms de modèles de Machine Learning.
+Pour ceux qui se demandent, «AlexNet», «ResNet», et «LeNet» sont juste des noms de modèles de Machine Learning.
///
-### Déclarer un paramètre de chemin
+### Déclarer un *paramètre de chemin* { #declare-a-path-parameter }
Créez ensuite un *paramètre de chemin* avec une annotation de type désignant l'énumération créée précédemment (`ModelName`) :
-{* ../../docs_src/path_params/tutorial005.py hl[16] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[16] *}
-### Documentation
+### Vérifier la documentation { #check-the-docs }
Les valeurs disponibles pour le *paramètre de chemin* sont bien prédéfinies, la documentation les affiche correctement :
-### Manipuler les *énumérations* Python
+### Manipuler les *énumérations* Python { #working-with-python-enumerations }
-La valeur du *paramètre de chemin* sera un des "membres" de l'énumération.
+La valeur du *paramètre de chemin* sera un des «membres» de l'énumération.
-#### Comparer les *membres d'énumération*
+#### Comparer les *membres d'énumération* { #compare-enumeration-members }
Vous pouvez comparer ce paramètre avec les membres de votre énumération `ModelName` :
-{* ../../docs_src/path_params/tutorial005.py hl[17] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[17] *}
-#### Récupérer la *valeur de l'énumération*
+#### Récupérer la *valeur de l'énumération* { #get-the-enumeration-value }
-Vous pouvez obtenir la valeur réel d'un membre (une chaîne de caractères ici), avec `model_name.value`, ou en général, `votre_membre_d'enum.value` :
+Vous pouvez obtenir la valeur réelle d'un membre (une chaîne de caractères ici), avec `model_name.value`, ou en général, `votre_membre_d'enum.value` :
-{* ../../docs_src/path_params/tutorial005.py hl[20] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[20] *}
/// 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`.
///
-#### Retourner des *membres d'énumération*
+#### Retourner des *membres d'énumération* { #return-enumeration-members }
-Vous pouvez retourner des *membres d'énumération* dans vos *fonctions de chemin*, même imbriquée dans un JSON (e.g. un `dict`).
+Vous pouvez retourner des *membres d'énumération* dans vos *opérations de chemin*, même imbriqués dans un corps JSON (e.g. un `dict`).
Ils seront convertis vers leurs valeurs correspondantes (chaînes de caractères ici) avant d'être transmis au client :
-{* ../../docs_src/path_params/tutorial005.py hl[18,21,23] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[18,21,23] *}
Le client recevra une réponse JSON comme celle-ci :
@@ -208,23 +206,23 @@ Le client recevra une réponse JSON comme celle-ci :
}
```
-## Paramètres de chemin contenant des chemins
+## Paramètres de chemin contenant des chemins { #path-parameters-containing-paths }
-Disons que vous avez une *fonction de chemin* liée au chemin `/files/{file_path}`.
+Disons que vous avez une *opération de chemin* liée au chemin `/files/{file_path}`.
Mais que `file_path` lui-même doit contenir un *chemin*, comme `home/johndoe/myfile.txt` par exemple.
Donc, l'URL pour ce fichier pourrait être : `/files/home/johndoe/myfile.txt`.
-### Support d'OpenAPI
+### Support d'OpenAPI { #openapi-support }
-OpenAPI ne supporte pas de manière de déclarer un paramètre de chemin contenant un *chemin*, cela pouvant causer des scénarios difficiles à tester et définir.
+OpenAPI ne supporte pas de manière de déclarer un *paramètre de chemin* contenant un *chemin* à l'intérieur, cela pouvant causer des scénarios difficiles à tester et définir.
Néanmoins, cela reste faisable dans **FastAPI**, via les outils internes de Starlette.
-Et la documentation fonctionne quand même, bien qu'aucune section ne soit ajoutée pour dire que la paramètre devrait contenir un *chemin*.
+Et la documentation fonctionne quand même, bien qu'aucune section ne soit ajoutée pour dire que le paramètre devrait contenir un *chemin*.
-### Convertisseur de *chemin*
+### Convertisseur de *chemin* { #path-convertor }
En utilisant une option de Starlette directement, vous pouvez déclarer un *paramètre de chemin* contenant un *chemin* avec une URL comme :
@@ -232,11 +230,11 @@ En utilisant une option de Starlette directement, vous pouvez déclarer un *para
/files/{file_path:path}
```
-Dans ce cas, le nom du paramètre est `file_path`, et la dernière partie, `:path`, indique à Starlette que le paramètre devrait correspondre à un *chemin*.
+Dans ce cas, le nom du paramètre est `file_path`, et la dernière partie, `:path`, indique que le paramètre doit correspondre à n'importe quel *chemin*.
-Vous pouvez donc l'utilisez comme tel :
+Vous pouvez donc l'utiliser comme tel :
-{* ../../docs_src/path_params/tutorial004.py hl[6] *}
+{* ../../docs_src/path_params/tutorial004_py39.py hl[6] *}
/// tip | Astuce
@@ -246,15 +244,15 @@ Dans ce cas, l'URL serait : `/files//home/johndoe/myfile.txt`, avec un double sl
///
-## Récapitulatif
+## Récapitulatif { #recap }
Avec **FastAPI**, en utilisant les déclarations de type rapides, intuitives et standards de Python, vous bénéficiez de :
-* Support de l'éditeur : vérification d'erreurs, auto-complétion, etc.
-* "Parsing" de données.
-* Validation de données.
-* Annotations d'API et documentation automatique.
+* Support de l'éditeur : vérification d'erreurs, autocomplétion, etc.
+* «Parsing» de données
+* Validation de données
+* Annotations d'API et documentation automatique
Et vous n'avez besoin de le déclarer qu'une fois.
-C'est probablement l'avantage visible principal de **FastAPI** comparé aux autres *frameworks* (outre les performances pures).
+C'est probablement l'avantage visible principal de **FastAPI** comparé aux autres frameworks (outre les performances pures).
diff --git a/docs/fr/docs/tutorial/query-params-str-validations.md b/docs/fr/docs/tutorial/query-params-str-validations.md
index c54c0c717..9158cb767 100644
--- a/docs/fr/docs/tutorial/query-params-str-validations.md
+++ b/docs/fr/docs/tutorial/query-params-str-validations.md
@@ -1,166 +1,273 @@
-# Paramètres de requête et validations de chaînes de caractères
+# Paramètres de requête et validations de chaînes de caractères { #query-parameters-and-string-validations }
-**FastAPI** vous permet de déclarer des informations et des validateurs additionnels pour vos paramètres de requêtes.
+**FastAPI** vous permet de déclarer des informations et des validations supplémentaires pour vos paramètres.
-Commençons avec cette application pour exemple :
+Prenons cette application comme exemple :
-{* ../../docs_src/query_params_str_validations/tutorial001.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial001_py310.py hl[7] *}
-Le paramètre de requête `q` a pour type `Union[str, None]` (ou `str | None` en Python 3.10), signifiant qu'il est de type `str` mais pourrait aussi être égal à `None`, et bien sûr, la valeur par défaut est `None`, donc **FastAPI** saura qu'il n'est pas requis.
+Le paramètre de requête `q` est de type `str | None`, ce qui signifie qu'il est de type `str` mais peut aussi être `None`. D'ailleurs, la valeur par défaut est `None`, donc FastAPI saura qu'il n'est pas requis.
-/// note
+/// note | Remarque
-**FastAPI** saura que la valeur de `q` n'est pas requise grâce à la valeur par défaut `= None`.
+FastAPI saura que la valeur de `q` n'est pas requise grâce à la valeur par défaut `= None`.
-Le `Union` dans `Union[str, None]` permettra à votre éditeur de vous offrir un meilleur support et de détecter les erreurs.
+Le fait d'avoir `str | None` permettra à votre éditeur de vous offrir un meilleur support et de détecter les erreurs.
///
-## Validation additionnelle
+## Validation additionnelle { #additional-validation }
-Nous allons imposer que bien que `q` soit un paramètre optionnel, dès qu'il est fourni, **sa longueur n'excède pas 50 caractères**.
+Nous allons imposer que, même si `q` est optionnel, dès qu'il est fourni, **sa longueur n'excède pas 50 caractères**.
-## Importer `Query`
+### Importer `Query` et `Annotated` { #import-query-and-annotated }
-Pour cela, importez d'abord `Query` depuis `fastapi` :
+Pour cela, importez d'abord :
-{* ../../docs_src/query_params_str_validations/tutorial002.py hl[3] *}
+* `Query` depuis `fastapi`
+* `Annotated` depuis `typing`
-## Utiliser `Query` comme valeur par défaut
+{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[1,3] *}
-Construisez ensuite la valeur par défaut de votre paramètre avec `Query`, en choisissant 50 comme `max_length` :
+/// info
-{* ../../docs_src/query_params_str_validations/tutorial002.py hl[9] *}
+FastAPI a ajouté la prise en charge de `Annotated` (et a commencé à le recommander) dans la version 0.95.0.
-Comme nous devons remplacer la valeur par défaut `None` dans la fonction par `Query()`, nous pouvons maintenant définir la valeur par défaut avec le paramètre `Query(default=None)`, il sert le même objectif qui est de définir cette valeur par défaut.
+Si vous avez une version plus ancienne, vous obtiendrez des erreurs en essayant d'utiliser `Annotated`.
-Donc :
+Assurez-vous de [mettre à niveau la version de FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} vers au moins la 0.95.1 avant d'utiliser `Annotated`.
+
+///
+
+## Utiliser `Annotated` dans le type pour le paramètre `q` { #use-annotated-in-the-type-for-the-q-parameter }
+
+Vous vous souvenez, je vous ai dit plus tôt que `Annotated` pouvait être utilisé pour ajouter des métadonnées à vos paramètres dans l’[introduction aux types Python](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank} ?
+
+Il est temps de l'utiliser avec FastAPI. 🚀
+
+Nous avions cette annotation de type :
+
+//// tab | Python 3.10+
```Python
-q: Union[str, None] = Query(default=None)
+q: str | None = None
```
-... rend le paramètre optionnel, et est donc équivalent à :
+////
+
+//// tab | Python 3.9+
```Python
q: Union[str, None] = None
```
-Mais déclare explicitement `q` comme étant un paramètre de requête.
+////
-/// info
+Nous allons l'envelopper avec `Annotated`, ce qui donne :
-Gardez à l'esprit que la partie la plus importante pour rendre un paramètre optionnel est :
+//// tab | Python 3.10+
```Python
-= None
+q: Annotated[str | None] = None
```
-ou :
+////
+
+//// tab | Python 3.9+
```Python
-= Query(None)
+q: Annotated[Union[str, None]] = None
```
-et utilisera ce `None` pour détecter que ce paramètre de requête **n'est pas requis**.
+////
-Le `Union[str, None]` est uniquement là pour permettre à votre éditeur un meilleur support.
+Ces deux versions signifient la même chose : `q` est un paramètre qui peut être un `str` ou `None`, et par défaut, il vaut `None`.
+
+Passons maintenant aux choses amusantes. 🎉
+
+## Ajouter `Query` à `Annotated` dans le paramètre `q` { #add-query-to-annotated-in-the-q-parameter }
+
+Maintenant que nous avons ce `Annotated` dans lequel nous pouvons mettre plus d'informations (dans ce cas une validation supplémentaire), ajoutez `Query` à l'intérieur de `Annotated`, et définissez le paramètre `max_length` à `50` :
+
+{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[9] *}
+
+Notez que la valeur par défaut est toujours `None`, donc le paramètre est toujours optionnel.
+
+Mais maintenant, avec `Query(max_length=50)` à l'intérieur de `Annotated`, nous indiquons à FastAPI que nous voulons une **validation supplémentaire** pour cette valeur, nous voulons qu'elle ait au maximum 50 caractères. 😎
+
+/// tip | Astuce
+
+Ici, nous utilisons `Query()` parce qu'il s'agit d'un **paramètre de requête**. Plus tard, nous verrons d'autres objets comme `Path()`, `Body()`, `Header()` et `Cookie()`, qui acceptent aussi les mêmes arguments que `Query()`.
///
-Ensuite, nous pouvons passer d'autres paramètres à `Query`. Dans cet exemple, le paramètre `max_length` qui s'applique aux chaînes de caractères :
+FastAPI va maintenant :
+
+* **Valider** les données en s'assurant que la longueur maximale est de 50 caractères
+* Afficher une **erreur claire** au client lorsque les données ne sont pas valides
+* **Documenter** le paramètre dans l’*opération de chemin* du schéma OpenAPI (de sorte qu'il apparaisse dans **l'interface de documentation automatique**)
+
+## Alternative (ancien) : `Query` comme valeur par défaut { #alternative-old-query-as-the-default-value }
+
+Les versions précédentes de FastAPI (avant 0.95.0) vous obligeaient à utiliser `Query` comme valeur par défaut de votre paramètre, au lieu de le mettre dans `Annotated`. Il y a de fortes chances que vous voyiez du code qui l'utilise encore, donc je vais vous l'expliquer.
+
+/// tip | Astuce
+
+Pour un nouveau code et dès que possible, utilisez `Annotated` comme expliqué ci-dessus. Il y a de multiples avantages (expliqués ci-dessous) et aucun inconvénient. 🍰
+
+///
+
+Voici comment vous utiliseriez `Query()` comme valeur par défaut du paramètre de votre fonction, en définissant le paramètre `max_length` à 50 :
+
+{* ../../docs_src/query_params_str_validations/tutorial002_py310.py hl[7] *}
+
+Comme dans ce cas (sans utiliser `Annotated`) nous devons remplacer la valeur par défaut `None` dans la fonction par `Query()`, nous devons maintenant définir la valeur par défaut avec le paramètre `Query(default=None)`, cela sert le même objectif de définir cette valeur par défaut (au moins pour FastAPI).
+
+Donc :
```Python
-q: Union[str, None] = Query(default=None, max_length=50)
+q: str | None = Query(default=None)
```
-Cela va valider les données, montrer une erreur claire si ces dernières ne sont pas valides, et documenter le paramètre dans le schéma `OpenAPI` de cette *path operation*.
+... rend le paramètre optionnel, avec une valeur par défaut de `None`, ce qui est équivalent à :
-## Rajouter plus de validation
+```Python
+q: str | None = None
+```
-Vous pouvez aussi rajouter un second paramètre `min_length` :
+Mais la version avec `Query` le déclare explicitement comme étant un paramètre de requête.
-{* ../../docs_src/query_params_str_validations/tutorial003.py hl[9] *}
+Ensuite, nous pouvons passer d'autres paramètres à `Query`. Dans ce cas, le paramètre `max_length` qui s'applique aux chaînes de caractères :
-## Ajouter des validations par expressions régulières
+```Python
+q: str | None = Query(default=None, max_length=50)
+```
-On peut définir une expression régulière à laquelle le paramètre doit correspondre :
+Cela va valider les données, afficher une erreur claire lorsque les données ne sont pas valides, et documenter le paramètre dans l’*opération de chemin* du schéma OpenAPI.
-{* ../../docs_src/query_params_str_validations/tutorial004.py hl[10] *}
+### `Query` comme valeur par défaut ou dans `Annotated` { #query-as-the-default-value-or-in-annotated }
-Cette expression régulière vérifie que la valeur passée comme paramètre :
+Gardez à l'esprit qu'en utilisant `Query` à l'intérieur de `Annotated`, vous ne pouvez pas utiliser le paramètre `default` de `Query`.
-* `^` : commence avec les caractères qui suivent, avec aucun caractère avant ceux-là.
+Utilisez plutôt la véritable valeur par défaut du paramètre de fonction. Sinon, ce serait incohérent.
+
+Par exemple, ceci n'est pas autorisé :
+
+```Python
+q: Annotated[str, Query(default="rick")] = "morty"
+```
+
+... parce qu'il n'est pas clair si la valeur par défaut devrait être «rick» ou «morty».
+
+Ainsi, vous utiliseriez (de préférence) :
+
+```Python
+q: Annotated[str, Query()] = "rick"
+```
+
+... ou dans des bases de code plus anciennes, vous trouverez :
+
+```Python
+q: str = Query(default="rick")
+```
+
+### Avantages de `Annotated` { #advantages-of-annotated }
+
+**Utiliser `Annotated` est recommandé** plutôt que la valeur par défaut dans les paramètres de fonction, c'est **mieux** pour plusieurs raisons. 🤓
+
+La **valeur par défaut** du **paramètre de fonction** est la **véritable valeur par défaut**, c'est plus intuitif en Python en général. 😌
+
+Vous pourriez **appeler** cette même fonction **ailleurs** sans FastAPI, et elle **fonctionnerait comme prévu**. S'il y a un paramètre **requis** (sans valeur par défaut), votre **éditeur** vous le signalera avec une erreur, **Python** se plaindra aussi si vous l'exécutez sans passer le paramètre requis.
+
+Lorsque vous n'utilisez pas `Annotated` et que vous utilisez à la place l’**(ancien) style de valeur par défaut**, si vous appelez cette fonction sans FastAPI **ailleurs**, vous devez **penser** à passer les arguments à la fonction pour qu'elle fonctionne correctement, sinon les valeurs seront différentes de ce à quoi vous vous attendez (par exemple `QueryInfo` ou quelque chose de similaire au lieu de `str`). Et votre éditeur ne se plaindra pas, et Python ne se plaindra pas en exécutant cette fonction, seulement lorsque les opérations internes échoueront.
+
+Comme `Annotated` peut avoir plus d'une annotation de métadonnées, vous pouvez même utiliser la même fonction avec d'autres outils, comme Typer. 🚀
+
+## Ajouter plus de validations { #add-more-validations }
+
+Vous pouvez aussi ajouter un paramètre `min_length` :
+
+{* ../../docs_src/query_params_str_validations/tutorial003_an_py310.py hl[10] *}
+
+## Ajouter des expressions régulières { #add-regular-expressions }
+
+Vous pouvez définir un `pattern` d’expression régulière auquel le paramètre doit correspondre :
+
+{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}
+
+Ce motif d'expression régulière vérifie que la valeur de paramètre reçue :
+
+* `^` : commence avec les caractères qui suivent, n'a pas de caractères avant.
* `fixedquery` : a pour valeur exacte `fixedquery`.
-* `$` : se termine directement ensuite, n'a pas d'autres caractères après `fixedquery`.
+* `$` : se termine là, n'a pas d'autres caractères après `fixedquery`.
-Si vous vous sentez perdu avec le concept d'**expression régulière**, pas d'inquiétudes. Il s'agit d'une notion difficile pour beaucoup, et l'on peut déjà réussir à faire beaucoup sans jamais avoir à les manipuler.
+Si vous vous sentez perdu avec toutes ces idées d’**«expression régulière»**, pas d'inquiétude. C'est un sujet difficile pour beaucoup. Vous pouvez déjà faire beaucoup de choses sans avoir besoin des expressions régulières.
-Mais si vous décidez d'apprendre à les utiliser, sachez qu'ensuite vous pouvez les utiliser directement dans **FastAPI**.
+Maintenant vous savez que, lorsque vous en avez besoin, vous pouvez les utiliser dans **FastAPI**.
-## Valeurs par défaut
+## Valeurs par défaut { #default-values }
-De la même façon que vous pouvez passer `None` comme premier argument pour l'utiliser comme valeur par défaut, vous pouvez passer d'autres valeurs.
+Vous pouvez, bien sûr, utiliser des valeurs par défaut autres que `None`.
-Disons que vous déclarez le paramètre `q` comme ayant une longueur minimale de `3`, et une valeur par défaut étant `"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.py hl[7] *}
+{* ../../docs_src/query_params_str_validations/tutorial005_an_py39.py hl[9] *}
-/// note | Rappel
+/// note | Remarque
-Avoir une valeur par défaut rend le paramètre optionnel.
+Avoir une valeur par défaut de n'importe quel type, y compris `None`, rend le paramètre optionnel (non requis).
///
-## Rendre ce paramètre requis
+## Paramètres requis { #required-parameters }
-Quand on ne déclare ni validation, ni métadonnée, on peut rendre le paramètre `q` requis en ne lui déclarant juste aucune valeur par défaut :
+Quand nous n'avons pas besoin de déclarer plus de validations ou de métadonnées, nous pouvons rendre le paramètre de requête `q` requis simplement en ne déclarant pas de valeur par défaut, comme :
```Python
q: str
```
-à la place de :
+au lieu de :
```Python
-q: Union[str, None] = None
+q: str | None = None
```
-Mais maintenant, on déclare `q` avec `Query`, comme ceci :
+Mais nous le déclarons maintenant avec `Query`, par exemple ainsi :
```Python
-q: Union[str, None] = Query(default=None, min_length=3)
+q: Annotated[str | None, Query(min_length=3)] = None
```
-Donc pour déclarer une valeur comme requise tout en utilisant `Query`, il faut utiliser `...` comme premier argument :
+Donc, lorsque vous avez besoin de déclarer une valeur comme requise tout en utilisant `Query`, vous pouvez simplement ne pas déclarer de valeur par défaut :
-{* ../../docs_src/query_params_str_validations/tutorial006.py hl[7] *}
+{* ../../docs_src/query_params_str_validations/tutorial006_an_py39.py hl[9] *}
-/// info
+### Requis, peut être `None` { #required-can-be-none }
-Si vous n'avez jamais vu ce `...` auparavant : c'est une des constantes natives de Python appelée "Ellipsis".
+Vous pouvez déclarer qu'un paramètre peut accepter `None`, mais qu'il est tout de même requis. Cela obligera les clients à envoyer une valeur, même si la valeur est `None`.
-///
+Pour cela, vous pouvez déclarer que `None` est un type valide mais ne pas déclarer de valeur par défaut :
-Cela indiquera à **FastAPI** que la présence de ce paramètre est obligatoire.
+{* ../../docs_src/query_params_str_validations/tutorial006c_an_py310.py hl[9] *}
-## Liste de paramètres / valeurs multiples via Query
+## Liste de paramètres de requête / valeurs multiples { #query-parameter-list-multiple-values }
-Quand on définit un paramètre de requête explicitement avec `Query` on peut aussi déclarer qu'il reçoit une liste de valeur, ou des "valeurs multiples".
+Quand vous définissez un paramètre de requête explicitement avec `Query`, vous pouvez aussi déclarer qu'il reçoit une liste de valeurs, autrement dit, des valeurs multiples.
-Par exemple, pour déclarer un paramètre de requête `q` qui peut apparaître plusieurs fois dans une URL, on écrit :
+Par exemple, pour déclarer un paramètre de requête `q` qui peut apparaître plusieurs fois dans l'URL, vous pouvez écrire :
-{* ../../docs_src/query_params_str_validations/tutorial011.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial011_an_py310.py hl[9] *}
-Ce qui fait qu'avec une URL comme :
+Avec une URL comme :
```
http://localhost:8000/items/?q=foo&q=bar
```
-vous recevriez les valeurs des multiples paramètres de requête `q` (`foo` et `bar`) dans une `list` Python au sein de votre fonction de **path operation**, dans le paramètre de fonction `q`.
+vous recevrez les valeurs des multiples paramètres de requête `q` (`foo` et `bar`) dans une `list` Python au sein de votre *fonction d'opération de chemin*, dans le *paramètre de fonction* `q`.
-Donc la réponse de cette URL serait :
+Donc, la réponse à cette URL serait :
```JSON
{
@@ -173,19 +280,19 @@ Donc la réponse de cette URL serait :
/// tip | Astuce
-Pour déclarer un paramètre de requête de type `list`, comme dans l'exemple ci-dessus, il faut explicitement utiliser `Query`, sinon cela sera interprété comme faisant partie du corps de la requête.
+Pour déclarer un paramètre de requête de type `list`, comme dans l'exemple ci-dessus, vous devez explicitement utiliser `Query`, sinon cela sera interprété comme faisant partie du corps de la requête.
///
-La documentation sera donc mise à jour automatiquement pour autoriser plusieurs valeurs :
+Les documents interactifs de l'API seront mis à jour en conséquence, pour autoriser plusieurs valeurs :
-### Combiner liste de paramètres et valeurs par défaut
+### Liste de paramètres de requête / valeurs multiples avec valeurs par défaut { #query-parameter-list-multiple-values-with-defaults }
-Et l'on peut aussi définir une liste de valeurs par défaut si aucune n'est fournie :
+Vous pouvez aussi définir une `list` de valeurs par défaut si aucune n'est fournie :
-{* ../../docs_src/query_params_str_validations/tutorial012.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial012_an_py39.py hl[9] *}
Si vous allez à :
@@ -193,9 +300,7 @@ Si vous allez à :
http://localhost:8000/items/
```
-la valeur par défaut de `q` sera : `["foo", "bar"]`
-
-et la réponse sera :
+la valeur par défaut de `q` sera : `["foo", "bar"]` et votre réponse sera :
```JSON
{
@@ -206,93 +311,163 @@ et la réponse sera :
}
```
-#### Utiliser `list`
+#### Utiliser simplement `list` { #using-just-list }
-Il est aussi possible d'utiliser directement `list` plutôt que `List[str]` :
+Vous pouvez aussi utiliser `list` directement au lieu de `list[str]` :
-{* ../../docs_src/query_params_str_validations/tutorial013.py hl[7] *}
+{* ../../docs_src/query_params_str_validations/tutorial013_an_py39.py hl[9] *}
-/// note
+/// note | Remarque
-Dans ce cas-là, **FastAPI** ne vérifiera pas le contenu de la liste.
+Gardez à l'esprit que dans ce cas, FastAPI ne vérifiera pas le contenu de la liste.
-Par exemple, `List[int]` vérifiera (et documentera) que la liste est bien entièrement composée d'entiers. Alors qu'un simple `list` ne ferait pas cette vérification.
+Par exemple, `list[int]` vérifierait (et documenterait) que le contenu de la liste est composé d'entiers. Mais `list` seul ne le ferait pas.
///
-## Déclarer des métadonnées supplémentaires
+## Déclarer plus de métadonnées { #declare-more-metadata }
-On peut aussi ajouter plus d'informations sur le paramètre.
+Vous pouvez ajouter plus d'informations sur le paramètre.
-Ces informations seront incluses dans le schéma `OpenAPI` généré et utilisées par la documentation interactive ou les outils externes utilisés.
+Ces informations seront incluses dans l'OpenAPI généré et utilisées par les interfaces utilisateur de la documentation et les outils externes.
-/// note
+/// note | Remarque
-Gardez en tête que les outils externes utilisés ne supportent pas forcément tous parfaitement OpenAPI.
+Gardez à l'esprit que différents outils peuvent avoir des niveaux de prise en charge d'OpenAPI différents.
-Il se peut donc que certains d'entre eux n'utilisent pas toutes les métadonnées que vous avez déclarées pour le moment, bien que dans la plupart des cas, les fonctionnalités manquantes ont prévu d'être implémentées.
+Certains d'entre eux peuvent ne pas encore afficher toutes les informations supplémentaires déclarées, bien que, dans la plupart des cas, la fonctionnalité manquante soit déjà planifiée.
///
Vous pouvez ajouter un `title` :
-{* ../../docs_src/query_params_str_validations/tutorial007.py hl[10] *}
+{* ../../docs_src/query_params_str_validations/tutorial007_an_py310.py hl[10] *}
Et une `description` :
-{* ../../docs_src/query_params_str_validations/tutorial008.py hl[13] *}
+{* ../../docs_src/query_params_str_validations/tutorial008_an_py310.py hl[14] *}
-## Alias de paramètres
+## Alias de paramètres { #alias-parameters }
-Imaginez que vous vouliez que votre paramètre se nomme `item-query`.
+Imaginez que vous vouliez que le paramètre soit `item-query`.
-Comme dans la requête :
+Comme dans :
```
http://127.0.0.1:8000/items/?item-query=foobaritems
```
-Mais `item-query` n'est pas un nom de variable valide en Python.
+Mais `item-query` n'est pas un nom de variable Python valide.
-Le nom le plus proche serait `item_query`.
+Le plus proche serait `item_query`.
-Mais vous avez vraiment envie que ce soit exactement `item-query`...
+Mais vous avez quand même besoin que ce soit exactement `item-query`...
-Pour cela vous pouvez déclarer un `alias`, et cet alias est ce qui sera utilisé pour trouver la valeur du paramètre :
+Vous pouvez alors déclarer un `alias`, et cet alias sera utilisé pour trouver la valeur du paramètre :
-{* ../../docs_src/query_params_str_validations/tutorial009.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial009_an_py310.py hl[9] *}
-## Déprécier des paramètres
+## Déprécier des paramètres { #deprecating-parameters }
-Disons que vous ne vouliez plus utiliser ce paramètre désormais.
+Disons maintenant que vous n'aimez plus ce paramètre.
-Il faut qu'il continue à exister pendant un certain temps car vos clients l'utilisent, mais vous voulez que la documentation mentionne clairement que ce paramètre est déprécié.
+Vous devez le laisser pendant un certain temps car des clients l'utilisent, mais vous voulez que les documents l'affichent clairement comme déprécié.
-On utilise alors l'argument `deprecated=True` de `Query` :
+Passez alors le paramètre `deprecated=True` à `Query` :
-{* ../../docs_src/query_params_str_validations/tutorial010.py hl[18] *}
+{* ../../docs_src/query_params_str_validations/tutorial010_an_py310.py hl[19] *}
-La documentation le présentera comme il suit :
+Les documents l'afficheront ainsi :
-## Pour résumer
+## Exclure des paramètres d’OpenAPI { #exclude-parameters-from-openapi }
-Il est possible d'ajouter des validateurs et métadonnées pour vos paramètres.
+Pour exclure un paramètre de requête du schéma OpenAPI généré (et donc, des systèmes de documentation automatiques), définissez le paramètre `include_in_schema` de `Query` à `False` :
-Validateurs et métadonnées génériques:
+{* ../../docs_src/query_params_str_validations/tutorial014_an_py310.py hl[10] *}
+
+## Validation personnalisée { #custom-validation }
+
+Il peut y avoir des cas où vous avez besoin d'une **validation personnalisée** qui ne peut pas être réalisée avec les paramètres présentés ci-dessus.
+
+Dans ces cas, vous pouvez utiliser une **fonction de validation personnalisée** qui est appliquée après la validation normale (par exemple, après avoir validé que la valeur est une `str`).
+
+Vous pouvez y parvenir en utilisant `AfterValidator` de Pydantic à l'intérieur de `Annotated`.
+
+/// tip | Astuce
+
+Pydantic dispose aussi de `BeforeValidator` et d'autres. 🤓
+
+///
+
+Par exemple, ce validateur personnalisé vérifie que l'identifiant d'item commence par `isbn-` pour un numéro de livre ISBN ou par `imdb-` pour un identifiant d'URL de film IMDB :
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
+
+/// info
+
+Ceci est disponible avec Pydantic version 2 ou supérieure. 😎
+
+///
+
+/// tip | Astuce
+
+Si vous devez effectuer un type de validation nécessitant une communication avec un **composant externe**, comme une base de données ou une autre API, vous devriez plutôt utiliser les **dépendances FastAPI**, que vous apprendrez à connaître plus tard.
+
+Ces validateurs personnalisés sont destinés aux choses qui peuvent être vérifiées **uniquement** avec **les mêmes données** fournies dans la requête.
+
+///
+
+### Comprendre ce code { #understand-that-code }
+
+Le point important est simplement d'utiliser **`AfterValidator` avec une fonction à l'intérieur de `Annotated`**. N'hésitez pas à sauter cette partie. 🤸
+
+---
+
+Mais si vous êtes curieux à propos de cet exemple de code spécifique et que vous êtes toujours captivé, voici quelques détails supplémentaires.
+
+#### Chaîne avec `value.startswith()` { #string-with-value-startswith }
+
+L'avez-vous remarqué ? une chaîne utilisant `value.startswith()` peut prendre un tuple, et elle vérifiera chaque valeur du tuple :
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}
+
+#### Un élément aléatoire { #a-random-item }
+
+Avec `data.items()` nous obtenons un objet itérable avec des tuples contenant la clé et la valeur pour chaque élément du dictionnaire.
+
+Nous convertissons cet objet itérable en une véritable `list` avec `list(data.items())`.
+
+Ensuite, avec `random.choice()` nous pouvons obtenir une **valeur aléatoire** depuis la liste, donc nous obtenons un tuple `(id, name)`. Ce sera quelque chose comme («imdb-tt0371724», «The Hitchhiker's Guide to the Galaxy»).
+
+Nous **affectons ensuite ces deux valeurs** du tuple aux variables `id` et `name`.
+
+Ainsi, si l'utilisateur n'a pas fourni d'identifiant d'item, il recevra tout de même une suggestion aléatoire.
+
+... nous faisons tout cela en **une seule ligne simple**. 🤯 N'adorez-vous pas Python ? 🐍
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *}
+
+## Récapitulatif { #recap }
+
+Vous pouvez déclarer des validations supplémentaires et des métadonnées pour vos paramètres.
+
+Validations et métadonnées génériques :
* `alias`
* `title`
* `description`
* `deprecated`
-Validateurs spécifiques aux chaînes de caractères :
+Validations spécifiques aux chaînes de caractères :
* `min_length`
* `max_length`
-* `regex`
+* `pattern`
-Parmi ces exemples, vous avez pu voir comment déclarer des validateurs pour les chaînes de caractères.
+Validations personnalisées en utilisant `AfterValidator`.
-Dans les prochains chapitres, vous verrez comment déclarer des validateurs pour d'autres types, comme les nombres.
+Dans ces exemples, vous avez vu comment déclarer des validations pour des valeurs de `str`.
+
+Voir les prochains chapitres pour apprendre à déclarer des validations pour d'autres types, comme les nombres.
diff --git a/docs/fr/docs/tutorial/query-params.md b/docs/fr/docs/tutorial/query-params.md
index b87c26c78..6a0cecedc 100644
--- a/docs/fr/docs/tutorial/query-params.md
+++ b/docs/fr/docs/tutorial/query-params.md
@@ -1,10 +1,10 @@
-# Paramètres de requête
+# Paramètres de requête { #query-parameters }
-Quand vous déclarez des paramètres dans votre fonction de chemin qui ne font pas partie des paramètres indiqués dans le chemin associé, ces paramètres sont automatiquement considérés comme des paramètres de "requête".
+Lorsque vous déclarez d'autres paramètres de fonction qui ne font pas partie des paramètres de chemin, ils sont automatiquement interprétés comme des paramètres de «requête».
-{* ../../docs_src/query_params/tutorial001.py hl[9] *}
+{* ../../docs_src/query_params/tutorial001_py39.py hl[9] *}
-La partie appelée requête (ou **query**) dans une URL est l'ensemble des paires clés-valeurs placées après le `?` , séparées par des `&`.
+La partie appelée requête (ou «query») dans une URL est l'ensemble des paires clé-valeur placées après le `?`, séparées par des `&`.
Par exemple, dans l'URL :
@@ -12,9 +12,9 @@ Par exemple, dans l'URL :
http://127.0.0.1:8000/items/?skip=0&limit=10
```
-...les paramètres de requête sont :
+... les paramètres de requête sont :
-* `skip` : avec une valeur de`0`
+* `skip` : avec une valeur de `0`
* `limit` : avec une valeur de `10`
Faisant partie de l'URL, ces valeurs sont des chaînes de caractères (`str`).
@@ -23,12 +23,12 @@ Mais quand on les déclare avec des types Python (dans l'exemple précédent, en
Toutes les fonctionnalités qui s'appliquent aux paramètres de chemin s'appliquent aussi aux paramètres de requête :
-* Support de l'éditeur : vérification d'erreurs, auto-complétion, etc.
-* "Parsing" de données.
-* Validation de données.
-* Annotations d'API et documentation automatique.
+* Prise en charge par l'éditeur (évidemment)
+* «parsing» des données
+* Validation des données
+* Documentation automatique
-## Valeurs par défaut
+## Valeurs par défaut { #defaults }
Les paramètres de requête ne sont pas une partie fixe d'un chemin, ils peuvent être optionnels et avoir des valeurs par défaut.
@@ -57,33 +57,25 @@ Les valeurs des paramètres de votre fonction seront :
* `skip=20` : car c'est la valeur déclarée dans l'URL.
* `limit=10` : car `limit` n'a pas été déclaré dans l'URL, et que la valeur par défaut était `10`.
-## Paramètres optionnels
+## Paramètres optionnels { #optional-parameters }
De la même façon, vous pouvez définir des paramètres de requête comme optionnels, en leur donnant comme valeur par défaut `None` :
-{* ../../docs_src/query_params/tutorial002.py hl[9] *}
+{* ../../docs_src/query_params/tutorial002_py310.py hl[7] *}
Ici, le paramètre `q` sera optionnel, et aura `None` comme valeur par défaut.
-/// check | Remarque
+/// check | vérifier
On peut voir que **FastAPI** est capable de détecter que le paramètre de chemin `item_id` est un paramètre de chemin et que `q` n'en est pas un, c'est donc un paramètre de requête.
///
-/// note
+## Conversion des types des paramètres de requête { #query-parameter-type-conversion }
-**FastAPI** saura que `q` est optionnel grâce au `=None`.
+Vous pouvez aussi déclarer des types `bool`, ils seront convertis :
-Le `Optional` dans `Optional[str]` n'est pas utilisé par **FastAPI** (**FastAPI** n'en utilisera que la partie `str`), mais il servira tout de même à votre éditeur de texte pour détecter des erreurs dans votre code.
-
-///
-
-## Conversion des types des paramètres de requête
-
-Vous pouvez aussi déclarer des paramètres de requête comme booléens (`bool`), **FastAPI** les convertira :
-
-{* ../../docs_src/query_params/tutorial003.py hl[9] *}
+{* ../../docs_src/query_params/tutorial003_py310.py hl[7] *}
Avec ce code, en allant sur :
@@ -117,7 +109,7 @@ http://127.0.0.1:8000/items/foo?short=yes
ou n'importe quelle autre variation de casse (tout en majuscules, uniquement la première lettre en majuscule, etc.), votre fonction considérera le paramètre `short` comme ayant une valeur booléenne à `True`. Sinon la valeur sera à `False`.
-## Multiples paramètres de chemin et de requête
+## Multiples paramètres de chemin et de requête { #multiple-path-and-query-parameters }
Vous pouvez déclarer plusieurs paramètres de chemin et paramètres de requête dans la même fonction, **FastAPI** saura comment les gérer.
@@ -125,9 +117,9 @@ Et vous n'avez pas besoin de les déclarer dans un ordre spécifique.
Ils seront détectés par leurs noms :
-{* ../../docs_src/query_params/tutorial004.py hl[8,10] *}
+{* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}
-## Paramètres de requête requis
+## Paramètres de requête requis { #required-query-parameters }
Quand vous déclarez une valeur par défaut pour un paramètre qui n'est pas un paramètre de chemin (actuellement, nous n'avons vu que les paramètres de requête), alors ce paramètre n'est pas requis.
@@ -135,7 +127,7 @@ Si vous ne voulez pas leur donner de valeur par défaut mais juste les rendre op
Mais si vous voulez rendre un paramètre de requête obligatoire, vous pouvez juste ne pas y affecter de valeur par défaut :
-{* ../../docs_src/query_params/tutorial005.py hl[6:7] *}
+{* ../../docs_src/query_params/tutorial005_py39.py hl[6:7] *}
Ici le paramètre `needy` est un paramètre requis (ou obligatoire) de type `str`.
@@ -145,20 +137,21 @@ Si vous ouvrez une URL comme :
http://127.0.0.1:8000/items/foo-item
```
-...sans ajouter le paramètre requis `needy`, vous aurez une erreur :
+... sans ajouter le paramètre requis `needy`, vous verrez une erreur semblable à :
```JSON
{
- "detail": [
- {
- "loc": [
- "query",
- "needy"
- ],
- "msg": "field required",
- "type": "value_error.missing"
- }
- ]
+ "detail": [
+ {
+ "type": "missing",
+ "loc": [
+ "query",
+ "needy"
+ ],
+ "msg": "Field required",
+ "input": null
+ }
+ ]
}
```
@@ -168,7 +161,7 @@ La présence de `needy` étant nécessaire, vous auriez besoin de l'insérer dan
http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
```
-...ce qui fonctionnerait :
+... cela fonctionnerait :
```JSON
{
@@ -177,11 +170,11 @@ http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
}
```
-Et bien sur, vous pouvez définir certains paramètres comme requis, certains avec des valeurs par défaut et certains entièrement optionnels :
+Et bien sûr, vous pouvez définir certains paramètres comme requis, certains avec des valeurs par défaut et certains entièrement optionnels :
-{* ../../docs_src/query_params/tutorial006.py hl[10] *}
+{* ../../docs_src/query_params/tutorial006_py310.py hl[8] *}
-Ici, on a donc 3 paramètres de requête :
+Dans ce cas, on a 3 paramètres de requête :
* `needy`, requis et de type `str`.
* `skip`, un `int` avec comme valeur par défaut `0`.
@@ -189,6 +182,6 @@ Ici, on a donc 3 paramètres de requête :
/// tip | Astuce
-Vous pouvez utiliser les `Enum`s de la même façon qu'avec les [Paramètres de chemin](path-params.md#valeurs-predefinies){.internal-link target=_blank}.
+Vous pouvez utiliser les `Enum`s de la même façon qu'avec les [Paramètres de chemin](path-params.md#predefined-values){.internal-link target=_blank}.
///