Files
javis_bot/tests/test_voice_worker_segmenter.py
javis-bot a7685e9078 feat(voice_worker): M1 multi-speaker streaming STT and sentence TTS over a local WebSocket
- One shared faster-whisper model for every speaker, batched; finals go before partials and
  partial batches are capped at two so a final never waits behind a ten-speaker pass.
- Per-speaker 48k stereo to 16k mono conversion, streaming Silero VAD, utterance ends on VAD
  silence, Discord speaking_end, missing audio, or the 28 s Whisper window.
- MeloTTS in its own venv through a child process; sentences stream out one chunk each, with
  incremental text, cancel and failure reporting.
- Loopback-only server with a token from the environment; logs carry no transcript text.
- Spec in src/voice_worker/voice_worker.spec.md; unit tests with fake engines and an opt-in
  real-GPU test that streams ten speakers at once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 10:00:06 +09:00

192 lines
5.5 KiB
Python

"""Voice worker: per-speaker utterance segmentation (start, partial cadence, the four end reasons).
The fake VAD reads the speech probability straight off the audio: a window of constant amplitude
0.9 is "speech at 0.9". That keeps the tests about the segmentation rules, not about Silero.
"""
from __future__ import annotations
import numpy as np
import pytest
from voice_worker.segmenter import Final, Partial, Segmenter, SpeechStart
from voice_worker.settings import SttSettings
SR = 16000
FRAME_MS = 20
class AmplitudeVad:
def prob(self, window: np.ndarray) -> float:
return float(np.max(np.abs(window)))
class Feeder:
def __init__(self, settings: SttSettings | None = None):
self.settings = settings or SttSettings()
self.seg = Segmenter(AmplitudeVad(), self.settings)
self.now = 100.0
self.events: list = []
def feed(self, level: float, ms: int) -> list:
got = []
for _ in range(ms // FRAME_MS):
self.now += FRAME_MS / 1000
got += self.seg.push(np.full(SR * FRAME_MS // 1000, level, dtype=np.float32), self.now)
self.events += got
return got
def of(self, cls) -> list:
return [e for e in self.events if isinstance(e, cls)]
@pytest.mark.unit
def test_silence_produces_nothing():
f = Feeder()
f.feed(0.0, 3000)
assert f.events == []
@pytest.mark.unit
def test_speech_then_silence_ends_with_one_final():
f = Feeder()
f.feed(0.0, 500)
f.feed(0.9, 1000)
f.feed(0.0, 500)
starts, finals = f.of(SpeechStart), f.of(Final)
assert [s.utt for s in starts] == [1]
assert len(finals) == 1
fin = finals[0]
assert fin.utt == 1 and fin.reason == "silence"
# Pre-roll (<= 200 ms) + 1 s speech + trailing silence capped at 200 ms.
assert 1.0 <= len(fin.audio) / SR <= 1.45
assert fin.audio.dtype == np.float32
@pytest.mark.unit
def test_final_waits_for_the_configured_silence():
f = Feeder(SttSettings(end_silence_ms=600))
f.feed(0.9, 800)
f.feed(0.0, 400)
assert f.of(Final) == []
f.feed(0.0, 300)
assert len(f.of(Final)) == 1
@pytest.mark.unit
def test_changed_settings_apply_to_the_running_utterance():
f = Feeder(SttSettings(end_silence_ms=1500))
f.feed(0.9, 800)
f.settings.update({"end_silence_ms": 200})
f.feed(0.0, 300)
assert [e.reason for e in f.of(Final)] == ["silence"]
@pytest.mark.unit
def test_a_short_blip_is_dropped_without_any_message():
f = Feeder()
f.feed(0.9, 120)
f.feed(0.0, 1000)
assert f.events == []
@pytest.mark.unit
def test_hysteresis_keeps_speech_going_but_never_starts_it():
f = Feeder()
f.feed(0.4, 1000)
assert f.events == []
f.feed(0.9, 400)
f.feed(0.4, 1000) # below the start threshold but above the keep threshold
assert f.of(Final) == []
f.feed(0.0, 400)
assert len(f.of(Final)) == 1
@pytest.mark.unit
def test_speaking_end_closes_the_utterance_at_once():
f = Feeder()
f.feed(0.9, 700)
events = f.seg.speaking_end(f.now)
assert [type(e) for e in events] == [Final]
assert events[0].reason == "speaking_end"
assert events[0].decided_at == f.now
@pytest.mark.unit
def test_speaking_end_after_a_blip_sends_nothing():
f = Feeder()
f.feed(0.9, 100)
assert f.seg.speaking_end(f.now) == []
@pytest.mark.unit
def test_audio_that_stops_arriving_ends_as_idle():
f = Feeder()
f.feed(0.9, 700)
assert f.seg.tick(f.now + 0.2) == []
events = f.seg.tick(f.now + 0.31)
assert [e.reason for e in events] == ["idle"]
assert f.seg.tick(f.now + 1.0) == []
@pytest.mark.unit
def test_long_speech_is_cut_at_the_whisper_window_and_continues_as_a_new_utterance():
f = Feeder()
f.feed(0.9, 29_000)
finals = f.of(Final)
assert [e.reason for e in finals] == ["max_length"]
assert len(finals[0].audio) / SR <= 28.0
assert [s.utt for s in f.of(SpeechStart)] == [1, 2]
@pytest.mark.unit
def test_partials_follow_the_interval_and_grow():
f = Feeder(SttSettings(partial_interval_ms=400))
f.feed(0.9, 2000)
partials = f.of(Partial)
assert 3 <= len(partials) <= 5
lengths = [len(p.audio) for p in partials]
assert lengths == sorted(lengths) and len(set(lengths)) == len(lengths)
assert all(p.utt == 1 for p in partials)
f.feed(0.0, 400)
n = len(f.of(Partial))
f.feed(0.0, 1000)
assert len(f.of(Partial)) == n # nothing after the final
@pytest.mark.unit
def test_no_partials_before_speech_start():
f = Feeder(SttSettings(partial_interval_ms=100))
f.feed(0.9, 200)
assert f.of(Partial) == []
@pytest.mark.unit
def test_utterance_numbers_count_up_per_speaker():
f = Feeder()
for _ in range(3):
f.feed(0.9, 500)
f.feed(0.0, 400)
assert [e.utt for e in f.of(Final)] == [1, 2, 3]
@pytest.mark.unit
@pytest.mark.parametrize("bad", [{"end_silence_ms": 50}, {"end_silence_ms": 5000}, {"final_beam": 0},
{"final_beam": 9}, {"partials": "yes"}, {"hotwords": "자비스"},
{"language": 3}, {"partial_interval_ms": 10}, {"nope": 1}])
def test_bad_settings_are_refused_and_change_nothing(bad):
s = SttSettings()
before = s.as_dict()
with pytest.raises(ValueError):
s.update(bad)
assert s.as_dict() == before
@pytest.mark.unit
def test_settings_accept_null_language_and_hotword_lists():
s = SttSettings()
s.update({"language": None, "hotwords": ["자비스", "Jarvis"], "partials": False})
assert s.as_dict()["language"] is None
assert s.hotwords == ("자비스", "Jarvis")
assert s.partials is False