karaoke-gen 0.76.20__py3-none-any.whl → 0.81.1__py3-none-any.whl

lyrics_transcriber/frontend/src/components/shared/components/HighlightedText.tsx

@@ -1,4 +1,4 @@
-import { Typography, Box } from '@mui/material'
+import { Typography, Box, useMediaQuery, useTheme } from '@mui/material'
 import { WordComponent } from './Word'
 import { useWordClick } from '../hooks/useWordClick'
 import {
@@ -16,6 +16,7 @@ import React from 'react'
 import ContentCopyIcon from '@mui/icons-material/ContentCopy'
 import IconButton from '@mui/material/IconButton'
 import { getWordsFromIds } from '../utils/wordUtils'
+import CorrectedWordWithActions from '../../CorrectedWordWithActions'
 
 export interface HighlightedTextProps {
     text?: string
@@ -36,6 +37,12 @@ export interface HighlightedTextProps {
     gaps?: GapSequence[]
     flashingHandler?: string | null
     corrections?: WordCorrection[]
+    // Review mode props for agentic corrections
+    reviewMode?: boolean
+    onRevertCorrection?: (wordId: string) => void
+    onEditCorrection?: (wordId: string) => void
+    onAcceptCorrection?: (wordId: string) => void
+    onShowCorrectionDetail?: (wordId: string) => void
 }
 
 export function HighlightedText({
@@ -57,7 +64,15 @@ export function HighlightedText({
     gaps = [],
     flashingHandler,
     corrections = [],
+    reviewMode = false,
+    onRevertCorrection,
+    onEditCorrection,
+    onAcceptCorrection,
+    onShowCorrectionDetail,
 }: HighlightedTextProps) {
+    const theme = useTheme()
+    const isMobile = useMediaQuery(theme.breakpoints.down('sm'))
+
     const { handleWordClick } = useWordClick({
         mode,
         onElementClick,
@@ -157,43 +172,83 @@ export function HighlightedText({
 
     const renderContent = () => {
         if (wordPositions && !segments) {
-            return wordPositions.map((wordPos, index) => (
-                <React.Fragment key={wordPos.word.id}>
-                    <WordComponent
-                        key={`${wordPos.word.id}-${index}`}
-                        word={wordPos.word.text}
-                        shouldFlash={shouldWordFlash(wordPos)}
-                        isAnchor={wordPos.type === 'anchor'}
-                        isCorrectedGap={wordPos.isCorrected}
-                        isUncorrectedGap={wordPos.type === 'gap' && !wordPos.isCorrected}
-                        isCurrentlyPlaying={shouldHighlightWord(wordPos)}
-                        onClick={() => handleWordClick(
-                            wordPos.word.text,
-                            wordPos.word.id,
-                            wordPos.type === 'anchor' ? wordPos.sequence as AnchorSequence : undefined,
-                            wordPos.type === 'gap' ? wordPos.sequence as GapSequence : undefined
-                        )}
-                        correction={(() => {
-                            const correction = corrections?.find(c => 
-                                c.corrected_word_id === wordPos.word.id || 
-                                c.word_id === wordPos.word.id
-                            );
-                            return correction ? {
+            return wordPositions.map((wordPos, index) => {
+                // Find correction for this word
+                const correction = corrections?.find(c =>
+                    c.corrected_word_id === wordPos.word.id ||
+                    c.word_id === wordPos.word.id
+                );
+
+                // Use CorrectedWordWithActions for agentic corrections
+                if (correction && correction.handler === 'AgenticCorrector') {
+                    return (
+                        <React.Fragment key={wordPos.word.id}>
+                            <CorrectedWordWithActions
+                                word={wordPos.word.text}
+                                originalWord={correction.original_word}
+                                correction={{
+                                    originalWord: correction.original_word,
+                                    handler: correction.handler,
+                                    confidence: correction.confidence,
+                                    source: correction.source,
+                                    reason: correction.reason
+                                }}
+                                shouldFlash={shouldWordFlash(wordPos)}
+                                showActions={reviewMode && !isMobile}
+                                onRevert={() => onRevertCorrection?.(wordPos.word.id)}
+                                onEdit={() => onEditCorrection?.(wordPos.word.id)}
+                                onAccept={() => onAcceptCorrection?.(wordPos.word.id)}
+                                onClick={() => {
+                                    if (isMobile) {
+                                        onShowCorrectionDetail?.(wordPos.word.id)
+                                    } else {
+                                        handleWordClick(
+                                            wordPos.word.text,
+                                            wordPos.word.id,
+                                            wordPos.type === 'anchor' ? wordPos.sequence as AnchorSequence : undefined,
+                                            wordPos.type === 'gap' ? wordPos.sequence as GapSequence : undefined
+                                        )
+                                    }
+                                }}
+                            />
+                            {index < wordPositions.length - 1 && ' '}
+                        </React.Fragment>
+                    );
+                }
+
+                // Default rendering with WordComponent
+                return (
+                    <React.Fragment key={wordPos.word.id}>
+                        <WordComponent
+                            key={`${wordPos.word.id}-${index}`}
+                            word={wordPos.word.text}
+                            shouldFlash={shouldWordFlash(wordPos)}
+                            isAnchor={wordPos.type === 'anchor'}
+                            isCorrectedGap={wordPos.isCorrected}
+                            isUncorrectedGap={wordPos.type === 'gap' && !wordPos.isCorrected}
+                            isCurrentlyPlaying={shouldHighlightWord(wordPos)}
+                            onClick={() => handleWordClick(
+                                wordPos.word.text,
+                                wordPos.word.id,
+                                wordPos.type === 'anchor' ? wordPos.sequence as AnchorSequence : undefined,
+                                wordPos.type === 'gap' ? wordPos.sequence as GapSequence : undefined
+                            )}
+                            correction={correction ? {
                                 originalWord: correction.original_word,
                                 handler: correction.handler,
                                 confidence: correction.confidence,
                                 source: correction.source,
                                 reason: correction.reason
-                            } : null;
-                        })()}
-                    />
-                    {index < wordPositions.length - 1 && ' '}
-                </React.Fragment>
-            ))
+                            } : null}
+                        />
+                        {index < wordPositions.length - 1 && ' '}
+                    </React.Fragment>
+                );
+            })
         } else if (segments) {
             return segments.map((segment) => (
-                <Box key={segment.id} sx={{ 
-                    display: 'flex', 
+                <Box key={segment.id} sx={{
+                    display: 'flex',
                     alignItems: 'flex-start',
                     mb: 0
                 }}>
@@ -212,12 +267,44 @@ export function HighlightedText({
 
                             const sequence = wordPos?.type === 'gap' ? wordPos.sequence as GapSequence : undefined;
 
-                            // Find correction information for the tooltip
-                            const correction = corrections?.find(c => 
-                                c.corrected_word_id === word.id || 
+                            // Find correction information
+                            const correction = corrections?.find(c =>
+                                c.corrected_word_id === word.id ||
                                 c.word_id === word.id
                             );
-                            
+
+                            // Use CorrectedWordWithActions for agentic corrections
+                            if (correction && correction.handler === 'AgenticCorrector') {
+                                return (
+                                    <React.Fragment key={word.id}>
+                                        <CorrectedWordWithActions
+                                            word={word.text}
+                                            originalWord={correction.original_word}
+                                            correction={{
+                                                originalWord: correction.original_word,
+                                                handler: correction.handler,
+                                                confidence: correction.confidence,
+                                                source: correction.source,
+                                                reason: correction.reason
+                                            }}
+                                            shouldFlash={shouldWordFlash(wordPos || { word: word.text, id: word.id })}
+                                            showActions={reviewMode && !isMobile}
+                                            onRevert={() => onRevertCorrection?.(word.id)}
+                                            onEdit={() => onEditCorrection?.(word.id)}
+                                            onAccept={() => onAcceptCorrection?.(word.id)}
+                                            onClick={() => {
+                                                if (isMobile) {
+                                                    onShowCorrectionDetail?.(word.id)
+                                                } else {
+                                                    handleWordClick(word.text, word.id, anchor, sequence)
+                                                }
+                                            }}
+                                        />
+                                        {wordIndex < segment.words.length - 1 && ' '}
+                                    </React.Fragment>
+                                );
+                            }
+
                             const correctionInfo = correction ? {
                                 originalWord: correction.original_word,
                                 handler: correction.handler,

lyrics_transcriber/frontend/src/components/shared/types.ts

@@ -85,6 +85,12 @@ export interface TranscriptionViewProps {
     anchors?: AnchorSequence[]
     flashingHandler?: string | null
     onDataChange?: (updatedData: CorrectionData) => void
+    // Review mode props for agentic corrections
+    reviewMode?: boolean
+    onRevertCorrection?: (wordId: string) => void
+    onEditCorrection?: (wordId: string) => void
+    onAcceptCorrection?: (wordId: string) => void
+    onShowCorrectionDetail?: (wordId: string) => void
 }
 
 // Add LinePosition type here since it's used in multiple places

lyrics_transcriber/output/generator.py

@@ -52,7 +52,7 @@ class OutputGenerator:
 
         self.logger.info(f"Initializing OutputGenerator with config: {self.config}")
 
-        # Load output styles from JSON if provided
+        # Load output styles from JSON if provided, otherwise use defaults
         if self.config.output_styles_json and os.path.exists(self.config.output_styles_json):
             try:
                 with open(self.config.output_styles_json, "r") as f:
@@ -67,9 +67,10 @@ class OutputGenerator:
                     self.logger.warning(f"Failed to load output styles file: {str(e)}")
                     self.config.styles = {}
         else:
-            # No styles file provided or doesn't exist
+            # No styles file provided or doesn't exist - use defaults
             if self.config.render_video or self.config.generate_cdg:
-                raise ValueError(f"Output styles file required for video/CDG generation but not found: {self.config.output_styles_json}")
+                self.logger.info("No output styles file provided, using default karaoke styles")
+                self.config.styles = self._get_default_styles()
             else:
                 self.config.styles = {}
 
@@ -242,6 +243,52 @@ class OutputGenerator:
 
         return resolution_dims, font_size, line_height
 
+    def _get_default_styles(self) -> dict:
+        """Get default styles for video/CDG generation when no styles file is provided."""
+        return {
+            "karaoke": {
+                # Video background
+                "background_color": "#000000",
+                "background_image": None,
+                # Font settings
+                "font": "Arial",
+                "font_path": "",  # Must be string, not None (for ASS generator)
+                "ass_name": "Default",
+                # Colors in "R, G, B, A" format (required by ASS)
+                "primary_color": "112, 112, 247, 255",
+                "secondary_color": "255, 255, 255, 255",
+                "outline_color": "26, 58, 235, 255",
+                "back_color": "0, 0, 0, 0",
+                # Boolean style options
+                "bold": False,
+                "italic": False,
+                "underline": False,
+                "strike_out": False,
+                # Numeric style options (all required for ASS)
+                "scale_x": 100,
+                "scale_y": 100,
+                "spacing": 0,
+                "angle": 0.0,
+                "border_style": 1,
+                "outline": 1,
+                "shadow": 0,
+                "margin_l": 0,
+                "margin_r": 0,
+                "margin_v": 0,
+                "encoding": 0,
+                # Layout settings
+                "max_line_length": 40,
+                "top_padding": 200,
+                "font_size": 100,
+            },
+            "cdg": {
+                "font_path": None,
+                "instrumental_background": None,
+                "title_screen_background": None,
+                "outro_background": None,
+            },
+        }
+
     def write_corrections_data(self, correction_result: CorrectionResult, output_prefix: str) -> str:
         """Write corrections data to JSON file."""
         self.logger.info("Writing corrections data JSON")

lyrics_transcriber/transcribers/local_whisper.py

@@ -0,0 +1,260 @@
+"""Local Whisper transcription service using whisper-timestamped for word-level timestamps."""
+
+from dataclasses import dataclass
+import os
+import logging
+from typing import Optional, Dict, Any, Union
+from pathlib import Path
+
+from lyrics_transcriber.types import TranscriptionData, LyricsSegment, Word
+from lyrics_transcriber.transcribers.base_transcriber import BaseTranscriber, TranscriptionError
+from lyrics_transcriber.utils.word_utils import WordUtils
+
+
+@dataclass
+class LocalWhisperConfig:
+    """Configuration for local Whisper transcription service."""
+
+    model_size: str = "medium"  # tiny, base, small, medium, large, large-v2, large-v3
+    device: Optional[str] = None  # None for auto-detect, or "cpu", "cuda", "mps"
+    cache_dir: Optional[str] = None  # Directory for model downloads (~/.cache/whisper by default)
+    language: Optional[str] = None  # Language code for transcription, None for auto-detect
+    compute_type: str = "auto"  # float16, float32, int8, auto
+
+
+class LocalWhisperTranscriber(BaseTranscriber):
+    """
+    Transcription service using local Whisper inference via whisper-timestamped.
+
+    This transcriber runs Whisper models locally on your machine, supporting
+    CPU, CUDA GPU, and Apple Silicon MPS acceleration. It uses the
+    whisper-timestamped library to get accurate word-level timestamps.
+
+    Requirements:
+        pip install karaoke-gen[local-whisper]
+
+    Configuration:
+        Set environment variables to customize behavior:
+        - WHISPER_MODEL_SIZE: Model size (tiny, base, small, medium, large)
+        - WHISPER_DEVICE: Device to use (cpu, cuda, mps, or auto)
+        - WHISPER_CACHE_DIR: Directory for model downloads
+        - WHISPER_LANGUAGE: Language code (en, es, fr, etc.) or auto-detect
+    """
+
+    def __init__(
+        self,
+        cache_dir: Union[str, Path],
+        config: Optional[LocalWhisperConfig] = None,
+        logger: Optional[logging.Logger] = None,
+    ):
+        """
+        Initialize local Whisper transcriber.
+
+        Args:
+            cache_dir: Directory for caching transcription results
+            config: Configuration options for the transcriber
+            logger: Logger instance to use
+        """
+        super().__init__(cache_dir=cache_dir, logger=logger)
+
+        # Initialize configuration from env vars or defaults
+        self.config = config or LocalWhisperConfig(
+            model_size=os.getenv("WHISPER_MODEL_SIZE", "medium"),
+            device=os.getenv("WHISPER_DEVICE"),  # None for auto-detect
+            cache_dir=os.getenv("WHISPER_CACHE_DIR"),
+            language=os.getenv("WHISPER_LANGUAGE"),  # None for auto-detect
+        )
+
+        # Lazy-loaded model instance (loaded on first use)
+        self._model = None
+        self._whisper_module = None
+
+        self.logger.debug(
+            f"LocalWhisperTranscriber initialized with model_size={self.config.model_size}, "
+            f"device={self.config.device or 'auto'}, language={self.config.language or 'auto-detect'}"
+        )
+
+    def get_name(self) -> str:
+        """Return the name of this transcription service."""
+        return "LocalWhisper"
+
+    def _check_dependencies(self) -> None:
+        """Check that required dependencies are installed."""
+        try:
+            import whisper_timestamped  # noqa: F401
+        except ImportError:
+            raise TranscriptionError(
+                "whisper-timestamped is not installed. "
+                "Install it with: pip install karaoke-gen[local-whisper] "
+                "or: pip install whisper-timestamped"
+            )
+
+    def _get_device(self) -> str:
+        """Determine the best device to use for inference."""
+        if self.config.device:
+            return self.config.device
+
+        # Auto-detect best available device
+        try:
+            import torch
+
+            if torch.cuda.is_available():
+                self.logger.info("Using CUDA GPU for Whisper inference")
+                return "cuda"
+            elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+                self.logger.info("Using Apple Silicon MPS for Whisper inference")
+                return "cpu"  # whisper-timestamped works better with CPU on MPS
+            else:
+                self.logger.info("Using CPU for Whisper inference (no GPU detected)")
+                return "cpu"
+        except ImportError:
+            self.logger.warning("PyTorch not available, defaulting to CPU")
+            return "cpu"
+
+    def _load_model(self):
+        """Load the Whisper model (lazy loading on first use)."""
+        if self._model is not None:
+            return self._model
+
+        self._check_dependencies()
+        import whisper_timestamped as whisper
+
+        self._whisper_module = whisper
+
+        device = self._get_device()
+        self.logger.info(f"Loading Whisper model '{self.config.model_size}' on device '{device}'...")
+
+        try:
+            # Load model with optional custom cache directory
+            download_root = self.config.cache_dir
+            self._model = whisper.load_model(
+                self.config.model_size,
+                device=device,
+                download_root=download_root,
+            )
+            self.logger.info(f"Whisper model '{self.config.model_size}' loaded successfully")
+            return self._model
+        except RuntimeError as e:
+            if "out of memory" in str(e).lower() or "CUDA" in str(e):
+                raise TranscriptionError(
+                    f"GPU out of memory loading model '{self.config.model_size}'. "
+                    "Try using a smaller model (set WHISPER_MODEL_SIZE=small or tiny) "
+                    "or force CPU mode (set WHISPER_DEVICE=cpu)"
+                ) from e
+            raise TranscriptionError(f"Failed to load Whisper model: {e}") from e
+        except Exception as e:
+            raise TranscriptionError(f"Failed to load Whisper model: {e}") from e
+
+    def _perform_transcription(self, audio_filepath: str) -> Dict[str, Any]:
+        """
+        Perform local Whisper transcription with word-level timestamps.
+
+        Args:
+            audio_filepath: Path to the audio file to transcribe
+
+        Returns:
+            Raw transcription result dictionary
+        """
+        self.logger.info(f"Starting local Whisper transcription for {audio_filepath}")
+
+        # Load model if not already loaded
+        model = self._load_model()
+
+        try:
+            # Perform transcription with word-level timestamps
+            transcribe_kwargs = {
+                "verbose": False,
+            }
+
+            # Add language if specified
+            if self.config.language:
+                transcribe_kwargs["language"] = self.config.language
+
+            self.logger.debug(f"Transcribing with options: {transcribe_kwargs}")
+            result = self._whisper_module.transcribe_timestamped(
+                model,
+                audio_filepath,
+                **transcribe_kwargs,
+            )
+
+            self.logger.info("Local Whisper transcription completed successfully")
+            return result
+
+        except RuntimeError as e:
+            if "out of memory" in str(e).lower():
+                raise TranscriptionError(
+                    f"GPU out of memory during transcription. "
+                    "Try using a smaller model (WHISPER_MODEL_SIZE=small) "
+                    "or force CPU mode (WHISPER_DEVICE=cpu)"
+                ) from e
+            raise TranscriptionError(f"Transcription failed: {e}") from e
+        except Exception as e:
+            raise TranscriptionError(f"Transcription failed: {e}") from e
+
+    def _convert_result_format(self, raw_data: Dict[str, Any]) -> TranscriptionData:
+        """
+        Convert whisper-timestamped output to standard TranscriptionData format.
+
+        The whisper-timestamped library returns results in this format:
+        {
+            "text": "Full transcription text",
+            "segments": [
+                {
+                    "id": 0,
+                    "text": "Segment text",
+                    "start": 0.0,
+                    "end": 2.5,
+                    "words": [
+                        {"text": "word", "start": 0.0, "end": 0.5, "confidence": 0.95},
+                        ...
+                    ]
+                },
+                ...
+            ],
+            "language": "en"
+        }
+
+        Args:
+            raw_data: Raw output from whisper_timestamped.transcribe_timestamped()
+
+        Returns:
+            TranscriptionData with segments, words, and metadata
+        """
+        segments = []
+        all_words = []
+
+        for seg in raw_data.get("segments", []):
+            segment_words = []
+
+            for word_data in seg.get("words", []):
+                word = Word(
+                    id=WordUtils.generate_id(),
+                    text=word_data.get("text", "").strip(),
+                    start_time=word_data.get("start", 0.0),
+                    end_time=word_data.get("end", 0.0),
+                    confidence=word_data.get("confidence"),
+                )
+                segment_words.append(word)
+                all_words.append(word)
+
+            # Create segment with its words
+            segment = LyricsSegment(
+                id=WordUtils.generate_id(),
+                text=seg.get("text", "").strip(),
+                words=segment_words,
+                start_time=seg.get("start", 0.0),
+                end_time=seg.get("end", 0.0),
+            )
+            segments.append(segment)
+
+        return TranscriptionData(
+            segments=segments,
+            words=all_words,
+            text=raw_data.get("text", "").strip(),
+            source=self.get_name(),
+            metadata={
+                "model_size": self.config.model_size,
+                "detected_language": raw_data.get("language", "unknown"),
+                "device": self._get_device(),
+            },
+        )