karaoke-gen 0.71.42__py3-none-any.whl → 0.75.53__py3-none-any.whl

karaoke_gen/utils/gen_cli.py

@@ -18,6 +18,7 @@ import glob
 import pyperclip
 from karaoke_gen import KaraokePrep
 from karaoke_gen.karaoke_finalise import KaraokeFinalise
+from karaoke_gen.audio_fetcher import UserCancelledError
 from karaoke_gen.instrumental_review import (
     AudioAnalyzer,
     WaveformGenerator,
@@ -59,6 +60,89 @@ def _resolve_path_for_cwd(path: str, track_dir: str) -> str:
     return path
 
 
+def auto_select_instrumental(track: dict, track_dir: str, logger: logging.Logger) -> str:
+    """
+    Auto-select the best instrumental file when --skip_instrumental_review is used.
+    
+    Selection priority:
+    1. Padded combined instrumental (+BV) - synchronized with vocals + backing vocals
+    2. Non-padded combined instrumental (+BV) - has backing vocals
+    3. Padded clean instrumental - synchronized with vocals
+    4. Non-padded clean instrumental - basic instrumental
+    
+    Args:
+        track: The track dictionary from KaraokePrep containing separated audio info
+        track_dir: The track output directory (we're already chdir'd into it)
+        logger: Logger instance
+        
+    Returns:
+        Path to the selected instrumental file
+        
+    Raises:
+        FileNotFoundError: If no suitable instrumental file can be found
+    """
+    separated = track.get("separated_audio", {})
+    
+    # Look for combined instrumentals first (they include backing vocals)
+    combined = separated.get("combined_instrumentals", {})
+    for model, path in combined.items():
+        if path:
+            resolved = _resolve_path_for_cwd(path, track_dir)
+            # Prefer padded version if it exists
+            base, ext = os.path.splitext(resolved)
+            padded = f"{base} (Padded){ext}"
+            if os.path.exists(padded):
+                logger.info(f"Auto-selected padded combined instrumental: {padded}")
+                return padded
+            if os.path.exists(resolved):
+                logger.info(f"Auto-selected combined instrumental: {resolved}")
+                return resolved
+    
+    # Fall back to clean instrumental
+    clean = separated.get("clean_instrumental", {})
+    if clean.get("instrumental"):
+        resolved = _resolve_path_for_cwd(clean["instrumental"], track_dir)
+        # Prefer padded version if it exists
+        base, ext = os.path.splitext(resolved)
+        padded = f"{base} (Padded){ext}"
+        if os.path.exists(padded):
+            logger.info(f"Auto-selected padded clean instrumental: {padded}")
+            return padded
+        if os.path.exists(resolved):
+            logger.info(f"Auto-selected clean instrumental: {resolved}")
+            return resolved
+    
+    # If separated_audio doesn't have what we need, search the directory
+    # This handles edge cases and custom instrumentals
+    logger.info("No instrumental found in separated_audio, searching directory...")
+    instrumental_files = glob.glob("*(Instrumental*.flac") + glob.glob("*(Instrumental*.wav")
+    
+    # Sort to prefer padded versions and combined instrumentals
+    padded_combined = [f for f in instrumental_files if "(Padded)" in f and "+BV" in f]
+    if padded_combined:
+        logger.info(f"Auto-selected from directory: {padded_combined[0]}")
+        return padded_combined[0]
+    
+    padded_files = [f for f in instrumental_files if "(Padded)" in f]
+    if padded_files:
+        logger.info(f"Auto-selected from directory: {padded_files[0]}")
+        return padded_files[0]
+    
+    combined_files = [f for f in instrumental_files if "+BV" in f]
+    if combined_files:
+        logger.info(f"Auto-selected from directory: {combined_files[0]}")
+        return combined_files[0]
+    
+    if instrumental_files:
+        logger.info(f"Auto-selected from directory: {instrumental_files[0]}")
+        return instrumental_files[0]
+    
+    raise FileNotFoundError(
+        "No instrumental file found. Audio separation may have failed. "
+        "Check the stems/ directory for separated audio files."
+    )
+
+
 def run_instrumental_review(track: dict, logger: logging.Logger) -> str | None:
     """
     Run the instrumental review UI to let user select the best instrumental track.
@@ -116,6 +200,15 @@ def run_instrumental_review(track: dict, logger: logging.Logger) -> str | None:
             with_backing_path = resolved_path
             break
     
+    # Find the original audio file (with vocals)
+    original_audio_path = None
+    raw_original_path = track.get("input_audio_wav")
+    if raw_original_path:
+        original_audio_path = _resolve_path_for_cwd(raw_original_path, track_dir)
+        if not os.path.exists(original_audio_path):
+            logger.warning(f"Original audio file not found: {original_audio_path}")
+            original_audio_path = None
+    
     try:
         logger.info("=== Starting Instrumental Review ===")
         logger.info(f"Analyzing backing vocals: {backing_vocals_path}")
@@ -138,7 +231,7 @@ def run_instrumental_review(track: dict, logger: logging.Logger) -> str | None:
         waveform_generator.generate(
             audio_path=backing_vocals_path,
             output_path=waveform_path,
-            audible_segments=analysis.audible_segments,
+            segments=analysis.audible_segments,
         )
         
         # Start the review server
@@ -152,6 +245,7 @@ def run_instrumental_review(track: dict, logger: logging.Logger) -> str | None:
             backing_vocals_path=backing_vocals_path,
             clean_instrumental_path=clean_instrumental_path,
             with_backing_path=with_backing_path,
+            original_audio_path=original_audio_path,
         )
         
         # Start server and open browser, wait for selection
@@ -182,6 +276,13 @@ def run_instrumental_review(track: dict, logger: logging.Logger) -> str | None:
                 else:
                     logger.warning("Custom instrumental not found, falling back to clean")
                     return clean_instrumental_path
+            elif selection == "uploaded":
+                uploaded_path = server.get_uploaded_instrumental_path()
+                if uploaded_path and os.path.exists(uploaded_path):
+                    return uploaded_path
+                else:
+                    logger.warning("Uploaded instrumental not found, falling back to clean")
+                    return clean_instrumental_path
             else:
                 logger.warning(f"Unknown selection: {selection}, falling back to numeric selection")
                 return None
@@ -199,6 +300,9 @@ def run_instrumental_review(track: dict, logger: logging.Logger) -> str | None:
 
 async def async_main():
     logger = logging.getLogger(__name__)
+    # Prevent log propagation to root logger to avoid duplicate logs
+    # when external packages (like lyrics_converter) configure root logger handlers
+    logger.propagate = False
     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)
@@ -208,6 +312,20 @@ async def async_main():
     parser = create_parser(prog="karaoke-gen")
     args = parser.parse_args()
 
+    # Set review UI URL environment variable for the lyrics transcriber review server
+    # Only set this if the user explicitly wants to use a dev server (e.g., http://localhost:5173)
+    # By default, let the ReviewServer use its bundled local frontend (served from lyrics_transcriber/frontend/)
+    # This enables local iteration on the frontend without redeploying
+    if hasattr(args, 'review_ui_url') and args.review_ui_url:
+        # Check if user provided a custom value (not the default hosted URL)
+        default_hosted_urls = [
+            'https://gen.nomadkaraoke.com/lyrics',
+            'https://lyrics.nomadkaraoke.com'
+        ]
+        if args.review_ui_url.rstrip('/') not in [url.rstrip('/') for url in default_hosted_urls]:
+            # User explicitly wants a specific URL (e.g., Vite dev server)
+            os.environ['LYRICS_REVIEW_UI_URL'] = args.review_ui_url
+        
     # Process style overrides
     try:
         style_overrides = process_style_overrides(args.style_override, logger)
@@ -299,7 +417,21 @@ async def async_main():
         kprep.input_media = input_audio_wav
         
         # Run KaraokePrep
-        tracks = await kprep.process()
+        try:
+            tracks = await kprep.process()
+        except UserCancelledError:
+            logger.info("Operation cancelled by user")
+            return
+        except KeyboardInterrupt:
+            logger.info("Operation cancelled by user (Ctrl+C)")
+            return
+        
+        # Filter out None tracks (can happen if prep failed for some tracks)
+        tracks = [t for t in tracks if t is not None] if tracks else []
+        
+        if not tracks:
+            logger.warning("No tracks to process")
+            return
         
         # Load CDG styles if CDG generation is enabled
         cdg_styles = None
@@ -618,7 +750,21 @@ async def async_main():
     kprep = kprep_coroutine
 
     # Create final tracks data structure
-    tracks = await kprep.process()
+    try:
+        tracks = await kprep.process()
+    except UserCancelledError:
+        logger.info("Operation cancelled by user")
+        return
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        logger.info("Operation cancelled by user (Ctrl+C)")
+        return
+
+    # Filter out None tracks (can happen if prep failed for some tracks)
+    tracks = [t for t in tracks if t is not None] if tracks else []
+    
+    if not tracks:
+        logger.warning("No tracks to process")
+        return
 
     # If prep-only mode, we're done
     if args.prep_only:
@@ -638,13 +784,82 @@ async def async_main():
         logger.info(f"Changing to directory: {track_dir}")
         os.chdir(track_dir)
 
-        # Run instrumental review UI if not skipped
+        # Select instrumental file - either via web UI, auto-selection, or custom instrumental
+        # This ALWAYS produces a selected file - no silent fallback to legacy code
         selected_instrumental_file = None
-        if not getattr(args, 'skip_instrumental_review', False):
+        skip_review = getattr(args, 'skip_instrumental_review', False)
+        
+        # Check if a custom instrumental was provided (via --existing_instrumental)
+        # In this case, the instrumental is already chosen - skip review entirely
+        separated_audio = track.get("separated_audio", {})
+        custom_instrumental = separated_audio.get("Custom", {}).get("instrumental")
+        
+        if custom_instrumental:
+            # Custom instrumental was provided - use it directly, no review needed
+            resolved_path = _resolve_path_for_cwd(custom_instrumental, track_dir)
+            if os.path.exists(resolved_path):
+                logger.info(f"Using custom instrumental (--existing_instrumental): {resolved_path}")
+                selected_instrumental_file = resolved_path
+            else:
+                logger.error(f"Custom instrumental file not found: {resolved_path}")
+                logger.error("The file may have been moved or deleted after preparation.")
+                sys.exit(1)
+                return  # Explicit return for testing
+        elif skip_review:
+            # Auto-select instrumental when review is skipped (non-interactive mode)
+            logger.info("Instrumental review skipped (--skip_instrumental_review), auto-selecting instrumental file...")
+            try:
+                selected_instrumental_file = auto_select_instrumental(
+                    track=track,
+                    track_dir=track_dir,
+                    logger=logger,
+                )
+            except FileNotFoundError as e:
+                logger.error(f"Failed to auto-select instrumental: {e}")
+                logger.error("Check that audio separation completed successfully.")
+                sys.exit(1)
+                return  # Explicit return for testing
+        else:
+            # Run instrumental review web UI
             selected_instrumental_file = run_instrumental_review(
                 track=track,
                 logger=logger,
             )
+            
+            # If instrumental review failed/returned None, show error and exit
+            # NO SILENT FALLBACK - we want to know if the new flow has issues
+            if selected_instrumental_file is None:
+                logger.error("")
+                logger.error("=" * 70)
+                logger.error("INSTRUMENTAL SELECTION FAILED")
+                logger.error("=" * 70)
+                logger.error("")
+                logger.error("The instrumental review UI could not find the required files.")
+                logger.error("")
+                logger.error("Common causes:")
+                logger.error("  - No backing vocals file was found (check stems/ directory)")
+                logger.error("  - No clean instrumental was found (audio separation may have failed)")
+                logger.error("  - Path resolution failed after directory change")
+                logger.error("")
+                logger.error("To investigate:")
+                logger.error("  - Check the stems/ directory for: *Backing Vocals*.flac and *Instrumental*.flac")
+                logger.error("  - Look for separation errors earlier in the log")
+                logger.error("  - Verify audio separation completed without errors")
+                logger.error("")
+                logger.error("Workarounds:")
+                logger.error("  - Re-run with --skip_instrumental_review to auto-select an instrumental")
+                logger.error("  - Re-run the full pipeline to regenerate stems")
+                logger.error("")
+                sys.exit(1)
+                return  # Explicit return for testing
+        
+        logger.info(f"Selected instrumental file: {selected_instrumental_file}")
+        
+        # Get countdown padding info from track (if vocals were padded, instrumental must match)
+        countdown_padding_seconds = None
+        if track.get("countdown_padding_added", False):
+            countdown_padding_seconds = track.get("countdown_padding_seconds", 3.0)
+            logger.info(f"Countdown padding detected: {countdown_padding_seconds}s (will be applied to instrumental if needed)")
         
         # Load CDG styles if CDG generation is enabled
         cdg_styles = None
@@ -690,6 +905,7 @@ async def async_main():
             keep_brand_code=getattr(args, 'keep_brand_code', False),
             non_interactive=args.yes,
             selected_instrumental_file=selected_instrumental_file,
+            countdown_padding_seconds=countdown_padding_seconds,
         )
 
         try: