🌐 Update translations for fr (add-missing)

github-actions[bot] · YuriiMotov · commit c9545a69edcc · 2026-03-19T14:17:55.000+01:00
diff --git a/docs/fr/docs/advanced/json-base64-bytes.md b/docs/fr/docs/advanced/json-base64-bytes.md
@@ -0,0 +1,63 @@
+# JSON avec des octets en Base64 { #json-with-bytes-as-base64 }
+
+Si votre application doit recevoir et envoyer des données JSON, mais que vous devez y inclure des données binaires, vous pouvez les encoder en base64.
+
+## 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.
+
+JSON ne peut contenir que des chaînes encodées en UTF-8, il ne peut donc pas contenir d'octets bruts.
+
+Base64 peut encoder des données binaires en chaînes, mais pour cela il doit utiliser plus de caractères que les données binaires originales ; c'est donc en général moins efficace que des fichiers classiques.
+
+N'utilisez base64 que si vous devez absolument inclure des données binaires dans du JSON et que vous ne pouvez pas utiliser des fichiers pour cela.
+
+## 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.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
+
+Si vous allez sur les `/docs`, vous verrez que le champ `data` attend des octets encodés en base64 :
+
+<div class="screenshot">
+<img src="/img/tutorial/json-base64-bytes/image01.png">
+</div>
+
+Vous pourriez envoyer une requête comme :
+
+```json
+{
+    "description": "Some data",
+    "data": "aGVsbG8="
+}
+```
+
+/// tip | Astuce
+
+`aGVsbG8=` est l'encodage base64 de `hello`.
+
+///
+
+Pydantic décodera ensuite la chaîne base64 et vous fournira les octets originaux dans le champ `data` du modèle.
+
+Vous recevrez une réponse comme :
+
+```json
+{
+  "description": "Some data",
+  "content": "hello"
+}
+```
+
+## 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.
+
+{* ../../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.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,19:26,29,44:46] hl[23:26] *}
diff --git a/docs/fr/docs/advanced/stream-data.md b/docs/fr/docs/advanced/stream-data.md
@@ -0,0 +1,117 @@
+# Diffuser des données { #stream-data }
+
+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.
+
+/// info
+
+Ajouté dans FastAPI 0.134.0.
+
+///
+
+## Cas d'utilisation { #use-cases }
+
+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 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.
+
+## Utiliser une `StreamingResponse` avec `yield` { #a-streamingresponse-with-yield }
+
+Si vous déclarez un `response_class=StreamingResponse` dans votre *fonction de chemin d'accès*, vous pouvez utiliser `yield` pour envoyer chaque bloc de données à son tour.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[1:23] hl[20,23] *}
+
+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 }
+
+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[26:29] hl[27] *}
+
+### Sans annotation { #no-annotation }
+
+Vous n'avez pas vraiment besoin de déclarer l'annotation de type de retour pour diffuser des données binaires.
+
+Comme FastAPI n'essaiera pas de convertir les données en JSON avec Pydantic ni de les sérialiser, dans ce cas l'annotation de type ne sert qu'à votre éditeur et à vos outils ; elle ne sera pas utilisée par FastAPI.
+
+{* ../../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. 🤓
+
+### Diffuser des bytes { #stream-bytes }
+
+L'un des principaux cas d'usage consiste à diffuser des `bytes` au lieu de chaînes ; vous pouvez bien sûr le faire.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[44:47] hl[47] *}
+
+## Créer une `PNGStreamingResponse` personnalisée { #a-custom-pngstreamingresponse }
+
+Dans les exemples ci-dessus, les octets de données étaient diffusés, mais la réponse n'avait pas d'en-tête `Content-Type`, le client ne savait donc pas quel type de données il recevait.
+
+Vous pouvez créer une sous-classe personnalisée de `StreamingResponse` qui définit l'en-tête `Content-Type` sur le type de données que vous diffusez.
+
+Par exemple, vous pouvez créer une `PNGStreamingResponse` qui définit l'en-tête `Content-Type` à `image/png` en utilisant l'attribut `media_type` :
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[6,19:20] hl[20] *}
+
+Vous pouvez ensuite utiliser cette nouvelle classe dans `response_class=PNGStreamingResponse` dans votre *fonction de chemin d'accès* :
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[23:27] hl[23] *}
+
+### Simuler un fichier { #simulate-a-file }
+
+Dans cet exemple, nous simulons un fichier avec `io.BytesIO`, qui est un objet de type fichier résidant uniquement en mémoire, mais qui permet d'utiliser la même interface.
+
+Par exemple, nous pouvons itérer dessus pour en consommer le contenu, comme nous le ferions avec un fichier.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[1:27] hl[3,12:13,25] *}
+
+/// note | Détails techniques
+
+Les deux autres variables, `image_base64` et `binary_image`, correspondent à une image encodée en Base64, puis convertie en bytes, afin de la passer à `io.BytesIO`.
+
+C'est uniquement pour que tout tienne dans le même fichier pour cet exemple, et que vous puissiez le copier et l'exécuter tel quel. 🥚
+
+///
+
+En utilisant un bloc `with`, nous nous assurons que l'objet de type fichier est fermé après l'exécution de la fonction génératrice (la fonction avec `yield`). Donc, après la fin de l'envoi de la réponse.
+
+Ce ne serait pas si important dans cet exemple précis, car il s'agit d'un faux fichier en mémoire (avec `io.BytesIO`), mais avec un vrai fichier, il est important de s'assurer qu'il est fermé une fois le travail terminé.
+
+### Gérer les fichiers et async { #files-and-async }
+
+Dans la plupart des cas, les objets de type fichier ne sont pas compatibles avec `async` et `await` par défaut.
+
+Par exemple, ils n'ont pas de `await file.read()`, ni de `async for chunk in file`.
+
+Et dans de nombreux cas, leur lecture serait une opération bloquante (pouvant bloquer la boucle d'événements), car ils sont lus depuis le disque ou le réseau.
+
+/// info
+
+L'exemple ci-dessus est en réalité une exception, car l'objet `io.BytesIO` est déjà en mémoire ; sa lecture ne bloquera donc rien.
+
+Mais dans de nombreux cas, la lecture d'un fichier ou d'un objet de type fichier bloquera.
+
+///
+
+Pour éviter de bloquer la boucle d'événements, vous pouvez simplement déclarer la *fonction de chemin d'accès* avec un `def` classique au lieu de `async def`. Ainsi, FastAPI l'exécutera dans un worker de pool de threads, afin d'éviter de bloquer la boucle principale.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}
+
+/// tip | Astuce
+
+Si vous devez appeler du code bloquant depuis une fonction async, ou une fonction async depuis une fonction bloquante, vous pouvez utiliser [Asyncer](https://asyncer.tiangolo.com), une bibliothèque sœur de FastAPI.
+
+///
+
+### `yield from` { #yield-from }
+
+Lorsque vous itérez sur quelque chose, comme un objet de type fichier, et que vous faites un `yield` pour chaque élément, vous pouvez aussi utiliser `yield from` pour émettre chaque élément directement et éviter la boucle `for`.
+
+Ce n'est pas spécifique à FastAPI, c'est simplement Python, mais c'est une astuce utile à connaître. 😎
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[37:40] hl[40] *}
diff --git a/docs/fr/docs/advanced/strict-content-type.md b/docs/fr/docs/advanced/strict-content-type.md
@@ -0,0 +1,88 @@
+# Vérifier strictement le Content-Type { #strict-content-type-checking }
+
+Par défaut, FastAPI applique une vérification stricte de l’en-tête `Content-Type` pour les corps de requêtes JSON ; cela signifie que les requêtes JSON doivent inclure un en-tête `Content-Type` valide (par ex. `application/json`) pour que le corps soit analysé comme JSON.
+
+## Risque CSRF { #csrf-risk }
+
+Ce comportement par défaut offre une protection contre une catégorie d’attaques de Cross-Site Request Forgery (CSRF) dans un scénario très spécifique.
+
+Ces attaques exploitent le fait que les navigateurs permettent à des scripts d’envoyer des requêtes sans effectuer de pré-vérification CORS (preflight) lorsqu’ils :
+
+* n’ont pas d’en-tête `Content-Type` (par ex. en utilisant `fetch()` avec un corps `Blob`)
+* et n’envoient aucune information d’authentification.
+
+Ce type d’attaque est surtout pertinent lorsque :
+
+* l’application s’exécute localement (par ex. sur `localhost`) ou sur un réseau interne
+* et l’application n’a aucun mécanisme d’authentification, elle part du principe que toute requête provenant du même réseau est fiable.
+
+## Exemple d’attaque { #example-attack }
+
+Imaginez que vous mettiez au point un moyen d’exécuter un agent IA local.
+
+Il expose une API à l’adresse
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Il y a aussi un frontend à l’adresse
+
+```
+http://localhost:8000
+```
+
+/// tip | Astuce
+
+Notez qu’ils ont le même hôte.
+
+///
+
+Vous pouvez alors, via le frontend, amener l’agent IA à effectuer des actions en votre nom.
+
+Comme il s’exécute localement, et non sur l’Internet ouvert, vous décidez de ne mettre en place aucun mécanisme d’authentification, en vous fiant simplement à l’accès au réseau local.
+
+Un de vos utilisateurs pourrait alors l’installer et l’exécuter localement.
+
+Il pourrait ensuite ouvrir un site malveillant, par exemple quelque chose comme
+
+```
+https://evilhackers.example.com
+```
+
+Et ce site malveillant enverrait des requêtes en utilisant `fetch()` avec un corps `Blob` vers l’API locale à l’adresse
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Même si l’hôte du site malveillant et celui de l’application locale sont différents, le navigateur ne déclenchera pas de pré-vérification CORS (preflight) parce que :
+
+* Elle s’exécute sans aucune authentification, il n’y a pas à envoyer d’informations d’authentification.
+* Le navigateur pense qu’il n’envoie pas de JSON (faute d’en-tête `Content-Type`).
+
+Le site malveillant pourrait alors amener l’agent IA local à envoyer des messages en colère à l’ancien patron de l’utilisateur ... ou pire. 😅
+
+## Internet ouvert { #open-internet }
+
+Si votre application est exposée sur l’Internet ouvert, vous ne « ferez pas confiance au réseau » et ne laisserez pas n’importe qui envoyer des requêtes privilégiées sans authentification.
+
+Des attaquants pourraient simplement exécuter un script pour envoyer des requêtes à votre API, sans interaction avec le navigateur ; vous sécurisez donc probablement déjà tout endpoint privilégié.
+
+Dans ce cas, cette attaque / ce risque ne vous concerne pas.
+
+Ce risque et cette attaque sont surtout pertinents lorsque l’application s’exécute sur le réseau local et que c’est la seule protection supposée.
+
+## Autoriser les requêtes sans Content-Type { #allowing-requests-without-content-type }
+
+Si vous devez prendre en charge des clients qui n’envoient pas d’en-tête `Content-Type`, vous pouvez désactiver la vérification stricte en définissant `strict_content_type=False` :
+
+{* ../../docs_src/strict_content_type/tutorial001_py310.py hl[4] *}
+
+Avec ce paramètre, les requêtes sans en-tête `Content-Type` verront leur corps analysé comme JSON, ce qui correspond au comportement des anciennes versions de FastAPI.
+
+/// info
+
+Ce comportement et cette configuration ont été ajoutés dans FastAPI 0.132.0.
+
+///
diff --git a/docs/fr/docs/editor-support.md b/docs/fr/docs/editor-support.md
@@ -0,0 +1,23 @@
+# 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.
+
+Pour plus de détails sur l’extension, reportez-vous au README sur le [référentiel GitHub](https://github.com/fastapi/fastapi-vscode).
+
+## Configurer et installer { #setup-and-installation }
+
+L’**Extension FastAPI** est disponible pour [VS Code](https://code.visualstudio.com/) et [Cursor](https://www.cursor.com/). Vous pouvez l’installer directement depuis le panneau Extensions de chaque éditeur en recherchant « FastAPI » et en sélectionnant l’extension publiée par **FastAPI Labs**. L’extension fonctionne également dans les éditeurs basés sur le navigateur tels que [vscode.dev](https://vscode.dev) et [github.dev](https://github.dev).
+
+### Découvrir l’application { #application-discovery }
+
+Par défaut, l’extension détecte automatiquement les applications FastAPI dans votre espace de travail en recherchant les fichiers qui instancient `FastAPI()`. Si la détection automatique ne convient pas à la structure de votre projet, vous pouvez spécifier un point d’entrée via `[tool.fastapi]` dans `pyproject.toml` ou le paramètre VS Code `fastapi.entryPoint`, en utilisant la notation de module (par ex. `myapp.main:app`).
+
+## Fonctionnalités { #features }
+
+- **Explorateur des chemins d'accès** — Une vue arborescente latérale de tous les <dfn title="routes, endpoints">*chemins d'accès*</dfn> de votre application. Cliquez pour accéder à n’importe quelle définition de route ou de routeur.
+- **Recherche de routes** — Recherchez par chemin, méthode ou nom avec <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>E</kbd> (sur macOS : <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>E</kbd>).
+- **Navigation CodeLens** — Liens cliquables au-dessus des appels du client de test (par ex. `client.get('/items')`) menant au *chemin d'accès* correspondant, pour naviguer rapidement entre les tests et l’implémentation.
+- **Déployer sur FastAPI Cloud** — Déploiement en un clic de votre application sur [FastAPI Cloud](https://fastapicloud.com/).
+- **Diffuser les journaux de l’application** — Diffusion en temps réel des journaux de votre application déployée sur FastAPI Cloud, avec filtrage par niveau et recherche textuelle.
+
+Si vous souhaitez vous familiariser avec les fonctionnalités de l’extension, vous pouvez consulter le guide pas à pas de l’extension en ouvrant la palette de commandes (<kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> ou sur macOS : <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd>) et en sélectionnant « Welcome: Open walkthrough ... » puis en choisissant le guide « Get started with FastAPI ».
diff --git a/docs/fr/docs/tutorial/server-sent-events.md b/docs/fr/docs/tutorial/server-sent-events.md
diff --git a/docs/fr/docs/tutorial/stream-json-lines.md b/docs/fr/docs/tutorial/stream-json-lines.md
