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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karaoke-gen
-Version: 0.72.2
+Version: 0.75.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
@@ -48,6 +48,7 @@ Requires-Dist: lyrics-converter (>=0.2.1)
 Requires-Dist: lyricsgenius (>=3)
 Requires-Dist: matplotlib (>=3)
 Requires-Dist: metaphone (>=0.6)
+Requires-Dist: nest-asyncio (>=1.5)
 Requires-Dist: nltk (>=3.9)
 Requires-Dist: numpy (>=2)
 Requires-Dist: ollama (>=0.4.7)

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

@@ -26,6 +26,9 @@ class AudioSearchResult:
     
     Used by both local CLI and cloud backend. Supports serialization
     for Firestore storage via to_dict()/from_dict().
+    
+    For rich display, this class can serialize the full flacfetch Release
+    data so remote CLIs can use flacfetch's shared display functions.
     """
 
     title: str
@@ -36,15 +39,18 @@ class AudioSearchResult:
     quality: Optional[str] = None  # e.g., "FLAC", "320kbps", etc.
     source_id: Optional[str] = None  # Unique ID from the source
     index: int = 0  # Index in the results list (for API selection)
+    seeders: Optional[int] = None  # Number of seeders (for torrent sources)
+    target_file: Optional[str] = None  # Target filename in the release
     # 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.
+        Includes full flacfetch Release data if available, enabling
+        remote CLIs to use flacfetch's shared display functions.
         """
-        return {
+        result = {
             "title": self.title,
             "artist": self.artist,
             "url": self.url,
@@ -53,7 +59,28 @@ class AudioSearchResult:
             "quality": self.quality,
             "source_id": self.source_id,
             "index": self.index,
+            "seeders": self.seeders,
+            "target_file": self.target_file,
         }
+        
+        # If we have a raw_result (flacfetch Release), include its full data
+        # This enables rich display on the remote CLI
+        if self.raw_result:
+            try:
+                release_dict = self.raw_result.to_dict()
+                # Merge Release fields into result (they may override basic fields)
+                for key in ['year', 'label', 'edition_info', 'release_type', 'channel',
+                           'view_count', 'size_bytes', 'target_file_size', 'track_pattern',
+                           'match_score', 'formatted_size', 'formatted_duration',
+                           'formatted_views', 'is_lossless', 'quality_str', 'quality']:
+                    if key in release_dict:
+                        # Use 'quality_data' for the quality dict to avoid confusion with quality string
+                        result_key = 'quality_data' if key == 'quality' else key
+                        result[result_key] = release_dict[key]
+            except AttributeError:
+                pass  # raw_result doesn't have to_dict() method
+        
+        return result
     
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "AudioSearchResult":
@@ -67,6 +94,8 @@ class AudioSearchResult:
             quality=data.get("quality"),
             source_id=data.get("source_id"),
             index=data.get("index", 0),
+            seeders=data.get("seeders"),
+            target_file=data.get("target_file"),
             raw_result=None,  # Not stored in serialized form
         )
 
@@ -241,6 +270,47 @@ class FlacFetchAudioFetcher(AudioFetcher):
         self._ops_api_key = ops_api_key or os.environ.get("OPS_API_KEY")
         self._provider_priority = provider_priority
         self._manager = None
+        self._transmission_available = None  # Cached result of Transmission check
+
+    def _check_transmission_available(self) -> bool:
+        """
+        Check if Transmission daemon is available for torrent downloads.
+        
+        This prevents adding tracker providers (Redacted/OPS) when Transmission
+        isn't running, which would result in search results that can't be downloaded.
+        
+        Returns:
+            True if Transmission is available and responsive, False otherwise.
+        """
+        if self._transmission_available is not None:
+            self.logger.info(f"[Transmission] Using cached status: available={self._transmission_available}")
+            return self._transmission_available
+        
+        host = os.environ.get("TRANSMISSION_HOST", "localhost")
+        port = int(os.environ.get("TRANSMISSION_PORT", "9091"))
+        self.logger.info(f"[Transmission] Checking availability at {host}:{port}")
+        
+        try:
+            import transmission_rpc
+            self.logger.info(f"[Transmission] transmission_rpc imported successfully")
+            
+            client = transmission_rpc.Client(host=host, port=port, timeout=5)
+            self.logger.info(f"[Transmission] Client created, calling session_stats()...")
+            
+            # Simple test to verify connection works
+            stats = client.session_stats()
+            self.logger.info(f"[Transmission] Connected! Download dir: {getattr(stats, 'download_dir', 'unknown')}")
+            
+            self._transmission_available = True
+        except ImportError as e:
+            self._transmission_available = False
+            self.logger.warning(f"[Transmission] transmission_rpc not installed: {e}")
+        except Exception as e:
+            self._transmission_available = False
+            self.logger.warning(f"[Transmission] Connection failed to {host}:{port}: {type(e).__name__}: {e}")
+        
+        self.logger.info(f"[Transmission] Final status: available={self._transmission_available}")
+        return self._transmission_available
 
     def _get_manager(self):
         """Lazily initialize and return the FetchManager."""
@@ -251,30 +321,46 @@ class FlacFetchAudioFetcher(AudioFetcher):
             from flacfetch.downloaders.youtube import YoutubeDownloader
 
             # Try to import TorrentDownloader (has optional dependencies)
+            TorrentDownloader = None
             try:
                 from flacfetch.downloaders.torrent import TorrentDownloader
             except ImportError:
-                TorrentDownloader = None
                 self.logger.debug("TorrentDownloader not available (missing dependencies)")
 
             self._manager = FetchManager()
 
+            # Only add tracker providers if we can actually download from them
+            # This requires both TorrentDownloader and a running Transmission daemon
+            has_torrent_downloader = TorrentDownloader is not None
+            transmission_available = self._check_transmission_available()
+            can_use_trackers = has_torrent_downloader and transmission_available
+            
+            self.logger.info(
+                f"[FlacFetcher] Provider setup: TorrentDownloader={has_torrent_downloader}, "
+                f"Transmission={transmission_available}, can_use_trackers={can_use_trackers}"
+            )
+            
+            if not can_use_trackers and (self._redacted_api_key or self._ops_api_key):
+                self.logger.warning(
+                    "[FlacFetcher] Tracker providers (Redacted/OPS) DISABLED: "
+                    f"TorrentDownloader={has_torrent_downloader}, Transmission={transmission_available}. "
+                    "Only YouTube sources will be used."
+                )
+
             # Add providers and downloaders based on available API keys
-            if self._redacted_api_key:
+            if self._redacted_api_key and can_use_trackers:
                 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")
+                self._manager.register_downloader("Redacted", TorrentDownloader())
+                self.logger.info("[FlacFetcher] Added Redacted provider with TorrentDownloader")
 
-            if self._ops_api_key:
+            if self._ops_api_key and can_use_trackers:
                 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")
+                self._manager.register_downloader("OPS", TorrentDownloader())
+                self.logger.info("[FlacFetcher] Added OPS provider with TorrentDownloader")
 
             # Always add YouTube as a fallback provider with its downloader
             self._manager.add_provider(YoutubeProvider())
@@ -325,6 +411,8 @@ class FlacFetchAudioFetcher(AudioFetcher):
                     quality=quality_str,
                     source_id=getattr(result, "info_hash", None),
                     index=i,  # Set index for API selection
+                    seeders=getattr(result, "seeders", None),
+                    target_file=getattr(result, "target_file", None),
                     raw_result=result,
                 )
             )
@@ -489,13 +577,15 @@ class FlacFetchAudioFetcher(AudioFetcher):
         self.logger.info(f"Downloading from {getattr(selected, 'source_name', 'Unknown')}...")
 
         try:
-            filepath = manager.download(
+            # Use interruptible download so Ctrl+C works during torrent downloads
+            filepath = self._interruptible_download(
+                manager,
                 selected,
                 output_path=output_dir,
                 output_filename=output_filename,
             )
 
-            if filepath is None:
+            if not filepath:
                 raise DownloadError(f"Download returned no file path for: {artist} - {title}")
 
             self.logger.info(f"Downloaded to: {filepath}")
@@ -581,6 +671,111 @@ class FlacFetchAudioFetcher(AudioFetcher):
             signal.signal(signal.SIGINT, original_handler)
             _interrupt_requested = False
 
+    def _interruptible_download(self, manager, selected, output_path: str, output_filename: str) -> str:
+        """
+        Run download in a way that can be interrupted by Ctrl+C.
+        
+        The flacfetch/transmission download is a blocking operation that doesn't
+        respond to SIGINT while running (especially for torrent downloads).
+        This method runs it in a background thread and periodically checks for interrupts.
+        
+        Args:
+            manager: The FetchManager instance
+            selected: The selected result to download
+            output_path: Directory to save the file
+            output_filename: Filename to save as
+            
+        Returns:
+            Path to the downloaded file
+            
+        Raises:
+            UserCancelledError: If user presses Ctrl+C during download
+            DownloadError: If download fails
+        """
+        global _interrupt_requested
+        _interrupt_requested = False
+        result_container = {"filepath": None, "error": None}
+        was_cancelled = False
+        
+        def do_download():
+            try:
+                result_container["filepath"] = manager.download(
+                    selected,
+                    output_path=output_path,
+                    output_filename=output_filename,
+                )
+            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 download... please wait (may take a few seconds)", file=sys.stderr)
+        
+        signal.signal(signal.SIGINT, interrupt_handler)
+        
+        try:
+            # Start download in background thread
+            download_thread = threading.Thread(target=do_download, daemon=True)
+            download_thread.start()
+            
+            # Wait for completion with periodic interrupt checks
+            while download_thread.is_alive():
+                download_thread.join(timeout=0.2)  # Check every 200ms
+                if _interrupt_requested:
+                    was_cancelled = True
+                    # Clean up any pending torrents before raising
+                    self._cleanup_transmission_torrents(selected)
+                    raise UserCancelledError("Download cancelled by user (Ctrl+C)")
+            
+            # Check for errors from the download
+            if result_container["error"] is not None:
+                raise result_container["error"]
+                
+            return result_container["filepath"]
+            
+        finally:
+            # Restore original signal handler
+            signal.signal(signal.SIGINT, original_handler)
+            _interrupt_requested = False
+
+    def _cleanup_transmission_torrents(self, selected) -> None:
+        """
+        Clean up any torrents in Transmission that were started for this download.
+        
+        Called when a download is cancelled to remove incomplete torrents and their data.
+        
+        Args:
+            selected: The selected result that was being downloaded
+        """
+        try:
+            import transmission_rpc
+            host = os.environ.get("TRANSMISSION_HOST", "localhost")
+            port = int(os.environ.get("TRANSMISSION_PORT", "9091"))
+            client = transmission_rpc.Client(host=host, port=port, timeout=5)
+            
+            # Get the release name to match against torrents
+            release_name = getattr(selected, 'name', None) or getattr(selected, 'title', None)
+            if not release_name:
+                self.logger.debug("[Transmission] No release name to match for cleanup")
+                return
+            
+            # Find and remove matching incomplete torrents
+            torrents = client.get_torrents()
+            for torrent in torrents:
+                # Match by name similarity and incomplete status
+                if torrent.progress < 100 and release_name.lower() in torrent.name.lower():
+                    self.logger.info(f"[Transmission] Removing cancelled torrent: {torrent.name}")
+                    client.remove_torrent(torrent.id, delete_data=True)
+                    
+        except Exception as e:
+            # Don't fail the cancellation if cleanup fails
+            self.logger.debug(f"[Transmission] Cleanup failed (non-fatal): {e}")
+
     def _interactive_select(self, results: list, artist: str, title: str) -> object:
         """
         Present search results to the user for interactive selection.
@@ -632,41 +827,9 @@ class FlacFetchAudioFetcher(AudioFetcher):
         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):
-            # 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", 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_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 ""
-
-            # 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")
-        print()
+        # Use flacfetch's shared display function
+        from flacfetch import print_releases
+        print_releases(results, target_artist=artist, use_colors=True)
 
         while True:
             try:

{karaoke_gen-0.72.2 → karaoke_gen-0.75.2}/karaoke_gen/instrumental_review/server.py

@@ -11,6 +11,7 @@ Similar pattern to LyricsTranscriber's ReviewServer.
 import logging
 import os
 from pathlib import Path
+import socket
 import threading
 import webbrowser
 from typing import List, Optional
@@ -358,23 +359,74 @@ class InstrumentalReviewServer:
 </body>
 </html>"""
     
+    @staticmethod
+    def _is_port_available(host: str, port: int) -> bool:
+        """Check if a port is available for binding."""
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                sock.bind((host, port))
+                return True
+        except OSError:
+            return False
+    
+    @staticmethod
+    def _find_available_port(host: str, preferred_port: int, max_attempts: int = 100) -> int:
+        """
+        Find an available port, starting with the preferred port.
+        
+        Args:
+            host: Host to bind to
+            preferred_port: The preferred port to try first
+            max_attempts: Maximum number of ports to try
+            
+        Returns:
+            An available port number
+            
+        Raises:
+            RuntimeError: If no available port could be found
+        """
+        # Try the preferred port first
+        if InstrumentalReviewServer._is_port_available(host, preferred_port):
+            return preferred_port
+        
+        # Try subsequent ports
+        for offset in range(1, max_attempts):
+            port = preferred_port + offset
+            if port > 65535:
+                break
+            if InstrumentalReviewServer._is_port_available(host, port):
+                return port
+        
+        # Last resort: let the OS assign a port
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.bind((host, 0))
+            return sock.getsockname()[1]
+    
     def start_and_open_browser(self, port: int = 8765) -> str:
         """
         Start server, open browser, and block until selection is submitted.
         
         Args:
-            port: Port to run the server on
+            port: Preferred port to run the server on. If unavailable, will
+                  automatically find an available port.
             
         Returns:
             The user's selection ("clean", "with_backing", or "custom")
         """
         self._app = self._create_app()
         
+        # Find an available port (handles concurrent CLI instances)
+        host = "127.0.0.1"
+        actual_port = self._find_available_port(host, port)
+        if actual_port != port:
+            logger.info(f"Port {port} in use, using port {actual_port} instead")
+        
         # Run uvicorn in a separate thread
         config = uvicorn.Config(
             self._app,
-            host="127.0.0.1",
-            port=port,
+            host=host,
+            port=actual_port,
             log_level="warning",
         )
         server = uvicorn.Server(config)
@@ -389,7 +441,7 @@ class InstrumentalReviewServer:
         import time
         time.sleep(0.5)
         
-        url = f"http://localhost:{port}/"
+        url = f"http://localhost:{actual_port}/"
         logger.info(f"Instrumental review server started at {url}")
         
         # Open browser

{karaoke_gen-0.72.2 → karaoke_gen-0.75.2}/karaoke_gen/instrumental_review/static/index.html

@@ -1428,9 +1428,25 @@
                     <div class="success-screen">
                         <h2>✓ Selection Submitted</h2>
                         <p>You selected: <strong>${escapeHtml(selectionLabel)}</strong></p>
-                        <p style="color: var(--text-muted);">You can close this window now.</p>
+                        <p id="close-msg" style="color: var(--text-muted);">Closing in <span id="countdown">2</span>s...</p>
                     </div>
                 `;
+                
+                // Auto-close window after 2 seconds
+                let countdown = 2;
+                const countdownEl = document.getElementById('countdown');
+                const countdownInterval = setInterval(() => {
+                    countdown--;
+                    if (countdownEl) countdownEl.textContent = countdown;
+                    if (countdown <= 0) {
+                        clearInterval(countdownInterval);
+                        // Try to close the window (works for windows opened by script)
+                        window.close();
+                        // If window.close() didn't work, update message
+                        const msg = document.getElementById('close-msg');
+                        if (msg) msg.textContent = 'You can close this window now.';
+                    }
+                }, 1000);
             } catch (error) {
                 showError(error.message);
                 if (btn) {