karaoke-gen 0.50.0__py3-none-any.whl → 0.56.0__py3-none-any.whl

karaoke_gen/__init__.py

@@ -0,0 +1,7 @@
+import warnings
+
+# Suppress specific SyntaxWarnings from third-party packages
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="pydub.*")
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="syrics.*")
+
+from .karaoke_gen import KaraokePrep

{karaoke_prep → karaoke_gen}/audio_processor.py

@@ -72,11 +72,11 @@ class AudioProcessor:
 
         for file in output_files:
             if "(Vocals)" in file:
-                self.logger.info(f"Renaming Vocals file {file} to {vocals_path}")
-                os.rename(file, vocals_path)
+                self.logger.info(f"Moving Vocals file {file} to {vocals_path}")
+                shutil.move(file, vocals_path)
             elif "(Instrumental)" in file:
-                self.logger.info(f"Renaming Instrumental file {file} to {instrumental_path}")
-                os.rename(file, instrumental_path)
+                self.logger.info(f"Moving Instrumental file {file} to {instrumental_path}")
+                shutil.move(file, instrumental_path)
             elif model_name in file:
                 # Example filename 1: "Freddie Jackson - All I'll Ever Ask (feat. Najee) (Local)_(Piano)_htdemucs_6s.flac"
                 # Example filename 2: "Freddie Jackson - All I'll Ever Ask (feat. Najee) (Local)_(Guitar)_htdemucs_6s.flac"
@@ -86,8 +86,8 @@ class AudioProcessor:
                 stem_name = stem_name.strip("()")  # Remove parentheses if present
 
                 other_stem_path = os.path.join(track_output_dir, f"{artist_title} ({stem_name} {model_name}).{self.lossless_output_format}")
-                self.logger.info(f"Renaming other stem file {file} to {other_stem_path}")
-                os.rename(file, other_stem_path)
+                self.logger.info(f"Moving other stem file {file} to {other_stem_path}")
+                shutil.move(file, other_stem_path)
 
             elif model_name_no_extension in file:
                 # Example filename 1: "Freddie Jackson - All I'll Ever Ask (feat. Najee) (Local)_(Piano)_htdemucs_6s.flac"
@@ -98,8 +98,8 @@ class AudioProcessor:
                 stem_name = stem_name.strip("()")  # Remove parentheses if present
 
                 other_stem_path = os.path.join(track_output_dir, f"{artist_title} ({stem_name} {model_name}).{self.lossless_output_format}")
-                self.logger.info(f"Renaming other stem file {file} to {other_stem_path}")
-                os.rename(file, other_stem_path)
+                self.logger.info(f"Moving other stem file {file} to {other_stem_path}")
+                shutil.move(file, other_stem_path)
 
         self.logger.info(f"Separation complete! Output file(s): {vocals_path} {instrumental_path}")
 
@@ -133,8 +133,13 @@ class AudioProcessor:
                                 runtime_mins = runtime.total_seconds() / 60
 
                                 # Get process command line
-                                proc = psutil.Process(pid)
-                                cmd = " ".join(proc.cmdline())
+                                try:
+                                    proc = psutil.Process(pid)
+                                    cmdline_args = proc.cmdline()
+                                    # Handle potential bytes in cmdline args (cross-platform compatibility)
+                                    cmd = " ".join(arg.decode('utf-8', errors='replace') if isinstance(arg, bytes) else arg for arg in cmdline_args)
+                                except (psutil.AccessDenied, psutil.NoSuchProcess):
+                                    cmd = "<command unavailable>"
 
                                 self.logger.info(
                                     f"Waiting for other audio separation process to complete before starting separation for {artist_title}...\n"
@@ -182,7 +187,7 @@ class AudioProcessor:
             stems_dir = self._create_stems_directory(track_output_dir)
             result = {"clean_instrumental": {}, "other_stems": {}, "backing_vocals": {}, "combined_instrumentals": {}}
 
-            if os.environ.get("KARAOKE_PREP_SKIP_AUDIO_SEPARATION"):
+            if os.environ.get("KARAOKE_GEN_SKIP_AUDIO_SEPARATION"):
                 return result
 
             result["clean_instrumental"] = self._separate_clean_instrumental(
@@ -257,10 +262,10 @@ class AudioProcessor:
 
             for file in clean_output_files:
                 if "(Vocals)" in file and not self._file_exists(vocals_path):
-                    os.rename(file, vocals_path)
+                    shutil.move(file, vocals_path)
                     result["vocals"] = vocals_path
                 elif "(Instrumental)" in file and not self._file_exists(instrumental_path):
-                    os.rename(file, instrumental_path)
+                    shutil.move(file, instrumental_path)
                     result["instrumental"] = instrumental_path
         else:
             result["vocals"] = vocals_path
@@ -293,7 +298,7 @@ class AudioProcessor:
                     new_filename = f"{artist_title} ({stem_name} {model}).{self.lossless_output_format}"
                     other_stem_path = os.path.join(stems_dir, new_filename)
                     if not self._file_exists(other_stem_path):
-                        os.rename(file, other_stem_path)
+                        shutil.move(file, other_stem_path)
                     result[model][stem_name] = other_stem_path
 
         return result
@@ -313,10 +318,10 @@ class AudioProcessor:
 
                 for file in backing_vocals_output:
                     if "(Vocals)" in file and not self._file_exists(lead_vocals_path):
-                        os.rename(file, lead_vocals_path)
+                        shutil.move(file, lead_vocals_path)
                         result[model]["lead_vocals"] = lead_vocals_path
                     elif "(Instrumental)" in file and not self._file_exists(backing_vocals_path):
-                        os.rename(file, backing_vocals_path)
+                        shutil.move(file, backing_vocals_path)
                         result[model]["backing_vocals"] = backing_vocals_path
             else:
                 result[model]["lead_vocals"] = lead_vocals_path

{karaoke_prep → karaoke_gen}/file_handler.py

@@ -39,28 +39,64 @@ class FileHandler:
 
         return copied_file_name
 
-    def download_video(self, url, output_filename_no_extension):
+    def download_video(self, url, output_filename_no_extension, cookies_str=None):
         self.logger.debug(f"Downloading media from URL {url} to filename {output_filename_no_extension} + (as yet) unknown extension")
 
         ydl_opts = {
             "quiet": True,
             "format": "bv*+ba/b",  # if a combined video + audio format is better than the best video-only format use the combined format
             "outtmpl": f"{output_filename_no_extension}.%(ext)s",
-            "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36",
+            # Enhanced anti-detection options
+            "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "referer": "https://www.youtube.com/",
+            "sleep_interval": 1,
+            "max_sleep_interval": 3,
+            "fragment_retries": 3,
+            "extractor_retries": 3,
+            "retries": 3,
+            # Headers to appear more human
+            "http_headers": {
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "en-us,en;q=0.5",
+                "Accept-Encoding": "gzip, deflate",
+                "DNT": "1",
+                "Connection": "keep-alive",
+                "Upgrade-Insecure-Requests": "1",
+            },
         }
 
-        with ydl(ydl_opts) as ydl_instance:
-            ydl_instance.download([url])
-
-            # Search for the file with any extension
-            downloaded_files = glob.glob(f"{output_filename_no_extension}.*")
-            if downloaded_files:
-                downloaded_file_name = downloaded_files[0]  # Assume the first match is the correct one
-                self.logger.info(f"Download finished, returning downloaded filename: {downloaded_file_name}")
-                return downloaded_file_name
-            else:
-                self.logger.error("No files found matching the download pattern.")
-                return None
+        # Add cookies if provided
+        if cookies_str:
+            self.logger.info("Using provided cookies for enhanced YouTube download access")
+            # Save cookies to a temporary file
+            import tempfile
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+                f.write(cookies_str)
+                ydl_opts['cookiefile'] = f.name
+        else:
+            self.logger.info("No cookies provided for download - attempting standard download")
+
+        try:
+            with ydl(ydl_opts) as ydl_instance:
+                ydl_instance.download([url])
+
+                # Search for the file with any extension
+                downloaded_files = glob.glob(f"{output_filename_no_extension}.*")
+                if downloaded_files:
+                    downloaded_file_name = downloaded_files[0]  # Assume the first match is the correct one
+                    self.logger.info(f"Download finished, returning downloaded filename: {downloaded_file_name}")
+                    return downloaded_file_name
+                else:
+                    self.logger.error("No files found matching the download pattern.")
+                    return None
+        finally:
+            # Clean up temporary cookie file if it was created
+            if cookies_str and 'cookiefile' in ydl_opts:
+                try:
+                    import os
+                    os.unlink(ydl_opts['cookiefile'])
+                except:
+                    pass
 
     def extract_still_image_from_video(self, input_filename, output_filename_no_extension):
         output_filename = output_filename_no_extension + ".png"

{karaoke_prep → karaoke_gen}/karaoke_finalise/karaoke_finalise.py

@@ -636,7 +636,13 @@ class KaraokeFinalise:
             self.logger.info(f"DRY RUN: Would run command: {command}")
         else:
             self.logger.info(f"Running command: {command}")
-            os.system(command)
+            exit_code = os.system(command)
+            
+            # Check if command failed (non-zero exit code)
+            if exit_code != 0:
+                error_msg = f"Command failed with exit code {exit_code}: {command}"
+                self.logger.error(error_msg)
+                raise Exception(error_msg)
 
     def remux_with_instrumental(self, with_vocals_file, instrumental_audio, output_file):
         """Remux the video with instrumental audio to create karaoke version"""
@@ -924,7 +930,14 @@ class KaraokeFinalise:
         else:
             shutil.copy2(output_files["final_karaoke_lossy_mp4"], dest_mp4_file)  # Changed to use lossy MP4
             shutil.copy2(output_files["final_karaoke_lossy_720p_mp4"], dest_720p_mp4_file)
-            shutil.copy2(output_files["final_karaoke_cdg_zip"], dest_zip_file)
+            
+            # Only copy CDG ZIP if CDG creation is enabled
+            if self.enable_cdg and "final_karaoke_cdg_zip" in output_files:
+                shutil.copy2(output_files["final_karaoke_cdg_zip"], dest_zip_file)
+                self.logger.info(f"Copied CDG ZIP file to public share directory")
+            else:
+                self.logger.info(f"CDG creation disabled, skipping CDG ZIP copy")
+                
             self.logger.info(f"Copied final files to public share directory")
 
     def sync_public_share_dir_to_rclone_destination(self):

karaoke_prep/karaoke_prep.py → karaoke_gen/karaoke_gen.py

@@ -69,6 +69,8 @@ class KaraokePrep:
         style_params_json=None,
         # Add the new parameter
         skip_separation=False,
+        # YouTube/Online Configuration
+        cookies_str=None,
     ):
         self.log_level = log_level
         self.log_formatter = log_formatter
@@ -124,6 +126,9 @@ class KaraokePrep:
         self.render_bounding_boxes = render_bounding_boxes # Passed to VideoGenerator
         self.style_params_json = style_params_json # Passed to LyricsProcessor
 
+        # YouTube/Online Config
+        self.cookies_str = cookies_str # Passed to metadata extraction and file download
+
         # Load style parameters using the config module
         self.style_params = load_style_params(self.style_params_json, self.logger)
 
@@ -197,7 +202,7 @@ class KaraokePrep:
     # Compatibility methods for tests - these call the new functions in metadata.py
     def extract_info_for_online_media(self, input_url=None, input_artist=None, input_title=None):
         """Compatibility method that calls the function in metadata.py"""
-        self.extracted_info = extract_info_for_online_media(input_url, input_artist, input_title, self.logger)
+        self.extracted_info = extract_info_for_online_media(input_url, input_artist, input_title, self.logger, self.cookies_str)
         return self.extracted_info
 
     def parse_single_track_metadata(self, input_artist, input_title):
@@ -242,7 +247,7 @@ class KaraokePrep:
                 self.logger.warning(f"Input media '{self.input_media}' is not a file and self.url was not set. Attempting to treat as URL.")
                 # This path requires calling extract/parse again, less efficient
                 try:
-                    extracted = extract_info_for_online_media(self.input_media, self.artist, self.title, self.logger)
+                    extracted = extract_info_for_online_media(self.input_media, self.artist, self.title, self.logger, self.cookies_str)
                     if extracted:
                          metadata_result = parse_track_metadata(
                              extracted, self.artist, self.title, self.persistent_artist, self.logger
@@ -345,7 +350,7 @@ class KaraokePrep:
 
                     self.logger.info(f"Downloading input media from {self.url}...")
                     # Delegate to FileHandler
-                    processed_track["input_media"] = self.file_handler.download_video(self.url, output_filename_no_extension)
+                    processed_track["input_media"] = self.file_handler.download_video(self.url, output_filename_no_extension, self.cookies_str)
 
                     self.logger.info("Extracting still image from downloaded media (if input is video)...")
                     # Delegate to FileHandler
@@ -382,14 +387,20 @@ class KaraokePrep:
                     # Run transcription in a separate thread
                     transcription_future = asyncio.create_task(
                         asyncio.to_thread(
-                            # Delegate to LyricsProcessor
-                            self.lyrics_processor.transcribe_lyrics, processed_track["input_audio_wav"], lyrics_artist, lyrics_title, track_output_dir
+                            # Delegate to LyricsProcessor - pass original artist/title for filenames, lyrics_artist/lyrics_title for processing
+                            self.lyrics_processor.transcribe_lyrics, 
+                            processed_track["input_audio_wav"], 
+                            self.artist,  # Original artist for filename generation
+                            self.title,   # Original title for filename generation  
+                            track_output_dir,
+                            lyrics_artist,  # Lyrics artist for processing
+                            lyrics_title    # Lyrics title for processing
                         )
                     )
                     self.logger.info(f"Transcription future created, type: {type(transcription_future)}")
 
-                # Default to a placeholder future if separation won't run
-                separation_future = asyncio.sleep(0)
+                # Default to a placeholder task if separation won't run
+                separation_future = asyncio.create_task(asyncio.sleep(0))
 
                 # Only create real separation future if not skipping AND no existing instrumental provided
                 if not self.skip_separation and not self.existing_instrumental:
@@ -501,7 +512,7 @@ class KaraokePrep:
             processed_track["title_video"] = os.path.join(track_output_dir, f"{artist_title} (Title).mov")
 
             # Use FileHandler._file_exists
-            if not self.file_handler._file_exists(processed_track["title_video"]) and not os.environ.get("KARAOKE_PREP_SKIP_TITLE_END_SCREENS"):
+            if not self.file_handler._file_exists(processed_track["title_video"]) and not os.environ.get("KARAOKE_GEN_SKIP_TITLE_END_SCREENS"):
                 self.logger.info(f"Creating title video...")
                 # Delegate to VideoGenerator
                 self.video_generator.create_title_video(
@@ -520,7 +531,7 @@ class KaraokePrep:
             processed_track["end_video"] = os.path.join(track_output_dir, f"{artist_title} (End).mov")
 
             # Use FileHandler._file_exists
-            if not self.file_handler._file_exists(processed_track["end_video"]) and not os.environ.get("KARAOKE_PREP_SKIP_TITLE_END_SCREENS"):
+            if not self.file_handler._file_exists(processed_track["end_video"]) and not os.environ.get("KARAOKE_GEN_SKIP_TITLE_END_SCREENS"):
                 self.logger.info(f"Creating end screen video...")
                  # Delegate to VideoGenerator
                 self.video_generator.create_end_video(
@@ -675,7 +686,7 @@ class KaraokePrep:
             self.url = self.input_media
             # Use the imported extract_info_for_online_media function
             self.extracted_info = extract_info_for_online_media(
-                input_url=self.url, input_artist=self.artist, input_title=self.title, logger=self.logger
+                input_url=self.url, input_artist=self.artist, input_title=self.title, logger=self.logger, cookies_str=self.cookies_str
             )
 
             if self.extracted_info and "playlist_count" in self.extracted_info:
@@ -684,4 +695,6 @@ class KaraokePrep:
                 return await self.process_playlist()
             else:
                 self.logger.info(f"Input URL is not a playlist, processing single track")
+                # Parse metadata to extract artist and title before processing
+                self.parse_single_track_metadata(self.artist, self.title)
                 return [await self.prep_single_track()]

{karaoke_prep → karaoke_gen}/lyrics_processor.py

@@ -2,6 +2,7 @@ import os
 import re
 import logging
 import shutil
+import json
 from lyrics_transcriber import LyricsTranscriber, OutputConfig, TranscriberConfig, LyricsConfig
 from lyrics_transcriber.core.controller import LyricsControllerResult
 from dotenv import load_dotenv
@@ -102,14 +103,33 @@ class LyricsProcessor:
 
         return processed_lines
 
-    def transcribe_lyrics(self, input_audio_wav, artist, title, track_output_dir):
+    def transcribe_lyrics(self, input_audio_wav, artist, title, track_output_dir, lyrics_artist=None, lyrics_title=None):
+        """
+        Transcribe lyrics for a track.
+        
+        Args:
+            input_audio_wav: Path to the audio file
+            artist: Original artist name (used for filename generation)
+            title: Original title (used for filename generation)
+            track_output_dir: Output directory path
+            lyrics_artist: Artist name for lyrics processing (defaults to artist if None)
+            lyrics_title: Title for lyrics processing (defaults to title if None)
+        """
+        # Use original artist/title for filename generation
+        filename_artist = artist
+        filename_title = title
+        
+        # Use lyrics_artist/lyrics_title for actual lyrics processing, fall back to originals if not provided
+        processing_artist = lyrics_artist or artist
+        processing_title = lyrics_title or title
+        
         self.logger.info(
-            f"Transcribing lyrics for track {artist} - {title} from audio file: {input_audio_wav} with output directory: {track_output_dir}"
+            f"Transcribing lyrics for track {processing_artist} - {processing_title} from audio file: {input_audio_wav} with output directory: {track_output_dir}"
         )
 
-        # Check for existing files first using sanitized names
-        sanitized_artist = sanitize_filename(artist)
-        sanitized_title = sanitize_filename(title)
+        # Check for existing files first using sanitized names from ORIGINAL artist/title for consistency
+        sanitized_artist = sanitize_filename(filename_artist)
+        sanitized_title = sanitize_filename(filename_title)
         parent_video_path = os.path.join(track_output_dir, f"{sanitized_artist} - {sanitized_title} (With Vocals).mkv")
         parent_lrc_path = os.path.join(track_output_dir, f"{sanitized_artist} - {sanitized_title} (Karaoke).lrc")
 
@@ -137,10 +157,15 @@ class LyricsProcessor:
                 "ass_filepath": parent_video_path,
             }
 
-        # Create lyrics subdirectory for new transcription
+        # Create lyrics directory if it doesn't exist
         os.makedirs(lyrics_dir, exist_ok=True)
         self.logger.info(f"Created lyrics directory: {lyrics_dir}")
 
+        # Set render_video to False if explicitly disabled
+        render_video = self.render_video
+        if not render_video:
+            self.logger.info("Video rendering disabled, skipping video output")
+
         # Load environment variables
         load_dotenv()
         env_config = {
@@ -162,29 +187,51 @@ class LyricsProcessor:
             lyrics_file=self.lyrics_file,
         )
 
+        # Detect if we're running in a serverless environment (Modal)
+        # Modal sets specific environment variables we can check for
+        is_serverless = (
+            os.getenv("MODAL_TASK_ID") is not None or 
+            os.getenv("MODAL_FUNCTION_NAME") is not None or
+            os.path.exists("/.modal")  # Modal creates this directory in containers
+        )
+        
+        # In serverless environment, disable interactive review even if skip_transcription_review=False
+        # This preserves CLI behavior while fixing serverless hanging
+        enable_review_setting = not self.skip_transcription_review and not is_serverless
+        
+        if is_serverless and not self.skip_transcription_review:
+            self.logger.info("Detected serverless environment - disabling interactive review to prevent hanging")
+        
+        # In serverless environment, disable video generation during Phase 1 to save compute
+        # Video will be generated in Phase 2 after human review
+        serverless_render_video = render_video and not is_serverless
+        
+        if is_serverless and render_video:
+            self.logger.info("Detected serverless environment - deferring video generation until after review")
+        
         output_config = OutputConfig(
             output_styles_json=self.style_params_json,
             output_dir=lyrics_dir,
-            render_video=self.render_video,
+            render_video=serverless_render_video,  # Disable video in serverless Phase 1
             fetch_lyrics=True,
             run_transcription=not self.skip_transcription,
             run_correction=True,
             generate_plain_text=True,
             generate_lrc=True,
-            generate_cdg=True,
+            generate_cdg=False,  # Also defer CDG generation to Phase 2 
             video_resolution="4k",
-            enable_review=not self.skip_transcription_review,
+            enable_review=enable_review_setting,
             subtitle_offset_ms=self.subtitle_offset_ms,
         )
 
         # Add this log entry to debug the OutputConfig
         self.logger.info(f"Instantiating LyricsTranscriber with OutputConfig: {output_config}")
 
-        # Initialize transcriber with new config objects
+        # Initialize transcriber with new config objects - use PROCESSING artist/title for lyrics work
         transcriber = LyricsTranscriber(
             audio_filepath=input_audio_wav,
-            artist=artist,
-            title=title,
+            artist=processing_artist,  # Use lyrics_artist for processing
+            title=processing_title,   # Use lyrics_title for processing
             transcriber_config=transcriber_config,
             lyrics_config=lyrics_config,
             output_config=output_config,
@@ -216,6 +263,19 @@ class LyricsProcessor:
             )
             transcriber_outputs["corrected_lyrics_text_filepath"] = results.corrected_txt
 
+            # Save correction data to JSON file for review interface
+            # Use the expected filename format: "{artist} - {title} (Lyrics Corrections).json"
+            corrections_filename = f"{filename_artist} - {filename_title} (Lyrics Corrections).json"
+            corrections_filepath = os.path.join(lyrics_dir, corrections_filename)
+            
+            # Use the CorrectionResult's to_dict() method to serialize
+            correction_data = results.transcription_corrected.to_dict()
+            
+            with open(corrections_filepath, 'w') as f:
+                json.dump(correction_data, f, indent=2)
+            
+            self.logger.info(f"Saved correction data to {corrections_filepath}")
+
         if transcriber_outputs:
             self.logger.info(f"*** Transcriber Filepath Outputs: ***")
             for key, value in transcriber_outputs.items():

{karaoke_prep → karaoke_gen}/metadata.py

@@ -1,30 +1,80 @@
 import logging
 import yt_dlp.YoutubeDL as ydl
 
-def extract_info_for_online_media(input_url, input_artist, input_title, logger):
+def extract_info_for_online_media(input_url, input_artist, input_title, logger, cookies_str=None):
     """Extracts metadata using yt-dlp, either from a URL or via search."""
     logger.info(f"Extracting info for input_url: {input_url} input_artist: {input_artist} input_title: {input_title}")
-    extracted_info = None
-    if input_url is not None:
-        # If a URL is provided, use it to extract the metadata
-        with ydl({"quiet": True}) as ydl_instance:
-            extracted_info = ydl_instance.extract_info(input_url, download=False)
+    
+    # Set up yt-dlp options with enhanced anti-detection
+    base_opts = {
+        "quiet": True,
+        # Anti-detection options
+        "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "referer": "https://www.youtube.com/",
+        "sleep_interval": 1,
+        "max_sleep_interval": 3,
+        "fragment_retries": 3,
+        "extractor_retries": 3,
+        "retries": 3,
+        # Headers to appear more human
+        "http_headers": {
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "en-us,en;q=0.5",
+            "Accept-Encoding": "gzip, deflate",
+            "DNT": "1",
+            "Connection": "keep-alive",
+            "Upgrade-Insecure-Requests": "1",
+        },
+    }
+    
+    # Add cookies if provided
+    if cookies_str:
+        logger.info("Using provided cookies for enhanced YouTube access")
+        # Save cookies to a temporary file
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+            f.write(cookies_str)
+            base_opts['cookiefile'] = f.name
     else:
-        # If no URL is provided, use the query to search for the top result
-        ydl_opts = {"quiet": "True", "format": "bestaudio", "noplaylist": "True", "extract_flat": True}
-        with ydl(ydl_opts) as ydl_instance:
-            query = f"{input_artist} {input_title}"
-            search_results = ydl_instance.extract_info(f"ytsearch1:{query}", download=False)
-            if search_results and "entries" in search_results and search_results["entries"]:
-                 extracted_info = search_results["entries"][0]
-            else:
-                # Raise IndexError to match the expected exception in tests
-                raise IndexError(f"No search results found on YouTube for query: {input_artist} {input_title}")
-
-    if not extracted_info:
-         raise Exception(f"Failed to extract info for query: {input_artist} {input_title} or URL: {input_url}")
-
-    return extracted_info
+        logger.info("No cookies provided - attempting standard extraction")
+    
+    extracted_info = None
+    try:
+        if input_url is not None:
+            # If a URL is provided, use it to extract the metadata
+            with ydl(base_opts) as ydl_instance:
+                extracted_info = ydl_instance.extract_info(input_url, download=False)
+        else:
+            # If no URL is provided, use the query to search for the top result
+            search_opts = base_opts.copy()
+            search_opts.update({
+                "format": "bestaudio", 
+                "noplaylist": "True", 
+                "extract_flat": True
+            })
+            
+            with ydl(search_opts) as ydl_instance:
+                query = f"{input_artist} {input_title}"
+                search_results = ydl_instance.extract_info(f"ytsearch1:{query}", download=False)
+                if search_results and "entries" in search_results and search_results["entries"]:
+                     extracted_info = search_results["entries"][0]
+                else:
+                    # Raise IndexError to match the expected exception in tests
+                    raise IndexError(f"No search results found on YouTube for query: {input_artist} {input_title}")
+
+        if not extracted_info:
+             raise Exception(f"Failed to extract info for query: {input_artist} {input_title} or URL: {input_url}")
+
+        return extracted_info
+        
+    finally:
+        # Clean up temporary cookie file if it was created
+        if cookies_str and 'cookiefile' in base_opts:
+            try:
+                import os
+                os.unlink(base_opts['cookiefile'])
+            except:
+                pass
 
 
 def parse_track_metadata(extracted_info, current_artist, current_title, persistent_artist, logger):

{karaoke_prep → karaoke_gen}/utils/bulk_cli.py

@@ -7,8 +7,8 @@ import csv
 import asyncio
 import json
 import sys
-from karaoke_prep import KaraokePrep
-from karaoke_prep.karaoke_finalise import KaraokeFinalise
+from karaoke_gen import KaraokePrep
+from karaoke_gen.karaoke_finalise import KaraokeFinalise
 
 # Global logger
 logger = logging.getLogger(__name__)

{karaoke_prep → karaoke_gen}/utils/gen_cli.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-print("DEBUG: gen_cli.py starting imports...")
 import argparse
 import logging
 from importlib import metadata
@@ -10,10 +9,8 @@ import json
 import asyncio
 import time
 import pyperclip
-from karaoke_prep import KaraokePrep
-from karaoke_prep.karaoke_finalise import KaraokeFinalise
-
-print("DEBUG: gen_cli.py imports complete.")
+from karaoke_gen import KaraokePrep
+from karaoke_gen.karaoke_finalise import KaraokeFinalise
 
 
 def is_url(string):
@@ -27,15 +24,12 @@ def is_file(string):
 
 
 async def async_main():
-    print("DEBUG: async_main() started.")
     logger = logging.getLogger(__name__)
     log_handler = logging.StreamHandler()
     log_formatter = logging.Formatter(fmt="%(asctime)s.%(msecs)03d - %(levelname)s - %(module)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
     log_handler.setFormatter(log_formatter)
     logger.addHandler(log_handler)
 
-    print("DEBUG: async_main() logger configured.")
-
     parser = argparse.ArgumentParser(
         description="Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video.",
         formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, max_help_position=54),
@@ -53,7 +47,6 @@ async def async_main():
         package_version = metadata.version("karaoke-gen")
     except metadata.PackageNotFoundError:
         package_version = "unknown"
-        print("DEBUG: Could not find version for karaoke-gen")
 
     parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {package_version}")
 
@@ -290,8 +283,6 @@ async def async_main():
 
     args = parser.parse_args()
 
-    print("DEBUG: async_main() args parsed.")
-
     # Handle test email template case first
     if args.test_email_template:
         log_level = getattr(logging, args.log_level.upper())
@@ -305,8 +296,6 @@ async def async_main():
         kfinalise.test_email_template()
         return
 
-    print("DEBUG: async_main() continuing after test_email_template check.")
-
     # Handle edit-lyrics mode
     if args.edit_lyrics:
         log_level = getattr(logging, args.log_level.upper())
@@ -484,8 +473,6 @@ async def async_main():
             raise e
             
         return
-        
-    print("DEBUG: async_main() continuing after edit_lyrics check.")
 
     # Handle finalise-only mode
     if args.finalise_only:
@@ -512,7 +499,11 @@ async def async_main():
                 logger.error(f"Invalid JSON in CDG styles configuration file: {e}")
                 sys.exit(1)
                 return  # Explicit return for testing
-
+            except KeyError:
+                logger.error(f"'cdg' key not found in style parameters file: {args.style_params_json}")
+                sys.exit(1)
+                return # Explicit return for testing
+        
         kfinalise = KaraokeFinalise(
             log_formatter=log_formatter,
             log_level=log_level,
@@ -530,13 +521,16 @@ async def async_main():
             discord_webhook_url=args.discord_webhook_url,
             email_template_file=args.email_template_file,
             cdg_styles=cdg_styles,
-            keep_brand_code=args.keep_brand_code,
+            keep_brand_code=getattr(args, 'keep_brand_code', False),
             non_interactive=args.yes,
         )
-
+        
         try:
             track = kfinalise.process()
-            logger.info(f"Karaoke finalisation processing complete! Output files:")
+            logger.info(f"Successfully completed finalisation for: {track['artist']} - {track['title']}")
+            
+            # Display summary of outputs
+            logger.info(f"Karaoke finalisation complete! Output files:")
             logger.info(f"")
             logger.info(f"Track: {track['artist']} - {track['title']}")
             logger.info(f"")
@@ -564,7 +558,7 @@ async def async_main():
                 logger.info(f"")
                 logger.info(f"Organization:")
                 logger.info(f" Brand Code: {track['brand_code']}")
-                logger.info(f" New Directory: {track['new_brand_code_dir_path']}")
+                logger.info(f" Directory: {track['new_brand_code_dir_path']}")
 
             if track["youtube_url"] or track["brand_code_dir_sharing_link"]:
                 logger.info(f"")
@@ -592,8 +586,6 @@ async def async_main():
         
         return
 
-    print("DEBUG: async_main() parsed positional args.")
-
     # For prep or full workflow, parse input arguments
     input_media, artist, title, filename_pattern = None, None, None, None
 
@@ -643,23 +635,18 @@ async def async_main():
     log_level = getattr(logging, args.log_level.upper())
     logger.setLevel(log_level)
 
-    print("DEBUG: async_main() log level set.")
-
     # Set up environment variables for lyrics-only mode
     if args.lyrics_only:
         args.skip_separation = True
-        os.environ["KARAOKE_PREP_SKIP_AUDIO_SEPARATION"] = "1"
-        os.environ["KARAOKE_PREP_SKIP_TITLE_END_SCREENS"] = "1"
+        os.environ["KARAOKE_GEN_SKIP_AUDIO_SEPARATION"] = "1"
+        os.environ["KARAOKE_GEN_SKIP_TITLE_END_SCREENS"] = "1"
         logger.info("Lyrics-only mode enabled: skipping audio separation and title/end screen generation")
 
-    print("DEBUG: async_main() instantiating KaraokePrep...")
-
     # Step 1: Run KaraokePrep
-    logger.info(f"KaraokePrep beginning with input_media: {input_media} artist: {artist} and title: {title}")
     kprep_coroutine = KaraokePrep(
+        input_media=input_media,
         artist=artist,
         title=title,
-        input_media=input_media,
         filename_pattern=filename_pattern,
         dry_run=args.dry_run,
         log_formatter=log_formatter,
@@ -688,64 +675,16 @@ async def async_main():
     # No await needed for constructor
     kprep = kprep_coroutine
 
-    print("DEBUG: async_main() KaraokePrep instantiated.")
-    
-    print(f"DEBUG: kprep type: {type(kprep)}")
-    print(f"DEBUG: kprep.process type: {type(kprep.process)}")
-    process_coroutine = kprep.process()
-    print(f"DEBUG: process_coroutine type: {type(process_coroutine)}")
-    tracks = await process_coroutine
-
-    print("DEBUG: async_main() kprep.process() finished.")
+    # Create final tracks data structure
+    tracks = await kprep.process()
 
-    # If prep-only mode, display detailed output and exit
+    # If prep-only mode, we're done
     if args.prep_only:
-        logger.info(f"Karaoke Prep complete! Output files:")
-
-        for track in tracks:
-            logger.info(f"")
-            logger.info(f"Track: {track['artist']} - {track['title']}")
-            logger.info(f" Input Media: {track['input_media']}")
-            logger.info(f" Input WAV Audio: {track['input_audio_wav']}")
-            logger.info(f" Input Still Image: {track['input_still_image']}")
-            logger.info(f" Lyrics: {track['lyrics']}")
-            logger.info(f" Processed Lyrics: {track['processed_lyrics']}")
-
-            logger.info(f" Separated Audio:")
-
-            # Clean Instrumental
-            logger.info(f"  Clean Instrumental Model:")
-            for stem_type, file_path in track["separated_audio"]["clean_instrumental"].items():
-                logger.info(f"   {stem_type.capitalize()}: {file_path}")
-
-            # Other Stems
-            logger.info(f"  Other Stems Models:")
-            for model, stems in track["separated_audio"]["other_stems"].items():
-                logger.info(f"   Model: {model}")
-                for stem_type, file_path in stems.items():
-                    logger.info(f"    {stem_type.capitalize()}: {file_path}")
-
-            # Backing Vocals
-            logger.info(f"  Backing Vocals Models:")
-            for model, stems in track["separated_audio"]["backing_vocals"].items():
-                logger.info(f"   Model: {model}")
-                for stem_type, file_path in stems.items():
-                    logger.info(f"    {stem_type.capitalize()}: {file_path}")
-
-            # Combined Instrumentals
-            logger.info(f"  Combined Instrumentals:")
-            for model, file_path in track["separated_audio"]["combined_instrumentals"].items():
-                logger.info(f"   Model: {model}")
-                logger.info(f"    Combined Instrumental: {file_path}")
-
-        logger.info("Preparation phase complete. Exiting due to --prep-only flag.")
+        logger.info("Prep-only mode: skipping finalisation phase")
         return
 
-    print("DEBUG: async_main() continuing after prep_only check.")
-
     # Step 2: For each track, run KaraokeFinalise
     for track in tracks:
-        print(f"DEBUG: async_main() starting finalise loop for track: {track.get('track_output_dir')}")
         logger.info(f"Starting finalisation phase for {track['artist']} - {track['title']}...")
 
         # Use the track directory that was actually created by KaraokePrep
@@ -776,8 +715,11 @@ async def async_main():
                 logger.error(f"Invalid JSON in CDG styles configuration file: {e}")
                 sys.exit(1)
                 return  # Explicit return for testing
+            except KeyError:
+                logger.error(f"'cdg' key not found in style parameters file: {args.style_params_json}")
+                sys.exit(1)
+                return # Explicit return for testing
 
-        # Initialize KaraokeFinalise
         kfinalise = KaraokeFinalise(
             log_formatter=log_formatter,
             log_level=log_level,
@@ -795,16 +737,16 @@ async def async_main():
             discord_webhook_url=args.discord_webhook_url,
             email_template_file=args.email_template_file,
             cdg_styles=cdg_styles,
-            keep_brand_code=args.keep_brand_code,
+            keep_brand_code=getattr(args, 'keep_brand_code', False),
             non_interactive=args.yes,
         )
 
         try:
             final_track = kfinalise.process()
-            logger.info(f"Successfully completed processing for: {track['artist']} - {track['title']}")
+            logger.info(f"Successfully completed processing: {final_track['artist']} - {final_track['title']}")
             
             # Display summary of outputs
-            logger.info(f"Karaoke processing complete! Output files:")
+            logger.info(f"Karaoke generation complete! Output files:")
             logger.info(f"")
             logger.info(f"Track: {final_track['artist']} - {final_track['title']}")
             logger.info(f"")
@@ -832,7 +774,7 @@ async def async_main():
                 logger.info(f"")
                 logger.info(f"Organization:")
                 logger.info(f" Brand Code: {final_track['brand_code']}")
-                logger.info(f" New Directory: {final_track['new_brand_code_dir_path']}")
+                logger.info(f" Directory: {final_track['new_brand_code_dir_path']}")
 
             if final_track["youtube_url"] or final_track["brand_code_dir_sharing_link"]:
                 logger.info(f"")
@@ -854,20 +796,16 @@ async def async_main():
                     logger.info(f" (YouTube URL copied to clipboard)")
                 except Exception as e:
                     logger.warning(f" Failed to copy YouTube URL to clipboard: {str(e)}")
-                    
         except Exception as e:
-            logger.error(f"Error during finalisation: {str(e)}")
+            logger.error(f"An error occurred during finalisation, see stack trace below: {str(e)}")
             raise e
-
-    print("DEBUG: async_main() finished.")
+        
+        return
 
 
 def main():
-    print("DEBUG: main() started.")
     asyncio.run(async_main())
-    print("DEBUG: main() finished.")
 
 
 if __name__ == "__main__":
-    print("DEBUG: __main__ block executing.")
     main()

{karaoke_prep → karaoke_gen}/video_generator.py

@@ -71,7 +71,7 @@ class VideoGenerator:
             else:
                 # Try to load from package resources
                 try:
-                    with pkg_resources.path("karaoke_prep.resources", format["font"]) as font_path:
+                    with pkg_resources.path("karaoke_gen.resources", format["font"]) as font_path:
                         font_path = str(font_path)
                 except Exception as e:
                     self.logger.warning(f"Could not load font from resources: {e}, falling back to default font")
@@ -96,7 +96,7 @@ class VideoGenerator:
 
     def calculate_text_size_to_fit(self, draw, text, font_path, region):
         font_size = 500  # Start with a large font size
-        font = ImageFont.truetype(font_path, size=font_size) if os.path.exists(font_path) else ImageFont.load_default()
+        font = ImageFont.truetype(font_path, size=font_size) if font_path and os.path.exists(font_path) else ImageFont.load_default()
 
         def get_text_size(text, font):
             bbox = draw.textbbox((0, 0), text, font=font)
@@ -117,7 +117,7 @@ class VideoGenerator:
 
                 # Reset font size for two-line layout
                 font_size = 500
-                font = ImageFont.truetype(font_path, size=font_size) if os.path.exists(font_path) else ImageFont.load_default()
+                font = ImageFont.truetype(font_path, size=font_size) if font_path and os.path.exists(font_path) else ImageFont.load_default()
 
                 while True:
                     text_width1, text_height1 = get_text_size(line1, font)
@@ -134,9 +134,9 @@ class VideoGenerator:
                     font_size -= 10
                     if font_size <= 0:
                         raise ValueError("Cannot fit text within the defined region.")
-                    font = ImageFont.truetype(font_path, size=font_size) if os.path.exists(font_path) else ImageFont.load_default()
+                    font = ImageFont.truetype(font_path, size=font_size) if font_path and os.path.exists(font_path) else ImageFont.load_default()
 
-            font = ImageFont.truetype(font_path, size=font_size) if os.path.exists(font_path) else ImageFont.load_default()
+            font = ImageFont.truetype(font_path, size=font_size) if font_path and os.path.exists(font_path) else ImageFont.load_default()
             text_width, text_height = get_text_size(text, font)
 
         return font, text

{karaoke_gen-0.50.0.dist-info → karaoke_gen-0.56.0.dist-info}/METADATA

@@ -1,19 +1,20 @@
 Metadata-Version: 2.3
 Name: karaoke-gen
-Version: 0.50.0
+Version: 0.56.0
 Summary: Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens.
 License: MIT
 Author: Andrew Beveridge
 Author-email: andrew@beveridge.uk
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.10,<3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: argparse (>=1.4.0)
 Requires-Dist: attrs (>=24.2.0)
-Requires-Dist: audio-separator[cpu] (>=0.21.0)
+Requires-Dist: audio-separator[cpu] (>=0.34.0)
 Requires-Dist: beautifulsoup4 (>=4)
 Requires-Dist: cattrs (>=24.1.2)
 Requires-Dist: fetch-lyrics-from-genius (>=0.1)
@@ -24,31 +25,38 @@ Requires-Dist: google-auth-httplib2
 Requires-Dist: google-auth-oauthlib
 Requires-Dist: kbputils (>=0.0.16,<0.0.17)
 Requires-Dist: lyrics-converter (>=0.2.1)
-Requires-Dist: lyrics-transcriber (>=0.34)
+Requires-Dist: lyrics-transcriber (>=0.58)
 Requires-Dist: lyricsgenius (>=3)
-Requires-Dist: numpy (>=1,<2)
+Requires-Dist: modal (>=1.0.5,<2.0.0)
+Requires-Dist: numpy (>=2)
 Requires-Dist: pillow (>=10.1)
 Requires-Dist: psutil (>=7.0.0,<8.0.0)
 Requires-Dist: pyinstaller (>=6.3)
 Requires-Dist: pyperclip
 Requires-Dist: pytest-asyncio (>=0.23.5,<0.24.0)
+Requires-Dist: python-multipart (>=0.0.20,<0.0.21)
 Requires-Dist: requests (>=2)
 Requires-Dist: thefuzz (>=0.22)
 Requires-Dist: toml (>=0.10)
-Requires-Dist: torch (<2.5)
+Requires-Dist: torch (>=2.7)
 Requires-Dist: yt-dlp
-Project-URL: Documentation, https://github.com/karaokenerds/karaoke-gen/blob/main/README.md
-Project-URL: Homepage, https://github.com/karaokenerds/karaoke-gen
-Project-URL: Repository, https://github.com/karaokenerds/karaoke-gen
+Project-URL: Documentation, https://github.com/nomadkaraoke/karaoke-gen/blob/main/README.md
+Project-URL: Homepage, https://github.com/nomadkaraoke/karaoke-gen
+Project-URL: Repository, https://github.com/nomadkaraoke/karaoke-gen
 Description-Content-Type: text/markdown
 
-# Karaoke Gen
+# Karaoke Generator 🎶 🎥 🚀
 
-Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens.
+![PyPI - Version](https://img.shields.io/pypi/v/karaoke-gen)
+![Python Version](https://img.shields.io/badge/python-3.10+-blue)
+![Tests](https://github.com/nomadkaraoke/karaoke-gen/workflows/Test%20and%20Publish/badge.svg)
+![Test Coverage](https://codecov.io/gh/nomadkaraoke/karaoke-gen/branch/main/graph/badge.svg)
+
+Generate karaoke videos with instrumental audio and synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens, uploading the resulting video to YouTube.
 
 ## Overview
 
-Karaoke Gen is a comprehensive tool for creating high-quality karaoke videos. It automates the entire workflow:
+Karaoke Generator is a comprehensive tool for creating high-quality karaoke videos. It automates the entire workflow:
 
 1. **Download** audio and lyrics for a specified song
 2. **Separate** audio stems (vocals, instrumental)
@@ -134,6 +142,25 @@ For a complete list of options:
 karaoke-gen --help
 ```
 
+## Development
+
+### Running Tests
+
+The project uses pytest for testing with unit and integration tests:
+
+```bash
+# Run all tests (unit tests first, then integration tests)
+pytest
+
+# Run only unit tests (fast feedback during development)
+pytest -m "not integration"
+
+# Run only integration tests (comprehensive end-to-end testing)
+pytest -m integration
+```
+
+Unit tests run quickly and provide fast feedback, while integration tests are slower but test the full workflow end-to-end.
+
 ## License
 
 MIT

karaoke_gen-0.56.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+karaoke_gen/__init__.py,sha256=ViryQjs8ALc8A7mqJGHu028zajF5-Za_etFagXlo6kk,269
+karaoke_gen/audio_processor.py,sha256=gqQo8dsG_4SEO5kwyT76DiU4jCNyiGpi6TT1R3imdGY,19591
+karaoke_gen/config.py,sha256=I3h-940ZXvbrCNq_xcWHPMIB76cl-VNQYcK7-qgB-YI,6833
+karaoke_gen/file_handler.py,sha256=c86-rGF7Fusl0uEIZFnreT7PJfK7lmUaEgauU8BBzjY,10024
+karaoke_gen/karaoke_finalise/__init__.py,sha256=HqZ7TIhgt_tYZ-nb_NNCaejWAcF_aK-7wJY5TaW_keM,46
+karaoke_gen/karaoke_finalise/karaoke_finalise.py,sha256=C2o9iRg5qgWc8qxNVzy8puA8W2ZtKJq28dnxXxS1RMs,56556
+karaoke_gen/karaoke_gen.py,sha256=NEyb-AWLdqJL4nXg21o_YbutZVVbKt08TTPAYgSBDao,38052
+karaoke_gen/lyrics_processor.py,sha256=054zBeYaCFti6lHRfYyHYdioM9YhBrpI52kHsSCh_KI,13363
+karaoke_gen/metadata.py,sha256=TprFzWj-iJ7ghrXlHFMPzzqzuHzWeNvs3zGaND-z9Ds,6503
+karaoke_gen/resources/AvenirNext-Bold.ttf,sha256=YxgKz2OP46lwLPCpIZhVa8COi_9KRDSXw4n8dIHHQSs,327048
+karaoke_gen/resources/Montserrat-Bold.ttf,sha256=mLFIaBDC7M-qF9RhCoPBJ5TAeY716etBrqA4eUKSoYc,198120
+karaoke_gen/resources/Oswald-Bold.ttf,sha256=S_2mLpNkBsDTe8FQRzrj1Qr-wloGETMJgoAcSKdi1lw,87604
+karaoke_gen/resources/Oswald-SemiBold.ttf,sha256=G-vSJeeyEVft7D4s7FZQtGfXAViWPjzGCImV2a4u9d8,87608
+karaoke_gen/resources/Zurich_Cn_BT_Bold.ttf,sha256=WNG5LOQ-uGUF_WWT5aQHzVbyWvQqGO5sZ4E-nRmvPuI,37780
+karaoke_gen/utils/__init__.py,sha256=FpOHyeBRB06f3zMoLBUJHTDZACrabg-DoyBTxNKYyNY,722
+karaoke_gen/utils/bulk_cli.py,sha256=uqAHnlidY-f_RhsQIHqZDnrznWRKhqpEDX2uiR1CUQs,18841
+karaoke_gen/utils/gen_cli.py,sha256=sAZ-sau_3dI2hNBOZfiZqJjRf_cJFtuvZLy1V6URcxM,35688
+karaoke_gen/video_generator.py,sha256=B7BQBrjkyvk3L3sctnPXnvr1rzkw0NYx5UCAl0ZiVx0,18464
+karaoke_gen-0.56.0.dist-info/LICENSE,sha256=81R_4XwMZDODHD7JcZeUR8IiCU8AD7Ajl6bmwR9tYDk,1074
+karaoke_gen-0.56.0.dist-info/METADATA,sha256=4zBpc8AJtrh7d6vuYczv5vdii4IdW7XjROzysGZji4E,5591
+karaoke_gen-0.56.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+karaoke_gen-0.56.0.dist-info/entry_points.txt,sha256=IZY3O8i7m-qkmPuqgpAcxiS2fotNc6hC-CDWvNmoUEY,107
+karaoke_gen-0.56.0.dist-info/RECORD,,

karaoke_gen-0.56.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+karaoke-bulk=karaoke_gen.utils.bulk_cli:main
+karaoke-gen=karaoke_gen.utils.gen_cli:main
+

karaoke_gen-0.50.0.dist-info/RECORD

@@ -1,23 +0,0 @@
-karaoke_prep/__init__.py,sha256=gwWt2-Z35n3jLfLG0phvz9IVZeM7rH5f3mflqUV79X4,38
-karaoke_prep/audio_processor.py,sha256=Po2x3x5JyRe5yGUhJlzM5_mw9E7GijUbv-_hc_kAXqs,19131
-karaoke_prep/config.py,sha256=I3h-940ZXvbrCNq_xcWHPMIB76cl-VNQYcK7-qgB-YI,6833
-karaoke_prep/file_handler.py,sha256=sQNfEpqIir4Jd-V0VXUGZlsItt7pxZ8n_muzc1ONYck,8479
-karaoke_prep/karaoke_finalise/__init__.py,sha256=HqZ7TIhgt_tYZ-nb_NNCaejWAcF_aK-7wJY5TaW_keM,46
-karaoke_prep/karaoke_finalise/karaoke_finalise.py,sha256=sDW50vz4UMVEcrqB7WXx2bNT9Hvza-EOx8KqGHvGNYA,55917
-karaoke_prep/karaoke_prep.py,sha256=nu5Ayg3UjlYiCICRr3hGQUNYRkFv6W3QvcCJEnQtFgM,37177
-karaoke_prep/lyrics_processor.py,sha256=Yuax-FlcL_aLcLIPPAKyIjjwrNlnvAWGJOFlLbAUXEE,9994
-karaoke_prep/metadata.py,sha256=PkwTnxX7fwbRmo_8ysC2zAMYSdZTtJtXWQypgNzssz8,4729
-karaoke_prep/resources/AvenirNext-Bold.ttf,sha256=YxgKz2OP46lwLPCpIZhVa8COi_9KRDSXw4n8dIHHQSs,327048
-karaoke_prep/resources/Montserrat-Bold.ttf,sha256=mLFIaBDC7M-qF9RhCoPBJ5TAeY716etBrqA4eUKSoYc,198120
-karaoke_prep/resources/Oswald-Bold.ttf,sha256=S_2mLpNkBsDTe8FQRzrj1Qr-wloGETMJgoAcSKdi1lw,87604
-karaoke_prep/resources/Oswald-SemiBold.ttf,sha256=G-vSJeeyEVft7D4s7FZQtGfXAViWPjzGCImV2a4u9d8,87608
-karaoke_prep/resources/Zurich_Cn_BT_Bold.ttf,sha256=WNG5LOQ-uGUF_WWT5aQHzVbyWvQqGO5sZ4E-nRmvPuI,37780
-karaoke_prep/utils/__init__.py,sha256=FpOHyeBRB06f3zMoLBUJHTDZACrabg-DoyBTxNKYyNY,722
-karaoke_prep/utils/bulk_cli.py,sha256=Lezs8XNLk2Op0b6wmmupZGU3owgdMoLN4PFVRQQbRxM,18843
-karaoke_prep/utils/gen_cli.py,sha256=vNhs0Oyi3sIkzNLvVXQCCsCF5Ku5bt75xdu4IsfAX3A,38326
-karaoke_prep/video_generator.py,sha256=agtE7zDfY-4COjb7yT8aSPxvNGpOORV_lRtKczGbokM,18409
-karaoke_gen-0.50.0.dist-info/LICENSE,sha256=81R_4XwMZDODHD7JcZeUR8IiCU8AD7Ajl6bmwR9tYDk,1074
-karaoke_gen-0.50.0.dist-info/METADATA,sha256=WWboqA8QSLhczte82rbRqlvJxDG5SMeSND0lmT4dUso,4563
-karaoke_gen-0.50.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-karaoke_gen-0.50.0.dist-info/entry_points.txt,sha256=8OkNvWtcr6Zceif8PbpYr6MBa2cFd_B1vJXP6Xcdyks,109
-karaoke_gen-0.50.0.dist-info/RECORD,,

karaoke_gen-0.50.0.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-[console_scripts]
-karaoke-bulk=karaoke_prep.utils.bulk_cli:main
-karaoke-gen=karaoke_prep.utils.gen_cli:main
-

karaoke_prep/__init__.py

@@ -1 +0,0 @@
-from .karaoke_prep import KaraokePrep