//// tab | Info
-Les onglets et les blocs « Info »/« Note »/« Warning »/etc. doivent avoir la traduction de leur titre ajoutée aprÚs une barre verticale (« | »).
+Les onglets et les blocs « Info »/« Note »/« Warning »/etc. doivent avoir la traduction de leur titre ajoutée aprÚs une barre verticale (`|`).
Voir les sections `### Special blocks` et `### Tab blocks` dans lâinvite gĂ©nĂ©rale dans `scripts/translate.py`.
# 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 en utilisant une `JSONResponse`, en plaçant le contenu que vous renvoyez depuis votre *chemin d'accÚs* à 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*.
{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[18] *}
-Et de cette façon, nous pouvons « paramĂ©trer » notre dĂ©pendance, qui contient maintenant « bar », en tant quâattribut `checker.fixed_content`.
+Et de cette façon, nous pouvons « paramĂ©trer » notre dĂ©pendance, qui contient maintenant `"bar"`, en tant quâattribut `checker.fixed_content`.
## Utiliser l'instance comme dépendance { #use-the-instance-as-a-dependency }
{* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}
-Cela fonctionne grĂące Ă **Pydantic**, qui offre une [prise en charge interne des `dataclasses`](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel).
+C'est toujours pris en charge grĂące Ă **Pydantic**, qui offre une [prise en charge interne des `dataclasses`](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel).
Ainsi, mĂȘme avec le code ciâdessus qui n'emploie pas explicitement Pydantic, FastAPI utilise Pydantic pour convertir ces dataclasses standard en la variante de dataclasses de Pydantic.
/// note | Remarque
-Gardez Ă l'esprit que les dataclasses ne peuvent pas tout ce que peuvent faire les modĂšles Pydantic.
+Gardez Ă l'esprit que les dataclasses ne peuvent pas faire tout ce que peuvent faire les modĂšles Pydantic.
Vous pourriez donc avoir encore besoin d'utiliser des modĂšles Pydantic.
### ĂvĂ©nement `startup` { #startup-event }
-Pour ajouter une fonction qui doit ĂȘtre exĂ©cutĂ©e avant le dĂ©marrage de l'application, dĂ©clarez-la avec l'Ă©vĂ©nement « startup » :
+Pour ajouter une fonction qui doit ĂȘtre exĂ©cutĂ©e avant le dĂ©marrage de l'application, dĂ©clarez-la avec l'Ă©vĂ©nement `"startup"` :
{* ../../docs_src/events/tutorial001_py310.py hl[8] *}
### ĂvĂ©nement `shutdown` { #shutdown-event }
-Pour ajouter une fonction qui doit ĂȘtre exĂ©cutĂ©e lorsque l'application s'arrĂȘte, dĂ©clarez-la avec l'Ă©vĂ©nement « shutdown » :
+Pour ajouter une fonction qui doit ĂȘtre exĂ©cutĂ©e lorsque l'application s'arrĂȘte, dĂ©clarez-la avec l'Ă©vĂ©nement `"shutdown"` :
{* ../../docs_src/events/tutorial002_py310.py hl[6] *}
-Ici, la fonction gestionnaire de l'événement `shutdown` écrira une ligne de texte « Application shutdown » dans un fichier `log.txt`.
+Ici, la fonction gestionnaire de l'événement `shutdown` écrira une ligne de texte `"Application shutdown"` dans un fichier `log.txt`.
/// note | Remarque
///
-## Générateurs de SDK par les sponsors de FastAPI { #sdk-generators-from-fastapi-sponsors }
-
-Cette section met en avant des solutions **soutenues par des fonds** et **par des entreprises** qui sponsorisent FastAPI. Ces produits offrent **des fonctionnalités supplémentaires** et **des intégrations** en plus de SDK de haute qualité générés.
-
-En âš [**sponsorisant FastAPI**](../help-fastapi.md#sponsor-the-author) âš, ces entreprises contribuent Ă garantir que le framework et son **Ă©cosystĂšme** restent sains et **durables**.
-
-Leur sponsoring dĂ©montre Ă©galement un fort engagement envers la **communautĂ©** FastAPI (vous), montrant quâelles se soucient non seulement dâoffrir un **excellent service**, mais aussi de soutenir un **framework robuste et florissant**, FastAPI. đ
-
-Par exemple, vous pourriez essayer :
-
-* [Stainless](https://www.stainless.com/?utm_source=fastapi&utm_medium=referral)
-
-Certaines de ces solutions peuvent aussi ĂȘtre open source ou proposer des niveaux gratuits, afin que vous puissiez les essayer sans engagement financier. Dâautres gĂ©nĂ©rateurs de SDK commerciaux existent et peuvent ĂȘtre trouvĂ©s en ligne. đ€
-
## Créer un SDK TypeScript { #create-a-typescript-sdk }
Commençons par une application FastAPI simple :
### Hey API { #hey-api }
-Une fois que vous avez une application FastAPI avec les modÚles, vous pouvez utiliser Hey API pour générer un client TypeScript. Le moyen le plus rapide de le faire est via npx.
+Une fois que nous avons une application FastAPI avec les modÚles, nous pouvons utiliser Hey API pour générer un client TypeScript. Le moyen le plus rapide de le faire est via npx.
```sh
npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
## Base64 vs fichiers { #base64-vs-files }
-Envisagez d'abord d'utiliser [Fichiers de requĂȘte](../tutorial/request-files.md) pour tĂ©lĂ©verser des donnĂ©es binaires et [RĂ©ponse personnalisĂ©e - FileResponse](./custom-response.md#fileresponse--fileresponse-) pour envoyer des donnĂ©es binaires, plutĂŽt que de les encoder dans du JSON.
+Envisagez d'abord d'utiliser [Fichiers de requĂȘte](../tutorial/request-files.md) pour tĂ©lĂ©verser des donnĂ©es binaires et [RĂ©ponse personnalisĂ©e - FileResponse](./custom-response.md#fileresponse) pour envoyer des donnĂ©es binaires, plutĂŽt que de les encoder dans du JSON.
JSON ne peut contenir que des chaßnes encodées en UTF-8, il ne peut donc pas contenir d'octets bruts.
## Pydantic `bytes` { #pydantic-bytes }
-Vous pouvez déclarer un modÚle Pydantic avec des champs `bytes`, puis utiliser `val_json_bytes` dans la configuration du modÚle pour lui indiquer d'utiliser base64 pour valider les données JSON en entrée ; dans le cadre de cette validation, il décodera la chaßne base64 en octets.
+Vous pouvez déclarer un modÚle Pydantic avec des champs `bytes`, puis utiliser `val_json_bytes` dans la configuration du modÚle pour lui indiquer d'utiliser base64 pour *valider* les données JSON en entrée ; dans le cadre de cette validation, il décodera la chaßne base64 en octets.
{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
## Pydantic `bytes` pour les données de sortie { #pydantic-bytes-for-output-data }
-Vous pouvez également utiliser des champs `bytes` avec `ser_json_bytes` dans la configuration du modÚle pour les données de sortie ; Pydantic sérialisera alors les octets en base64 lors de la génération de la réponse JSON.
+Vous pouvez également utiliser des champs `bytes` avec `ser_json_bytes` dans la configuration du modÚle pour les données de sortie ; Pydantic *sérialisera* alors les octets en base64 lors de la génération de la réponse JSON.
{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,12:16,29,38:41] hl[16] *}
## Pydantic `bytes` pour les données d'entrée et de sortie { #pydantic-bytes-for-input-and-output-data }
-Et bien sĂ»r, vous pouvez utiliser le mĂȘme modĂšle configurĂ© pour utiliser base64 afin de gĂ©rer Ă la fois l'entrĂ©e (valider) avec `val_json_bytes` et la sortie (sĂ©rialiser) avec `ser_json_bytes` lors de la rĂ©ception et de l'envoi de donnĂ©es JSON.
+Et bien sĂ»r, vous pouvez utiliser le mĂȘme modĂšle configurĂ© pour utiliser base64 afin de gĂ©rer Ă la fois l'entrĂ©e (*valider*) avec `val_json_bytes` et la sortie (*sĂ©rialiser*) avec `ser_json_bytes` lors de la rĂ©ception et de l'envoi de donnĂ©es JSON.
{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,19:26,29,44:46] hl[23:26] *}
# Callbacks OpenAPI { #openapi-callbacks }
-Vous pourriez crĂ©er une API avec un *chemin d'accĂšs* qui dĂ©clenche une requĂȘte vers une *API externe* crĂ©Ă©e par quelqu'un d'autre (probablement la mĂȘme personne dĂ©veloppeuse qui utiliserait votre API).
+Vous pourriez crĂ©er une API avec un *chemin d'accĂšs* qui dĂ©clenche une requĂȘte vers une *API externe* crĂ©Ă©e par quelqu'un d'autre (probablement la mĂȘme personne dĂ©veloppeuse qui *utiliserait* votre API).
-Le processus qui se produit lorsque votre application API appelle lâ*API externe* sâappelle un « callback ». Parce que le logiciel Ă©crit par la personne dĂ©veloppeuse externe envoie une requĂȘte Ă votre API puis votre API « rappelle », en envoyant une requĂȘte Ă une *API externe* (probablement crĂ©Ă©e par la mĂȘme personne dĂ©veloppeuse).
+Le processus qui se produit lorsque votre application API appelle lâ*API externe* sâappelle un « callback ». Parce que le logiciel Ă©crit par la personne dĂ©veloppeuse externe envoie une requĂȘte Ă votre API puis votre API *rappelle*, en envoyant une requĂȘte Ă une *API externe* (probablement crĂ©Ă©e par la mĂȘme personne dĂ©veloppeuse).
-Dans ce cas, vous pourriez vouloir documenter à quoi cette API externe devrait ressembler. Quel *chemin d'accÚs* elle devrait avoir, quel corps elle devrait attendre, quelle réponse elle devrait renvoyer, etc.
+Dans ce cas, vous pourriez vouloir documenter à quoi cette API externe *devrait* ressembler. Quel *chemin d'accÚs* elle devrait avoir, quel corps elle devrait attendre, quelle réponse elle devrait renvoyer, etc.
## Une application avec des callbacks { #an-app-with-callbacks }
Et il variera probablement beaucoup dâune application Ă lâautre.
-Cela pourrait ĂȘtre seulement une ou deux lignes de code, comme :
+Cela pourrait ĂȘtre seulement une ou deux lignes de code, comme :
```Python
callback_url = "https://example.com/api/v1/invoices/events/"
Pour crĂ©er le *chemin d'accĂšs* du callback, utilisez le mĂȘme `APIRouter` que vous avez crĂ©Ă© ci-dessus.
-Il devrait ressembler exactement à un *chemin d'accÚs* FastAPI normal :
+Il devrait ressembler exactement Ă un *chemin d'accĂšs* FastAPI normal :
* Il devrait probablement dĂ©clarer le corps quâil doit recevoir, par exemple `body: InvoiceEvent`.
* Et il pourrait aussi dĂ©clarer la rĂ©ponse quâil doit renvoyer, par exemple `response_model=InvoiceEventReceived`.
{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[14:16,19:20,26:30] *}
-Il y a 2 principales différences par rapport à un *chemin d'accÚs* normal :
+Il y a 2 principales différences par rapport à un *chemin d'accÚs* normal :
* Il nâa pas besoin dâavoir de code rĂ©el, car votre application nâappellera jamais ce code. Il sert uniquement Ă documenter lâ*API externe*. La fonction peut donc simplement contenir `pass`.
-* Le *chemin* peut contenir une [expression OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) (voir plus bas) oĂč il peut utiliser des variables avec des paramĂštres et des parties de la requĂȘte originale envoyĂ©e Ă *votre API*.
+* Le *chemin* peut contenir une [expression OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) (voir plus bas) oĂč il peut utiliser des variables avec des paramĂštres et des parties de la requĂȘte originale envoyĂ©e Ă *votre API*.
### Lâexpression du chemin de callback { #the-callback-path-expression }
-Le *chemin* du callback peut contenir une [expression OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) qui peut inclure des parties de la requĂȘte originale envoyĂ©e Ă *votre API*.
+Le *chemin* du callback peut contenir une [expression OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) qui peut inclure des parties de la requĂȘte originale envoyĂ©e Ă *votre API*.
-Dans ce cas, câest la `str`Â :
+Dans ce cas, câest la `str` :
```Python
"{$callback_url}/invoices/{$request.body.id}"
```
-Ainsi, si lâutilisateur de votre API (la personne dĂ©veloppeuse externe) envoie une requĂȘte Ă *votre API* vers :
+Ainsi, si lâutilisateur de votre API (la personne dĂ©veloppeuse externe) envoie une requĂȘte Ă *votre API* vers :
```
https://yourapi.com/invoices/?callback_url=https://www.external.org/events
```
-avec un corps JSONÂ :
+avec un corps JSON :
```JSON
{
}
```
-alors *votre API* traitera la facture et, Ă un moment ultĂ©rieur, enverra une requĂȘte de callback Ă `callback_url` (lâ*API externe*) :
+alors *votre API* traitera la facture et, Ă un moment ultĂ©rieur, enverra une requĂȘte de callback Ă `callback_url` (lâ*API externe*) :
```
https://www.external.org/events/invoices/2expen51ve
```
-avec un corps JSON contenant quelque chose comme :
+avec un corps JSON contenant quelque chose comme :
```JSON
{
}
```
-et elle sâattendra Ă une rĂ©ponse de cette *API externe* avec un corps JSON comme :
+et elle sâattendrait Ă une rĂ©ponse de cette *API externe* avec un corps JSON comme :
```JSON
{
Ă ce stade, vous avez le(s) *chemin(s) d'accĂšs de callback* nĂ©cessaire(s) (celui/ceux que la *personne dĂ©veloppeuse externe* doit implĂ©menter dans lâ*API externe*) dans le routeur de callback que vous avez crĂ©Ă© ci-dessus.
-Utilisez maintenant le paramĂštre `callbacks` dans *le dĂ©corateur de chemin d'accĂšs de votre API* pour passer lâattribut `.routes` depuis ce routeur de callback :
+Utilisez maintenant le paramĂštre `callbacks` dans *le dĂ©corateur de chemin d'accĂšs de votre API* pour passer lâattribut `.routes` depuis ce routeur de callback :
{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[33] *}
Vous pouvez maintenant démarrer votre application et aller sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
-Vous verrez votre documentation incluant une section « Callbacks » pour votre *chemin d'accĂšs* qui montre Ă quoi lâ*API externe* devrait ressembler :
+Vous verrez votre documentation incluant une section « Callbacks » pour votre *chemin d'accĂšs* qui montre Ă quoi lâ*API externe* devrait ressembler :
<img src="/img/tutorial/openapi-callbacks/image01.png">
## Utiliser un paramĂštre `Response` { #use-a-response-parameter }
-Vous pouvez dĂ©clarer un paramĂštre de type `Response` dans votre fonction de chemin d'accĂšs (comme vous pouvez le faire pour les cookies et les en-tĂȘtes).
+Vous pouvez dĂ©clarer un paramĂštre de type `Response` dans votre *fonction de chemin d'accĂšs* (comme vous pouvez le faire pour les cookies et les en-tĂȘtes).
Vous pouvez ensuite définir le `status_code` dans cet objet de réponse *temporaire*.
# Cookies de réponse { #response-cookies }
+
## Utiliser un paramĂštre `Response` { #use-a-response-parameter }
Vous pouvez déclarer un paramÚtre de type `Response` dans votre *fonction de chemin d'accÚs*.
## Utiliser un paramĂštre `Response` { #use-a-response-parameter }
-Vous pouvez déclarer un paramÚtre de type `Response` dans votre fonction de chemin d'accÚs (comme vous pouvez le faire pour les cookies).
+Vous pouvez déclarer un paramÚtre de type `Response` dans votre *fonction de chemin d'accÚs* (comme vous pouvez le faire pour les cookies).
-Vous pouvez ensuite dĂ©finir des en-tĂȘtes dans cet objet de rĂ©ponse temporaire.
+Vous pouvez ensuite dĂ©finir des en-tĂȘtes dans cet objet de rĂ©ponse *temporaire*.
{* ../../docs_src/response_headers/tutorial002_py310.py hl[1, 7:8] *}
Et si vous avez déclaré un `response_model`, il sera toujours utilisé pour filtrer et convertir l'objet que vous avez renvoyé.
-**FastAPI** utilisera cette rĂ©ponse temporaire pour extraire les en-tĂȘtes (ainsi que les cookies et le code de statut), et les placera dans la rĂ©ponse finale qui contient la valeur que vous avez renvoyĂ©e, filtrĂ©e par tout `response_model`.
+**FastAPI** utilisera cette rĂ©ponse *temporaire* pour extraire les en-tĂȘtes (ainsi que les cookies et le code de statut), et les placera dans la rĂ©ponse finale qui contient la valeur que vous avez renvoyĂ©e, filtrĂ©e par tout `response_model`.
Vous pouvez Ă©galement dĂ©clarer le paramĂštre `Response` dans des dĂ©pendances, et y dĂ©finir des en-tĂȘtes (et des cookies).
Vous pouvez utiliser des scopes OAuth2 directement avec **FastAPI**, ils sont intégrés pour fonctionner de maniÚre transparente.
-Cela vous permettrait dâavoir un systĂšme dâautorisations plus fin, conforme au standard OAuth2, intĂ©grĂ© Ă votre application OpenAPI (et Ă la documentation de lâAPI).
+Cela vous permettrait dâavoir un systĂšme dâautorisations plus fin, conforme au standard OAuth2, intĂ©grĂ© Ă votre application OpenAPI (et aux documents de lâAPI).
OAuth2 avec scopes est le mĂ©canisme utilisĂ© par de nombreux grands fournisseurs dâauthentification, comme Facebook, Google, GitHub, Microsoft, X (Twitter), etc. Ils lâutilisent pour fournir des permissions spĂ©cifiques aux utilisateurs et aux applications.
-Chaque fois que vous « log in with » Facebook, Google, GitHub, Microsoft, X (Twitter), cette application utilise OAuth2 avec scopes.
+Chaque fois que vous utilisez « se connecter avec » Facebook, Google, GitHub, Microsoft, X (Twitter), cette application utilise OAuth2 avec scopes.
Dans cette section, vous verrez comment gĂ©rer lâauthentification et lâautorisation avec le mĂȘme OAuth2 avec scopes dans votre application **FastAPI**.
Vous nâavez pas nĂ©cessairement besoin des scopes OAuth2, et vous pouvez gĂ©rer lâauthentification et lâautorisation comme vous le souhaitez.
-Mais OAuth2 avec scopes peut sâintĂ©grer Ă©lĂ©gamment Ă votre API (avec OpenAPI) et Ă votre documentation dâAPI.
+Mais OAuth2 avec scopes peut sâintĂ©grer Ă©lĂ©gamment Ă votre API (avec OpenAPI) et Ă vos documents dâAPI.
NĂ©anmoins, câest toujours Ă vous de faire appliquer ces scopes, ou toute autre exigence de sĂ©curitĂ©/autorisation, selon vos besoins, dans votre code.
Ces scopes représentent des « permissions ».
-Dans OpenAPI (par ex. la documentation de lâAPI), vous pouvez dĂ©finir des « schĂ©mas de sĂ©curitĂ© ».
+Dans OpenAPI (par ex. les documents de lâAPI), vous pouvez dĂ©finir des « schĂ©mas de sĂ©curitĂ© ».
Lorsquâun de ces schĂ©mas de sĂ©curitĂ© utilise OAuth2, vous pouvez aussi dĂ©clarer et utiliser des scopes.
{* ../../docs_src/security/tutorial005_an_py310.py hl[63:66] *}
-Comme nous dĂ©clarons maintenant ces scopes, ils apparaĂźtront dans la documentation de lâAPI lorsque vous vous authentifiez/autorisez.
+Comme nous dĂ©clarons maintenant ces scopes, ils apparaĂźtront dans les documents de lâAPI lorsque vous vous authentifiez/autorisez.
Et vous pourrez sĂ©lectionner Ă quels scopes vous souhaitez accorder lâaccĂšs : `me` et `items`.
## Tester { #check-it }
-Si vous ouvrez la documentation de lâAPI, vous pouvez vous authentifier et spĂ©cifier quels scopes vous voulez autoriser.
+Si vous ouvrez les documents de lâAPI, vous pouvez vous authentifier et spĂ©cifier quels scopes vous voulez autoriser.
<img src="/img/tutorial/security/image11.png">
-Si vous ne sĂ©lectionnez aucun scope, vous serez « authenticated », mais lorsque vous essayerez dâaccĂ©der Ă `/users/me/` ou `/users/me/items/`, vous obtiendrez une erreur indiquant que vous nâavez pas suffisamment de permissions. Vous pourrez toujours accĂ©der Ă `/status/`.
+Si vous ne sĂ©lectionnez aucun scope, vous serez « authentifiĂ© », mais lorsque vous essayerez dâaccĂ©der Ă `/users/me/` ou `/users/me/items/`, vous obtiendrez une erreur indiquant que vous nâavez pas suffisamment de permissions. Vous pourrez toujours accĂ©der Ă `/status/`.
Et si vous sélectionnez le scope `me` mais pas le scope `items`, vous pourrez accéder à `/users/me/` mais pas à `/users/me/items/`.
///
-Nous pouvons ensuite l'exiger depuis la fonction de chemin d'accĂšs comme dĂ©pendance et l'utiliser oĂč nous en avons besoin.
+Nous pouvons ensuite l'exiger depuis la *fonction de chemin d'accĂšs* comme dĂ©pendance et l'utiliser oĂč nous en avons besoin.
{* ../../docs_src/settings/app02_an_py310/main.py hl[17,19:21] *}
Si vous voulez diffuser des donnĂ©es pouvant ĂȘtre structurĂ©es en JSON, vous devez [Diffuser des JSON Lines](../tutorial/stream-json-lines.md).
-Mais si vous voulez diffuser des données binaires pures ou des chaßnes, voici comment procéder.
+Mais si vous voulez **diffuser des données binaires pures** ou des chaßnes, voici comment procéder.
/// note | Remarque
Vous pouvez l'utiliser si vous souhaitez diffuser des chaĂźnes pures, par exemple directement depuis la sortie d'un service d'**IA LLM**.
-Vous pouvez également l'utiliser pour diffuser de gros fichiers binaires, en envoyant chaque bloc de données au fur et à mesure de la lecture, sans tout charger en mémoire d'un coup.
+Vous pouvez également l'utiliser pour diffuser de **gros fichiers binaires**, en envoyant chaque bloc de données au fur et à mesure de la lecture, sans tout charger en mémoire d'un coup.
Vous pouvez aussi diffuser de la **vidĂ©o** ou de l'**audio** de cette maniĂšre ; cela peut mĂȘme ĂȘtre gĂ©nĂ©rĂ© au fil du traitement et de l'envoi.
FastAPI transmettra chaque bloc de données à la `StreamingResponse` tel quel ; il n'essaiera pas de le convertir en JSON ni autre chose similaire.
-### Fonctions de chemin d'accĂšs non async { #non-async-path-operation-functions }
+### *Fonctions de chemin d'accĂšs* non async { #non-async-path-operation-functions }
Vous pouvez Ă©galement utiliser des fonctions `def` classiques (sans `async`), et utiliser `yield` de la mĂȘme maniĂšre.
{* ../../docs_src/stream_data/tutorial001_py310.py ln[32:35] hl[33] *}
-Cela signifie aussi qu'avec `StreamingResponse` vous avez la libertĂ© â et la responsabilitĂ© â de produire et d'encoder les octets de donnĂ©es exactement comme vous avez besoin de les envoyer, indĂ©pendamment des annotations de type. đ€
+Cela signifie aussi qu'avec `StreamingResponse` vous avez la **libertĂ©** et la **responsabilitĂ©** de produire et d'encoder les octets de donnĂ©es exactement comme vous avez besoin de les envoyer, indĂ©pendamment des annotations de type. đ€
### Diffuser des bytes { #stream-bytes }
# Inclure WSGI - Flask, Django, autres { #including-wsgi-flask-django-others }
+
Vous pouvez monter des applications WSGI comme vous l'avez vu avec [Sous-applications - Montages](sub-applications.md), [DerriĂšre un proxy](behind-a-proxy.md).
Pour cela, vous pouvez utiliser `WSGIMiddleware` et l'utiliser pour envelopper votre application WSGI, par exemple Flask, Django, etc.
/// note | Remarque
-Django REST Framework a été créé par Tom Christie. Le créateur de Starlette et Uvicorn, sur lesquels **FastAPI** est basé.
+Django REST Framework a Ă©tĂ© crĂ©Ă© par Tom Christie. Le mĂȘme crĂ©ateur de Starlette et Uvicorn, sur lesquels **FastAPI** est basĂ©.
///
/// tip | A inspirĂ© **FastAPI** Ă
-Avoir une interface de documentation automatique de l'API.
+Avoir une interface utilisateur web de documentation automatique de l'API.
///
### [Flask](https://flask.palletsprojects.com) { #flask }
-Flask est un « microâframework », il ne comprend pas d'intĂ©grations de bases de donnĂ©es ni beaucoup de choses qui sont fournies par dĂ©faut dans Django.
+Flask est un « microframework », il ne comprend pas d'intégrations de bases de données ni beaucoup de choses qui sont fournies par défaut dans Django.
Cette simplicité et cette flexibilité permettent d'utiliser des bases de données NoSQL comme principal systÚme de stockage de données.
Il est aussi couramment utilisĂ© pour d'autres applications qui n'ont pas nĂ©cessairement besoin d'une base de donnĂ©es, de gestion des utilisateurs ou de l'une des nombreuses fonctionnalitĂ©s prĂ©installĂ©es dans Django. Bien que beaucoup de ces fonctionnalitĂ©s puissent ĂȘtre ajoutĂ©es avec des plug-ins.
-Ce dĂ©couplage des parties, et le fait d'ĂȘtre un « microâframework » qui puisse ĂȘtre Ă©tendu pour couvrir exactement ce
+Ce dĂ©couplage des parties, et le fait d'ĂȘtre un « microframework » qui puisse ĂȘtre Ă©tendu pour couvrir exactement ce
qui est nécessaire, était une caractéristique clé que je voulais conserver.
Compte tenu de la simplicité de Flask, il semblait bien adapté à la création d'API. La prochaine chose à trouver était un « Django REST Framework » pour Flask.
/// tip | A inspirĂ© **FastAPI** Ă
-Ătre un microâframework. Il est donc facile de combiner les outils et les piĂšces nĂ©cessaires.
+Ătre un micro-framework. Il est donc facile de combiner les outils et les piĂšces nĂ©cessaires.
-Proposer un systĂšme de routage simple et facile Ă utiliser.
+Proposer un systĂšme de routing simple et facile Ă utiliser.
///
### [Requests](https://requests.readthedocs.io) { #requests }
-**FastAPI** n'est pas réellement une alternative à **Requests**. Leur cadre est trÚs différent.
+**FastAPI** n'est pas réellement une alternative à **Requests**. Leur portée est trÚs différente.
Il serait en fait plus courant d'utiliser Requests _à l'intérieur_ d'une application FastAPI.
Ils sont, plus ou moins, aux extrémités opposées, se complétant l'un l'autre.
-Requests a un design trÚs simple et intuitif, il est trÚs facile à utiliser, avec des valeurs par défaut raisonnables, tout en étant trÚs puissant et personnalisable.
+Requests a un design trĂšs simple et intuitif, il est trĂšs facile Ă utiliser, avec des valeurs par dĂ©faut raisonnables. Mais en mĂȘme temps, il est trĂšs puissant et personnalisable.
C'est pourquoi, comme le dit le site officiel :
response = requests.get("http://example.com/some/url")
```
-LâopĂ©ration de chemin d'accĂšs correspondante dans **FastAPI** pourrait ressembler Ă ceci :
+Le *chemin d'accĂšs* d'API correspondant dans **FastAPI** pourrait ressembler Ă ceci :
```Python hl_lines="1"
@app.get("/some/url")
### [Swagger](https://swagger.io/) / [OpenAPI](https://github.com/OAI/OpenAPI-Specification/) { #swagger-openapi }
-La principale fonctionnalité que j'ai emprunté à Django REST Framework était la documentation automatique des API.
+La principale fonctionnalité que j'ai empruntée à Django REST Framework était la documentation automatique des API.
Puis j'ai découvert qu'il existait une norme pour documenter les API, en utilisant JSON (ou YAML, une extension de JSON) appelée Swagger.
Adopter et utiliser une norme ouverte pour les spécifications des API, au lieu d'un schéma personnalisé.
-Intégrer des outils d'interface utilisateur basés sur des normes :
+Et intégrer des outils d'interface utilisateur basés sur des normes :
* [Swagger UI](https://github.com/swagger-api/swagger-ui)
* [ReDoc](https://github.com/Rebilly/ReDoc)
-Ces deux-là ont été choisis parce qu'ils sont populaires et stables, mais en faisant une recherche rapide, vous pourriez trouver des dizaines d'alternatives supplémentaires pour OpenAPI (que vous pouvez utiliser avec **FastAPI**).
+Ces deux-là ont été choisis parce qu'ils sont populaires et stables, mais en faisant une recherche rapide, vous pourriez trouver des dizaines d'interfaces utilisateur alternatives pour OpenAPI (que vous pouvez utiliser avec **FastAPI**).
///
### [Marshmallow](https://marshmallow.readthedocs.io/en/stable/) { #marshmallow }
-L'une des principales fonctionnalitĂ©s nĂ©cessaires aux systĂšmes API est la « <dfn title="aussi appelĂ© : marshalling, conversion">sĂ©rialisation</dfn> » des donnĂ©es, qui consiste Ă prendre les donnĂ©es du code (Python) et Ă
+L'une des principales fonctionnalitĂ©s nĂ©cessaires aux systĂšmes API est la « <dfn title="aussi appelĂ© marshalling, conversion">sĂ©rialisation</dfn> » des donnĂ©es, qui consiste Ă prendre les donnĂ©es du code (Python) et Ă
les convertir en quelque chose qui peut ĂȘtre envoyĂ© sur le rĂ©seau. Par exemple, convertir un objet contenant des
données provenant d'une base de données en un objet JSON. Convertir des objets `datetime` en strings, etc.
La validation des données est une autre fonctionnalité importante dont ont besoin les API. Elle permet de s'assurer
que les données sont valides, compte tenu de certains paramÚtres. Par exemple, qu'un champ est un `int`, et non un
-string.
-Ceci est particuliÚrement utile pour les données entrantes.
+string. Ceci est particuliÚrement utile pour les données entrantes.
Sans un systÚme de validation des données, vous devriez effectuer toutes les vérifications à la main, dans le code.
/// note | Remarque
-Webargs a été créé par les développeurs de Marshmallow.
+Webargs a Ă©tĂ© crĂ©Ă© par les mĂȘmes dĂ©veloppeurs de Marshmallow.
///
C'est ainsi que cela fonctionne dans Flask, Starlette, Responder, etc.
-Mais alors, nous avons Ă nouveau le problĂšme d'avoir une micro-syntaxe, dans une docstring Python (un gros morceau de YAML).
+Mais alors, nous avons Ă nouveau le problĂšme d'avoir une micro-syntaxe, dans une string Python (un gros morceau de YAML).
L'éditeur ne peut guÚre aider en la matiÚre. Et si nous modifions les paramÚtres ou les schémas Marshmallow et que nous oublions de modifier également cette docstring YAML, le schéma généré deviendrait obsolÚte.
/// note | Remarque
-APISpec a été créé par les développeurs de Marshmallow.
+APISpec a Ă©tĂ© crĂ©Ă© par les mĂȘmes dĂ©veloppeurs de Marshmallow.
///
* [https://github.com/tiangolo/full-stack-flask-couchbase](https://github.com/tiangolo/full-stack-flask-couchbase)
* [https://github.com/tiangolo/full-stack-flask-couchdb](https://github.com/tiangolo/full-stack-flask-couchdb)
-Ces mĂȘmes gĂ©nĂ©rateurs full-stack ont servi de base aux [GĂ©nĂ©rateurs de projets pour **FastAPI**](project-generation.md).
+Et ces mĂȘmes gĂ©nĂ©rateurs full-stack ont servi de base aux [GĂ©nĂ©rateurs de projets **FastAPI**](project-generation.md).
/// note | Remarque
-Flask-apispec a été créé par les développeurs de Marshmallow.
+Flask-apispec a Ă©tĂ© crĂ©Ă© par les mĂȘmes dĂ©veloppeurs de Marshmallow.
///
/// note | DĂ©tails techniques
-Il utilisait [`uvloop`](https://github.com/MagicStack/uvloop) au lieu du systÚme par défaut de Python `asyncio`. C'est ce qui l'a rendu si rapide.
+Il utilisait [`uvloop`](https://github.com/MagicStack/uvloop) au lieu de la boucle par défaut de Python `asyncio`. C'est ce qui l'a rendu si rapide.
-Il a clairement inspiré Uvicorn et Starlette, qui sont actuellement plus rapides que Sanic dans les benchmarks.
+Il a clairement inspiré Uvicorn et Starlette, qui sont actuellement plus rapides que Sanic dans les benchmarks ouverts.
///
Il est conçu pour avoir des fonctions qui reçoivent deux paramĂštres, une « requĂȘte » et une « rĂ©ponse ». Ensuite, vous
« lisez » des parties de la requĂȘte et « Ă©crivez » des parties dans la rĂ©ponse. En raison de cette conception, il n'est
-pas possible de dĂ©clarer des paramĂštres de requĂȘte et des corps avec des indications de type Python standard comme paramĂštres de fonction.
+pas possible de dĂ©clarer des paramĂštres de requĂȘte et des corps avec des annotations de type Python standard comme paramĂštres de fonction.
Ainsi, la validation, la sĂ©rialisation et la documentation des donnĂ©es doivent ĂȘtre effectuĂ©es dans le code, et non pas automatiquement. Ou bien elles doivent ĂȘtre implĂ©mentĂ©es comme un framework au-dessus de Falcon, comme Hug. Cette mĂȘme distinction se retrouve dans d'autres frameworks qui s'inspirent de la conception de Falcon, qui consiste Ă avoir un objet de requĂȘte et un objet de rĂ©ponse comme paramĂštres.
* Validation et documentation via ces types.
* SystÚme d'injection de dépendances.
-Il n'utilise pas une librairie tiers de validation, sérialisation et de documentation tel que Pydantic, il utilise son propre systÚme. Ainsi, ces définitions de types de données ne sont pas réutilisables aussi facilement.
+Il n'utilise pas une librairie tierce de validation, sérialisation et de documentation telle que Pydantic, il utilise son propre systÚme. Ainsi, ces définitions de types de données ne sont pas réutilisables aussi facilement.
Il nécessite une configuration un peu plus verbeuse. Et comme il est basé sur WSGI (au lieu d'ASGI), il n'est pas
conçu pour profiter des hautes performances fournies par des outils comme Uvicorn, Starlette et Sanic.
/// note | Remarque
-Hug a été créé par Timothy Crosley, le créateur de [`isort`](https://github.com/timothycrosley/isort), un excellent outil pour trier automatiquement les imports dans les fichiers Python.
+Hug a Ă©tĂ© crĂ©Ă© par Timothy Crosley, le mĂȘme crĂ©ateur de [`isort`](https://github.com/timothycrosley/isort), un excellent outil pour trier automatiquement les imports dans les fichiers Python.
///
Il disposait de la validation automatique, sĂ©rialisation des donnĂ©es et d'une gĂ©nĂ©ration de schĂ©ma OpenAPI basĂ©e sur les mĂȘmes annotations de type Ă plusieurs endroits.
-La dĂ©finition du schĂ©ma de corps de requĂȘte n'utilisait pas les mĂȘmes annotations de type Python que Pydantic, il Ă©tait un peu plus proche de Marshmallow, donc le support de l'Ă©diteur n'Ă©tait pas aussi bon, mais APIStar Ă©tait quand mĂȘme la meilleure option disponible.
+Les dĂ©finitions de schĂ©ma de corps n'utilisaient pas les mĂȘmes annotations de type Python que Pydantic, c'Ă©tait un peu plus proche de Marshmallow, donc le support de l'Ă©diteur n'Ă©tait pas aussi bon, mais APIStar Ă©tait quand mĂȘme la meilleure option disponible.
Il avait les meilleures performances d'aprÚs les benchmarks de l'époque (seulement surpassé par Starlette).
-Au départ, il ne disposait pas d'une interface web de documentation automatique de l'API, mais je savais que je pouvais lui ajouter une interface Swagger.
+Au départ, il ne disposait pas d'une interface utilisateur web de documentation automatique de l'API, mais je savais que je pouvais lui ajouter Swagger UI.
Il avait un systĂšme d'injection de dĂ©pendances. Il nĂ©cessitait un prĂ©-enregistrement des composants, comme d'autres outils discutĂ©s ci-dessus. Mais c'Ă©tait quand mĂȘme une excellente fonctionnalitĂ©.
Et aprÚs avoir longtemps cherché un framework similaire et testé de nombreuses alternatives, APIStar était la meilleure option disponible.
-Puis APIStar a cessé d'exister en tant que serveur et Starlette a été créé, et a constitué une meilleure base pour un tel systÚme. Ce fut l'inspiration finale pour construire **FastAPI**.
+Puis APIStar a cessé d'exister en tant que serveur et Starlette a été créé, et a constitué une nouvelle base meilleure pour un tel systÚme. Ce fut l'inspiration finale pour construire **FastAPI**.
Je considÚre **FastAPI** comme un « successeur spirituel » d'APIStar, tout en améliorant et en augmentant les fonctionnalités, le systÚme de typage et d'autres parties, sur la base des enseignements tirés de tous ces outils précédents.
/// tip | **FastAPI** l'utilise pour
-Gérer toute la validation des données, leur sérialisation et la documentation automatique du modÚle (basée sur le schéma JSON).
+Gérer toute la validation des données, leur sérialisation et la documentation automatique du modÚle (basée sur JSON Schema).
**FastAPI** prend ensuite ces données JSON Schema et les place dans OpenAPI, en plus de toutes les autres choses qu'il fait.
Il offre :
-- Des performances vraiment impressionnantes.
-- Le support des WebSockets.
-- Les tĂąches d'arriĂšre-plan.
-- Les Ă©vĂ©nements de dĂ©marrage et d'arrĂȘt.
-- Un client de test basé sur HTTPX.
-- CORS, GZip, fichiers statiques, streaming des réponses.
-- Le support des sessions et des cookies.
-- Une couverture de test Ă 100 %.
-- 100 % de la base de code avec des annotations de type.
-- Peu de dépendances strictes.
+* Des performances vraiment impressionnantes.
+* Le support de WebSocket.
+* Les tĂąches d'arriĂšre-plan in-process.
+* Les Ă©vĂ©nements de dĂ©marrage et d'arrĂȘt.
+* Un client de test basé sur HTTPX.
+* CORS, GZip, fichiers statiques, streaming des réponses.
+* Le support des sessions et des cookies.
+* Une couverture de test Ă 100 %.
+* 100 % de la base de code avec des annotations de type.
+* Peu de dépendances strictes.
Starlette est actuellement le framework Python le plus rapide testé. Seulement dépassé par Uvicorn, qui n'est pas un framework, mais un serveur.
-Starlette fournit toutes les fonctionnalitĂ©s de base d'un microâframework web.
+Starlette fournit toutes les fonctionnalités de base d'un microframework web.
Mais il ne fournit pas de validation automatique des données, de sérialisation ou de documentation.
Uvicorn est un serveur ASGI rapide comme l'éclair, basé sur uvloop et httptools.
-Il ne s'agit pas d'un framework web, mais d'un serveur. Par exemple, il ne fournit pas d'outils pour le routing. C'est
+Il ne s'agit pas d'un framework web, mais d'un serveur. Par exemple, il ne fournit pas d'outils pour le routing par chemins. C'est
quelque chose qu'un framework comme Starlette (ou **FastAPI**) fournirait par-dessus.
C'est le serveur recommandé pour Starlette et **FastAPI**.
---
-Si vous ne savez pas, utilisez seulement `def`.
+Si vous ne savez pas, utilisez un `def` normal.
---
-Note : vous pouvez mĂ©langer `def` et `async def` dans vos *fonctions de chemin d'accĂšs* autant que nĂ©cessaire, et dĂ©finir chacune avec lâoption la plus adaptĂ©e pour vous. FastAPI fera ce qu'il faut avec elles.
+**Remarque** : vous pouvez mĂ©langer `def` et `async def` dans vos *fonctions de chemin d'accĂšs* autant que nĂ©cessaire, et dĂ©finir chacune avec lâoption la plus adaptĂ©e pour vous. FastAPI fera ce qu'il faut avec elles.
Au final, peu importe le cas parmi ceux ci-dessus, FastAPI fonctionnera de maniĂšre asynchrone et sera extrĂȘmement rapide.
-Mais si vous suivez bien les instructions ci-dessus, il pourra effectuer quelques optimisations et ainsi améliorer les performances.
+Mais si vous suivez bien les Ă©tapes ci-dessus, il pourra effectuer quelques optimisations de performance.
## DĂ©tails techniques { #technical-details }
-Les versions modernes de Python supportent le **code asynchrone** grùce aux **« coroutines »** avec les syntaxes **`async` et `await`**.
+Les versions modernes de Python supportent le **« code asynchrone »** en utilisant quelque chose appelé **« coroutines »**, avec la syntaxe **`async` et `await`**.
Analysons les différentes parties de cette phrase dans les sections suivantes :
Donc, pendant ce temps, l'ordinateur pourra effectuer d'autres tĂąches, pendant que « slow-file » đ se termine.
-Ensuite l'ordinateur / le programme đ€ reviendra Ă chaque fois qu'il en a la chance que ce soit parce qu'il attend Ă nouveau, ou car il đ€ a fini tout le travail qu'il avait Ă faire. Il đ€ regardera donc si les tĂąches qu'il attend ont terminĂ© d'ĂȘtre effectuĂ©es.
+Ensuite l'ordinateur / le programme đ€ reviendra Ă chaque fois qu'il en a la chance, parce qu'il attend Ă nouveau, ou quand il đ€ a fini tout le travail qu'il avait Ă faire Ă ce moment-lĂ . Et il đ€ regardera si des tĂąches qu'il attendait ont dĂ©jĂ terminĂ©, en faisant ce qu'il devait faire.
Ensuite, il đ€ prendra la premiĂšre tĂąche Ă finir (disons, notre « slow-file » đ) et continuera Ă faire avec cette derniĂšre ce qu'il Ă©tait censĂ©.
* de la donnée envoyée depuis votre programme soit reçue par le client à travers le réseau
* le contenu d'un fichier sur le disque soit lu par le systÚme et passé à votre programme
* le contenu que votre programme a passé au systÚme soit écrit sur le disque
-* une opération effectuée à distance par une API se termine
+* une opération effectuée à distance par une API
* une opération en base de données se termine
* une requĂȘte Ă une base de donnĂ©es renvoie un rĂ©sultat
* etc.
Le temps d'exécution étant consommé majoritairement par l'attente d'opérations <abbr title="Input and Output - Entrées et sorties">I/O</abbr>, on appelle ceci des opérations « I/O bound ».
-Ce concept se nomme « asynchrone » car l'ordinateur / le programme n'a pas besoin d'ĂȘtre « synchronisĂ© » avec la tĂąche, attendant le moment exact oĂč cette derniĂšre se terminera en ne faisant rien, pour ĂȘtre capable de rĂ©cupĂ©rer le rĂ©sultat de la tĂąche et l'utiliser dans la suite des opĂ©rations.
+Ce concept se nomme « asynchrone » car l'ordinateur / le programme n'a pas besoin d'ĂȘtre « synchronisĂ© » avec la tĂąche lente, attendant le moment exact oĂč cette derniĂšre se terminera en ne faisant rien, pour ĂȘtre capable de rĂ©cupĂ©rer le rĂ©sultat de la tĂąche et l'utiliser dans la suite des opĂ©rations.
-à la place, en étant « asynchrone », une fois terminée, une tùche peut légÚrement attendre (quelques microsecondes) que l'ordinateur / le programme finisse ce qu'il était en train de faire, et revienne récupérer le résultat.
+à la place, en étant un systÚme « asynchrone », une fois terminée, la tùche peut attendre un peu dans la file (quelques microsecondes) que l'ordinateur / le programme finisse ce qu'il était en train de faire, puis revienne récupérer les résultats et continue à travailler avec eux.
-Pour parler de tĂąches « synchrones » (en opposition à « asynchrones »), on utilise souvent le terme « sĂ©quentiel », car l'ordinateur / le programme va effectuer toutes les Ă©tapes d'une tĂąche sĂ©quentiellement avant de passer Ă une autre tĂąche, mĂȘme si ces Ă©tapes impliquent de l'attente.
+Pour parler de tĂąches « synchrones » (en opposition à « asynchrones »), on utilise souvent aussi le terme « sĂ©quentiel », car l'ordinateur / le programme va effectuer toutes les Ă©tapes d'une tĂąche sĂ©quentiellement avant de passer Ă une autre tĂąche, mĂȘme si ces Ă©tapes impliquent de l'attente.
### Concurrence et Burgers { #concurrency-and-burgers }
La **concurrence** et le **parallĂ©lisme** sont tous deux liĂ©s Ă l'idĂ©e de « diffĂ©rentes choses arrivant plus ou moins au mĂȘme moment ».
-Mais les détails entre la **concurrence** et le **parallélisme** diffÚrent sur de nombreux points.
+Mais les détails entre la *concurrence* et le *parallélisme* sont assez différents.
-Pour expliquer la différence, voici une histoire de burgers :
+Pour expliquer la différence, imaginez l'histoire suivante à propos de burgers :
### Burgers concurrents { #concurrent-burgers }
-Vous amenez votre crush đ dans votre fast food đ favori, et faites la queue pendant que le serveur đ prend les commandes des personnes devant vous.
+Vous allez avec votre crush chercher de la nourriture dans un fast food, vous faites la queue pendant que le caissier prend les commandes des personnes devant vous. đ
<img src="/img/async/concurrent-burgers/concurrent-burgers-01.png" class="illustration">
-Puis vient votre tour, vous commandez alors 2 magnifiques burgers đ pour votre crush đ et vous.
+Puis vient votre tour, vous commandez alors 2 burgers trĂšs sophistiquĂ©s pour votre crush et vous. đđ
<img src="/img/async/concurrent-burgers/concurrent-burgers-02.png" class="illustration">
-Le serveur đ dit quelque chose Ă son collĂšgue dans la cuisine đšâđł pour qu'il sache qu'il doit prĂ©parer vos burgers đ (bien qu'il soit dĂ©jĂ en train de prĂ©parer ceux des clients prĂ©cĂ©dents).
+Le caissier dit quelque chose au cuisinier dans la cuisine pour qu'il sache qu'il doit préparer vos burgers (bien qu'il soit déjà en train de préparer ceux des clients précédents).
<img src="/img/async/concurrent-burgers/concurrent-burgers-03.png" class="illustration">
-Vous payez đž.
+Vous payez. đž
-Le serveur đ vous donne le numĂ©ro assignĂ© Ă votre commande.
+Le caissier vous donne le numéro de votre tour.
<img src="/img/async/concurrent-burgers/concurrent-burgers-04.png" class="illustration">
-Pendant que vous attendez, vous allez choisir une table avec votre crush đ, vous discutez avec votre crush đ pendant un long moment (les burgers Ă©tant « magnifiques » ils sont trĂšs longs Ă prĂ©parer âšđâš).
+Pendant que vous attendez, vous allez choisir une table avec votre crush, vous vous asseyez et discutez avec votre crush pendant un long moment (vos burgers étant trÚs sophistiqués, ils prennent du temps à préparer).
-Pendant que vous ĂȘtes assis Ă table, en attendant que les burgers đ soient prĂȘts, vous pouvez passer ce temps Ă admirer Ă quel point votre crush đ est gĂ©niale, mignonne et intelligente âšđâš.
+Pendant que vous ĂȘtes assis Ă table avec votre crush, en attendant les burgers, vous pouvez passer ce temps Ă admirer Ă quel point votre crush est gĂ©niale, mignonne et intelligente âšđâš.
<img src="/img/async/concurrent-burgers/concurrent-burgers-05.png" class="illustration">
-Pendant que vous discutez avec votre crush đ, de temps en temps vous jetez un coup dâĆil au nombre affichĂ© au-dessus du comptoir pour savoir si c'est Ă votre tour d'ĂȘtre servis.
+Pendant que vous attendez et discutez avec votre crush, de temps en temps, vous jetez un coup dâĆil au nombre affichĂ© au-dessus du comptoir pour savoir si c'est dĂ©jĂ votre tour.
-Jusqu'au moment oĂč c'est (enfin) votre tour. Vous allez au comptoir, rĂ©cupĂ©rez vos burgers đ et revenez Ă votre table.
+Puis, à un moment, c'est enfin votre tour. Vous allez au comptoir, récupérez vos burgers et revenez à votre table.
<img src="/img/async/concurrent-burgers/concurrent-burgers-06.png" class="illustration">
-Vous et votre crush đ mangez les burgers đ et passez un bon moment âš.
+Vous et votre crush mangez les burgers et passez un bon moment. âš
<img src="/img/async/concurrent-burgers/concurrent-burgers-07.png" class="illustration">
/// note | Remarque
-Illustrations proposĂ©es par [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). đš
+Belles illustrations par [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). đš
///
Imaginez que vous ĂȘtes l'ordinateur / le programme đ€ dans cette histoire.
-Pendant que vous faites la queue, vous ĂȘtre simplement inactif đŽ, attendant votre tour, ne faisant rien de « productif ». Mais la queue est rapide car le serveur đ prend seulement les commandes (et ne les prĂ©pare pas), donc tout va bien.
+Pendant que vous faites la queue, vous ĂȘtes simplement inactif đŽ, attendant votre tour, ne faisant rien de trĂšs « productif ». Mais la queue est rapide car le caissier prend seulement les commandes (et ne les prĂ©pare pas), donc tout va bien.
-Ensuite, quand c'est votre tour, vous faites des actions « productives » đ€, vous Ă©tudiez le menu, dĂ©cidez ce que vous voulez, demandez Ă votre crush đ son choix, payez đž, vĂ©rifiez que vous utilisez la bonne carte de crĂ©dit, vĂ©rifiez que le montant dĂ©bitĂ© sur la carte est correct, vĂ©rifiez que la commande contient les bons produits, etc.
+Ensuite, quand c'est votre tour, vous faites du vrai travail « productif », vous étudiez le menu, décidez ce que vous voulez, demandez à votre crush son choix, payez, vérifiez que vous donnez le bon billet ou la bonne carte, vérifiez que le montant débité est correct, vérifiez que la commande contient les bons produits, etc.
-Mais ensuite, mĂȘme si vous n'avez pas encore vos burgers đ, votre travail avec le serveur đ est « en pause » âž, car vous devez attendre đ que vos burgers soient prĂȘts.
+Mais ensuite, mĂȘme si vous n'avez toujours pas vos burgers, votre travail avec le caissier est « en pause » âž, car vous devez attendre đ que vos burgers soient prĂȘts.
-AprĂšs vous ĂȘtre Ă©cartĂ© du comptoir et vous ĂȘtre assis Ă votre table avec le numĂ©ro de votre commande, vous pouvez tourner đ votre attention vers votre crush đ, et « travailler » ⯠đ€ lĂ -dessus. Vous ĂȘtes donc Ă nouveau en train de faire quelque chose de « productif » đ€, vous flirtez avec votre crush đ.
+Mais lorsque vous vous Ă©cartez du comptoir et vous asseyez Ă table avec un numĂ©ro pour votre tour, vous pouvez tourner đ votre attention vers votre crush, et « travailler » ⯠đ€ lĂ -dessus. Vous ĂȘtes donc Ă nouveau en train de faire quelque chose de trĂšs « productif », comme flirter avec votre crush đ.
-Puis le serveur đ dit « J'ai fini de prĂ©parer les burgers » đ en mettant votre numĂ©ro sur l'affichage du comptoir, mais vous ne courez pas immĂ©diatement au moment oĂč votre numĂ©ro s'affiche. Vous savez que personne ne volera vos burgers đ car vous avez votre numĂ©ro et les autres clients ont le leur.
+Puis le caissier đ dit « J'ai fini de faire les burgers » en mettant votre numĂ©ro sur l'affichage du comptoir, mais vous ne sautez pas comme un fou immĂ©diatement quand le numĂ©ro affichĂ© change pour devenir votre numĂ©ro. Vous savez que personne ne volera vos burgers car vous avez le numĂ©ro de votre tour, et les autres ont le leur.
-Vous attendez donc que votre crush đ finisse son histoire, souriez gentiment et dites que vous allez chercher les burgers âž.
+Vous attendez donc que votre crush finisse son histoire (termine le travail actuel ⯠/ la tĂąche en cours de traitement đ€), souriez gentiment et dites que vous allez chercher les burgers âž.
-Pour finir vous allez au comptoir đ, vers la tĂąche initiale qui est dĂ©sormais terminĂ©e âŻ, rĂ©cupĂ©rez les burgers đ, remerciez le serveur et ramenez les burgers đ Ă votre table. Ceci termine l'Ă©tape / la tĂąche d'interaction avec le comptoir âč. Ce qui ensuite, crĂ©e une nouvelle tĂąche de « manger les burgers » đ âŻ, mais la prĂ©cĂ©dente, « rĂ©cupĂ©rer les burgers » est terminĂ©e âč.
+Puis vous allez au comptoir đ, vers la tĂąche initiale qui est dĂ©sormais terminĂ©e âŻ, rĂ©cupĂ©rez les burgers, remerciez et ramenez les burgers Ă votre table. Ceci termine l'Ă©tape / la tĂąche d'interaction avec le comptoir âč. Ce qui ensuite crĂ©e une nouvelle tĂąche, « manger les burgers » đ âŻ, mais la prĂ©cĂ©dente, « rĂ©cupĂ©rer les burgers », est terminĂ©e âč.
### Burgers parallĂšles { #parallel-burgers }
-Imaginons désormais que ce ne sont pas des « burgers concurrents » mais des « burgers parallÚles ».
+Imaginons désormais que ce ne sont pas des « Burgers concurrents » mais des « Burgers parallÚles ».
-Vous allez avec votre crush đ dans un fast food đ parallĂ©lisĂ©.
+Vous allez avec votre crush chercher de la nourriture dans un fast food parallĂšle.
-Vous attendez pendant que plusieurs (disons 8) serveurs qui sont aussi des cuisiniers đšâđłđšâđłđšâđłđšâđłđšâđłđšâđłđšâđłđšâđł prennent les commandes des personnes devant vous.
+Vous attendez pendant que plusieurs (disons 8) caissiers qui sont en mĂȘme temps cuisiniers prennent les commandes des personnes devant vous.
-Chaque personne devant vous attend đ que son burger đ soit prĂȘt avant de quitter le comptoir car chacun des 8 serveurs va lui-mĂȘme prĂ©parer le burger directement avant de prendre la commande suivante.
+Chaque personne devant vous attend que son burger soit prĂȘt avant de quitter le comptoir car chacun des 8 caissiers va prĂ©parer le burger directement avant de prendre la commande suivante.
<img src="/img/async/parallel-burgers/parallel-burgers-01.png" class="illustration">
-Puis c'est enfin votre tour, vous commandez 2 magnifiques burgers đ pour vous et votre crush đ.
+Puis c'est enfin votre tour, vous commandez 2 burgers trÚs sophistiqués pour vous et votre crush.
Vous payez đž.
<img src="/img/async/parallel-burgers/parallel-burgers-02.png" class="illustration">
-Le serveur va dans la cuisine đšâđł.
+Le caissier va dans la cuisine.
-Vous attendez devant le comptoir afin que personne ne prenne vos burgers đ avant vous, vu qu'il n'y a pas de numĂ©ro de commande.
+Vous attendez, debout devant le comptoir đ, afin que personne d'autre ne prenne vos burgers avant vous, vu qu'il n'y a pas de numĂ©ros pour les tours.
<img src="/img/async/parallel-burgers/parallel-burgers-03.png" class="illustration">
-Vous et votre crush đ Ă©tant occupĂ©s Ă vĂ©rifier que personne ne passe devant vous prendre vos burgers au moment oĂč ils arriveront đ, vous ne pouvez pas vous prĂ©occuper de votre crush đ.
+Vous et votre crush Ă©tant occupĂ©s Ă ne laisser personne passer devant vous et prendre vos burgers au moment oĂč ils arriveront, vous ne pouvez pas prĂȘter attention Ă votre crush. đ
-C'est du travail « synchrone », vous ĂȘtre « synchronisĂ©s » avec le serveur/cuisinier đšâđł. Vous devez attendre đ et ĂȘtre prĂ©sent au moment exact oĂč le serveur/cuisinier đšâđł finira les burgers đ et vous les donnera, sinon quelqu'un risque de vous les prendre.
+C'est du travail « synchrone », vous ĂȘtre « synchronisĂ©s » avec le caissier/cuisinier đšâđł. Vous devez attendre đ et ĂȘtre prĂ©sent au moment exact oĂč le caissier/cuisinier đšâđł finira les burgers et vous les donnera, sinon quelqu'un d'autre risque de vous les prendre.
<img src="/img/async/parallel-burgers/parallel-burgers-04.png" class="illustration">
-Puis le serveur/cuisinier đšâđł revient enfin avec vos burgers đ, aprĂšs un long moment d'attente đ devant le comptoir.
+Puis votre caissier/cuisinier đšâđł revient enfin avec vos burgers, aprĂšs un long moment d'attente đ devant le comptoir.
<img src="/img/async/parallel-burgers/parallel-burgers-05.png" class="illustration">
-Vous prenez vos burgers đ et allez Ă une table avec votre crush đ
+Vous prenez vos burgers et allez Ă une table avec votre crush.
-Vous les mangez, et vous avez terminĂ© đ âč.
+Vous les mangez simplement, et vous avez terminĂ©. âč
<img src="/img/async/parallel-burgers/parallel-burgers-06.png" class="illustration">
-Durant tout ce processus, il n'y a presque pas eu de discussions ou de flirts car la plupart de votre temps Ă Ă©tĂ© passĂ© Ă attendre đ devant le comptoir đ.
+Il n'y a pas eu beaucoup de discussions ou de flirts car la plupart du temps a Ă©tĂ© passĂ© Ă attendre đ devant le comptoir. đ
/// note | Remarque
-Illustrations proposĂ©es par [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). đš
+Belles illustrations par [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). đš
///
---
-Dans ce scĂ©nario de burgers parallĂšles, vous ĂȘtes un ordinateur / programme đ€ avec deux processeurs (vous et votre crush đ) attendant đ Ă deux et dĂ©diant votre attention ⯠à « attendre devant le comptoir » đ pour une longue durĂ©e.
+Dans ce scĂ©nario de burgers parallĂšles, vous ĂȘtes un ordinateur / programme đ€ avec deux processeurs (vous et votre crush), tous deux attendant đ et dĂ©diant leur attention ⯠à « attendre devant le comptoir » đ pour une longue durĂ©e.
-Le fast-food a 8 processeurs (serveurs/cuisiniers) đšâđłđšâđłđšâđłđšâđłđšâđłđšâđłđšâđłđšâđł. Alors que le fast-food de burgers concurrents en avait 2 (un serveur et un cuisinier).
+Le fast food a 8 processeurs (caissiers/cuisiniers). Alors que le fast food de burgers concurrents aurait pu n'en avoir que 2 (un caissier et un cuisinier).
-Et pourtant l'expĂ©rience finale n'est pas meilleure đ.
+Mais tout de mĂȘme, l'expĂ©rience finale n'est pas la meilleure. đ
---
-C'est donc l'histoire Ă©quivalente parallĂšle pour les burgers đ.
+Ce serait donc l'histoire Ă©quivalente parallĂšle pour les burgers. đ
-Pour un exemple plus courant dans la « vie réelle », imaginez une banque.
+Pour un exemple plus « vie réelle », imaginez une banque.
-Jusqu'Ă rĂ©cemment, la plupart des banques avaient plusieurs caisses (et banquiers) đšâđŒđšâđŒđšâđŒđšâđŒ et une unique file d'attente đđđđđđđđ.
+Jusqu'Ă rĂ©cemment, la plupart des banques avaient plusieurs caissiers đšâđŒđšâđŒđšâđŒđšâđŒ et une grande file d'attente đđđđđđđđ.
-Tous les banquiers faisaient l'intĂ©gralitĂ© du travail avec chaque client avant de passer au suivant đšâđŒâŻ.
+Tous les caissiers faisaient tout le travail avec chaque client avant de passer au suivant đšâđŒâŻ.
-Et vous deviez attendre đ dans la file pendant un long moment ou vous perdiez votre place.
+Et vous devez attendre đ dans la file pendant un long moment ou vous perdez votre tour.
-Vous n'auriez donc probablement pas envie d'amener votre crush đ avec vous Ă la banque đŠ.
+Vous n'auriez donc probablement pas envie d'amener votre crush đ avec vous pour faire des dĂ©marches Ă la banque đŠ.
### Conclusion sur les burgers { #burger-conclusion }
-Dans ce scĂ©nario des « burgers du fast-food avec votre crush », comme il y a beaucoup d'attente đ, il est trĂšs logique d'avoir un systĂšme concurrent âžđâŻ.
+Dans ce scĂ©nario des « burgers de fast food avec votre crush », comme il y a beaucoup d'attente đ, il est beaucoup plus logique d'avoir un systĂšme concurrent âžđâŻ.
-Et c'est le cas pour la plupart des applications web.
+C'est le cas pour la plupart des applications web.
-Vous aurez de nombreux, nombreux utilisateurs, mais votre serveur attendra đ que leur connexion peu performante envoie des requĂȘtes.
+De trĂšs, trĂšs nombreux utilisateurs, mais votre serveur attend đ que leur connexion pas trĂšs bonne envoie leurs requĂȘtes.
-Puis vous attendrez đ de nouveau que leurs rĂ©ponses reviennent.
+Puis attend đ de nouveau que les rĂ©ponses reviennent.
-Cette « attente » đ se mesure en microsecondes, mais tout de mĂȘme, en cumulĂ© cela fait beaucoup d'attente.
+Cette « attente » đ se mesure en microsecondes, mais tout de mĂȘme, en les cumulant toutes, cela fait beaucoup d'attente au final.
-C'est pourquoi il est logique d'utiliser du code asynchrone âžđ⯠pour des APIs web.
+C'est pourquoi il est trĂšs logique d'utiliser du code asynchrone âžđ⯠pour des APIs web.
Ce type d'asynchronicité est ce qui a rendu NodeJS populaire (bien que NodeJS ne soit pas parallÚle) et c'est la force de Go en tant que langage de programmation.
### Est-ce que la concurrence est mieux que le parallélisme ? { #is-concurrency-better-than-parallelism }
-Nope ! C'est ça la morale de l'histoire.
+Nope ! Ce n'est pas la morale de l'histoire.
-La concurrence est différente du parallélisme. C'est mieux sur des scénarios **spécifiques** qui impliquent beaucoup d'attente. à cause de ça, c'est généralement bien meilleur que le parallélisme pour le développement d'applications web. Mais pas pour tout.
+La concurrence est différente du parallélisme. Et c'est mieux dans des scénarios **spécifiques** qui impliquent beaucoup d'attente. à cause de ça, c'est généralement bien meilleur que le parallélisme pour le développement d'applications web. Mais pas pour tout.
-Donc pour équilibrer tout ça, imaginez l'histoire suivante :
+Donc pour équilibrer tout ça, imaginez l'histoire courte suivante :
> Vous devez nettoyer une grande et sale maison.
Il n'y a plus d'attente đ nulle part, juste beaucoup de travail Ă effectuer, dans diffĂ©rentes piĂšces de la maison.
-Vous pourriez diviser en diffĂ©rentes sections comme avec les burgers, d'abord le salon, puis la cuisine, etc. Mais vous n'attendez đ rien, vous ne faites que nettoyer et nettoyer, la sĂ©paration en sections ne changerait rien au final.
+Vous pourriez avoir des tours comme dans l'exemple des burgers, d'abord le salon, puis la cuisine, mais comme vous n'attendez đ rien, vous ne faites que nettoyer et nettoyer, les tours ne changeraient rien.
-Cela prendrait autant de temps pour finir avec ou sans sections (concurrence) et vous auriez effectuĂ© la mĂȘme quantitĂ© de travail.
+Cela prendrait autant de temps pour finir avec ou sans tours (concurrence) et vous auriez effectuĂ© la mĂȘme quantitĂ© de travail.
-Mais dans ce cas, si pouviez amener 8 ex-serveurs/cuisiniers/devenus-nettoyeurs đšâđłđšâđłđšâđłđšâđłđšâđłđšâđłđšâđłđšâđł, et que chacun d'eux (plus vous) pouvait prendre une zone de la maison pour la nettoyer, vous pourriez faire tout le travail en parallĂšle, et finir plus tĂŽt.
+Mais dans ce cas, si vous pouviez amener les 8 ex-caissiers/cuisiniers/désormais-nettoyeurs, et que chacun d'eux (plus vous) pouvait prendre une zone de la maison pour la nettoyer, vous pourriez faire tout le travail en **parallÚle**, avec l'aide supplémentaire, et finir beaucoup plus tÎt.
Dans ce scénario, chacun des nettoyeurs (vous y compris) serait un processeur, faisant sa partie du travail.
-Et comme la plupart du temps d'exécution est pris par du
« vrai » travail (et non de l'attente), et que le travail dans un ordinateur est fait par un <abbr title="Central Processing Unit - Unité centrale de traitement">CPU</abbr>, ce sont des problÚmes dits « CPU bound ».
+Et comme la plupart du temps d'exécution est pris par du
vrai travail (et non de l'attente), et que le travail dans un ordinateur est fait par un <abbr title="Central Processing Unit - Unité centrale de traitement">CPU</abbr>, ce sont des problÚmes dits « CPU bound ».
---
-Des exemples communs d'opérations « CPU bound » sont les procédés qui requiÚrent des traitements mathématiques complexes.
+Des exemples communs d'opérations CPU bound sont les choses qui requiÚrent des traitements mathématiques complexes.
Par exemple :
-* Traitements d'**audio** et d'**images**.
-* La **vision par ordinateur** : une image est composĂ©e de millions de pixels, chaque pixel ayant 3 valeurs / couleurs, les traiter tous va nĂ©cessiter d'effectuer des traitements sur chaque pixel, et de prĂ©fĂ©rence tous en mĂȘme temps.
-* L'apprentissage automatique (ou **Machine Learning**) : cela nĂ©cessite de nombreuses multiplications de matrices et vecteurs. Imaginez une Ă©norme feuille de calcul remplie de nombres que vous multiplierez entre eux tous au mĂȘme moment.
-* L'apprentissage profond (ou **Deep Learning**) : est un sous-domaine du **Machine Learning**, donc les mĂȘmes raisons s'appliquent. Avec la diffĂ©rence qu'il n'y a pas une unique feuille de calcul de nombres Ă multiplier, mais une Ă©norme quantitĂ© d'entre elles, et dans de nombreux cas, on utilise un processeur spĂ©cial pour construire et / ou utiliser ces modĂšles.
+* Traitements d'**audio** ou d'**images**.
+* **Computer vision** : une image est composĂ©e de millions de pixels, chaque pixel ayant 3 valeurs / couleurs, les traiter nĂ©cessite normalement d'effectuer des calculs sur ces pixels, tous en mĂȘme temps.
+* **Machine Learning** : cela nĂ©cessite normalement de nombreuses multiplications de « matrices » et de « vecteurs ». Imaginez une Ă©norme feuille de calcul remplie de nombres et les multiplier tous ensemble au mĂȘme moment.
+* **Deep Learning** : c'est un sous-domaine du Machine Learning, donc les mĂȘmes raisons s'appliquent. C'est juste qu'il n'y a pas une unique feuille de calcul de nombres Ă multiplier, mais une Ă©norme quantitĂ© d'entre elles, et dans de nombreux cas, on utilise un processeur spĂ©cial pour construire et / ou utiliser ces modĂšles.
### Concurrence + Parallélisme : Web + Machine Learning { #concurrency-parallelism-web-machine-learning }
-Avec **FastAPI** vous pouvez bénéficier de la concurrence qui est trÚs courante en développement web (c'est l'attrait principal de NodeJS).
+Avec **FastAPI** vous pouvez bĂ©nĂ©ficier de la concurrence qui est trĂšs courante en dĂ©veloppement web (le mĂȘme attrait principal de NodeJS).
-Mais vous pouvez aussi profiter du parallélisme et du multiprocessing (plusieurs processus s'exécutant en parallÚle) afin de gérer des charges **CPU bound** qui sont récurrentes dans les systÚmes de *Machine Learning*.
+Mais vous pouvez aussi profiter du parallélisme et du multiprocessing (plusieurs processus s'exécutant en parallÚle) afin de gérer des charges **CPU bound** comme celles des systÚmes de Machine Learning.
-Ăa, ajoutĂ© au fait que Python soit le langage le plus populaire pour la **Data Science**, le **Machine Learning** et surtout le **Deep Learning**, font de **FastAPI** un trĂšs bon choix pour les APIs et applications de **Data Science** / **Machine Learning**.
+Ăa, ajoutĂ© au simple fait que Python soit le langage principal pour la **Data Science**, le Machine Learning et surtout le Deep Learning, fait de FastAPI un trĂšs bon choix pour les APIs web et applications de Data Science / Machine Learning (entre autres).
-Pour comprendre comment mettre en place ce parallélisme en production, allez lire la section [Déploiement](deployment/index.md).
+Pour comprendre comment mettre en place ce parallélisme en production, consultez la section sur le [Déploiement](deployment/index.md).
## `async` et `await` { #async-and-await }
-Les versions modernes de Python ont une maniÚre trÚs intuitive de définir le code asynchrone, tout en gardant une apparence de code « séquentiel » classique en laissant Python faire l'attente pour vous au bon moment.
+Les versions modernes de Python ont une maniÚre trÚs intuitive de définir le code asynchrone. Cela le fait ressembler à du code « séquentiel » normal et effectue l'« attente » pour vous aux bons moments.
-Pour une opération qui nécessite de l'attente avant de donner un résultat et qui supporte ces nouvelles fonctionnalités Python, vous pouvez l'utiliser comme tel :
+Pour une opération qui nécessite de l'attente avant de donner un résultat et qui supporte ces nouvelles fonctionnalités Python, vous pouvez l'écrire comme ceci :
```Python
burgers = await get_burgers(2)
Le mot-clĂ© important ici est `await`. Il informe Python qu'il faut attendre âž que `get_burgers(2)` finisse d'effectuer ses opĂ©rations đ avant de stocker les rĂ©sultats dans la variable `burgers`. GrĂące Ă cela, Python saura qu'il peut aller effectuer d'autres opĂ©rations đ ⯠pendant ce temps (comme par exemple recevoir une autre requĂȘte).
-Pour que `await` fonctionne, il doit ĂȘtre placĂ© dans une fonction qui supporte l'asynchronicitĂ©. Pour que ça soit le cas, il faut dĂ©clarer cette derniĂšre avec `async def` :
+Pour que `await` fonctionne, il doit ĂȘtre placĂ© dans une fonction qui supporte cette asynchronicitĂ©. Pour que ça soit le cas, il faut dĂ©clarer cette derniĂšre avec `async def` :
```Python hl_lines="1"
async def get_burgers(number: int):
return burgers
```
-... et non `def` :
+... au lieu de `def` :
```Python hl_lines="2"
# Ceci n'est pas asynchrone
Avec `async def`, Python sait que dans cette fonction il doit prendre en compte les expressions `await`, et qu'il peut mettre en pause âž l'exĂ©cution de la fonction pour aller faire autre chose đ avant de revenir.
-Pour appeler une fonction définie avec `async def`, vous devez utiliser `await`. Donc ceci ne marche pas :
+Lorsque vous voulez appeler une fonction `async def`, vous devez l'« attendre ». Donc ceci ne marche pas :
```Python
-# Ceci ne fonctionne pas, car get_burgers a été défini avec async def
+# Ceci ne fonctionne pas, car get_burgers a été défini avec : async def
burgers = get_burgers(2)
```
---
-Donc, si vous utilisez une bibliothÚque qui nécessite que ses fonctions soient appelées avec `await`, vous devez définir la *fonction de chemin d'accÚs* en utilisant `async def` comme dans :
+Donc, si vous utilisez une bibliothÚque qui vous indique que vous pouvez l'appeler avec `await`, vous devez créer les *fonctions de chemin d'accÚs* qui l'utilisent avec `async def`, comme dans :
```Python hl_lines="2-3"
@app.get('/burgers')
### Plus de détails techniques { #more-technical-details }
-Vous avez donc compris que `await` peut seulement ĂȘtre utilisĂ© dans des fonctions dĂ©finies avec `async def`.
+Vous avez peut-ĂȘtre remarquĂ© que `await` peut seulement ĂȘtre utilisĂ© dans des fonctions dĂ©finies avec `async def`.
-Mais en mĂȘme temps, les fonctions dĂ©finies avec `async def` doivent ĂȘtre appelĂ©es avec `await` et donc dans des fonctions dĂ©finies elles aussi avec `async def`.
+Mais en mĂȘme temps, les fonctions dĂ©finies avec `async def` doivent ĂȘtre « attendues ». Donc, les fonctions avec `async def` peuvent seulement ĂȘtre appelĂ©es Ă l'intĂ©rieur de fonctions dĂ©finies elles aussi avec `async def`.
-Vous avez donc remarquĂ© ce paradoxe d'Ćuf et de la poule, comment appelle-t-on la premiĂšre fonction `async` ?
+Donc, Ă propos de l'Ćuf et de la poule, comment appelle-t-on la premiĂšre fonction `async` ?
-Si vous utilisez **FastAPI**, pas besoin de vous en inquiéter, car cette « premiÚre » fonction sera votre *fonction de chemin d'accÚs* ; et **FastAPI** saura comment arriver au résultat attendu.
+Si vous utilisez **FastAPI**, pas besoin de vous en inquiéter, car cette « premiÚre » fonction sera votre *fonction de chemin d'accÚs*, et FastAPI saura comment faire ce qu'il faut.
Mais si vous souhaitez utiliser `async` / `await` sans FastAPI, vous pouvez Ă©galement le faire.
En particulier, vous pouvez utiliser directement [AnyIO](https://anyio.readthedocs.io/en/stable/) pour vos cas dâusage de concurrence avancĂ©s qui nĂ©cessitent des schĂ©mas plus Ă©laborĂ©s dans votre propre code.
-Et mĂȘme si vous nâutilisiez pas FastAPI, vous pourriez aussi Ă©crire vos propres applications async avec [AnyIO](https://anyio.readthedocs.io/en/stable/) pour une grande compatibilitĂ© et pour bĂ©nĂ©ficier de ses avantages (par ex. la « structured concurrency »).
+Et mĂȘme si vous nâutilisiez pas FastAPI, vous pourriez aussi Ă©crire vos propres applications async avec [AnyIO](https://anyio.readthedocs.io/en/stable/) pour une grande compatibilitĂ© et pour bĂ©nĂ©ficier de ses avantages (par ex. la *structured concurrency*).
Jâai crĂ©Ă© une autre bibliothĂšque au-dessus dâAnyIO, comme une fine surcouche, pour amĂ©liorer un peu les annotations de type et obtenir une meilleure **autocomplĂ©tion**, des **erreurs en ligne**, etc. Elle propose Ă©galement une introduction et un tutoriel accessibles pour vous aider Ă **comprendre** et Ă©crire **votre propre code async** : [Asyncer](https://asyncer.tiangolo.com/). Elle sera particuliĂšrement utile si vous devez **combiner du code async avec du code classique** (bloquant/synchrone).
Mais cela rend la programmation asynchrone bien plus simple.
-Cette mĂȘme syntaxe (ou presque) a aussi Ă©tĂ© incluse rĂ©cemment dans les versions modernes de JavaScript (dans les navigateurs et NodeJS).
+Cette mĂȘme syntaxe (ou presque) a aussi Ă©tĂ© incluse rĂ©cemment dans les versions modernes de JavaScript (dans le navigateur et NodeJS).
Mais avant ça, gérer du code asynchrone était bien plus complexe et difficile.
-Dans les versions précédentes de Python, vous auriez utilisé des threads ou [Gevent](https://www.gevent.org/). Mais le code aurait été bien plus difficile à comprendre, débugger, et concevoir.
+Dans les versions précédentes de Python, vous auriez pu utiliser des threads ou [Gevent](https://www.gevent.org/). Mais le code est bien plus difficile à comprendre, débugger, et concevoir.
-Dans les versions précédentes de JavaScript cÎté navigateur / NodeJS, vous auriez utilisé des « callbacks ». Menant potentiellement à ce que l'on appelle le « callback hell ».
+Dans les versions précédentes de NodeJS / JavaScript de navigateur, vous auriez utilisé des « callbacks ». Ce qui mÚne au « callback hell ».
## Coroutines { #coroutines }
-« Coroutine » est juste un terme Ă©laborĂ© pour dĂ©signer ce qui est retournĂ© par une fonction dĂ©finie avec `async def`. Python sait que c'est comme une fonction classique qui va dĂ©marrer Ă un moment et terminer Ă un autre, mais qu'elle peut aussi ĂȘtre mise en pause âž, du moment qu'il y a un `await` dans son contenu.
+**Coroutine** est juste un terme Ă©laborĂ© pour dĂ©signer ce qui est retournĂ© par une fonction dĂ©finie avec `async def`. Python sait que c'est comme une fonction, qui peut dĂ©marrer et qui se terminera Ă un moment, mais qu'elle peut aussi ĂȘtre mise en pause âž en interne, quand il y a un `await` Ă l'intĂ©rieur.
Mais toutes ces fonctionnalités d'utilisation de code asynchrone avec `async` et `await` sont souvent résumées comme l'utilisation des « coroutines ». On peut comparer cela à la principale fonctionnalité clé de Go, les « Goroutines ».
## Conclusion { #conclusion }
-Reprenons la phrase du début de la page :
+Reprenons la mĂȘme phrase ci-dessus :
-> Les versions modernes de Python supportent le **code asynchrone** grùce aux **« coroutines »** avec les syntaxes **`async` et `await`**.
+> Les versions modernes de Python supportent le **« code asynchrone »** en utilisant quelque chose appelé **« coroutines »**, avec la syntaxe **`async` et `await`**.
Ceci devrait ĂȘtre plus comprĂ©hensible dĂ©sormais. âš
Ce sont des détails trÚs poussés sur comment **FastAPI** fonctionne en arriÚre-plan.
-Si vous avez de bonnes connaissances techniques (coroutines, threads, code bloquant, etc.) et ĂȘtes curieux de comment **FastAPI** gĂšre `async def` versus le `def` classique, cette partie est faite pour vous.
+Si vous avez de bonnes connaissances techniques (coroutines, threads, code bloquant, etc.) et ĂȘtes curieux de comment FastAPI gĂšre `async def` versus le `def` classique, cette partie est faite pour vous.
///
### Fonctions de chemin d'accĂšs { #path-operation-functions }
-Quand vous dĂ©clarez une *fonction de chemin d'accĂšs* avec un `def` normal et non `async def`, elle est exĂ©cutĂ©e dans un groupe de threads (threadpool) externe qui est ensuite attendu, plutĂŽt que d'ĂȘtre appelĂ©e directement (car cela bloquerait le serveur).
+Quand vous dĂ©clarez une *fonction de chemin d'accĂšs* avec un `def` normal et non `async def`, elle est exĂ©cutĂ©e dans une threadpool externe qui est ensuite attendue, plutĂŽt que d'ĂȘtre appelĂ©e directement (car cela bloquerait le serveur).
-Si vous venez d'un autre framework async
hrone qui ne fonctionne pas comme de la façon dĂ©crite ci-dessus et que vous ĂȘtes habituĂ© Ă dĂ©finir des *fonctions de chemin d'accĂšs* basiques et purement calculatoires avec un simple `def` pour un faible gain de performance (environ 100 nanosecondes), veuillez noter que dans **FastAPI**, l'effet serait plutĂŽt contraire. Dans ces cas-lĂ , il vaut mieux utiliser `async def` Ă moins que votre *fonction de chemin d'accĂšs* utilise du code qui effectue des opĂ©rations <abbr title="Input/Output - EntrĂ©es/Sorties: lecture ou Ă©criture sur le disque, communications rĂ©seau.">I/O</abbr> bloquantes.
+Si vous venez d'un autre framework async
qui ne fonctionne pas de la façon dĂ©crite ci-dessus et que vous ĂȘtes habituĂ© Ă dĂ©finir des *fonctions de chemin d'accĂšs* triviales faisant uniquement du calcul avec un simple `def` pour un faible gain de performance (environ 100 nanosecondes), veuillez noter que dans **FastAPI**, l'effet serait plutĂŽt contraire. Dans ces cas-lĂ , il vaut mieux utiliser `async def` Ă moins que vos *fonctions de chemin d'accĂšs* utilisent du code qui effectue des opĂ©rations <abbr title="Input/Output - EntrĂ©es/Sorties: lecture ou Ă©criture sur le disque, communications rĂ©seau.">I/O</abbr> bloquantes.
-Au final, dans les deux situations, il est fort probable que **FastAPI** soit tout de mĂȘme [plus rapide](index.md#performance) que (ou au moins de vitesse Ă©gale Ă ) votre framework prĂ©cĂ©dent.
+Au final, dans les deux situations, il est fort probable que **FastAPI** soit [tout de mĂȘme plus rapide](index.md#performance) que (ou au moins comparable Ă ) votre framework prĂ©cĂ©dent.
### DĂ©pendances { #dependencies }
-La mĂȘme chose s'applique aux [dĂ©pendances](tutorial/dependencies/index.md). Si une dĂ©pendance est dĂ©finie avec `def` plutĂŽt que `async def`, elle est exĂ©cutĂ©e dans la threadpool externe.
+La mĂȘme chose s'applique aux [dĂ©pendances](tutorial/dependencies/index.md). Si une dĂ©pendance est une fonction standard `def` plutĂŽt qu'`async def`, elle est exĂ©cutĂ©e dans la threadpool externe.
### Sous-dépendances { #sub-dependencies }
-Vous pouvez avoir de multiples dĂ©pendances et [sous-dĂ©pendances](tutorial/dependencies/sub-dependencies.md) dĂ©pendant les unes des autres (en tant que paramĂštres de la dĂ©finition de la *fonction de chemin d'accĂšs*), certaines crĂ©Ă©es avec `async def` et d'autres avec `def`. Cela fonctionnerait aussi, et celles dĂ©finies avec un simple `def` seraient exĂ©cutĂ©es sur un thread externe (venant de la threadpool) plutĂŽt que d'ĂȘtre « attendues ».
+Vous pouvez avoir de multiples dĂ©pendances et [sous-dĂ©pendances](tutorial/dependencies/sub-dependencies.md) dĂ©pendant les unes des autres (en tant que paramĂštres des dĂ©finitions des fonctions), certaines crĂ©Ă©es avec `async def` et d'autres avec un `def` normal. Cela fonctionnerait aussi, et celles dĂ©finies avec un `def` normal seraient appelĂ©es sur un thread externe (venant de la threadpool) plutĂŽt que d'ĂȘtre « attendues ».
### Autres fonctions utilitaires { #other-utility-functions }
Contrairement aux fonctions que FastAPI appelle pour vous : les *fonctions de chemin d'accÚs* et dépendances.
-Si votre fonction utilitaire est une fonction classique définie avec `def`, elle sera appelée directement (telle qu'écrite dans votre code), pas dans une threadpool ; si la fonction est définie avec `async def` alors vous devrez attendre (avec `await`) que cette fonction se termine avant de passer à la suite du code.
+Si votre fonction utilitaire est une fonction classique définie avec `def`, elle sera appelée directement (telle qu'écrite dans votre code), pas dans une threadpool ; si la fonction est définie avec `async def` alors vous devez `await` cette fonction lorsque vous l'appelez dans votre code.
---
Encore une fois, ce sont des dĂ©tails trĂšs techniques qui peuvent ĂȘtre utiles si vous venez ici les chercher.
-Sinon, les instructions de la section <a href="#in-a-hurry">Vous ĂȘtes pressĂ©s ?</a> ci-dessus sont largement suffisantes.
+Sinon, les instructions de la section ci-dessus sont largement suffisantes : <a href="#in-a-hurry">Vous ĂȘtes pressĂ©s ?</a>.
# DĂ©ployer FastAPI sur des fournisseurs cloud { #deploy-fastapi-on-cloud-providers }
-Vous pouvez utiliser pratiquement n'importe quel fournisseur cloud pour déployer votre application FastAPI.
+Vous pouvez utiliser pratiquement **n'importe quel fournisseur cloud** pour déployer votre application FastAPI.
Dans la plupart des cas, les principaux fournisseurs cloud proposent des guides pour déployer FastAPI avec leurs services.
## Fournisseurs cloud - Sponsors { #cloud-providers-sponsors }
-D'autres fournisseurs cloud âš [**parrainent FastAPI**](../help-fastapi.md#sponsor-the-author) âš Ă©galement. đ
+Certains autres fournisseurs cloud âš [**parrainent FastAPI**](https://github.com/sponsors/tiangolo) âš Ă©galement. đ
Vous pouvez Ă©galement envisager ces fournisseurs pour suivre leurs guides et essayer leurs services :
# Concepts de déploiement { #deployments-concepts }
+
Lorsque vous déployez une application **FastAPI**, ou en fait n'importe quel type de web API, il existe plusieurs concepts qui vous importent probablement, et en les utilisant vous pouvez trouver la maniÚre la **plus appropriée** de **déployer votre application**.
Parmi les concepts importants, on trouve :
/// warning | Alertes
-Vous devez vous assurer d'utiliser **toujours** la **forme exec** de l'instruction `CMD`, comme expliqué ci-dessous.
+Vous devez **toujours** utiliser la **forme exec** de l'instruction `CMD`, comme expliqué ci-dessous.
///
CMD fastapi run app/main.py --port 80
```
-Assurez-vous d'utiliser toujours la forme **exec** pour garantir que FastAPI peut s'arrĂȘter proprement et que les [Ă©vĂ©nements de cycle de vie](../advanced/events.md) sont dĂ©clenchĂ©s.
+Vous devez toujours utiliser la forme **exec** pour garantir que FastAPI peut s'arrĂȘter proprement et que les [Ă©vĂ©nements de cycle de vie](../advanced/events.md) sont dĂ©clenchĂ©s.
Vous pouvez en lire davantage dans la [documentation Docker sur les formes shell et exec](https://docs.docker.com/reference/dockerfile/#shell-and-exec-form).
///
-Pour apprendre les bases du HTTPS, du point de vue d'un utilisateur, consultez [https://howhttps.works/](https://howhttps.works/).
+Pour **apprendre les bases du HTTPS**, du point de vue d'un utilisateur, consultez [https://howhttps.works/](https://howhttps.works/).
-Maintenant, du point de vue d'un dĂ©veloppeur, voici plusieurs choses Ă avoir en tĂȘte en pensant au HTTPS :
+Maintenant, du **point de vue d'un dĂ©veloppeur**, voici plusieurs choses Ă avoir en tĂȘte en pensant au HTTPS :
* Pour le HTTPS, **le serveur** doit **disposer de « certificats »** générés par une **tierce partie**.
* Ces certificats sont en réalité **acquis** auprÚs de la tierce partie, et non « générés ».
Tout commencerait probablement par le fait que vous **acquĂ©riez** un **nom de domaine**. Ensuite, vous le configureriez dans un serveur DNS (possiblement le mĂȘme que votre fournisseur cloud).
-Vous obtiendriez probablement un serveur cloud (une machine virtuelle) ou quelque chose de similaire, et il aurait une adresse IP publique <dfn title="Ne change pas dans le temps. Pas dynamique.">fixe</dfn>.
+Vous obtiendriez probablement un serveur cloud (une machine virtuelle) ou quelque chose de similaire, et il aurait une **adresse IP publique** <dfn title="Ne change pas dans le temps. Pas dynamique.">fixe</dfn>.
Dans le ou les serveurs DNS, vous configureriez un enregistrement (un « `A record` ») pour faire pointer **votre domaine** vers l'**adresse IP publique de votre serveur**.
Cela fonctionnerait pour la plupart des cas. đ
-Vous pourriez utiliser cette commande par exemple pour démarrer votre application **FastAPI** dans un conteneur, sur un serveur, etc.
+Vous pourriez utiliser cette commande par exemple pour démarrer votre **FastAPI** app dans un conteneur, sur un serveur, etc.
## Serveurs ASGI { #asgi-servers }
FastAPI utilise un standard pour construire des frameworks web Python et des serveurs appelé <abbr title="Asynchronous Server Gateway Interface - Interface passerelle serveur asynchrone">ASGI</abbr>. FastAPI est un framework web ASGI.
-La principale chose dont vous avez besoin pour exécuter une application **FastAPI** (ou toute autre application ASGI) sur une machine serveur distante est un programme serveur ASGI comme **Uvicorn**, c'est celui utilisé par défaut par la commande `fastapi`.
+La principale chose dont vous avez besoin pour exécuter une application **FastAPI** (ou toute autre application ASGI) sur une machine serveur distante est un programme serveur ASGI comme **Uvicorn**, c'est celui fourni par défaut avec la commande `fastapi`.
Il existe plusieurs alternatives, notamment :
Il y a un petit dĂ©tail sur les noms Ă garder Ă l'esprit. đĄ
-Le mot « serveur » est couramment utilisé pour désigner à la fois l'ordinateur distant/cloud (la machine physique ou virtuelle) et également le programme qui s'exécute sur cette machine (par exemple, Uvicorn).
+Le mot « **serveur** » est couramment utilisé pour désigner à la fois l'ordinateur distant/cloud (la machine physique ou virtuelle) et également le programme qui s'exécute sur cette machine (par exemple, Uvicorn).
-Gardez cela à l'esprit lorsque vous lisez « serveur » en général, cela pourrait faire référence à l'une de ces deux choses.
+Gardez simplement à l'esprit que lorsque vous lisez « serveur » en général, cela pourrait faire référence à l'une de ces deux choses.
Lorsqu'on se rĂ©fĂšre Ă la machine distante, il est courant de l'appeler **serveur**, mais aussi **machine**, **VM** (machine virtuelle), **nĆud**. Tout cela fait rĂ©fĂ©rence Ă un type de machine distante, exĂ©cutant normalement Linux, sur laquelle vous exĂ©cutez des programmes.
La commande `uvicorn main:app` fait référence à  :
-* `main` : le fichier `main.py` (le « module » Python).
+* `main` : le fichier `main.py` (le « module » Python).
* `app` : l'objet créé dans `main.py` avec la ligne `app = FastAPI()`.
C'est Ă©quivalent Ă Â :
# Prise en charge des Ă©diteurs { #editor-support }
-Lâextension officielle [Extension FastAPI](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) amĂ©liore votre flux de dĂ©veloppement FastAPI grĂące Ă la dĂ©couverte des chemins d'accĂšs, Ă la navigation, ainsi quâau dĂ©ploiement sur FastAPI Cloud et Ă la diffusion en direct des journaux.
+Lâextension officielle [Extension FastAPI](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) amĂ©liore votre flux de dĂ©veloppement FastAPI grĂące Ă la dĂ©couverte des *chemins d'accĂšs*, Ă la navigation, ainsi quâau dĂ©ploiement sur FastAPI Cloud et Ă la diffusion en direct des journaux.
Pour plus de dĂ©tails sur lâextension, reportez-vous au README sur le [rĂ©fĂ©rentiel GitHub](https://github.com/fastapi/fastapi-vscode).
///
-Une variable d'environnement (Ă©galement appelĂ©e « env var ») est une variable qui vit en dehors du code Python, dans le systĂšme d'exploitation, et qui peut ĂȘtre lue par votre code Python (ou par d'autres programmes Ă©galement).
+Une variable d'environnement (Ă©galement appelĂ©e « **env var** ») est une variable qui vit **en dehors** du code Python, dans le **systĂšme d'exploitation**, et qui peut ĂȘtre lue par votre code Python (ou par d'autres programmes Ă©galement).
Les variables d'environnement peuvent ĂȘtre utiles pour gĂ©rer des **paramĂštres** d'application, dans le cadre de l'**installation** de Python, etc.
## Créer et utiliser des variables d'environnement { #create-and-use-env-vars }
-Vous pouvez créer et utiliser des variables d'environnement dans le **shell (terminal)**, sans avoir besoin de Python :
+Vous pouvez **créer** et utiliser des variables d'environnement dans le **shell (terminal)**, sans avoir besoin de Python :
//// tab | Linux, macOS, Windows Bash
Vous pouvez également créer des variables d'environnement **en dehors** de Python, dans le terminal (ou par tout autre moyen), puis les **lire en Python**.
-Par exemple, vous pouvez avoir un fichier `main.py` contenant :
+Par exemple, vous pouvez avoir un fichier `main.py` contenant :
```Python hl_lines="3"
import os
///
-Vous pouvez ensuite exécuter ce programme Python :
+Vous pouvez ensuite exécuter ce programme Python :
//// tab | Linux, macOS, Windows Bash
Vous pouvez également créer une variable d'environnement uniquement pour l'**invocation d'un programme spécifique**, qui ne sera disponible que pour ce programme et uniquement pendant sa durée d'exécution.
-Pour cela, crĂ©ez-la juste avant le programme, sur la mĂȘme ligne :
+Pour cela, crĂ©ez-la juste avant le programme, sur la mĂȘme ligne :
<div class="termy">
## GĂ©rer les types et la validation { #types-and-validation }
-Ces variables d'environnement ne peuvent gĂ©rer que des **chaĂźnes de texte**, car elles sont externes Ă Python et doivent ĂȘtre compatibles avec les autres programmes et le reste du systĂšme (et mĂȘme avec diffĂ©rents systĂšmes d'exploitation, comme Linux, Windows, macOS).
+Ces variables d'environnement ne peuvent gĂ©rer que des **chaĂźnes de texte**, car elles sont externes Ă Python et doivent ĂȘtre compatibles avec les autres programmes et le reste du systĂšme (et mĂȘme avec diffĂ©rents systĂšmes d'exploitation, comme Linux, Windows et macOS).
Cela signifie que **toute valeur** lue en Python Ă partir d'une variable d'environnement **sera une `str`**, et que toute conversion vers un autre type ou toute validation doit ĂȘtre effectuĂ©e dans le code.
## Variable d'environnement `PATH` { #path-environment-variable }
-Il existe une **variable d'environnement spéciale** appelée **`PATH`** qui est utilisée par les systÚmes d'exploitation (Linux, macOS, Windows) pour trouver les programmes à exécuter.
+Il existe une variable d'environnement **spéciale** appelée **`PATH`** qui est utilisée par les systÚmes d'exploitation (Linux, macOS, Windows) pour trouver les programmes à exécuter.
La valeur de la variable `PATH` est une longue chaßne composée de répertoires séparés par deux-points `:` sous Linux et macOS, et par point-virgule `;` sous Windows.
-Par exemple, la variable d'environnement `PATH` peut ressembler à ceci :
+Par exemple, la variable d'environnement `PATH` peut ressembler Ă ceci :
//// tab | Linux, macOS
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
```
-Cela signifie que le systÚme doit rechercher les programmes dans les répertoires :
+Cela signifie que le systÚme doit rechercher les programmes dans les répertoires :
* `/usr/local/bin`
* `/usr/bin`
C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32
```
-Cela signifie que le systÚme doit rechercher les programmes dans les répertoires :
+Cela signifie que le systÚme doit rechercher les programmes dans les répertoires :
* `C:\Program Files\Python312\Scripts`
* `C:\Program Files\Python312`
Si vous acceptez de mettre Ă jour la variable d'environnement `PATH`, l'installateur ajoutera `/opt/custompython/bin` Ă la variable d'environnement `PATH`.
-Cela pourrait ressembler à ceci :
+Cela pourrait ressembler Ă ceci :
```plaintext
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin
////
-Ainsi, si vous tapez :
+Ainsi, si vous tapez :
<div class="termy">
Le systÚme va **trouver** le programme `python` dans `/opt/custompython/bin` et l'exécuter.
-Cela reviendrait à peu prÚs à taper :
+Cela reviendrait Ă peu prĂšs Ă taper :
<div class="termy">
Le systÚme va **trouver** le programme `python` dans `C:\opt\custompython\bin\python` et l'exécuter.
-Cela reviendrait à peu prÚs à taper :
+Cela reviendrait Ă peu prĂšs Ă taper :
<div class="termy">
* [**Swagger UI**](https://github.com/swagger-api/swagger-ui), avec exploration interactive, appelez et testez votre API directement depuis le navigateur.
-
+
* Documentation d'API alternative avec [**ReDoc**](https://github.com/Rebilly/ReDoc).
* dans [Visual Studio Code](https://code.visualstudio.com/) :
-
+
* dans [PyCharm](https://www.jetbrains.com/pycharm/) :
-
+
Vous obtiendrez de l'autocomplĂ©tion dans du code que vous auriez pu considĂ©rer impossible auparavant. Par exemple, la clĂ© `price` Ă l'intĂ©rieur d'un corps JSON (qui aurait pu ĂȘtre imbriquĂ©) provenant d'une requĂȘte.
* Validation pour la plupart (ou tous ?) des **types de données** Python, y compris :
* objets JSON (`dict`).
- * tableaux JSON (`list`) définissant les types d'éléments.
+ * tableau JSON (`list`) définissant les types d'éléments.
* champs String (`str`), définition des longueurs minimale et maximale.
* nombres (`int`, `float`) avec valeurs minimale et maximale, etc.
# Aider { #help }
+
Souhaitez-vous aider FastAPI ou obtenir de l'aide Ă propos de FastAPI ?
Il existe des moyens trĂšs simples d'aider et d'obtenir de l'aide.
## Autres paramĂštres de Swagger UI { #other-swagger-ui-parameters }
-Pour voir toutes les autres configurations possibles que vous pouvez utiliser, lisez les [documents officiels pour les paramĂštres de Swagger UI](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/).
+Pour voir toutes les autres configurations possibles que vous pouvez utiliser, lisez les documents officiels [pour les paramĂštres de Swagger UI](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/).
## ParamĂštres JavaScript uniquement { #javascript-only-settings }
-Swagger UI permet également d'autres configurations qui sont des objets réservés à JavaScript (par exemple, des fonctions JavaScript).
+Swagger UI permet également d'autres configurations qui sont des objets **réservés à JavaScript** (par exemple, des fonctions JavaScript).
FastAPI inclut aussi ces paramÚtres `presets` réservés à JavaScript :
Et ces deux éléments, `scope` et `receive`, sont ce dont on a besoin pour créer une nouvelle instance de `Request`.
-Pour en savoir plus sur `Request`, consultez [la documentation de Starlette sur les requĂȘtes](https://www.starlette.dev/requests/).
+Pour en savoir plus sur `Request`, consultez [les documents de Starlette sur les requĂȘtes](https://www.starlette.dev/requests/).
///
Voici quelques bibliothĂšques **GraphQL** qui prennent en charge **ASGI**. Vous pouvez les utiliser avec **FastAPI** :
* [Strawberry](https://strawberry.rocks/) đ
- * Avec [la documentation pour FastAPI](https://strawberry.rocks/docs/integrations/fastapi)
+ * Avec [les documents pour FastAPI](https://strawberry.rocks/docs/integrations/fastapi)
* [Ariadne](https://ariadnegraphql.org/)
- * Avec [la documentation pour FastAPI](https://ariadnegraphql.org/docs/fastapi-integration)
+ * Avec [les documents pour FastAPI](https://ariadnegraphql.org/docs/fastapi-integration)
* [Tartiflette](https://tartiflette.io/)
* Avec [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) pour fournir l'intégration ASGI
* [Graphene](https://graphene-python.org/)
Vous pouvez en apprendre davantage sur Strawberry dans la [documentation de Strawberry](https://strawberry.rocks/).
-Et Ă©galement la documentation sur [Strawberry avec FastAPI](https://strawberry.rocks/docs/integrations/fastapi).
+Et Ă©galement les documents sur [Strawberry avec FastAPI](https://strawberry.rocks/docs/integrations/fastapi).
## Ancien `GraphQLApp` de Starlette { #older-graphqlapp-from-starlette }
FastAPI 0.126.0 a supprimé la prise en charge de Pydantic v1, tout en continuant à prendre en charge `pydantic.v1` pendant un certain temps.
+FastAPI 0.128.0 a également supprimé la prise en charge de `pydantic.v1`, donc les derniÚres versions de FastAPI nécessitent Pydantic v2.
+
/// warning | Alertes
L'Ă©quipe Pydantic a arrĂȘtĂ© la prise en charge de Pydantic v1 pour les derniĂšres versions de Python, Ă partir de **Python 3.14**.
### Prise en charge de FastAPI pour Pydantic v1 dans v2 { #fastapi-support-for-pydantic-v1-in-v2 }
+/// warning | Alertes
+
+Cette prise en charge FastAPI des modĂšles `pydantic.v1` a Ă©tĂ© ajoutĂ©e dans **FastAPI 0.119.0** et supprimĂ©e dans **FastAPI 0.128.0**. Elle Ă©tait destinĂ©e Ă ĂȘtre une aide temporaire pour la migration vers Pydantic v2.
+
+Dans les versions actuelles de FastAPI, l'utilisation d'un modĂšle `pydantic.v1` dans votre application lĂšvera une erreur.
+
+Le reste de cette section décrit la prise en charge temporaire disponible uniquement dans ces anciennes versions.
+
+///
+
Depuis FastAPI 0.119.0, il existe également une prise en charge partielle de Pydantic v1 depuis l'intérieur de Pydantic v2, pour faciliter la migration vers v2.
Vous pouvez donc mettre Ă niveau Pydantic vers la derniĂšre version 2 et modifier les imports pour utiliser le sous-module `pydantic.v1`, et dans de nombreux cas cela fonctionnera tel quel.
### Migrer par Ă©tapes { #migrate-in-steps }
+/// warning | Alertes
+
+La migration progressive utilisant Ă la fois des modĂšles Pydantic v1 et v2 dans la mĂȘme application dĂ©crite ci-dessous ne fonctionne que dans **FastAPI 0.119.0 Ă 0.127.x**. Elle a Ă©tĂ© supprimĂ©e dans **FastAPI 0.128.0**, les derniĂšres versions nĂ©cessitent des modĂšles **Pydantic v2**.
+
+///
+
/// tip | Astuce
Essayez d'abord avec `bump-pydantic` ; si vos tests passent et que cela fonctionne, vous avez tout terminĂ© en une seule commande. âš
{* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py hl[19] *}
-... alors, comme `description` a une valeur par dĂ©faut, si vous ne retournez rien pour ce champ, il aura tout de mĂȘme cette **valeur par dĂ©faut**.
+... alors, comme `description` a une valeur par dĂ©faut, si vous **ne retournez rien** pour ce champ, il aura tout de mĂȘme cette **valeur par dĂ©faut**.
### ModÚle pour les données de réponse en sortie { #model-for-output-response-data }
Pour cette raison, le schĂ©ma JSON d'un modĂšle peut ĂȘtre diffĂ©rent selon qu'il est utilisĂ© pour **l'entrĂ©e ou la sortie** :
-- pour **l'entrée**, `description` ne sera **pas requis**
-- pour **la sortie**, il sera **requis** (et Ă©ventuellement `None`, ou en termes JSON, `null`)
+* pour **l'entrée**, `description` ne sera **pas requis**
+* pour **la sortie**, il sera **requis** (et Ă©ventuellement `None`, ou en termes JSON, `null`)
### ModĂšle de sortie dans les documents { #model-for-output-in-docs }
## Ne pas séparer les schémas { #do-not-separate-schemas }
-Il existe des cas oĂč vous pourriez vouloir avoir le **mĂȘme schĂ©ma pour l'entrĂ©e et la sortie**.
+Maintenant, il existe des cas oĂč vous pourriez vouloir avoir le **mĂȘme schĂ©ma pour l'entrĂ©e et la sortie**.
Le cas d'usage principal est probablement que vous avez dĂ©jĂ du code client/SDKs gĂ©nĂ©rĂ©s automatiquement et que vous ne souhaitez pas encore mettre Ă jour tout ce code client/ces SDKs gĂ©nĂ©rĂ©s automatiquement ; vous le ferez sans doute Ă un moment donnĂ©, mais peutâĂȘtre pas tout de suite.
### Utiliser le mĂȘme schĂ©ma pour les modĂšles d'entrĂ©e et de sortie dans les documents { #same-schema-for-input-and-output-models-in-docs }
-Désormais, il n'y aura qu'un seul schéma pour l'entrée et la sortie du modÚle, uniquement `Item`, et `description` ne sera pas requis :
+Désormais, il n'y aura qu'un seul schéma pour l'entrée et la sortie du modÚle, uniquement `Item`, et `description` sera **non requis** :
<div class="screenshot">
<img src="/img/tutorial/separate-openapi-schemas/image05.png">
* **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 compatibilité avec les éditeurs. <dfn title="également connu sous le nom de : auto-complétion, autocomplétion, IntelliSense">Autocomplétion</dfn> partout. Moins de temps passé à déboguer.
+* **Intuitif** : excellente compatibilité avec les éditeurs. <dfn title="également connu sous le nom de : autocomplétion, autocomplétion, IntelliSense">Autocomplétion</dfn> partout. Moins de temps passé à déboguer.
* **Facile** : conçu pour ĂȘtre facile Ă utiliser et Ă apprendre. Moins de temps passĂ© Ă lire les documents.
* **Concis** : diminue la duplication de code. Plusieurs fonctionnalités à partir de chaque déclaration de paramÚtre. Moins de bugs.
* **Robuste** : obtenez un code prĂȘt pour la production. Avec une documentation interactive automatique.
</div>
-**Remarque** : Vous devez vous assurer de mettre « fastapi[standard] » entre guillemets pour garantir que cela fonctionne dans tous les terminaux.
+**Remarque** : Vous devez vous assurer de mettre `"fastapi[standard]"` entre guillemets pour garantir que cela fonctionne dans tous les terminaux.
## Exemple { #example }
**Remarque** :
-Si vous ne savez pas, consultez la section « Vous ĂȘtes pressĂ©s ? » Ă propos de [`async` et `await` dans la documentation](https://fastapi.tiangolo.com/fr/async/#in-a-hurry).
+Si vous ne savez pas, consultez la section « Vous ĂȘtes pressĂ©s ? » Ă propos de [`async` et `await` dans les documents](https://fastapi.tiangolo.com/fr/async/#in-a-hurry).
</details>
# ModĂšle Full Stack FastAPI { #full-stack-fastapi-template }
+
Les modĂšles, bien qu'ils soient gĂ©nĂ©ralement livrĂ©s avec une configuration spĂ©cifique, sont conçus pour ĂȘtre flexibles et personnalisables. Cela vous permet de les modifier et de les adapter aux exigences de votre projet, ce qui en fait un excellent point de dĂ©part. đ
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.
Mais maintenant imaginez que vous l'écriviez de zéro.
-Ă un certain moment, vous auriez commencĂ© la dĂ©finition de la fonction, vous aviez les paramĂštres prĂȘts ...
+Ă un moment donnĂ©, vous commencez Ă dĂ©finir la fonction, et vous avez les paramĂštres prĂȘts ...
Mais ensuite vous devez appeler « cette méthode qui convertit la premiÚre lettre en majuscule ».
Et vous obtenez tout le support de l'éditeur avec cet objet résultant.
-Un exemple tiré de la documentation officielle de Pydantic :
+Un exemple tiré des documents officiels de Pydantic :
{* ../../docs_src/python_types/tutorial011_py310.py *}
/// note | Remarque
-Pour en savoir plus Ă propos de [Pydantic, consultez sa documentation](https://docs.pydantic.dev/).
+Pour en savoir plus Ă propos de [Pydantic, consultez ses documents](https://docs.pydantic.dev/).
///
Mais vous pouvez utiliser cet espace dans `Annotated` pour fournir à **FastAPI** des métadonnées supplémentaires sur la façon dont vous voulez 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.
+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 juste besoin de savoir que `Annotated` existe, et que c'est du Python standard. đ
```
.
âââ app
-â  âââ __init__.py
-â  âââ main.py
-â  âââ dependencies.py
-â  âââ routers
-â  â âââ __init__.py
-â  â âââ items.py
-â  â âââ users.py
-â  âââ internal
-â  âââ __init__.py
-â  âââ admin.py
+â âââ __init__.py
+â âââ main.py
+â âââ dependencies.py
+â âââ routers
+â â âââ __init__.py
+â â âââ items.py
+â â âââ users.py
+â âââ internal
+â âââ __init__.py
+â âââ admin.py
```
/// tip | Astuce
/// tip | Astuce
-Ce dernier *chemin d'accĂšs* aura la combinaison de tags : `["items", "custom"]`.
+Ce dernier chemin d'accĂšs aura la combinaison de tags : `["items", "custom"]`.
Et il aura également les deux réponses dans la documentation, une pour `404` et une pour `403`.
/// note | DĂ©tails trĂšs techniques
-Note : c'est un détail trÚs technique que vous pouvez probablement **simplement ignorer**.
+**Remarque** : c'est un détail trÚs technique que vous pouvez probablement **simplement ignorer**.
---
$ fastapi dev app/main.py
```
-Mais vous devriez vous rappeler de passer le bon chemin Ă chaque fois que vous appelez la commande `fastapi`.
+Mais vous devez vous rappeler de passer le bon chemin Ă chaque fois que vous appelez la commande `fastapi`.
En outre, d'autres outils pourraient ne pas ĂȘtre en mesure de la trouver, par exemple l'[Extension VS Code](../editor-support.md) ou [FastAPI Cloud](https://fastapicloud.com), il est donc recommandĂ© d'utiliser l'`entrypoint` dans `pyproject.toml`.
///
-## Consulter la documentation API automatique { #check-the-automatic-api-docs }
+## Consulter les documents d'API automatiques { #check-the-automatic-api-docs }
Maintenant, exécutez votre application :
Et ouvrez les documents Ă [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
-Vous verrez la documentation API automatique, incluant les chemins de tous les sous-modules, utilisant les bons chemins (et préfixes) et les bons tags :
+Vous verrez les documents d'API automatiques, incluant les chemins de tous les sous-modules, utilisant les bons chemins (et préfixes) et les bons tags :
<img src="/img/tutorial/bigger-applications/image01.png">
# Corps - ModÚles imbriqués { #body-nested-models }
-Avec FastAPI, vous pouvez définir, valider, documenter et utiliser des modÚles imbriqués à n'importe quelle profondeur (grùce à Pydantic).
+Avec **FastAPI**, vous pouvez définir, valider, documenter et utiliser des modÚles imbriqués à n'importe quelle profondeur (grùce à Pydantic).
## DĂ©clarer des champs de liste { #list-fields }
{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[18] *}
-Cela signifie que FastAPI attendrait un corps similaire Ă :
+Cela signifie que **FastAPI** attendrait un corps similaire Ă :
```JSON
{
}
```
-Là encore, avec cette simple déclaration, avec FastAPI vous obtenez :
+Là encore, avec cette simple déclaration, avec **FastAPI** vous obtenez :
- Prise en charge par l'Ă©diteur (autocomplĂ©tion, etc.), mĂȘme pour les modĂšles imbriquĂ©s
- Conversion des données
## RĂ©capitulatif { #recap }
-Avec FastAPI, vous bénéficiez de la flexibilité maximale fournie par les modÚles Pydantic, tout en gardant votre code simple, concis et élégant.
+Avec **FastAPI**, vous bénéficiez de la flexibilité maximale fournie par les modÚles Pydantic, tout en gardant votre code simple, concis et élégant.
Mais avec tous les avantages :
# 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 de la donnĂ©e depuis un client (comme un navigateur) vers votre API, vous l'envoyez en tant que **corps de la 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.
-Votre API aura presque toujours Ă envoyer un corps de **rĂ©ponse**. Mais un client n'a pas toujours Ă envoyer un **corps de requĂȘte** : parfois il demande seulement un chemin, peut-ĂȘtre avec quelques paramĂštres de requĂȘte, mais n'envoie pas de corps.
+Votre API aura presque toujours Ă envoyer un corps de **rĂ©ponse**. Mais un client n'a pas toujours Ă envoyer un **corps de la requĂȘte** : parfois il demande seulement un chemin, peut-ĂȘtre avec quelques paramĂštres de requĂȘte, mais n'envoie pas de corps.
Pour dĂ©clarer un corps de **requĂȘte**, on utilise les modĂšles de [Pydantic](https://docs.pydantic.dev/) en profitant de tous leurs avantages et fonctionnalitĂ©s.
/// note | Remarque
-Pour envoyer de la donnée, vous devez utiliser : `POST` (le plus populaire), `PUT`, `DELETE` ou `PATCH`.
+Pour envoyer de la donnée, vous devez utiliser l'une de ces méthodes : `POST` (le plus populaire), `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 dans une requĂȘte `GET` a un comportement non dĂ©fini dans les spĂ©cifications, cela est nĂ©anmoins supportĂ© par FastAPI, seulement pour des cas d'utilisation trĂšs complexes/extrĂȘmes.
Ceci Ă©tant dĂ©couragĂ©, la documentation interactive gĂ©nĂ©rĂ©e par Swagger UI ne montrera pas de documentation pour le corps d'une requĂȘte `GET`, et les proxys intermĂ©diaires risquent de ne pas le supporter.
{* ../../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, il est requis. Utilisez `None` pour le rendre simplement optionnel.
Par exemple, le modÚle ci-dessus déclare un JSON « `object` » (ou `dict` Python) tel que :
* 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 (autocomplétion, etc.) pour tous les attributs de ce paramÚtre et les types de ces attributs.
* Générer des définitions [JSON Schema](https://json-schema.org) pour votre modÚle ; vous pouvez également les utiliser partout ailleurs si cela a du sens pour votre projet.
-* Ces schémas participeront à la constitution du schéma généré OpenAPI, et seront utilisés par les documentations automatiques <abbr title="User Interfaces - Interfaces utilisateur">UIs</abbr>.
+* Ces schémas feront partie du schéma OpenAPI généré, et seront utilisés par les <abbr title="User Interfaces - Interfaces utilisateur">UIs</abbr> de la documentation automatique.
## Documentation automatique { #automatic-docs }
Ce n'est pas un hasard, ce framework entier a été bùti avec ce design comme objectif.
-Et cela a été rigoureusement testé durant la phase de design, avant toute implémentation, pour vous assurer que cela fonctionnerait avec tous les éditeurs.
+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.
Des changements sur Pydantic ont mĂȘme Ă©tĂ© faits pour supporter cela.
-Les captures d'écran précédentes ont été prises sur [Visual Studio Code](https://code.visualstudio.com).
+Les captures d'écran précédentes ont été prises avec [Visual Studio Code](https://code.visualstudio.com).
Mais vous auriez le mĂȘme support de l'Ă©diteur avec [PyCharm](https://www.jetbrains.com/pycharm/) et la majoritĂ© des autres Ă©diteurs de code Python :
## 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 *chemin d'accĂšs*.
+Vous pouvez dĂ©clarer des paramĂštres de chemin et le corps de la 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** 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 la fonction dĂ©clarĂ©s comme modĂšles Pydantic devraient ĂȘtre **rĂ©cupĂ©rĂ©s depuis le corps de la requĂȘte**.
{* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
+
## 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 *chemin d'accĂšs*.
+Vous pouvez aussi dĂ©clarer un **corps**, et des paramĂštres 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.
/// 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`.
-L'annotation de type `str | None` n'est pas utilisée par **FastAPI** pour déterminer que la valeur n'est pas requise, il le saura parce qu'elle a une valeur par défaut `= None`.
+L'annotation de type `str | None` n'est pas utilisée par FastAPI pour déterminer que la valeur n'est pas requise, il le saura parce qu'elle a une valeur par défaut `= None`.
Mais ajouter ces annotations de type permettra à votre éditeur de vous offrir un meilleur support et de détecter des erreurs.
/// note | Remarque
-Pour plus d'informations, consultez [la documentation officielle de Python](https://docs.python.org/3/library/__main__.html).
+Pour plus d'informations, consultez [les documents officiels de Python](https://docs.python.org/3/library/__main__.html).
///
Par exemple, dans Visual Studio Code, vous pouvez :
-- Allez dans le panneau « Debug ».
-- « Add configuration ... ».
-- Sélectionnez « Python ».
-- Lancez le <abbr title="En anglais: debugger">débogueur</abbr> avec l'option « Python: Current File (Integrated Terminal) ».
+* Allez dans le panneau « Debug ».
+* « Add configuration... ».
+* Sélectionnez « Python ».
+* Lancez le <abbr title="En anglais: debugger">débogueur</abbr> avec l'option « `Python: Current File (Integrated Terminal)` ».
Il dĂ©marrera alors le serveur avec votre code **FastAPI**, s'arrĂȘtera Ă vos points d'arrĂȘt, etc.
---
-Si vous utilisez Pycharm, vous pouvez :
+Si vous utilisez PyCharm, vous pouvez :
-- 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`).
+* 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.
# Utiliser des dépendances avec `yield` { #dependencies-with-yield }
-FastAPI prend en charge des dépendances qui effectuent des <dfn title='parfois aussi appelées « exit code », « cleanup code », « teardown code », « closing code », « context manager exit code », etc.'>étapes supplémentaires aprÚs l'exécution</dfn>.
+FastAPI prend en charge des dépendances qui effectuent des <dfn title='parfois également appelées « code de sortie », « code de nettoyage », « code de démontage », « code de fermeture », « code de sortie de gestionnaire de contexte », etc.'>étapes supplémentaires aprÚs l'exécution</dfn>.
Pour cela, utilisez `yield` au lieu de `return`, et écrivez les étapes supplémentaires (code) aprÚs.
`Depends()` reçoit un paramĂštre `scope` qui peut ĂȘtre :
-* « function » : dĂ©marrer la dĂ©pendance avant la *fonction de chemin d'accĂšs* qui gĂšre la requĂȘte, terminer la dĂ©pendance aprĂšs la fin de la *fonction de chemin d'accĂšs*, mais **avant** que la rĂ©ponse ne soit renvoyĂ©e au client. Ainsi, la fonction de dĂ©pendance sera exĂ©cutĂ©e **autour** de la *fonction de chemin d'accĂšs*.
-* « request » : dĂ©marrer la dĂ©pendance avant la *fonction de chemin d'accĂšs* qui gĂšre la requĂȘte (similaire Ă l'utilisation de « function »), mais terminer **aprĂšs** que la rĂ©ponse a Ă©tĂ© renvoyĂ©e au client. Ainsi, la fonction de dĂ©pendance sera exĂ©cutĂ©e **autour** du cycle **requĂȘte** et rĂ©ponse.
+* `"function"` : dĂ©marrer la dĂ©pendance avant la *fonction de chemin d'accĂšs* qui gĂšre la requĂȘte, terminer la dĂ©pendance aprĂšs la fin de la *fonction de chemin d'accĂšs*, mais **avant** que la rĂ©ponse ne soit renvoyĂ©e au client. Ainsi, la fonction de dĂ©pendance sera exĂ©cutĂ©e **autour** de la *fonction de chemin d'accĂšs*.
+* `"request"` : dĂ©marrer la dĂ©pendance avant la *fonction de chemin d'accĂšs* qui gĂšre la requĂȘte (similaire Ă l'utilisation de `"function"`), mais terminer **aprĂšs** que la rĂ©ponse a Ă©tĂ© renvoyĂ©e au client. Ainsi, la fonction de dĂ©pendance sera exĂ©cutĂ©e **autour** du cycle **requĂȘte** et rĂ©ponse.
-S'il n'est pas spécifié et que la dépendance utilise `yield`, le `scope` sera par défaut « request ».
+S'il n'est pas spécifié et que la dépendance utilise `yield`, le `scope` sera par défaut `"request"`.
### Définir `scope` pour les sous-dépendances { #scope-for-sub-dependencies }
-Lorsque vous déclarez une dépendance avec un `scope="request"` (par défaut), toute sous-dépendance doit également avoir un `scope` de « request ».
+Lorsque vous déclarez une dépendance avec un `scope="request"` (par défaut), toute sous-dépendance doit également avoir un `scope` de `"request"`.
-Mais une dépendance avec un `scope` de « function » peut avoir des dépendances avec un `scope` de « function » et un `scope` de « request ».
+Mais une dépendance avec un `scope` de `"function"` peut avoir des dépendances avec un `scope` de `"function"` et un `scope` de `"request"`.
Cela vient du fait que toute dépendance doit pouvoir exécuter son code de sortie avant ses sous-dépendances, car elle pourrait encore avoir besoin de les utiliser pendant son code de sortie.
Les dépendances avec `yield` ont évolué au fil du temps pour couvrir différents cas d'utilisation et corriger certains problÚmes.
Si vous souhaitez voir ce qui a changé dans différentes versions de FastAPI, vous pouvez en savoir plus dans le guide avancé, dans [Dépendances avancées - Dépendances avec `yield`, `HTTPException`, `except` et Background Tasks](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks).
+
## Gestionnaires de contexte { #context-managers }
### Que sont les « Context Managers » { #what-are-context-managers }
* `datetime.timedelta` :
* Un `datetime.timedelta` Python.
* Dans les requĂȘtes et les rĂ©ponses, il sera reprĂ©sentĂ© sous forme de `float` de secondes totales.
- * Pydantic permet aussi de le représenter sous la forme d'un « encodage de différence de temps ISO 8601 », [voir la documentation pour plus d'informations](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
+ * Pydantic permet aussi de le représenter sous la forme d'un « encodage de différence de temps ISO 8601 », [voir les documents pour plus d'informations](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
* `frozenset` :
* Dans les requĂȘtes et les rĂ©ponses, traitĂ© de la mĂȘme maniĂšre qu'un `set` :
* Dans les requĂȘtes, une liste sera lue, les doublons Ă©liminĂ©s, puis convertie en `set`.
C'est particuliĂšrement vrai pour les modĂšles d'utilisateur, car :
-* Le modÚle d'entrée doit pouvoir contenir un mot de passe.
-* Le modĂšle de sortie ne doit pas avoir de mot de passe.
-* Le modÚle de base de données devra probablement avoir un mot de passe haché.
+* Le **modÚle d'entrée** doit pouvoir contenir un mot de passe.
+* Le **modĂšle de sortie** ne doit pas avoir de mot de passe.
+* Le **modÚle de base de données** aurait probablement besoin d'avoir un mot de passe haché.
/// danger | Danger
Les modÚles Pydantic ont une méthode `.model_dump()` qui renvoie un `dict` avec les données du modÚle.
-Ainsi, si nous créons un objet Pydantic `user_in` comme :
+Ainsi, si nous créons un objet Pydantic `user_in` comme :
```Python
user_in = UserIn(username="john", password="secret", email="john.doe@example.com")
```
-et que nous appelons ensuite :
+et que nous appelons ensuite :
```Python
user_dict = user_in.model_dump()
nous avons maintenant un `dict` avec les données dans la variable `user_dict` (c'est un `dict` au lieu d'un objet modÚle Pydantic).
-Et si nous appelons :
+Et si nous appelons :
```Python
print(user_dict)
```
-nous obtiendrions un `dict` Python contenant :
+nous obtiendrions un `dict` Python contenant :
```Python
{
#### DĂ©baller un `dict` { #unpacking-a-dict }
-Si nous prenons un `dict` comme `user_dict` et que nous le passons à une fonction (ou une classe) avec `**user_dict`, Python va « déballer » ce `dict`. Il passera les clés et valeurs de `user_dict` directement comme arguments nommés.
+Si nous prenons un `dict` comme `user_dict` et que nous le passons à une fonction (ou une classe) avec `**user_dict`, Python va « déballer » ce `dict`. Il passera les clés et valeurs de `user_dict` directement comme arguments clé-valeur.
-Ainsi, en reprenant `user_dict` ci-dessus, écrire :
+Ainsi, en reprenant `user_dict` ci-dessus, Ă©crire :
```Python
UserInDB(**user_dict)
```
-aurait pour résultat quelque chose d'équivalent à  :
+aurait pour résultat quelque chose d'équivalent à :
```Python
UserInDB(
)
```
-Ou plus exactement, en utilisant `user_dict` directement, quels que soient ses contenus futurs :
+Ou plus exactement, en utilisant `user_dict` directement, quels que soient ses contenus futurs :
```Python
UserInDB(
#### Créer un modÚle Pydantic à partir du contenu d'un autre { #a-pydantic-model-from-the-contents-of-another }
-Comme dans l'exemple ci-dessus nous avons obtenu `user_dict` depuis `user_in.model_dump()`, ce code :
+Comme dans l'exemple ci-dessus nous avons obtenu `user_dict` depuis `user_in.model_dump()`, ce code :
```Python
user_dict = user_in.model_dump()
UserInDB(**user_dict)
```
-serait Ă©quivalent Ă Â :
+serait Ă©quivalent Ă :
```Python
UserInDB(**user_in.model_dump())
#### Déballer un `dict` et ajouter des mots-clés supplémentaires { #unpacking-a-dict-and-extra-keywords }
-Et en ajoutant ensuite l'argument nommé supplémentaire `hashed_password=hashed_password`, comme ici :
+Et en ajoutant ensuite l'argument nommé supplémentaire `hashed_password=hashed_password`, comme ici :
```Python
UserInDB(**user_in.model_dump(), hashed_password=hashed_password)
```
-... revient Ă Â :
+... revient Ă :
```Python
UserInDB(
Toutes les conversions de données, validations, documentation, etc., fonctionneront comme d'habitude.
-De cette façon, nous pouvons ne déclarer que les différences entre les modÚles (avec `password` en clair, avec `hashed_password` et sans mot de passe) :
+De cette façon, nous pouvons ne déclarer que les différences entre les modÚles (avec `password` en clair, avec `hashed_password` et sans mot de passe) :
{* ../../docs_src/extra_models/tutorial002_py310.py hl[7,13:14,17:18,21:22] *}
Cela sera défini dans OpenAPI avec `anyOf`.
-Pour ce faire, utilisez l'annotation de type Python standard [`typing.Union`](https://docs.python.org/3/library/typing.html#typing.Union)Â :
+Pour ce faire, utilisez l'annotation de type Python standard [`typing.Union`](https://docs.python.org/3/library/typing.html#typing.Union) :
/// note | Remarque
Dans cet exemple, nous passons `Union[PlaneItem, CarItem]` comme valeur de l'argument `response_model`.
-Comme nous le passons comme valeur d'un argument au lieu de l'utiliser dans une annotation de type, nous devons utiliser `Union` mĂȘme en Python 3.10.
+Comme nous le passons comme **valeur Ă un argument** au lieu de l'utiliser dans une **annotation de type**, nous devons utiliser `Union` mĂȘme en Python 3.10.
-S'il s'agissait d'une annotation de type, nous pourrions utiliser la barre verticale, comme :
+S'il s'agissait d'une annotation de type, nous pourrions utiliser la barre verticale, comme :
```Python
some_variable: PlaneItem | CarItem
```
-Mais si nous écrivons cela dans l'affectation `response_model=PlaneItem | CarItem`, nous obtiendrons une erreur, car Python essaierait d'effectuer une « opération invalide » entre `PlaneItem` et `CarItem` au lieu de l'interpréter comme une annotation de type.
+Mais si nous écrivons cela dans l'affectation `response_model=PlaneItem | CarItem`, nous obtiendrons une erreur, car Python essaierait d'effectuer une **opération invalide** entre `PlaneItem` et `CarItem` au lieu de l'interpréter comme une annotation de type.
## Liste de modĂšles { #list-of-models }
De la mĂȘme maniĂšre, vous pouvez dĂ©clarer des rĂ©ponses contenant des listes d'objets.
-Pour cela, utilisez le `list` Python standard :
+Pour cela, utilisez le `list` Python standard :
{* ../../docs_src/extra_models/tutorial004_py310.py hl[18] *}
C'est utile si vous ne connaissez pas à l'avance les noms de champs/attributs valides (qui seraient nécessaires pour un modÚle Pydantic).
-Dans ce cas, vous pouvez utiliser `dict`Â :
+Dans ce cas, vous pouvez utiliser `dict` :
{* ../../docs_src/extra_models/tutorial005_py310.py hl[6] *}
Utilisez plusieurs modÚles Pydantic et héritez librement selon chaque cas.
-Vous n'avez pas besoin d'avoir un seul modÚle de données par entité si cette entité doit pouvoir avoir différents « états ». Comme pour l'« entité » utilisateur, avec un état incluant `password`, `password_hash` et sans mot de passe.
+Vous n'avez pas besoin d'avoir un seul modÚle de données par entité si cette entité doit pouvoir avoir différents « états ». L'« entité » **utilisateur** est un exemple, avec des états qui incluent `password`, `password_hash`, ou aucun mot de passe.
### Configurer le `entrypoint` de lâapplication dans `pyproject.toml` { #configure-the-app-entrypoint-in-pyproject-toml }
-Vous pouvez configurer lâemplacement de votre application dans un fichier `pyproject.toml` commeâŻ:
+Vous pouvez configurer lâemplacement de votre application dans un fichier `pyproject.toml` comme :
```toml
[tool.fastapi]
entrypoint = "main:app"
```
-Ce `entrypoint` indiquera Ă la commande `fastapi` quâelle doit importer lâapplication commeâŻ:
+Ce `entrypoint` indiquera Ă la commande `fastapi` quâelle doit importer lâapplication comme :
```python
from main import app
```
-Si votre code est structurĂ© commeâŻ:
+Si votre code est structuré comme :
```
.
â  âââ __init__.py
```
-Alors vous dĂ©finiriez le `entrypoint` commeâŻ:
+Alors vous définiriez le `entrypoint` comme :
```toml
[tool.fastapi]
entrypoint = "backend.main:app"
```
-ce qui Ă©quivaudrait Ă âŻ:
+ce qui Ă©quivaudrait Ă :
```python
from backend.main import app
### `fastapi dev` avec un chemin ou avec lâoption CLI `--entrypoint` { #fastapi-dev-with-path-or-with-entrypoint-cli-option }
-Vous pouvez Ă©galement passer le chemin du fichier Ă la commande `fastapi dev`, et elle devinera lâobjet dâapplication FastAPI Ă utiliserâŻ:
+Vous pouvez Ă©galement passer le chemin du fichier Ă la commande `fastapi dev`, et elle devinera lâobjet dâapplication FastAPI Ă utiliser :
```console
$ fastapi dev main.py
```
-Ou bien, vous pouvez aussi passer lâoption `--entrypoint` Ă la commande `fastapi dev`âŻ:
+Ou bien, vous pouvez aussi passer lâoption `--entrypoint` Ă la commande `fastapi dev` :
```console
$ fastapi dev --entrypoint main:app
```
-Mais vous devrez vous souvenir de passer le chemin\entrypoint correct à chaque exécution de la commande `fastapi`.
+Mais vous devez vous souvenir de passer le chemin\entrypoint correct à chaque exécution de la commande `fastapi`.
De plus, dâautres outils pourraient ne pas ĂȘtre capables de le trouver, par exemple lâ[Extension VS Code](../editor-support.md) ou [FastAPI Cloud](https://fastapicloud.com), il est donc recommandĂ© dâutiliser le `entrypoint` dans `pyproject.toml`.
Ce sera le point principal dâinteraction pour crĂ©er toute votre API.
-### Ătape 3 : crĂ©er un « chemin dâaccĂšs » { #step-3-create-a-path-operation }
+### Ătape 3 : crĂ©er un *chemin dâaccĂšs* { #step-3-create-a-path-operation }
#### Chemin { #path }
Nous allons donc aussi les appeler « opérations ».
-#### DĂ©finir un « dĂ©corateur de chemin dâaccĂšs » { #define-a-path-operation-decorator }
+#### DĂ©finir un *dĂ©corateur de chemin dâaccĂšs* { #define-a-path-operation-decorator }
{* ../../docs_src/first_steps/tutorial001_py310.py hl[6] *}
-Le `@app.get("/")` indique Ă **FastAPI** que la fonction juste en dessous est chargĂ©e de gĂ©rer les requĂȘtes qui vont versâŻ:
+Le `@app.get("/")` indique Ă **FastAPI** que la fonction juste en dessous est chargĂ©e de gĂ©rer les requĂȘtes qui vont vers :
* le chemin `/`
* en utilisant une <dfn title="une méthode HTTP GET"><code>get</code> opération</dfn>
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 câest de lĂ que vient le terme đ€·đ»ââ).
+Vous la mettez au-dessus dâune fonction. Comme un joli chapeau dĂ©coratif (jâimagine que câest de lĂ que vient le terme).
Un « décorateur » prend la fonction en dessous et fait quelque chose avec.
Dans notre cas, ce décorateur indique à **FastAPI** que la fonction en dessous correspond au **chemin** `/` avec une **opération** `get`.
-Câest le « dĂ©corateur de chemin dâaccĂšs ».
+Câest le **« dĂ©corateur de chemin dâaccĂšs »**.
///
### Ătape 4 : dĂ©finir la **fonction de chemin dâaccĂšs** { #step-4-define-the-path-operation-function }
-Voici notre « fonction de chemin dâaccĂšs » :
+Voici notre **« fonction de chemin dâaccĂšs »** :
* **chemin** : `/`.
* **opération** : `get`.
Câest une fonction Python.
-Elle sera appelĂ©e par **FastAPI** chaque fois quâil recevra une requĂȘte vers lâURL « / » en utilisant une opĂ©ration `GET`.
+Elle sera appelĂ©e par **FastAPI** chaque fois quâil recevra une requĂȘte vers lâURL « `/` » en utilisant une opĂ©ration `GET`.
Dans ce cas, câest une fonction `async`.
/// note | Remarque
-Si vous ne connaissez pas la différence, consultez [Asynchrone : « Pressé ? »](../async.md#in-a-hurry).
+Si vous ne connaissez pas la différence, consultez [Asynchrone : *« Pressé ? »*](../async.md#in-a-hurry).
///
### Réponse résultante { #the-resulting-response }
-Si le client demande `http://example.com/items/foo` (un `item_id` « foo »), il recevra un code d'état HTTP 200 et une réponse JSON :
+Si le client demande `http://example.com/items/foo` (un `item_id` `"foo"`), il recevra un code d'état HTTP 200 et une réponse JSON :
```JSON
{
}
```
-Mais si le client demande `http://example.com/items/bar` (un `item_id` inexistant « bar »), il recevra un code d'état HTTP 404 (l'erreur « not found ») et une réponse JSON :
+Mais si le client demande `http://example.com/items/bar` (un `item_id` inexistant `"bar"`), il recevra un code d'état HTTP 404 (l'erreur « not found ») et une réponse JSON :
```JSON
{
# Tutoriel - Guide utilisateur { #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épondre à vos besoins spécifiques d'API.
| `title` | `str` | Le titre de lâAPI. |
| `summary` | `str` | Un court rĂ©sumĂ© de lâAPI. <small>Disponible depuis OpenAPI 3.1.0, FastAPI 0.99.0.</small> |
| `description` | `str` | Une brĂšve description de lâAPI. Elle peut utiliser Markdown. |
-| `version` | `string` | La version de lâAPI. Câest la version de votre propre application, pas dâOpenAPI. Par exemple `2.5.0`. |
+| `version` | `str` | La version de lâAPI. Câest la version de votre propre application, pas dâOpenAPI. Par exemple `2.5.0`. |
| `terms_of_service` | `str` | Une URL vers les Conditions dâutilisation de lâAPI. Le cas Ă©chĂ©ant, il doit sâagir dâune URL. |
| `contact` | `dict` | Les informations de contact pour lâAPI exposĂ©e. Cela peut contenir plusieurs champs. <details><summary>champs de <code>contact</code></summary><table><thead><tr><th>ParamĂštre</th><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td>Le nom identifiant de la personne/organisation de contact.</td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>LâURL pointant vers les informations de contact. DOIT ĂȘtre au format dâune URL.</td></tr><tr><td><code>email</code></td><td><code>str</code></td><td>Lâadresse e-mail de la personne/organisation de contact. DOIT ĂȘtre au format dâune adresse e-mail.</td></tr></tbody></table></details> |
| `license_info` | `dict` | Les informations de licence pour lâAPI exposĂ©e. Cela peut contenir plusieurs champs. <details><summary>champs de <code>license_info</code></summary><table><thead><tr><th>ParamĂštre</th><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td><strong>OBLIGATOIRE</strong> (si un <code>license_info</code> est dĂ©fini). Le nom de la licence utilisĂ©e pour lâAPI.</td></tr><tr><td><code>identifier</code></td><td><code>str</code></td><td>Une expression de licence [SPDX](https://spdx.org/licenses/) pour lâAPI. Le champ <code>identifier</code> est mutuellement exclusif du champ <code>url</code>. <small>Disponible depuis OpenAPI 3.1.0, FastAPI 0.99.0.</small></td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>Une URL vers la licence utilisĂ©e pour lâAPI. DOIT ĂȘtre au format dâune URL.</td></tr></tbody></table></details> |
# Configurer les chemins d'accĂšs { #path-operation-configuration }
+
Vous pouvez passer plusieurs paramÚtres à votre *décorateur de chemin d'accÚs* pour le configurer.
/// warning | Alertes
- **Valider** les donnĂ©es en sâassurant que la longueur maximale est de 50 caractĂšres
- Afficher une **erreur claire** au client quand les données ne sont pas valides
-- **Documenter** le paramĂštre dans la *chemin d'accĂšs* du schĂ©ma OpenAPI (il apparaĂźtra donc dans lâ**interface de documentation automatique**)
+- **Documenter** le paramĂštre dans le *chemin d'accĂšs* du schĂ©ma OpenAPI (il apparaĂźtra donc dans lâ**interface de documentation automatique**)
## Alternative (ancienne) : `Query` comme valeur par défaut { #alternative-old-query-as-the-default-value }
/// tip | Astuce
-Pour du 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. đ°
+Pour du nouveau code et chaque fois que possible, utilisez `Annotated` comme expliquĂ© ci-dessus. Il y a de multiples avantages (expliquĂ©s ci-dessous) et aucun inconvĂ©nient. đ°
///
q: str | None = Query(default=None, max_length=50)
```
-Cela validera les données, affichera une erreur claire lorsque les données ne sont pas valides et documentera le paramÚtre dans la *chemin d'accÚs* du schéma OpenAPI.
+Cela validera les données, affichera une erreur claire lorsque les données ne sont pas valides et documentera le paramÚtre dans le *chemin d'accÚs* du schéma OpenAPI.
### `Query` comme valeur par défaut ou dans `Annotated` { #query-as-the-default-value-or-in-annotated }
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 Ă lâintĂ©rieur de votre fonction de *chemin d'accĂšs*, dans le *paramĂštre de fonction* `q`.
+vous recevriez les valeurs des multiples paramĂštres de requĂȘte `q` (`foo` et `bar`) dans une `list` Python Ă lâintĂ©rieur de votre *fonction de chemin d'accĂšs*, dans le *paramĂštre de fonction* `q`.
Donc, la réponse pour cette URL serait :
# ParamĂštres de requĂȘte { #query-parameters }
-Quand 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 « query ».
+Quand 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_py310.py hl[9] *}
ou n'importe quelle autre variation de casse (tout en majuscules, uniquement la premiĂšre lettre en majuscule, etc.), votre fonction verra le paramĂštre `short` avec une valeur `bool` Ă `True`. Sinon la valeur sera Ă `False`.
+
## 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 en mĂȘme temps, **FastAPI** sait lequel est lequel.
# Envoyer des fichiers { #request-files }
+
Vous pouvez définir des fichiers à téléverser par le client en utilisant `File`.
/// note | Remarque
Mais lorsque le formulaire inclut des fichiers, il est encodé en `multipart/form-data`. Vous lirez la gestion des fichiers dans le chapitre suivant.
-Si vous voulez en savoir plus sur ces encodages et les champs de formulaire, consultez la [<abbr title="Mozilla Developer Network - Réseau des développeurs Mozilla">MDN</abbr> web docs pour `POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST).
+Si vous voulez en savoir plus sur ces encodages et les champs de formulaire, consultez les [documents web de la <abbr title="Mozilla Developer Network - Réseau des développeurs Mozilla">MDN</abbr> pour `POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST).
///
# Code d'état de la réponse { #response-status-code }
+
De la mĂȘme maniĂšre que vous pouvez spĂ©cifier un modĂšle de rĂ©ponse, vous pouvez Ă©galement dĂ©clarer le code d'Ă©tat HTTP utilisĂ© pour la rĂ©ponse avec le paramĂštre `status_code` dans n'importe lequel des chemins d'accĂšs :
* `@app.get()`
# DĂ©clarer des exemples de donnĂ©es de requĂȘte { #declare-request-example-data }
-Vous pouvez déclarer des exemples des données que votre application peut recevoir.
+Vous pouvez déclarer des exemples de données que votre application peut recevoir.
Voici plusieurs façons de le faire.
{* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}
-Ces informations supplémentaires seront ajoutées telles quelles au **JSON Schema** de sortie pour ce modÚle, et elles seront utilisées dans la documentation de l'API.
+Ces informations supplémentaires seront ajoutées telles quelles au **JSON Schema** de sortie pour ce modÚle, et elles seront utilisées dans les documents de l'API.
-Vous pouvez utiliser l'attribut `model_config` qui accepte un `dict` comme décrit dans [Documentation de Pydantic : Configuration](https://docs.pydantic.dev/latest/api/config/).
+Vous pouvez utiliser l'attribut `model_config` qui accepte un `dict` comme décrit dans [documents de Pydantic : Configuration](https://docs.pydantic.dev/latest/api/config/).
Vous pouvez définir `"json_schema_extra"` avec un `dict` contenant toutes les données supplémentaires que vous souhaitez voir apparaßtre dans le JSON Schema généré, y compris `examples`.
OpenAPI 3.1.0 (utilisé depuis FastAPI 0.99.0) a ajouté la prise en charge de `examples`, qui fait partie du standard **JSON Schema**.
-Avant cela, seule la clĂ© `example` avec un exemple unique Ă©tait prise en charge. Elle l'est toujours par OpenAPI 3.1.0, mais elle est dĂ©prĂ©ciĂ©e et ne fait pas partie du standard JSON Schema. Vous ĂȘtes donc encouragĂ© Ă migrer de `example` vers `examples`. đ€
+Avant cela, seul le mot-clĂ© `example` avec un exemple unique Ă©tait pris en charge. Il l'est toujours par OpenAPI 3.1.0, mais il est dĂ©prĂ©ciĂ© et ne fait pas partie du standard JSON Schema. Vous ĂȘtes donc encouragĂ© Ă migrer de `example` vers `examples`. đ€
Vous pouvez en lire davantage Ă la fin de cette page.
/// note | Remarque
-MĂȘme aprĂšs la sortie d'OpenAPI 3.1.0 avec cette nouvelle intĂ©gration plus simple avec JSON Schema, pendant un temps, Swagger UI, l'outil qui fournit la documentation automatique, ne prenait pas en charge OpenAPI 3.1.0 (il le fait depuis la version 5.0.0 đ).
+MĂȘme aprĂšs la sortie d'OpenAPI 3.1.0 avec cette nouvelle intĂ©gration plus simple avec JSON Schema, pendant un temps, Swagger UI, l'outil qui fournit les documents automatiques, ne prenait pas en charge OpenAPI 3.1.0 (il le fait depuis la version 5.0.0 đ).
à cause de cela, les versions de FastAPI antérieures à 0.99.0 utilisaient encore des versions d'OpenAPI inférieures à 3.1.0.
Lorsque vous ajoutez `examples` dans un modÚle Pydantic, en utilisant `schema_extra` ou `Field(examples=["something"])`, cet exemple est ajouté au **JSON Schema** de ce modÚle Pydantic.
-Et ce **JSON Schema** du modÚle Pydantic est inclus dans l'**OpenAPI** de votre API, puis il est utilisé dans l'interface de la documentation.
+Et ce **JSON Schema** du modÚle Pydantic est inclus dans l'**OpenAPI** de votre API, puis il est utilisé dans l'interface des documents.
Dans les versions de FastAPI antĂ©rieures Ă 0.99.0 (0.99.0 et supĂ©rieures utilisent le nouveau OpenAPI 3.1.0), lorsque vous utilisiez `example` ou `examples` avec l'une des autres utilitaires (`Query()`, `Body()`, etc.), ces exemples n'Ă©taient pas ajoutĂ©s au JSON Schema qui dĂ©crit ces donnĂ©es (pas mĂȘme Ă la version de JSON Schema propre Ă OpenAPI), ils Ă©taient ajoutĂ©s directement Ă la dĂ©claration du *chemin d'accĂšs* dans OpenAPI (en dehors des parties d'OpenAPI qui utilisent JSON Schema).
### Swagger UI et `examples` spécifiques à OpenAPI { #swagger-ui-and-openapi-specific-examples }
-Comme Swagger UI ne prenait pas en charge plusieurs exemples JSON Schema (au 2023-08-26), les utilisateurs n'avaient pas de moyen d'afficher plusieurs exemples dans les documents.
+Maintenant, comme Swagger UI ne prenait pas en charge plusieurs exemples JSON Schema (au 2023-08-26), les utilisateurs n'avaient pas de moyen d'afficher plusieurs exemples dans les documents.
Pour rĂ©soudre cela, FastAPI `0.103.0` a **ajoutĂ© la prise en charge** de la dĂ©claration du mĂȘme ancien champ `examples` **spĂ©cifique Ă OpenAPI** avec le nouveau paramĂštre `openapi_examples`. đ€
## VĂ©rifier { #check-it }
-Allez à la documentation interactive à l'adresse : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
+Allez aux documents interactifs à l'adresse : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Vous verrez quelque chose comme ceci :
Voyons cela selon ce point de vue simplifié :
-- L'utilisateur saisit le `username` et le `password` dans le frontend, puis appuie sur Entrée.
-- Le frontend (exécuté dans le navigateur de l'utilisateur) envoie ce `username` et ce `password` vers une URL spécifique de notre API (déclarée avec `tokenUrl="token"`).
-- L'API vérifie ce `username` et ce `password`, et répond avec un « token » (nous n'avons encore rien implémenté de tout cela).
- - Un « token » n'est qu'une chaßne contenant des informations que nous pouvons utiliser plus tard pour vérifier cet utilisateur.
- - Normalement, un token est configuré pour expirer aprÚs un certain temps.
- - Ainsi, l'utilisateur devra se reconnecter à un moment donné.
- - Et si le token est volé, le risque est moindre. Ce n'est pas une clé permanente qui fonctionnerait indéfiniment (dans la plupart des cas).
-- Le frontend stocke ce token temporairement quelque part.
-- L'utilisateur clique dans le frontend pour aller vers une autre section de l'application web frontend.
-- Le frontend doit récupérer d'autres données depuis l'API.
- - Mais cela nécessite une authentification pour cet endpoint spécifique.
- - Donc, pour s'authentifier auprĂšs de notre API, il envoie un en-tĂȘte `Authorization` avec une valeur `Bearer ` suivie du token.
- - Si le token contient `foobar`, le contenu de l'en-tĂȘte `Authorization` serait : `Bearer foobar`.
+* L'utilisateur saisit le `username` et le `password` dans le frontend, puis appuie sur Entrée.
+* Le frontend (exécuté dans le navigateur de l'utilisateur) envoie ce `username` et ce `password` vers une URL spécifique de notre API (déclarée avec `tokenUrl="token"`).
+* L'API vérifie ce `username` et ce `password`, et répond avec un « token » (nous n'avons encore rien implémenté de tout cela).
+ * Un « token » n'est qu'une chaßne contenant des informations que nous pouvons utiliser plus tard pour vérifier cet utilisateur.
+ * Normalement, un token est configuré pour expirer aprÚs un certain temps.
+ * Ainsi, l'utilisateur devra se reconnecter à un moment donné.
+ * Et si le token est volé, le risque est moindre. Ce n'est pas une clé permanente qui fonctionnerait indéfiniment (dans la plupart des cas).
+* Le frontend stocke ce token temporairement quelque part.
+* L'utilisateur clique dans le frontend pour aller vers une autre section de l'application web frontend.
+* Le frontend doit récupérer d'autres données depuis l'API.
+ * Mais cela nécessite une authentification pour cet endpoint spécifique.
+ * Donc, pour s'authentifier auprĂšs de notre API, il envoie un en-tĂȘte `Authorization` avec une valeur `Bearer ` suivie du token.
+ * Si le token contient `foobar`, le contenu de l'en-tĂȘte `Authorization` serait : `Bearer foobar`.
## Le `OAuth2PasswordBearer` de **FastAPI** { #fastapis-oauth2passwordbearer }
{* ../../docs_src/security/tutorial001_an_py310.py hl[12] *}
-Cette dépendance fournira une `str` qui est affectée au paramÚtre `token` de la fonction de *chemin d'accÚs*.
+Cette dépendance fournira une `str` qui est affectée au paramÚtre `token` de la *fonction de chemin d'accÚs*.
-**FastAPI** saura qu'il peut utiliser cette dépendance pour définir un « schéma de sécurité » dans le schéma OpenAPI (et la documentation API automatique).
+**FastAPI** saura qu'il peut utiliser cette dépendance pour définir un « schéma de sécurité » dans le schéma OpenAPI (et les documents automatiques de l'API).
/// note | DĂ©tails techniques
**FastAPI** saura qu'il peut utiliser la classe `OAuth2PasswordBearer` (déclarée dans une dépendance) pour définir le schéma de sécurité dans OpenAPI parce qu'elle hérite de `fastapi.security.oauth2.OAuth2`, qui hérite à son tour de `fastapi.security.base.SecurityBase`.
-Tous les utilitaires de sécurité qui s'intÚgrent à OpenAPI (et à la documentation API automatique) héritent de `SecurityBase`, c'est ainsi que **FastAPI** sait comment les intégrer dans OpenAPI.
+Tous les utilitaires de sécurité qui s'intÚgrent à OpenAPI (et aux documents automatiques de l'API) héritent de `SecurityBase`, c'est ainsi que **FastAPI** sait comment les intégrer dans OpenAPI.
///
Vous n'avez mĂȘme pas Ă vĂ©rifier si le token existe pour renvoyer une erreur. Vous pouvez ĂȘtre sĂ»r que si votre fonction est exĂ©cutĂ©e, elle aura une `str` dans ce token.
-Vous pouvez déjà l'essayer dans la documentation interactive :
+Vous pouvez déjà l'essayer dans les documents interactifs :
<img src="/img/tutorial/security/image03.png">
De la mĂȘme maniĂšre que nous utilisons Pydantic pour dĂ©clarer des corps de requĂȘte, nous pouvons l'utiliser ailleurs :
-{* ../../docs_src/security/tutorial002_an_py310.py hl[5,12:6] *}
+{* ../../docs_src/security/tutorial002_an_py310.py hl[5,12:16] *}
## Créer une dépendance `get_current_user` { #create-a-get-current-user-dependency }
Mais vous ne pouvez pas convertir le charabia en sens inverse vers le mot de passe.
-### Pourquoi utiliser le hachage de mot passe { #why-use-password-hashing }
+### Pourquoi utiliser le hachage de mot de passe { #why-use-password-hashing }
Si votre base de données est volée, le voleur n'aura pas les mots de passe en clair de vos utilisateurs, seulement les hachages.
Lorsque `authenticate_user` est appelĂ©e avec un nom d'utilisateur qui n'existe pas dans la base de donnĂ©es, nous exĂ©cutons tout de mĂȘme `verify_password` contre un hachage factice.
-Cela garantit que le point de terminaison met approximativement le mĂȘme temps Ă rĂ©pondre que le nom d'utilisateur soit valide ou non, empĂȘchant des **attaques temporelles** qui pourraient ĂȘtre utilisĂ©es pour Ă©numĂ©rer les noms d'utilisateur existants.
+Cela garantit que l'endpoint met approximativement le mĂȘme temps Ă rĂ©pondre que le nom d'utilisateur soit valide ou non, empĂȘchant des **attaques temporelles** qui pourraient ĂȘtre utilisĂ©es pour Ă©numĂ©rer les noms d'utilisateur existants.
/// note | Remarque
Créez une variable pour l'expiration du jeton.
-Définissez un modÚle Pydantic qui sera utilisé dans le point de terminaison du jeton pour la réponse.
+Définissez un modÚle Pydantic qui sera utilisé dans l'endpoint du jeton pour la réponse.
Créez une fonction utilitaire pour générer un nouveau jeton d'accÚs.
## VĂ©rifier { #check-it }
-Lancez le serveur et allez Ă la documentation : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
+Lancez le serveur et accédez aux documents : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Vous verrez l'interface utilisateur suivante :
/// tip | Astuce
-Remarquez qu'à aucun endroit du code le mot de passe en clair « secret » n'apparaßt, nous n'avons que la version hachée.
+Remarquez qu'à aucun endroit du code le mot de passe en clair « `secret` » n'apparaßt, nous n'avons que la version hachée.
///
<img src="/img/tutorial/security/image08.png">
-Appelez le point de terminaison `/users/me/`, vous obtiendrez la réponse suivante :
+Appelez l'endpoint `/users/me/`, vous obtiendrez la réponse suivante :
```JSON
{
Et vos modÚles de base de données peuvent utiliser les noms que vous voulez.
-Mais pour le chemin d'accĂšs de connexion, nous devons utiliser ces noms pour ĂȘtre compatibles avec la spĂ©cification (et pouvoir, par exemple, utiliser le systĂšme de documentation API intĂ©grĂ©).
+Mais pour le *chemin d'accĂšs* de connexion, nous devons utiliser ces noms pour ĂȘtre compatibles avec la spĂ©cification (et pouvoir, par exemple, utiliser le systĂšme de documentation API intĂ©grĂ©).
La spĂ©cification prĂ©cise Ă©galement que `username` et `password` doivent ĂȘtre envoyĂ©s en donnĂ©es de formulaire (donc pas de JSON ici).
### `scope` { #scope }
-La spécification indique aussi que le client peut envoyer un autre champ de formulaire « scope ».
+La spécification indique aussi que le client peut envoyer un autre champ de formulaire « `scope` ».
Le nom du champ de formulaire est `scope` (au singulier), mais il s'agit en fait d'une longue chaßne contenant des « scopes » séparés par des espaces.
### `OAuth2PasswordRequestForm` { #oauth2passwordrequestform }
-Tout d'abord, importez `OAuth2PasswordRequestForm`, et utilisez-la en tant que dépendance avec `Depends` dans le chemin d'accÚs pour `/token` :
+Tout d'abord, importez `OAuth2PasswordRequestForm`, et utilisez-la en tant que dépendance avec `Depends` dans le *chemin d'accÚs* pour `/token` :
{* ../../docs_src/security/tutorial003_an_py310.py hl[4,78] *}
/// tip | Astuce
-La spécification OAuth2 exige en réalité un champ `grant_type` avec la valeur fixe `password`, mais `OAuth2PasswordRequestForm` ne l'impose pas.
+La spécification OAuth2 *exige* en réalité un champ `grant_type` avec la valeur fixe `password`, mais `OAuth2PasswordRequestForm` ne l'impose pas.
Si vous avez besoin de l'imposer, utilisez `OAuth2PasswordRequestFormStrict` au lieu de `OAuth2PasswordRequestForm`.
`UserInDB(**user_dict)` signifie :
-Passez les clĂ©s et valeurs de `user_dict` directement comme arguments clĂ©âvaleur, Ă©quivalent Ă :
+*Passez les clĂ©s et valeurs de `user_dict` directement comme arguments clĂ©âvaleur, Ă©quivalent Ă :*
```Python
UserInDB(
/// note | Remarque
-Pour une explication plus complÚte de `**user_dict`, consultez [la documentation pour **ModÚles supplémentaires**](../extra-models.md#about-user-in-dict).
+Pour une explication plus complÚte de `**user_dict`, consultez [la documentation pour **ModÚles supplémentaires**](../extra-models.md#about-user-in-model-dump).
///
La rĂ©ponse de l'endpoint `token` doit ĂȘtre un objet JSON.
-Il doit contenir un `token_type`. Dans notre cas, comme nous utilisons des jetons « Bearer », le type de jeton doit ĂȘtre « bearer ».
+Il doit contenir un `token_type`. Dans notre cas, comme nous utilisons des jetons « Bearer », le type de jeton doit ĂȘtre « `bearer` ».
Et il doit contenir un `access_token`, avec une chaĂźne contenant notre jeton d'accĂšs.
Nous allons maintenant mettre à jour nos dépendances.
-Nous voulons obtenir `current_user` uniquement si cet utilisateur est actif.
+Nous voulons obtenir `current_user` *uniquement* si cet utilisateur est actif.
Nous créons donc une dépendance supplémentaire `get_current_active_user` qui utilise à son tour `get_current_user` comme dépendance.
## Voir en action { #see-it-in-action }
-Ouvrez la documentation interactive : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
+Ouvrez les documents interactifs : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
### S'authentifier { #authenticate }
///
-Il s'agit d'un tutoriel trÚs simple et court ; si vous souhaitez apprendre sur les bases de données en général, sur SQL, ou des fonctionnalités plus avancées, allez voir la [documentation SQLModel](https://sqlmodel.tiangolo.com/).
+Il s'agit d'un tutoriel trÚs simple et court ; si vous souhaitez apprendre sur les bases de données en général, sur SQL, ou des fonctionnalités plus avancées, allez voir les [documents de SQLModel](https://sqlmodel.tiangolo.com/).
## Installer `SQLModel` { #install-sqlmodel }
{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[1:11] hl[7:11] *}
-La classe `Hero` est trÚs similaire à un modÚle Pydantic (en fait, en dessous, c'est réellement un modÚle Pydantic).
+La classe `Hero` est trÚs similaire à un modÚle Pydantic (en fait, en dessous, c'est réellement *un modÚle Pydantic*).
Il y a quelques différences :
* `table=True` indique à SQLModel qu'il s'agit d'un *modÚle de table*, il doit représenter une **table** dans la base SQL, ce n'est pas seulement un *modÚle de données* (comme le serait n'importe quelle autre classe Pydantic classique).
-* `Field(primary_key=True)` indique à SQLModel que `id` est la **clé primaire** dans la base SQL (vous pouvez en savoir plus sur les clés primaires SQL dans la documentation SQLModel).
+* `Field(primary_key=True)` indique à SQLModel que `id` est la **clé primaire** dans la base SQL (vous pouvez en savoir plus sur les clés primaires SQL dans les documents de SQLModel).
- Remarque : nous utilisons `int | None` pour le champ clé primaire afin qu'en Python nous puissions *créer un objet sans `id`* (`id=None`), en supposant que la base *le génÚre à l'enregistrement*. SQLModel comprend que la base fournira l'`id` et *définit la colonne comme un `INTEGER` non nul* dans le schéma de base. Voir la [documentation SQLModel sur les clés primaires](https://sqlmodel.tiangolo.com/tutorial/create-db-and-table/#primary-key-id) pour plus de détails.
+ **Remarque :** nous utilisons `int | None` pour le champ clé primaire afin qu'en Python nous puissions *créer un objet sans `id`* (`id=None`), en supposant que la base *le génÚre à l'enregistrement*. SQLModel comprend que la base fournira l'`id` et *définit la colonne comme un `INTEGER` non nul* dans le schéma de base. Voir les [documents de SQLModel sur les clés primaires](https://sqlmodel.tiangolo.com/tutorial/create-db-and-table/#primary-key-id) pour plus de détails.
* `Field(index=True)` indique à SQLModel qu'il doit créer un **index SQL** pour cette colonne, ce qui permettra des recherches plus rapides dans la base lors de la lecture de données filtrées par cette colonne.
Par exemple, si vous déclarez un paramÚtre de type `Hero`, il sera lu depuis le **corps JSON**.
-De la mĂȘme maniĂšre, vous pouvez le dĂ©clarer comme **type de retour** de la fonction, et alors la forme des donnĂ©es apparaĂźtra dans l'UI automatique de documentation de l'API.
+De la mĂȘme maniĂšre, vous pouvez le dĂ©clarer comme **type de retour** de la fonction, et alors la forme des donnĂ©es apparaĂźtra dans l'UI automatique des documents de l'API.
{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[40:45] hl[40:45] *}
Nous ne devrions pas laisser cela se produire, ils pourraient Ă©craser un `id` que nous avons dĂ©jĂ attribuĂ© dans la base. DĂ©cider de l'`id` doit ĂȘtre fait par le **backend** ou la **base**, **pas par le client**.
-De plus, nous crĂ©ons un `secret_name` pour le hĂ©ros, mais jusqu'ici, nous le renvoyons partout, ce n'est pas trĂšs « secret » ... đ
+De plus, nous crĂ©ons un `secret_name` pour le hĂ©ros, mais jusqu'ici, nous le renvoyons partout, ce n'est pas trĂšs **secret** ... đ
Nous allons corriger ces choses en ajoutant quelques **modĂšles supplĂ©mentaires**. C'est lĂ que SQLModel brille. âš
Vous pouvez utiliser [**SQLModel**](https://sqlmodel.tiangolo.com/) pour interagir avec une base SQL et simplifier le code avec des *modÚles de données* et des *modÚles de table*.
-Vous pouvez en apprendre beaucoup plus dans la documentation **SQLModel**, il y a un mini [tutoriel plus long sur l'utilisation de SQLModel avec **FastAPI**](https://sqlmodel.tiangolo.com/tutorial/fastapi/). đ
+Vous pouvez en apprendre beaucoup plus dans les documents de **SQLModel**, il y a un mini [tutoriel plus long sur l'utilisation de SQLModel avec **FastAPI**](https://sqlmodel.tiangolo.com/tutorial/fastapi/). đ
Vous pouvez servir des fichiers statiques automatiquement à partir d'un répertoire en utilisant `StaticFiles`.
+/// tip | Astuce
+
+Si vous devez héberger un frontend, utilisez plutÎt `app.frontend()`, lisez-en davantage dans [Frontend](frontend.md).
+
+`app.frontend()` utilise `StaticFiles` en interne, avec plusieurs avantages supplémentaires pour les frontends, comme la gestion du routing cÎté client.
+
+///
+
## Utiliser `StaticFiles` { #use-staticfiles }
- Importer `StaticFiles`.
Pour utiliser `TestClient`, installez dâabord [`httpx`](https://www.python-httpx.org).
-Vous devez crĂ©er un [environnement virtuel](../virtual-environments.md), lâactiver, puis y installer le paquet, par exemple :
+Vous devez vous assurer de crĂ©er un [environnement virtuel](../virtual-environments.md), de lâactiver, puis dây installer le paquet, par exemple :
```console
$ pip install httpx
AprĂšs cela, vous avez simplement besoin dâinstaller `pytest`.
-Vous devez crĂ©er un [environnement virtuel](../virtual-environments.md), lâactiver, puis y installer le paquet, par exemple :
+Vous devez vous assurer de crĂ©er un [environnement virtuel](../virtual-environments.md), de lâactiver, puis dây installer le paquet, par exemple :
<div class="termy">
# Environnements virtuels { #virtual-environments }
-Lorsque vous travaillez sur des projets Python, vous devriez probablement utiliser un environnement virtuel (ou un mécanisme similaire) pour isoler les packages que vous installez pour chaque projet.
+Lorsque vous travaillez sur des projets Python, vous devriez probablement utiliser un **environnement virtuel** (ou un mécanisme similaire) pour isoler les packages que vous installez pour chaque projet.
/// note | Remarque
/// tip | Astuce
-Un environnement virtuel est diffĂ©rent dâune variable dâenvironnement.
+Un **environnement virtuel** est diffĂ©rent dâune **variable dâenvironnement**.
-Une variable dâenvironnement est une variable du systĂšme qui peut ĂȘtre utilisĂ©e par des programmes.
+Une **variable dâenvironnement** est une variable du systĂšme qui peut ĂȘtre utilisĂ©e par des programmes.
-Un environnement virtuel est un répertoire contenant certains fichiers.
+Un **environnement virtuel** est un répertoire contenant certains fichiers.
///
/// note | Remarque
-Cette page vous apprendra Ă utiliser les environnements virtuels et Ă comprendre leur fonctionnement.
+Cette page vous apprendra Ă utiliser les **environnements virtuels** et Ă comprendre leur fonctionnement.
-Si vous ĂȘtes prĂȘt Ă adopter un outil qui gĂšre tout pour vous (y compris lâinstallation de Python), essayez [uv](https://github.com/astral-sh/uv).
+Si vous ĂȘtes prĂȘt Ă adopter un **outil qui gĂšre tout** pour vous (y compris lâinstallation de Python), essayez [uv](https://github.com/astral-sh/uv).
///
## Créer un environnement virtuel { #create-a-virtual-environment }
-Lorsque vous commencez à travailler sur un projet Python pour la premiÚre fois, créez un environnement virtuel <strong><dfn title="il existe d'autres options, il s'agit d'une simple recommandation">dans votre projet</dfn></strong>.
+Lorsque vous commencez à travailler sur un projet Python **pour la premiÚre fois**, créez un environnement virtuel **<dfn title="il existe d'autres options, il s'agit d'une simple recommandation">dans votre projet</dfn>**.
/// tip | Astuce
-Vous nâavez besoin de faire cela quâune seule fois par projet, pas Ă chaque fois que vous travaillez.
+Vous nâavez besoin de faire cela quâ**une seule fois par projet**, pas Ă chaque fois que vous travaillez.
///
/// tip | Astuce
-Faites cela à chaque fois que vous démarrez une nouvelle session de terminal pour travailler sur le projet.
+Faites cela **chaque fois** que vous démarrez une **nouvelle session de terminal** pour travailler sur le projet.
///
/// tip | Astuce
-Chaque fois que vous installez un nouveau package dans cet environnement, activez de nouveau lâenvironnement.
+Chaque fois que vous installez un **nouveau package** dans cet environnement, **activez** de nouveau lâenvironnement.
-Vous vous assurez ainsi que si vous utilisez un programme de terminal (<abbr title="command line interface - interface en ligne de commande">CLI</abbr>) installĂ© par ce package, vous utilisez celui de votre environnement virtuel et non un autre qui pourrait ĂȘtre installĂ© globalement, probablement avec une version diffĂ©rente de celle dont vous avez besoin.
+Vous vous assurez ainsi que si vous utilisez un **programme de terminal (<abbr title="command line interface - interface en ligne de commande">CLI</abbr>)** installĂ© par ce package, vous utilisez celui de votre environnement virtuel et non un autre qui pourrait ĂȘtre installĂ© globalement, probablement avec une version diffĂ©rente de celle dont vous avez besoin.
///
/// tip | Astuce
-Câest facultatif, mais câest une bonne maniĂšre de vĂ©rifier que tout fonctionne comme prĂ©vu et que vous utilisez lâenvironnement virtuel voulu.
+Câest **facultatif**, mais câest une bonne maniĂšre de **vĂ©rifier** que tout fonctionne comme prĂ©vu et que vous utilisez lâenvironnement virtuel voulu.
///
///
-Si vous utilisez `pip` pour installer des packages (il est fourni par défaut avec Python), vous devez le mettre à niveau vers la derniÚre version.
+Si vous utilisez `pip` pour installer des packages (il est fourni par défaut avec Python), vous devez le **mettre à niveau** vers la derniÚre version.
Beaucoup dâerreurs exotiques lors de lâinstallation dâun package se rĂ©solvent simplement en mettant dâabord `pip` Ă niveau.
/// tip | Astuce
-Vous feriez normalement cela une seule fois, juste aprĂšs avoir crĂ©Ă© lâenvironnement virtuel.
+Vous feriez normalement cela **une seule fois**, juste aprĂšs avoir crĂ©Ă© lâenvironnement virtuel.
///
## Ajouter `.gitignore` { #add-gitignore }
-Si vous utilisez Git (vous devriez), ajoutez un fichier `.gitignore` pour exclure tout ce qui se trouve dans votre `.venv` de Git.
+Si vous utilisez **Git** (vous devriez), ajoutez un fichier `.gitignore` pour exclure tout ce qui se trouve dans votre `.venv` de Git.
/// tip | Astuce
/// tip | Astuce
-Faites cela une seule fois, juste aprĂšs avoir crĂ©Ă© lâenvironnement virtuel.
+Faites cela **une seule fois**, juste aprĂšs avoir crĂ©Ă© lâenvironnement virtuel.
///
/// tip | Astuce
-Faites cela une seule fois lorsque vous installez ou mettez à niveau les packages nécessaires à votre projet.
+Faites cela **une seule fois** lorsque vous installez ou mettez à niveau les packages nécessaires à votre projet.
-Si vous devez mettre Ă niveau une version ou ajouter un nouveau package, vous le referez.
+Si vous devez mettre Ă niveau une version ou ajouter un nouveau package, vous le **referez**.
///
### Installer des packages directement { #install-packages-directly }
-Si vous ĂȘtes pressĂ© et ne souhaitez pas utiliser un fichier pour dĂ©clarer les dĂ©pendances de votre projet, vous pouvez les installer directement.
+Si vous ĂȘtes pressĂ© et ne souhaitez pas utiliser un fichier pour dĂ©clarer les dĂ©pendances de packages de votre projet, vous pouvez les installer directement.
/// tip | Astuce
-Câest une trĂšs bonne idĂ©e de placer les packages et leurs versions nĂ©cessaires Ă votre programme dans un fichier (par exemple `requirements.txt` ou `pyproject.toml`).
+Câest une (trĂšs) bonne idĂ©e de placer les packages et leurs versions nĂ©cessaires Ă votre programme dans un fichier (par exemple `requirements.txt` ou `pyproject.toml`).
///
/// tip | Astuce
-Vous devez normalement faire cela une seule fois, lorsque vous crĂ©ez lâenvironnement virtuel.
+Vous devez normalement faire cela seulement **une fois**, lorsque vous crĂ©ez lâenvironnement virtuel.
///
## DĂ©sactiver lâenvironnement virtuel { #deactivate-the-virtual-environment }
-Une fois que vous avez fini de travailler sur votre projet, vous pouvez dĂ©sactiver lâenvironnement virtuel.
+Une fois que vous avez fini de travailler sur votre projet, vous pouvez **dĂ©sactiver** lâenvironnement virtuel.
<div class="termy">
Pour travailler avec FastAPI, vous devez installer [Python](https://www.python.org/).
-Ensuite, vous devrez installer FastAPI et tout autre package que vous souhaitez utiliser.
+Ensuite, vous devez **installer** FastAPI et tout autre **package** que vous souhaitez utiliser.
Pour installer des packages, vous utiliseriez normalement la commande `pip` fournie avec Python (ou des alternatives similaires).
-NĂ©anmoins, si vous utilisez simplement `pip` directement, les packages seraient installĂ©s dans votre environnement Python global (lâinstallation globale de Python).
+NĂ©anmoins, si vous utilisez simplement `pip` directement, les packages seraient installĂ©s dans votre **environnement Python global** (lâinstallation globale de Python).
### Le problĂšme { #the-problem }
Alors, quel est le problĂšme dâinstaller des packages dans lâenvironnement Python global ?
-Ă un moment donnĂ©, vous finirez probablement par Ă©crire de nombreux programmes diffĂ©rents qui dĂ©pendent de packages diffĂ©rents. Et certains de ces projets sur lesquels vous travaillez dĂ©pendront de versions diffĂ©rentes du mĂȘme package. đ±
+Ă un moment donnĂ©, vous finirez probablement par Ă©crire de nombreux programmes diffĂ©rents qui dĂ©pendent de **packages diffĂ©rents**. Et certains de ces projets sur lesquels vous travaillez dĂ©pendront de **versions diffĂ©rentes** du mĂȘme package. đ±
Par exemple, vous pourriez crĂ©er un projet appelĂ© `philosophers-stone`, ce programme dĂ©pend dâun autre package appelĂ© **`harry`, en version `1`**. Vous devez donc installer `harry`.
azkaban(prisoner-of-azkaban) --> |requires| harry-3[harry v3]
```
-Mais maintenant, le problĂšme est que, si vous installez les packages globalement (dans lâenvironnement global) au lieu de dans un environnement virtuel local, vous devrez choisir quelle version de `harry` installer.
+Mais maintenant, le problĂšme est que, si vous installez les packages globalement (dans lâenvironnement global) au lieu de dans un **environnement virtuel** local, vous devrez choisir quelle version de `harry` installer.
Si vous voulez exĂ©cuter `philosophers-stone`, vous devrez dâabord installer `harry` en version `1`, par exemple avec :
Et vous vous retrouverez alors avec `harry` version `3` installé dans votre environnement Python global.
-Et si vous essayez dâexĂ©cuter Ă nouveau `philosophers-stone`, il y a une chance que cela ne fonctionne pas car il a besoin de `harry` version `1`.
+Et si vous essayez dâexĂ©cuter Ă nouveau `philosophers-stone`, il y a une chance que cela **ne fonctionne pas** car il a besoin de `harry` version `1`.
```mermaid
flowchart LR
/// tip | Astuce
-Il est trÚs courant que les packages Python fassent de leur mieux pour éviter les changements cassants dans les nouvelles versions, mais il vaut mieux jouer la sécurité et installer de nouvelles versions intentionnellement et lorsque vous pouvez exécuter les tests pour vérifier que tout fonctionne correctement.
+Il est trÚs courant que les packages Python fassent de leur mieux pour **éviter les changements cassants** dans les **nouvelles versions**, mais il vaut mieux jouer la sécurité et installer de nouvelles versions intentionnellement et lorsque vous pouvez exécuter les tests pour vérifier que tout fonctionne correctement.
///
-Maintenant, imaginez cela avec beaucoup dâautres packages dont tous vos projets dĂ©pendent. Câest trĂšs difficile Ă gĂ©rer. Et vous finiriez probablement par exĂ©cuter certains projets avec des versions incompatibles des packages, sans savoir pourquoi quelque chose ne fonctionne pas.
+Maintenant, imaginez cela avec **beaucoup** dâautres **packages** dont tous vos **projets dĂ©pendent**. Câest trĂšs difficile Ă gĂ©rer. Et vous finiriez probablement par exĂ©cuter certains projets avec des **versions incompatibles** des packages, sans savoir pourquoi quelque chose ne fonctionne pas.
-De plus, selon votre systĂšme dâexploitation (par exemple Linux, Windows, macOS), il se peut quâil soit livrĂ© avec Python dĂ©jĂ installĂ©. Et dans ce cas, il avait probablement des packages prĂ©installĂ©s avec des versions spĂ©cifiques nĂ©cessaires Ă votre systĂšme. Si vous installez des packages dans lâenvironnement Python global, vous pourriez finir par casser certains des programmes fournis avec votre systĂšme dâexploitation.
+De plus, selon votre systĂšme dâexploitation (par exemple Linux, Windows, macOS), il se peut quâil soit livrĂ© avec Python dĂ©jĂ installĂ©. Et dans ce cas, il avait probablement des packages prĂ©installĂ©s avec des versions spĂ©cifiques **nĂ©cessaires Ă votre systĂšme**. Si vous installez des packages dans lâenvironnement Python global, vous pourriez finir par **casser** certains des programmes fournis avec votre systĂšme dâexploitation.
## OĂč les packages sont-ils installĂ©s { #where-are-packages-installed }
Cela téléchargera un fichier compressé avec le code de FastAPI, normalement depuis [PyPI](https://pypi.org/project/fastapi/).
-Il tĂ©lĂ©chargera Ă©galement des fichiers pour dâautres packages dont FastAPI dĂ©pend.
+Il **tĂ©lĂ©chargera** Ă©galement des fichiers pour dâautres packages dont FastAPI dĂ©pend.
-Ensuite, il extraira tous ces fichiers et les placera dans un répertoire de votre ordinateur.
+Ensuite, il **extraira** tous ces fichiers et les placera dans un répertoire de votre ordinateur.
-Par dĂ©faut, il placera ces fichiers tĂ©lĂ©chargĂ©s et extraits dans le rĂ©pertoire fourni avec votre installation de Python, câest lâenvironnement global.
+Par dĂ©faut, il placera ces fichiers tĂ©lĂ©chargĂ©s et extraits dans le rĂ©pertoire fourni avec votre installation de Python, câest lâ**environnement global**.
## Quâest-ce quâun environnement virtuel { #what-are-virtual-environments }
-La solution aux problĂšmes posĂ©s par le fait dâavoir tous les packages dans lâenvironnement global est dâutiliser un environnement virtuel pour chaque projet sur lequel vous travaillez.
+La solution aux problĂšmes posĂ©s par le fait dâavoir tous les packages dans lâenvironnement global est dâutiliser un **environnement virtuel pour chaque projet** sur lequel vous travaillez.
-Un environnement virtuel est un rĂ©pertoire, trĂšs similaire Ă celui global, oĂč vous pouvez installer les packages pour un projet.
+Un environnement virtuel est un **rĂ©pertoire**, trĂšs similaire Ă celui global, oĂč vous pouvez installer les packages pour un projet.
De cette maniÚre, chaque projet aura son propre environnement virtuel (répertoire `.venv`) avec ses propres packages.
////
-Un dĂ©tail important est quâil placera le chemin de lâenvironnement virtuel au dĂ©but de la variable `PATH`. Le systĂšme le trouvera avant de trouver tout autre Python disponible. Ainsi, lorsque vous exĂ©cutez `python`, il utilisera le Python de lâenvironnement virtuel au lieu de tout autre `python` (par exemple, un `python` dâun environnement global).
+Un dĂ©tail important est quâil placera le chemin de lâenvironnement virtuel au **dĂ©but** de la variable `PATH`. Le systĂšme le trouvera **avant** de trouver tout autre Python disponible. Ainsi, lorsque vous exĂ©cutez `python`, il utilisera le Python **de lâenvironnement virtuel** au lieu de tout autre `python` (par exemple, un `python` dâun environnement global).
Activer un environnement virtuel change aussi deux ou trois autres choses, mais câest lâun des points les plus importants.
////
-Cela signifie que le programme `python` qui sera utilisĂ© est celui dans lâenvironnement virtuel.
+Cela signifie que le programme `python` qui sera utilisĂ© est celui **dans lâenvironnement virtuel**.
Vous utilisez `which` sous Linux et macOS et `Get-Command` sous Windows PowerShell.
-La façon dont cette commande fonctionne est quâelle va vĂ©rifier la variable dâenvironnement `PATH`, en parcourant chaque chemin dans lâordre, Ă la recherche du programme nommĂ© `python`. Une fois trouvĂ©, elle vous affichera le chemin vers ce programme.
+La façon dont cette commande fonctionne est quâelle va vĂ©rifier la variable dâenvironnement `PATH`, en parcourant **chaque chemin dans lâordre**, Ă la recherche du programme nommĂ© `python`. Une fois trouvĂ©, elle vous **affichera le chemin** vers ce programme.
La partie la plus importante est que lorsque vous appelez `python`, câest exactement « `python` » qui sera exĂ©cutĂ©.
/// tip | Astuce
-Il est facile dâactiver un environnement virtuel, dâobtenir un Python, puis dâaller vers un autre projet.
+Il est facile dâactiver un environnement virtuel, dâobtenir un Python, puis dâ**aller vers un autre projet**.
-Et le second projet ne fonctionnerait pas parce que vous utilisez le Python incorrect, provenant dâun environnement virtuel dâun autre projet.
+Et le second projet **ne fonctionnerait pas** parce que vous utilisez le **Python incorrect**, provenant dâun environnement virtuel dâun autre projet.
Il est utile de pouvoir vĂ©rifier quel `python` est utilisĂ©. đ€
## Pourquoi désactiver un environnement virtuel { #why-deactivate-a-virtual-environment }
-Par exemple, vous pourriez travailler sur un projet `philosophers-stone`, activer cet environnement virtuel, installer des packages et travailler avec cet environnement.
+Par exemple, vous pourriez travailler sur un projet `philosophers-stone`, **activer cet environnement virtuel**, installer des packages et travailler avec cet environnement.
-Puis vous souhaitez travailler sur un autre projet `prisoner-of-azkaban`.
+Puis vous souhaitez travailler sur **un autre projet** `prisoner-of-azkaban`.
Vous allez vers ce projet :
## Alternatives { #alternatives }
-Ceci est un guide simple pour vous lancer et vous montrer comment tout fonctionne en dessous.
+Ceci est un guide simple pour vous lancer et vous montrer comment tout fonctionne **en dessous**.
-Il existe de nombreuses alternatives pour gérer les environnements virtuels, les dépendances de packages (requirements), les projets.
+Il existe de nombreuses **alternatives** pour gérer les environnements virtuels, les dépendances de packages (requirements), les projets.
-Lorsque vous ĂȘtes prĂȘt et souhaitez utiliser un outil pour gĂ©rer lâensemble du projet, les dĂ©pendances, les environnements virtuels, etc., je vous suggĂšre dâessayer [uv](https://github.com/astral-sh/uv).
+Lorsque vous ĂȘtes prĂȘt et souhaitez utiliser un outil pour **gĂ©rer lâensemble du projet**, les dĂ©pendances de packages, les environnements virtuels, etc., je vous suggĂšre dâessayer [uv](https://github.com/astral-sh/uv).
`uv` peut faire beaucoup de choses, il peutâŻ:
-* Installer Python pour vous, y compris différentes versions
-* GĂ©rer lâenvironnement virtuel pour vos projets
-* Installer des packages
-* Gérer les dépendances de packages et leurs versions pour votre projet
-* Vous assurer dâavoir un ensemble exact de packages et de versions Ă installer, y compris leurs dĂ©pendances, afin que vous puissiez ĂȘtre certain dâexĂ©cuter votre projet en production exactement comme sur votre ordinateur pendant le dĂ©veloppement, cela sâappelle le locking
+* **Installer Python** pour vous, y compris différentes versions
+* GĂ©rer lâ**environnement virtuel** pour vos projets
+* Installer des **packages**
+* Gérer les **dépendances et versions** de packages pour votre projet
+* Vous assurer dâavoir un ensemble **exact** de packages et de versions Ă installer, y compris leurs dĂ©pendances, afin que vous puissiez ĂȘtre certain dâexĂ©cuter votre projet en production exactement comme sur votre ordinateur pendant le dĂ©veloppement, cela sâappelle le **locking**
* Et bien dâautres choses
## Conclusion { #conclusion }
-Si vous avez lu et compris tout cela, vous en savez maintenant bien plus sur les environnements virtuels que beaucoup de dĂ©veloppeurs. đ€
+Si vous avez lu et compris tout cela, vous en savez maintenant **bien plus** sur les environnements virtuels que beaucoup de dĂ©veloppeurs. đ€
-ConnaĂźtre ces dĂ©tails vous sera trĂšs probablement utile Ă lâavenir lorsque vous dĂ©boguerez quelque chose qui semble complexe, mais vous saurez comment tout fonctionne en dessous. đ
+ConnaĂźtre ces dĂ©tails vous sera trĂšs probablement utile Ă lâavenir lorsque vous dĂ©boguerez quelque chose qui semble complexe, mais vous saurez **comment tout fonctionne en dessous**. đ
projects / thirdparty / fastapi / fastapi.git / commitdiff
