karaoke-gen 0.65.0__tar.gz → 0.66.0__tar.gz

{karaoke_gen-0.65.0 → karaoke_gen-0.66.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karaoke-gen
-Version: 0.65.0
+Version: 0.66.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
 License-File: LICENSE
@@ -161,6 +161,23 @@ karaoke-gen --lyrics_file="path/to/lyrics.txt" "Rick Astley" "Never Gonna Give Y
 karaoke-gen --subtitle_offset_ms=500 "Rick Astley" "Never Gonna Give You Up"
 ```
 
+### Video Background
+
+```bash
+# Use a video as background instead of static image
+karaoke-gen --background_video="path/to/video.mp4" "Rick Astley" "Never Gonna Give You Up"
+
+# Use a video background with darkening overlay (0-100%)
+karaoke-gen --background_video="path/to/video.mp4" --background_video_darkness=50 "Rick Astley" "Never Gonna Give You Up"
+```
+
+The video background feature automatically:
+- Scales the video to 4K resolution (3840x2160) with intelligent cropping
+- Loops the video if it's shorter than the audio
+- Trims the video if it's longer than the audio
+- Applies an optional darkening overlay to improve subtitle readability
+- Renders synchronized ASS subtitles on top of the video
+
 ### Finalisation Options
 
 ```bash

{karaoke_gen-0.65.0 → karaoke_gen-0.66.0}/README.md

@@ -112,6 +112,23 @@ karaoke-gen --lyrics_file="path/to/lyrics.txt" "Rick Astley" "Never Gonna Give Y
 karaoke-gen --subtitle_offset_ms=500 "Rick Astley" "Never Gonna Give You Up"
 ```
 
+### Video Background
+
+```bash
+# Use a video as background instead of static image
+karaoke-gen --background_video="path/to/video.mp4" "Rick Astley" "Never Gonna Give You Up"
+
+# Use a video background with darkening overlay (0-100%)
+karaoke-gen --background_video="path/to/video.mp4" --background_video_darkness=50 "Rick Astley" "Never Gonna Give You Up"
+```
+
+The video background feature automatically:
+- Scales the video to 4K resolution (3840x2160) with intelligent cropping
+- Loops the video if it's shorter than the audio
+- Trims the video if it's longer than the audio
+- Applies an optional darkening overlay to improve subtitle readability
+- Renders synchronized ASS subtitles on top of the video
+
 ### Finalisation Options
 
 ```bash

{karaoke_gen-0.65.0 → karaoke_gen-0.66.0}/karaoke_gen/karaoke_gen.py

@@ -28,6 +28,7 @@ from .file_handler import FileHandler
 from .audio_processor import AudioProcessor
 from .lyrics_processor import LyricsProcessor
 from .video_generator import VideoGenerator
+from .video_background_processor import VideoBackgroundProcessor
 
 
 class KaraokePrep:
@@ -70,6 +71,9 @@ class KaraokePrep:
         style_overrides=None,
         # Add the new parameter
         skip_separation=False,
+        # Video Background Configuration
+        background_video=None,
+        background_video_darkness=0,
         # YouTube/Online Configuration
         cookies_str=None,
     ):
@@ -129,6 +133,10 @@ class KaraokePrep:
         self.style_overrides = style_overrides
         self.temp_style_file = None
 
+        # Video Background Config
+        self.background_video = background_video
+        self.background_video_darkness = background_video_darkness
+
         # YouTube/Online Config
         self.cookies_str = cookies_str # Passed to metadata extraction and file download
 
@@ -192,6 +200,16 @@ class KaraokePrep:
              output_jpg=self.output_jpg,
         )
 
+        # Instantiate VideoBackgroundProcessor if background_video is provided
+        if self.background_video:
+            self.logger.info(f"Video background enabled: {self.background_video}")
+            self.video_background_processor = VideoBackgroundProcessor(
+                logger=self.logger,
+                ffmpeg_base_command=self.ffmpeg_base_command,
+            )
+        else:
+            self.video_background_processor = None
+
         self.logger.debug(f"Initialized title_format with extra_text: {self.title_format['extra_text']}")
         self.logger.debug(f"Initialized title_format with extra_text_region: {self.title_format['extra_text_region']}")
 
@@ -493,6 +511,9 @@ class KaraokePrep:
                                 processed_track["countdown_padding_seconds"] = transcriber_outputs.get("countdown_padding_seconds", 0.0)
                                 processed_track["padded_vocals_audio"] = transcriber_outputs.get("padded_audio_filepath")
                                 
+                                # Store ASS filepath for video background processing
+                                processed_track["ass_filepath"] = transcriber_outputs.get("ass_filepath")
+                                
                                 if processed_track["countdown_padding_added"]:
                                     self.logger.info(
                                         f"=== COUNTDOWN PADDING DETECTED ==="
@@ -544,6 +565,78 @@ class KaraokePrep:
 
                 self.logger.info("=== Parallel Processing Complete ===")
 
+            # Apply video background if requested and lyrics were processed
+            if self.video_background_processor and processed_track.get("lyrics"):
+                self.logger.info("=== Processing Video Background ===")
+                
+                # Find the With Vocals video file
+                with_vocals_video = os.path.join(track_output_dir, f"{artist_title} (With Vocals).mkv")
+                
+                # Get ASS file from transcriber outputs if available
+                ass_file = processed_track.get("ass_filepath")
+                
+                # If not in processed_track, try to find it in common locations
+                if not ass_file or not os.path.exists(ass_file):
+                    self.logger.info("ASS filepath not found in transcriber outputs, searching for it...")
+                    from .utils import sanitize_filename
+                    sanitized_artist = sanitize_filename(self.artist)
+                    sanitized_title = sanitize_filename(self.title)
+                    lyrics_dir = os.path.join(track_output_dir, "lyrics")
+                    
+                    possible_ass_files = [
+                        os.path.join(lyrics_dir, f"{sanitized_artist} - {sanitized_title}.ass"),
+                        os.path.join(track_output_dir, f"{sanitized_artist} - {sanitized_title}.ass"),
+                        os.path.join(lyrics_dir, f"{artist_title}.ass"),
+                        os.path.join(track_output_dir, f"{artist_title}.ass"),
+                        os.path.join(track_output_dir, f"{artist_title} (Karaoke).ass"),
+                        os.path.join(lyrics_dir, f"{artist_title} (Karaoke).ass"),
+                    ]
+                    
+                    for possible_file in possible_ass_files:
+                        if os.path.exists(possible_file):
+                            ass_file = possible_file
+                            self.logger.info(f"Found ASS subtitle file: {ass_file}")
+                            break
+                
+                if os.path.exists(with_vocals_video) and ass_file and os.path.exists(ass_file):
+                    self.logger.info(f"Found With Vocals video, will replace with video background: {with_vocals_video}")
+                    self.logger.info(f"Using ASS subtitle file: {ass_file}")
+                    
+                    # Get audio duration
+                    audio_duration = self.video_background_processor.get_audio_duration(processed_track["input_audio_wav"])
+                    
+                    # Check if we need to use the padded audio instead
+                    if processed_track.get("countdown_padding_added") and processed_track.get("padded_vocals_audio"):
+                        self.logger.info(f"Using padded vocals audio for video background processing")
+                        audio_for_video = processed_track["padded_vocals_audio"]
+                    else:
+                        audio_for_video = processed_track["input_audio_wav"]
+                    
+                    # Process video background
+                    try:
+                        self.video_background_processor.process_video_background(
+                            video_path=self.background_video,
+                            audio_path=audio_for_video,
+                            ass_subtitles_path=ass_file,
+                            output_path=with_vocals_video,
+                            darkness_percent=self.background_video_darkness,
+                            audio_duration=audio_duration,
+                        )
+                        self.logger.info(f"✓ Video background applied, With Vocals video updated: {with_vocals_video}")
+                    except Exception as e:
+                        self.logger.error(f"Failed to apply video background: {e}")
+                        self.logger.exception("Full traceback:")
+                        # Continue with original video if background processing fails
+                else:
+                    if not os.path.exists(with_vocals_video):
+                        self.logger.warning(f"With Vocals video not found at {with_vocals_video}, skipping video background processing")
+                    elif not ass_file or not os.path.exists(ass_file):
+                        self.logger.warning("Could not find ASS subtitle file, skipping video background processing")
+                        if 'possible_ass_files' in locals():
+                            self.logger.warning("Searched locations:")
+                            for possible_file in possible_ass_files:
+                                self.logger.warning(f"  - {possible_file}")
+
             output_image_filepath_noext = os.path.join(track_output_dir, f"{artist_title} (Title)")
             processed_track["title_image_png"] = f"{output_image_filepath_noext}.png"
             processed_track["title_image_jpg"] = f"{output_image_filepath_noext}.jpg"

{karaoke_gen-0.65.0 → karaoke_gen-0.66.0}/karaoke_gen/utils/gen_cli.py

@@ -220,6 +220,16 @@ async def async_main():
         action="append",
         help="Optional: Override a style parameter. Can be used multiple times. Example: --style_override 'intro.background_image=/path/to/new_image.png'",
     )
+    style_group.add_argument(
+        "--background_video",
+        help="Optional: Path to video file to use as background instead of static image. Example: --background_video='/path/to/video.mp4'",
+    )
+    style_group.add_argument(
+        "--background_video_darkness",
+        type=int,
+        default=0,
+        help="Optional: Darkness overlay percentage (0-100) for video background (default: %(default)s). Example: --background_video_darkness=50",
+    )
 
     # Finalisation Configuration
     finalise_group = parser.add_argument_group("Finalisation Configuration")
@@ -371,6 +381,8 @@ async def async_main():
             subtitle_offset_ms=args.subtitle_offset_ms,
             style_params_json=args.style_params_json,
             style_overrides=style_overrides,
+            background_video=args.background_video,
+            background_video_darkness=args.background_video_darkness,
         )
         # No await needed for constructor
         kprep = kprep_coroutine
@@ -689,6 +701,8 @@ async def async_main():
         subtitle_offset_ms=args.subtitle_offset_ms,
         style_params_json=args.style_params_json,
         style_overrides=style_overrides,
+        background_video=args.background_video,
+        background_video_darkness=args.background_video_darkness,
     )
     # No await needed for constructor
     kprep = kprep_coroutine

karaoke_gen-0.66.0/karaoke_gen/video_background_processor.py

@@ -0,0 +1,353 @@
+import os
+import sys
+import logging
+import subprocess
+import shutil
+
+
+class VideoBackgroundProcessor:
+    """
+    Handles video background processing for karaoke videos.
+    Responsible for scaling, looping/trimming, darkening, and subtitle rendering.
+    """
+
+    def __init__(self, logger, ffmpeg_base_command):
+        """
+        Initialize the VideoBackgroundProcessor.
+
+        Args:
+            logger: Logger instance for output
+            ffmpeg_base_command: Base ffmpeg command with common flags
+        """
+        self.logger = logger
+        self.ffmpeg_base_command = ffmpeg_base_command
+
+        # Detect and configure hardware acceleration
+        self.nvenc_available = self.detect_nvenc_support()
+        self.configure_hardware_acceleration()
+
+    def detect_nvenc_support(self):
+        """Detect if NVENC hardware encoding is available with comprehensive checks."""
+        try:
+            self.logger.info("🔍 Detecting NVENC hardware acceleration support...")
+
+            # Step 1: Check for nvidia-smi (indicates NVIDIA driver presence)
+            try:
+                nvidia_smi_result = subprocess.run(
+                    ["nvidia-smi", "--query-gpu=name,driver_version", "--format=csv,noheader"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                if nvidia_smi_result.returncode == 0:
+                    gpu_info = nvidia_smi_result.stdout.strip()
+                    self.logger.info(f"✓ NVIDIA GPU detected: {gpu_info}")
+                else:
+                    self.logger.warning("⚠️ nvidia-smi not available or no NVIDIA GPU detected")
+                    return False
+            except (subprocess.TimeoutExpired, FileNotFoundError, subprocess.CalledProcessError):
+                self.logger.warning("⚠️ nvidia-smi not available or failed")
+                return False
+
+            # Step 2: Check for NVENC encoders in FFmpeg
+            try:
+                encoders_cmd = f"{self.ffmpeg_base_command} -hide_banner -encoders 2>/dev/null | grep nvenc"
+                encoders_result = subprocess.run(encoders_cmd, shell=True, capture_output=True, text=True, timeout=10)
+                if encoders_result.returncode == 0 and "nvenc" in encoders_result.stdout:
+                    nvenc_encoders = [line.strip() for line in encoders_result.stdout.split("\n") if "nvenc" in line]
+                    self.logger.info("✓ Found NVENC encoders in FFmpeg:")
+                    for encoder in nvenc_encoders:
+                        if encoder:
+                            self.logger.info(f"  {encoder}")
+                else:
+                    self.logger.warning("⚠️ No NVENC encoders found in FFmpeg")
+                    return False
+            except Exception as e:
+                self.logger.warning(f"⚠️ Failed to check FFmpeg NVENC encoders: {e}")
+                return False
+
+            # Step 3: Check for libcuda.so.1 (critical for NVENC)
+            try:
+                libcuda_check = subprocess.run(["ldconfig", "-p"], capture_output=True, text=True, timeout=10)
+                if libcuda_check.returncode == 0 and "libcuda.so.1" in libcuda_check.stdout:
+                    self.logger.info("✅ libcuda.so.1 found in system libraries")
+                else:
+                    self.logger.warning("❌ libcuda.so.1 NOT found in system libraries")
+                    self.logger.warning("💡 This usually indicates the CUDA runtime image is needed instead of devel")
+                    return False
+            except Exception as e:
+                self.logger.warning(f"⚠️ Failed to check for libcuda.so.1: {e}")
+                return False
+
+            # Step 4: Test h264_nvenc encoder with simple test
+            self.logger.info("🧪 Testing h264_nvenc encoder...")
+            test_cmd = f"{self.ffmpeg_base_command} -hide_banner -loglevel warning -f lavfi -i testsrc=duration=1:size=320x240:rate=1 -c:v h264_nvenc -f null -"
+            self.logger.debug(f"Running test command: {test_cmd}")
+
+            try:
+                result = subprocess.run(test_cmd, shell=True, capture_output=True, text=True, timeout=30)
+
+                if result.returncode == 0:
+                    self.logger.info("✅ NVENC hardware encoding available for video generation")
+                    self.logger.info(f"Test command succeeded. Output: {result.stderr if result.stderr else '...'}")
+                    return True
+                else:
+                    self.logger.warning(f"❌ NVENC test failed with exit code {result.returncode}")
+                    if result.stderr:
+                        self.logger.warning(f"Error output: {result.stderr}")
+                        if "Cannot load libcuda.so.1" in result.stderr:
+                            self.logger.warning("💡 Root cause: libcuda.so.1 cannot be loaded by NVENC")
+                            self.logger.warning("💡 Solution: Use nvidia/cuda:*-devel-* image instead of runtime")
+                    return False
+
+            except subprocess.TimeoutExpired:
+                self.logger.warning("❌ NVENC test timed out")
+                return False
+
+        except Exception as e:
+            self.logger.warning(f"❌ Failed to detect NVENC support: {e}, falling back to software encoding")
+            return False
+
+    def configure_hardware_acceleration(self):
+        """Configure hardware acceleration settings based on detected capabilities."""
+        if self.nvenc_available:
+            self.video_encoder = "h264_nvenc"
+            self.hwaccel_decode_flags = "-hwaccel cuda"
+            self.scale_filter = "scale"
+            self.logger.info("Configured for NVIDIA hardware acceleration")
+        else:
+            self.video_encoder = "libx264"
+            self.hwaccel_decode_flags = ""
+            self.scale_filter = "scale"
+            self.logger.info("Configured for software encoding")
+
+    def get_nvenc_quality_settings(self):
+        """Get NVENC settings for high quality encoding."""
+        return "-preset p4 -tune hq -rc vbr -cq 18 -spatial-aq 1 -temporal-aq 1 -b:v 8000k -maxrate 15000k -bufsize 16000k"
+
+    def get_audio_duration(self, audio_path):
+        """
+        Get duration of audio file in seconds using ffprobe.
+
+        Args:
+            audio_path: Path to audio file
+
+        Returns:
+            float: Duration in seconds
+        """
+        try:
+            cmd = [
+                "ffprobe",
+                "-v",
+                "error",
+                "-show_entries",
+                "format=duration",
+                "-of",
+                "default=noprint_wrappers=1:nokey=1",
+                audio_path,
+            ]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            duration = float(result.stdout.strip())
+            self.logger.info(f"Audio duration: {duration:.2f} seconds")
+            return duration
+        except Exception as e:
+            self.logger.error(f"Failed to get audio duration: {e}")
+            raise
+
+    def escape_filter_path(self, path):
+        """
+        Escape a file path for use in ffmpeg filter expressions.
+
+        Args:
+            path: File path to escape
+
+        Returns:
+            str: Escaped path
+        """
+        # Escape backslashes and colons for ffmpeg filter syntax
+        escaped = path.replace("\\", "\\\\").replace(":", "\\:")
+        return escaped
+
+    def build_video_filter(self, ass_subtitles_path, darkness_percent, fonts_dir=None):
+        """
+        Build the video filter chain for scaling, darkening, and subtitles.
+
+        Args:
+            ass_subtitles_path: Path to ASS subtitle file
+            darkness_percent: Darkness overlay percentage (0-100)
+            fonts_dir: Optional fonts directory for ASS rendering
+
+        Returns:
+            str: FFmpeg filter string
+        """
+        filters = []
+
+        # Scale to 4K with intelligent cropping (not stretching)
+        # force_original_aspect_ratio=increase ensures we scale up to fill the frame
+        # then crop to exact 4K dimensions
+        filters.append("scale=w=3840:h=2160:force_original_aspect_ratio=increase,crop=3840:2160")
+
+        # Add darkening overlay if requested (before ASS subtitles)
+        if darkness_percent > 0:
+            # Convert percentage (0-100) to alpha (0.0-1.0)
+            alpha = darkness_percent / 100.0
+            filters.append(f"drawbox=x=0:y=0:w=iw:h=ih:color=black@{alpha:.2f}:t=fill")
+
+        # Add ASS subtitle filter
+        ass_escaped = self.escape_filter_path(ass_subtitles_path)
+        ass_filter = f"ass={ass_escaped}"
+
+        # Add fonts directory if provided
+        if fonts_dir and os.path.isdir(fonts_dir):
+            fonts_escaped = self.escape_filter_path(fonts_dir)
+            ass_filter += f":fontsdir={fonts_escaped}"
+
+        filters.append(ass_filter)
+
+        # Combine all filters with commas
+        return ",".join(filters)
+
+    def execute_command_with_fallback(self, gpu_command, cpu_command, description):
+        """
+        Execute GPU command with automatic fallback to CPU if it fails.
+
+        Args:
+            gpu_command: Command to try with GPU acceleration
+            cpu_command: Fallback command for CPU encoding
+            description: Description for logging
+
+        Raises:
+            Exception: If both GPU and CPU commands fail
+        """
+        self.logger.info(f"{description}")
+
+        # Try GPU-accelerated command first if available
+        if self.nvenc_available and gpu_command != cpu_command:
+            self.logger.debug(f"Attempting hardware-accelerated encoding: {gpu_command}")
+            try:
+                result = subprocess.run(gpu_command, shell=True, capture_output=True, text=True, timeout=600)
+
+                if result.returncode == 0:
+                    self.logger.info(f"✓ Hardware acceleration successful")
+                    return
+                else:
+                    self.logger.warning(f"✗ Hardware acceleration failed (exit code {result.returncode})")
+                    self.logger.warning(f"GPU Command: {gpu_command}")
+
+                    if result.stderr:
+                        self.logger.warning(f"FFmpeg STDERR: {result.stderr}")
+                    if result.stdout:
+                        self.logger.warning(f"FFmpeg STDOUT: {result.stdout}")
+                    self.logger.info("Falling back to software encoding...")
+
+            except subprocess.TimeoutExpired:
+                self.logger.warning("✗ Hardware acceleration timed out, falling back to software encoding")
+            except Exception as e:
+                self.logger.warning(f"✗ Hardware acceleration failed with exception: {e}, falling back to software encoding")
+
+        # Use CPU command (either as fallback or primary method)
+        self.logger.debug(f"Running software encoding: {cpu_command}")
+        try:
+            result = subprocess.run(cpu_command, shell=True, capture_output=True, text=True, timeout=600)
+
+            if result.returncode != 0:
+                error_msg = f"Software encoding failed with exit code {result.returncode}"
+                self.logger.error(error_msg)
+                self.logger.error(f"CPU Command: {cpu_command}")
+                if result.stderr:
+                    self.logger.error(f"FFmpeg STDERR: {result.stderr}")
+                if result.stdout:
+                    self.logger.error(f"FFmpeg STDOUT: {result.stdout}")
+                raise Exception(f"{error_msg}: {cpu_command}")
+            else:
+                self.logger.info(f"✓ Software encoding successful")
+
+        except subprocess.TimeoutExpired:
+            error_msg = "Software encoding timed out"
+            self.logger.error(error_msg)
+            raise Exception(f"{error_msg}: {cpu_command}")
+        except Exception as e:
+            if "Software encoding failed" not in str(e):
+                error_msg = f"Software encoding failed with exception: {e}"
+                self.logger.error(error_msg)
+                raise Exception(f"{error_msg}: {cpu_command}")
+            else:
+                raise
+
+    def process_video_background(
+        self, video_path, audio_path, ass_subtitles_path, output_path, darkness_percent=0, audio_duration=None
+    ):
+        """
+        Process video background with scaling, looping/trimming, darkening, and subtitle rendering.
+
+        Args:
+            video_path: Path to input video file
+            audio_path: Path to audio file (used for duration and audio track)
+            ass_subtitles_path: Path to ASS subtitle file
+            output_path: Path to output video file
+            darkness_percent: Darkness overlay percentage (0-100), default 0
+            audio_duration: Optional pre-calculated audio duration (will calculate if not provided)
+
+        Returns:
+            str: Path to output file
+
+        Raises:
+            Exception: If video processing fails
+        """
+        self.logger.info(f"Processing video background: {video_path}")
+        self.logger.info(f"  Output: {output_path}")
+        self.logger.info(f"  Darkness: {darkness_percent}%")
+
+        # Validate inputs
+        if not os.path.isfile(video_path):
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+        if not os.path.isfile(audio_path):
+            raise FileNotFoundError(f"Audio file not found: {audio_path}")
+        if not os.path.isfile(ass_subtitles_path):
+            raise FileNotFoundError(f"ASS subtitle file not found: {ass_subtitles_path}")
+
+        # Validate darkness parameter
+        if not 0 <= darkness_percent <= 100:
+            raise ValueError(f"Darkness percentage must be between 0 and 100, got {darkness_percent}")
+
+        # Get audio duration if not provided
+        if audio_duration is None:
+            audio_duration = self.get_audio_duration(audio_path)
+
+        # Check for optional fonts directory (matching video.py behavior)
+        fonts_dir = os.environ.get("KARAOKE_FONTS_DIR")
+
+        # Build video filter chain
+        vf_filter = self.build_video_filter(ass_subtitles_path, darkness_percent, fonts_dir)
+
+        # Build commands for GPU and CPU encoding
+        # Use -stream_loop -1 to loop video indefinitely, -shortest to cut when audio ends
+        base_inputs = f'-stream_loop -1 -i "{video_path}" -i "{audio_path}"'
+
+        # GPU-accelerated version
+        gpu_command = (
+            f"{self.ffmpeg_base_command} {self.hwaccel_decode_flags} {base_inputs} "
+            f'-c:a flac -vf "{vf_filter}" -c:v {self.video_encoder} '
+            f"{self.get_nvenc_quality_settings()} -shortest -y \"{output_path}\""
+        )
+
+        # Software fallback version
+        cpu_command = (
+            f'{self.ffmpeg_base_command} {base_inputs} '
+            f'-c:a flac -vf "{vf_filter}" -c:v libx264 -preset fast '
+            f"-b:v 5000k -minrate 5000k -maxrate 20000k -bufsize 10000k "
+            f'-shortest -y "{output_path}"'
+        )
+
+        # Execute with fallback
+        self.execute_command_with_fallback(
+            gpu_command, cpu_command, f"Rendering video with background, subtitles, and effects"
+        )
+
+        # Verify output was created
+        if not os.path.isfile(output_path):
+            raise Exception(f"Output video file was not created: {output_path}")
+
+        self.logger.info(f"✓ Video background processing complete: {output_path}")
+        return output_path
+

{karaoke_gen-0.65.0 → karaoke_gen-0.66.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "karaoke-gen"
-version = "0.65.0"
+version = "0.66.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"