karaoke-gen 0.61.0__tar.gz → 0.62.0__tar.gz

{karaoke_gen-0.61.0 → karaoke_gen-0.62.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: karaoke-gen
-Version: 0.61.0
+Version: 0.62.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

{karaoke_gen-0.61.0 → karaoke_gen-0.62.0}/karaoke_gen/config.py

@@ -46,15 +46,43 @@ DEFAULT_STYLE_PARAMS = {
 }
 
 
-def load_style_params(style_params_json, logger):
+def apply_style_overrides(style_params, overrides, logger):
+    """Recursively applies overrides to the style parameters."""
+    for key, value in overrides.items():
+        keys = key.split('.')
+        current_level = style_params
+        for i, k in enumerate(keys):
+            if i == len(keys) - 1:
+                if k in current_level:
+                    # Attempt to cast the value to the type of the existing value
+                    try:
+                        original_type = type(current_level[k])
+                        if original_type == bool:
+                            # Handle boolean conversion
+                            value = value.lower() in ('true', '1', 't', 'y', 'yes')
+                        else:
+                            value = original_type(value)
+                    except (ValueError, TypeError) as e:
+                        logger.warning(f"Could not cast override value '{value}' for key '{key}' to original type. Using as string. Error: {e}")
+                    current_level[k] = value
+                    logger.info(f"Overrode style: {key} = {value}")
+                else:
+                    logger.warning(f"Override key '{key}' not found in style parameters.")
+            elif k in current_level and isinstance(current_level[k], dict):
+                current_level = current_level[k]
+            else:
+                logger.warning(f"Override key part '{k}' not found or not a dictionary for key '{key}'.")
+                break
+
+
+def load_style_params(style_params_json, style_overrides, logger):
     """Loads style parameters from a JSON file or uses defaults."""
+    style_params = {}
     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)
@@ -66,7 +94,12 @@ def load_style_params(style_params_json, logger):
             sys.exit(1)
     else:
         logger.info("No style parameters JSON file provided. Using default styles.")
-        return DEFAULT_STYLE_PARAMS
+        style_params = DEFAULT_STYLE_PARAMS
+
+    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."""

{karaoke_gen-0.61.0 → karaoke_gen-0.62.0}/karaoke_gen/karaoke_finalise/karaoke_finalise.py

@@ -412,26 +412,33 @@ class KaraokeFinalise:
         if "items" in response and len(response["items"]) > 0:
             for item in response["items"]:
                 found_title = item["snippet"]["title"]
-                similarity_score = fuzz.ratio(youtube_title.lower(), found_title.lower())
-                if similarity_score >= 70:  # 70% similarity
+
+                # In server-side mode, require an exact match to avoid false positives.
+                # Otherwise, use fuzzy matching for interactive CLI usage.
+                if self.server_side_mode:
+                    is_match = youtube_title.lower() == found_title.lower()
+                    similarity_score = 100 if is_match else 0
+                else:
+                    similarity_score = fuzz.ratio(youtube_title.lower(), found_title.lower())
+                    is_match = similarity_score >= 70
+
+                if is_match:
                     found_id = item["id"]["videoId"]
                     self.logger.info(
                         f"Potential match found on YouTube channel with ID: {found_id} and title: {found_title} (similarity: {similarity_score}%)"
                     )
-                    
-                    # In non-interactive mode, automatically confirm if similarity is high enough
+
+                    # In non-interactive mode (server mode), we don't prompt. Just record the match and return.
                     if self.non_interactive:
-                        self.logger.info(f"Non-interactive mode, automatically confirming match with similarity score {similarity_score}%")
+                        self.logger.info(f"Non-interactive mode, found a match.")
                         self.youtube_video_id = found_id
                         self.youtube_url = f"{self.youtube_url_prefix}{self.youtube_video_id}"
-                        self.skip_notifications = True
                         return True
-                    
+
                     confirmation = input(f"Is '{found_title}' the video you are finalising? (y/n): ").strip().lower()
                     if confirmation == "y":
                         self.youtube_video_id = found_id
                         self.youtube_url = f"{self.youtube_url_prefix}{self.youtube_video_id}"
-                        self.skip_notifications = True
                         return True
 
         self.logger.info(f"No matching video found with title: {youtube_title}")
@@ -483,8 +490,12 @@ class KaraokeFinalise:
             max_length = 95
             youtube_title = self.truncate_to_nearest_word(youtube_title, max_length)
 
+            # In server-side mode, we should always replace videos if an exact match is found.
+            # Otherwise, respect the replace_existing flag from CLI.
+            should_replace = True if self.server_side_mode else replace_existing
+
             if self.check_if_video_title_exists_on_youtube_channel(youtube_title):
-                if replace_existing:
+                if should_replace:
                     self.logger.info(f"Video already exists on YouTube, deleting before re-upload: {self.youtube_url}")
                     if self.delete_youtube_video(self.youtube_video_id):
                         self.logger.info(f"Successfully deleted existing video, proceeding with upload")

{karaoke_gen-0.61.0 → karaoke_gen-0.62.0}/karaoke_gen/karaoke_gen.py

@@ -67,6 +67,7 @@ class KaraokePrep:
         subtitle_offset_ms=0,
         # Style Configuration
         style_params_json=None,
+        style_overrides=None,
         # Add the new parameter
         skip_separation=False,
         # YouTube/Online Configuration
@@ -124,13 +125,23 @@ class KaraokePrep:
 
         # Style Config - Keep needed ones
         self.render_bounding_boxes = render_bounding_boxes # Passed to VideoGenerator
-        self.style_params_json = style_params_json # Passed to LyricsProcessor
+        self.style_params_json = style_params_json
+        self.style_overrides = style_overrides
+        self.temp_style_file = None
 
         # 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)
+        self.style_params = load_style_params(self.style_params_json, self.style_overrides, self.logger)
+
+        # If overrides were applied, write to a temp file and update the path
+        if self.style_overrides:
+            with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".json") as temp_file:
+                json.dump(self.style_params, temp_file, indent=2)
+                self.temp_style_file = temp_file.name
+                self.style_params_json = self.temp_style_file
+                self.logger.info(f"Style overrides applied. Using temporary style file: {self.temp_style_file}")
 
         # Set up title and end formats using the config module
         self.title_format = setup_title_format(self.style_params)
@@ -199,6 +210,15 @@ class KaraokePrep:
         else:
             self.logger.debug(f"Overall output dir {self.output_dir} already exists")
 
+    def __del__(self):
+        # Cleanup the temporary style file if it was created
+        if self.temp_style_file and os.path.exists(self.temp_style_file):
+            try:
+                os.remove(self.temp_style_file)
+                self.logger.debug(f"Removed temporary style file: {self.temp_style_file}")
+            except OSError as e:
+                self.logger.warning(f"Error removing temporary style file {self.temp_style_file}: {e}")
+
     # 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"""

{karaoke_gen-0.61.0 → karaoke_gen-0.62.0}/karaoke_gen/utils/gen_cli.py

@@ -215,6 +215,11 @@ async def async_main():
         "--style_params_json",
         help="Optional: Path to JSON file containing style configuration. Example: --style_params_json='/path/to/style_params.json'",
     )
+    style_group.add_argument(
+        "--style_override",
+        action="append",
+        help="Optional: Override a style parameter. Can be used multiple times. Example: --style_override 'intro.background_image=/path/to/new_image.png'",
+    )
 
     # Finalisation Configuration
     finalise_group = parser.add_argument_group("Finalisation Configuration")
@@ -283,6 +288,17 @@ async def async_main():
 
     args = parser.parse_args()
 
+    # Process style overrides
+    style_overrides = {}
+    if args.style_override:
+        for override in args.style_override:
+            try:
+                key, value = override.split("=", 1)
+                style_overrides[key] = value
+            except ValueError:
+                logger.error(f"Invalid style override format: {override}. Must be in 'key=value' format.")
+                sys.exit(1)
+
     # Handle test email template case first
     if args.test_email_template:
         log_level = getattr(logging, args.log_level.upper())
@@ -354,6 +370,7 @@ async def async_main():
             skip_transcription_review=args.skip_transcription_review,
             subtitle_offset_ms=args.subtitle_offset_ms,
             style_params_json=args.style_params_json,
+            style_overrides=style_overrides,
         )
         # No await needed for constructor
         kprep = kprep_coroutine
@@ -671,6 +688,7 @@ async def async_main():
         skip_transcription_review=args.skip_transcription_review,
         subtitle_offset_ms=args.subtitle_offset_ms,
         style_params_json=args.style_params_json,
+        style_overrides=style_overrides,
     )
     # No await needed for constructor
     kprep = kprep_coroutine

{karaoke_gen-0.61.0 → karaoke_gen-0.62.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "karaoke-gen"
-version = "0.61.0"
+version = "0.62.0"
 description = "Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens."
 authors = ["Andrew Beveridge <andrew@beveridge.uk>"]
 license = "MIT"