> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Tracer les fonctions générateurs
> Suivez les fonctions générateurs synchrones et asynchrones avec le traçage W&B Weave
W\&B Weave prend en charge le traçage des fonctions générateurs synchrones et asynchrones, y compris dans les structures profondément imbriquées. Cette page vous montre comment décorer des fonctions générateurs avec `@weave.op` afin que Weave capture leurs entrées, les valeurs de sortie produites et la hiérarchie complète des appels imbriqués. Utilisez cette approche si votre code comporte des chemins en streaming ou à évaluation paresseuse dont vous souhaitez inspecter les sorties dans l’interface Weights & Biases, aux côtés de vos autres traces.
Comme les générateurs produisent leurs valeurs de manière paresseuse, Weave ne journalise les sorties qu’une fois le générateur entièrement consommé (par exemple, lorsque vous le convertissez en liste).
Pour que Weave capture les sorties dans la trace, consommez entièrement le générateur (par exemple, avec `list()`).
```python theme={"system"}
from typing import Generator
import weave
weave.init("my-project")
# Cette fonction utilise un générateur synchrone.
# Weave trace l’appel et son entrée (`x`),
# mais les valeurs de sortie ne sont capturées qu’une fois le générateur consommé (par exemple, avec `list()`).
@weave.op
def basic_gen(x: int) -> Generator[int, None, None]:
yield from range(x)
# Une fonction synchrone classique utilisée dans le pipeline du générateur.
# Ses appels sont également tracés indépendamment par Weave.
@weave.op
def inner(x: int) -> int:
return x + 1
# Un générateur synchrone qui appelle une autre fonction tracée (`inner`).
# Chaque valeur produite provient d’un appel tracé distinct à `inner`.
@weave.op
def nested_generator(x: int) -> Generator[int, None, None]:
for i in range(x):
yield inner(i)
# Un générateur qui s’appuie sur le générateur ci-dessus.
# Le traçage produit ici une arborescence d’appels hiérarchique :
# - `deeply_nested_generator` (parent)
# - `nested_generator` (enfant)
# - `inner` (petit-enfant)
@weave.op
def deeply_nested_generator(x: int) -> Generator[int, None, None]:
for i in range(x):
for j in nested_generator(i):
yield j
# Le générateur doit être *consommé* pour que Weave capture les sorties.
# Cela vaut aussi bien pour les générateurs synchrones qu’asynchrones.
res = deeply_nested_generator(4)
list(res) # Déclenche le traçage de tous les appels imbriqués et des valeurs produites
```
```plaintext theme={"system"}
This feature is not available in the TypeScript SDK yet.
```
La capture d’écran suivante montre la page **Traces** avec une trace sélectionnée issue du code précédent. Le panneau central affiche l’arborescence de la trace sélectionnée, dans laquelle figurent les ops `deeply_nested_generator`, `nested_generator` et `inner` selon leur hiérarchie.
Consommer les générateurs
Cette section explique pourquoi vous devez consommer les générateurs pour que Weave enregistre leurs sorties, et quels modes de consommation fonctionnent.
Weave ne capture les sorties d’un générateur qu’une fois celui-ci entièrement consommé. Pour consommer le générateur, parcourez-le (par exemple, avec `list()`, une boucle `for` ou des appels à `next()` jusqu’à épuisement). Il en va de même pour les générateurs asynchrones consommés avec `async for` ou un mécanisme équivalent.
Pour plus d’informations sur la décoration des fonctions et des méthodes avec `@weave.op`, voir [Créer des appels](/fr/products/wandb/weave/guides/tracking/create-call).
Accumuler les valeurs produites dans une seule trace
Si vous souhaitez que Weave enregistre un résultat combiné (comme une chaîne concaténée ou une liste) plutôt que la séquence brute des valeurs produites, utilisez un accumulateur.
Le paramètre `accumulator` de `weave.op` vous permet de personnaliser la manière dont les valeurs produites par les fonctions génératrices sont combinées, par exemple pour concaténer en une seule chaîne des jetons de texte transmis en streaming. L’accumulateur est une fonction à deux arguments que Weave appelle une fois par valeur produite, afin de construire le résultat de manière incrémentielle.
Le paramètre `accumulator` n'est pas disponible pour TypeScript.
L’exemple suivant présente un accumulateur personnalisé qui ajoute chaque valeur produite à une liste, de sorte que Weave enregistre cette liste comme sortie de l’appel une fois le générateur entièrement consommé.
```python theme={"system"}
from typing import Generator
import weave
weave.init("your-team-name/your-project-name")
# Weave appelle cette fonction après chaque yield. acc vaut None lors du premier appel.
# La dernière valeur que vous renvoyez devient la sortie tracée de l’op.
def list_accumulator(acc, value):
if acc is None:
acc = []
acc.append(value)
return acc
# Définir le paramètre accumulator
@weave.op(accumulator=list_accumulator)
def basic_gen_with_accumulator(x: int) -> Generator[int, None, None]:
yield from range(x)
# Itérer jusqu’au bout pour que chaque yield s’exécute et que l’accumulateur puisse produire la sortie tracée finale.
result = list(basic_gen_with_accumulator(3))
print(result)
```
## Related topics
- [Tracer votre code](/fr/products/wandb/weave/guides/tracking/create-call.md)