Files
sjmusicsearch/sjaudiosearch/transcription/worker.py
T
2026-11-16 16:29:32 +01:00

205 lines
6.5 KiB
Python

"""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,
)
)