lyrics-transcriber 0.32.3__py3-none-any.whl → 0.34.0__py3-none-any.whl

lyrics_transcriber/cli/cli_main.py

@@ -60,19 +60,24 @@ def create_arg_parser() -> argparse.ArgumentParser:
     output_group.add_argument(
         "--cache_dir",
         type=Path,
-        help="Directory to cache downloaded/generated files. Default: /tmp/lyrics-transcriber-cache/",
+        help="Directory to cache downloaded/generated files. Default: ~/lyrics-transcriber-cache/",
     )
     output_group.add_argument(
         "--output_styles_json",
         type=Path,
         help="JSON file containing output style configurations for CDG and video generation",
     )
-    output_group.add_argument("--generate_cdg", action="store_true", help="Generate CDG karaoke files")
 
-    # Video options
-    video_group = parser.add_argument_group("Video Options")
-    video_group.add_argument("--render_video", action="store_true", help="Render a karaoke video with the generated lyrics")
-    video_group.add_argument(
+    # Feature control group
+    feature_group = parser.add_argument_group("Feature Control")
+    feature_group.add_argument("--skip_lyrics_fetch", action="store_true", help="Skip fetching lyrics from online sources")
+    feature_group.add_argument("--skip_transcription", action="store_true", help="Skip audio transcription process")
+    feature_group.add_argument("--skip_correction", action="store_true", help="Skip lyrics correction process")
+    feature_group.add_argument("--skip_plain_text", action="store_true", help="Skip generating plain text output files")
+    feature_group.add_argument("--skip_lrc", action="store_true", help="Skip generating LRC file")
+    feature_group.add_argument("--skip_cdg", action="store_true", help="Skip generating CDG karaoke files")
+    feature_group.add_argument("--skip_video", action="store_true", help="Skip rendering karaoke video")
+    feature_group.add_argument(
         "--video_resolution", choices=["4k", "1080p", "720p", "360p"], default="360p", help="Resolution of the karaoke video. Default: 360p"
     )
 
@@ -86,7 +91,7 @@ def parse_args(parser: argparse.ArgumentParser, args_list: list[str] | None = No
 
     # Set default cache_dir if not provided
     if not hasattr(args, "cache_dir") or args.cache_dir is None:
-        args.cache_dir = Path(os.getenv("LYRICS_TRANSCRIBER_CACHE_DIR", "/tmp/lyrics-transcriber-cache/"))
+        args.cache_dir = Path(os.getenv("LYRICS_TRANSCRIBER_CACHE_DIR", os.path.join(os.path.expanduser("~"), "lyrics-transcriber-cache")))
 
     return args
 
@@ -135,9 +140,14 @@ def create_configs(args: argparse.Namespace, env_config: Dict[str, str]) -> tupl
         output_styles_json=str(args.output_styles_json),
         output_dir=str(args.output_dir) if args.output_dir else os.getcwd(),
         cache_dir=str(args.cache_dir),
-        render_video=args.render_video,
-        generate_cdg=args.generate_cdg,
         video_resolution=args.video_resolution,
+        fetch_lyrics=not args.skip_lyrics_fetch,
+        run_transcription=not args.skip_transcription,
+        run_correction=not args.skip_correction,
+        generate_plain_text=not args.skip_plain_text,
+        generate_lrc=not args.skip_lrc,
+        generate_cdg=not args.skip_cdg,
+        render_video=not args.skip_video,
     )
 
     return transcriber_config, lyrics_config, output_config

lyrics_transcriber/core/config.py

@@ -28,8 +28,18 @@ class OutputConfig:
     max_line_length: int = 36
     styles: Dict[str, Any] = field(default_factory=dict)
     output_dir: Optional[str] = os.getcwd()
-    cache_dir: str = os.getenv("LYRICS_TRANSCRIBER_CACHE_DIR", "/tmp/lyrics-transcriber-cache/")
-    render_video: bool = False
-    generate_cdg: bool = False
-    video_resolution: str = "360p"
+    cache_dir: str = os.getenv(
+        "LYRICS_TRANSCRIBER_CACHE_DIR",
+        os.path.join(os.path.expanduser("~"), "lyrics-transcriber-cache")
+    )
+
+    fetch_lyrics: bool = True
+    run_transcription: bool = True
+    run_correction: bool = True
     enable_review: bool = True
+
+    generate_plain_text: bool = True
+    generate_lrc: bool = True
+    generate_cdg: bool = True
+    render_video: bool = True
+    video_resolution: str = "360p"

lyrics_transcriber/core/controller.py

@@ -1,12 +1,9 @@
+import difflib
 import os
 import logging
 from dataclasses import dataclass, field
 from typing import Dict, Optional, List
-from lyrics_transcriber.types import (
-    LyricsData,
-    TranscriptionResult,
-    CorrectionResult,
-)
+from lyrics_transcriber.types import LyricsData, TranscriptionResult, CorrectionResult
 from lyrics_transcriber.transcribers.base_transcriber import BaseTranscriber
 from lyrics_transcriber.transcribers.audioshake import AudioShakeTranscriber, AudioShakeConfig
 from lyrics_transcriber.transcribers.whisper import WhisperTranscriber, WhisperConfig
@@ -83,6 +80,16 @@ class LyricsTranscriber:
         self.lyrics_config = lyrics_config or LyricsConfig()
         self.output_config = output_config or OutputConfig()
 
+        # Check if styles JSON is available for CDG and video features
+        if not self.output_config.output_styles_json or not os.path.exists(self.output_config.output_styles_json):
+            if self.output_config.generate_cdg or self.output_config.render_video:
+                self.logger.warning(
+                    f"Output styles JSON file not found: {self.output_config.output_styles_json}. "
+                    "CDG and video generation will be disabled."
+                )
+                self.output_config.generate_cdg = False
+                self.output_config.render_video = False
+
         # Basic settings
         self.audio_filepath = audio_filepath
         self.artist = artist
@@ -106,6 +113,18 @@ class LyricsTranscriber:
         self.corrector = corrector or LyricsCorrector(cache_dir=self.output_config.cache_dir, logger=self.logger)
         self.output_generator = output_generator or self._initialize_output_generator()
 
+        # Log enabled features
+        self.logger.info("Enabled features:")
+        self.logger.info(f"  Lyrics fetching: {'enabled' if self.output_config.fetch_lyrics else 'disabled'}")
+        self.logger.info(f"  Transcription: {'enabled' if self.output_config.run_transcription else 'disabled'}")
+        self.logger.info(f"  Lyrics correction: {'enabled' if self.output_config.run_correction else 'disabled'}")
+        self.logger.info(f"  Plain text output: {'enabled' if self.output_config.generate_plain_text else 'disabled'}")
+        self.logger.info(f"  LRC file generation: {'enabled' if self.output_config.generate_lrc else 'disabled'}")
+        self.logger.info(f"  CDG file generation: {'enabled' if self.output_config.generate_cdg else 'disabled'}")
+        self.logger.info(f"  Video rendering: {'enabled' if self.output_config.render_video else 'disabled'}")
+        if self.output_config.render_video:
+            self.logger.info(f"    Video resolution: {self.output_config.video_resolution}")
+
     def _initialize_transcribers(self) -> Dict[str, BaseTranscriber]:
         """Initialize available transcription services."""
         transcribers = {}
@@ -175,27 +194,27 @@ class LyricsTranscriber:
         return OutputGenerator(config=self.output_config, logger=self.logger)
 
     def process(self) -> LyricsControllerResult:
-        """
-        Main processing method that orchestrates the entire workflow.
-
-        Returns:
-            LyricsControllerResult containing all outputs and generated files.
+        """Main processing method that orchestrates the entire workflow."""
 
-        Raises:
-            Exception: If a critical error occurs during processing.
-        """
-        # Step 1: Fetch lyrics if artist and title are provided
-        if self.artist and self.title:
+        # Step 1: Fetch lyrics if enabled and artist/title are provided
+        if self.output_config.fetch_lyrics and self.artist and self.title:
             self.fetch_lyrics()
 
-        # Step 2: Run transcription
-        self.transcribe()
+        # Step 2: Run transcription if enabled
+        if self.output_config.run_transcription:
+            self.transcribe()
 
-        # Step 3: Process and correct lyrics
-        self.correct_lyrics()
+        # Step 3: Process and correct lyrics if enabled AND we have transcription results
+        if self.output_config.run_correction and self.results.transcription_results:
+            self.correct_lyrics()
+        elif self.output_config.run_correction:
+            self.logger.info("Skipping lyrics correction - no transcription results available")
 
-        # Step 4: Generate outputs
-        self.generate_outputs()
+        # Step 4: Generate outputs based on what we have
+        if self.results.transcription_corrected or self.results.lyrics_results:
+            self.generate_outputs()
+        else:
+            self.logger.warning("No corrected transcription or lyrics available. Skipping output generation.")
 
         self.logger.info("Processing completed successfully")
         return self.results
@@ -239,7 +258,32 @@ class LyricsTranscriber:
         """Run lyrics correction using transcription and internet lyrics."""
         self.logger.info("Starting lyrics correction process")
 
-        # Run correction
+        # Check if we have reference lyrics to work with
+        if not self.results.lyrics_results:
+            self.logger.warning("No reference lyrics available for correction - using raw transcription")
+            # Use the highest priority transcription result as the "corrected" version
+            if self.results.transcription_results:
+                sorted_results = sorted(self.results.transcription_results, key=lambda x: x.priority)
+                best_transcription = sorted_results[0]
+
+                # Create a CorrectionResult with no corrections
+                self.results.transcription_corrected = CorrectionResult(
+                    original_segments=best_transcription.result.segments,
+                    corrected_segments=best_transcription.result.segments,
+                    corrected_text="",  # Will be generated from segments
+                    corrections=[],  # No corrections made
+                    corrections_made=0,  # No corrections made
+                    confidence=1.0,  # Full confidence since we're using original
+                    transcribed_text="",  # Will be generated from segments
+                    reference_texts={},
+                    anchor_sequences=[],
+                    gap_sequences=[],
+                    resized_segments=[],  # Will be populated later
+                    metadata={"correction_type": "none", "reason": "no_reference_lyrics"},
+                )
+            return
+
+        # Run correction if we have reference lyrics
         corrected_data = self.corrector.run(
             transcription_results=self.results.transcription_results, lyrics_results=self.results.lyrics_results
         )
@@ -249,19 +293,60 @@ class LyricsTranscriber:
         self.logger.info("Lyrics correction completed")
 
         # Add human review step
-        if self.output_config.enable_review:  # We'll need to add this config option
+        if self.output_config.enable_review:
             from ..review import start_review_server
+            import json
+            from copy import deepcopy
 
             self.logger.info("Starting human review process")
-            self.results.transcription_corrected = start_review_server(corrected_data)
+
+            def normalize_data(data_dict):
+                """Normalize numeric values in the data structure before JSON conversion."""
+                if isinstance(data_dict, dict):
+                    return {k: normalize_data(v) for k, v in data_dict.items()}
+                elif isinstance(data_dict, list):
+                    return [normalize_data(item) for item in data_dict]
+                elif isinstance(data_dict, float):
+                    # Convert whole number floats to integers
+                    if data_dict.is_integer():
+                        return int(data_dict)
+                    return data_dict
+                return data_dict
+
+            # Normalize and convert auto-corrected data
+            auto_data = normalize_data(deepcopy(self.results.transcription_corrected.to_dict()))
+            auto_corrected_json = json.dumps(auto_data, indent=4).splitlines()
+
+            # Pass through review server
+            reviewed_data = start_review_server(self.results.transcription_corrected)
+
+            # Normalize and convert reviewed data
+            human_data = normalize_data(deepcopy(reviewed_data.to_dict()))
+            human_corrected_json = json.dumps(human_data, indent=4).splitlines()
+
             self.logger.info("Human review completed")
 
+            # Compare the normalized JSON strings
+            diff = list(
+                difflib.unified_diff(auto_corrected_json, human_corrected_json, fromfile="auto-corrected", tofile="human-corrected")
+            )
+
+            if diff:
+                self.logger.warning("Changes made by human review:")
+                for line in diff:
+                    self.logger.warning(line.rstrip())
+
+            # exit(1)
+
     def generate_outputs(self) -> None:
-        """Generate output files."""
+        """Generate output files based on enabled features and available data."""
         self.logger.info("Generating output files")
 
+        # Only proceed with outputs that make sense based on what we have
+        has_correction = bool(self.results.transcription_corrected)
+
         output_files = self.output_generator.generate_outputs(
-            transcription_corrected=self.results.transcription_corrected,
+            transcription_corrected=self.results.transcription_corrected if has_correction else None,
             lyrics_results=self.results.lyrics_results,
             output_prefix=self.output_prefix,
             audio_filepath=self.audio_filepath,
@@ -269,7 +354,7 @@ class LyricsTranscriber:
             title=self.title,
         )
 
-        # Store all output paths in results
+        # Store results
         self.results.lrc_filepath = output_files.lrc
         self.results.ass_filepath = output_files.ass
         self.results.video_filepath = output_files.video

lyrics_transcriber/correction/corrector.py

@@ -28,7 +28,8 @@ class LyricsCorrector:
         logger: Optional[logging.Logger] = None,
     ):
         self.logger = logger or logging.getLogger(__name__)
-        self.anchor_finder = anchor_finder or AnchorSequenceFinder(cache_dir=cache_dir, logger=self.logger)
+        self._anchor_finder = anchor_finder
+        self._cache_dir = cache_dir
 
         # Default handlers in order of preference
         self.handlers = handlers or [
@@ -42,6 +43,13 @@ class LyricsCorrector:
             LevenshteinHandler(),
         ]
 
+    @property
+    def anchor_finder(self) -> AnchorSequenceFinder:
+        """Lazy load the anchor finder instance, initializing it if not already set."""
+        if self._anchor_finder is None:
+            self._anchor_finder = AnchorSequenceFinder(cache_dir=self._cache_dir, logger=self.logger)
+        return self._anchor_finder
+
     def run(self, transcription_results: List[TranscriptionResult], lyrics_results: List[LyricsData]) -> CorrectionResult:
         """Execute the correction process."""
         if not transcription_results:

lyrics_transcriber/lyrics/base_lyrics_provider.py

@@ -7,6 +7,7 @@ from pathlib import Path
 import os
 from abc import ABC, abstractmethod
 from lyrics_transcriber.types import LyricsData
+from karaoke_lyrics_processor import KaraokeLyricsProcessor
 
 
 @dataclass
@@ -17,6 +18,7 @@ class LyricsProviderConfig:
     spotify_cookie: Optional[str] = None
     cache_dir: Optional[str] = None
     audio_filepath: Optional[str] = None
+    max_line_length: int = 36  # New config parameter for KaraokeLyricsProcessor
 
 
 class BaseLyricsProvider(ABC):
@@ -26,6 +28,7 @@ class BaseLyricsProvider(ABC):
         self.logger = logger or logging.getLogger(__name__)
         self.cache_dir = Path(config.cache_dir) if config.cache_dir else None
         self.audio_filepath = config.audio_filepath
+        self.max_line_length = config.max_line_length
         if self.cache_dir:
             self.cache_dir.mkdir(parents=True, exist_ok=True)
             self.logger.debug(f"Initialized {self.__class__.__name__} with cache dir: {self.cache_dir}")
@@ -35,21 +38,22 @@ class BaseLyricsProvider(ABC):
         if not self.cache_dir:
             return self._fetch_and_convert_result(artist, title)
 
-        file_hash = self._get_file_hash(self.audio_filepath)
-        raw_cache_path = self._get_cache_path(file_hash, "raw")
+        # Use artist and title for cache key instead of audio file hash
+        cache_key = self._get_artist_title_hash(artist, title)
+        raw_cache_path = self._get_cache_path(cache_key, "raw")
 
         # Try to load from cache first
         raw_data = self._load_from_cache(raw_cache_path)
         if raw_data is not None:
             self.logger.info(f"Using cached lyrics for {artist} - {title}")
-            return self._save_and_convert_result(file_hash, raw_data)
+            return self._save_and_convert_result(cache_key, raw_data)
 
         # If not in cache, fetch from source
         raw_result = self._fetch_data_from_source(artist, title)
         if raw_result:
             # Save raw API response
             self._save_to_cache(raw_cache_path, raw_result)
-            return self._save_and_convert_result(file_hash, raw_result)
+            return self._save_and_convert_result(cache_key, raw_result)
 
         return None
 
@@ -95,13 +99,30 @@ class BaseLyricsProvider(ABC):
             self.logger.warning(f"Cache file {cache_path} is corrupted")
             return None
 
+    def _process_lyrics(self, lyrics_data: LyricsData) -> LyricsData:
+        """Process lyrics using KaraokeLyricsProcessor."""
+        processor = KaraokeLyricsProcessor(
+            log_level=self.logger.getEffectiveLevel(),
+            log_formatter=self.logger.handlers[0].formatter if self.logger.handlers else None,
+            input_lyrics_text=lyrics_data.lyrics,
+            max_line_length=self.max_line_length,
+        )
+        processed_text = processor.process()
+
+        # Create new LyricsData with processed text
+        return LyricsData(source=lyrics_data.source, lyrics=processed_text, segments=lyrics_data.segments, metadata=lyrics_data.metadata)
+
     def _save_and_convert_result(self, cache_key: str, raw_data: Dict[str, Any]) -> LyricsData:
-        """Convert raw result to standardized format, save to cache, and return."""
+        """Convert raw result to standardized format, process lyrics, save to cache, and return."""
         converted_cache_path = self._get_cache_path(cache_key, "converted")
         converted_result = self._convert_result_format(raw_data)
+
+        # Process the lyrics
+        processed_result = self._process_lyrics(converted_result)
+
         # Convert to dictionary before saving to cache
-        self._save_to_cache(converted_cache_path, converted_result.to_dict())
-        return converted_result
+        self._save_to_cache(converted_cache_path, processed_result.to_dict())
+        return processed_result
 
     def _fetch_and_convert_result(self, artist: str, title: str) -> Optional[LyricsData]:
         """Fetch and convert result when caching is disabled."""

lyrics_transcriber/lyrics/genius.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from typing import Optional, Dict, Any
 import lyricsgenius
 from lyrics_transcriber.types import LyricsData, LyricsMetadata
@@ -13,9 +14,15 @@ class GeniusProvider(BaseLyricsProvider):
         self.api_token = config.genius_api_token
         self.client = None
         if self.api_token:
-            self.client = lyricsgenius.Genius(self.api_token)
-            self.client.verbose = False
-            self.client.remove_section_headers = True
+            self.client = lyricsgenius.Genius(
+                self.api_token,
+                verbose=(logger.getEffectiveLevel() == logging.DEBUG if logger else False),
+                remove_section_headers=True,  # Remove [Chorus], [Verse], etc.
+                skip_non_songs=True,  # Skip track listings and other non-song results
+                timeout=10,  # Reasonable timeout for requests
+                retries=3,  # Number of retries for failed requests
+                sleep_time=1,  # Small delay between requests to be nice to the API
+            )
 
     def _fetch_data_from_source(self, artist: str, title: str) -> Optional[Dict[str, Any]]:
         """Fetch raw song data from Genius API."""
@@ -35,6 +42,9 @@ class GeniusProvider(BaseLyricsProvider):
 
     def _convert_result_format(self, raw_data: Dict[str, Any]) -> LyricsData:
         """Convert Genius's raw API response to standardized format."""
+        # Clean the lyrics before processing
+        lyrics = self._clean_lyrics(raw_data.get("lyrics", ""))
+
         # Extract release date components if available
         release_date = None
         if release_components := raw_data.get("release_date_components"):
@@ -68,6 +78,23 @@ class GeniusProvider(BaseLyricsProvider):
         )
 
         # Create result object
-        return LyricsData(
-            source="genius", lyrics=raw_data.get("lyrics", ""), segments=[], metadata=metadata
-        )  # Genius doesn't provide timestamp data
+        return LyricsData(source="genius", lyrics=lyrics, segments=[], metadata=metadata)
+
+    def _clean_lyrics(self, lyrics: str) -> str:
+        """Clean and process lyrics from Genius to remove unwanted content."""
+
+        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
+        return lyrics

lyrics_transcriber/output/generator.py

@@ -95,7 +95,7 @@ class OutputGenerator:
 
     def generate_outputs(
         self,
-        transcription_corrected: CorrectionResult,
+        transcription_corrected: Optional[CorrectionResult],
         lyrics_results: List[LyricsData],
         output_prefix: str,
         audio_filepath: str,
@@ -110,35 +110,37 @@ class OutputGenerator:
             for lyrics_data in lyrics_results:
                 self.plain_text.write_lyrics(lyrics_data, output_prefix)
 
-            # Write original (uncorrected) transcription
-            outputs.original_txt = self.plain_text.write_original_transcription(transcription_corrected, output_prefix)
-
-            # Resize corrected segments to ensure none are longer than max_line_length
-            resized_segments = self.segment_resizer.resize_segments(transcription_corrected.corrected_segments)
-            transcription_corrected.resized_segments = resized_segments
-            outputs.corrections_json = self.write_corrections_data(transcription_corrected, output_prefix)
-
-            # Write corrected lyrics as plain text
-            outputs.corrected_txt = self.plain_text.write_corrected_lyrics(resized_segments, output_prefix)
-
-            # Generate LRC using LyricsFileGenerator
-            outputs.lrc = self.lyrics_file.generate_lrc(resized_segments, output_prefix)
-
-            # Generate CDG file if requested
-            if self.config.generate_cdg:
-                outputs.cdg, outputs.mp3, outputs.cdg_zip = self.cdg.generate_cdg(
-                    segments=resized_segments,
-                    audio_file=audio_filepath,
-                    title=title or output_prefix,
-                    artist=artist or "",
-                    cdg_styles=self.config.styles["cdg"],
-                )
-
-            # Generate video if requested
-            if self.config.render_video:
-                # Generate ASS subtitles
-                outputs.ass = self.subtitle.generate_ass(resized_segments, output_prefix, audio_filepath)
-                outputs.video = self.video.generate_video(outputs.ass, audio_filepath, output_prefix)
+            # Only process transcription-related outputs if we have transcription data
+            if transcription_corrected:
+                # Write original (uncorrected) transcription
+                outputs.original_txt = self.plain_text.write_original_transcription(transcription_corrected, output_prefix)
+
+                # Resize corrected segments to ensure none are longer than max_line_length
+                resized_segments = self.segment_resizer.resize_segments(transcription_corrected.corrected_segments)
+                transcription_corrected.resized_segments = resized_segments
+                outputs.corrections_json = self.write_corrections_data(transcription_corrected, output_prefix)
+
+                # Write corrected lyrics as plain text
+                outputs.corrected_txt = self.plain_text.write_corrected_lyrics(resized_segments, output_prefix)
+
+                # Generate LRC using LyricsFileGenerator
+                outputs.lrc = self.lyrics_file.generate_lrc(resized_segments, output_prefix)
+
+                # Generate CDG file if requested
+                if self.config.generate_cdg:
+                    outputs.cdg, outputs.mp3, outputs.cdg_zip = self.cdg.generate_cdg(
+                        segments=resized_segments,
+                        audio_file=audio_filepath,
+                        title=title or output_prefix,
+                        artist=artist or "",
+                        cdg_styles=self.config.styles["cdg"],
+                    )
+
+                # Generate video if requested
+                if self.config.render_video:
+                    # Generate ASS subtitles
+                    outputs.ass = self.subtitle.generate_ass(resized_segments, output_prefix, audio_filepath)
+                    outputs.video = self.video.generate_video(outputs.ass, audio_filepath, output_prefix)
 
             return outputs
 

lyrics_transcriber/output/segment_resizer.py

@@ -123,8 +123,9 @@ class SegmentResizer:
                 LyricsSegment(text="Here's another one.", ...)
             ]
         """
-        self.logger.info(f"Processing oversized segment {segment_idx}: '{segment.text}'")
         segment_text = self._clean_text(segment.text)
+
+        self.logger.info(f"Processing oversized segment {segment_idx}: '{segment_text}'")
         split_lines = self._process_segment_text(segment_text)
         self.logger.debug(f"Split into {len(split_lines)} lines: {split_lines}")
 
@@ -163,7 +164,7 @@ class SegmentResizer:
                     if word_pos != -1:
                         line_words.append(words_to_process.pop(0))
                         # Remove the word and any following spaces from remaining line
-                        remaining_line = remaining_line[word_pos + len(word_clean):].strip()
+                        remaining_line = remaining_line[word_pos + len(word_clean) :].strip()
                         continue
 
                 # If we can't find the word in the remaining line, we're done with this line

lyrics_transcriber/review/server.py

@@ -2,7 +2,7 @@ import logging
 from fastapi import FastAPI, Body
 from fastapi.middleware.cors import CORSMiddleware
 from typing import Optional, Dict, Any
-from ..types import CorrectionResult
+from ..types import CorrectionResult, WordCorrection, LyricsSegment
 import time
 import subprocess
 import os
@@ -64,16 +64,22 @@ async def complete_review(updated_data: Dict[str, Any] = Body(...)):
     Mark the review as complete and update the correction data.
 
     Args:
-        updated_data: The complete correction result data with any modifications
+        updated_data: Dictionary containing corrections and corrected_segments
     """
     global review_completed, current_review
 
     logger.info("Received updated correction data")
 
     try:
-        # Update the current review with modified data
-        # We use from_dict to ensure the data is properly structured
-        current_review = CorrectionResult.from_dict(updated_data)
+        # Only update the specific fields that were modified
+        if current_review is None:
+            raise ValueError("No review in progress")
+
+        # Update only the corrections and corrected_segments
+        current_review.corrections = [WordCorrection.from_dict(c) for c in updated_data["corrections"]]
+        current_review.corrected_segments = [LyricsSegment.from_dict(s) for s in updated_data["corrected_segments"]]
+        current_review.corrections_made = len(current_review.corrections)
+
         logger.info(f"Successfully updated correction data with {len(current_review.corrections)} corrections")
 
         review_completed = True

{lyrics_transcriber-0.32.3.dist-info → lyrics_transcriber-0.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lyrics-transcriber
-Version: 0.32.3
+Version: 0.34.0
 Summary: Automatically create synchronised lyrics files in ASS and MidiCo LRC formats with word-level timestamps, using Whisper and lyrics from Genius and Spotify
 License: MIT
 Author: Andrew Beveridge

{lyrics_transcriber-0.32.3.dist-info → lyrics_transcriber-0.34.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 lyrics_transcriber/__init__.py,sha256=JpdjDK1MH_Be2XiSQWnb4i5Bbil1uPMA_KcuDZ3cyUI,240
 lyrics_transcriber/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lyrics_transcriber/cli/cli_main.py,sha256=pquvPfhw6brNgUyMuAzXfCUXNN0NM5tP_MyxlLWqNPc,8968
+lyrics_transcriber/cli/cli_main.py,sha256=TFB7CwzgLuwPfoV7ggPPe5dh4WKNcWRoZkCu_WWUcLQ,9818
 lyrics_transcriber/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lyrics_transcriber/core/config.py,sha256=eddocVn_VoBGRqgBzfSvO7EZp3NuoGfSmd6mcT8wa74,941
-lyrics_transcriber/core/controller.py,sha256=eQ0M67SWIA-hr23fkw6F8hmqKkklOHsxOsJnYQLXFBE,12184
+lyrics_transcriber/core/config.py,sha256=y6MsAL0gFz7zRErtRRF81Z0vFOrySIrCw2aKDHExBz8,1160
+lyrics_transcriber/core/controller.py,sha256=o3nGoNWFGbeXAKtqbWFArede1UNmCip8U1bn8viVlwo,17493
 lyrics_transcriber/correction/anchor_sequence.py,sha256=YpKyY24Va5i4JgzP9ssqlOIkaYu060KaldiehbfgTdk,22200
-lyrics_transcriber/correction/corrector.py,sha256=VOM6YhbANu00rYs6JpKHGZXnZtD5fxArnYtRrsp1YM4,12998
+lyrics_transcriber/correction/corrector.py,sha256=SFEmueWtTUipztVDaV8yTDsKp8XMHBZcZ343Z5NHSLE,13303
 lyrics_transcriber/correction/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lyrics_transcriber/correction/handlers/base.py,sha256=Vanmp6ykP5cdejuJ5ttzjP0Wl4JgKBL-mHbo9EFaeVc,1009
 lyrics_transcriber/correction/handlers/extend_anchor.py,sha256=9rBrZPmc4grMSnCL2ilkcBsWHc05s6RBL9GDyNAplJk,3821
@@ -19,8 +19,8 @@ lyrics_transcriber/correction/handlers/word_count_match.py,sha256=zbyZ01VE_6azaF
 lyrics_transcriber/correction/handlers/word_operations.py,sha256=2COTaJsEwpSWyXHXmGgjfcf2x7tbAnsQ0dIW0qyHYK4,5141
 lyrics_transcriber/correction/phrase_analyzer.py,sha256=dtO_2LjxnPdHJM7De40mYIdHCkozwhizVVQp5XGO7x0,16962
 lyrics_transcriber/correction/text_utils.py,sha256=VkOqgZHa9wEqLJdVNi4-KLFojQ6d4lWOGl_Y_vknenU,808
-lyrics_transcriber/lyrics/base_lyrics_provider.py,sha256=i4wxzu8nk2a3NDtnB_4r6rOGBZ7WvJFVlcEBjAkUYgI,5511
-lyrics_transcriber/lyrics/genius.py,sha256=M4rs3yk5RKW-RYfMm9w-UxwKQ8itgYeM-kVS6LCn8D0,3295
+lyrics_transcriber/lyrics/base_lyrics_provider.py,sha256=l61XJCvazt7wb6_vIQ23N8x9Otane8Pac5nvnBVCig8,6563
+lyrics_transcriber/lyrics/genius.py,sha256=x8dNOygrDRZgwK0v2qK6F6wmqGEIiXe_Edgx-IkNWHA,5003
 lyrics_transcriber/lyrics/spotify.py,sha256=9n4n98xS_BrpTPZg-24n0mzyPk9vkdmhy6T8ei8imh4,3599
 lyrics_transcriber/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lyrics_transcriber/output/ass/__init__.py,sha256=EYQ45gI7_-vclVgzISL0ML8VgxCdB0odqEyPyiPCIw0,578
@@ -65,22 +65,22 @@ lyrics_transcriber/output/fonts/Zurich_Cn_BT_Bold.ttf,sha256=WNG5LOQ-uGUF_WWT5aQ
 lyrics_transcriber/output/fonts/arial.ttf,sha256=NcDzVZ2NtWnjbDEJW4pg1EFkPZX1kTneQOI_ragZuDM,275572
 lyrics_transcriber/output/fonts/georgia.ttf,sha256=fQuyDGMrtZ6BoIhfVzvSFz9x9zIE3pBY_raM4DIicHI,142964
 lyrics_transcriber/output/fonts/verdana.ttf,sha256=lu0UlJyktzks_yNbnEHVXBJTgqu-DA08K53WaJfK4Ms,139640
-lyrics_transcriber/output/generator.py,sha256=HQa3Ft8SKJie9-cYO0NKDbAU2-h_YnnH5wACxj0qFKw,7482
+lyrics_transcriber/output/generator.py,sha256=W_wUo3Plt0A_H48WGbti4NeiE6eZAW-iRLwDnEOPkts,7715
 lyrics_transcriber/output/lyrics_file.py,sha256=_KQyQjCOMIwQdQ0115uEAUIjQWTRmShkSfQuINPKxaw,3741
 lyrics_transcriber/output/plain_text.py,sha256=3mYKq0BLYz1rGBD6ROjG2dn6BPuzbn5dxIQbWZVi4ao,3689
-lyrics_transcriber/output/segment_resizer.py,sha256=xkKCNt4CTdTErUTYsYtjmllKY8YHny1srqQMrJQYbK8,17141
+lyrics_transcriber/output/segment_resizer.py,sha256=b553FCdcjYAl9T1IA5K6ya0pcn1-irD5spmxSc26wnI,17143
 lyrics_transcriber/output/subtitles.py,sha256=BQy7N_2zdBBWEiHL0NWFz3ZgAerWqQvTLALgxxK3Etk,16920
 lyrics_transcriber/output/video.py,sha256=kYGeEMYtoJvrGnMuyNpuSmu2DTskGDXBNlrv6ddvC8I,8485
 lyrics_transcriber/review/__init__.py,sha256=_3Eqw-uXZhOZwo6_sHZLhP9vxAVkLF9EBXduUvPdLjQ,57
-lyrics_transcriber/review/server.py,sha256=iAG0WUkGrqnAF7dI4ZQQayp2qaamqGGYT6rWJF9OysI,4397
+lyrics_transcriber/review/server.py,sha256=xUW55PhAeCKldXFm6F2X7waYid5vI_BsiPSoF4KnO0g,4744
 lyrics_transcriber/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lyrics_transcriber/storage/dropbox.py,sha256=Dyam1ULTkoxD1X5trkZ5dGp5XhBGCn998moC8IS9-68,9804
 lyrics_transcriber/transcribers/audioshake.py,sha256=QzKGimVa6BovlvYFj35CbGpaGePI_DApAJGEBR_JQLc,8709
 lyrics_transcriber/transcribers/base_transcriber.py,sha256=yPzUWPTCGmzE97H5Rz6g61e-qEGL77ZzUoiBOmswhts,5973
 lyrics_transcriber/transcribers/whisper.py,sha256=P0kas2_oX16MO1-Qy7U5gl5KQN-RuUIJZz7LsEFLUiE,12906
 lyrics_transcriber/types.py,sha256=xGf3hkTRcGZTTAjMVIev2i2DOU6co0QGpW8NxvaBQAA,16759
-lyrics_transcriber-0.32.3.dist-info/LICENSE,sha256=BiPihPDxhxIPEx6yAxVfAljD5Bhm_XG2teCbPEj_m0Y,1069
-lyrics_transcriber-0.32.3.dist-info/METADATA,sha256=gKyuaWObELiKS3aopmqaSo-mvaA4-Via4Q8vza819zs,5856
-lyrics_transcriber-0.32.3.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-lyrics_transcriber-0.32.3.dist-info/entry_points.txt,sha256=ChnmR13YoalGnC3sHW0TppX5FbhEXntYIha24tVQJ1M,104
-lyrics_transcriber-0.32.3.dist-info/RECORD,,
+lyrics_transcriber-0.34.0.dist-info/LICENSE,sha256=BiPihPDxhxIPEx6yAxVfAljD5Bhm_XG2teCbPEj_m0Y,1069
+lyrics_transcriber-0.34.0.dist-info/METADATA,sha256=-NmP0C2ecou2bru2kFgDVCchjN10D-QdZsigcETfCFM,5856
+lyrics_transcriber-0.34.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+lyrics_transcriber-0.34.0.dist-info/entry_points.txt,sha256=ChnmR13YoalGnC3sHW0TppX5FbhEXntYIha24tVQJ1M,104
+lyrics_transcriber-0.34.0.dist-info/RECORD,,