Skip to main content
W&B Weave supports tracing both sync and async generator functions, including deeply nested patterns.
Because generators yield values lazily, Weave logs outputs only when the generator is fully consumed (for example, when you convert it to a list). To ensure Weave captures outputs in the trace, fully consume the generator (for example, with list()).
from typing import Generator
import weave

weave.init("my-project")

# This function uses a simple sync generator.
# Weave will trace the call and its input (`x`),
# but output values are only captured once the generator is consumed (for example, with `list()`).
@weave.op
def basic_gen(x: int) -> Generator[int, None, None]:
    yield from range(x)

# A normal sync function used within the generator pipeline.
# Its calls are also traced independently by Weave.
@weave.op
def inner(x: int) -> int:
    return x + 1

# A sync generator that calls another traced function (`inner`).
# Each yielded value comes from a separate traced call to `inner`.
@weave.op
def nested_generator(x: int) -> Generator[int, None, None]:
    for i in range(x):
        yield inner(i)

# A more complex generator that composes the above generator.
# Tracing here produces a hierarchical call tree:
# - `deeply_nested_generator` (parent)
#   - `nested_generator` (child)
#     - `inner` (grandchild)
@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

# The generator must be *consumed* for Weave to capture outputs.
# This is true for both sync and async generators.
res = deeply_nested_generator(4)
list(res)  # Triggers tracing of all nested calls and yields
The following screenshot shows the Traces page with a selected trace of the preceding code. The center panel shows the trace tree for the selected trace. The trace tree shows the deeply_nested_generator, nested_generator, and inner Ops in the trace tree hierarchy. Weave Traces page showing a selected trace tree illustrating deeply nested Ops

​
Consuming generators

Weave captures generator outputs only after you fully consume the generator. Consume the generator by iterating over it (for example, with list(), a for loop, or next() until exhaustion). The same applies to async generators when you use async for or equivalent consumption. For more on decorating functions and methods with @weave.op, see Create calls.