karaoke-gen 0.71.29__tar.gz → 0.72.2__tar.gz

{karaoke_gen-0.71.29 → karaoke_gen-0.72.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karaoke-gen
-Version: 0.71.29
+Version: 0.72.2
 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
@@ -29,8 +29,10 @@ Requires-Dist: google-auth
 Requires-Dist: google-auth-httplib2
 Requires-Dist: google-auth-oauthlib
 Requires-Dist: google-cloud-firestore (>=2.14.0)
+Requires-Dist: google-cloud-run (>=0.10.0)
 Requires-Dist: google-cloud-secret-manager (>=2.18.0)
 Requires-Dist: google-cloud-storage (>=2.14.0)
+Requires-Dist: google-cloud-tasks (>=2.16.0)
 Requires-Dist: httpx (>=0.25.0)
 Requires-Dist: jiwer (>=3.0.0)
 Requires-Dist: karaoke-lyrics-processor (>=0.6)
@@ -82,6 +84,7 @@ Requires-Dist: torch (>=2.7)
 Requires-Dist: tqdm (>=4.67)
 Requires-Dist: transformers (>=4.47)
 Requires-Dist: uvicorn[standard] (>=0.24.0)
+Requires-Dist: yt-dlp (>=2024.0.0)
 Project-URL: Documentation, https://github.com/nomadkaraoke/karaoke-gen/blob/main/README.md
 Project-URL: Homepage, https://github.com/nomadkaraoke/karaoke-gen
 Project-URL: Repository, https://github.com/nomadkaraoke/karaoke-gen

karaoke_gen-0.72.2/karaoke_gen/__init__.py

@@ -0,0 +1,38 @@
+import warnings
+
+# Suppress specific SyntaxWarnings from third-party packages
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="pydub.*")
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="syrics.*")
+
+# Lazy imports to avoid loading heavy dependencies when not needed.
+# KaraokePrep has many dependencies (lyrics_transcriber, etc.) which may not
+# be available in all contexts (e.g., backend which only needs audio_fetcher).
+# 
+# Use explicit imports instead:
+#   from karaoke_gen.karaoke_gen import KaraokePrep
+#   from karaoke_gen.audio_fetcher import FlacFetcher, AudioSearchResult, ...
+
+__all__ = [
+    "KaraokePrep",
+    # Audio fetcher
+    "FlacFetcher",
+    "AudioSearchResult",
+    "AudioFetchResult",
+    "AudioFetcherError",
+    "NoResultsError",
+    "DownloadError",
+    "UserCancelledError",
+]
+
+
+def __getattr__(name):
+    """Lazy import for heavy modules."""
+    if name == "KaraokePrep":
+        from .karaoke_gen import KaraokePrep
+        return KaraokePrep
+    elif name in ("FlacFetcher", "AudioSearchResult", "AudioFetchResult", 
+                  "AudioFetcherError", "NoResultsError", "DownloadError", 
+                  "UserCancelledError"):
+        from . import audio_fetcher
+        return getattr(audio_fetcher, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{karaoke_gen-0.71.29 → karaoke_gen-0.72.2}/karaoke_gen/audio_fetcher.py

@@ -7,15 +7,26 @@ using flacfetch, replacing the previous direct yt-dlp usage.
 
 import logging
 import os
+import signal
+import sys
 import tempfile
+import threading
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import List, Optional
+from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError
+from dataclasses import dataclass, asdict, field
+from typing import List, Optional, Dict, Any
+
+# Global flag to track if user requested cancellation via Ctrl+C
+_interrupt_requested = False
 
 
 @dataclass
 class AudioSearchResult:
-    """Represents a single search result for audio."""
+    """Represents a single search result for audio.
+    
+    Used by both local CLI and cloud backend. Supports serialization
+    for Firestore storage via to_dict()/from_dict().
+    """
 
     title: str
     artist: str
@@ -24,13 +35,49 @@ class AudioSearchResult:
     duration: Optional[int] = None  # Duration in seconds
     quality: Optional[str] = None  # e.g., "FLAC", "320kbps", etc.
     source_id: Optional[str] = None  # Unique ID from the source
-    # Raw result object from the provider (for download)
-    raw_result: Optional[object] = None
+    index: int = 0  # Index in the results list (for API selection)
+    # Raw result object from the provider (for download) - not serialized
+    raw_result: Optional[object] = field(default=None, repr=False)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict for JSON/Firestore serialization.
+        
+        Note: raw_result is excluded as it's not serializable.
+        """
+        return {
+            "title": self.title,
+            "artist": self.artist,
+            "url": self.url,
+            "provider": self.provider,
+            "duration": self.duration,
+            "quality": self.quality,
+            "source_id": self.source_id,
+            "index": self.index,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AudioSearchResult":
+        """Create from dict (e.g., from Firestore)."""
+        return cls(
+            title=data.get("title", ""),
+            artist=data.get("artist", ""),
+            url=data.get("url", ""),
+            provider=data.get("provider", "Unknown"),
+            duration=data.get("duration"),
+            quality=data.get("quality"),
+            source_id=data.get("source_id"),
+            index=data.get("index", 0),
+            raw_result=None,  # Not stored in serialized form
+        )
 
 
 @dataclass
 class AudioFetchResult:
-    """Result of an audio fetch operation."""
+    """Result of an audio fetch operation.
+    
+    Used by both local CLI and cloud backend. Supports serialization
+    for Firestore storage via to_dict()/from_dict().
+    """
 
     filepath: str
     artist: str
@@ -38,6 +85,22 @@ class AudioFetchResult:
     provider: str
     duration: Optional[int] = None
     quality: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict for JSON/Firestore serialization."""
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AudioFetchResult":
+        """Create from dict (e.g., from Firestore)."""
+        return cls(
+            filepath=data.get("filepath", ""),
+            artist=data.get("artist", ""),
+            title=data.get("title", ""),
+            provider=data.get("provider", "Unknown"),
+            duration=data.get("duration"),
+            quality=data.get("quality"),
+        )
 
 
 class AudioFetcherError(Exception):
@@ -58,6 +121,19 @@ class DownloadError(AudioFetcherError):
     pass
 
 
+class UserCancelledError(AudioFetcherError):
+    """Raised when user explicitly cancels the operation (e.g., enters 0 or Ctrl+C)."""
+
+    pass
+
+
+def _check_interrupt():
+    """Check if interrupt was requested and raise UserCancelledError if so."""
+    global _interrupt_requested
+    if _interrupt_requested:
+        raise UserCancelledError("Operation cancelled by user")
+
+
 class AudioFetcher(ABC):
     """Abstract base class for audio fetching implementations."""
 
@@ -140,6 +216,8 @@ class FlacFetchAudioFetcher(AudioFetcher):
 
     This provides access to multiple audio sources including private music trackers
     and YouTube, with intelligent prioritization of high-quality sources.
+    
+    Also exported as FlacFetcher for shorter name.
     """
 
     def __init__(
@@ -169,25 +247,38 @@ class FlacFetchAudioFetcher(AudioFetcher):
         if self._manager is None:
             # Import flacfetch here to avoid import errors if not installed
             from flacfetch.core.manager import FetchManager
-            from flacfetch.providers.youtube import YouTubeProvider
+            from flacfetch.providers.youtube import YoutubeProvider
+            from flacfetch.downloaders.youtube import YoutubeDownloader
+
+            # Try to import TorrentDownloader (has optional dependencies)
+            try:
+                from flacfetch.downloaders.torrent import TorrentDownloader
+            except ImportError:
+                TorrentDownloader = None
+                self.logger.debug("TorrentDownloader not available (missing dependencies)")
 
             self._manager = FetchManager()
 
-            # Add providers based on available API keys
+            # Add providers and downloaders based on available API keys
             if self._redacted_api_key:
                 from flacfetch.providers.redacted import RedactedProvider
 
                 self._manager.add_provider(RedactedProvider(api_key=self._redacted_api_key))
+                if TorrentDownloader:
+                    self._manager.register_downloader("Redacted", TorrentDownloader())
                 self.logger.debug("Added Redacted provider")
 
             if self._ops_api_key:
                 from flacfetch.providers.ops import OPSProvider
 
                 self._manager.add_provider(OPSProvider(api_key=self._ops_api_key))
+                if TorrentDownloader:
+                    self._manager.register_downloader("OPS", TorrentDownloader())
                 self.logger.debug("Added OPS provider")
 
-            # Always add YouTube as a fallback provider
-            self._manager.add_provider(YouTubeProvider())
+            # Always add YouTube as a fallback provider with its downloader
+            self._manager.add_provider(YoutubeProvider())
+            self._manager.register_downloader("YouTube", YoutubeDownloader())
             self.logger.debug("Added YouTube provider")
 
         return self._manager
@@ -219,16 +310,21 @@ class FlacFetchAudioFetcher(AudioFetcher):
 
         # Convert to our AudioSearchResult format
         search_results = []
-        for result in results:
+        for i, result in enumerate(results):
+            # Get quality as string if it's a Quality object
+            quality = getattr(result, "quality", None)
+            quality_str = str(quality) if quality else None
+
             search_results.append(
                 AudioSearchResult(
                     title=getattr(result, "title", title),
                     artist=getattr(result, "artist", artist),
-                    url=getattr(result, "url", ""),
-                    provider=getattr(result, "provider", "Unknown"),
-                    duration=getattr(result, "duration", None),
-                    quality=getattr(result, "quality", None),
-                    source_id=getattr(result, "id", None),
+                    url=getattr(result, "download_url", "") or "",
+                    provider=getattr(result, "source_name", "Unknown"),
+                    duration=getattr(result, "duration_seconds", None),
+                    quality=quality_str,
+                    source_id=getattr(result, "info_hash", None),
+                    index=i,  # Set index for API selection
                     raw_result=result,
                 )
             )
@@ -265,7 +361,7 @@ class FlacFetchAudioFetcher(AudioFetcher):
         if output_filename is None:
             output_filename = f"{result.artist} - {result.title}"
 
-        self.logger.info(f"Downloading: {result.artist} - {result.title} from {result.provider}")
+        self.logger.info(f"Downloading: {result.artist} - {result.title} from {result.provider or 'Unknown'}")
 
         try:
             # Use flacfetch to download
@@ -292,6 +388,40 @@ class FlacFetchAudioFetcher(AudioFetcher):
         except Exception as e:
             raise DownloadError(f"Failed to download {result.artist} - {result.title}: {e}") from e
 
+    def select_best(self, results: List[AudioSearchResult]) -> int:
+        """
+        Select the best result from a list of search results.
+        
+        Uses flacfetch's built-in quality ranking to determine the best source.
+        This is useful for automated/non-interactive usage.
+        
+        Args:
+            results: List of AudioSearchResult objects from search()
+            
+        Returns:
+            Index of the best result in the list
+        """
+        if not results:
+            return 0
+        
+        manager = self._get_manager()
+        
+        # Get raw results that have raw_result set
+        raw_results = [r.raw_result for r in results if r.raw_result is not None]
+        
+        if raw_results:
+            try:
+                best = manager.select_best(raw_results)
+                # Find index of best result
+                for i, r in enumerate(results):
+                    if r.raw_result == best:
+                        return i
+            except Exception as e:
+                self.logger.warning(f"select_best failed, using first result: {e}")
+        
+        # Fallback: return first result
+        return 0
+
     def search_and_download(
         self,
         artist: str,
@@ -319,6 +449,7 @@ class FlacFetchAudioFetcher(AudioFetcher):
         Raises:
             NoResultsError: If no results are found
             DownloadError: If download fails
+            UserCancelledError: If user cancels (Ctrl+C or enters 0)
         """
         from flacfetch.core.models import TrackQuery
 
@@ -326,7 +457,9 @@ class FlacFetchAudioFetcher(AudioFetcher):
         query = TrackQuery(artist=artist, title=title)
 
         self.logger.info(f"Searching for: {artist} - {title}")
-        results = manager.search(query)
+        
+        # Run search in a thread so we can handle Ctrl+C
+        results = self._interruptible_search(manager, query)
 
         if not results:
             raise NoResultsError(f"No results found for: {artist} - {title}")
@@ -336,11 +469,13 @@ class FlacFetchAudioFetcher(AudioFetcher):
         if auto_select:
             # Auto mode: select best result based on flacfetch's ranking
             selected = manager.select_best(results)
-            self.logger.info(f"Auto-selected: {getattr(selected, 'title', title)} from {getattr(selected, 'provider', 'Unknown')}")
+            self.logger.info(f"Auto-selected: {getattr(selected, 'title', title)} from {getattr(selected, 'source_name', 'Unknown')}")
         else:
             # Interactive mode: present options to user
             selected = self._interactive_select(results, artist, title)
 
+        # Note: _interactive_select now raises UserCancelledError instead of returning None
+        # This check is kept as a safety net
         if selected is None:
             raise NoResultsError(f"No result selected for: {artist} - {title}")
 
@@ -351,7 +486,7 @@ class FlacFetchAudioFetcher(AudioFetcher):
         if output_filename is None:
             output_filename = f"{artist} - {title}"
 
-        self.logger.info(f"Downloading from {getattr(selected, 'provider', 'Unknown')}...")
+        self.logger.info(f"Downloading from {getattr(selected, 'source_name', 'Unknown')}...")
 
         try:
             filepath = manager.download(
@@ -365,51 +500,169 @@ class FlacFetchAudioFetcher(AudioFetcher):
 
             self.logger.info(f"Downloaded to: {filepath}")
 
+            # Get quality as string if it's a Quality object
+            quality = getattr(selected, "quality", None)
+            quality_str = str(quality) if quality else None
+
             return AudioFetchResult(
                 filepath=filepath,
                 artist=artist,
                 title=title,
-                provider=getattr(selected, "provider", "Unknown"),
-                duration=getattr(selected, "duration", None),
-                quality=getattr(selected, "quality", None),
+                provider=getattr(selected, "source_name", "Unknown"),
+                duration=getattr(selected, "duration_seconds", None),
+                quality=quality_str,
             )
 
+        except (UserCancelledError, KeyboardInterrupt):
+            # Let cancellation exceptions propagate without wrapping
+            raise
         except Exception as e:
             raise DownloadError(f"Failed to download {artist} - {title}: {e}") from e
 
+    def _interruptible_search(self, manager, query) -> list:
+        """
+        Run search in a way that can be interrupted by Ctrl+C.
+        
+        The flacfetch search is a blocking network operation that doesn't
+        respond to SIGINT while running. This method runs it in a background
+        thread and periodically checks for interrupts.
+        
+        Args:
+            manager: The FetchManager instance
+            query: The TrackQuery to search for
+            
+        Returns:
+            List of search results
+            
+        Raises:
+            UserCancelledError: If user presses Ctrl+C during search
+        """
+        global _interrupt_requested
+        _interrupt_requested = False
+        result_container = {"results": None, "error": None}
+        
+        def do_search():
+            try:
+                result_container["results"] = manager.search(query)
+            except Exception as e:
+                result_container["error"] = e
+        
+        # Set up signal handler for immediate response to Ctrl+C
+        original_handler = signal.getsignal(signal.SIGINT)
+        
+        def interrupt_handler(signum, frame):
+            global _interrupt_requested
+            _interrupt_requested = True
+            # Print immediately so user knows it was received
+            print("\nCancelling... please wait", file=sys.stderr)
+        
+        signal.signal(signal.SIGINT, interrupt_handler)
+        
+        try:
+            # Start search in background thread
+            search_thread = threading.Thread(target=do_search, daemon=True)
+            search_thread.start()
+            
+            # Wait for completion with periodic interrupt checks
+            while search_thread.is_alive():
+                search_thread.join(timeout=0.1)  # Check every 100ms
+                if _interrupt_requested:
+                    # Don't wait for thread - it's a daemon and will be killed
+                    raise UserCancelledError("Search cancelled by user (Ctrl+C)")
+            
+            # Check for errors from the search
+            if result_container["error"] is not None:
+                raise result_container["error"]
+                
+            return result_container["results"]
+            
+        finally:
+            # Restore original signal handler
+            signal.signal(signal.SIGINT, original_handler)
+            _interrupt_requested = False
+
     def _interactive_select(self, results: list, artist: str, title: str) -> object:
         """
         Present search results to the user for interactive selection.
 
+        Uses flacfetch's built-in CLIHandler for rich, colorized output.
+
         Args:
-            results: List of search results from flacfetch
+            results: List of Release objects from flacfetch
             artist: The artist name being searched
             title: The track title being searched
 
         Returns:
-            The selected result object
+            The selected Release object
+            
+        Raises:
+            UserCancelledError: If user cancels selection
+        """
+        try:
+            # Use flacfetch's built-in CLIHandler for rich display
+            from flacfetch.interface.cli import CLIHandler
+
+            handler = CLIHandler(target_artist=artist)
+            result = handler.select_release(results)
+            if result is None:
+                # User selected 0 to cancel
+                raise UserCancelledError("Selection cancelled by user")
+            return result
+        except ImportError:
+            # Fallback to basic display if CLIHandler not available
+            return self._basic_interactive_select(results, artist, title)
+        except (KeyboardInterrupt, EOFError):
+            raise UserCancelledError("Selection cancelled by user (Ctrl+C)")
+        except (AttributeError, TypeError):
+            # Fallback if results aren't proper Release objects (e.g., in tests)
+            return self._basic_interactive_select(results, artist, title)
+
+    def _basic_interactive_select(self, results: list, artist: str, title: str) -> object:
+        """
+        Basic fallback for interactive selection without rich formatting.
+
+        Args:
+            results: List of Release objects from flacfetch
+            artist: The artist name being searched
+            title: The track title being searched
+
+        Returns:
+            The selected Release object
+            
+        Raises:
+            UserCancelledError: If user cancels selection
         """
         print(f"\n{'=' * 60}")
         print(f"Search Results for: {artist} - {title}")
         print(f"{'=' * 60}\n")
 
         for i, result in enumerate(results, 1):
-            provider = getattr(result, "provider", "Unknown")
+            # Use correct flacfetch attribute names
+            source_name = getattr(result, "source_name", "Unknown")
             result_title = getattr(result, "title", "Unknown")
             result_artist = getattr(result, "artist", "Unknown")
-            quality = getattr(result, "quality", "")
-            duration = getattr(result, "duration", None)
+            quality = getattr(result, "quality", None)
+            duration_seconds = getattr(result, "duration_seconds", None)
+            seeders = getattr(result, "seeders", None)
+            target_file = getattr(result, "target_file", None)
 
             # Format duration if available
             duration_str = ""
-            if duration:
-                minutes = duration // 60
-                seconds = duration % 60
+            if duration_seconds:
+                minutes = duration_seconds // 60
+                seconds = duration_seconds % 60
                 duration_str = f" [{minutes}:{seconds:02d}]"
 
+            # Format quality - it's a Quality object with __str__
             quality_str = f" ({quality})" if quality else ""
 
-            print(f"  {i}. [{provider}] {result_artist} - {result_title}{quality_str}{duration_str}")
+            # Format seeders for torrent sources
+            seeders_str = f" Seeders: {seeders}" if seeders is not None else ""
+
+            # Format target file
+            file_str = f' "{target_file}"' if target_file else ""
+
+            print(f"  {i}. [{source_name}] {result_artist} - {result_title}{quality_str}{duration_str}{seeders_str}{file_str}")
 
         print()
         print("  0. Cancel")
@@ -421,7 +674,7 @@ class FlacFetchAudioFetcher(AudioFetcher):
 
                 if choice == "0":
                     self.logger.info("User cancelled selection")
-                    return None
+                    raise UserCancelledError("Selection cancelled by user")
 
                 choice_num = int(choice)
                 if 1 <= choice_num <= len(results):
@@ -435,7 +688,11 @@ class FlacFetchAudioFetcher(AudioFetcher):
                 print("Please enter a valid number")
             except KeyboardInterrupt:
                 print("\nCancelled")
-                return None
+                raise UserCancelledError("Selection cancelled by user (Ctrl+C)")
+
+
+# Alias for shorter name - used by backend and other consumers
+FlacFetcher = FlacFetchAudioFetcher
 
 
 def create_audio_fetcher(

{karaoke_gen-0.71.29 → karaoke_gen-0.72.2}/karaoke_gen/audio_processor.py

@@ -771,8 +771,16 @@ class AudioProcessor:
         padded_result["other_stems"] = separation_result.get("other_stems", {})
         padded_result["backing_vocals"] = separation_result.get("backing_vocals", {})
         
-        self.logger.info(
-            f"✓ Countdown padding applied to {len(padded_result['combined_instrumentals']) + 1} instrumental file(s)"
-        )
+        # Count actual padded files (don't assume clean instrumental was padded)
+        padded_count = (1 if padded_result["clean_instrumental"].get("instrumental") else 0) + len(padded_result["combined_instrumentals"])
+        
+        if padded_count > 0:
+            self.logger.info(
+                f"✓ Countdown padding applied to {padded_count} instrumental file(s)"
+            )
+        else:
+            self.logger.warning(
+                "No instrumental files found to pad. Check that audio separation completed successfully."
+            )
         
         return padded_result