pinecall-runtime 0.1.6__py3-none-any.whl

pinecall/session/_livekit.py

@@ -0,0 +1,195 @@
+"""What livekit hands the session, read as ours: usage, transcripts, blocks, names, switches."""
+
+import contextlib
+import time
+from collections.abc import Callable, Iterable, Mapping
+
+from livekit.agents import (
+    NOT_GIVEN,
+    APIStatusError,
+    NotGivenOr,
+    StopResponse,
+    llm,
+    metrics,
+    stt,
+    tts,
+    utils,
+)
+from livekit.agents.metrics.base import AvatarMetrics
+from livekit.agents.types import TimedString
+from livekit.agents.voice import AgentSession
+from pydantic import BaseModel
+
+from pinecall.providers.build import Modality
+from pinecall.session.call import Writing
+from pinecall.wire import events as wire
+from pinecall.wire import metrics as measured
+from pinecall.wire.frames import WireModel
+
+type Adapter = llm.FallbackAdapter | stt.FallbackAdapter | tts.FallbackAdapter
+
+
+# Errors of the request itself; 408, 429 and 5xx are transient and livekit retries them.
+FOREVER = frozenset({400, 401, 402, 403, 404, 422})
+
+
+# The WebSocket close for a policy violation: a vendor that refuses a voice or a key sends it,
+# and livekit's 4xx check misses it.
+POLICY_VIOLATION = 1008
+
+
+# Each block is read by the wire's fields, under livekit's own names.
+BLOCKS: tuple[tuple[type[metrics.AgentMetrics], str, type[WireModel]], ...] = (
+    (metrics.LLMMetrics, "metrics.llm", measured.LLMMetrics),
+    (metrics.STTMetrics, "metrics.stt", measured.STTMetrics),
+    (metrics.TTSMetrics, "metrics.tts", measured.TTSMetrics),
+    (metrics.VADMetrics, "metrics.vad", measured.VADMetrics),
+    (metrics.EOUMetrics, "metrics.eou", measured.EOUMetrics),
+    (metrics.InterruptionMetrics, "metrics.interruption", measured.InterruptionMetrics),
+    (metrics.RealtimeModelMetrics, "metrics.realtime", measured.RealtimeModelMetrics),
+    (metrics.EOTInferenceMetrics, "metrics.eot", measured.EOTInferenceMetrics),
+    (AvatarMetrics, "metrics.avatar", measured.AvatarMetrics),
+)
+
+
+def given_or_unset[T](value: T | None) -> NotGivenOr[T]:
+    """The value, or livekit's NOT_GIVEN when it is None."""
+    return NOT_GIVEN if value is None else value
+
+
+def transcript_of(live: AgentSession[None], delta: str | TimedString) -> wire.AgentTranscript:
+    """What the agent said, as the wire's transcript entry, with the word timings livekit gave."""
+    speech = live.current_speech.id if live.current_speech else ""
+    timed: dict[str, float] = {}
+    if isinstance(delta, TimedString):
+        if utils.is_given(delta.start_time):
+            timed["start"] = delta.start_time
+        if utils.is_given(delta.end_time):
+            timed["end"] = delta.end_time
+    return wire.AgentTranscript(speech_id=speech, text=str(delta), final=False, **timed)
+
+
+# interrupt() raises when nothing is playing or the session has stopped.
+async def silence(live: AgentSession[None]) -> None:
+    """Stop the agent's speech now, and wait for livekit to say it stopped."""
+    with contextlib.suppress(RuntimeError):
+        await live.interrupt(force=True)
+    live.output.set_audio_enabled(False)
+    live.input.set_audio_enabled(False)
+
+
+# The ears first, then the voice, so the agent never speaks before it can hear.
+def hearing_again(live: AgentSession[None]) -> None:
+    """Let the caller's audio reach the ears again after a pause."""
+    live.input.set_audio_enabled(True)
+    live.output.set_audio_enabled(True)
+
+
+async def nothing_after(_: llm.Toolset.ToolCompletedEvent) -> None:
+    """Speak nothing after a tool finished: the app speaks when it wants to."""
+    raise StopResponse
+
+
+def forever(error: APIStatusError) -> bool:
+    """Whether a vendor's HTTP error will fail the same way every time it is retried."""
+    return error.status_code == POLICY_VIOLATION or error.status_code in FOREVER
+
+
+def usage_of(used: metrics.ModelUsage) -> measured.ModelUsage:
+    """The usage of one model livekit measured, as the wire writes it."""
+    match used:
+        case metrics.LLMModelUsage():
+            return _read_as(measured.LLMModelUsage, used)
+        case metrics.TTSModelUsage():
+            return _read_as(measured.TTSModelUsage, used)
+        case metrics.STTModelUsage():
+            return _read_as(measured.STTModelUsage, used)
+        case metrics.InterruptionModelUsage():
+            return _read_as(measured.InterruptionModelUsage, used)
+        case _:
+            return _read_as(measured.EOTModelUsage, used)
+
+
+def block_of(block: metrics.AgentMetrics) -> tuple[str, WireModel] | None:
+    """The metrics livekit measured for one step, as the entry type and model the log keeps."""
+    for livekits, kind, ours in BLOCKS:
+        if isinstance(block, livekits):
+            return kind, _read_as(ours, block)
+    return None
+
+
+# livekit emits the end-of-utterance block on the session only, so it is built again from the
+# user turn's report, as livekit builds it.
+def end_of_utterance(report: Mapping[str, object], speech: str) -> measured.EOUMetrics | None:
+    """The end-of-turn metrics livekit reports, as the wire's; None when a field is missing."""
+    delays = ("end_of_turn_delay", "transcription_delay", "on_user_turn_completed_delay")
+    if not any(key in report for key in delays):
+        return None
+    # Said, or written() drops the default and the SDKs refuse the entry.
+    return measured.EOUMetrics.model_validate(
+        {
+            "type": "eou_metrics",
+            "timestamp": time.time(),
+            "end_of_utterance_delay": report.get("end_of_turn_delay", 0.0),
+            "transcription_delay": report.get("transcription_delay", 0.0),
+            "on_user_turn_completed_delay": report.get("on_user_turn_completed_delay", 0.0),
+            "speech_id": speech,
+        }
+    )
+
+
+# livekit's adapter says when a vendor goes down or comes back (`<stage>_availability_changed`,
+# the vendor under the stage's own name), and names the next to serve. Its emitter is untyped:
+# it is read as an object.
+def switches_written(writing: Writing, built: Iterable[object]) -> None:
+    """Write vendor.switched each time a stage's fallback adapter loses or regains a vendor."""
+    for component in built:
+        match component:
+            case llm.FallbackAdapter():
+                stage: Modality = "llm"
+            case stt.FallbackAdapter():
+                stage = "stt"
+            case tts.FallbackAdapter():
+                stage = "tts"
+            case _:
+                continue
+        listen: object = getattr(component, "on", None)
+        if callable(listen):
+            listen(f"{stage}_availability_changed", _switch(writing, stage, component))
+
+
+def switch_of(stage: Modality, event: object, adapter: Adapter) -> wire.VendorSwitched | None:
+    """The entry for one vendor of a stage lost or back, and the one serving from now."""
+    changed: object = getattr(event, stage, None)
+    available: object = getattr(event, "available", None)
+    if not isinstance(changed, (llm.LLM, stt.STT, tts.TTS)) or not isinstance(available, bool):
+        return None
+    return wire.VendorSwitched(
+        stage=stage,
+        vendor=changed.provider,
+        model=changed.model,
+        available=available,
+        serving=adapter.provider,
+        serving_model=adapter.model,
+    )
+
+
+# livekit's rows carry the wire's names, and livekit adds fields the wire does not know
+# (`input_audio_tokens` on the ears' usage in 1.8.3). The wire refuses an unknown key, and a
+# listener's exception is swallowed by livekit's emitter, so the call would lose its usage in
+# silence: each row is read by the fields its wire model declares.
+def _read_as[T: WireModel](model: type[T], livekits: BaseModel) -> T:
+    """The wire model read from livekit's, field by field, so a field livekit grew is left out."""
+    dumped = livekits.model_dump()
+    return model.model_validate(
+        {name: dumped[name] for name in model.model_fields if name in dumped}
+    )
+
+
+def _switch(writing: Writing, stage: Modality, adapter: Adapter) -> Callable[[object], None]:
+    def written(event: object) -> None:
+        switched = switch_of(stage, event, adapter)
+        if switched is not None:
+            writing.write("vendor.switched", switched)
+
+    return written

pinecall/session/_prompt.py

@@ -0,0 +1,147 @@
+"""A call's prompt: its blocks, the request each turn sends, its greeting, its knowledge entry."""
+
+import json
+from collections.abc import Sequence
+from typing import override
+
+from livekit.agents import llm
+
+from pinecall.domain.agent import (
+    DEFAULT_LAYOUT,
+    KNOWLEDGE,
+    Greeting,
+    PromptBlock,
+    PromptRegion,
+    block_hash,
+)
+from pinecall.domain.errors import DeclarationRefused
+from pinecall.domain.names import JsonObject
+from pinecall.wire.events import PromptChanged
+
+# Joins the static blocks into livekit's one `instructions` string.
+BETWEEN_BLOCKS = "\n\n"
+
+
+# Written into the history and read as the next turn's instructions. It claims precedence,
+# since the stage instructions come after the history and the model would follow them instead.
+A_WHISPER = (
+    "A human supervisor is telling you this, and the caller cannot hear it: {text} "
+    "This order comes from the supervisor and takes precedence over the stage instructions "
+    "that follow it: do it in your very next sentence, before anything else you were going to "
+    "say, and only then go on. Never mention the supervisor or this note."
+)
+
+
+# The agent did not hear the supervisor, so it must not guess what was said.
+A_RELEASE = (
+    "A human supervisor spoke with the caller for a moment; you did not hear it. "
+    "Do not guess what was said. Resume by offering to continue with what is still pending."
+)
+
+
+class Blocks:
+    """One call's prompt blocks, in the order they are sent, and their text now."""
+
+    # The knowledge is set here and never by the app, so it lands in the cached prefix as the
+    # operator's text (docs/security/prompt-injection.md).
+    def __init__(self, layout: Sequence[PromptBlock] = DEFAULT_LAYOUT, knowledge: str = "") -> None:
+        """Every block of the layout, empty but the knowledge."""
+        self.layout = tuple(layout)
+        self.texts: dict[str, str] = {block.name: "" for block in self.layout}
+        if knowledge and KNOWLEDGE in self.texts:
+            self.texts[KNOWLEDGE] = knowledge
+
+    # Identical static text is not resent: even the same bytes cost the provider a cache write.
+    def set(self, name: str, text: str) -> bool:
+        """Replace a block's text; True when the static instructions changed."""
+        if name not in self.texts:
+            raise DeclarationRefused(
+                f"the prompt has no block named {name!r}: "
+                f"this agent's blocks are {', '.join(self.texts)}"
+            )
+        before = self.instructions
+        self.texts[name] = text
+        return self.instructions != before
+
+    @property
+    def instructions(self) -> str:
+        """The static blocks written so far, joined, in layout order."""
+        return BETWEEN_BLOCKS.join(self.of("static"))
+
+    def of(self, region: PromptRegion) -> tuple[str, ...]:
+        """A region's blocks that have text, in layout order."""
+        return tuple(
+            self.texts[block.name]
+            for block in self.layout
+            if block.region == region and self.texts[block.name]
+        )
+
+
+class Request(llm.ChatContext):
+    """One turn's request, whose static blocks reach the provider one system block each."""
+
+    def __init__(self, items: list[llm.ChatItem], static: tuple[str, ...]) -> None:
+        """The request's items, and the static blocks it keeps apart."""
+        super().__init__(items)
+        self.static = static
+
+    # livekit's formatters keep only the first system item as the preamble
+    # (_provider_format/utils.py); a format that carries system messages apart (the one that
+    # caches up to its last block among them) gets one per static block instead.
+    @override
+    def to_provider_format(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, format: str, **kwargs: object
+    ) -> tuple[list[dict[str, object]], object]:
+        """The request as the provider's formatter builds it, the static blocks kept apart."""
+        formatted = super().to_provider_format(format, **kwargs)  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+        if self.static and hasattr(formatted[1], "system_messages"):
+            formatted[1].system_messages = list(self.static)
+        return formatted  # pyright: ignore[reportUnknownVariableType]
+
+
+# Always a new context: livekit reuses its own across a turn's tool steps, so additions would
+# pile up. The order is the one prompt-injection.md states: static blocks, history, the view.
+def request(
+    history: llm.ChatContext, blocks: Blocks, lookups: Sequence[llm.ChatItem] = ()
+) -> Request:
+    """One request: the history with this turn's lookups spliced in, then the dynamic blocks."""
+    items = _ahead_of_the_caller(history.items, lookups)
+    items += [llm.ChatMessage(role="system", content=[text]) for text in blocks.of("dynamic")]
+    return Request(items, blocks.of("static"))
+
+
+# The log keeps the prompt's hashes alone; a run keeps what was sent, to reproduce a failure.
+def as_asked(sent: Request, tools: Sequence[llm.Tool]) -> JsonObject:
+    """One request as a failing golden reproduces it: the static blocks, the tools, the items."""
+    schemas = llm.ToolContext(list(tools)).parse_function_tools("openai")
+    items: object = sent.to_dict().get("items", [])
+    return json.loads(
+        json.dumps({"system": list(sent.static), "tools": schemas, "messages": items})
+    )
+
+
+# An eval run starts in the middle of a conversation, so it never greets.
+def greeting_for(greeting: Greeting | None, run: str | None) -> Greeting | None:
+    """The declared greeting, or none when an eval run opened the call."""
+    return None if run is not None else greeting
+
+
+# The app never sends prompt.set for this block, so without this entry the log would not show
+# that the file reached the model.
+def knowledge_changed(blocks: Blocks) -> PromptChanged | None:
+    """The entry saying the knowledge file reached the prompt, when there is one."""
+    text = blocks.texts.get(KNOWLEDGE, "")
+    return PromptChanged(name=KNOWLEDGE, hash=block_hash(text), chars=len(text)) if text else None
+
+
+# Lookups go before the caller's newest message (livekit appends it after
+# on_user_turn_completed); placed after it, models skip the next tool. They are spliced into
+# the request only, never into the history. No trailing user message (a tool step, agent.reply):
+# they go at the end.
+def _ahead_of_the_caller(
+    items: Sequence[llm.ChatItem], lookups: Sequence[llm.ChatItem]
+) -> list[llm.ChatItem]:
+    last = items[-1] if items else None
+    if not lookups or not (isinstance(last, llm.ChatMessage) and last.role == "user"):
+        return [*items, *lookups]
+    return [*items[:-1], *lookups, last]

pinecall/session/_recording.py

@@ -0,0 +1,237 @@
+"""A call's audio recorded by its own session: the caller left, every other voice right."""
+
+import asyncio
+import logging
+import time
+from collections.abc import Callable, Iterable, Iterator
+from dataclasses import dataclass
+from pathlib import Path
+
+import av
+import numpy as np
+from av.audio.stream import AudioStream
+from livekit import rtc
+from livekit.agents import AgentSession
+from livekit.agents.voice.recorder_io import RecorderIO
+
+from pinecall.session.hold import VOLUME, HoldMusic, drained
+from pinecall.session.room import CallRoom
+
+logger = logging.getLogger(__name__)
+
+# livekit's recorder wraps the session's audio in and out and places both on one timeline: the
+# caller on the left, the agent on the right, encoded in a thread of this process. Egress did the
+# same work in a process of its own per call (~0.12 vCPU, ~80 MB), and a track egress per voice
+# costs more still (~0.1 vCPU and ~170 MB a track, the load lab 2026-10-02): the voices are already
+# decoded here, so the recording is made here. A supervisor who takes over and the far end of a
+# transfer are the room's, not the session's: each is heard from its own track while it speaks and
+# spooled beside the file, and with the hold melody (from its clip, where it sounded) they are laid
+# in on the right when the file is closed: the file decoded and encoded once more, a stretch at a
+# time. That costs about a fiftieth of the call's length on one core (ten minutes in ~13 s on a
+# laptop's), within the worker's sealing budget for the calls a phone line takes; a call with no
+# other voice and no hold is never touched again. The session closes the recorder before the seal,
+# so the file is whole when the summary names it.
+
+# The agent's voice comes at 24 kHz and a phone at 8: 48 keeps nothing more (~10 % of a worker's
+# cores less, the load lab).
+RATE = 24000
+
+# Opus takes whole frames of 20 ms (480 samples at RATE).
+OPUS_FRAME = 480
+
+# A sum of voices can pass full scale; it is clipped, not wrapped.
+FULL_SCALE = 1.0
+
+# Who in the room speaks into the recording besides the session's own two.
+OTHERS = frozenset({"supervisor", "sip"})
+
+LOST = "a voice in the room of %s is not in its recording"
+
+
+@dataclass(frozen=True)
+class Sound:
+    """One sound laid on the right: the sample it starts at, how many, and any stretch of it."""
+
+    start: int
+    length: int
+    stretch: Callable[[int, int], np.ndarray]
+
+
+class Recorder:
+    """The call's file: livekit's recorder for its two sides, the room's other voices beside."""
+
+    def __init__(self, recorder: RecorderIO, audio: Path, where: CallRoom | None) -> None:
+        """A recording that started now and heard nobody else yet."""
+        self.recorder = recorder
+        self.audio = audio
+        self.where = where
+        self.others: list[tuple[float, Path]] = []
+        self.tasks: set[asyncio.Task[None]] = set()
+
+    def listen(self) -> None:
+        """Hear every other voice the room has, and each one that joins from now on."""
+        if self.where is None:
+            return
+        room = self.where.room
+        room.on("track_subscribed", self._subscribed)  # pyright: ignore[reportUnknownMemberType]
+        for seat in room.remote_participants.values():
+            for publication in seat.track_publications.values():
+                if publication.track is not None:
+                    self._subscribed(publication.track, publication, seat)
+
+    async def close(self, melody: HoldMusic | None) -> None:
+        """Finish the file; lay in the other voices and the melody when there were any."""
+        if self.where is not None:
+            self.where.room.off("track_subscribed", self._subscribed)  # pyright: ignore[reportUnknownMemberType]
+        for task in self.tasks:
+            task.cancel()
+        await asyncio.gather(*self.tasks, return_exceptions=True)
+        await self.recorder.aclose()
+        began = self.recorder.recording_started_at
+        played = [] if melody is None else melody.sounded()
+        if began is None or (not self.others and not played):
+            return
+        spans = [(start - began, end - began) for start, end in played]
+        clip = None if melody is None else melody.clip
+        await asyncio.to_thread(laid_in, self.audio, self.others, (clip, spans))
+
+    def _subscribed(
+        self, track: rtc.Track, _publication: rtc.TrackPublication, seat: rtc.RemoteParticipant
+    ) -> None:
+        if self.where is None or not isinstance(track, rtc.RemoteAudioTrack):
+            return
+        if self.where.kind_of(seat, dict(seat.attributes)) not in OTHERS:
+            return
+        task = asyncio.create_task(self._heard(track))
+        self.tasks.add(task)
+        task.add_done_callback(self.tasks.discard)
+
+    # The track's frames come continuous (the jitter buffer fills a silence), so one run a voice,
+    # spooled as it comes and placed where its first frame arrived. A run that breaks is said and
+    # kept as far as it got: the recording is the call's, with or without that voice.
+    async def _heard(self, track: rtc.RemoteAudioTrack) -> None:
+        began = self.recorder.recording_started_at or time.time()
+        spool = self.audio.with_name(f"{track.sid}.pcm")
+        stream = rtc.AudioStream(track, sample_rate=RATE, num_channels=1)
+        try:
+            with spool.open("wb") as sink:
+                async for event in stream:
+                    if sink.tell() == 0:
+                        self.others.append((time.time() - event.frame.duration - began, spool))
+                    sink.write(event.frame.data)
+        except Exception:
+            logger.warning(LOST, self.audio.parent.name, exc_info=True)
+        finally:
+            await stream.aclose()
+
+
+# A stretch of silence laid in past the file's end, at a time.
+STRETCH = RATE
+
+
+async def recorded(
+    live: AgentSession[None], audio: Path | None, where: CallRoom | None
+) -> Recorder | None:
+    """Record the call into the file from now on; None when it keeps no audio."""
+    caller, agent = live.input.audio, live.output.audio
+    if audio is None or caller is None or agent is None:
+        return None
+    recorder = RecorderIO(agent_session=live, sample_rate=RATE)
+    live.input.audio = recorder.record_input(caller)
+    live.output.audio = recorder.record_output(agent)
+    await recorder.start(output_path=audio)
+    recording = Recorder(recorder, audio, where)
+    recording.listen()
+    return recording
+
+
+# Blocking, for a thread: the file decoded a frame at a time, the sounds added on the right where
+# each falls, encoded as it goes, put in its place. Nothing of the call's length is held at once.
+def laid_in(
+    audio: Path,
+    others: list[tuple[float, Path]],
+    melody: tuple[Path | None, list[tuple[float, float]]],
+) -> None:
+    """Add the other voices and the melody to the recording's right channel, each at its time."""
+    sounds = [*(_voice(at_s, pcm) for at_s, pcm in others), *_tune(*melody)]
+    part = audio.with_name(f"{audio.name}.part")
+    encoded(_mixed(_decoded(audio, "stereo"), sounds), part)
+    part.replace(audio)
+    for _, pcm in others:
+        pcm.unlink(missing_ok=True)
+
+
+def encoded(stretches: Iterable[np.ndarray], out: Path) -> None:
+    """Write stretches of two channels of floats at RATE as one stereo Ogg Opus."""
+    fifo = av.AudioFifo()
+    with av.open(str(out), mode="w", format="ogg") as sink:
+        stream: AudioStream = sink.add_stream("libopus", rate=RATE)  # pyright: ignore[reportUnknownMemberType]
+        stream.layout = "stereo"
+        for stretch in stretches:
+            frame = av.AudioFrame.from_ndarray(
+                np.ascontiguousarray(stretch), format="fltp", layout="stereo"
+            )
+            frame.sample_rate = RATE
+            frame.pts = None
+            fifo.write(frame)
+            drained(fifo, stream, sink, final=False)
+        drained(fifo, stream, sink, final=True)
+        for packet in stream.encode(None):  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            sink.mux(packet)  # pyright: ignore[reportUnknownMemberType]
+
+
+def _voice(at_s: float, pcm: Path) -> Sound:
+    samples = np.memmap(pcm, dtype="<i2", mode="r")
+
+    def stretch(at: int, count: int) -> np.ndarray:
+        return samples[at : at + count].astype(np.float32) / 32768
+
+    return Sound(round(at_s * RATE), len(samples), stretch)
+
+
+# The melody loops from the start of each span, as the player played it.
+def _tune(clip: Path | None, spans: list[tuple[float, float]]) -> list[Sound]:
+    pieces = [] if clip is None else list(_decoded(clip, "mono"))
+    if not pieces or not spans:
+        return []
+    tune = np.concatenate(pieces, axis=1)[0] * VOLUME
+
+    def stretch(at: int, count: int) -> np.ndarray:
+        return np.take(tune, np.arange(at, at + count) % len(tune))
+
+    return [
+        Sound(round(start_s * RATE), max(round((end_s - start_s) * RATE), 0), stretch)
+        for start_s, end_s in spans
+    ]
+
+
+def _mixed(stretches: Iterator[np.ndarray], sounds: list[Sound]) -> Iterator[np.ndarray]:
+    cursor = 0
+    end = max((sound.start + sound.length for sound in sounds), default=0)
+    for stretch in stretches:
+        yield _laid(stretch, cursor, sounds)
+        cursor += stretch.shape[1]
+    while cursor < end:
+        count = min(STRETCH, end - cursor)
+        yield _laid(np.zeros((2, count), dtype=np.float32), cursor, sounds)
+        cursor += count
+
+
+def _laid(stretch: np.ndarray, cursor: int, sounds: list[Sound]) -> np.ndarray:
+    until = cursor + stretch.shape[1]
+    for sound in sounds:
+        low, high = max(sound.start, cursor), min(sound.start + sound.length, until)
+        if low < high:
+            stretch[1, low - cursor : high - cursor] += sound.stretch(low - sound.start, high - low)
+    np.clip(stretch, -FULL_SCALE, FULL_SCALE, out=stretch)
+    return stretch
+
+
+def _decoded(audio: Path, layout: str) -> Iterator[np.ndarray]:
+    resampler = av.AudioResampler(format="fltp", layout=layout, rate=RATE)
+    with av.open(str(audio)) as source:
+        for frame in source.decode(audio=0):
+            for piece in resampler.resample(frame):
+                yield piece.to_ndarray()
+        for piece in resampler.resample(None):
+            yield piece.to_ndarray()