From 1ae5466140082e7cbcd89dd26164f2fe7a97339b Mon Sep 17 00:00:00 2001
From: Cedric Fraboulet <62244267+frabc@users.noreply.github.com>
Date: Thu, 13 Apr 2023 19:59:44 +0200
Subject: [PATCH] =?UTF-8?q?=F0=9F=8C=90=20Add=20French=20translation=20for?=
=?UTF-8?q?=20`docs/fr/docs/index.md`=20(#9265)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
* docs(index): copy the new index.md from docs/en
* docs(index): add translation for docs/index.md
* Apply rjNemo's suggestions
* Apply Viicos's suggestions
---
docs/fr/docs/index.md | 343 +++++++++++++++++++++---------------------
1 file changed, 173 insertions(+), 170 deletions(-)
diff --git a/docs/fr/docs/index.md b/docs/fr/docs/index.md
index e7fb9947d..5ee8b462f 100644
--- a/docs/fr/docs/index.md
+++ b/docs/fr/docs/index.md
@@ -1,48 +1,46 @@
-
-{!../../../docs/missing-translation.md!}
-
-
- FastAPI framework, high performance, easy to learn, fast to code, ready for production
+ Framework FastAPI, haute performance, facile à apprendre, rapide à coder, prêt pour la production
-
- 
+
+ 
-
- 
+
+ 
+
+ 
+
---
-**Documentation**: https://fastapi.tiangolo.com
+**Documentation** : https://fastapi.tiangolo.com
-**Source Code**: https://github.com/tiangolo/fastapi
+**Code Source** : https://github.com/tiangolo/fastapi
---
-FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.
+FastAPI est un framework web moderne et rapide (haute performance) pour la création d'API avec Python 3.7+, basé sur les annotations de type standard de Python.
-The key features are:
+Les principales fonctionnalités sont :
-* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
+* **Rapidité** : De très hautes performances, au niveau de **NodeJS** et **Go** (grâce à Starlette et Pydantic). [L'un des frameworks Python les plus rapides](#performance).
+* **Rapide à coder** : Augmente la vitesse de développement des fonctionnalités d'environ 200 % à 300 %. *
+* **Moins de bugs** : Réduit d'environ 40 % les erreurs induites par le développeur. *
+* **Intuitif** : Excellente compatibilité avec les IDE. Complétion complète. Moins de temps passé à déboguer.
+* **Facile** : Conçu pour être facile à utiliser et à apprendre. Moins de temps passé à lire la documentation.
+* **Concis** : Diminue la duplication de code. De nombreuses fonctionnalités liées à la déclaration de chaque paramètre. Moins de bugs.
+* **Robuste** : Obtenez un code prêt pour la production. Avec une documentation interactive automatique.
+* **Basé sur des normes** : Basé sur (et entièrement compatible avec) les standards ouverts pour les APIs : OpenAPI (précédemment connu sous le nom de Swagger) et JSON Schema.
-* **Fast to code**: Increase the speed to develop features by about 200% to 300%. *
-* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *
-* **Intuitive**: Great editor support. Completion everywhere. Less time debugging.
-* **Easy**: Designed to be easy to use and learn. Less time reading docs.
-* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
-* **Robust**: Get production-ready code. With automatic interactive documentation.
-* **Standards-based**: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema.
-
-* estimation based on tests on an internal development team, building production applications.
+* estimation basée sur des tests d'une équipe de développement interne, construisant des applications de production.
## Sponsors
@@ -63,60 +61,66 @@ The key features are:
## Opinions
-"_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._"
+"_[...] J'utilise beaucoup **FastAPI** ces derniers temps. [...] Je prévois de l'utiliser dans mon équipe pour tous les **services de ML chez Microsoft**. Certains d'entre eux seront intégrés dans le coeur de **Windows** et dans certains produits **Office**._"
Kabir Khan -
Microsoft (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Piero Molino, Yaroslav Dudin et Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Deon Pillsbury -
Cisco (ref)
-If you are building a CLI app to be used in the terminal instead of a web API, check out **Typer**.
+Si vous souhaitez construire une application CLI utilisable dans un terminal au lieu d'une API web, regardez **Typer**.
-**Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀
+**Typer** est le petit frère de FastAPI. Et il est destiné à être le **FastAPI des CLI**. ⌨️ 🚀
-## Requirements
+## Prérequis
Python 3.7+
-FastAPI stands on the shoulders of giants:
+FastAPI repose sur les épaules de géants :
-* Starlette for the web parts.
-* Pydantic for the data parts.
+* Starlette pour les parties web.
+* Pydantic pour les parties données.
## Installation
@@ -130,7 +134,7 @@ $ pip install fastapi
-You will also need an ASGI server, for production such as Uvicorn or Hypercorn.
+Vous aurez également besoin d'un serveur ASGI pour la production tel que Uvicorn ou Hypercorn.
@@ -142,11 +146,11 @@ $ pip install "uvicorn[standard]"
-## Example
+## Exemple
-### Create it
+### Créez
-* Create a file `main.py` with:
+* Créez un fichier `main.py` avec :
```Python
from typing import Union
@@ -167,11 +171,11 @@ def read_item(item_id: int, q: Union[str, None] = None):
```
-Or use async def...
+Ou utilisez async def ...
-If your code uses `async` / `await`, use `async def`:
+Si votre code utilise `async` / `await`, utilisez `async def` :
-```Python hl_lines="9 14"
+```Python hl_lines="9 14"
from typing import Union
from fastapi import FastAPI
@@ -189,15 +193,15 @@ async def read_item(item_id: int, q: Union[str, None] = None):
return {"item_id": item_id, "q": q}
```
-**Note**:
+**Note**
-If you don't know, check the _"In a hurry?"_ section about `async` and `await` in the docs.
+Si vous n'êtes pas familier avec cette notion, consultez la section _"Vous êtes pressés ?"_ à propos de `async` et `await` dans la documentation.
-### Run it
+### Lancez
-Run the server with:
+Lancez le serveur avec :
@@ -214,56 +218,56 @@ INFO: Application startup complete.
-About the command uvicorn main:app --reload...
+À propos de la commande uvicorn main:app --reload ...
-The command `uvicorn main:app` refers to:
+La commande `uvicorn main:app` fait référence à :
-* `main`: the file `main.py` (the Python "module").
-* `app`: the object created inside of `main.py` with the line `app = FastAPI()`.
-* `--reload`: make the server restart after code changes. Only do this for development.
+* `main` : le fichier `main.py` (le "module" Python).
+* `app` : l'objet créé à l'intérieur de `main.py` avec la ligne `app = FastAPI()`.
+* `--reload` : fait redémarrer le serveur après des changements de code. À n'utiliser que pour le développement.
-### Check it
+### Vérifiez
-Open your browser at http://127.0.0.1:8000/items/5?q=somequery.
+Ouvrez votre navigateur à l'adresse http://127.0.0.1:8000/items/5?q=somequery.
-You will see the JSON response as:
+Vous obtenez alors cette réponse JSON :
```JSON
{"item_id": 5, "q": "somequery"}
```
-You already created an API that:
+Vous venez de créer une API qui :
-* Receives HTTP requests in the _paths_ `/` and `/items/{item_id}`.
-* Both _paths_ take `GET` operations (also known as HTTP _methods_).
-* The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.
-* The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.
+* Reçoit les requêtes HTTP pour les _chemins_ `/` et `/items/{item_id}`.
+* Les deux _chemins_ acceptent des opérations `GET` (également connu sous le nom de _méthodes_ HTTP).
+* Le _chemin_ `/items/{item_id}` a un _paramètre_ `item_id` qui doit être un `int`.
+* Le _chemin_ `/items/{item_id}` a un _paramètre de requête_ optionnel `q` de type `str`.
-### Interactive API docs
+### Documentation API interactive
-Now go to http://127.0.0.1:8000/docs.
+Maintenant, rendez-vous sur http://127.0.0.1:8000/docs.
-You will see the automatic interactive API documentation (provided by Swagger UI):
+Vous verrez la documentation interactive automatique de l'API (fournie par Swagger UI) :
-### Alternative API docs
+### Documentation API alternative
-And now, go to http://127.0.0.1:8000/redoc.
+Et maintenant, rendez-vous sur http://127.0.0.1:8000/redoc.
-You will see the alternative automatic documentation (provided by ReDoc):
+Vous verrez la documentation interactive automatique de l'API (fournie par ReDoc) :
-## Example upgrade
+## Exemple plus poussé
-Now modify the file `main.py` to receive a body from a `PUT` request.
+Maintenant, modifiez le fichier `main.py` pour recevoir le corps d'une requête `PUT`.
-Declare the body using standard Python types, thanks to Pydantic.
+Déclarez ce corps en utilisant les types Python standards, grâce à Pydantic.
-```Python hl_lines="4 9 10 11 12 25 26 27"
+```Python hl_lines="4 9-12 25-27"
from typing import Union
from fastapi import FastAPI
@@ -293,174 +297,173 @@ def update_item(item_id: int, item: Item):
return {"item_name": item.name, "item_id": item_id}
```
-The server should reload automatically (because you added `--reload` to the `uvicorn` command above).
+Le serveur se recharge normalement automatiquement (car vous avez pensé à `--reload` dans la commande `uvicorn` ci-dessus).
-### Interactive API docs upgrade
+### Plus loin avec la documentation API interactive
-Now go to http://127.0.0.1:8000/docs.
+Maintenant, rendez-vous sur http://127.0.0.1:8000/docs.
-* The interactive API documentation will be automatically updated, including the new body:
+* La documentation interactive de l'API sera automatiquement mise à jour, y compris le nouveau corps de la requête :
-* Click on the button "Try it out", it allows you to fill the parameters and directly interact with the API:
+* Cliquez sur le bouton "Try it out", il vous permet de renseigner les paramètres et d'interagir directement avec l'API :
-* Then click on the "Execute" button, the user interface will communicate with your API, send the parameters, get the results and show them on the screen:
+* Cliquez ensuite sur le bouton "Execute", l'interface utilisateur communiquera avec votre API, enverra les paramètres, obtiendra les résultats et les affichera à l'écran :
-### Alternative API docs upgrade
+### Plus loin avec la documentation API alternative
-And now, go to http://127.0.0.1:8000/redoc.
+Et maintenant, rendez-vous sur http://127.0.0.1:8000/redoc.
-* The alternative documentation will also reflect the new query parameter and body:
+* La documentation alternative reflétera également le nouveau paramètre de requête et le nouveau corps :
-### Recap
+### En résumé
-In summary, you declare **once** the types of parameters, body, etc. as function parameters.
+En résumé, vous déclarez **une fois** les types de paramètres, le corps de la requête, etc. en tant que paramètres de fonction.
-You do that with standard modern Python types.
+Vous faites cela avec les types Python standard modernes.
-You don't have to learn a new syntax, the methods or classes of a specific library, etc.
+Vous n'avez pas à apprendre une nouvelle syntaxe, les méthodes ou les classes d'une bibliothèque spécifique, etc.
-Just standard **Python 3.6+**.
+Juste du **Python 3.7+** standard.
-For example, for an `int`:
+Par exemple, pour un `int`:
```Python
item_id: int
```
-or for a more complex `Item` model:
+ou pour un modèle `Item` plus complexe :
```Python
item: Item
```
-...and with that single declaration you get:
-
-* Editor support, including:
- * Completion.
- * Type checks.
-* Validation of data:
- * Automatic and clear errors when the data is invalid.
- * Validation even for deeply nested JSON objects.
-* Conversion of input data: coming from the network to Python data and types. Reading from:
- * JSON.
- * Path parameters.
- * Query parameters.
- * Cookies.
- * Headers.
- * Forms.
- * Files.
-* Conversion of output data: converting from Python data and types to network data (as JSON):
- * Convert Python types (`str`, `int`, `float`, `bool`, `list`, etc).
- * `datetime` objects.
- * `UUID` objects.
- * Database models.
- * ...and many more.
-* Automatic interactive API documentation, including 2 alternative user interfaces:
+... et avec cette déclaration unique, vous obtenez :
+
+* Une assistance dans votre IDE, notamment :
+ * la complétion.
+ * la vérification des types.
+* La validation des données :
+ * des erreurs automatiques et claires lorsque les données ne sont pas valides.
+ * une validation même pour les objets JSON profondément imbriqués.
+* Une conversion des données d'entrée : venant du réseau et allant vers les données et types de Python, permettant de lire :
+ * le JSON.
+ * les paramètres du chemin.
+ * les paramètres de la requête.
+ * les cookies.
+ * les en-têtes.
+ * les formulaires.
+ * les fichiers.
+* La conversion des données de sortie : conversion des données et types Python en données réseau (au format JSON), permettant de convertir :
+ * les types Python (`str`, `int`, `float`, `bool`, `list`, etc).
+ * les objets `datetime`.
+ * les objets `UUID`.
+ * les modèles de base de données.
+ * ... et beaucoup plus.
+* La documentation API interactive automatique, avec 2 interfaces utilisateur au choix :
* Swagger UI.
* ReDoc.
---
-Coming back to the previous code example, **FastAPI** will:
-
-* Validate that there is an `item_id` in the path for `GET` and `PUT` requests.
-* Validate that the `item_id` is of type `int` for `GET` and `PUT` requests.
- * If it is not, the client will see a useful, clear error.
-* Check if there is an optional query parameter named `q` (as in `http://127.0.0.1:8000/items/foo?q=somequery`) for `GET` requests.
- * As the `q` parameter is declared with `= None`, it is optional.
- * Without the `None` it would be required (as is the body in the case with `PUT`).
-* For `PUT` requests to `/items/{item_id}`, Read the body as JSON:
- * Check that it has a required attribute `name` that should be a `str`.
- * Check that it has a required attribute `price` that has to be a `float`.
- * Check that it has an optional attribute `is_offer`, that should be a `bool`, if present.
- * All this would also work for deeply nested JSON objects.
-* Convert from and to JSON automatically.
-* Document everything with OpenAPI, that can be used by:
- * Interactive documentation systems.
- * Automatic client code generation systems, for many languages.
-* Provide 2 interactive documentation web interfaces directly.
+Pour revenir à l'exemple de code précédent, **FastAPI** permet de :
+
+* Valider que `item_id` existe dans le chemin des requêtes `GET` et `PUT`.
+* Valider que `item_id` est de type `int` pour les requêtes `GET` et `PUT`.
+ * Si ce n'est pas le cas, le client voit une erreur utile et claire.
+* Vérifier qu'il existe un paramètre de requête facultatif nommé `q` (comme dans `http://127.0.0.1:8000/items/foo?q=somequery`) pour les requêtes `GET`.
+ * Puisque le paramètre `q` est déclaré avec `= None`, il est facultatif.
+ * Sans le `None`, il serait nécessaire (comme l'est le corps de la requête dans le cas du `PUT`).
+* Pour les requêtes `PUT` vers `/items/{item_id}`, de lire le corps en JSON :
+ * Vérifier qu'il a un attribut obligatoire `name` qui devrait être un `str`.
+ * Vérifier qu'il a un attribut obligatoire `prix` qui doit être un `float`.
+ * Vérifier qu'il a un attribut facultatif `is_offer`, qui devrait être un `bool`, s'il est présent.
+ * Tout cela fonctionnerait également pour les objets JSON profondément imbriqués.
+* Convertir de et vers JSON automatiquement.
+* Documenter tout avec OpenAPI, qui peut être utilisé par :
+ * Les systèmes de documentation interactifs.
+ * Les systèmes de génération automatique de code client, pour de nombreuses langues.
+* Fournir directement 2 interfaces web de documentation interactive.
---
-We just scratched the surface, but you already get the idea of how it all works.
+Nous n'avons fait qu'effleurer la surface, mais vous avez déjà une idée de la façon dont tout cela fonctionne.
-Try changing the line with:
+Essayez de changer la ligne contenant :
```Python
return {"item_name": item.name, "item_id": item_id}
```
-...from:
+... de :
```Python
... "item_name": item.name ...
```
-...to:
+... vers :
```Python
... "item_price": item.price ...
```
-...and see how your editor will auto-complete the attributes and know their types:
+... et voyez comment votre éditeur complétera automatiquement les attributs et connaîtra leurs types :
-
+
-For a more complete example including more features, see the Tutorial - User Guide.
+Pour un exemple plus complet comprenant plus de fonctionnalités, voir le Tutoriel - Guide utilisateur.
-**Spoiler alert**: the tutorial - user guide includes:
+**Spoiler alert** : le tutoriel - guide utilisateur inclut :
-* Declaration of **parameters** from other different places as: **headers**, **cookies**, **form fields** and **files**.
-* How to set **validation constraints** as `maximum_length` or `regex`.
-* A very powerful and easy to use **Dependency Injection** system.
-* Security and authentication, including support for **OAuth2** with **JWT tokens** and **HTTP Basic** auth.
-* More advanced (but equally easy) techniques for declaring **deeply nested JSON models** (thanks to Pydantic).
-* Many extra features (thanks to Starlette) as:
+* Déclaration de **paramètres** provenant d'autres endroits différents comme : **en-têtes.**, **cookies**, **champs de formulaire** et **fichiers**.
+* L'utilisation de **contraintes de validation** comme `maximum_length` ou `regex`.
+* Un **systéme d'injection de dépendance ** très puissant et facile à utiliser .
+* Sécurité et authentification, y compris la prise en charge de **OAuth2** avec les **jetons JWT** et l'authentification **HTTP Basic**.
+* Des techniques plus avancées (mais tout aussi faciles) pour déclarer les **modèles JSON profondément imbriqués** (grâce à Pydantic).
+* Intégration de **GraphQL** avec Strawberry et d'autres bibliothèques.
+* D'obtenir de nombreuses fonctionnalités supplémentaires (grâce à Starlette) comme :
* **WebSockets**
- * **GraphQL**
- * extremely easy tests based on HTTPX and `pytest`
- * **CORS**
+ * de tester le code très facilement avec `requests` et `pytest`
+ * **CORS**
* **Cookie Sessions**
- * ...and more.
+ * ... et plus encore.
## Performance
-Independent TechEmpower benchmarks show **FastAPI** applications running under Uvicorn as one of the fastest Python frameworks available, only below Starlette and Uvicorn themselves (used internally by FastAPI). (*)
+Les benchmarks TechEmpower indépendants montrent que les applications **FastAPI** s'exécutant sous Uvicorn sont parmi les frameworks existants en Python les plus rapides , juste derrière Starlette et Uvicorn (utilisés en interne par FastAPI). (*)
-To understand more about it, see the section Benchmarks.
+Pour en savoir plus, consultez la section Benchmarks.
-## Optional Dependencies
+## Dépendances facultatives
-Used by Pydantic:
+Utilisées par Pydantic:
-* ujson - for faster JSON "parsing".
-* email_validator - for email validation.
+* ujson - pour un "décodage" JSON plus rapide.
+* email_validator - pour la validation des adresses email.
-Used by Starlette:
+Utilisées par Starlette :
-* HTTPX - Required if you want to use the `TestClient`.
-* jinja2 - Required if you want to use the default template configuration.
-* python-multipart - Required if you want to support form "parsing", with `request.form()`.
-* itsdangerous - Required for `SessionMiddleware` support.
-* pyyaml - Required for Starlette's `SchemaGenerator` support (you probably don't need it with FastAPI).
-* graphene - Required for `GraphQLApp` support.
-* ujson - Required if you want to use `UJSONResponse`.
+* requests - Obligatoire si vous souhaitez utiliser `TestClient`.
+* jinja2 - Obligatoire si vous souhaitez utiliser la configuration de template par defaut.
+* python-multipart - Obligatoire si vous souhaitez supporter le "décodage" de formulaire avec `request.form()`.
+* itsdangerous - Obligatoire pour la prise en charge de `SessionMiddleware`.
+* pyyaml - Obligatoire pour le support `SchemaGenerator` de Starlette (vous n'en avez probablement pas besoin avec FastAPI).
+* ujson - Obligatoire si vous souhaitez utiliser `UJSONResponse`.
-Used by FastAPI / Starlette:
+Utilisées par FastAPI / Starlette :
-* uvicorn - for the server that loads and serves your application.
-* orjson - Required if you want to use `ORJSONResponse`.
+* uvicorn - Pour le serveur qui charge et sert votre application.
+* orjson - Obligatoire si vous voulez utiliser `ORJSONResponse`.
-You can install all of these with `pip install fastapi[all]`.
+Vous pouvez tout installer avec `pip install fastapi[all]`.
-## License
+## Licence
-This project is licensed under the terms of the MIT license.
+Ce projet est soumis aux termes de la licence MIT.