🌐 Update translations for fr (add-missing) (#15163)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

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] *}

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] *}

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.
+
+///

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 ».

docs/fr/docs/tutorial/server-sent-events.md

@@ -0,0 +1,120 @@
+# Événements envoyés par le serveur (SSE) { #server-sent-events-sse }
+
+Vous pouvez diffuser des données vers le client en utilisant les **Server-Sent Events** (SSE).
+
+C'est similaire à [Diffuser des JSON Lines](stream-json-lines.md), mais cela utilise le format `text/event-stream`, pris en charge nativement par les navigateurs via l’API [`EventSource`](https://developer.mozilla.org/en-US/docs/Web/API/EventSource).
+
+/// info | Info
+
+Ajouté dans FastAPI 0.135.0.
+
+///
+
+## Que sont les Server-Sent Events ? { #what-are-server-sent-events }
+
+SSE est un standard pour diffuser des données du serveur au client via HTTP.
+
+Chaque événement est un petit bloc de texte avec des « champs » comme `data`, `event`, `id` et `retry`, séparés par des lignes vides.
+
+Cela ressemble à ceci :
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+Les SSE sont couramment utilisés pour le streaming de chat IA, les notifications en direct, les journaux et l’observabilité, et d’autres cas où le serveur envoie des mises à jour au client.
+
+/// tip | Astuce
+
+Si vous souhaitez diffuser des données binaires, par exemple de la vidéo ou de l’audio, consultez le guide avancé : [Diffuser des données](../advanced/stream-data.md).
+
+///
+
+## Diffuser des SSE avec FastAPI { #stream-sse-with-fastapi }
+
+Pour diffuser des SSE avec FastAPI, utilisez `yield` dans votre *fonction de chemin d'accès* et définissez `response_class=EventSourceResponse`.
+
+Importez `EventSourceResponse` depuis `fastapi.sse` :
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+Chaque élément produit avec `yield` est encodé en JSON et envoyé dans le champ `data:` d’un événement SSE.
+
+Si vous déclarez le type de retour comme `AsyncIterable[Item]`, FastAPI l’utilisera pour **valider**, **documenter** et **sérialiser** les données avec Pydantic.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[10:12,23] *}
+
+/// tip | Astuce
+
+Comme Pydantic le sérialisera du côté **Rust**, vous obtiendrez une **performance** bien supérieure que si vous ne déclarez pas de type de retour.
+
+///
+
+### Fonctions de chemin d'accès non async { #non-async-path-operation-functions }
+
+Vous pouvez aussi utiliser des fonctions `def` normales (sans `async`), et utiliser `yield` de la même façon.
+
+FastAPI s’assure qu’elles s’exécutent correctement pour ne pas bloquer la boucle d’événements.
+
+Dans ce cas la fonction n’est pas async, le type de retour approprié serait `Iterable[Item]` :
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[28:31] hl[29] *}
+
+### Sans type de retour { #no-return-type }
+
+Vous pouvez aussi omettre le type de retour. FastAPI utilisera le [`jsonable_encoder`](./encoder.md) pour convertir les données et les envoyer.
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+Si vous devez définir des champs SSE comme `event`, `id`, `retry` ou `comment`, vous pouvez produire des objets `ServerSentEvent` au lieu de données brutes.
+
+Importez `ServerSentEvent` depuis `fastapi.sse` :
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+Le champ `data` est toujours encodé en JSON. Vous pouvez passer toute valeur sérialisable en JSON, y compris des modèles Pydantic.
+
+## Données brutes { #raw-data }
+
+Si vous devez envoyer des données **sans** encodage JSON, utilisez `raw_data` au lieu de `data`.
+
+C’est utile pour envoyer du texte préformaté, des lignes de log, ou des valeurs <dfn title="Une valeur utilisée pour indiquer une condition ou un état particulier">« sentinelle »</dfn> spéciales comme `[DONE]`.
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | Remarque
+
+`data` et `raw_data` s’excluent mutuellement. Vous ne pouvez en définir qu’un seul par `ServerSentEvent`.
+
+///
+
+## Reprendre avec `Last-Event-ID` { #resuming-with-last-event-id }
+
+Quand un navigateur se reconnecte après une coupure, il envoie le dernier `id` reçu dans l’en-tête `Last-Event-ID`.
+
+Vous pouvez le lire comme paramètre d’en-tête et l’utiliser pour reprendre le flux là où le client s’était arrêté :
+
+{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}
+
+## SSE avec POST { #sse-with-post }
+
+SSE fonctionne avec **n’importe quelle méthode HTTP**, pas seulement `GET`.
+
+C’est utile pour des protocoles comme [MCP](https://modelcontextprotocol.io) qui diffusent des SSE via `POST` :
+
+{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}
+
+## Détails techniques { #technical-details }
+
+FastAPI met en œuvre certaines bonnes pratiques SSE prêtes à l’emploi.
+
+- Envoyer un commentaire **« keep alive » `ping`** toutes les 15 secondes quand aucun message n’a été émis, pour éviter que certains proxys ne ferment la connexion, comme suggéré dans la [Spécification HTML : Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes).
+- Définir l’en-tête `Cache-Control: no-cache` pour **empêcher la mise en cache** du flux.
+- Définir un en-tête spécial `X-Accel-Buffering: no` pour **empêcher le buffering** dans certains proxys comme Nginx.
+
+Vous n’avez rien à faire, cela fonctionne prêt à l’emploi. 🤓

docs/fr/docs/tutorial/stream-json-lines.md

@@ -0,0 +1,111 @@
+# Diffuser des JSON Lines { #stream-json-lines }
+
+Vous pouvez avoir une séquence de données que vous souhaitez envoyer en « flux » ; vous pouvez le faire avec « JSON Lines ».
+
+/// info
+
+Ajouté dans FastAPI 0.134.0.
+
+///
+
+## Qu'est-ce qu'un flux ? { #what-is-a-stream }
+
+La « diffusion en continu » de données signifie que votre application commence à envoyer des éléments de données au client sans attendre que l'ensemble de la séquence soit prêt.
+
+Ainsi, elle enverra le premier élément, le client le recevra et commencera à le traiter, et vous pourriez être encore en train de produire l'élément suivant.
+
+```mermaid
+sequenceDiagram
+    participant App
+    participant Client
+
+    App->>App: Produce Item 1
+    App->>Client: Send Item 1
+    App->>App: Produce Item 2
+    Client->>Client: Process Item 1
+    App->>Client: Send Item 2
+    App->>App: Produce Item 3
+    Client->>Client: Process Item 2
+    App->>Client: Send Item 3
+    Client->>Client: Process Item 3
+    Note over App: Keeps producing...
+    Note over Client: Keeps consuming...
+```
+
+Cela peut même être un flux infini, où vous continuez à envoyer des données.
+
+## JSON Lines { #json-lines }
+
+Dans ces cas, il est courant d'envoyer des « JSON Lines », qui est un format où vous envoyez un objet JSON par ligne.
+
+Une réponse aurait un type de contenu `application/jsonl` (au lieu de `application/json`) et le corps ressemblerait à ceci :
+
+```json
+{"name": "Plumbus", "description": "A multi-purpose household device."}
+{"name": "Portal Gun", "description": "A portal opening device."}
+{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
+```
+
+C'est très similaire à un tableau JSON (équivalent d'une liste Python), mais au lieu d'être entouré de `[]` et d'avoir des `,` entre les éléments, il y a un objet JSON par ligne, ils sont séparés par un caractère de saut de ligne.
+
+/// info
+
+Le point important est que votre application pourra produire chaque ligne à son tour, tandis que le client consomme les lignes précédentes.
+
+///
+
+/// note | Détails techniques
+
+Comme chaque objet JSON sera séparé par un saut de ligne, ils ne peuvent pas contenir de caractères de saut de ligne littéraux dans leur contenu, mais ils peuvent contenir des sauts de ligne échappés (`\n`), ce qui fait partie du standard JSON.
+
+Mais normalement, vous n'avez pas à vous en soucier, c'est fait automatiquement, continuez la lecture. 🤓
+
+///
+
+## Cas d'utilisation { #use-cases }
+
+Vous pouvez utiliser cela pour diffuser des données depuis un service **AI LLM**, depuis des **journaux** ou de la **télémétrie**, ou depuis d'autres types de données pouvant être structurées en éléments **JSON**.
+
+/// tip | Astuce
+
+Si vous voulez diffuser des données binaires, par exemple de la vidéo ou de l'audio, consultez le guide avancé : [Diffuser des données](../advanced/stream-data.md).
+
+///
+
+## Diffuser des JSON Lines avec FastAPI { #stream-json-lines-with-fastapi }
+
+Pour diffuser des JSON Lines avec FastAPI, au lieu d'utiliser `return` dans votre fonction de chemin d'accès, utilisez `yield` pour produire chaque élément à tour de rôle.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[24] *}
+
+Si chaque élément JSON que vous voulez renvoyer est de type `Item` (un modèle Pydantic) et que c'est une fonction async, vous pouvez déclarer le type de retour comme `AsyncIterable[Item]` :
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[1:24] hl[9:11,22] *}
+
+Si vous déclarez le type de retour, FastAPI l'utilisera pour **valider** les données, les **documenter** dans OpenAPI, les **filtrer**, et les **sérialiser** avec Pydantic.
+
+/// tip | Astuce
+
+Comme Pydantic les sérialisera côté **Rust**, vous obtiendrez une **performance** bien supérieure que si vous ne déclarez pas de type de retour.
+
+///
+
+### Fonctions de chemin d'accès non asynchrones { #non-async-path-operation-functions }
+
+Vous pouvez aussi utiliser des fonctions `def` classiques (sans `async`), et utiliser `yield` de la même manière.
+
+FastAPI s'assure qu'elle s'exécute correctement afin de ne pas bloquer la boucle d'événements.
+
+Comme dans ce cas la fonction n'est pas async, le bon type de retour serait `Iterable[Item]` :
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[27:30] hl[28] *}
+
+### Sans type de retour { #no-return-type }
+
+Vous pouvez également omettre le type de retour. FastAPI utilisera alors [`jsonable_encoder`](./encoder.md) pour convertir les données en quelque chose qui peut être sérialisé en JSON, puis les enverra en JSON Lines.
+
+{* ../../docs_src/stream_json_lines/tutorial001_py310.py ln[33:36] hl[34] *}
+
+## Événements envoyés par le serveur (SSE) { #server-sent-events-sse }
+
+FastAPI propose également une prise en charge native des Server-Sent Events (SSE), qui sont assez proches mais avec quelques détails supplémentaires. Vous pouvez en apprendre davantage dans le chapitre suivant : [Événements envoyés par le serveur (SSE)](server-sent-events.md). 🤓