205 lines
6.5 KiB
Python
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,
|
|
)
|
|
)
|