lyrics-transcriber 0.37.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

lyrics_transcriber/frontend/src/components/shared/hooks/useWordClick.ts

@@ -19,6 +19,7 @@ export interface UseWordClickProps {
     onWordClick?: (info: WordClickInfo) => void
     isReference?: boolean
     currentSource?: string
+    gaps?: GapSequence[]
 }
 
 export function useWordClick({
@@ -26,7 +27,8 @@ export function useWordClick({
     onElementClick,
     onWordClick,
     isReference,
-    currentSource
+    currentSource,
+    gaps = []
 }: UseWordClickProps) {
     const handleWordClick = useCallback((
         word: string,
@@ -47,21 +49,20 @@ export function useWordClick({
                     wordIds: anchor.word_ids,
                     length: anchor.length,
                     words: anchor.words,
-                    referenceWordIds: anchor.reference_word_ids
+                    referenceWordIds: anchor.reference_word_ids,
+                    matchesWordId: isReference
+                        ? anchor.reference_word_ids[currentSource!]?.includes(wordId)
+                        : anchor.word_ids.includes(wordId)
                 },
                 gapInfo: gap && {
                     wordIds: gap.word_ids,
                     length: gap.length,
                     words: gap.words,
-                    corrections: gap.corrections.map(c => ({
-                        original_word: c.original_word,
-                        corrected_word: c.corrected_word,
-                        word_id: c.word_id,
-                        length: c.length,
-                        is_deletion: c.is_deletion,
-                        split_index: c.split_index,
-                        split_total: c.split_total
-                    }))
+                    referenceWords: gap.reference_words,
+                    corrections: gap.corrections,
+                    matchesWordId: isReference
+                        ? gap.reference_words[currentSource!]?.includes(wordId)
+                        : gap.word_ids.includes(wordId)
                 },
                 belongsToAnchor: anchor && (
                     isReference
@@ -78,6 +79,28 @@ export function useWordClick({
             }
         }, null, 2))
 
+        // For reference view clicks, find the corresponding gap
+        if (isReference && currentSource) {
+            // Extract position from wordId (e.g., "genius-word-3" -> 3)
+            const position = parseInt(wordId.split('-').pop() || '', 10);
+
+            // Find gap that has a correction matching this reference position
+            const matchingGap = gaps?.find(g =>
+                g.corrections.some(c => {
+                    const refPosition = c.reference_positions?.[currentSource];
+                    return typeof refPosition === 'number' && refPosition === position;
+                })
+            );
+
+            if (matchingGap) {
+                console.log('Found matching gap for reference click:', {
+                    position,
+                    gap: matchingGap
+                });
+                gap = matchingGap;
+            }
+        }
+
         const belongsToAnchor = anchor && (
             isReference
                 ? anchor.reference_word_ids[currentSource!]?.includes(wordId)
@@ -86,17 +109,58 @@ export function useWordClick({
 
         const belongsToGap = gap && (
             isReference
-                ? gap.corrections.some(c => c.word_id === wordId)
+                ? gap.corrections.some(c => {
+                    const refPosition = c.reference_positions?.[currentSource!];
+                    const clickedPosition = parseInt(wordId.split('-').pop() || '', 10);
+                    return typeof refPosition === 'number' && refPosition === clickedPosition;
+                })
                 : gap.word_ids.includes(wordId)
         )
 
         if (mode === 'highlight' || mode === 'edit') {
-            onWordClick?.({
-                word_id: wordId,
-                type: belongsToAnchor ? 'anchor' : belongsToGap ? 'gap' : 'other',
-                anchor: belongsToAnchor ? anchor : undefined,
-                gap: belongsToGap ? gap : undefined
-            })
+            if (belongsToAnchor && anchor) {
+                onWordClick?.({
+                    word_id: wordId,
+                    type: 'anchor',
+                    anchor,
+                    gap: undefined
+                })
+            } else if (belongsToGap && gap) {
+                // Create highlight info that includes both transcription and reference IDs
+                const referenceWords: Record<string, string[]> = {};
+
+                // For each correction in the gap, add its reference positions
+                gap.corrections.forEach(correction => {
+                    Object.entries(correction.reference_positions || {}).forEach(([source, position]) => {
+                        if (typeof position === 'number') {
+                            const refId = `${source}-word-${position}`;
+                            if (!referenceWords[source]) {
+                                referenceWords[source] = [];
+                            }
+                            if (!referenceWords[source].includes(refId)) {
+                                referenceWords[source].push(refId);
+                            }
+                        }
+                    });
+                });
+
+                onWordClick?.({
+                    word_id: wordId,
+                    type: 'gap',
+                    anchor: undefined,
+                    gap: {
+                        ...gap,
+                        reference_words: referenceWords // Use reference_words instead of reference_word_ids
+                    }
+                })
+            } else {
+                onWordClick?.({
+                    word_id: wordId,
+                    type: 'other',
+                    anchor: undefined,
+                    gap: undefined
+                })
+            }
         } else if (mode === 'details') {
             if (belongsToAnchor && anchor) {
                 onElementClick({
@@ -139,7 +203,7 @@ export function useWordClick({
                 })
             }
         }
-    }, [mode, onWordClick, onElementClick, isReference, currentSource])
+    }, [mode, onWordClick, onElementClick, isReference, currentSource, gaps])
 
     return { handleWordClick }
 } 

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

@@ -35,7 +35,10 @@ export interface TranscriptionWordPosition extends BaseWordPosition {
         start_time?: number
         end_time?: number
     }
+    type: 'anchor' | 'gap' | 'other'
+    sequence?: AnchorSequence | GapSequence
     isInRange: boolean
+    isCorrected?: boolean
 }
 
 // Reference-specific word position with simple string word

lyrics_transcriber/frontend/src/components/shared/utils/initializeDataWithIds.tsx

@@ -54,16 +54,57 @@ function findWordIdsForSequence(
     return allWords.slice(startIndex, endIndex).map(word => word.id);
 }
 
-// Helper function to find word ID for a correction
+// Add this at the top of the file
+const logWordMatching = (segments: LyricsSegment[], correction: { original_word: string }, foundId: string | null) => {
+    const allWords = segments.flatMap(s => s.words);
+    console.log('Word ID Assignment:', {
+        searchingFor: correction.original_word,
+        allWordsWithIds: allWords.map(w => ({
+            text: w.text,
+            id: w.id
+        })),
+        matchedId: foundId,
+        matchedWord: foundId ? allWords.find(w => w.id === foundId)?.text : null
+    });
+};
+
+// Modify findWordIdForCorrection to include logging
 function findWordIdForCorrection(
     segments: LyricsSegment[],
-    correction: { original_word: string; }
+    correction: {
+        original_word: string;
+        original_position?: number;
+    }
 ): string {
+    const allWords = segments.flatMap(s => s.words);
+
+    // If we have position information, use it to find the exact word
+    if (typeof correction.original_position === 'number') {
+        const word = allWords[correction.original_position];
+        if (word && word.text === correction.original_word) {
+            logWordMatching(segments, correction, word.id);
+            return word.id;
+        }
+    }
+
+    // Fallback to finding by text (but log a warning)
     for (const segment of segments) {
         const word = segment.words.find(w => w.text === correction.original_word);
-        if (word) return word.id;
+        if (word) {
+            console.warn(
+                'Warning: Had to find word by text match rather than position.',
+                correction.original_word,
+                'Consider using position information for more accurate matching.'
+            );
+            logWordMatching(segments, correction, word.id);
+            return word.id;
+        }
     }
-    return nanoid(); // Fallback if word not found
+
+    const newId = nanoid();
+    logWordMatching(segments, correction, null);
+    console.log('Generated new ID:', newId, 'for word:', correction.original_word);
+    return newId;
 }
 
 // Helper function to find word IDs in reference text
@@ -130,15 +171,30 @@ export function initializeDataWithIds(data: CorrectionData): CorrectionData {
     // Update gap sequences to use word IDs
     newData.gap_sequences = newData.gap_sequences.map((gap) => {
         const serverGap = gap as unknown as ServerData;
+        console.log('Processing gap sequence:', {
+            words: gap.words,
+            word_ids: gap.word_ids,
+            corrections: gap.corrections,
+            foundWordIds: findWordIdsForSequence(newData.corrected_segments, serverGap)
+        });
+
         return {
             ...gap,
             id: gap.id || nanoid(),
             word_ids: gap.word_ids || findWordIdsForSequence(newData.corrected_segments, serverGap),
-            corrections: gap.corrections.map((correction: WordCorrection) => ({
-                ...correction,
-                id: correction.id || nanoid(),
-                word_id: correction.word_id || findWordIdForCorrection(newData.corrected_segments, correction)
-            }))
+            corrections: gap.corrections.map((correction: WordCorrection) => {
+                const wordId = correction.word_id || findWordIdForCorrection(newData.corrected_segments, correction);
+                console.log('Correction word ID assignment:', {
+                    original_word: correction.original_word,
+                    corrected_word: correction.corrected_word,
+                    assigned_id: wordId
+                });
+                return {
+                    ...correction,
+                    id: correction.id || nanoid(),
+                    word_id: wordId
+                };
+            })
         } as GapSequence;
     });
 

lyrics_transcriber/frontend/vite.config.js

@@ -3,4 +3,8 @@ import react from '@vitejs/plugin-react';
 // https://vite.dev/config/
 export default defineConfig({
     plugins: [react()],
+    build: {
+        minify: false,
+        sourcemap: true,
+    }
 });

lyrics_transcriber/frontend/vite.config.ts

@@ -4,4 +4,8 @@ import react from '@vitejs/plugin-react'
 // https://vite.dev/config/
 export default defineConfig({
   plugins: [react()],
+  build: {
+    minify: false,
+    sourcemap: true,
+  }
 })

lyrics_transcriber/lyrics/genius.py

@@ -82,19 +82,48 @@ class GeniusProvider(BaseLyricsProvider):
 
     def _clean_lyrics(self, lyrics: str) -> str:
         """Clean and process lyrics from Genius to remove unwanted content."""
+        self.logger.debug("Starting lyrics cleaning process")
+        original = lyrics
 
         lyrics = lyrics.replace("\\n", "\n")
         lyrics = re.sub(r"You might also like", "", lyrics)
-        lyrics = re.sub(
-            r".*?Lyrics([A-Z])", r"\1", lyrics
-        )  # Remove the song name and word "Lyrics" if this has a non-newline char at the start
-        lyrics = re.sub(r"^[0-9]* Contributors.*Lyrics", "", lyrics)  # Remove this example: 27 ContributorsSex Bomb Lyrics
-        lyrics = re.sub(
-            r"See.*Live.*Get tickets as low as \$[0-9]+", "", lyrics
-        )  # Remove this example: See Tom Jones LiveGet tickets as low as $71
-        lyrics = re.sub(r"[0-9]+Embed$", "", lyrics)  # Remove the word "Embed" at end of line with preceding numbers if found
-        lyrics = re.sub(r"(\S)Embed$", r"\1", lyrics)  # Remove the word "Embed" if it has been tacked onto a word at the end of a line
-        lyrics = re.sub(r"^Embed$", r"", lyrics)  # Remove the word "Embed" if it has been tacked onto a word at the end of a line
-        lyrics = re.sub(r".*?\[.*?\].*?", "", lyrics)  # Remove lines containing square brackets
-        # add any additional cleaning rules here
+        if original != lyrics:
+            self.logger.debug("Removed 'You might also like' text")
+
+        original = lyrics
+        lyrics = re.sub(r".*?Lyrics([A-Z])", r"\1", lyrics)
+        if original != lyrics:
+            self.logger.debug("Removed song name and 'Lyrics' prefix")
+
+        original = lyrics
+        lyrics = re.sub(r"^[0-9]* Contributors.*Lyrics", "", lyrics)
+        if original != lyrics:
+            self.logger.debug("Removed contributors count and 'Lyrics' text")
+
+        original = lyrics
+        lyrics = re.sub(r"See.*Live.*Get tickets as low as \$[0-9]+", "", lyrics)
+        if original != lyrics:
+            self.logger.debug("Removed ticket sales text")
+
+        original = lyrics
+        lyrics = re.sub(r"[0-9]+Embed$", "", lyrics)
+        if original != lyrics:
+            self.logger.debug("Removed numbered embed marker")
+
+        original = lyrics
+        lyrics = re.sub(r"(\S)Embed$", r"\1", lyrics)
+        if original != lyrics:
+            self.logger.debug("Removed 'Embed' suffix from word")
+
+        original = lyrics
+        lyrics = re.sub(r"^Embed$", r"", lyrics)
+        if original != lyrics:
+            self.logger.debug("Removed standalone 'Embed' text")
+
+        original = lyrics
+        lyrics = re.sub(r".*?\[.*?\].*?", "", lyrics)
+        if original != lyrics:
+            self.logger.debug("Removed lines containing square brackets")
+
+        self.logger.debug("Completed lyrics cleaning process")
         return lyrics

lyrics_transcriber/output/cdg.py

@@ -9,6 +9,7 @@ import os
 import zipfile
 import shutil
 
+from lyrics_transcriber.output.cdgmaker.cdg import CDG_VISIBLE_WIDTH
 from lyrics_transcriber.output.cdgmaker.composer import KaraokeComposer
 from lyrics_transcriber.output.cdgmaker.render import get_wrapped_text
 from lyrics_transcriber.types import LyricsSegment
@@ -110,7 +111,7 @@ class CDGGenerator:
                 # Convert time from seconds to centiseconds
                 timestamp = int(word.start_time * 100)
                 lyrics_data.append({"timestamp": timestamp, "text": word.text.upper()})  # CDG format expects uppercase text
-                # self.logger.debug(f"Added lyric: timestamp {timestamp}, text '{word.text}'")
+                self.logger.debug(f"Added lyric: timestamp {timestamp}, text '{word.text}'")
 
         # Sort by timestamp to ensure correct order
         lyrics_data.sort(key=lambda x: x["timestamp"])
@@ -189,6 +190,7 @@ class CDGGenerator:
         """Compose CDG using KaraokeComposer."""
         kc = KaraokeComposer.from_file(toml_file)
         kc.compose()
+        kc.create_mp4(height=1080, fps=30)
 
     def _find_cdg_zip(self, artist: str, title: str) -> str:
         """Find the generated CDG ZIP file."""
@@ -337,20 +339,20 @@ class CDGGenerator:
         formatted_lyrics = []
 
         for i, lyric in enumerate(lyrics_data):
-            # self.logger.debug(f"Processing lyric {i}: timestamp {lyric['timestamp']}, text '{lyric['text']}'")
+            self.logger.debug(f"Processing lyric {i}: timestamp {lyric['timestamp']}, text '{lyric['text']}'")
 
             if i == 0 or lyric["timestamp"] - lyrics_data[i - 1]["timestamp"] >= cdg_styles["lead_in_threshold"]:
                 lead_in_start = lyric["timestamp"] - cdg_styles["lead_in_total"]
-                # self.logger.debug(f"Adding lead-in before lyric {i} at timestamp {lead_in_start}")
+                self.logger.debug(f"Adding lead-in before lyric {i} at timestamp {lead_in_start}")
                 for j, symbol in enumerate(cdg_styles["lead_in_symbols"]):
                     sync_time = lead_in_start + j * cdg_styles["lead_in_duration"]
                     sync_times.append(sync_time)
                     formatted_lyrics.append(symbol)
-                    # self.logger.debug(f"  Added lead-in symbol {j+1}: '{symbol}' at {sync_time}")
+                    self.logger.debug(f"  Added lead-in symbol {j+1}: '{symbol}' at {sync_time}")
 
             sync_times.append(lyric["timestamp"])
             formatted_lyrics.append(lyric["text"])
-            # self.logger.debug(f"Added lyric: '{lyric['text']}' at {lyric['timestamp']}")
+            self.logger.debug(f"Added lyric: '{lyric['text']}' at {lyric['timestamp']}")
 
         formatted_text = self.format_lyrics(
             formatted_lyrics,
@@ -472,24 +474,29 @@ class CDGGenerator:
         page_number = 1
 
         for i, text in enumerate(lyrics_data):
-            # self.logger.debug(f"Processing text {i}: '{text}' (sync time: {sync_times[i]})")
+            self.logger.debug(f"format_lyrics: Processing text {i}: '{text}' (sync time: {sync_times[i]})")
 
             if text.startswith("/"):
                 if current_line:
-                    wrapped_lines = get_wrapped_text(current_line.strip(), font, self.cdg_visible_width).split("\n")
+                    wrapped_lines = get_wrapped_text(current_line.strip(), font, CDG_VISIBLE_WIDTH).split("\n")
                     for wrapped_line in wrapped_lines:
                         formatted_lyrics.append(wrapped_line)
                         lines_on_page += 1
-                        # self.logger.debug(f"Added wrapped line: '{wrapped_line}'. Lines on page: {lines_on_page}")
+                        self.logger.debug(f"format_lyrics: Added wrapped line: '{wrapped_line}'. Lines on page: {lines_on_page}")
+                        # Add empty line after punctuation immediately
+                        if wrapped_line.endswith(("!", "?", ".")) and not wrapped_line == "~":
+                            formatted_lyrics.append("~")
+                            lines_on_page += 1
+                            self.logger.debug(f"format_lyrics: Added empty line after punctuation. Lines on page now: {lines_on_page}")
                         if lines_on_page == 4:
                             lines_on_page = 0
                             page_number += 1
-                            # self.logger.debug(f"Page full. New page number: {page_number}")
+                            self.logger.debug(f"format_lyrics: Page full. New page number: {page_number}")
                     current_line = ""
                 text = text[1:]
 
             current_line += text + " "
-            # self.logger.debug(f"Current line: '{current_line}'")
+            self.logger.debug(f"format_lyrics: Current line: '{current_line}'")
 
             is_last_before_instrumental = any(
                 inst["sync"] > sync_times[i] and (i == len(sync_times) - 1 or sync_times[i + 1] > inst["sync"]) for inst in instrumentals
@@ -497,33 +504,103 @@ class CDGGenerator:
 
             if is_last_before_instrumental or i == len(lyrics_data) - 1:
                 if current_line:
-                    wrapped_lines = get_wrapped_text(current_line.strip(), font, self.cdg_visible_width).split("\n")
+                    wrapped_lines = get_wrapped_text(current_line.strip(), font, CDG_VISIBLE_WIDTH).split("\n")
                     for wrapped_line in wrapped_lines:
                         formatted_lyrics.append(wrapped_line)
                         lines_on_page += 1
-                        # self.logger.debug(f"Added wrapped line at end of section: '{wrapped_line}'. Lines on page: {lines_on_page}")
+                        self.logger.debug(
+                            f"format_lyrics: Added wrapped line at end of section: '{wrapped_line}'. Lines on page: {lines_on_page}"
+                        )
                         if lines_on_page == 4:
                             lines_on_page = 0
                             page_number += 1
-                            # self.logger.debug(f"Page full. New page number: {page_number}")
+                            self.logger.debug(f"format_lyrics: Page full. New page number: {page_number}")
                     current_line = ""
 
                 if is_last_before_instrumental:
-                    blank_lines_needed = 4 - lines_on_page
-                    if blank_lines_needed < 4:
-                        formatted_lyrics.extend(["~"] * blank_lines_needed)
-                        # self.logger.debug(f"Added {blank_lines_needed} empty lines before instrumental. Lines on page was {lines_on_page}")
+                    self.logger.debug(f"format_lyrics: is_last_before_instrumental: True lines_on_page: {lines_on_page}")
+                    # Calculate remaining lines needed to reach next full page
+                    remaining_lines = 4 - (lines_on_page % 4) if lines_on_page % 4 != 0 else 0
+                    if remaining_lines > 0:
+                        formatted_lyrics.extend(["~"] * remaining_lines)
+                        self.logger.debug(f"format_lyrics: Added {remaining_lines} empty lines to complete current page")
+
+                    # Reset the counter and increment page
                     lines_on_page = 0
                     page_number += 1
-                    # self.logger.debug(f"Reset lines_on_page to 0. New page number: {page_number}")
-
-        final_lyrics = []
-        for line in formatted_lyrics:
-            final_lyrics.append(line)
-            if line.endswith(("!", "?", ".")) and not line == "~":
-                final_lyrics.append("~")
-                # self.logger.debug("Added empty line after punctuation")
-
-        result = "\n".join(final_lyrics)
-        # self.logger.debug(f"Final formatted lyrics:\n{result}")
-        return result
+                    self.logger.debug(f"format_lyrics: Reset lines_on_page to 0. New page number: {page_number}")
+
+        return "\n".join(formatted_lyrics)
+
+    def generate_cdg_from_lrc(
+        self,
+        lrc_file: str,
+        audio_file: str,
+        title: str,
+        artist: str,
+        cdg_styles: dict,
+    ) -> Tuple[str, str, str]:
+        """Generate a CDG file from an LRC file and audio file.
+
+        Args:
+            lrc_file: Path to the LRC file
+            audio_file: Path to the audio file
+            title: Title of the song
+            artist: Artist name
+            cdg_styles: Dictionary containing CDG style parameters
+
+        Returns:
+            Tuple containing paths to (cdg_file, mp3_file, zip_file)
+        """
+        self._validate_and_setup_font(cdg_styles)
+
+        # Parse LRC file and convert to lyrics_data format
+        lyrics_data = self._parse_lrc(lrc_file)
+
+        toml_file = self._create_toml_file(
+            audio_file=audio_file,
+            title=title,
+            artist=artist,
+            lyrics_data=lyrics_data,
+            cdg_styles=cdg_styles,
+        )
+
+        try:
+            self._compose_cdg(toml_file)
+            output_zip = self._find_cdg_zip(artist, title)
+            self._extract_cdg_files(output_zip)
+
+            cdg_file = self._get_cdg_path(artist, title)
+            mp3_file = self._get_mp3_path(artist, title)
+
+            self._verify_output_files(cdg_file, mp3_file)
+
+            self.logger.info("CDG file generated successfully")
+            return cdg_file, mp3_file, output_zip
+
+        except Exception as e:
+            self.logger.error(f"Error composing CDG: {e}")
+            raise
+
+    def _parse_lrc(self, lrc_file: str) -> List[dict]:
+        """Parse LRC file and extract timestamps and lyrics."""
+        with open(lrc_file, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Extract timestamps and lyrics
+        pattern = r"\[(\d{2}):(\d{2})\.(\d{3})\](\d+:)?(/?.*)"
+        matches = re.findall(pattern, content)
+
+        if not matches:
+            raise ValueError(f"No valid lyrics found in the LRC file: {lrc_file}")
+
+        lyrics = []
+        for match in matches:
+            minutes, seconds, milliseconds = map(int, match[:3])
+            timestamp = (minutes * 60 + seconds) * 100 + int(milliseconds / 10)  # Convert to centiseconds
+            text = match[4].strip().upper()
+            if text:  # Only add non-empty lyrics
+                lyrics.append({"timestamp": timestamp, "text": text})
+
+        self.logger.info(f"Found {len(lyrics)} lyric lines")
+        return lyrics