karaoke-gen 0.57.0__py3-none-any.whl → 0.71.23__py3-none-any.whl

karaoke_gen/config.py

@@ -1,130 +1,79 @@
+"""
+Configuration utilities for karaoke generation.
+
+This module provides configuration loading and setup functions.
+Style loading is delegated to the unified style_loader module.
+"""
 import os
 import sys
-import json
 import logging
 
-# Default style parameters if no JSON file is provided or if it's invalid
-DEFAULT_STYLE_PARAMS = {
-    "intro": {
-        "video_duration": 5,
-        "existing_image": None,
-        "background_color": "#000000",
-        "background_image": None,
-        "font": "Montserrat-Bold.ttf",
-        "artist_color": "#ffdf6b",
-        "artist_gradient": None,
-        "title_color": "#ffffff",
-        "title_gradient": None,
-        "title_region": "370, 200, 3100, 480",
-        "artist_region": "370, 700, 3100, 480",
-        "extra_text": None,
-        "extra_text_color": "#ffffff",
-        "extra_text_gradient": None,
-        "extra_text_region": "370, 1200, 3100, 480",
-        "title_text_transform": None,  # none, uppercase, lowercase, propercase
-        "artist_text_transform": None,  # none, uppercase, lowercase, propercase
-    },
-    "end": {
-        "video_duration": 5,
-        "existing_image": None,
-        "background_color": "#000000",
-        "background_image": None,
-        "font": "Montserrat-Bold.ttf",
-        "artist_color": "#ffdf6b",
-        "artist_gradient": None,
-        "title_color": "#ffffff",
-        "title_gradient": None,
-        "title_region": None,
-        "artist_region": None,
-        "extra_text": "THANK YOU FOR SINGING!",
-        "extra_text_color": "#ff7acc",
-        "extra_text_gradient": None,
-        "extra_text_region": None,
-        "title_text_transform": None,  # none, uppercase, lowercase, propercase
-        "artist_text_transform": None,  # none, uppercase, lowercase, propercase
-    },
-}
+# Import from the unified style loader module
+from .style_loader import (
+    # Re-export defaults for backwards compatibility
+    DEFAULT_STYLE_PARAMS,
+    DEFAULT_INTRO_STYLE as _DEFAULT_INTRO,
+    DEFAULT_END_STYLE as _DEFAULT_END,
+    # Functions
+    load_style_params_from_file,
+    apply_style_overrides,
+    get_intro_format as _get_intro_format,
+    get_end_format as _get_end_format,
+    get_video_durations,
+    get_existing_images,
+)
 
 
-def load_style_params(style_params_json, logger):
-    """Loads style parameters from a JSON file or uses defaults."""
-    if style_params_json:
-        try:
-            with open(style_params_json, "r") as f:
-                style_params = json.loads(f.read())
-                logger.info(f"Loaded style parameters from {style_params_json}")
-                # You might want to add validation here to ensure the structure matches expectations
-                return style_params
-        except FileNotFoundError:
-            logger.error(f"Style parameters configuration file not found: {style_params_json}")
-            sys.exit(1)
-        except json.JSONDecodeError as e:
-            logger.error(f"Invalid JSON in style parameters configuration file: {e}")
-            sys.exit(1)
-        except Exception as e:
-            logger.error(f"Error loading style parameters file {style_params_json}: {e}")
-            sys.exit(1)
-    else:
-        logger.info("No style parameters JSON file provided. Using default styles.")
-        return DEFAULT_STYLE_PARAMS
+def load_style_params(style_params_json, style_overrides, logger):
+    """
+    Loads style parameters from a JSON file or uses defaults.
+    
+    This is the main entry point for the local CLI to load styles.
+    
+    Args:
+        style_params_json: Path to style JSON file, or None for defaults.
+        style_overrides: Dict of "section.key" -> value overrides.
+        logger: Logger for messages.
+    
+    Returns:
+        Dictionary of style parameters.
+    """
+    style_params = load_style_params_from_file(
+        style_params_json,
+        logger=logger,
+        exit_on_error=True,
+    )
+    
+    if style_overrides:
+        apply_style_overrides(style_params, style_overrides, logger)
+    
+    return style_params
+
 
 def setup_title_format(style_params):
-    """Sets up the title format dictionary from style parameters."""
-    intro_params = style_params.get("intro", DEFAULT_STYLE_PARAMS["intro"])
-    return {
-        "background_color": intro_params.get("background_color", DEFAULT_STYLE_PARAMS["intro"]["background_color"]),
-        "background_image": intro_params.get("background_image"),
-        "font": intro_params.get("font", DEFAULT_STYLE_PARAMS["intro"]["font"]),
-        "artist_color": intro_params.get("artist_color", DEFAULT_STYLE_PARAMS["intro"]["artist_color"]),
-        "artist_gradient": intro_params.get("artist_gradient"),
-        "title_color": intro_params.get("title_color", DEFAULT_STYLE_PARAMS["intro"]["title_color"]),
-        "title_gradient": intro_params.get("title_gradient"),
-        "extra_text": intro_params.get("extra_text"),
-        "extra_text_color": intro_params.get("extra_text_color", DEFAULT_STYLE_PARAMS["intro"]["extra_text_color"]),
-        "extra_text_gradient": intro_params.get("extra_text_gradient"),
-        "extra_text_region": intro_params.get("extra_text_region", DEFAULT_STYLE_PARAMS["intro"]["extra_text_region"]),
-        "title_region": intro_params.get("title_region", DEFAULT_STYLE_PARAMS["intro"]["title_region"]),
-        "artist_region": intro_params.get("artist_region", DEFAULT_STYLE_PARAMS["intro"]["artist_region"]),
-        "title_text_transform": intro_params.get("title_text_transform"),
-        "artist_text_transform": intro_params.get("artist_text_transform"),
-    }
+    """
+    Sets up the title format dictionary from style parameters.
+    
+    This is a thin wrapper around style_loader.get_intro_format()
+    for backwards compatibility.
+    """
+    return _get_intro_format(style_params)
 
-def setup_end_format(style_params):
-    """Sets up the end format dictionary from style parameters."""
-    end_params = style_params.get("end", DEFAULT_STYLE_PARAMS["end"])
-    return {
-        "background_color": end_params.get("background_color", DEFAULT_STYLE_PARAMS["end"]["background_color"]),
-        "background_image": end_params.get("background_image"),
-        "font": end_params.get("font", DEFAULT_STYLE_PARAMS["end"]["font"]),
-        "artist_color": end_params.get("artist_color", DEFAULT_STYLE_PARAMS["end"]["artist_color"]),
-        "artist_gradient": end_params.get("artist_gradient"),
-        "title_color": end_params.get("title_color", DEFAULT_STYLE_PARAMS["end"]["title_color"]),
-        "title_gradient": end_params.get("title_gradient"),
-        "extra_text": end_params.get("extra_text", DEFAULT_STYLE_PARAMS["end"]["extra_text"]),
-        "extra_text_color": end_params.get("extra_text_color", DEFAULT_STYLE_PARAMS["end"]["extra_text_color"]),
-        "extra_text_gradient": end_params.get("extra_text_gradient"),
-        "extra_text_region": end_params.get("extra_text_region"),
-        "title_region": end_params.get("title_region"),
-        "artist_region": end_params.get("artist_region"),
-        "title_text_transform": end_params.get("title_text_transform"),
-        "artist_text_transform": end_params.get("artist_text_transform"),
-    }
 
-def get_video_durations(style_params):
-    """Gets intro and end video durations from style parameters."""
-    intro_duration = style_params.get("intro", {}).get("video_duration", DEFAULT_STYLE_PARAMS["intro"]["video_duration"])
-    end_duration = style_params.get("end", {}).get("video_duration", DEFAULT_STYLE_PARAMS["end"]["video_duration"])
-    return intro_duration, end_duration
+def setup_end_format(style_params):
+    """
+    Sets up the end format dictionary from style parameters.
+    
+    This is a thin wrapper around style_loader.get_end_format()
+    for backwards compatibility.
+    """
+    return _get_end_format(style_params)
 
-def get_existing_images(style_params):
-    """Gets existing title and end images from style parameters."""
-    existing_title_image = style_params.get("intro", {}).get("existing_image")
-    existing_end_image = style_params.get("end", {}).get("existing_image")
-    return existing_title_image, existing_end_image
 
 def setup_ffmpeg_command(log_level):
     """Sets up the base ffmpeg command string based on log level."""
-    # Path to the Windows PyInstaller frozen bundled ffmpeg.exe, or the system-installed FFmpeg binary on Mac/Linux
+    # Path to the Windows PyInstaller frozen bundled ffmpeg.exe, 
+    # or the system-installed FFmpeg binary on Mac/Linux
     ffmpeg_path = os.path.join(sys._MEIPASS, "ffmpeg.exe") if getattr(sys, "frozen", False) else "ffmpeg"
     ffmpeg_base_command = f"{ffmpeg_path} -hide_banner -nostats"
     if log_level == logging.DEBUG:

karaoke_gen/file_handler.py

@@ -3,7 +3,6 @@ import glob
 import logging
 import shutil
 import tempfile
-import yt_dlp.YoutubeDL as ydl
 from .utils import sanitize_filename
 
 
@@ -39,64 +38,38 @@ class FileHandler:
 
         return copied_file_name
 
-    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",
-            # 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",
-            },
-        }
-
-        # 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 download_audio_from_fetcher_result(self, filepath, output_filename_no_extension):
+        """
+        Handle audio that was downloaded via the AudioFetcher.
+        
+        This method copies/moves the downloaded file to the expected location
+        and returns the path with the correct naming convention.
+        
+        Args:
+            filepath: Path to the downloaded audio file from AudioFetcher
+            output_filename_no_extension: Desired output filename without extension
+            
+        Returns:
+            Path to the renamed/copied audio file
+        """
+        if not os.path.isfile(filepath):
+            self.logger.error(f"Downloaded file not found: {filepath}")
+            return None
+            
+        # Get the extension from the downloaded file
+        ext = os.path.splitext(filepath)[1]
+        target_path = f"{output_filename_no_extension}{ext}"
+        
+        # If source and target are the same, no action needed
+        if os.path.abspath(filepath) == os.path.abspath(target_path):
+            self.logger.debug(f"Downloaded file already at target location: {target_path}")
+            return target_path
+            
+        # Copy the file to the target location
+        self.logger.debug(f"Copying downloaded file from {filepath} to {target_path}")
+        shutil.copy2(filepath, target_path)
+        
+        return target_path
 
     def extract_still_image_from_video(self, input_filename, output_filename_no_extension):
         output_filename = output_filename_no_extension + ".png"