karaoke-gen 0.96.0__py3-none-any.whl → 0.101.0__py3-none-any.whl

lyrics_transcriber/correction/anchor_sequence.py

@@ -32,19 +32,24 @@ class AnchorSequenceFinder:
         progress_check_interval: int = 50,  # Check progress every N iterations
         logger: Optional[logging.Logger] = None,
     ):
+        init_start = time.time()
         self.min_sequence_length = min_sequence_length
         self.min_sources = min_sources
         self.timeout_seconds = timeout_seconds
         self.max_iterations_per_ngram = max_iterations_per_ngram
         self.progress_check_interval = progress_check_interval
         self.logger = logger or logging.getLogger(__name__)
+
+        self.logger.info("Initializing AnchorSequenceFinder...")
         self.phrase_analyzer = PhraseAnalyzer(logger=self.logger)
         self.used_positions = {}
 
         # Initialize cache directory
         self.cache_dir = Path(cache_dir)
         self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self.logger.info(f"Initialized AnchorSequenceFinder with cache dir: {self.cache_dir}, timeout: {timeout_seconds}s")
+
+        init_elapsed = time.time() - init_start
+        self.logger.info(f"Initialized AnchorSequenceFinder in {init_elapsed:.2f}s (cache: {self.cache_dir}, timeout: {timeout_seconds}s)")
 
     def _check_timeout(self, start_time: float, operation_name: str = "operation"):
         """Check if timeout has occurred and raise exception if so."""
@@ -245,6 +250,65 @@ class AnchorSequenceFinder:
             self.logger.error(f"Unexpected error loading cache: {type(e).__name__}: {e}")
             return None
 
+    def _process_ngram_length_no_state(
+        self,
+        n: int,
+        trans_words: List[str],
+        all_words: List[Word],
+        ref_texts_clean: Dict[str, List[str]],
+        ref_words: Dict[str, List[Word]],
+        min_sources: int,
+    ) -> List[AnchorSequence]:
+        """Process a single n-gram length without modifying shared state (thread-safe).
+
+        This version doesn't track used positions - overlap filtering happens later
+        in _remove_overlapping_sequences. This allows parallel processing of different
+        n-gram lengths.
+        """
+        candidate_anchors = []
+
+        # Build hash-based index for O(1) lookups
+        ngram_index = self._build_ngram_index(ref_texts_clean, n)
+
+        # Generate n-grams from transcribed text
+        trans_ngrams = self._find_ngrams(trans_words, n)
+
+        # Single pass through all transcription n-grams
+        for ngram, trans_pos in trans_ngrams:
+            # Use indexed lookup (O(1) instead of O(n))
+            ngram_tuple = tuple(ngram)
+            if ngram_tuple not in ngram_index:
+                continue
+
+            # Find matches in all sources (no used_positions check - handled later)
+            matches = {}
+            source_positions = ngram_index[ngram_tuple]
+            for source, positions in source_positions.items():
+                if positions:
+                    matches[source] = positions[0]  # Take first position
+
+            if len(matches) >= min_sources:
+                # Get Word IDs for transcribed words
+                transcribed_word_ids = [w.id for w in all_words[trans_pos : trans_pos + n]]
+
+                # Get Word IDs for reference words
+                reference_word_ids = {
+                    source: [w.id for w in ref_words[source][pos : pos + n]]
+                    for source, pos in matches.items()
+                }
+
+                anchor = AnchorSequence(
+                    id=WordUtils.generate_id(),
+                    transcribed_word_ids=transcribed_word_ids,
+                    transcription_position=trans_pos,
+                    reference_positions=matches,
+                    reference_word_ids=reference_word_ids,
+                    confidence=len(matches) / len(ref_texts_clean),
+                )
+                candidate_anchors.append(anchor)
+
+        return candidate_anchors
+
     def _process_ngram_length(
         self,
         n: int,
@@ -408,45 +472,95 @@ class AnchorSequenceFinder:
                 min_sources=self.min_sources,
             )
 
-            # Process n-gram lengths sequentially (single-threaded for cloud compatibility)
+            # Process n-gram lengths in parallel for better performance
+            # The overlap filtering at the end handles deduplication, so we don't
+            # need to track used_positions during processing
             candidate_anchors = []
-            
+
             # Check timeout before processing
             self._check_timeout(start_time, "n-gram processing start")
-            self.logger.info(f"🔍 ANCHOR SEARCH: Starting sequential n-gram processing ({len(n_gram_lengths)} lengths)")
-            
-            batch_size = 10
-            batch_results = []
-            
-            for i, n in enumerate(n_gram_lengths):
-                try:
-                    # Check timeout periodically
-                    if self.timeout_seconds > 0:
-                        elapsed_time = time.time() - start_time
-                        if elapsed_time > self.timeout_seconds:
-                            self.logger.warning(f"🔍 ANCHOR SEARCH: ⏰ Timeout reached at n-gram {n}, stopping")
-                            break
-                    
-                    anchors = self._process_ngram_length(
-                        n, trans_words, all_words, ref_texts_clean, ref_words, self.min_sources
-                    )
-                    candidate_anchors.extend(anchors)
-                    
-                    # Batch logging
-                    batch_results.append((n, len(anchors)))
-                    
-                    # Log progress every batch_size results or on the last result
-                    if (i + 1) % batch_size == 0 or (i + 1) == len(n_gram_lengths):
-                        total_anchors_in_batch = sum(anchor_count for _, anchor_count in batch_results)
-                        n_gram_ranges = [str(ng) for ng, _ in batch_results]
-                        range_str = f"{n_gram_ranges[0]}-{n_gram_ranges[-1]}" if len(n_gram_ranges) > 1 else n_gram_ranges[0]
-                        self.logger.debug(f"🔍 ANCHOR SEARCH: Completed n-gram lengths {range_str} - found {total_anchors_in_batch} anchors")
-                        batch_results = []
-                        
-                except Exception as e:
-                    self.logger.warning(f"🔍 ANCHOR SEARCH: ⚠️ n-gram length {n} failed: {str(e)}")
-                    batch_results.append((n, 0))
-                    continue
+
+            # Determine parallelization strategy
+            import os
+            from concurrent.futures import ThreadPoolExecutor, as_completed
+
+            # Use parallel processing by default, can be disabled via env var
+            use_parallel = os.getenv("ANCHOR_SEARCH_SEQUENTIAL", "0").lower() not in {"1", "true", "yes"}
+            max_workers = int(os.getenv("ANCHOR_SEARCH_WORKERS", "4"))
+
+            if use_parallel and len(n_gram_lengths) > 1:
+                self.logger.info(f"🔍 ANCHOR SEARCH: Starting PARALLEL n-gram processing ({len(n_gram_lengths)} lengths, {max_workers} workers)")
+
+                # Process in parallel - each n-gram length is independent
+                # since we don't track used_positions during processing
+                with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                    # Submit all tasks
+                    future_to_n = {
+                        executor.submit(
+                            self._process_ngram_length_no_state,
+                            n, trans_words, all_words, ref_texts_clean, ref_words, self.min_sources
+                        ): n
+                        for n in n_gram_lengths
+                    }
+
+                    completed = 0
+                    for future in as_completed(future_to_n):
+                        n = future_to_n[future]
+                        completed += 1
+
+                        # Check timeout periodically
+                        if self.timeout_seconds > 0:
+                            elapsed_time = time.time() - start_time
+                            if elapsed_time > self.timeout_seconds:
+                                self.logger.warning(f"🔍 ANCHOR SEARCH: ⏰ Timeout reached, stopping ({completed}/{len(n_gram_lengths)} completed)")
+                                # Cancel remaining futures
+                                for f in future_to_n.keys():
+                                    f.cancel()
+                                break
+
+                        try:
+                            anchors = future.result()
+                            candidate_anchors.extend(anchors)
+                            if completed % 20 == 0:
+                                self.logger.debug(f"🔍 ANCHOR SEARCH: Progress {completed}/{len(n_gram_lengths)} lengths processed")
+                        except Exception as e:
+                            self.logger.warning(f"🔍 ANCHOR SEARCH: ⚠️ n-gram length {n} failed: {str(e)}")
+            else:
+                # Sequential fallback
+                self.logger.info(f"🔍 ANCHOR SEARCH: Starting sequential n-gram processing ({len(n_gram_lengths)} lengths)")
+
+                batch_size = 10
+                batch_results = []
+
+                for i, n in enumerate(n_gram_lengths):
+                    try:
+                        # Check timeout periodically
+                        if self.timeout_seconds > 0:
+                            elapsed_time = time.time() - start_time
+                            if elapsed_time > self.timeout_seconds:
+                                self.logger.warning(f"🔍 ANCHOR SEARCH: ⏰ Timeout reached at n-gram {n}, stopping")
+                                break
+
+                        anchors = self._process_ngram_length(
+                            n, trans_words, all_words, ref_texts_clean, ref_words, self.min_sources
+                        )
+                        candidate_anchors.extend(anchors)
+
+                        # Batch logging
+                        batch_results.append((n, len(anchors)))
+
+                        # Log progress every batch_size results or on the last result
+                        if (i + 1) % batch_size == 0 or (i + 1) == len(n_gram_lengths):
+                            total_anchors_in_batch = sum(anchor_count for _, anchor_count in batch_results)
+                            n_gram_ranges = [str(ng) for ng, _ in batch_results]
+                            range_str = f"{n_gram_ranges[0]}-{n_gram_ranges[-1]}" if len(n_gram_ranges) > 1 else n_gram_ranges[0]
+                            self.logger.debug(f"🔍 ANCHOR SEARCH: Completed n-gram lengths {range_str} - found {total_anchors_in_batch} anchors")
+                            batch_results = []
+
+                    except Exception as e:
+                        self.logger.warning(f"🔍 ANCHOR SEARCH: ⚠️ n-gram length {n} failed: {str(e)}")
+                        batch_results.append((n, 0))
+                        continue
 
             self.logger.info(f"🔍 ANCHOR SEARCH: ✅ Found {len(candidate_anchors)} candidate anchors in {time.time() - start_time:.1f}s")
             

lyrics_transcriber/correction/handlers/syllables_match.py

@@ -1,6 +1,7 @@
 from typing import List, Tuple, Dict, Any, Optional
 import spacy
 import logging
+import time
 import pyphen
 import nltk
 from nltk.corpus import cmudict
@@ -11,6 +12,15 @@ from lyrics_transcriber.types import GapSequence, WordCorrection
 from lyrics_transcriber.correction.handlers.base import GapCorrectionHandler
 from lyrics_transcriber.correction.handlers.word_operations import WordOperations
 
+# Try to import preloaders (may not exist in standalone library usage)
+try:
+    from backend.services.spacy_preloader import get_preloaded_model
+    from backend.services.nltk_preloader import get_preloaded_cmudict
+
+    _HAS_PRELOADER = True
+except ImportError:
+    _HAS_PRELOADER = False
+
 
 class SyllablesMatchHandler(GapCorrectionHandler):
     """Handles gaps where number of syllables in reference text matches number of syllables in transcription."""
@@ -18,11 +28,27 @@ class SyllablesMatchHandler(GapCorrectionHandler):
     def __init__(self, logger: Optional[logging.Logger] = None):
         super().__init__(logger)
         self.logger = logger or logging.getLogger(__name__)
+        init_start = time.time()
 
         # Marking SpacySyllables as used to prevent unused import warning
         _ = SpacySyllables
 
-        # Load spacy model with syllables pipeline
+        # Try to use preloaded model first (avoids 60+ second load on Cloud Run)
+        if _HAS_PRELOADER:
+            preloaded = get_preloaded_model("en_core_web_sm")
+            if preloaded is not None:
+                self.logger.info("Using preloaded SpaCy model for syllable analysis")
+                self.nlp = preloaded
+                # Add syllables component if not already present
+                if "syllables" not in self.nlp.pipe_names:
+                    self.nlp.add_pipe("syllables", after="tagger")
+                self._init_nltk_resources()
+                init_elapsed = time.time() - init_start
+                self.logger.info(f"Initialized SyllablesMatchHandler in {init_elapsed:.2f}s (preloaded)")
+                return
+
+        # Fall back to loading model directly
+        self.logger.info("Loading SpaCy model for syllable analysis (not preloaded)...")
         try:
             self.nlp = spacy.load("en_core_web_sm")
         except OSError:
@@ -43,10 +69,26 @@ class SyllablesMatchHandler(GapCorrectionHandler):
         if "syllables" not in self.nlp.pipe_names:
             self.nlp.add_pipe("syllables", after="tagger")
 
+        self._init_nltk_resources()
+        init_elapsed = time.time() - init_start
+        self.logger.info(f"Initialized SyllablesMatchHandler in {init_elapsed:.2f}s (lazy loaded)")
+
+    def _init_nltk_resources(self):
+        """Initialize NLTK resources (Pyphen and CMU dictionary)."""
+
         # Initialize Pyphen for English
         self.dic = pyphen.Pyphen(lang="en_US")
 
-        # Initialize NLTK's CMU dictionary
+        # Try to use preloaded cmudict first (avoids 50-100+ second download on Cloud Run)
+        if _HAS_PRELOADER:
+            preloaded_cmudict = get_preloaded_cmudict()
+            if preloaded_cmudict is not None:
+                self.logger.debug("Using preloaded NLTK cmudict")
+                self.cmudict = preloaded_cmudict
+                return
+
+        # Fall back to loading directly
+        self.logger.info("Loading NLTK cmudict (not preloaded)...")
         try:
             self.cmudict = cmudict.dict()
         except LookupError:

lyrics_transcriber/correction/phrase_analyzer.py

@@ -5,6 +5,14 @@ import logging
 from lyrics_transcriber.correction.text_utils import clean_text
 from lyrics_transcriber.types import PhraseType, PhraseScore
 
+# Try to import preloader (may not exist in standalone library usage)
+try:
+    from backend.services.spacy_preloader import get_preloaded_model
+
+    _HAS_PRELOADER = True
+except ImportError:
+    _HAS_PRELOADER = False
+
 
 class PhraseAnalyzer:
     """Language-agnostic phrase analyzer using spaCy"""
@@ -17,6 +25,16 @@ class PhraseAnalyzer:
             language_code: spaCy language model to use
         """
         self.logger = logger
+
+        # Try to use preloaded model first (avoids 60+ second load on Cloud Run)
+        if _HAS_PRELOADER:
+            preloaded = get_preloaded_model(language_code)
+            if preloaded is not None:
+                self.logger.info(f"Using preloaded SpaCy model: {language_code}")
+                self.nlp = preloaded
+                return
+
+        # Fall back to loading model directly
         self.logger.info(f"Initializing PhraseAnalyzer with language model: {language_code}")
         try:
             self.nlp = spacy.load(language_code)

lyrics_transcriber/frontend/src/api.ts

@@ -6,7 +6,7 @@ export interface ApiClient {
     getCorrectionData: () => Promise<CorrectionData>;
     submitCorrections: (data: CorrectionData) => Promise<void>;
     getAudioUrl: (audioHash: string) => string;
-    generatePreviewVideo: (data: CorrectionData) => Promise<PreviewVideoResponse>;
+    generatePreviewVideo: (data: CorrectionData, options?: PreviewOptions) => Promise<PreviewVideoResponse>;
     getPreviewVideoUrl: (previewHash: string) => string;
     updateHandlers: (enabledHandlers: string[]) => Promise<CorrectionData>;
     isUpdatingHandlers?: boolean;
@@ -21,6 +21,11 @@ interface CorrectionUpdate {
     corrected_segments: CorrectionData['corrected_segments'];
 }
 
+// Add interface for preview generation options
+export interface PreviewOptions {
+    use_background_image?: boolean;
+}
+
 // Add new interface for preview response
 interface PreviewVideoResponse {
     status: "success" | "error";
@@ -96,11 +101,13 @@ export class LiveApiClient implements ApiClient {
         return this.buildUrl(`/audio/${audioHash}`)
     }
 
-    async generatePreviewVideo(data: CorrectionData): Promise<PreviewVideoResponse> {
+    async generatePreviewVideo(data: CorrectionData, options?: PreviewOptions): Promise<PreviewVideoResponse> {
         // Extract only the needed fields, just like in submitCorrections
-        const updatePayload: CorrectionUpdate = {
+        // Include use_background_image option (defaults to false for fast black background)
+        const updatePayload = {
             corrections: data.corrections,
-            corrected_segments: data.corrected_segments
+            corrected_segments: data.corrected_segments,
+            use_background_image: options?.use_background_image ?? false,
         };
 
         const response = await fetch(this.buildUrl('/preview-video'), {
@@ -224,7 +231,8 @@ export class FileOnlyClient implements ApiClient {
         throw new Error('Not supported in file-only mode');
     }
 
-    async generatePreviewVideo(): Promise<PreviewVideoResponse> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async generatePreviewVideo(_data: CorrectionData, _options?: PreviewOptions): Promise<PreviewVideoResponse> {
         throw new Error('Not supported in file-only mode');
     }
 

lyrics_transcriber/frontend/src/components/PreviewVideoSection.tsx

@@ -1,5 +1,5 @@
-import { Box, Typography, CircularProgress, Alert, Button } from '@mui/material'
-import { useState, useEffect } from 'react'
+import { Box, Typography, CircularProgress, Alert, Button, FormControlLabel, Checkbox } from '@mui/material'
+import { useState, useEffect, useCallback } from 'react'
 import { ApiClient } from '../api'
 import { CorrectionData } from '../types'
 import { applyOffsetToCorrectionData } from './shared/utils/timingUtils'
@@ -25,75 +25,108 @@ export default function PreviewVideoSection({
         error?: string;
     }>({ status: 'loading' });
 
-    // Generate preview when modal opens
-    useEffect(() => {
-        if (isModalOpen && apiClient) {
-            const generatePreview = async () => {
-                setPreviewState({ status: 'loading' });
-                try {
-                    // Debug logging for timing offset
-                    console.log(`[TIMING] PreviewVideoSection - Current timing offset: ${timingOffsetMs}ms`);
-                    
-                    // Apply timing offset if needed
-                    const dataToPreview = timingOffsetMs !== 0 
-                        ? applyOffsetToCorrectionData(updatedData, timingOffsetMs) 
-                        : updatedData;
-                    
-                    // Log some example timestamps after potential offset application
-                    if (dataToPreview.corrected_segments.length > 0) {
-                        const firstSegment = dataToPreview.corrected_segments[0];
-                        console.log(`[TIMING] Preview - First segment id: ${firstSegment.id}`);
-                        console.log(`[TIMING] - start_time: ${firstSegment.start_time}, end_time: ${firstSegment.end_time}`);
-                        
-                        if (firstSegment.words.length > 0) {
-                            const firstWord = firstSegment.words[0];
-                            console.log(`[TIMING] - first word "${firstWord.text}" time: ${firstWord.start_time} -> ${firstWord.end_time}`);
-                        }
-                    }
-                    
-                    const response = await apiClient.generatePreviewVideo(dataToPreview);
-
-                    if (response.status === 'error') {
-                        setPreviewState({
-                            status: 'error',
-                            error: response.message || 'Failed to generate preview video'
-                        });
-                        return;
-                    }
+    // Toggle for rendering with theme background image (slower) vs black background (faster)
+    const [useBackgroundImage, setUseBackgroundImage] = useState(false);
 
-                    if (!response.preview_hash) {
-                        setPreviewState({
-                            status: 'error',
-                            error: 'No preview hash received from server'
-                        });
-                        return;
-                    }
+    // Memoized function to generate preview
+    const generatePreview = useCallback(async () => {
+        if (!apiClient) return;
+
+        setPreviewState({ status: 'loading' });
+        try {
+            // Debug logging for timing offset
+            console.log(`[TIMING] PreviewVideoSection - Current timing offset: ${timingOffsetMs}ms`);
+            console.log(`[PREVIEW] Using background image: ${useBackgroundImage}`);
+
+            // Apply timing offset if needed
+            const dataToPreview = timingOffsetMs !== 0
+                ? applyOffsetToCorrectionData(updatedData, timingOffsetMs)
+                : updatedData;
 
-                    const videoUrl = apiClient.getPreviewVideoUrl(response.preview_hash);
-                    setPreviewState({
-                        status: 'ready',
-                        videoUrl
-                    });
-                } catch (error) {
-                    setPreviewState({
-                        status: 'error',
-                        error: (error as Error).message || 'Failed to generate preview video'
-                    });
+            // Log some example timestamps after potential offset application
+            if (dataToPreview.corrected_segments.length > 0) {
+                const firstSegment = dataToPreview.corrected_segments[0];
+                console.log(`[TIMING] Preview - First segment id: ${firstSegment.id}`);
+                console.log(`[TIMING] - start_time: ${firstSegment.start_time}, end_time: ${firstSegment.end_time}`);
+
+                if (firstSegment.words.length > 0) {
+                    const firstWord = firstSegment.words[0];
+                    console.log(`[TIMING] - first word "${firstWord.text}" time: ${firstWord.start_time} -> ${firstWord.end_time}`);
                 }
-            };
+            }
+
+            const response = await apiClient.generatePreviewVideo(dataToPreview, {
+                use_background_image: useBackgroundImage
+            });
 
+            if (response.status === 'error') {
+                setPreviewState({
+                    status: 'error',
+                    error: response.message || 'Failed to generate preview video'
+                });
+                return;
+            }
+
+            if (!response.preview_hash) {
+                setPreviewState({
+                    status: 'error',
+                    error: 'No preview hash received from server'
+                });
+                return;
+            }
+
+            const videoUrl = apiClient.getPreviewVideoUrl(response.preview_hash);
+            setPreviewState({
+                status: 'ready',
+                videoUrl
+            });
+        } catch (error) {
+            setPreviewState({
+                status: 'error',
+                error: (error as Error).message || 'Failed to generate preview video'
+            });
+        }
+    }, [apiClient, updatedData, timingOffsetMs, useBackgroundImage]);
+
+    // Generate preview when modal opens or when background toggle changes
+    useEffect(() => {
+        if (isModalOpen && apiClient) {
             generatePreview();
         }
-    }, [isModalOpen, apiClient, updatedData, timingOffsetMs]);
+    }, [isModalOpen, apiClient, generatePreview]);
 
     if (!apiClient) return null;
 
     return (
         <Box sx={{ mb: 2 }}>
+            {/* Background image toggle */}
+            <Box sx={{ px: 2, pt: 2, pb: 1 }}>
+                <FormControlLabel
+                    control={
+                        <Checkbox
+                            checked={useBackgroundImage}
+                            onChange={(e) => setUseBackgroundImage(e.target.checked)}
+                            disabled={previewState.status === 'loading'}
+                            size="small"
+                        />
+                    }
+                    label={
+                        <Box>
+                            <Typography variant="body2" component="span">
+                                Render with theme background
+                            </Typography>
+                            <Typography variant="caption" color="text.secondary" display="block">
+                                Preview uses black background for speed (~10s). Enable for theme background (~30-60s).
+                            </Typography>
+                        </Box>
+                    }
+                />
+            </Box>
+
             {previewState.status === 'loading' && (
                 <Box sx={{ display: 'flex', alignItems: 'center', gap: 2, p: 2 }}>
                     <CircularProgress size={24} />
-                    <Typography>Generating preview video...</Typography>
+                    <Typography>Generating preview video{useBackgroundImage ? ' with theme background' : ''}...</Typography>
                 </Box>
             )}