248 lines
8.1 KiB
Python
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"}
|