lyrics-transcriber 0.30.1__tar.gz → 0.32.1__tar.gz

{lyrics_transcriber-0.30.1 → lyrics_transcriber-0.32.1}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: lyrics-transcriber
-Version: 0.30.1
+Version: 0.32.1
 Summary: Automatically create synchronised lyrics files in ASS and MidiCo LRC formats with word-level timestamps, using Whisper and lyrics from Genius and Spotify
-Home-page: https://github.com/karaokenerds/python-lyrics-transcriber
 License: MIT
 Author: Andrew Beveridge
 Author-email: andrew@beveridge.uk
@@ -14,13 +13,25 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: dropbox (>=12)
+Requires-Dist: fastapi (>=0.115.6,<0.116.0)
 Requires-Dist: karaoke-lyrics-processor (>=0.4)
 Requires-Dist: lyricsgenius (>=3)
+Requires-Dist: metaphone (>=0.6,<0.7)
+Requires-Dist: nltk (>=3.9.1,<4.0.0)
 Requires-Dist: pydub (>=0.25)
 Requires-Dist: python-dotenv (>=1)
+Requires-Dist: python-levenshtein (>=0.26.1,<0.27.0)
 Requires-Dist: python-slugify (>=8)
+Requires-Dist: spacy (>=3.8.3,<4.0.0)
+Requires-Dist: spacy-syllables (>=3.0.2,<4.0.0)
+Requires-Dist: syllables (>=1.0.9,<2.0.0)
 Requires-Dist: syrics (>=0)
+Requires-Dist: torch (>=2.5.1,<3.0.0)
+Requires-Dist: tqdm (>=4.67.1,<5.0.0)
+Requires-Dist: transformers (>=4.47.1,<5.0.0)
+Requires-Dist: uvicorn (>=0.34.0,<0.35.0)
 Project-URL: Documentation, https://github.com/karaokenerds/python-lyrics-transcriber/blob/main/README.md
+Project-URL: Homepage, https://github.com/karaokenerds/python-lyrics-transcriber
 Project-URL: Repository, https://github.com/karaokenerds/python-lyrics-transcriber
 Description-Content-Type: text/markdown
 

lyrics_transcriber-0.32.1/lyrics_transcriber/__init__.py

@@ -0,0 +1,4 @@
+from lyrics_transcriber.core.config import TranscriberConfig, LyricsConfig, OutputConfig
+from lyrics_transcriber.core.controller import LyricsTranscriber
+
+__all__ = ["LyricsTranscriber", "TranscriberConfig", "LyricsConfig", "OutputConfig"]

{lyrics_transcriber-0.30.1 → lyrics_transcriber-0.32.1}/lyrics_transcriber/cli/cli_main.py

@@ -57,12 +57,17 @@ def create_arg_parser() -> argparse.ArgumentParser:
     # Output options
     output_group = parser.add_argument_group("Output Options")
     output_group.add_argument("--output_dir", type=Path, help="Directory where output files will be saved. Default: current directory")
-
     output_group.add_argument(
         "--cache_dir",
         type=Path,
         help="Directory to cache downloaded/generated files. Default: /tmp/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")
@@ -70,12 +75,6 @@ def create_arg_parser() -> argparse.ArgumentParser:
     video_group.add_argument(
         "--video_resolution", choices=["4k", "1080p", "720p", "360p"], default="360p", help="Resolution of the karaoke video. Default: 360p"
     )
-    video_group.add_argument("--video_background_image", type=Path, help="Image file to use for karaoke video background")
-    video_group.add_argument(
-        "--video_background_color",
-        default="black",
-        help="Color for karaoke video background (hex format or FFmpeg color name). Default: black",
-    )
 
     return parser
 
@@ -133,12 +132,12 @@ def create_configs(args: argparse.Namespace, env_config: Dict[str, str]) -> tupl
     )
 
     output_config = OutputConfig(
+        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,
-        video_background_image=str(args.video_background_image) if args.video_background_image else None,
-        video_background_color=args.video_background_color,
     )
 
     return transcriber_config, lyrics_config, output_config
@@ -194,13 +193,35 @@ def main() -> None:
         # Log results
         logger.info("*** Success! ***")
 
+        # Log all generated output files
+        if results.original_txt:
+            logger.info(f"Generated original transcription: {results.original_txt}")
+        if results.corrections_json:
+            logger.info(f"Generated corrections data: {results.corrections_json}")
+
+        if results.corrected_txt:
+            logger.info(f"Generated corrected lyrics: {results.corrected_txt}")
         if results.lrc_filepath:
             logger.info(f"Generated LRC file: {results.lrc_filepath}")
+
+        if results.cdg_filepath:
+            logger.info(f"Generated CDG file: {results.cdg_filepath}")
+        if results.mp3_filepath:
+            logger.info(f"Generated MP3 file: {results.mp3_filepath}")
+        if results.cdg_zip_filepath:
+            logger.info(f"Generated CDG ZIP archive: {results.cdg_zip_filepath}")
+
         if results.ass_filepath:
-            logger.info(f"Generated ASS file: {results.ass_filepath}")
+            logger.info(f"Generated ASS subtitles: {results.ass_filepath}")
         if results.video_filepath:
-            logger.info(f"Generated video file: {results.video_filepath}")
+            logger.info(f"Generated video: {results.video_filepath}")
 
     except Exception as e:
-        logger.error(f"Processing failed: {str(e)}")
+        # Get the full exception traceback
+        import traceback
+
+        error_details = traceback.format_exc()
+
+        # Log both the error message and the full traceback
+        logger.error(f"Processing failed: {str(e)}\n\nFull traceback:\n{error_details}")
         exit(1)

lyrics_transcriber-0.32.1/lyrics_transcriber/core/config.py

@@ -0,0 +1,35 @@
+import os
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class TranscriberConfig:
+    """Configuration for transcription services."""
+
+    audioshake_api_token: Optional[str] = None
+    runpod_api_key: Optional[str] = None
+    whisper_runpod_id: Optional[str] = None
+
+
+@dataclass
+class LyricsConfig:
+    """Configuration for lyrics services."""
+
+    genius_api_token: Optional[str] = None
+    spotify_cookie: Optional[str] = None
+
+
+@dataclass
+class OutputConfig:
+    """Configuration for output generation."""
+
+    output_styles_json: str
+    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"
+    enable_review: bool = True

{lyrics_transcriber-0.30.1 → lyrics_transcriber-0.32.1}/lyrics_transcriber/core/controller.py

@@ -1,44 +1,21 @@
 import os
 import logging
 from dataclasses import dataclass, field
-from typing import Dict, Optional, Any, List
-from ..transcribers.base_transcriber import BaseTranscriber, TranscriptionResult
-from ..transcribers.audioshake import AudioShakeTranscriber, AudioShakeConfig
-from ..transcribers.whisper import WhisperTranscriber, WhisperConfig
-from ..lyrics.base_lyrics_provider import BaseLyricsProvider, LyricsProviderConfig, LyricsData
-from ..lyrics.genius import GeniusProvider
-from ..lyrics.spotify import SpotifyProvider
-from ..output.generator import OutputGenerator, OutputGeneratorConfig
-from ..correction.corrector import LyricsCorrector, CorrectionResult
-
-
-@dataclass
-class TranscriberConfig:
-    """Configuration for transcription services."""
-
-    audioshake_api_token: Optional[str] = None
-    runpod_api_key: Optional[str] = None
-    whisper_runpod_id: Optional[str] = None
-
-
-@dataclass
-class LyricsConfig:
-    """Configuration for lyrics services."""
-
-    genius_api_token: Optional[str] = None
-    spotify_cookie: Optional[str] = None
-
-
-@dataclass
-class OutputConfig:
-    """Configuration for output generation."""
-
-    output_dir: Optional[str] = os.getcwd()
-    cache_dir: str = os.getenv("LYRICS_TRANSCRIBER_CACHE_DIR", "/tmp/lyrics-transcriber-cache/")
-    render_video: bool = False
-    video_resolution: str = "360p"
-    video_background_image: Optional[str] = None
-    video_background_color: str = "black"
+from typing import Dict, Optional, List
+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
+from lyrics_transcriber.lyrics.base_lyrics_provider import BaseLyricsProvider, LyricsProviderConfig
+from lyrics_transcriber.lyrics.genius import GeniusProvider
+from lyrics_transcriber.lyrics.spotify import SpotifyProvider
+from lyrics_transcriber.output.generator import OutputGenerator
+from lyrics_transcriber.correction.corrector import LyricsCorrector
+from lyrics_transcriber.core.config import TranscriberConfig, LyricsConfig, OutputConfig
 
 
 @dataclass
@@ -56,6 +33,12 @@ class LyricsControllerResult:
     lrc_filepath: Optional[str] = None
     ass_filepath: Optional[str] = None
     video_filepath: Optional[str] = None
+    mp3_filepath: Optional[str] = None
+    cdg_filepath: Optional[str] = None
+    cdg_zip_filepath: Optional[str] = None
+    original_txt: Optional[str] = None
+    corrected_txt: Optional[str] = None
+    corrections_json: Optional[str] = None
 
 
 class LyricsTranscriber:
@@ -120,7 +103,7 @@ class LyricsTranscriber:
         # Initialize components (with dependency injection)
         self.transcribers = transcribers or self._initialize_transcribers()
         self.lyrics_providers = lyrics_providers or self._initialize_lyrics_providers()
-        self.corrector = corrector or LyricsCorrector(logger=self.logger)
+        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()
 
     def _initialize_transcribers(self) -> Dict[str, BaseTranscriber]:
@@ -189,18 +172,7 @@ class LyricsTranscriber:
 
     def _initialize_output_generator(self) -> OutputGenerator:
         """Initialize output generation service."""
-
-        # Convert OutputConfig to OutputGeneratorConfig
-        generator_config = OutputGeneratorConfig(
-            output_dir=self.output_config.output_dir,
-            cache_dir=self.output_config.cache_dir,
-            video_resolution=self.output_config.video_resolution,
-            video_background_image=self.output_config.video_background_image,
-            video_background_color=self.output_config.video_background_color,
-        )
-
-        # Initialize output generator
-        return OutputGenerator(config=generator_config, logger=self.logger)
+        return OutputGenerator(config=self.output_config, logger=self.logger)
 
     def process(self) -> LyricsControllerResult:
         """
@@ -212,49 +184,39 @@ class LyricsTranscriber:
         Raises:
             Exception: If a critical error occurs during processing.
         """
-        try:
-            # Step 1: Fetch lyrics if artist and title are provided
-            if self.artist and self.title:
-                self.fetch_lyrics()
+        # Step 1: Fetch lyrics if artist and title are provided
+        if self.artist and self.title:
+            self.fetch_lyrics()
 
-            # Step 2: Run transcription
-            self.transcribe()
+        # Step 2: Run transcription
+        self.transcribe()
 
-            # Step 3: Process and correct lyrics
-            self.correct_lyrics()
+        # Step 3: Process and correct lyrics
+        self.correct_lyrics()
 
-            # Step 4: Generate outputs
-            self.generate_outputs()
+        # Step 4: Generate outputs
+        self.generate_outputs()
 
-            self.logger.info("Processing completed successfully")
-            return self.results
-
-        except Exception as e:
-            self.logger.error(f"Error during processing: {str(e)}")
-            raise
+        self.logger.info("Processing completed successfully")
+        return self.results
 
     def fetch_lyrics(self) -> None:
         """Fetch lyrics from available providers."""
         self.logger.info(f"Fetching lyrics for {self.artist} - {self.title}")
 
-        try:
-            for name, provider in self.lyrics_providers.items():
-                try:
-                    result = provider.fetch_lyrics(self.artist, self.title)
-                    if result:
-                        self.results.lyrics_results.append(result)
-                        self.logger.info(f"Successfully fetched lyrics from {name}")
-
-                except Exception as e:
-                    self.logger.error(f"Failed to fetch lyrics from {name}: {str(e)}")
-                    continue
+        for name, provider in self.lyrics_providers.items():
+            try:
+                result = provider.fetch_lyrics(self.artist, self.title)
+                if result:
+                    self.results.lyrics_results.append(result)
+                    self.logger.info(f"Successfully fetched lyrics from {name}")
 
-            if not self.results.lyrics_results:
-                self.logger.warning("No lyrics found from any source")
+            except Exception as e:
+                self.logger.error(f"Failed to fetch lyrics from {name}: {str(e)}")
+                continue
 
-        except Exception as e:
-            self.logger.error(f"Failed to fetch lyrics: {str(e)}")
-            # Don't raise - we can continue without lyrics
+        if not self.results.lyrics_results:
+            self.logger.warning("No lyrics found from any source")
 
     def transcribe(self) -> None:
         """Run transcription using all available transcribers."""
@@ -262,18 +224,13 @@ class LyricsTranscriber:
 
         for name, transcriber_info in self.transcribers.items():
             self.logger.info(f"Running transcription with {name}")
-            try:
-                result = transcriber_info["instance"].transcribe(self.audio_filepath)
-                if result:
-                    # Add the transcriber name and priority to the result
-                    self.results.transcription_results.append(
-                        TranscriptionResult(name=name, priority=transcriber_info["priority"], result=result)
-                    )
-                    self.logger.debug(f"Transcription completed for {name}")
-
-            except Exception as e:
-                self.logger.error(f"Transcription failed for {name}: {str(e)}", exc_info=True)
-                continue
+            result = transcriber_info["instance"].transcribe(self.audio_filepath)
+            if result:
+                # Add the transcriber name and priority to the result
+                self.results.transcription_results.append(
+                    TranscriptionResult(name=name, priority=transcriber_info["priority"], result=result)
+                )
+                self.logger.debug(f"Transcription completed for {name}")
 
         if not self.results.transcription_results:
             self.logger.warning("No successful transcriptions from any provider")
@@ -282,36 +239,43 @@ class LyricsTranscriber:
         """Run lyrics correction using transcription and internet lyrics."""
         self.logger.info("Starting lyrics correction process")
 
-        try:
-            # Run correction
-            corrected_data = self.corrector.run(
-                transcription_results=self.results.transcription_results, lyrics_results=self.results.lyrics_results
-            )
+        # Run correction
+        corrected_data = self.corrector.run(
+            transcription_results=self.results.transcription_results, lyrics_results=self.results.lyrics_results
+        )
+
+        # Store corrected results
+        self.results.transcription_corrected = corrected_data
+        self.logger.info("Lyrics correction completed")
 
-            # Store corrected results
-            self.results.transcription_corrected = corrected_data
-            self.logger.info("Lyrics correction completed")
+        # Add human review step
+        if self.output_config.enable_review:  # We'll need to add this config option
+            from ..review import start_review_server
 
-        except Exception as e:
-            self.logger.error(f"Failed to correct lyrics: {str(e)}", exc_info=True)
+            self.logger.info("Starting human review process")
+            self.results.transcription_corrected = start_review_server(corrected_data)
+            self.logger.info("Human review completed")
 
     def generate_outputs(self) -> None:
         """Generate output files."""
         self.logger.info("Generating output files")
 
-        try:
-            output_files = self.output_generator.generate_outputs(
-                transcription_corrected=self.results.transcription_corrected,
-                lyrics_results=self.results.lyrics_results,
-                output_prefix=self.output_prefix,
-                audio_filepath=self.audio_filepath,
-            )
-
-            # Store output paths - access attributes directly instead of using .get()
-            self.results.lrc_filepath = output_files.lrc
-            self.results.ass_filepath = output_files.ass
-            self.results.video_filepath = output_files.video
-
-        except Exception as e:
-            self.logger.error(f"Failed to generate outputs: {str(e)}")
-            raise
+        output_files = self.output_generator.generate_outputs(
+            transcription_corrected=self.results.transcription_corrected,
+            lyrics_results=self.results.lyrics_results,
+            output_prefix=self.output_prefix,
+            audio_filepath=self.audio_filepath,
+            artist=self.artist,
+            title=self.title,
+        )
+
+        # Store all output paths in results
+        self.results.lrc_filepath = output_files.lrc
+        self.results.ass_filepath = output_files.ass
+        self.results.video_filepath = output_files.video
+        self.results.original_txt = output_files.original_txt
+        self.results.corrected_txt = output_files.corrected_txt
+        self.results.corrections_json = output_files.corrections_json
+        self.results.cdg_filepath = output_files.cdg
+        self.results.mp3_filepath = output_files.mp3
+        self.results.cdg_zip_filepath = output_files.cdg_zip