pipecat-effects 0.1.0__py3-none-any.whl

pipecat_effects/__init__.py

@@ -0,0 +1,39 @@
+"""Output audio effects for pipecat. Filter, effects, meter."""
+
+from pipecat_effects.effects import (
+    AGC,
+    Apply,
+    Biquad,
+    Compressor,
+    DeEsser,
+    Effect,
+    Effects,
+    Gain,
+    Limiter,
+    Reverb,
+    Saturation,
+)
+from pipecat_effects.filter import EffectsFilter
+from pipecat_effects.meter import Meter, Reading
+from pipecat_effects.mixer import FilterMixer
+from pipecat_effects.primitives import Kind, Samples
+
+__all__ = [
+    "AGC",
+    "Apply",
+    "Biquad",
+    "Compressor",
+    "DeEsser",
+    "Effect",
+    "Effects",
+    "EffectsFilter",
+    "FilterMixer",
+    "Gain",
+    "Kind",
+    "Limiter",
+    "Meter",
+    "Reading",
+    "Reverb",
+    "Samples",
+    "Saturation",
+]

pipecat_effects/effects.py

@@ -0,0 +1,270 @@
+"""Eight effects. Each one validates values and builds one apply call."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from typing import Protocol
+
+import numpy as np
+
+from pipecat_effects.primitives import KINDS, Envelope, Kind, Line, Loudness, Samples, Section, row
+
+type Apply = Callable[[Samples], Samples]
+
+FLOOR = 1e-9  # linear level that reads as silence
+HOLD_LUFS = -50.0  # under this loudness, gain holds
+WINDOW_MS = 400.0  # loudness window, automatic gain
+COMBS = (1116, 1188, 1277, 1356)  # Schroeder delays in samples at 44100 Hz
+ALLPASS = (556, 441)
+ALLPASS_FEEDBACK = 0.5
+SCHROEDER_RATE = 44100
+
+
+class Effect(Protocol):
+    """One stage. start gives one apply call."""
+
+    def start(self, rate: int) -> Apply:
+        """Builds primitives of this stage."""
+        ...
+
+
+type Effects = Sequence[Effect]
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Gain:
+    """One multiply."""
+
+    db: float = 0.0
+
+    def __post_init__(self) -> None:
+        _within("db", self.db, -60.0, 24.0)
+
+    def start(self, rate: int) -> Apply:
+        """Gives one multiply."""
+        factor = np.float32(_linear(self.db))
+        return lambda x: x * factor
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Biquad:
+    """One second-order section from the Audio EQ Cookbook."""
+
+    kind: Kind
+    hz: float
+    q: float = 0.7071
+    gain_db: float = 0.0
+
+    def __post_init__(self) -> None:
+        if self.kind not in KINDS:
+            raise ValueError(f"kind: expected one of {KINDS}, got a name outside them")
+        _within("hz", self.hz, 10.0, 20000.0)
+        _within("q", self.q, 0.1, 20.0)
+        _within("gain_db", self.gain_db, -24.0, 24.0)
+
+    def start(self, rate: int) -> Apply:
+        """Gives one section run call."""
+        return Section(self.row(rate)).run
+
+    def row(self, rate: int) -> tuple[float, ...]:
+        """Gives the 6 coefficients of this section at this rate."""
+        return row(self.kind, rate=rate, hz=self.hz, q=self.q, gain_db=self.gain_db)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Saturation:
+    """Memoryless tanh waveshaper with a dry/wet mix."""
+
+    drive: float = 2.0
+    mix: float = 1.0
+
+    def __post_init__(self) -> None:
+        _within("drive", self.drive, 0.1, 20.0)
+        _within("mix", self.mix, 0.0, 1.0)
+
+    def start(self, rate: int) -> Apply:
+        """Gives one waveshaper call, unity at full scale."""
+        drive = np.float32(self.drive)
+        wet = np.float32(self.mix / math.tanh(self.drive))
+        dry = np.float32(1.0 - self.mix)
+        return lambda x: dry * x + wet * np.tanh(drive * x)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Compressor:
+    """One envelope, gain over threshold by ratio, then makeup."""
+
+    threshold_db: float = -18.0
+    ratio: float = 3.0
+    attack_ms: float = 5.0
+    release_ms: float = 80.0
+    makeup_db: float = 0.0
+
+    def __post_init__(self) -> None:
+        _within("threshold_db", self.threshold_db, -60.0, 0.0)
+        _within("ratio", self.ratio, 1.0, 20.0)
+        _within("attack_ms", self.attack_ms, 0.0, 200.0)
+        _within("release_ms", self.release_ms, 1.0, 2000.0)
+        _within("makeup_db", self.makeup_db, -24.0, 24.0)
+
+    def start(self, rate: int) -> Apply:
+        """Follows level, applies gain."""
+        level = Envelope(rate=rate, attack_ms=self.attack_ms, release_ms=self.release_ms)
+        slope = 1.0 - 1.0 / self.ratio
+        threshold, makeup = self.threshold_db, self.makeup_db
+
+        def apply(x: Samples) -> Samples:
+            over = np.maximum(_decibels(level.run(np.abs(x))) - threshold, 0.0)
+            return x * _gain(makeup - slope * over)
+
+        return apply
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AGC:
+    """Momentary K-weighted loudness to target, at bounded rate."""
+
+    target_lufs: float = -20.0
+    max_db_per_second: float = 6.0
+
+    def __post_init__(self) -> None:
+        _within("target_lufs", self.target_lufs, -40.0, -10.0)
+        _within("max_db_per_second", self.max_db_per_second, 0.1, 20.0)
+
+    def start(self, rate: int) -> Apply:
+        """Measures loudness, ramps gain."""
+        loudness = Loudness(rate=rate, window_ms=WINDOW_MS)
+        gain = Envelope(
+            rate=rate, attack_ms=0.0, release_ms=0.0, max_per_second=self.max_db_per_second
+        )
+        target = self.target_lufs
+
+        def apply(x: Samples) -> Samples:
+            level = loudness.run(x)
+            wanted = gain.value if level < HOLD_LUFS else target - level
+            return x * _gain(gain.run(np.full(x.size, wanted, dtype=np.float32)))
+
+        return apply
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Limiter:
+    """Memoryless soft clipper. Soft knee under the ceiling, hard ceiling at it."""
+
+    ceiling_db: float = -1.0
+    knee_db: float = 3.0
+
+    def __post_init__(self) -> None:
+        _within("ceiling_db", self.ceiling_db, -24.0, 0.0)
+        _within("knee_db", self.knee_db, 0.0, 12.0)
+
+    def start(self, rate: int) -> Apply:
+        """Memoryless curve, 0 samples over the ceiling."""
+        ceiling = np.float32(_linear(self.ceiling_db))
+        knee = np.float32(_linear(self.ceiling_db - self.knee_db))
+        width = np.float32(2.0 * (ceiling - knee))
+        span = np.float32(4.0 * (ceiling - knee)) if self.knee_db > 0.0 else np.float32(1.0)
+
+        def apply(x: Samples) -> Samples:
+            magnitude = np.abs(x)
+            over = np.clip(magnitude - knee, 0.0, width)
+            return np.copysign(np.minimum(magnitude, knee + over - over * over / span), x)
+
+        return apply
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Reverb:
+    """Schroeder reverberator. Four comb filters, 2 allpass filters."""
+
+    decay_ms: float = 200.0
+    mix: float = 0.15
+
+    def __post_init__(self) -> None:
+        _within("decay_ms", self.decay_ms, 10.0, 500.0)
+        _within("mix", self.mix, 0.0, 1.0)
+
+    def start(self, rate: int) -> Apply:
+        """Sums combs, runs the allpass pair."""
+        combs = [
+            Line(samples=n, feedback=self._feedback(n, rate)) for n in self._delays(COMBS, rate)
+        ]
+        allpass = [
+            Line(samples=n, feedback=ALLPASS_FEEDBACK, allpass=True)
+            for n in self._delays(ALLPASS, rate)
+        ]
+        wet, dry = np.float32(self.mix / len(combs)), np.float32(1.0 - self.mix)
+
+        def apply(x: Samples) -> Samples:
+            tail = np.stack([comb.run(x) for comb in combs]).sum(axis=0) * wet
+            for section in allpass:
+                tail = section.run(tail)
+            return dry * x + tail
+
+        return apply
+
+    def _delays(self, delays: tuple[int, ...], rate: int) -> list[int]:
+        """Scales Schroeder delays to this rate."""
+        return [max(round(delay * rate / SCHROEDER_RATE), 1) for delay in delays]
+
+    def _feedback(self, samples: int, rate: int) -> float:
+        """Gives feedback that falls 60 dB in decay_ms."""
+        return 10.0 ** (-3000.0 * samples / (rate * self.decay_ms))
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeEsser:
+    """Split-band de-esser. The envelope of one band-pass band sets the cut of that band."""
+
+    hz: float = 6500.0
+    q: float = 1.5
+    threshold_db: float = -30.0
+    ratio: float = 4.0
+    attack_ms: float = 1.0
+    release_ms: float = 40.0
+
+    def __post_init__(self) -> None:
+        _within("hz", self.hz, 1000.0, 20000.0)
+        _within("q", self.q, 0.1, 20.0)
+        _within("threshold_db", self.threshold_db, -60.0, 0.0)
+        _within("ratio", self.ratio, 1.0, 20.0)
+        _within("attack_ms", self.attack_ms, 0.0, 200.0)
+        _within("release_ms", self.release_ms, 1.0, 2000.0)
+
+    def start(self, rate: int) -> Apply:
+        """Takes the band down over threshold."""
+        band = Section.at("bandpass", rate=rate, hz=self.hz, q=self.q)
+        level = Envelope(rate=rate, attack_ms=self.attack_ms, release_ms=self.release_ms)
+        slope = 1.0 - 1.0 / self.ratio
+        threshold = self.threshold_db
+
+        def apply(x: Samples) -> Samples:
+            found = band.run(x)
+            over = np.maximum(_decibels(level.run(np.abs(found))) - threshold, 0.0)
+            return x - (1.0 - _gain(-slope * over)) * found
+
+        return apply
+
+
+def _within(field: str, value: float, low: float, high: float) -> None:
+    """Refuses one value outside its range."""
+    if not low <= value <= high:
+        side = "under" if value < low else "over"
+        raise ValueError(f"{field}: expected {low} to {high}, got a value {side} the range")
+
+
+def _linear(db: float) -> float:
+    """Gives one amplitude from dB."""
+    return 10.0 ** (db / 20.0)
+
+
+def _gain(db: Samples | float) -> Samples:
+    """Gives one amplitude per dB level."""
+    return 10.0 ** (np.asarray(db, dtype=np.float32) / 20.0)
+
+
+def _decibels(level: Samples) -> Samples:
+    """Gives one dB level per amplitude."""
+    return 20.0 * np.log10(np.maximum(level, FLOOR))

pipecat_effects/filter.py

@@ -0,0 +1,139 @@
+"""Output audio filter. One chain per session, run as given."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+import numpy as np
+from pipecat.audio.filters.base_audio_filter import BaseAudioFilter
+from pipecat.frames.frames import FilterControlFrame, FilterEnableFrame, FilterUpdateSettingsFrame
+
+from pipecat_effects.effects import Apply, Biquad, Effects
+from pipecat_effects.primitives import Samples, Section
+
+SCALE = 32768.0  # int16 full scale
+TOP = 32767  # highest int16 sample
+SETTING = "effects"  # update frame key of a new chain
+
+
+class EffectsFilter(BaseAudioFilter):
+    """Processes spoken audio. It adds 0 samples of latency and runs on mono."""
+
+    def __init__(self, effects: Effects) -> None:
+        self._effects: Effects = tuple(effects)
+        self._rate = 0
+        self._chain: list[Apply] = []
+        self._heard: list[Apply] | None = None  # the chain of the last chunk, None for the input
+        self._enabled = True
+
+    async def start(self, sample_rate: int) -> None:
+        """Builds the chain at this rate."""
+        self._rate = sample_rate
+        self._chain = _started(self._effects, sample_rate)
+        self._heard = self._chain if self._enabled else None
+
+    async def stop(self) -> None:
+        """Drops the chain."""
+        self._chain, self._heard, self._rate = [], None, 0
+
+    async def process_frame(self, frame: FilterControlFrame) -> None:
+        """Enable frame switches the bypass. Settings frame rebuilds the chain."""
+        if isinstance(frame, FilterEnableFrame):
+            self._enabled = frame.enable
+        elif isinstance(frame, FilterUpdateSettingsFrame):
+            self._update(frame.settings)
+
+    async def filter(self, audio: bytes) -> bytes:
+        """Runs one mono int16 chunk, silence included. Gives int16 bytes."""
+        taken = decoded(audio)
+        if not taken.size:
+            return audio
+        given = self._chunk(taken)
+        return np.clip(np.rint(given * SCALE), -SCALE, TOP).astype(np.int16).tobytes()
+
+    def _chunk(self, x: Samples) -> Samples:
+        """Runs the chain, in bypass too. A change fades from the output last heard."""
+        wet = _through(self._chain, x)
+        before, after = self._before(x, wet), (wet if self._enabled else x)
+        self._heard = self._chain if self._enabled else None
+        return after if before is after else _faded(before, after)
+
+    def _before(self, x: Samples, wet: Samples) -> Samples:
+        """Gives this chunk through the chain last heard. A bypass heard the input."""
+        if self._heard is None:
+            return x
+        return wet if self._heard is self._chain else _through(self._heard, x)
+
+    def _update(self, settings: Mapping[str, Any]) -> None:
+        """Builds the new chain, then swaps it in. A failed build keeps the old chain."""
+        if (payload := settings.get(SETTING)) is None:
+            return
+        effects = _sequence(payload)
+        if self._rate:
+            try:
+                self._chain = _started(effects, self._rate)
+            except ValueError as error:
+                raise ValueError(f"{SETTING}: {error}") from error
+            except TypeError as error:
+                raise TypeError(f"{SETTING}: {error}") from error
+        self._effects = effects
+
+
+def decoded(audio: bytes) -> Samples:
+    """Gives one int16 chunk as float32 samples, full scale at 1.0. An odd byte count raises."""
+    if len(audio) % 2:
+        raise ValueError(f"audio: expected int16 bytes, an even count, got {len(audio)} bytes")
+    return np.frombuffer(audio, dtype=np.int16).astype(np.float32) / SCALE
+
+
+def _started(effects: Effects, rate: int) -> list[Apply]:
+    """Starts each effect. Adjacent biquads run as one cascade in one sosfilt call."""
+    chain: list[Apply] = []
+    biquads: list[Biquad] = []
+    for index, effect in enumerate(effects):
+        if isinstance(effect, Biquad):
+            biquads.append(effect)
+        else:
+            chain += [*_cascade(biquads, rate), _stage(index, effect, rate)]
+            biquads = []
+    return chain + _cascade(biquads, rate)
+
+
+def _cascade(biquads: Sequence[Biquad], rate: int) -> list[Apply]:
+    """Gives one section run call for these biquads, or none for 0 biquads."""
+    return [Section([biquad.row(rate) for biquad in biquads]).run] if biquads else []
+
+
+def _stage(index: int, effect: Any, rate: int) -> Apply:
+    """Starts one effect. An item whose start gives no callable raises with its index."""
+    start = getattr(effect, "start", None)
+    apply: Apply | None = None if start is None else start(rate)
+    if not callable(apply):
+        raise TypeError(
+            f"index {index}: expected an effect whose start gives a callable, "
+            f"got {type(effect).__name__}"
+        )
+    return apply
+
+
+def _through(chain: Sequence[Apply], x: Samples) -> Samples:
+    """Runs one chunk through each stage."""
+    for stage in chain:
+        x = stage(x)
+    return x
+
+
+def _faded(before: Samples, after: Samples) -> Samples:
+    """Fades linearly from one output to the other over 1 chunk."""
+    ramp = np.linspace(0.0, 1.0, before.size + 1, dtype=np.float32)[1:]
+    return before * (1.0 - ramp) + after * ramp
+
+
+def _sequence(effects: Any) -> Effects:
+    """Refuses one update payload outside a sequence of effects."""
+    if isinstance(effects, str | bytes) or not isinstance(effects, Sequence):
+        raise TypeError(
+            f"{SETTING}: expected a sequence of effects, got one {type(effects).__name__}"
+        )
+    return tuple(effects)

pipecat_effects/meter.py

@@ -0,0 +1,55 @@
+"""Output meter. LUFS loudness, dBTP true peak."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+from scipy.signal import firwin
+
+from pipecat_effects.primitives import SILENCE, Fir, Loudness, Samples, dbfs
+
+# 48 taps at 4 times, BS.1770 Annex 2
+OVERSAMPLE = 4
+TAPS = 48
+BAND = 1.0 / OVERSAMPLE  # cutoff at the input Nyquist, as part of the oversampled Nyquist
+TRUE_PEAK_TAPS = np.asarray(firwin(TAPS, BAND, window="blackman"), dtype=np.float32)
+
+
+@dataclass(frozen=True, slots=True)
+class Reading:
+    """One read of the output."""
+
+    lufs: float
+    dbtp: float
+
+
+class Meter:
+    """Reads loudness and true peak per interval."""
+
+    def __init__(self) -> None:
+        self._loudness: Loudness | None = None
+        self._peak: Fir | None = None
+        self._top = 0.0
+
+    def start(self, rate: int) -> None:
+        """Builds both readers."""
+        self._loudness = Loudness(rate=rate)
+        self._peak = Fir(TRUE_PEAK_TAPS, factor=OVERSAMPLE)
+        self._top = 0.0
+
+    def write(self, x: Samples) -> None:
+        """Takes one chunk. It skips a chunk before start and a chunk of 0 samples."""
+        if self._loudness is None or self._peak is None or not x.size:
+            return
+        self._loudness.run(x)
+        self._top = max(self._top, float(np.abs(self._peak.run(x)).max(initial=0.0)))
+
+    def read(self) -> Reading:
+        """Gives both readings, then clears."""
+        reading = Reading(
+            lufs=SILENCE if self._loudness is None else self._loudness.take(),
+            dbtp=dbfs(self._top),
+        )
+        self._top = 0.0
+        return reading

pipecat_effects/mixer.py

@@ -0,0 +1,54 @@
+"""Mixer adapter. It runs one filter on the output and meters the result."""
+
+from __future__ import annotations
+
+from pipecat.audio.filters.base_audio_filter import BaseAudioFilter
+from pipecat.audio.mixers.base_audio_mixer import BaseAudioMixer
+from pipecat.frames.frames import (
+    FilterEnableFrame,
+    FilterUpdateSettingsFrame,
+    MixerControlFrame,
+    MixerEnableFrame,
+    MixerUpdateSettingsFrame,
+)
+
+from pipecat_effects.filter import decoded
+from pipecat_effects.meter import Meter, Reading
+from pipecat_effects.primitives import SILENCE
+
+
+class FilterMixer(BaseAudioMixer):
+    """Runs one filter on the output and meters each chunk."""
+
+    def __init__(self, audio_filter: BaseAudioFilter, *, channels: int) -> None:
+        self._filter = audio_filter
+        self._channels = channels
+        self._meter = Meter()
+
+    async def start(self, sample_rate: int) -> None:
+        """Starts the filter and the meter. Over 1 channel raises."""
+        if self._channels != 1:
+            raise ValueError(f"channels: expected 1, got {self._channels}")
+        await self._filter.start(sample_rate)
+        self._meter.start(sample_rate)
+
+    async def stop(self) -> None:
+        await self._filter.stop()
+
+    async def process_frame(self, frame: MixerControlFrame) -> None:
+        """Maps one mixer frame to one filter frame."""
+        if isinstance(frame, MixerEnableFrame):
+            await self._filter.process_frame(FilterEnableFrame(enable=frame.enable))
+        elif isinstance(frame, MixerUpdateSettingsFrame):
+            await self._filter.process_frame(FilterUpdateSettingsFrame(settings=frame.settings))
+
+    async def mix(self, audio: bytes) -> bytes:
+        """Filters one chunk and meters the int16 result."""
+        mixed = await self._filter.filter(audio)
+        self._meter.write(decoded(mixed))
+        return mixed
+
+    def read(self) -> Reading | None:
+        """Gives loudness and true peak since the last read, then clears. Silence gives None."""
+        reading = self._meter.read()
+        return None if reading.lufs <= SILENCE else reading

pipecat_effects/primitives.py

@@ -0,0 +1,303 @@
+"""Five stateful blocks. Each effect composes them and adds no state."""
+
+from __future__ import annotations
+
+import cmath
+import math
+from collections.abc import Sequence
+from functools import cache
+from typing import Literal, get_args
+
+import numpy as np
+from numpy.lib.stride_tricks import sliding_window_view
+from numpy.typing import NDArray
+from scipy.signal import sos2zpk, sosfilt, zpk2sos
+
+type Samples = NDArray[np.floating]
+type Roots = NDArray[np.complex128]
+type Kind = Literal["lowpass", "highpass", "bandpass", "peak", "lowshelf", "highshelf"]
+
+KINDS = get_args(Kind.__value__)  # get_args on the alias itself gives ()
+NYQUIST_RATIO = 0.45  # highest centre, as part of the rate
+BLOCK_MS = 1.0  # envelope step
+K_RATE = 48000  # rate of the published K-weighting sections
+# fmt: off
+K_SECTIONS = (  # BS.1770 stage 1 shelf and stage 2 highpass, b0 b1 b2 over a0 a1 a2
+    (1.53512485958697, -2.69169618940638, 1.19839281085285,
+     1.0, -1.69065929318241, 0.73248077421585),
+    (1.0, -2.0, 1.0,
+     1.0, -1.99004745483398, 0.99007225036621),
+)
+# fmt: on
+K_MATCH_HZ = 1000.0  # the K-weighting at each rate keeps the published response here
+OFFSET_LUFS = -0.691  # calibration, K-weighted mean square, BS.1770
+SILENCE = -120.0  # floor of one level reading
+
+
+class Section:
+    """One second-order section on sosfilt, or a cascade."""
+
+    def __init__(self, sos: Sequence[float] | Sequence[Sequence[float]]) -> None:
+        self._sos = np.asarray(sos, dtype=np.float64).reshape(-1, 6)
+        self._state = np.zeros((self._sos.shape[0], 2), dtype=np.float64)
+
+    @classmethod
+    def at(
+        cls, kind: Kind, *, rate: int, hz: float, q: float = 0.7071, gain_db: float = 0.0
+    ) -> Section:
+        """Gives one Audio EQ Cookbook section at this rate. A centre over the bound raises."""
+        return cls(row(kind, rate=rate, hz=hz, q=q, gain_db=gain_db))
+
+    def run(self, x: Samples) -> Samples:
+        """Filters one chunk and holds its state."""
+        out, self._state = sosfilt(self._sos, x.astype(np.float64), zi=self._state)
+        return out.astype(np.float32)
+
+
+class Envelope:
+    """One-pole follower on 1 ms blocks. Attack on rise, release on fall, bounded rate."""
+
+    def __init__(
+        self,
+        *,
+        rate: int,
+        attack_ms: float,
+        release_ms: float,
+        max_per_second: float = math.inf,
+    ) -> None:
+        self._block = max(round(BLOCK_MS * rate / 1000.0), 1)
+        blocks = rate / self._block
+        self._attack = _pole(attack_ms, blocks)
+        self._release = _pole(release_ms, blocks)
+        self._step = max_per_second / blocks
+        self._value = 0.0
+
+    @property
+    def value(self) -> float:
+        """Gives one level this follower holds."""
+        return self._value
+
+    def run(self, x: Samples) -> Samples:
+        """Gives one followed level per sample. It steps once per block."""
+        attack, release, step, value = self._attack, self._release, self._step, self._value
+        levels: list[float] = []
+        for peak in _peaks(x, self._block):
+            pole = attack if peak > value else release
+            moved = value + (1.0 - pole) * (peak - value)
+            value = min(max(moved, value - step), value + step)
+            levels.append(value)
+        self._value = value
+        return np.repeat(np.array(levels, dtype=np.float32), self._block)[: x.size]
+
+
+class Line:
+    """Delay line with feedback. One comb, or one allpass."""
+
+    def __init__(self, *, samples: int, feedback: float, allpass: bool = False) -> None:
+        self._buffer = np.zeros(max(samples, 1), dtype=np.float32)
+        self._feedback = np.float32(feedback)
+        self._allpass = allpass
+        self._at = 0
+
+    def run(self, x: Samples) -> Samples:
+        """Reads, writes with feedback, moves on."""
+        out = np.empty_like(x)
+        done = 0
+        while done < x.size:
+            step = min(self._buffer.size - self._at, x.size - done)
+            delayed = self._buffer[self._at : self._at + step]
+            stored = x[done : done + step] + self._feedback * delayed
+            out[done : done + step] = (
+                delayed - self._feedback * stored if self._allpass else delayed
+            )
+            self._buffer[self._at : self._at + step] = stored
+            self._at = (self._at + step) % self._buffer.size
+            done += step
+        return out
+
+
+class Fir:
+    """Polyphase interpolator. It holds one chunk tail."""
+
+    def __init__(self, taps: Samples, *, factor: int) -> None:
+        phases = np.stack([taps[phase::factor] * factor for phase in range(factor)])
+        self._phases = np.ascontiguousarray(phases[:, ::-1].T)  # one column per phase, back in time
+        self._tail = np.zeros(phases.shape[1] - 1, dtype=np.float32)
+
+    def run(self, x: Samples) -> Samples:
+        """Gives factor samples per input sample."""
+        block = np.concatenate((self._tail, x))
+        self._tail = block[block.size - self._tail.size :]
+        return (sliding_window_view(block, self._phases.shape[0]) @ self._phases).reshape(-1)
+
+
+class Loudness:
+    """K-weighted loudness on 2 sections, BS.1770. One window gives the momentary value."""
+
+    def __init__(self, *, rate: int, window_ms: float = 0.0) -> None:
+        self._weight = Section(_k_weighting(rate))
+        self._window = np.zeros(round(window_ms * rate / 1000.0), dtype=np.float64)
+        self._at = 0
+        self._held = 0.0
+        self._square = 0.0
+        self._samples = 0
+
+    @property
+    def value(self) -> float:
+        """Gives loudness since one take, in LUFS."""
+        return lufs(self._square / self._samples if self._samples else 0.0)
+
+    def run(self, x: Samples) -> float:
+        """Takes one chunk. Gives window loudness, or interval loudness with no window."""
+        squares = np.square(self._weight.run(x).astype(np.float64))
+        self._square += float(squares.sum())
+        self._samples += x.size
+        if not self._window.size:
+            return self.value
+        return lufs(self._slide(squares) / self._window.size)
+
+    def _slide(self, squares: Samples) -> float:
+        """Writes one chunk into its ring, oldest first, and gives that window sum."""
+        size = self._window.size
+        if squares.size >= size:
+            self._window[:] = squares[-size:]
+            self._at, self._held = 0, float(self._window.sum())
+            return self._held
+        end = self._at + squares.size
+        if end <= size:
+            self._held += float(squares.sum() - self._window[self._at : end].sum())
+            self._window[self._at : end] = squares
+        else:
+            head = size - self._at
+            self._held += float(
+                squares.sum() - self._window[self._at :].sum() - self._window[: end - size].sum()
+            )
+            self._window[self._at :] = squares[:head]
+            self._window[: end - size] = squares[head:]
+        self._at = end % size
+        return self._held
+
+    def take(self) -> float:
+        """Gives loudness since one take, then clears it."""
+        taken = self.value
+        self._square, self._samples = 0.0, 0
+        return taken
+
+
+def lufs(mean_square: float) -> float:
+    """Gives loudness of one K-weighted mean square. Silence gives its floor."""
+    return _floor(OFFSET_LUFS + 10.0 * math.log10(mean_square)) if mean_square > 0.0 else SILENCE
+
+
+def dbfs(level: float) -> float:
+    """Gives one amplitude in dB. Silence gives the floor."""
+    return _floor(20.0 * math.log10(level)) if level > 0.0 else SILENCE
+
+
+def _floor(db: float) -> float:
+    """Holds one reading at the floor."""
+    return max(db, SILENCE)
+
+
+def row(
+    kind: Kind, *, rate: int, hz: float, q: float = 0.7071, gain_db: float = 0.0
+) -> tuple[float, ...]:
+    """Gives 6 coefficients of one section at this rate. A centre over its bound raises."""
+    bound = NYQUIST_RATIO * rate
+    if hz > bound:
+        raise ValueError(
+            f"hz: expected at most {bound} Hz at the rate {rate} Hz, got a centre over it"
+        )
+    w0 = 2.0 * math.pi * hz / rate
+    b, a = _cookbook(kind, w0=w0, alpha=math.sin(w0) / (2.0 * q), gain_db=gain_db)
+    return (*(value / a[0] for value in b), 1.0, a[1] / a[0], a[2] / a[0])
+
+
+def _peaks(x: Samples, size: int) -> Samples:
+    """Gives highest value of each block. Its last block repeats one edge."""
+    blocks = -(-x.size // size)
+    padded = np.pad(x, (0, blocks * size - x.size), mode="edge")
+    return padded.reshape(blocks, size).max(axis=1)
+
+
+def _pole(ms: float, per_second: float) -> float:
+    """Gives one pole of this time constant, at this step rate."""
+    return math.exp(-1000.0 / (ms * per_second)) if ms > 0.0 else 0.0
+
+
+def _cookbook(
+    kind: Kind, *, w0: float, alpha: float, gain_db: float
+) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
+    """Gives numerator and denominator of one kind."""
+    cos = math.cos(w0)
+    amp = 10.0 ** (gain_db / 40.0)
+    shelf = 2.0 * math.sqrt(amp) * alpha
+    match kind:
+        case "lowpass":
+            return ((1.0 - cos) / 2.0, 1.0 - cos, (1.0 - cos) / 2.0), _poles(cos, alpha)
+        case "highpass":
+            return ((1.0 + cos) / 2.0, -(1.0 + cos), (1.0 + cos) / 2.0), _poles(cos, alpha)
+        case "bandpass":
+            return (alpha, 0.0, -alpha), _poles(cos, alpha)
+        case "peak":
+            return (
+                (1.0 + alpha * amp, -2.0 * cos, 1.0 - alpha * amp),
+                (1.0 + alpha / amp, -2.0 * cos, 1.0 - alpha / amp),
+            )
+        case "lowshelf":
+            plus, minus = amp + 1.0, amp - 1.0
+            return (
+                (
+                    amp * (plus - minus * cos + shelf),
+                    2.0 * amp * (minus - plus * cos),
+                    amp * (plus - minus * cos - shelf),
+                ),
+                (
+                    plus + minus * cos + shelf,
+                    -2.0 * (minus + plus * cos),
+                    plus + minus * cos - shelf,
+                ),
+            )
+        case "highshelf":
+            plus, minus = amp + 1.0, amp - 1.0
+            return (
+                (
+                    amp * (plus + minus * cos + shelf),
+                    -2.0 * amp * (minus + plus * cos),
+                    amp * (plus + minus * cos - shelf),
+                ),
+                (
+                    plus - minus * cos + shelf,
+                    2.0 * (minus - plus * cos),
+                    plus - minus * cos - shelf,
+                ),
+            )
+
+
+def _poles(cos: float, alpha: float) -> tuple[float, float, float]:
+    """Gives one denominator each resonant kind shares."""
+    return (1.0 + alpha, -2.0 * cos, 1.0 - alpha)
+
+
+@cache
+def _k_weighting(rate: int) -> tuple[tuple[float, ...], ...]:
+    """Gives the K-weighting sections at this rate, from the published sections at K_RATE.
+
+    Each zero and pole moves through the s plane. The gain keeps the response at K_MATCH_HZ.
+    """
+    zeros, poles, gain = map(np.asarray, sos2zpk(K_SECTIONS))
+    zeros_at, poles_at = _moved(zeros, rate), _moved(poles, rate)
+    gain_at = gain * _response(zeros, poles, K_RATE) / _response(zeros_at, poles_at, rate)
+    return tuple(map(tuple, zpk2sos(zeros_at, poles_at, gain_at).tolist()))
+
+
+def _moved(roots: Roots, rate: int) -> Roots:
+    """Moves roots from K_RATE to this rate by the bilinear transform, through the s plane."""
+    s = 2.0 * K_RATE * (roots - 1.0) / (roots + 1.0)
+    return (2.0 * rate + s) / (2.0 * rate - s)
+
+
+def _response(zeros: Roots, poles: Roots, rate: int) -> float:
+    """Gives the unit gain magnitude of these roots at K_MATCH_HZ."""
+    z = cmath.exp(2j * math.pi * K_MATCH_HZ / rate)
+    return float(np.abs(np.prod(z - zeros) / np.prod(z - poles)))

pipecat_effects-0.1.0.dist-info/METADATA

@@ -0,0 +1,293 @@
+Metadata-Version: 2.4
+Name: pipecat-effects
+Version: 0.1.0
+Summary: Output audio effects for pipecat. One filter, 8 effects and a loudness meter.
+Keywords: pipecat,audio,effects,voice
+Author: Softcery
+License-Expression: BSD-2-Clause
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Typing :: Typed
+Requires-Dist: pipecat-ai>=1.10,<2
+Requires-Dist: numpy>=2.0
+Requires-Dist: scipy>=1.14
+Requires-Python: >=3.12
+Project-URL: Source, https://github.com/softcery/pipecat-effects
+Project-URL: Issues, https://github.com/softcery/pipecat-effects/issues
+Description-Content-Type: text/markdown
+
+# pipecat-effects
+
+Output audio effects for [pipecat](https://github.com/pipecat-ai/pipecat). One filter, 8 effects
+and one loudness meter. You build the chain. The chain adds 0 samples of latency.
+
+## Install
+
+```
+pip install pipecat-effects
+```
+
+## Use
+
+Pipecat 1.10.0 has no output filter field. `FilterMixer` runs the filter as the output mixer.
+
+```python
+from pipecat.transports.base_transport import TransportParams
+from pipecat_effects import (
+    AGC,
+    Biquad,
+    Compressor,
+    DeEsser,
+    Effects,
+    EffectsFilter,
+    FilterMixer,
+    Limiter,
+    Saturation,
+)
+
+CHAIN: Effects = (
+    AGC(target_lufs=-20.0),
+    Biquad(kind="highpass", hz=90.0),
+    Biquad(kind="lowshelf", hz=200.0, gain_db=2.5),
+    Biquad(kind="peak", hz=3200.0, q=1.2, gain_db=-2.0),
+    DeEsser(hz=6500.0, threshold_db=-32.0, ratio=4.0),
+    Compressor(threshold_db=-20.0, ratio=3.0, attack_ms=8.0, release_ms=120.0, makeup_db=2.0),
+    Saturation(drive=1.2, mix=0.15),
+    Limiter(ceiling_db=-1.0, knee_db=3.0),
+)
+CHANNELS = 1
+
+
+def transport_params() -> TransportParams:
+    return TransportParams(
+        audio_in_enabled=True,
+        audio_out_enabled=True,
+        audio_out_channels=CHANNELS,
+        audio_out_mixer=FilterMixer(EffectsFilter(CHAIN), channels=CHANNELS),
+    )
+```
+
+`examples/bot.py` runs one voice bot with that chain. It needs 4 pipecat extras and
+`OPENAI_API_KEY`. The wheel has no `examples/`, so run it from a clone of this repository.
+
+```
+pip install pipecat-effects "pipecat-ai[runner,webrtc,openai,silero]"
+python examples/bot.py
+```
+
+## Listen
+
+One sentence of Cartesia sonic-3.5 speech, 24 kHz mono, run in 40 ms chunks, the stock output
+chunk of pipecat. `examples/chains.py` holds each chain. `examples/clips.py` renders the clips
+with ffmpeg. GitHub mutes each player at load. Unmute it to listen. On PyPI each player is a
+link. Loudness is integrated, measured by ffmpeg `ebur128`.
+
+### Unprocessed
+
+https://github.com/user-attachments/assets/9b4a4b80-8168-4380-a12d-b98f9fdcaaa7
+
+No filter. -18.3 LUFS, -1.3 dBTP.
+
+### EQ and compression
+
+https://github.com/user-attachments/assets/33bbbafc-3627-416c-84f0-baf398f4922f
+
+The chain in [Use](#use): 2.5 dB low shelf at 200 Hz, 2 dB cut at 3.2 kHz, de-esser, 3:1
+compressor. -23.2 LUFS, -5.5 dBTP.
+
+### Telephone
+
+https://github.com/user-attachments/assets/6fff6b7a-ef53-44a1-b275-5e29ca4ab1bb
+
+300 Hz to 3400 Hz band, 4:1 compressor, drive 3.0 at 0.3 mix. -22.0 LUFS, -5.1 dBTP.
+
+### Broadcast
+
+https://github.com/user-attachments/assets/0e336600-fde6-4ddb-8210-bd74be7fe0b4
+
+100 Hz high-pass, de-esser, 4:1 compressor with 0.5 ms attack and 18 dB makeup, +4 dB at 3.5 kHz.
+-16.3 LUFS, -1.4 dBTP. Against the unprocessed clip: +2.0 LU, and +3.7 dB in the share of power
+from 2 to 4 kHz.
+
+### Room
+
+https://github.com/user-attachments/assets/6cbc794c-5a33-4cb4-a2be-ccfebffe1f79
+
+Schroeder reverb, 400 ms decay, 0.3 mix. -21.2 LUFS, -3.5 dBTP.
+
+## Build a chain
+
+- A chain is any sequence of effects. The filter runs them in order and adds no stage.
+- Build one filter per session. Each effect holds its state across chunks.
+- Put `AGC` first. It reads the level before any stage changes it.
+- If a chain ends without `Limiter`, the int16 cast hard clips each sample over full scale. End
+  each chain with `Limiter`.
+- Give `FilterMixer` the `audio_out_channels` value as `channels`. `start` raises over 1 channel.
+- Each effect validates its values at build time. A value outside the range raises `ValueError`
+  that names the field and the range.
+
+## Effects
+
+| effect | field | default | range |
+| --- | --- | --- | --- |
+| `Gain` | `db` | 0.0 | -60 to 24 |
+| `Biquad` | `kind` | required | one of lowpass, highpass, bandpass, peak, lowshelf, highshelf |
+| | `hz` | required | 10 to 20000 |
+| | `q` | 0.7071 | 0.1 to 20 |
+| | `gain_db` | 0.0 | -24 to 24 |
+| `Saturation` | `drive` | 2.0 | 0.1 to 20 |
+| | `mix` | 1.0 | 0 to 1 |
+| `Compressor` | `threshold_db` | -18.0 | -60 to 0 |
+| | `ratio` | 3.0 | 1 to 20 |
+| | `attack_ms` | 5.0 | 0 to 200 |
+| | `release_ms` | 80.0 | 1 to 2000 |
+| | `makeup_db` | 0.0 | -24 to 24 |
+| `AGC` | `target_lufs` | -20.0 | -40 to -10 |
+| | `max_db_per_second` | 6.0 | 0.1 to 20 |
+| `Limiter` | `ceiling_db` | -1.0 | -24 to 0 |
+| | `knee_db` | 3.0 | 0 to 12 |
+| `Reverb` | `decay_ms` | 200.0 | 10 to 500 |
+| | `mix` | 0.15 | 0 to 1 |
+| `DeEsser` | `hz` | 6500.0 | 1000 to 20000 |
+| | `q` | 1.5 | 0.1 to 20 |
+| | `threshold_db` | -30.0 | -60 to 0 |
+| | `ratio` | 4.0 | 1 to 20 |
+| | `attack_ms` | 1.0 | 0 to 200 |
+| | `release_ms` | 40.0 | 1 to 2000 |
+
+`mix` sets the dry/wet ratio. 0 gives only the input, the dry signal. 1 gives only the processed
+signal, the wet signal.
+
+Method of each effect:
+
+| effect | method |
+| --- | --- |
+| `Gain` | one multiply |
+| `Biquad` | one second-order section, Audio EQ Cookbook by Robert Bristow-Johnson |
+| `Saturation` | tanh waveshaper, `tanh(drive * x) / tanh(drive)`, dry/wet mix |
+| `Compressor` | one envelope follower |
+| `AGC` | K-weighted loudness over 400 ms, gain ramped at `max_db_per_second` or less |
+| `Limiter` | memoryless soft clipper, soft knee, hard ceiling on sample peaks |
+| `Reverb` | Schroeder reverberator, 4 comb filters and 2 allpass filters |
+| `DeEsser` | split-band, the envelope of one band-pass band sets the cut of that band |
+
+## Control
+
+Change the chain at runtime with 2 stock frames.
+
+```python
+from pipecat.frames.frames import MixerEnableFrame, MixerUpdateSettingsFrame
+from pipecat_effects import Gain, Limiter
+
+await worker.queue_frame(MixerEnableFrame(enable=False))
+await worker.queue_frame(MixerUpdateSettingsFrame(settings={"effects": (Gain(db=-3.0), Limiter())}))
+```
+
+- `MixerEnableFrame(enable=False)` bypasses the chain. The filter gives the input, and the chain
+  keeps running on it, so envelopes and delay lines stay current.
+- `MixerUpdateSettingsFrame` with an `effects` key builds a new chain and swaps it in.
+- Each change fades over one chunk, from the output last heard to the new output. If 2 updates
+  arrive before one chunk, the chain last heard fades to the last chain. The chain between them
+  is not heard.
+- `FilterMixer` maps the 2 mixer frames to `FilterEnableFrame` and `FilterUpdateSettingsFrame`.
+  Call `EffectsFilter.process_frame` with those 2 frames when you hold the filter directly.
+- An `effects` value outside a sequence of effects raises `TypeError` that names the field. An
+  item whose `start` gives no callable raises `TypeError` that names the field and the index.
+- A chain that fails to build raises `ValueError` that names the `effects` field. The old chain
+  keeps running.
+- An update before `start` builds at `start`. A failed build then raises at `start` and names the
+  field of the effect, not `effects`.
+
+## Meter
+
+```python
+reading = mixer.read()  # Reading(lufs=-19.92, dbtp=-1.04), or None on silence
+```
+
+- `FilterMixer` meters each chunk it gives to the transport, after the int16 cast.
+- `FilterMixer.read()` gives a `Reading` with `lufs` and `dbtp` since the last read, then clears
+  both. Silence gives `None`.
+- `lufs` is the K-weighted loudness of ITU-R BS.1770, the loudness standard. The published 48 kHz filter moves to the
+  session rate by the bilinear transform. A 997 Hz sine at 0 dBFS reads -3.01 LUFS.
+- `dbtp` is the true peak, on 4 times oversampling with 48 taps.
+- `Meter` reads float chunks for any other caller. Its `read` gives the floor, -120.0 dB, in
+  place of `None`.
+
+## Cost
+
+One 40 ms chunk at 24 kHz, the stock output chunk of pipecat. The 8 effect chain above, mean of
+1000 chunks, median of 4 runs. Python 3.13.9, macOS arm64.
+
+| path | mean | 95th |
+| --- | --- | --- |
+| filter | 0.245 ms | 0.265 ms |
+| mixer on silence with the meter | 0.315 ms | 0.347 ms |
+| true peak | 0.028 ms | 0.030 ms |
+| loudness and true peak | 0.063 ms | 0.069 ms |
+
+`python examples/bench.py --out rows.jsonl --sha <commit>` writes one row.
+
+## Limits
+
+### Chain
+
+- The filter runs on mono. `FilterMixer.start` raises on more than 1 channel.
+- The chain runs on each chunk, silence included, so attack and release stay continuous through
+  silence. At the stock `audio_out_10ms_chunks` of 4, one idle session costs 25 silent chunks of
+  40 ms a second, 7.9 ms of compute a second on the [Cost](#cost) machine.
+- A bypassed chain keeps running, so it costs the same as an active chain.
+- Outside a bypass, the chunk after an update runs the old chain and the new chain.
+- A chunk of 0 samples passes through. An odd byte count raises `ValueError` that names `audio`.
+- A `Biquad` or `DeEsser` centre over 0.45 of the sample rate raises at `start`, with the highest
+  allowed centre and the rate. The error names `hz`, not the effect.
+- At 8 kHz the highest centre is 3600 Hz. The chain in [Use](#use) raises there, since its
+  `DeEsser` sits at 6500 Hz.
+- Not included: lookahead, convolution, pitch shift, formant shift. The broadcast clip holds a
+  peak-to-loudness ratio, true peak minus loudness, of 14.9 dB. The unprocessed clip holds
+  17.0 dB. A hall reverb needs convolution.
+
+### Effects
+
+- `Compressor` and `DeEsser` set the gain of each 1 ms block from the peak of that block. `AGC`
+  sets one target per chunk from the loudness at the chunk end. Each gain reads ahead inside its
+  chunk, by up to 1 ms or 1 chunk.
+- `AGC` reads momentary loudness without the gate of BS.1770. Under -50 LUFS the gain holds.
+- `AGC` sets the level at its place in the chain. Later stages move the output level. The EQ and
+  compression clip holds `AGC(target_lufs=-20.0)` and measures -23.2 LUFS.
+- `Limiter` is a memoryless soft clipper. It has no attack or release, so a signal driven far
+  over the ceiling distorts.
+- The -1 dB ceiling leaves the margin for inter-sample peaks at a codec resampler. The true peak
+  meter only reports.
+- One section falls 12 dB per octave. A lowpass at 6000 Hz drops an 8 kHz tone by 10.0 dB at a
+  24 kHz rate.
+- `Reverb` takes `decay_ms` to 500.
+
+### Meter
+
+- The true peak meter cuts at the input Nyquist. At a 24 kHz rate it reads a 10 kHz sine 0.5 dB
+  under its peak.
+- The K-weighting at 8 kHz differs from the standard by 0.43 dB at most from 100 Hz to 3 kHz. At
+  24 kHz it differs by 0.040 dB at most.
+
+### Pipecat
+
+- With an output mixer, a flush that fails to drain does not time out. Each mixer chunk reaches
+  the pipeline sink and counts as progress. A flush that drains returns. The defect is in
+  pipecat 1.10.0 and holds for each output mixer.
+
+## Develop
+
+- The package ships a `py.typed` marker. It exports `Effect`, `Apply` and `Samples` for a caller
+  who writes an effect.
+- `make lint` checks the lock, the format, the lint rules, and the types with pyright.
+- `make test` runs the tests. `make test-lowest` runs them on the lowest allowed pipecat-ai,
+  numpy and scipy. CI runs both.
+- `make audit` checks `uv.lock` for known vulnerabilities.
+
+## License
+
+BSD 2-Clause.

pipecat_effects-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pipecat_effects/__init__.py,sha256=lWLjZazUv0cyS6w3im9XCpNoftiz8A7vTIL9dGFGp2Q,708
+pipecat_effects/effects.py,sha256=dprtCeYMeAZORXLq29U4p3RbM-saJkkX9qLGtG7Q_u4,9030
+pipecat_effects/filter.py,sha256=S-_Y_R0hhuLCmIxj10mgMHgFcGuf-P2qKub5vDFTg88,5589
+pipecat_effects/meter.py,sha256=3revxTOzk7OxhwSBgc6pR2mOGOHEtXrPrwP_SYm1uPM,1639
+pipecat_effects/mixer.py,sha256=ODSya3ykqHE0zE27YU3tl_GZLpTz-IEa3aeYmeAfNDw,2091
+pipecat_effects/primitives.py,sha256=ufeRyuYMZyDgFbWKTEoH_cvNvj3NqMqFsqVj_lZBN9o,11730
+pipecat_effects/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pipecat_effects-0.1.0.dist-info/licenses/LICENSE,sha256=uxp0LOugmvVcPDhABOnJ5zcRpoARpD5Zc0SZ73bM8b0,1301
+pipecat_effects-0.1.0.dist-info/WHEEL,sha256=-i9oRNYVXXZJUIYl5zclLIg6onEb0NLibTX34uln84w,81
+pipecat_effects-0.1.0.dist-info/METADATA,sha256=BhH6AYGV-hdQQ6YNtpBJY7lqMtXF1O_zv4fOp7Edyvc,11704
+pipecat_effects-0.1.0.dist-info/RECORD,,

pipecat_effects-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.13
+Root-Is-Purelib: true
+Tag: py3-none-any

pipecat_effects-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Softcery OÜ
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.