"""Transkriptionswarteschlange. Eine Datei nach der anderen, Modell nur einmal geladen, Fehler einer Datei brechen den Lauf nicht ab. Der Status wird dauerhaft gespeichert, sodass ein Neustart an der letzten Stelle fortsetzt. """ from __future__ import annotations import time from dataclasses import dataclass, field from pathlib import Path from typing import Callable, Protocol from ..config import ProcessingConfig from ..core.models import AudioFileRecord, FileStatus from ..database.repository import Repository from ..utils.logging import get_logger from .models import TranscriptResult logger = get_logger("transcription.worker") class EngineProtocol(Protocol): """Minimal benoetigte Engine-Schnittstelle (fuer Tests austauschbar).""" model_name: str def transcribe(self, path: str | Path) -> TranscriptResult: ... @dataclass class WorkerEvent: """Ereignis fuer die Fortschrittsanzeige.""" kind: str # start | done | error | skipped | finished record: AudioFileRecord | None = None message: str | None = None elapsed: float = 0.0 audio_duration: float | None = None stats: "RunStats | None" = None @dataclass class RunStats: """Zusammenfassung eines Transkriptionslaufs.""" queued: int = 0 processed: int = 0 failed: int = 0 skipped: int = 0 audio_seconds: float = 0.0 elapsed: float = 0.0 model: str = "" device: str = "" compute_type: str = "" errors: list[tuple[str, str]] = field(default_factory=list) @property def rate(self) -> float: if self.elapsed <= 0: return 0.0 return self.audio_seconds / self.elapsed class TranscriptionWorker: """Verarbeitet die Transkriptionswarteschlange.""" def __init__( self, repository: Repository, engine: EngineProtocol, processing: ProcessingConfig | None = None, *, device: str = "", compute_type: str = "", ): self.repo = repository self.engine = engine self.processing = processing or ProcessingConfig() self.stats = RunStats( model=getattr(engine, "model_name", ""), device=device, compute_type=compute_type, ) # ------------------------------------------------------------------ def run( self, *, limit: int | None = None, force: bool = False, event_callback: Callable[[WorkerEvent], None] | None = None, ) -> RunStats: """Arbeitet die Warteschlange ab.""" if self.processing.resume: reset = self.repo.reset_stale_processing() if reset: logger.info("%d unterbrochene Eintraege zurueckgesetzt", reset) queue = self.repo.transcription_queue(force=force) if limit is not None: queue = queue[: max(0, int(limit))] self.stats.queued = len(queue) started_at = time.monotonic() try: for record in queue: self._process(record, event_callback) except KeyboardInterrupt: logger.warning("Transkription durch Benutzer abgebrochen") raise finally: self.stats.elapsed = time.monotonic() - started_at if event_callback: event_callback(WorkerEvent(kind="finished", stats=self.stats)) logger.info( "Transkription beendet: %d verarbeitet, %d Fehler, %d uebersprungen, " "%.1f s Audio in %.1f s (%.2fx Echtzeit)", self.stats.processed, self.stats.failed, self.stats.skipped, self.stats.audio_seconds, self.stats.elapsed, self.stats.rate, ) return self.stats # ------------------------------------------------------------------ def _process( self, record: AudioFileRecord, event_callback: Callable[[WorkerEvent], None] | None ) -> None: path = Path(record.path) if not path.is_file(): message = f"Datei nicht gefunden: {record.path}" self.repo.set_status(record.id, FileStatus.ERROR.value, message) self.stats.failed += 1 self.stats.errors.append((record.path, message)) if event_callback: event_callback(WorkerEvent(kind="error", record=record, message=message)) return self.repo.set_status(record.id, FileStatus.PROCESSING.value) if event_callback: event_callback(WorkerEvent(kind="start", record=record)) file_started = time.monotonic() try: result = self.engine.transcribe(path) if not result.segments: raise ValueError("Keine Sprache im Transkript erkannt") self.repo.save_transcript( record.id, language=result.language, model=result.model or self.engine.model_name, full_text=result.full_text, segments=result.segments, duration=result.duration or record.duration, ) except KeyboardInterrupt: self.repo.set_status(record.id, FileStatus.PENDING.value) raise except Exception as exc: elapsed = time.monotonic() - file_started message = f"{type(exc).__name__}: {exc}" logger.exception("Transkription fehlgeschlagen fuer %s", record.path) self.repo.set_status(record.id, FileStatus.ERROR.value, message) self.stats.failed += 1 self.stats.errors.append((record.path, message)) if event_callback: event_callback( WorkerEvent( kind="error", record=record, message=message, elapsed=elapsed, audio_duration=record.duration, ) ) return elapsed = time.monotonic() - file_started audio_duration = result.duration or record.duration or 0.0 self.stats.processed += 1 self.stats.audio_seconds += float(audio_duration or 0.0) logger.info( "Fertig: %s (%.1f s Audio, %.1f s Laufzeit, %d Segmente)", record.filename, audio_duration or 0.0, elapsed, len(result.segments), ) if event_callback: event_callback( WorkerEvent( kind="done", record=record, elapsed=elapsed, audio_duration=audio_duration, ) )