lyrics-transcriber 0.43.1__py3-none-any.whl → 0.44.0__py3-none-any.whl

lyrics_transcriber/frontend/src/theme.ts

@@ -0,0 +1,177 @@
+import { createTheme } from '@mui/material/styles';
+
+// Create a theme with smaller typography and spacing
+const theme = createTheme({
+  typography: {
+    // Scale down all typography by about 20%
+    fontSize: 14, // Default is 16
+    h1: {
+      fontSize: '2.5rem', // Default is ~3rem
+    },
+    h2: {
+      fontSize: '2rem', // Default is ~2.5rem
+    },
+    h3: {
+      fontSize: '1.5rem', // Default is ~1.75rem
+    },
+    h4: {
+      fontSize: '1.2rem', // Default is ~1.5rem
+      marginBottom: '0.5rem',
+    },
+    h5: {
+      fontSize: '1rem', // Default is ~1.25rem
+    },
+    h6: {
+      fontSize: '0.9rem', // Default is ~1.1rem
+      marginBottom: '0.5rem',
+    },
+    body1: {
+      fontSize: '0.85rem', // Default is ~1rem
+    },
+    body2: {
+      fontSize: '0.75rem', // Default is ~0.875rem
+    },
+    button: {
+      fontSize: '0.8rem', // Default is ~0.875rem
+    },
+    caption: {
+      fontSize: '0.7rem', // Default is ~0.75rem
+    },
+  },
+  components: {
+    MuiButton: {
+      styleOverrides: {
+        root: {
+          padding: '3px 10px', // Further reduced from 4px 12px
+          minHeight: '30px', // Further reduced from 32px
+        },
+        sizeSmall: {
+          padding: '1px 6px', // Further reduced from 2px 8px
+          minHeight: '24px', // Further reduced from 28px
+        },
+      },
+    },
+    MuiIconButton: {
+      styleOverrides: {
+        root: {
+          padding: '4px', // Further reduced from 6px
+        },
+        sizeSmall: {
+          padding: '2px', // Further reduced from 4px
+        },
+      },
+    },
+    MuiTextField: {
+      styleOverrides: {
+        root: {
+          '& .MuiInputBase-root': {
+            minHeight: '32px', // Further reduced from 36px
+          },
+        },
+      },
+    },
+    MuiDialog: {
+      styleOverrides: {
+        paper: {
+          padding: '8px', // Further reduced from 12px
+        },
+      },
+    },
+    MuiDialogTitle: {
+      styleOverrides: {
+        root: {
+          padding: '8px 12px', // Further reduced from 12px 16px
+        },
+      },
+    },
+    MuiDialogContent: {
+      styleOverrides: {
+        root: {
+          padding: '6px 12px', // Further reduced from 8px 16px
+        },
+      },
+    },
+    MuiDialogActions: {
+      styleOverrides: {
+        root: {
+          padding: '6px 12px', // Further reduced from 8px 16px
+        },
+      },
+    },
+    MuiPaper: {
+      styleOverrides: {
+        root: {
+          padding: '8px', // Further reduced from 12px
+        },
+      },
+    },
+    MuiList: {
+      styleOverrides: {
+        root: {
+          padding: '2px 0', // Further reduced from 4px 0
+        },
+      },
+    },
+    MuiListItem: {
+      styleOverrides: {
+        root: {
+          padding: '2px 8px', // Further reduced from 4px 12px
+        },
+      },
+    },
+    MuiTableCell: {
+      styleOverrides: {
+        root: {
+          padding: '4px 8px', // Further reduced from 8px 12px
+        },
+      },
+    },
+    MuiCard: {
+      styleOverrides: {
+        root: {
+          padding: '8px',
+        },
+      },
+    },
+    MuiCardContent: {
+      styleOverrides: {
+        root: {
+          padding: '8px',
+          '&:last-child': {
+            paddingBottom: '8px',
+          },
+        },
+      },
+    },
+    MuiCardHeader: {
+      styleOverrides: {
+        root: {
+          padding: '8px',
+        },
+      },
+    },
+    MuiCardActions: {
+      styleOverrides: {
+        root: {
+          padding: '4px 8px',
+        },
+      },
+    },
+    MuiGrid: {
+      styleOverrides: {
+        container: {
+          marginTop: '-4px',
+          marginLeft: '-4px',
+          width: 'calc(100% + 8px)',
+        },
+        item: {
+          paddingTop: '4px',
+          paddingLeft: '4px',
+        },
+      },
+    },
+  },
+  spacing: (factor: number) => `${0.6 * factor}rem`, // Further reduced from 0.8 * factor
+});
+
+export default theme; 

lyrics_transcriber/frontend/src/types.ts

@@ -136,4 +136,4 @@ export interface HighlightInfo {
     correction?: WordCorrection
 }
 
-export type InteractionMode = 'highlight' | 'details' | 'edit'
+export type InteractionMode = 'highlight' | 'edit'

lyrics_transcriber/frontend/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/app.tsx","./src/api.ts","./src/main.tsx","./src/types.ts","./src/validation.ts","./src/vite-env.d.ts","./src/components/audioplayer.tsx","./src/components/correctionmetrics.tsx","./src/components/detailsmodal.tsx","./src/components/editmodal.tsx","./src/components/fileupload.tsx","./src/components/header.tsx","./src/components/lyricsanalyzer.tsx","./src/components/modeselector.tsx","./src/components/previewvideosection.tsx","./src/components/referenceview.tsx","./src/components/reviewchangesmodal.tsx","./src/components/segmentdetailsmodal.tsx","./src/components/timelineeditor.tsx","./src/components/transcriptionview.tsx","./src/components/wordeditcontrols.tsx","./src/components/shared/constants.ts","./src/components/shared/styles.ts","./src/components/shared/types.ts","./src/components/shared/components/highlightedtext.tsx","./src/components/shared/components/sourceselector.tsx","./src/components/shared/components/word.tsx","./src/components/shared/hooks/usewordclick.ts","./src/components/shared/utils/keyboardhandlers.ts","./src/components/shared/utils/localstorage.ts","./src/components/shared/utils/referencelinecalculator.ts","./src/components/shared/utils/segmentoperations.ts","./src/components/shared/utils/wordutils.ts","./src/types/global.d.ts"],"version":"5.6.3"}
+{"root":["./src/app.tsx","./src/api.ts","./src/main.tsx","./src/theme.ts","./src/types.ts","./src/validation.ts","./src/vite-env.d.ts","./src/components/addlyricsmodal.tsx","./src/components/audioplayer.tsx","./src/components/correctionmetrics.tsx","./src/components/editmodal.tsx","./src/components/fileupload.tsx","./src/components/findreplacemodal.tsx","./src/components/globalsynceditor.tsx","./src/components/header.tsx","./src/components/lyricsanalyzer.tsx","./src/components/modeselector.tsx","./src/components/previewvideosection.tsx","./src/components/referenceview.tsx","./src/components/reviewchangesmodal.tsx","./src/components/segmentdetailsmodal.tsx","./src/components/timelineeditor.tsx","./src/components/transcriptionview.tsx","./src/components/worddivider.tsx","./src/components/shared/constants.ts","./src/components/shared/styles.ts","./src/components/shared/types.ts","./src/components/shared/components/highlightedtext.tsx","./src/components/shared/components/sourceselector.tsx","./src/components/shared/components/word.tsx","./src/components/shared/hooks/usewordclick.ts","./src/components/shared/utils/keyboardhandlers.ts","./src/components/shared/utils/localstorage.ts","./src/components/shared/utils/referencelinecalculator.ts","./src/components/shared/utils/segmentoperations.ts","./src/components/shared/utils/wordutils.ts","./src/hooks/usemanualsync.ts","./src/types/global.d.ts"],"version":"5.6.3"}

lyrics_transcriber/lyrics/base_lyrics_provider.py

@@ -47,14 +47,14 @@ class BaseLyricsProvider(ABC):
         converted_cache_path = self._get_cache_path(cache_key, "converted")
         converted_data = self._load_from_cache(converted_cache_path)
         if converted_data:
-            self.logger.info(f"Using cached converted lyrics for {artist} - {title}")
+            self.logger.info(f"Using cached converted lyrics for {artist} - {title} from file: {converted_cache_path}")
             return LyricsData.from_dict(converted_data)
 
         # Check raw cache next
         raw_cache_path = self._get_cache_path(cache_key, "raw")
         raw_data = self._load_from_cache(raw_cache_path)
         if raw_data:
-            self.logger.info(f"Using cached raw lyrics for {artist} - {title}")
+            self.logger.info(f"Using cached raw lyrics for {artist} - {title} from file: {raw_cache_path}")
             converted_result = self._convert_result_format(raw_data)
             self._save_to_cache(converted_cache_path, converted_result.to_dict())
             return converted_result

lyrics_transcriber/lyrics/user_input_provider.py

@@ -0,0 +1,44 @@
+from typing import Optional, Dict, Any
+from lyrics_transcriber.lyrics.base_lyrics_provider import BaseLyricsProvider, LyricsProviderConfig
+from lyrics_transcriber.types import LyricsData, LyricsMetadata
+
+
+class UserInputProvider(BaseLyricsProvider):
+    """Provider for manually input lyrics text."""
+
+    def __init__(self, lyrics_text: str, source_name: str, metadata: Dict[str, Any], *args, **kwargs):
+        """Initialize with the user's input text."""
+        super().__init__(LyricsProviderConfig(), *args, **kwargs)
+        self.lyrics_text = lyrics_text
+        self.source_name = source_name
+        self.input_metadata = metadata
+
+    def _fetch_data_from_source(self, artist: str, title: str) -> Optional[Dict[str, Any]]:
+        """Return the user's input text as raw data."""
+        return {"text": self.lyrics_text, "metadata": self.input_metadata}
+
+    def _convert_result_format(self, raw_data: Dict[str, Any]) -> LyricsData:
+        """Convert the raw text into LyricsData format."""
+        # Create segments with words from the text
+        segments = self._create_segments_with_words(raw_data["text"])
+
+        # Create metadata
+        metadata = LyricsMetadata(
+            source=self.source_name,
+            track_name=raw_data["metadata"].get("title", ""),
+            artist_names=raw_data["metadata"].get("artist", ""),
+            is_synced=False,
+            lyrics_provider="manual",
+            lyrics_provider_id="",
+            album_name=None,
+            duration_ms=None,
+            explicit=None,
+            language=None,
+            provider_metadata={},
+        )
+
+        return LyricsData(segments=segments, metadata=metadata, source=self.source_name)
+
+    def get_name(self) -> str:
+        """Return the provider name."""
+        return "UserInput"

lyrics_transcriber/output/generator.py

@@ -37,6 +37,7 @@ class OutputGenerator:
         self,
         config: OutputConfig,
         logger: Optional[logging.Logger] = None,
+        preview_mode: bool = False,
     ):
         """
         Initialize OutputGenerator with configuration.
@@ -44,20 +45,12 @@ class OutputGenerator:
         Args:
             config: OutputConfig instance with required paths and settings
             logger: Optional logger instance
+            preview_mode: Boolean indicating if the generator is in preview mode
         """
         self.config = config
         self.logger = logger or logging.getLogger(__name__)
 
-        self.logger.debug(f"Initializing OutputGenerator with config: {self.config}")
-
-        # Set video resolution parameters
-        self.video_resolution_num, self.font_size, self.line_height = self._get_video_params(self.config.video_resolution)
-
-        self.segment_resizer = SegmentResizer(max_line_length=self.config.max_line_length, logger=self.logger)
-
-        # Initialize generators
-        self.plain_text = PlainTextGenerator(self.config.output_dir, self.logger)
-        self.lyrics_file = LyricsFileGenerator(self.config.output_dir, self.logger)
+        self.logger.info(f"Initializing OutputGenerator with config: {self.config}")
 
         if self.config.render_video or self.config.generate_cdg:
             # Load output styles from JSON
@@ -68,10 +61,46 @@ class OutputGenerator:
             except Exception as e:
                 raise ValueError(f"Failed to load output styles file: {str(e)}")
 
+        # Set video resolution parameters
+        self.video_resolution_num, self.font_size, self.line_height = self._get_video_params(self.config.video_resolution)
+        self.logger.info(f"Video resolution: {self.video_resolution_num}, font size: {self.font_size}, line height: {self.line_height}")
+
+        self.segment_resizer = SegmentResizer(max_line_length=self.config.max_line_length, logger=self.logger)
+
+        # Initialize generators
+        self.plain_text = PlainTextGenerator(self.config.output_dir, self.logger)
+        self.lyrics_file = LyricsFileGenerator(self.config.output_dir, self.logger)
+
         if self.config.generate_cdg:
             self.cdg = CDGGenerator(self.config.output_dir, self.logger)
 
+        self.preview_mode = preview_mode
         if self.config.render_video:
+            # Apply preview mode scaling if needed
+            if self.preview_mode:
+                # Scale down from 4K (2160p) to 360p - factor of 1/6
+                scale_factor = 1 / 6
+
+                # Scale down top padding for preview if it exists
+                if "karaoke" in self.config.styles and "top_padding" in self.config.styles["karaoke"]:
+                    self.logger.info(f"Preview mode: Found top_padding: {self.config.styles['karaoke']['top_padding']}")
+                    original_padding = self.config.styles["karaoke"]["top_padding"]
+                    if original_padding is not None:
+                        # Scale down from 4K (2160p) to 360p - factor of 1/6
+                        self.config.styles["karaoke"]["top_padding"] = original_padding * scale_factor
+                        self.logger.info(f"Preview mode: Scaled down top_padding to: {self.config.styles['karaoke']['top_padding']}")
+
+                # Scale down font size for preview if it exists
+                if "karaoke" in self.config.styles and "font_size" in self.config.styles["karaoke"]:
+                    self.logger.info(f"Preview mode: Found font_size: {self.config.styles['karaoke']['font_size']}")
+                    original_font_size = self.config.styles["karaoke"]["font_size"]
+                    if original_font_size is not None:
+                        # Scale down from 4K (2160p) to 360p - factor of 1/6
+                        self.font_size = original_font_size * scale_factor
+                        self.config.styles["karaoke"]["font_size"] = self.font_size
+                        self.logger.info(f"Preview mode: Scaled down font_size to: {self.font_size}")
+
+            # Initialize subtitle generator with potentially scaled values
             self.subtitle = SubtitlesGenerator(
                 output_dir=self.config.output_dir,
                 video_resolution=self.video_resolution_num,
@@ -102,7 +131,6 @@ class OutputGenerator:
         audio_filepath: str,
         artist: Optional[str] = None,
         title: Optional[str] = None,
-        preview_mode: bool = False,
     ) -> OutputPaths:
         """Generate all requested output formats."""
         outputs = OutputPaths()
@@ -116,7 +144,7 @@ class OutputGenerator:
                 transcription_corrected.resized_segments = resized_segments
 
                 # For preview, we only need to generate ASS and video
-                if preview_mode:
+                if self.preview_mode:
                     # Generate ASS subtitles for preview
                     outputs.ass = self.subtitle.generate_ass(transcription_corrected.resized_segments, output_prefix, audio_filepath)
 

lyrics_transcriber/review/server.py

@@ -2,8 +2,8 @@ import logging
 import socket
 from fastapi import FastAPI, Body, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from typing import Dict, Any, List
-from lyrics_transcriber.types import CorrectionResult, WordCorrection, LyricsSegment
+from typing import Dict, Any, List, Optional
+from lyrics_transcriber.types import CorrectionResult, WordCorrection, LyricsSegment, LyricsData, LyricsMetadata, Word
 import time
 import os
 import urllib.parse
@@ -18,6 +18,7 @@ from lyrics_transcriber.output.generator import OutputGenerator
 import json
 from lyrics_transcriber.correction.corrector import LyricsCorrector
 from lyrics_transcriber.types import TranscriptionResult, TranscriptionData
+from lyrics_transcriber.lyrics.user_input_provider import UserInputProvider
 
 
 class ReviewServer:
@@ -73,6 +74,7 @@ class ReviewServer:
         self.app.add_api_route("/api/audio/{audio_hash}", self.get_audio, methods=["GET"])
         self.app.add_api_route("/api/ping", self.ping, methods=["GET"])
         self.app.add_api_route("/api/handlers", self.update_handlers, methods=["POST"])
+        self.app.add_api_route("/api/add-lyrics", self.add_lyrics, methods=["POST"])
 
     async def get_correction_data(self):
         """Get the correction data."""
@@ -83,8 +85,8 @@ class ReviewServer:
         return CorrectionResult(
             corrections=[
                 WordCorrection(
-                    original_word=c.get("original_word", ""),
-                    corrected_word=c.get("corrected_word", ""),
+                    original_word=c.get("original_word", "").strip(),
+                    corrected_word=c.get("corrected_word", "").strip(),
                     original_position=c.get("original_position", 0),
                     source=c.get("source", "review"),
                     reason=c.get("reason", "manual_review"),
@@ -103,7 +105,26 @@ class ReviewServer:
                 )
                 for c in updated_data["corrections"]
             ],
-            corrected_segments=[LyricsSegment.from_dict(s) for s in updated_data["corrected_segments"]],
+            corrected_segments=[
+                LyricsSegment(
+                    id=s["id"],
+                    text=s["text"].strip(),
+                    words=[
+                        Word(
+                            id=w["id"],
+                            text=w["text"].strip(),
+                            start_time=w["start_time"],
+                            end_time=w["end_time"],
+                            confidence=w.get("confidence"),
+                            created_during_correction=w.get("created_during_correction", False),
+                        )
+                        for w in s["words"]
+                    ],
+                    start_time=s["start_time"],
+                    end_time=s["end_time"],
+                )
+                for s in updated_data["corrected_segments"]
+            ],
             # Copy existing fields from the base result
             original_segments=base_result.original_segments,
             corrections_made=len(updated_data["corrections"]),
@@ -166,7 +187,7 @@ class ReviewServer:
                 styles=self.output_config.styles,
                 max_line_length=self.output_config.max_line_length,
             )
-            output_generator = OutputGenerator(config=preview_config, logger=self.logger)
+            output_generator = OutputGenerator(config=preview_config, logger=self.logger, preview_mode=True)
 
             # Generate preview outputs with unique prefix
             preview_outputs = output_generator.generate_outputs(
@@ -174,7 +195,6 @@ class ReviewServer:
                 lyrics_results={},  # Empty dict since we don't need lyrics results for preview
                 output_prefix=f"preview_{preview_hash}",  # Include hash in filename
                 audio_filepath=self.audio_filepath,
-                preview_mode=True,
             )
 
             if not preview_outputs.video:
@@ -238,13 +258,58 @@ class ReviewServer:
                 source="original",
             )
 
-            # Run correction
+            # Get currently enabled handlers from metadata
+            enabled_handlers = None
+            if self.correction_result.metadata:
+                if "enabled_handlers" in self.correction_result.metadata:
+                    enabled_handlers = self.correction_result.metadata["enabled_handlers"]
+                    self.logger.info(f"Found existing enabled handlers in metadata: {enabled_handlers}")
+                elif "available_handlers" in self.correction_result.metadata:
+                    # If no enabled_handlers but we have available_handlers, enable all default handlers
+                    enabled_handlers = [
+                        handler["id"] for handler in self.correction_result.metadata["available_handlers"] if handler.get("enabled", True)
+                    ]
+                    self.logger.info(f"No enabled handlers found in metadata, using default enabled handlers: {enabled_handlers}")
+                else:
+                    self.logger.warning("No handler configuration found in metadata")
+
+            # Log reference sources before correction
+            for source, lyrics in self.correction_result.reference_lyrics.items():
+                word_count = sum(len(s.words) for s in lyrics.segments)
+                self.logger.info(f"Reference source '{source}': {word_count} words in {len(lyrics.segments)} segments")
+
+            # Rerun correction with updated reference lyrics
+            self.logger.info("Initializing LyricsCorrector for re-correction")
+            self.logger.info(f"Passing enabled handlers to corrector: {enabled_handlers or '[]'}")
+            corrector = LyricsCorrector(
+                cache_dir=self.output_config.cache_dir,
+                enabled_handlers=enabled_handlers,  # Pass the preserved handlers or None to use defaults
+                logger=self.logger,
+            )
+
+            self.logger.info(f"Active correction handlers: {[h.__class__.__name__ for h in corrector.handlers]}")
+            self.logger.info("Running correction with updated reference lyrics")
             self.correction_result = corrector.run(
                 transcription_results=[TranscriptionResult(name="original", priority=1, result=transcription_data)],
                 lyrics_results=self.correction_result.reference_lyrics,
                 metadata=self.correction_result.metadata,
             )
 
+            # Update metadata with the new handler state from corrector
+            if not self.correction_result.metadata:
+                self.correction_result.metadata = {}
+            self.correction_result.metadata.update(
+                {
+                    "available_handlers": corrector.all_handlers,
+                    "enabled_handlers": [getattr(handler, "name", handler.__class__.__name__) for handler in corrector.handlers],
+                }
+            )
+
+            self.logger.info("Correction process completed")
+            self.logger.info(
+                f"Updated metadata with {len(corrector.handlers)} enabled handlers: {self.correction_result.metadata['enabled_handlers']}"
+            )
+
             # Restore audio hash
             if audio_hash:
                 if not self.correction_result.metadata:
@@ -256,6 +321,171 @@ class ReviewServer:
             self.logger.error(f"Failed to update handlers: {str(e)}")
             raise HTTPException(status_code=500, detail=str(e))
 
+    def _create_lyrics_data_from_text(self, text: str, source: str) -> LyricsData:
+        """Create LyricsData object from plain text lyrics."""
+        self.logger.info(f"Creating LyricsData for source '{source}'")
+
+        # Split text into lines and create segments
+        lines = [line.strip() for line in text.split("\n") if line.strip()]
+        self.logger.info(f"Found {len(lines)} non-empty lines in input text")
+
+        segments = []
+        for i, line in enumerate(lines):
+            # Split line into words
+            word_texts = line.strip().split()
+            words = []
+
+            for j, word_text in enumerate(word_texts):
+                word = Word(
+                    id=f"manual_{source}_word_{i}_{j}",  # Create unique ID for each word
+                    text=word_text,
+                    start_time=0.0,  # Placeholder timing
+                    end_time=0.0,
+                    confidence=1.0,  # Reference lyrics are considered ground truth
+                    created_during_correction=False,
+                )
+                words.append(word)
+
+            segments.append(
+                LyricsSegment(
+                    id=f"manual_{source}_{i}",
+                    text=line,
+                    words=words,  # Now including the word objects
+                    start_time=0.0,  # Placeholder timing
+                    end_time=0.0,
+                )
+            )
+
+        # Create metadata
+        self.logger.info("Creating metadata for LyricsData")
+        metadata = LyricsMetadata(
+            source=source,
+            track_name=self.correction_result.metadata.get("title", "") or "",
+            artist_names=self.correction_result.metadata.get("artist", "") or "",
+            is_synced=False,
+            lyrics_provider="manual",
+            lyrics_provider_id="",
+            album_name=None,
+            duration_ms=None,
+            explicit=None,
+            language=None,
+            provider_metadata={},
+        )
+        self.logger.info(f"Created metadata: {metadata}")
+
+        lyrics_data = LyricsData(segments=segments, metadata=metadata, source=source)
+        self.logger.info(f"Created LyricsData with {len(segments)} segments and {sum(len(s.words) for s in segments)} total words")
+
+        return lyrics_data
+
+    async def add_lyrics(self, data: Dict[str, str] = Body(...)):
+        """Add new lyrics source and rerun correction."""
+        try:
+            # Store existing audio hash
+            audio_hash = self.correction_result.metadata.get("audio_hash") if self.correction_result.metadata else None
+
+            source = data.get("source", "").strip()
+            lyrics_text = data.get("lyrics", "").strip()
+
+            self.logger.info(f"Received request to add lyrics source '{source}' with {len(lyrics_text)} characters")
+
+            if not source or not lyrics_text:
+                self.logger.warning("Invalid request: missing source or lyrics text")
+                raise HTTPException(status_code=400, detail="Source name and lyrics text are required")
+
+            # Validate source name isn't already used
+            if source in self.correction_result.reference_lyrics:
+                self.logger.warning(f"Source name '{source}' is already in use")
+                raise HTTPException(status_code=400, detail=f"Source name '{source}' is already in use")
+
+            # Create lyrics data using the provider
+            self.logger.info("Creating LyricsData using UserInputProvider")
+            provider = UserInputProvider(
+                lyrics_text=lyrics_text, source_name=source, metadata=self.correction_result.metadata or {}, logger=self.logger
+            )
+            lyrics_data = provider._convert_result_format({"text": lyrics_text, "metadata": self.correction_result.metadata or {}})
+            self.logger.info(f"Created LyricsData with {len(lyrics_data.segments)} segments")
+
+            # Add to reference lyrics
+            self.logger.info(f"Adding new source '{source}' to reference_lyrics")
+            self.correction_result.reference_lyrics[source] = lyrics_data
+            self.logger.info(f"Now have {len(self.correction_result.reference_lyrics)} total reference sources")
+
+            # Create TranscriptionData from original segments
+            self.logger.info("Creating TranscriptionData from original segments")
+            transcription_data = TranscriptionData(
+                segments=self.correction_result.original_segments,
+                words=[word for segment in self.correction_result.original_segments for word in segment.words],
+                text="\n".join(segment.text for segment in self.correction_result.original_segments),
+                source="original",
+            )
+
+            # Get currently enabled handlers from metadata
+            enabled_handlers = None
+            if self.correction_result.metadata:
+                if "enabled_handlers" in self.correction_result.metadata:
+                    enabled_handlers = self.correction_result.metadata["enabled_handlers"]
+                    self.logger.info(f"Found existing enabled handlers in metadata: {enabled_handlers}")
+                elif "available_handlers" in self.correction_result.metadata:
+                    # If no enabled_handlers but we have available_handlers, enable all default handlers
+                    enabled_handlers = [
+                        handler["id"] for handler in self.correction_result.metadata["available_handlers"] if handler.get("enabled", True)
+                    ]
+                    self.logger.info(f"No enabled handlers found in metadata, using default enabled handlers: {enabled_handlers}")
+                else:
+                    self.logger.warning("No handler configuration found in metadata")
+
+            # Log reference sources before correction
+            for source, lyrics in self.correction_result.reference_lyrics.items():
+                word_count = sum(len(s.words) for s in lyrics.segments)
+                self.logger.info(f"Reference source '{source}': {word_count} words in {len(lyrics.segments)} segments")
+
+            # Rerun correction with updated reference lyrics
+            self.logger.info("Initializing LyricsCorrector for re-correction")
+            self.logger.info(f"Passing enabled handlers to corrector: {enabled_handlers or '[]'}")
+            corrector = LyricsCorrector(
+                cache_dir=self.output_config.cache_dir,
+                enabled_handlers=enabled_handlers,  # Pass the preserved handlers or None to use defaults
+                logger=self.logger,
+            )
+
+            self.logger.info(f"Active correction handlers: {[h.__class__.__name__ for h in corrector.handlers]}")
+            self.logger.info("Running correction with updated reference lyrics")
+            self.correction_result = corrector.run(
+                transcription_results=[TranscriptionResult(name="original", priority=1, result=transcription_data)],
+                lyrics_results=self.correction_result.reference_lyrics,
+                metadata=self.correction_result.metadata,
+            )
+
+            # Update metadata with the new handler state from corrector
+            if not self.correction_result.metadata:
+                self.correction_result.metadata = {}
+            self.correction_result.metadata.update(
+                {
+                    "available_handlers": corrector.all_handlers,
+                    "enabled_handlers": [getattr(handler, "name", handler.__class__.__name__) for handler in corrector.handlers],
+                }
+            )
+
+            # Restore audio hash
+            if audio_hash:
+                if not self.correction_result.metadata:
+                    self.correction_result.metadata = {}
+                self.correction_result.metadata["audio_hash"] = audio_hash
+
+            self.logger.info("Correction process completed")
+            self.logger.info(
+                f"Updated metadata with {len(corrector.handlers)} enabled handlers: {self.correction_result.metadata['enabled_handlers']}"
+            )
+
+            return {"status": "success", "data": self.correction_result.to_dict()}
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            self.logger.error(f"Failed to add lyrics: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail=str(e))
+
     def start(self) -> CorrectionResult:
         """Start the review server and wait for completion."""
         # Generate audio hash if audio file exists