Files
sjmusicsearch/tests/test_transcription.py
T
2026-11-16 16:29:32 +01:00

248 lines
8.1 KiB
Python

"""Tests fuer Transkriptionswarteschlange, Wiederaufnahme und GPU-Diagnose."""
from __future__ import annotations
from pathlib import Path
import pytest
from sjaudiosearch.config import ProcessingConfig
from sjaudiosearch.core.models import FileStatus
from sjaudiosearch.system.gpu import (
GpuInfo,
RuntimeInfo,
resolve_execution,
)
from sjaudiosearch.transcription.models import TranscriptResult, TranscriptSegment, WordToken
from sjaudiosearch.transcription.worker import TranscriptionWorker
class FakeEngine:
"""Ersetzt faster-whisper; laedt nie ein Modell und braucht kein Netzwerk."""
model_name = "fake-model"
def __init__(self, fail_for: set[str] | None = None):
self.fail_for = fail_for or set()
self.calls: list[str] = []
def transcribe(self, path: str | Path) -> TranscriptResult:
name = Path(path).name
self.calls.append(name)
if name in self.fail_for:
raise RuntimeError("Simulierter Decoderfehler")
words = [
WordToken(word="Der", start=0.0, end=0.4),
WordToken(word="Schlüssel", start=0.4, end=1.0),
WordToken(word="liegt", start=1.0, end=1.4),
WordToken(word="im", start=1.4, end=1.6),
WordToken(word="alten", start=1.6, end=2.0),
WordToken(word="Haus.", start=2.0, end=2.6),
]
segment = TranscriptSegment(
text="Der Schlüssel liegt im alten Haus.",
start=0.0,
end=2.6,
confidence=0.95,
words=words,
)
return TranscriptResult(
segments=[segment],
full_text=segment.text,
language="de",
language_probability=0.99,
duration=10.0,
model=self.model_name,
)
def test_worker_transcribes_and_indexes(repo, add_audio, make_wav, search_config):
record = add_audio(make_wav("folge1.wav"))
engine = FakeEngine()
worker = TranscriptionWorker(repo, engine, ProcessingConfig())
stats = worker.run()
assert stats.queued == 1
assert stats.processed == 1
assert stats.failed == 0
assert engine.calls == ["folge1.wav"]
updated = repo.get_audio(record.id)
assert updated.status == FileStatus.DONE.value
transcript = repo.get_transcript(record.id)
assert transcript is not None
assert transcript["model"] == "fake-model"
from sjaudiosearch.search.engine import SearchEngine
hits = SearchEngine(repo, search_config).search("Schlüssel liegt im alten Haus")
assert hits and hits[0].audio_id == record.id
def test_worker_isolates_errors(repo, add_audio, make_wav):
good = add_audio(make_wav("good.wav"))
bad = add_audio(make_wav("bad.wav"))
engine = FakeEngine(fail_for={"bad.wav"})
worker = TranscriptionWorker(repo, engine, ProcessingConfig())
stats = worker.run()
assert stats.queued == 2
assert stats.processed == 1
assert stats.failed == 1
assert stats.errors[0][0].endswith("bad.wav")
assert repo.get_audio(good.id).status == "done"
failed = repo.get_audio(bad.id)
assert failed.status == "error"
assert "Simulierter Decoderfehler" in failed.error_message
def test_worker_skips_done_and_resumes(repo, add_audio, make_wav):
record = add_audio(make_wav("done.wav"), status="done")
engine = FakeEngine()
worker = TranscriptionWorker(repo, engine, ProcessingConfig())
stats = worker.run()
assert stats.queued == 0
assert engine.calls == []
stats_forced = worker.run(force=True)
assert stats_forced.queued == 1
assert engine.calls == ["done.wav"]
assert repo.get_audio(record.id).status == "done"
def test_worker_resets_stale_processing(repo, add_audio, make_wav):
record = add_audio(make_wav("haengt.wav"), status="processing")
worker = TranscriptionWorker(repo, FakeEngine(), ProcessingConfig(resume=True))
stats = worker.run()
assert stats.processed == 1
assert repo.get_audio(record.id).status == "done"
def test_worker_limits_queue(repo, add_audio, make_wav):
for index in range(3):
add_audio(make_wav(f"folge{index}.wav"))
engine = FakeEngine()
worker = TranscriptionWorker(repo, engine, ProcessingConfig())
stats = worker.run(limit=2)
assert stats.queued == 2
assert len(engine.calls) == 2
def test_failed_transcription_can_be_retried(repo, add_audio, make_wav):
record = add_audio(make_wav("retry.wav"))
failing = TranscriptionWorker(repo, FakeEngine(fail_for={"retry.wav"}), ProcessingConfig())
failing.run()
assert repo.get_audio(record.id).status == "error"
assert repo.reset_errors() == 1
retrying = TranscriptionWorker(repo, FakeEngine(), ProcessingConfig())
stats = retrying.run()
assert stats.processed == 1
assert repo.get_audio(record.id).status == "done"
def test_worker_marks_missing_file(repo, add_audio):
record = add_audio("/tmp/gibt-es-nicht-mehr.mp3")
Path(record.path).unlink(missing_ok=True)
stats = TranscriptionWorker(repo, FakeEngine(), ProcessingConfig()).run()
assert stats.failed == 1
assert repo.get_audio(record.id).status == "error"
def test_worker_events_are_emitted(repo, add_audio, make_wav):
add_audio(make_wav("event.wav"))
events = []
TranscriptionWorker(repo, FakeEngine(), ProcessingConfig()).run(event_callback=events.append)
kinds = [event.kind for event in events]
assert kinds[0] == "start"
assert "done" in kinds
assert kinds[-1] == "finished"
# ----------------------------------------------------------------------
# GPU-/Ausfuehrungsdiagnose (reine Funktionen, keine echte GPU noetig)
# ----------------------------------------------------------------------
def _pascal_gpu() -> GpuInfo:
return GpuInfo(
name="NVIDIA GeForce GTX 1070 Ti",
driver_version="580.196.07",
cuda_driver_version="13.0",
memory_total_mb=8192,
compute_capability="6.1",
)
def _runtime(**overrides) -> RuntimeInfo:
runtime = RuntimeInfo(
ctranslate2_version="4.9.0",
cuda_device_count=1,
supported_compute_types={
"cpu": ["float32", "int16", "int8", "int8_float32"],
"cuda": ["float32", "int8", "int8_float32"],
},
cuda_libraries=["/usr/lib/libcudart.so.12"],
cudnn_libraries=["/usr/lib/libcudnn.so.9"],
python_version="3.13.15",
platform="Linux",
sqlite_version="3.50.0",
fts5_available=True,
trigram_available=True,
)
for key, value in overrides.items():
setattr(runtime, key, value)
return runtime
def test_pascal_uses_int8_float32():
resolved = resolve_execution("cuda", "int8_float32", _pascal_gpu(), _runtime())
assert resolved.device == "cuda"
assert resolved.compute_type == "int8_float32"
assert not resolved.used_fallback
def test_diagnostics_rejects_float16_on_incompatible_gpu():
resolved = resolve_execution("cuda", "float16", _pascal_gpu(), _runtime())
assert resolved.compute_type != "float16"
assert resolved.compute_type == "int8_float32"
assert any("Pascal" in note for note in resolved.notes)
def test_diagnostics_falls_back_when_int8_float32_unsupported():
runtime = _runtime(
supported_compute_types={"cpu": ["float32", "int8"], "cuda": ["float32"]}
)
resolved = resolve_execution("cuda", "int8_float32", _pascal_gpu(), runtime)
assert resolved.compute_type == "float32"
assert resolved.device == "cuda"
def test_cpu_fallback_when_cuda_unavailable():
runtime = _runtime(
cuda_device_count=0,
supported_compute_types={"cpu": ["float32", "int8"], "cuda": []},
)
resolved = resolve_execution("cuda", "int8_float32", None, runtime)
assert resolved.device == "cpu"
assert resolved.used_fallback
assert resolved.compute_type in {"int8", "int8_float32", "float32"}
assert any("CPU" in note for note in resolved.notes)
def test_cpu_mode_never_returns_gpu_compute_type():
resolved = resolve_execution("cpu", "float16", _pascal_gpu(), _runtime())
assert resolved.device == "cpu"
assert resolved.compute_type not in {"float16", "bfloat16"}