lyrics-transcriber 0.20.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

lyrics_transcriber/__init__.py

@@ -1,6 +1,3 @@
-import warnings
-
-warnings.simplefilter("ignore")
-
-from .transcriber import LyricsTranscriber
+from .core.controller import LyricsTranscriber, TranscriberConfig, LyricsConfig, OutputConfig
 
+__all__ = ["LyricsTranscriber", "TranscriberConfig", "LyricsConfig", "OutputConfig"]

lyrics_transcriber/cli/main.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python
+import argparse
+import logging
+import os
+from pathlib import Path
+from typing import Dict
+from importlib.metadata import version
+from dotenv import load_dotenv
+
+from lyrics_transcriber import LyricsTranscriber
+from lyrics_transcriber.core.controller import TranscriberConfig, LyricsConfig, OutputConfig
+
+
+def create_arg_parser() -> argparse.ArgumentParser:
+    """Create and configure the argument parser."""
+    parser = argparse.ArgumentParser(
+        description="Create synchronised lyrics files in ASS and MidiCo LRC formats with word-level timestamps",
+        formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=52),
+    )
+
+    # Required arguments
+    parser.add_argument(
+        "audio_filepath",
+        nargs="?",
+        help="The audio file path to transcribe lyrics for.",
+        default=argparse.SUPPRESS,
+    )
+
+    # Version
+    package_version = version("lyrics-transcriber")
+    parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {package_version}")
+
+    # Optional arguments
+    parser.add_argument(
+        "--log_level", default="INFO", choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"], help="Logging level. Default: INFO"
+    )
+
+    # Song identification
+    song_group = parser.add_argument_group("Song Identification")
+    song_group.add_argument("--artist", help="Song artist for lyrics lookup and auto-correction")
+    song_group.add_argument("--title", help="Song title for lyrics lookup and auto-correction")
+
+    # API Credentials
+    api_group = parser.add_argument_group("API Credentials")
+    api_group.add_argument(
+        "--audioshake_api_token", help="AudioShake API token for lyrics transcription. Can also use AUDIOSHAKE_API_TOKEN env var."
+    )
+    api_group.add_argument("--genius_api_token", help="Genius API token for lyrics fetching. Can also use GENIUS_API_TOKEN env var.")
+    api_group.add_argument(
+        "--spotify_cookie", help="Spotify sp_dc cookie value for lyrics fetching. Can also use SPOTIFY_COOKIE_SP_DC env var."
+    )
+    api_group.add_argument("--runpod_api_key", help="RunPod API key for Whisper transcription. Can also use RUNPOD_API_KEY env var.")
+    api_group.add_argument(
+        "--whisper_runpod_id", help="RunPod endpoint ID for Whisper transcription. Can also use WHISPER_RUNPOD_ID env var."
+    )
+
+    # 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,
+        default=Path("/tmp/lyrics-transcriber-cache/"),
+        help="Directory to cache downloaded/generated files. Default: /tmp/lyrics-transcriber-cache/",
+    )
+
+    # 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(
+        "--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
+
+
+def get_config_from_env() -> Dict[str, str]:
+    """Load configuration from environment variables."""
+    load_dotenv()
+    return {
+        "audioshake_api_token": os.getenv("AUDIOSHAKE_API_TOKEN"),
+        "genius_api_token": os.getenv("GENIUS_API_TOKEN"),
+        "spotify_cookie": os.getenv("SPOTIFY_COOKIE_SP_DC"),
+        "runpod_api_key": os.getenv("RUNPOD_API_KEY"),
+        "whisper_runpod_id": os.getenv("WHISPER_RUNPOD_ID"),
+    }
+
+
+def setup_logging(log_level: str) -> logging.Logger:
+    """Configure logging with consistent format."""
+    logger = logging.getLogger("lyrics_transcriber")
+    log_level_enum = getattr(logging, log_level.upper())
+    logger.setLevel(log_level_enum)
+
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(fmt="%(asctime)s.%(msecs)03d - %(levelname)s - %(module)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    return logger
+
+
+def create_configs(args: argparse.Namespace, env_config: Dict[str, str]) -> tuple[TranscriberConfig, LyricsConfig, OutputConfig]:
+    """Create configuration objects from arguments and environment variables."""
+    transcriber_config = TranscriberConfig(
+        audioshake_api_token=args.audioshake_api_token or env_config.get("audioshake_api_token"),
+        runpod_api_key=args.runpod_api_key or env_config.get("runpod_api_key"),
+        whisper_runpod_id=args.whisper_runpod_id or env_config.get("whisper_runpod_id"),
+    )
+
+    lyrics_config = LyricsConfig(
+        genius_api_token=args.genius_api_token or env_config.get("genius_api_token"),
+        spotify_cookie=args.spotify_cookie or env_config.get("spotify_cookie"),
+    )
+
+    output_config = OutputConfig(
+        output_dir=str(args.output_dir) if args.output_dir else None,
+        cache_dir=str(args.cache_dir),
+        render_video=args.render_video,
+        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
+
+
+def validate_args(args: argparse.Namespace, parser: argparse.ArgumentParser, logger: logging.Logger) -> None:
+    """Validate command line arguments."""
+    if not hasattr(args, "audio_filepath"):
+        parser.print_help()
+        logger.error("No audio filepath provided")
+        exit(1)
+
+    if not os.path.exists(args.audio_filepath):
+        logger.error(f"Audio file not found: {args.audio_filepath}")
+        exit(1)
+
+    if args.artist and not args.title or args.title and not args.artist:
+        logger.error("Both artist and title must be provided together")
+        exit(1)
+
+
+def main() -> None:
+    """Main entry point for the CLI."""
+    parser = create_arg_parser()
+    args = parser.parse_args()
+
+    # Set up logging first
+    logger = setup_logging(args.log_level)
+
+    # Validate arguments
+    validate_args(args, parser, logger)
+
+    # Load environment variables
+    env_config = get_config_from_env()
+
+    # Create configuration objects
+    transcriber_config, lyrics_config, output_config = create_configs(args, env_config)
+
+    try:
+        # Initialize and run transcriber
+        transcriber = LyricsTranscriber(
+            audio_filepath=args.audio_filepath,
+            artist=args.artist,
+            title=args.title,
+            transcriber_config=transcriber_config,
+            lyrics_config=lyrics_config,
+            output_config=output_config,
+            logger=logger,
+        )
+
+        results = transcriber.process()
+
+        # Log results
+        logger.info("*** Success! ***")
+
+        if results.lrc_filepath:
+            logger.info(f"Generated LRC file: {results.lrc_filepath}")
+        if results.ass_filepath:
+            logger.info(f"Generated ASS file: {results.ass_filepath}")
+        if results.video_filepath:
+            logger.info(f"Generated video file: {results.video_filepath}")
+
+    except Exception as e:
+        logger.error(f"Processing failed: {str(e)}")
+        exit(1)

lyrics_transcriber/core/controller.py

@@ -0,0 +1,283 @@
+import os
+import logging
+from dataclasses import dataclass
+from typing import Dict, Optional, List
+from ..transcribers.base import BaseTranscriber
+from ..transcribers.audioshake import AudioShakeTranscriber
+from ..transcribers.whisper import WhisperTranscriber
+from .fetcher import LyricsFetcher
+from ..output.generator import OutputGenerator
+from .corrector import LyricsTranscriptionCorrector
+
+
+@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] = None
+    cache_dir: str = "/tmp/lyrics-transcriber-cache/"
+    render_video: bool = False
+    video_resolution: str = "360p"
+    video_background_image: Optional[str] = None
+    video_background_color: str = "black"
+
+
+@dataclass
+class TranscriptionResult:
+    """Holds the results of the transcription and correction process."""
+
+    # Lyrics from internet sources
+    lyrics_text: Optional[str] = None
+    lyrics_source: Optional[str] = None
+    lyrics_genius: Optional[str] = None
+    lyrics_spotify: Optional[str] = None
+    spotify_lyrics_data: Optional[Dict] = None
+
+    # Transcription results
+    transcription_whisper: Optional[Dict] = None
+    transcription_audioshake: Optional[Dict] = None
+    transcription_primary: Optional[Dict] = None
+    transcription_corrected: Optional[Dict] = None
+
+    # Output files
+    lrc_filepath: Optional[str] = None
+    ass_filepath: Optional[str] = None
+    video_filepath: Optional[str] = None
+
+
+class LyricsTranscriber:
+    """
+    Controller class that orchestrates the lyrics transcription workflow:
+    1. Fetch lyrics from internet sources
+    2. Run multiple transcription methods
+    3. Correct transcribed lyrics using fetched lyrics
+    4. Generate output formats (LRC, ASS, video)
+    """
+
+    def __init__(
+        self,
+        audio_filepath: str,
+        artist: Optional[str] = None,
+        title: Optional[str] = None,
+        transcriber_config: Optional[TranscriberConfig] = None,
+        lyrics_config: Optional[LyricsConfig] = None,
+        output_config: Optional[OutputConfig] = None,
+        lyrics_fetcher: Optional[LyricsFetcher] = None,
+        corrector: Optional[LyricsTranscriptionCorrector] = None,
+        output_generator: Optional[OutputGenerator] = None,
+        logger: Optional[logging.Logger] = None,
+        log_level: int = logging.DEBUG,
+        log_formatter: Optional[logging.Formatter] = None,
+    ):
+        # Set up logging
+        self.logger = logger or logging.getLogger(__name__)
+        if not logger:
+            self.logger.setLevel(log_level)
+            if not self.logger.handlers:
+                handler = logging.StreamHandler()
+                formatter = log_formatter or logging.Formatter("%(asctime)s - %(levelname)s - %(module)s - %(message)s")
+                handler.setFormatter(formatter)
+                self.logger.addHandler(handler)
+
+        self.logger.debug(f"LyricsTranscriber instantiating with input file: {audio_filepath}")
+
+        # Store configs (with defaults if not provided)
+        self.transcriber_config = transcriber_config or TranscriberConfig()
+        self.lyrics_config = lyrics_config or LyricsConfig()
+        self.output_config = output_config or OutputConfig()
+
+        # Basic settings
+        self.audio_filepath = audio_filepath
+        self.artist = artist
+        self.title = title
+        self.output_prefix = f"{artist} - {title}" if artist and title else os.path.splitext(os.path.basename(audio_filepath))[0]
+
+        # Create necessary folders
+        os.makedirs(self.output_config.cache_dir, exist_ok=True)
+        if self.output_config.output_dir:
+            os.makedirs(self.output_config.output_dir, exist_ok=True)
+
+        # Initialize results
+        self.results = TranscriptionResult()
+
+        # Initialize components (with dependency injection)
+        self.transcribers = self._initialize_transcribers()
+        self.lyrics_fetcher = lyrics_fetcher or self._initialize_lyrics_fetcher()
+        self.corrector = corrector or LyricsTranscriptionCorrector(logger=self.logger)
+        self.output_generator = output_generator or self._initialize_output_generator()
+
+    def _initialize_transcribers(self) -> Dict[str, BaseTranscriber]:
+        """Initialize available transcription services."""
+        transcribers = {}
+
+        if self.transcriber_config.audioshake_api_token:
+            transcribers["audioshake"] = AudioShakeTranscriber(api_token=self.transcriber_config.audioshake_api_token, logger=self.logger)
+
+        if self.transcriber_config.runpod_api_key and self.transcriber_config.whisper_runpod_id:
+            transcribers["whisper"] = WhisperTranscriber(
+                logger=self.logger,
+                runpod_api_key=self.transcriber_config.runpod_api_key,
+                endpoint_id=self.transcriber_config.whisper_runpod_id,
+            )
+
+        return transcribers
+
+    def _initialize_lyrics_fetcher(self) -> LyricsFetcher:
+        """Initialize lyrics fetching service."""
+        return LyricsFetcher(
+            genius_api_token=self.lyrics_config.genius_api_token, spotify_cookie=self.lyrics_config.spotify_cookie, logger=self.logger
+        )
+
+    def _initialize_output_generator(self) -> OutputGenerator:
+        """Initialize output generation service."""
+        return OutputGenerator(
+            logger=self.logger,
+            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,
+        )
+
+    def process(self) -> TranscriptionResult:
+        """
+        Main processing method that orchestrates the entire workflow.
+
+        Returns:
+            TranscriptionResult containing all outputs and generated files.
+
+        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 2: Run transcription
+            self.transcribe()
+
+            # Step 3: Process and correct lyrics
+            if self.results.transcription_primary:
+                self.correct_lyrics()
+
+            # Step 4: Generate outputs
+            if self.results.transcription_corrected:
+                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
+
+    def fetch_lyrics(self) -> None:
+        """Fetch lyrics from online sources."""
+        self.logger.info(f"Fetching lyrics for {self.artist} - {self.title}")
+
+        try:
+            lyrics_result = self.lyrics_fetcher.fetch_lyrics(self.artist, self.title)
+
+            # Update results
+            self.results.lyrics_text = lyrics_result["lyrics"]
+            self.results.lyrics_source = lyrics_result["source"]
+            self.results.lyrics_genius = lyrics_result["genius_lyrics"]
+            self.results.lyrics_spotify = lyrics_result["spotify_lyrics"]
+            self.results.spotify_lyrics_data = lyrics_result.get("spotify_lyrics_data")
+
+            if lyrics_result["lyrics"]:
+                self.logger.info(f"Successfully fetched lyrics from {lyrics_result['source']}")
+            else:
+                self.logger.warning("No lyrics found from any source")
+
+        except Exception as e:
+            self.logger.error(f"Failed to fetch lyrics: {str(e)}")
+            # Don't raise - we can continue without lyrics
+
+    def transcribe(self) -> None:
+        """Run transcription using all available transcribers."""
+        self.logger.info("Starting transcription process")
+
+        for name, transcriber in self.transcribers.items():
+            try:
+                result = transcriber.transcribe(self.audio_filepath)
+
+                # Store result based on transcriber type
+                if name == "whisper":
+                    self.results.transcription_whisper = result
+                elif name == "audioshake":
+                    self.results.transcription_audioshake = result
+
+                # Use first successful transcription as primary
+                if not self.results.transcription_primary:
+                    self.results.transcription_primary = result
+
+            except Exception as e:
+                self.logger.error(f"Transcription failed for {name}: {str(e)}")
+                continue
+
+    def correct_lyrics(self) -> None:
+        """Run lyrics correction using transcription and internet lyrics."""
+        self.logger.info("Starting lyrics correction process")
+
+        try:
+            # Set input data for correction
+            self.corrector.set_input_data(
+                spotify_lyrics_data_dict=self.results.spotify_lyrics_data,
+                spotify_lyrics_text=self.results.lyrics_spotify,
+                genius_lyrics_text=self.results.lyrics_genius,
+                transcription_data_dict_whisper=self.results.transcription_whisper,
+                transcription_data_dict_audioshake=self.results.transcription_audioshake,
+            )
+
+            # Run correction
+            corrected_data = self.corrector.run_corrector()
+
+            # Store corrected results
+            self.results.transcription_corrected = corrected_data
+            self.logger.info("Lyrics correction completed")
+
+        except Exception as e:
+            self.logger.error(f"Failed to correct lyrics: {str(e)}")
+            # Use uncorrected transcription as fallback
+            self.results.transcription_corrected = self.results.transcription_primary
+            self.logger.warning("Using uncorrected transcription as fallback")
+
+    def generate_outputs(self) -> None:
+        """Generate output files."""
+        self.logger.info("Generating output files")
+
+        try:
+            output_files = self.output_generator.generate_outputs(
+                transcription_data=self.results.transcription_corrected,
+                output_prefix=self.output_prefix,
+                audio_filepath=self.audio_filepath,
+                render_video=self.output_config.render_video,
+            )
+
+            # Store output paths
+            self.results.lrc_filepath = output_files.get("lrc")
+            self.results.ass_filepath = output_files.get("ass")
+            self.results.video_filepath = output_files.get("video")
+
+        except Exception as e:
+            self.logger.error(f"Failed to generate outputs: {str(e)}")
+            raise

lyrics_transcriber/{corrector.py → core/corrector.py}

@@ -1,6 +1,5 @@
 import json
 import logging
-from openai import OpenAI
 from typing import Dict, Optional
 
 

lyrics_transcriber/core/fetcher.py

@@ -0,0 +1,143 @@
+import os
+import logging
+import lyricsgenius
+import requests
+from typing import Optional, Dict, Any
+
+
+class LyricsFetcher:
+    """Handles fetching lyrics from various online sources."""
+
+    def __init__(
+        self, genius_api_token: Optional[str] = None, spotify_cookie: Optional[str] = None, logger: Optional[logging.Logger] = None
+    ):
+        self.logger = logger or logging.getLogger(__name__)
+        self.genius_api_token = genius_api_token or os.getenv("GENIUS_API_TOKEN")
+        self.spotify_cookie = spotify_cookie or os.getenv("SPOTIFY_COOKIE")
+
+        # Initialize Genius API client if token provided
+        self.genius = None
+        if self.genius_api_token:
+            self.genius = lyricsgenius.Genius(self.genius_api_token)
+            self.genius.verbose = False
+            self.genius.remove_section_headers = True
+
+    def fetch_lyrics(self, artist: str, title: str) -> Dict[str, Any]:
+        """
+        Fetch lyrics from all available sources.
+
+        Args:
+            artist: Name of the artist
+            title: Title of the song
+
+        Returns:
+            Dict containing:
+                - genius_lyrics: Lyrics from Genius (if available)
+                - spotify_lyrics: Lyrics from Spotify (if available)
+                - source: The preferred source ("genius" or "spotify")
+                - lyrics: The best lyrics found from any source
+        """
+        self.logger.info(f"Fetching lyrics for {artist} - {title}")
+
+        result = {"genius_lyrics": None, "spotify_lyrics": None, "source": None, "lyrics": None}
+
+        # Try Genius first
+        if self.genius:
+            try:
+                result["genius_lyrics"] = self._fetch_from_genius(artist, title)
+                if result["genius_lyrics"]:
+                    result["source"] = "genius"
+                    result["lyrics"] = result["genius_lyrics"]
+            except Exception as e:
+                self.logger.error(f"Failed to fetch lyrics from Genius: {str(e)}")
+
+        # Try Spotify if Genius failed or wasn't available
+        if self.spotify_cookie and not result["lyrics"]:
+            try:
+                result["spotify_lyrics"] = self._fetch_from_spotify(artist, title)
+                if result["spotify_lyrics"]:
+                    result["source"] = "spotify"
+                    result["lyrics"] = result["spotify_lyrics"]
+            except Exception as e:
+                self.logger.error(f"Failed to fetch lyrics from Spotify: {str(e)}")
+
+        return result
+
+    def _fetch_from_genius(self, artist: str, title: str) -> Optional[str]:
+        """Fetch lyrics from Genius."""
+        self.logger.info(f"Searching Genius for {artist} - {title}")
+
+        try:
+            song = self.genius.search_song(title, artist)
+            if song:
+                self.logger.info("Found lyrics on Genius")
+                return song.lyrics
+        except Exception as e:
+            self.logger.error(f"Error fetching from Genius: {str(e)}")
+
+        return None
+
+    def _fetch_from_spotify(self, artist: str, title: str) -> Optional[str]:
+        """
+        Fetch lyrics from Spotify.
+
+        Uses the Spotify cookie to authenticate and fetch lyrics for a given song.
+        The cookie can be obtained by logging into Spotify Web Player and copying
+        the 'sp_dc' cookie value.
+        """
+        self.logger.info(f"Searching Spotify for {artist} - {title}")
+
+        if not self.spotify_cookie:
+            self.logger.warning("No Spotify cookie provided, skipping Spotify lyrics fetch")
+            return None
+
+        try:
+            # First, search for the track
+            search_url = "https://api.spotify.com/v1/search"
+            headers = {
+                "Cookie": f"sp_dc={self.spotify_cookie}",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+                "App-Platform": "WebPlayer",
+            }
+            params = {"q": f"artist:{artist} track:{title}", "type": "track", "limit": 1}
+
+            self.logger.debug("Making Spotify search request")
+            response = requests.get(search_url, headers=headers, params=params)
+            response.raise_for_status()
+
+            search_data = response.json()
+            if not search_data.get("tracks", {}).get("items"):
+                self.logger.warning("No tracks found on Spotify")
+                return None
+
+            track = search_data["tracks"]["items"][0]
+            track_id = track["id"]
+
+            # Then, fetch lyrics for the track
+            lyrics_url = f"https://api.spotify.com/v1/tracks/{track_id}/lyrics"
+
+            self.logger.debug("Making Spotify lyrics request")
+            lyrics_response = requests.get(lyrics_url, headers=headers)
+            lyrics_response.raise_for_status()
+
+            lyrics_data = lyrics_response.json()
+            if not lyrics_data.get("lyrics", {}).get("lines"):
+                self.logger.warning("No lyrics found for track on Spotify")
+                return None
+
+            # Combine all lines into a single string
+            lyrics_lines = [line["words"] for line in lyrics_data["lyrics"]["lines"] if line.get("words")]
+            lyrics = "\n".join(lyrics_lines)
+
+            self.logger.info("Successfully fetched lyrics from Spotify")
+            return lyrics
+
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Error making request to Spotify: {str(e)}")
+            return None
+        except KeyError as e:
+            self.logger.error(f"Unexpected response format from Spotify: {str(e)}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Unexpected error fetching from Spotify: {str(e)}")
+            return None