Files
live-app-translator/tests/test_pipeline.py
EJClaw c2e600fa3d
Some checks failed
Windows / verify (push) Has been cancelled
fix: GPU 로 모델을 못 올려도 CPU 로 시작 · cuBLAS 받는 중 정지하면 캡처를 켜지 않게
- preload_on_start(기본값)에서 모델 로드가 GPU 오류를 내면 ERROR 로 끝나던 것을,
  CPU 로 바꿔 다시 올리게 했다.
- cuBLAS 를 받는 중에 정지하면 받기는 계속되고, 끝난 뒤 캡처가 켜져 상태가 다시
  RUNNING 이 되던 것을 고쳤다. 시작 작업마다 전용 정지 이벤트를 넘기고, 받기는
  그 이벤트를 보고 멈추며, 시작 작업은 정지된 뒤에는 캡처·상태를 건드리지 않는다.

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

256 lines
8.4 KiB
Python

"""엔진 파이프라인을 가짜 모델로 끝까지 돌려본다 (GPU/오디오 장치 불필요)."""
from __future__ import annotations
import threading
import time
import numpy as np
import pytest
from livesub.audio.base import CaptureBackend, to_mono_16k
from livesub.config import AppConfig
from livesub.constants import SAMPLE_RATE
from livesub.core.engine import TranslationEngine
from livesub.models.asr import Transcript
class FakeCapture(CaptureBackend):
"""말-침묵-말-침묵 패턴을 즉시 흘려보낸다."""
name = "fake"
per_process = True
@staticmethod
def available() -> bool:
return True
@staticmethod
def list_sources():
return []
def _run(self) -> None:
def tone(ms, amp=0.35):
n = SAMPLE_RATE * ms // 1000
t = np.arange(n, dtype=np.float32) / SAMPLE_RATE
return (np.sin(2 * np.pi * 240 * t) * amp).astype(np.float32)
pattern = np.concatenate(
[np.zeros(SAMPLE_RATE // 5, np.float32), tone(900),
np.zeros(SAMPLE_RATE, np.float32)]
)
while not self._stop.is_set():
for i in range(0, pattern.size, 1600):
if self._stop.is_set():
return
self._emit(pattern[i : i + 1600].copy())
time.sleep(0.005)
class FakeRecognizer:
loaded = True
def load(self):
pass
def unload(self):
pass
def transcribe(self, audio, language=None, fast=False, prompt="", target_lang=None):
return Transcript(text="hello world", language="en", confidence=0.99)
class FakeTranslator:
loaded = True
def load(self):
pass
def unload(self):
pass
def translate(self, text, source_lang, target_lang, glossary=None, **kwargs):
# 실제 Translator 와 같은 키워드(speech_level, source_politeness)를 받는다.
self.last_kwargs = kwargs
return f"[{target_lang}] {text}"
@pytest.fixture
def engine(tmp_path, monkeypatch):
config = AppConfig()
config.models.preload_on_start = False
config.glossary.path = str(tmp_path / "glossary.json")
config.audio.partial_interval_ms = 0
config.audio.silence_ms = 300
config.audio.min_segment_ms = 200
lines = []
eng = TranslationEngine(config, on_line=lines.append)
monkeypatch.setattr(eng.models, "recognizer", lambda: FakeRecognizer())
monkeypatch.setattr(eng.models, "translator", lambda: FakeTranslator())
monkeypatch.setattr("livesub.core.engine.create_capture", lambda cfg: FakeCapture())
eng.lines = lines
yield eng
eng.shutdown()
def test_engine_produces_translated_lines(engine):
engine.start()
deadline = time.time() + 12
while time.time() < deadline and not engine.lines:
time.sleep(0.05)
engine.stop()
assert engine.lines, "12초 안에 자막이 한 줄도 나오지 않았습니다"
line = engine.lines[0]
assert line.source_text == "hello world"
assert line.translated_text == "[ko] hello world"
assert line.source_lang == "en"
assert line.is_final
assert line.latency_s >= 0
def test_stop_is_idempotent(engine):
engine.start()
time.sleep(0.3)
engine.stop()
engine.stop()
assert not engine.running
def test_to_mono_16k_downmixes_and_resamples():
stereo_48k = np.tile(np.array([1.0, -1.0], dtype=np.float32), 48_000)
out = to_mono_16k(stereo_48k, channels=2, src_rate=48_000)
assert out.dtype == np.float32
assert abs(out.size - 16_000) <= 2 # 1초 분량
assert np.allclose(out, 0.0, atol=1e-6) # L+R 이 상쇄
def test_to_mono_16k_passthrough_when_already_correct():
mono = np.linspace(-1, 1, 16_000, dtype=np.float32)
out = to_mono_16k(mono, channels=1, src_rate=16_000)
assert np.array_equal(out, mono)
class CublasMissingRecognizer(FakeRecognizer):
"""Windows exe 에서 cuBLAS 가 없을 때 CTranslate2 가 내는 오류를 흉내 낸다."""
def transcribe(self, *args, **kwargs):
raise RuntimeError("Library cublas64_12.dll is not found or cannot be loaded")
def _wait_for(predicate, timeout=12.0):
deadline = time.time() + timeout
while time.time() < deadline and not predicate():
time.sleep(0.05)
return predicate()
def test_gpu_failure_falls_back_to_cpu_and_still_produces_lines(engine, monkeypatch):
statuses = []
engine._on_status = statuses.append
monkeypatch.setattr(
engine.models,
"recognizer",
lambda: CublasMissingRecognizer() if engine.models.device == "cuda" else FakeRecognizer(),
)
assert engine.models.device == "cuda"
engine.start()
assert _wait_for(lambda: engine.lines), "CPU 로 바꾼 뒤에도 자막이 나오지 않았습니다"
engine.stop()
assert engine.models.device == "cpu"
assert engine.config.models.device == "cuda", "설정 파일 값은 그대로 둬야 한다"
assert any("CPU로" in s.message and "cublas" in s.message for s in statuses)
def test_non_gpu_failure_is_shown_on_status(engine, monkeypatch):
statuses = []
engine._on_status = statuses.append
class Broken(FakeRecognizer):
def transcribe(self, *args, **kwargs):
raise ValueError("토크나이저가 깨졌습니다")
monkeypatch.setattr(engine.models, "recognizer", lambda: Broken())
engine.start()
assert _wait_for(lambda: any("문장 처리 실패" in s.message for s in statuses))
engine.stop()
assert engine.models.device == "cuda", "GPU 와 상관없는 오류로 CPU 로 바꾸면 안 된다"
assert any("토크나이저가 깨졌습니다" in s.message for s in statuses)
def test_gpu_runtime_download_failure_runs_on_cpu(engine, monkeypatch):
statuses = []
engine._on_status = statuses.append
def fail(*args, **kwargs):
raise OSError("네트워크 연결 없음")
monkeypatch.setattr("livesub.core.engine.cuda_runtime.ensure", fail)
engine.start()
assert _wait_for(lambda: engine.lines)
engine.stop()
assert engine.models.device == "cpu"
running = [s for s in statuses if s.state.value == "running"]
assert running and "GPU 계산 파일을 받지 못했습니다" in running[0].message
def test_gpu_failure_while_preloading_falls_back_to_cpu(engine, monkeypatch):
"""기본값(preload_on_start=True)에서 GPU 로 모델이 안 올라가도 CPU 로 시작한다."""
statuses = []
engine._on_status = statuses.append
engine.config.models.preload_on_start = True
devices = []
def preload(progress=None):
devices.append(engine.models.device)
if engine.models.device == "cuda":
raise RuntimeError("CUDA failed with error no CUDA-capable device is detected")
monkeypatch.setattr(engine.models, "preload", preload)
engine.start()
assert _wait_for(lambda: engine.lines), "CPU 로 바꾼 뒤에도 자막이 나오지 않았습니다"
engine.stop()
assert devices == ["cuda", "cpu"]
assert not any(s.state.value == "error" for s in statuses)
running = [s for s in statuses if s.state.value == "running"]
assert running and "CPU로" in running[0].message
def test_stop_while_downloading_gpu_runtime_never_starts_capture(engine, monkeypatch):
"""cuBLAS 를 받는 중에 정지하면 받기를 멈추고, 캡처를 켜지 않는다."""
from livesub.models.cuda_runtime import DownloadCancelled
statuses = []
engine._on_status = statuses.append
downloading = threading.Event()
captures = []
def slow_download(progress=None, device="cuda", cancel=None):
downloading.set()
while not cancel.is_set():
progress("GPU 계산 파일 받는 중", 0.1)
time.sleep(0.05)
raise DownloadCancelled("멈춤")
def make_capture(cfg):
captures.append(cfg)
return FakeCapture()
monkeypatch.setattr("livesub.core.engine.cuda_runtime.ensure", slow_download)
monkeypatch.setattr("livesub.core.engine.create_capture", make_capture)
engine.start()
assert downloading.wait(5)
engine.stop()
boot_done = _wait_for(lambda: not any(t.name == "engine-boot" for t in threading.enumerate()), 5)
time.sleep(0.3)
assert boot_done, "정지했는데 시작 작업이 끝나지 않았습니다"
assert captures == [], "정지한 뒤에 캡처가 켜졌습니다"
assert engine.status.state.value == "idle"
assert statuses[-1].state.value == "idle"
assert engine.models.device == "cuda", "정지는 GPU 실패가 아니다"