karaoke-gen 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

karaoke_gen/audio_processor.py

@@ -12,6 +12,14 @@ import psutil
 from datetime import datetime
 from pydub import AudioSegment
 
+# Try to import the remote API client if available
+try:
+    from audio_separator.remote import AudioSeparatorAPIClient
+    REMOTE_API_AVAILABLE = True
+except ImportError:
+    REMOTE_API_AVAILABLE = False
+    AudioSeparatorAPIClient = None
+
 
 # Placeholder class or functions for audio processing
 class AudioProcessor:
@@ -104,9 +112,36 @@ class AudioProcessor:
         self.logger.info(f"Separation complete! Output file(s): {vocals_path} {instrumental_path}")
 
     def process_audio_separation(self, audio_file, artist_title, track_output_dir):
+        # Check if we should use remote API
+        remote_api_url = os.environ.get("AUDIO_SEPARATOR_API_URL")
+        if remote_api_url:
+            if not REMOTE_API_AVAILABLE:
+                self.logger.warning("AUDIO_SEPARATOR_API_URL is set but remote API client is not available. "
+                                  "Please ensure audio-separator is updated to a version that includes remote API support. "
+                                  "Falling back to local processing.")
+            else:
+                self.logger.info(f"Using remote audio separator API at: {remote_api_url}")
+                try:
+                    return self._process_audio_separation_remote(audio_file, artist_title, track_output_dir, remote_api_url)
+                except Exception as e:
+                    error_str = str(e)
+                    # Don't fall back for download failures - these indicate API issues that should be fixed
+                    if ("no files were downloaded" in error_str or 
+                        "failed to produce essential" in error_str):
+                        self.logger.error(f"Remote API processing failed with download/file organization issue: {error_str}")
+                        self.logger.error("This indicates an audio-separator API issue that should be fixed. Not falling back to local processing.")
+                        raise e
+                    else:
+                        # Fall back for other types of errors (network issues, etc.)
+                        self.logger.error(f"Remote API processing failed: {error_str}")
+                        self.logger.info("Falling back to local audio separation")
+        else:
+            self.logger.info("AUDIO_SEPARATOR_API_URL not set, using local audio separation. "
+                           "Set this environment variable to use remote GPU processing.")
+        
         from audio_separator.separator import Separator
 
-        self.logger.info(f"Starting audio separation process for {artist_title}")
+        self.logger.info(f"Starting local audio separation process for {artist_title}")
 
         # Define lock file path in system temp directory
         lock_file_path = os.path.join(tempfile.gettempdir(), "audio_separator.lock")
@@ -203,33 +238,34 @@ class AudioProcessor:
             self._normalize_audio_files(result, artist_title, track_output_dir)
 
             # Create Audacity LOF file
-            lof_path = os.path.join(stems_dir, f"{artist_title} (Audacity).lof")
-            first_model = list(result["backing_vocals"].keys())[0]
-
-            files_to_include = [
-                audio_file,  # Original audio
-                result["clean_instrumental"]["instrumental"],  # Clean instrumental
-                result["backing_vocals"][first_model]["backing_vocals"],  # Backing vocals
-                result["combined_instrumentals"][first_model],  # Combined instrumental+BV
-            ]
-
-            # Convert to absolute paths
-            files_to_include = [os.path.abspath(f) for f in files_to_include]
-
-            with open(lof_path, "w") as lof:
-                for file_path in files_to_include:
-                    lof.write(f'file "{file_path}"\n')
-
-            self.logger.info(f"Created Audacity LOF file: {lof_path}")
-            result["audacity_lof"] = lof_path
-
-            # Launch Audacity with multiple tracks
-            if sys.platform == "darwin":  # Check if we're on macOS
-                if lof_path and os.path.exists(lof_path):
-                    self.logger.info(f"Launching Audacity with LOF file: {lof_path}")
-                    os.system(f'open -a Audacity "{lof_path}"')
-                else:
-                    self.logger.debug("Audacity LOF file not available or not found")
+            if result["backing_vocals"]:
+                lof_path = os.path.join(stems_dir, f"{artist_title} (Audacity).lof")
+                first_model = list(result["backing_vocals"].keys())[0]
+
+                files_to_include = [
+                    audio_file,  # Original audio
+                    result["clean_instrumental"]["instrumental"],  # Clean instrumental
+                    result["backing_vocals"][first_model]["backing_vocals"],  # Backing vocals
+                    result["combined_instrumentals"][first_model],  # Combined instrumental+BV
+                ]
+
+                # Convert to absolute paths
+                files_to_include = [os.path.abspath(f) for f in files_to_include]
+
+                with open(lof_path, "w") as lof:
+                    for file_path in files_to_include:
+                        lof.write(f'file "{file_path}"\n')
+
+                self.logger.info(f"Created Audacity LOF file: {lof_path}")
+                result["audacity_lof"] = lof_path
+
+                # Launch Audacity with multiple tracks
+                if sys.platform == "darwin":  # Check if we're on macOS
+                    if lof_path and os.path.exists(lof_path):
+                        self.logger.info(f"Launching Audacity with LOF file: {lof_path}")
+                        os.system(f'open -a Audacity "{lof_path}"')
+                    else:
+                        self.logger.debug("Audacity LOF file not available or not found")
 
             self.logger.info("Audio separation, combination, and normalization process completed")
             return result
@@ -242,6 +278,288 @@ class AudioProcessor:
             except OSError:
                 pass
 
+    def _process_audio_separation_remote(self, audio_file, artist_title, track_output_dir, remote_api_url):
+        """Process audio separation using remote API with proper two-stage workflow."""
+        self.logger.info(f"Starting remote audio separation process for {artist_title}")
+        
+        # Initialize the API client
+        api_client = AudioSeparatorAPIClient(remote_api_url, self.logger)
+        
+        stems_dir = self._create_stems_directory(track_output_dir)
+        result = {"clean_instrumental": {}, "other_stems": {}, "backing_vocals": {}, "combined_instrumentals": {}}
+
+        if os.environ.get("KARAOKE_GEN_SKIP_AUDIO_SEPARATION"):
+            return result
+
+        try:
+            # Stage 1: Process original song with clean instrumental model + other stems models
+            stage1_models = []
+            if self.clean_instrumental_model:
+                stage1_models.append(self.clean_instrumental_model)
+            stage1_models.extend(self.other_stems_models)
+            
+            self.logger.info(f"Stage 1: Submitting audio separation job with models: {stage1_models}")
+            
+            # Submit the first stage job
+            stage1_result = api_client.separate_audio_and_wait(
+                audio_file,
+                models=stage1_models,
+                timeout=1800,  # 30 minutes timeout
+                poll_interval=15,  # Check every 15 seconds
+                download=True,
+                output_dir=stems_dir,
+                output_format=self.lossless_output_format.lower()
+            )
+            
+            if stage1_result["status"] != "completed":
+                raise Exception(f"Stage 1 remote audio separation failed: {stage1_result.get('error', 'Unknown error')}")
+            
+            self.logger.info(f"Stage 1 completed. Downloaded {len(stage1_result['downloaded_files'])} files")
+            
+            # Check if we actually got the expected files for Stage 1
+            if len(stage1_result["downloaded_files"]) == 0:
+                error_msg = ("Stage 1 audio separation completed successfully but no files were downloaded. "
+                           "This indicates a filename encoding or API issue in the audio-separator remote service. "
+                           f"Expected files for models {stage1_models} but got 0.")
+                self.logger.error(error_msg)
+                raise Exception(error_msg)
+            
+            # Organize the stage 1 results
+            result = self._organize_stage1_remote_results(
+                stage1_result["downloaded_files"], artist_title, track_output_dir, stems_dir
+            )
+            
+            # Validate that we got the essential clean instrumental outputs
+            if not result["clean_instrumental"].get("vocals") or not result["clean_instrumental"].get("instrumental"):
+                missing = []
+                if not result["clean_instrumental"].get("vocals"):
+                    missing.append("clean vocals")
+                if not result["clean_instrumental"].get("instrumental"):
+                    missing.append("clean instrumental")
+                error_msg = (f"Stage 1 completed but failed to produce essential clean instrumental outputs: {', '.join(missing)}. "
+                           "This may indicate a model naming or file organization issue in the remote API.")
+                self.logger.error(error_msg)
+                raise Exception(error_msg)
+            
+            # Stage 2: Process clean vocals with backing vocals models (if we have both)
+            if result["clean_instrumental"].get("vocals") and self.backing_vocals_models:
+                self.logger.info(f"Stage 2: Processing clean vocals for backing vocals separation...")
+                vocals_path = result["clean_instrumental"]["vocals"]
+                
+                stage2_result = api_client.separate_audio_and_wait(
+                    vocals_path,
+                    models=self.backing_vocals_models,
+                    timeout=900,  # 15 minutes timeout for backing vocals
+                    poll_interval=10,
+                    download=True,
+                    output_dir=stems_dir,
+                    output_format=self.lossless_output_format.lower()
+                )
+                
+                if stage2_result["status"] == "completed":
+                    self.logger.info(f"Stage 2 completed. Downloaded {len(stage2_result['downloaded_files'])} files")
+                    
+                    # Check if we actually got the expected files
+                    if len(stage2_result["downloaded_files"]) == 0:
+                        error_msg = ("Stage 2 backing vocals separation completed successfully but no files were downloaded. "
+                                   "This indicates a filename encoding or API issue in the audio-separator remote service. "
+                                   "Expected 2 files (lead vocals + backing vocals) but got 0.")
+                        self.logger.error(error_msg)
+                        raise Exception(error_msg)
+                    
+                    # Organize the stage 2 results (backing vocals)
+                    backing_vocals_result = self._organize_stage2_remote_results(
+                        stage2_result["downloaded_files"], artist_title, stems_dir
+                    )
+                    result["backing_vocals"] = backing_vocals_result
+                else:
+                    error_msg = f"Stage 2 backing vocals separation failed: {stage2_result.get('error', 'Unknown error')}"
+                    self.logger.error(error_msg)
+                    raise Exception(error_msg)
+            else:
+                result["backing_vocals"] = {}
+            
+            # Generate combined instrumentals
+            if result["clean_instrumental"].get("instrumental") and result["backing_vocals"]:
+                result["combined_instrumentals"] = self._generate_combined_instrumentals(
+                    result["clean_instrumental"]["instrumental"], result["backing_vocals"], artist_title, track_output_dir
+                )
+            else:
+                result["combined_instrumentals"] = {}
+            
+            # Normalize audio files
+            self._normalize_audio_files(result, artist_title, track_output_dir)
+
+            # Create Audacity LOF file
+            if result["backing_vocals"]:
+                lof_path = os.path.join(stems_dir, f"{artist_title} (Audacity).lof")
+                first_model = list(result["backing_vocals"].keys())[0]
+
+                files_to_include = [
+                    audio_file,  # Original audio
+                    result["clean_instrumental"]["instrumental"],  # Clean instrumental
+                    result["backing_vocals"][first_model]["backing_vocals"],  # Backing vocals
+                    result["combined_instrumentals"][first_model],  # Combined instrumental+BV
+                ]
+
+                # Convert to absolute paths
+                files_to_include = [os.path.abspath(f) for f in files_to_include]
+
+                with open(lof_path, "w") as lof:
+                    for file_path in files_to_include:
+                        lof.write(f'file "{file_path}"\n')
+
+                self.logger.info(f"Created Audacity LOF file: {lof_path}")
+                result["audacity_lof"] = lof_path
+
+                # Launch Audacity with multiple tracks
+                if sys.platform == "darwin":  # Check if we're on macOS
+                    if lof_path and os.path.exists(lof_path):
+                        self.logger.info(f"Launching Audacity with LOF file: {lof_path}")
+                        os.system(f'open -a Audacity "{lof_path}"')
+                    else:
+                        self.logger.debug("Audacity LOF file not available or not found")
+
+            self.logger.info("Remote audio separation, combination, and normalization process completed")
+            return result
+            
+        except Exception as e:
+            self.logger.error(f"Error during remote audio separation: {str(e)}")
+            raise e
+
+    def _organize_stage1_remote_results(self, downloaded_files, artist_title, track_output_dir, stems_dir):
+        """Organize stage 1 separation results (clean instrumental + other stems)."""
+        result = {"clean_instrumental": {}, "other_stems": {}}
+        
+        for file_path in downloaded_files:
+            filename = os.path.basename(file_path)
+            self.logger.debug(f"Stage 1 - Processing downloaded file: {filename}")
+            
+            # Determine which model and stem type this file represents
+            model_name = None
+            stem_type = None
+            
+            # Extract model name and stem type from filename
+            # Expected format: "audio_(StemType)_modelname.ext"
+            if "_(Vocals)_" in filename:
+                stem_type = "Vocals"
+                model_name = filename.split("_(Vocals)_")[1].split(".")[0]
+            elif "_(Instrumental)_" in filename:
+                stem_type = "Instrumental"
+                model_name = filename.split("_(Instrumental)_")[1].split(".")[0]
+            elif "_(Drums)_" in filename:
+                stem_type = "Drums"
+                model_name = filename.split("_(Drums)_")[1].split(".")[0]
+            elif "_(Bass)_" in filename:
+                stem_type = "Bass"
+                model_name = filename.split("_(Bass)_")[1].split(".")[0]
+            elif "_(Other)_" in filename:
+                stem_type = "Other"
+                model_name = filename.split("_(Other)_")[1].split(".")[0]
+            elif "_(Guitar)_" in filename:
+                stem_type = "Guitar"
+                model_name = filename.split("_(Guitar)_")[1].split(".")[0]
+            elif "_(Piano)_" in filename:
+                stem_type = "Piano"
+                model_name = filename.split("_(Piano)_")[1].split(".")[0]
+            else:
+                # Try to extract stem type from parentheses
+                import re
+                match = re.search(r'_\(([^)]+)\)_([^.]+)', filename)
+                if match:
+                    stem_type = match.group(1)
+                    model_name = match.group(2)
+                else:
+                    self.logger.warning(f"Could not parse stem type and model from filename: {filename}")
+                    continue
+            
+            # Check if this model name matches the clean instrumental model
+            is_clean_instrumental_model = (
+                model_name == self.clean_instrumental_model or 
+                self.clean_instrumental_model.startswith(model_name) or
+                model_name.startswith(self.clean_instrumental_model.split('.')[0])
+            )
+            
+            if is_clean_instrumental_model:
+                if stem_type == "Vocals":
+                    target_path = os.path.join(stems_dir, f"{artist_title} (Vocals {self.clean_instrumental_model}).{self.lossless_output_format}")
+                    shutil.move(file_path, target_path)
+                    result["clean_instrumental"]["vocals"] = target_path
+                elif stem_type == "Instrumental":
+                    target_path = os.path.join(track_output_dir, f"{artist_title} (Instrumental {self.clean_instrumental_model}).{self.lossless_output_format}")
+                    shutil.move(file_path, target_path)
+                    result["clean_instrumental"]["instrumental"] = target_path
+            
+            elif any(model_name == os_model or os_model.startswith(model_name) or model_name.startswith(os_model.split('.')[0]) for os_model in self.other_stems_models):
+                # Find the matching other stems model
+                matching_os_model = None
+                for os_model in self.other_stems_models:
+                    if model_name == os_model or os_model.startswith(model_name) or model_name.startswith(os_model.split('.')[0]):
+                        matching_os_model = os_model
+                        break
+                
+                if matching_os_model:
+                    if matching_os_model not in result["other_stems"]:
+                        result["other_stems"][matching_os_model] = {}
+                    
+                    target_path = os.path.join(stems_dir, f"{artist_title} ({stem_type} {matching_os_model}).{self.lossless_output_format}")
+                    shutil.move(file_path, target_path)
+                    result["other_stems"][matching_os_model][stem_type] = target_path
+        
+        return result
+
+    def _organize_stage2_remote_results(self, downloaded_files, artist_title, stems_dir):
+        """Organize stage 2 separation results (backing vocals)."""
+        result = {}
+        
+        for file_path in downloaded_files:
+            filename = os.path.basename(file_path)
+            self.logger.debug(f"Stage 2 - Processing downloaded file: {filename}")
+            
+            # Determine which model and stem type this file represents
+            model_name = None
+            stem_type = None
+            
+            # Extract model name and stem type from filename
+            if "_(Vocals)_" in filename:
+                stem_type = "Vocals"
+                model_name = filename.split("_(Vocals)_")[1].split(".")[0]
+            elif "_(Instrumental)_" in filename:
+                stem_type = "Instrumental"
+                model_name = filename.split("_(Instrumental)_")[1].split(".")[0]
+            else:
+                # Try to extract stem type from parentheses
+                import re
+                match = re.search(r'_\(([^)]+)\)_([^.]+)', filename)
+                if match:
+                    stem_type = match.group(1)
+                    model_name = match.group(2)
+                else:
+                    self.logger.warning(f"Could not parse stem type and model from filename: {filename}")
+                    continue
+            
+            # Find the matching backing vocals model
+            matching_bv_model = None
+            for bv_model in self.backing_vocals_models:
+                if model_name == bv_model or bv_model.startswith(model_name) or model_name.startswith(bv_model.split('.')[0]):
+                    matching_bv_model = bv_model
+                    break
+            
+            if matching_bv_model:
+                if matching_bv_model not in result:
+                    result[matching_bv_model] = {}
+                
+                if stem_type == "Vocals":
+                    target_path = os.path.join(stems_dir, f"{artist_title} (Lead Vocals {matching_bv_model}).{self.lossless_output_format}")
+                    shutil.move(file_path, target_path)
+                    result[matching_bv_model]["lead_vocals"] = target_path
+                elif stem_type == "Instrumental":
+                    target_path = os.path.join(stems_dir, f"{artist_title} (Backing Vocals {matching_bv_model}).{self.lossless_output_format}")
+                    shutil.move(file_path, target_path)
+                    result[matching_bv_model]["backing_vocals"] = target_path
+        
+        return result
+
     def _create_stems_directory(self, track_output_dir):
         stems_dir = os.path.join(track_output_dir, "stems")
         os.makedirs(stems_dir, exist_ok=True)

karaoke_gen/karaoke_gen.py

@@ -566,16 +566,16 @@ class KaraokePrep:
                     "instrumental": instrumental_path,
                     "vocals": None,
                 }
+            elif "separated_audio" not in processed_track or not processed_track["separated_audio"]:
+                # Only run separation if it wasn't already done in parallel processing
+                self.logger.info(f"Separation was not completed in parallel processing, running separation for track: {self.title} by {self.artist}")
+                # Delegate to AudioProcessor (called directly, not in thread here)
+                separation_results = self.audio_processor.process_audio_separation(
+                    audio_file=processed_track["input_audio_wav"], artist_title=artist_title, track_output_dir=track_output_dir
+                )
+                processed_track["separated_audio"] = separation_results
             else:
-                # Only run separation if not skipped
-                if not self.skip_separation:
-                    self.logger.info(f"Separating audio for track: {self.title} by {self.artist}")
-                    # Delegate to AudioProcessor (called directly, not in thread here)
-                    separation_results = self.audio_processor.process_audio_separation(
-                        audio_file=processed_track["input_audio_wav"], artist_title=artist_title, track_output_dir=track_output_dir
-                    )
-                    processed_track["separated_audio"] = separation_results
-                # We don't need an else here, if skip_separation is true, separated_audio remains the default empty dict
+                self.logger.info("Audio separation was already completed in parallel processing, skipping duplicate separation.")
 
             self.logger.info("Script finished, audio downloaded, lyrics fetched and audio separated!")
 

{karaoke_gen-0.60.0.dist-info → karaoke_gen-0.61.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: karaoke-gen
-Version: 0.60.0
+Version: 0.61.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
@@ -72,6 +72,47 @@ Karaoke Generator is a comprehensive tool for creating high-quality karaoke vide
 pip install karaoke-gen
 ```
 
+## Remote Audio Separation 🌐
+
+Karaoke Generator now supports remote audio separation using the Audio Separator API. This allows you to offload the compute-intensive audio separation to a remote GPU server while keeping the rest of the workflow local.
+
+### Benefits of Remote Processing
+- **Save Local Resources**: No more laptop CPU/GPU consumption during separation
+- **Faster Processing**: GPU-accelerated separation on dedicated hardware
+- **Cost Effective**: ~$0.019 per separation job on Modal.com (with $30/month free credits)
+- **Multiple Models**: Process with multiple separation models efficiently
+
+### Setup Remote Processing
+
+1. **Deploy Audio Separator API** (using Modal.com):
+   ```bash
+   pip install modal
+   modal setup
+   modal deploy audio_separator/remote/deploy_modal.py
+   ```
+
+2. **Set Environment Variable**:
+   ```bash
+   export AUDIO_SEPARATOR_API_URL="https://USERNAME--audio-separator-api.modal.run"
+   ```
+
+3. **Run Karaoke Generator Normally**:
+   ```bash
+   karaoke-gen "Rick Astley" "Never Gonna Give You Up"
+   ```
+
+The tool will automatically detect the `AUDIO_SEPARATOR_API_URL` environment variable and use remote processing instead of local separation. If the remote API is unavailable, it will gracefully fall back to local processing.
+
+### Remote vs Local Processing
+
+| Aspect | Remote Processing | Local Processing |
+|--------|------------------|------------------|
+| **Resource Usage** | Minimal local CPU/GPU | High local CPU/GPU |
+| **Processing Time** | ~2-5 minutes | ~15-45 minutes |
+| **Cost** | ~$0.019 per job | Free (but uses local resources) |
+| **Requirements** | Internet connection | Local GPU recommended |
+| **Setup** | One-time API deployment | Audio separator models download |
+
 ## Quick Start
 
 ```bash

{karaoke_gen-0.60.0.dist-info → karaoke_gen-0.61.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 karaoke_gen/__init__.py,sha256=ViryQjs8ALc8A7mqJGHu028zajF5-Za_etFagXlo6kk,269
-karaoke_gen/audio_processor.py,sha256=gqQo8dsG_4SEO5kwyT76DiU4jCNyiGpi6TT1R3imdGY,19591
+karaoke_gen/audio_processor.py,sha256=XMQcEUgLCcMbh4R3onZF4nPezWRFx4JYRk-k3RTUNPk,36901
 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=KNuekKG5p4QF5D_RuTmwgcFU_S4KLu2jhSw12Endr7g,84901
-karaoke_gen/karaoke_gen.py,sha256=NEyb-AWLdqJL4nXg21o_YbutZVVbKt08TTPAYgSBDao,38052
+karaoke_gen/karaoke_gen.py,sha256=o2EaFgnDlP3GaKMjLzABNfq--Ey6z_pS6fg5FBB76Ts,38182
 karaoke_gen/lyrics_processor.py,sha256=eUyu0d1OZyWwmpyNCBTKrV1grNzbZ91pFIXnz7le04k,14203
 karaoke_gen/metadata.py,sha256=TprFzWj-iJ7ghrXlHFMPzzqzuHzWeNvs3zGaND-z9Ds,6503
 karaoke_gen/resources/AvenirNext-Bold.ttf,sha256=YxgKz2OP46lwLPCpIZhVa8COi_9KRDSXw4n8dIHHQSs,327048
@@ -16,8 +16,8 @@ karaoke_gen/utils/__init__.py,sha256=FpOHyeBRB06f3zMoLBUJHTDZACrabg-DoyBTxNKYyNY
 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.60.0.dist-info/LICENSE,sha256=81R_4XwMZDODHD7JcZeUR8IiCU8AD7Ajl6bmwR9tYDk,1074
-karaoke_gen-0.60.0.dist-info/METADATA,sha256=idKsdzQBQeJFk3K8W-muCFozKrJyBjqt-F_yqziqs3M,5604
-karaoke_gen-0.60.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-karaoke_gen-0.60.0.dist-info/entry_points.txt,sha256=IZY3O8i7m-qkmPuqgpAcxiS2fotNc6hC-CDWvNmoUEY,107
-karaoke_gen-0.60.0.dist-info/RECORD,,
+karaoke_gen-0.61.0.dist-info/LICENSE,sha256=81R_4XwMZDODHD7JcZeUR8IiCU8AD7Ajl6bmwR9tYDk,1074
+karaoke_gen-0.61.0.dist-info/METADATA,sha256=zLoiEUouh10OEnyl1KRIDGkYJq9RuqADijSWmOmIm1k,7345
+karaoke_gen-0.61.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+karaoke_gen-0.61.0.dist-info/entry_points.txt,sha256=IZY3O8i7m-qkmPuqgpAcxiS2fotNc6hC-CDWvNmoUEY,107
+karaoke_gen-0.61.0.dist-info/RECORD,,