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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karaoke-gen
-Version: 0.73.1
+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.73.1 → karaoke_gen-0.75.2}/karaoke_gen/audio_fetcher.py

@@ -270,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."""
@@ -280,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())
@@ -520,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}")
@@ -612,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.

{karaoke_gen-0.73.1 → 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.73.1 → 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) {

{karaoke_gen-0.73.1 → karaoke_gen-0.75.2}/karaoke_gen/utils/remote_cli.py

@@ -1331,6 +1331,54 @@ class JobMonitor:
         """Get user-friendly description for a status."""
         return self.STATUS_DESCRIPTIONS.get(status, status)
     
+    def _show_download_progress(self, job_data: Dict[str, Any]) -> None:
+        """Show detailed download progress during audio download."""
+        try:
+            # Get provider from job state_data
+            state_data = job_data.get('state_data', {})
+            provider = state_data.get('selected_audio_provider', 'unknown')
+            
+            # For non-torrent providers (YouTube), just show simple message
+            if provider.lower() == 'youtube':
+                self.logger.info(f"  [Downloading from YouTube...]")
+                return
+            
+            # Query health endpoint for transmission status (torrent providers)
+            health_url = f"{self.config.service_url}/api/health/detailed"
+            response = requests.get(health_url, timeout=5)
+            
+            if response.status_code == 200:
+                health = response.json()
+                transmission = health.get('dependencies', {}).get('transmission', {})
+                
+                if transmission.get('available'):
+                    torrents = transmission.get('torrents', [])
+                    if torrents:
+                        # Show info about active torrents
+                        for t in torrents:
+                            progress = t.get('progress', 0)
+                            peers = t.get('peers', 0)
+                            speed = t.get('download_speed', 0)
+                            stalled = t.get('stalled', False)
+                            
+                            if stalled:
+                                self.logger.info(f"  [Downloading from {provider}] {progress:.1f}% - STALLED (no peers)")
+                            elif progress < 100:
+                                self.logger.info(f"  [Downloading from {provider}] {progress:.1f}% @ {speed:.1f} KB/s ({peers} peers)")
+                            else:
+                                self.logger.info(f"  [Downloading from {provider}] Complete, processing...")
+                    else:
+                        # No torrents - might be starting or YouTube download
+                        self.logger.info(f"  [Downloading from {provider}] Starting download...")
+                else:
+                    self.logger.info(f"  [Downloading from {provider}] Transmission not available - download may fail")
+            else:
+                self.logger.info(f"  [Downloading from {provider}]...")
+                
+        except Exception as e:
+            # Fall back to simple message
+            self.logger.info(f"  [Downloading audio...]")
+    
     def open_browser(self, url: str) -> None:
         """Open URL in the default browser."""
         system = platform.system()
@@ -2067,9 +2115,15 @@ class JobMonitor:
                     self._polls_without_updates = 0
                 else:
                     self._polls_without_updates += 1
-                    if self._polls_without_updates >= self._heartbeat_interval:
-                        description = self._get_status_description(status)
-                        self.logger.info(f"  [Still processing: {description}]")
+                    # More frequent updates during audio download (every poll)
+                    heartbeat_threshold = 1 if status == 'downloading_audio' else self._heartbeat_interval
+                    if self._polls_without_updates >= heartbeat_threshold:
+                        if status == 'downloading_audio':
+                            # Show detailed download progress including transmission status
+                            self._show_download_progress(job_data)
+                        else:
+                            description = self._get_status_description(status)
+                            self.logger.info(f"  [Still processing: {description}]")
                         self._polls_without_updates = 0
                 
                 # Handle human interaction points

{karaoke_gen-0.73.1 → karaoke_gen-0.75.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "karaoke-gen"
-version = "0.73.1"
+version = "0.75.2"
 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"
@@ -57,6 +57,7 @@ syllables = ">=1"
 fonttools = ">=4.55"
 ollama = ">=0.4.7"
 shortuuid = ">=1.0.13"
+nest-asyncio = ">=1.5"
 openai = ">=1.63.2"
 langgraph = ">=0.2.0"
 langchain = ">=0.3.0"