"""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"}