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

karaoke_gen/audio_fetcher.py

@@ -264,6 +264,36 @@ class AudioFetcher(ABC):
         """
         pass
 
+    @abstractmethod
+    def download_from_url(
+        self,
+        url: str,
+        output_dir: str,
+        output_filename: Optional[str] = None,
+        artist: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> AudioFetchResult:
+        """
+        Download audio directly from a URL (e.g., YouTube URL).
+
+        This bypasses the search step and downloads directly from the provided URL.
+        Useful when the user provides a specific YouTube URL rather than artist/title.
+
+        Args:
+            url: The URL to download from (e.g., YouTube video URL)
+            output_dir: Directory to save the downloaded file
+            output_filename: Optional filename (without extension)
+            artist: Optional artist name for metadata
+            title: Optional title for metadata
+
+        Returns:
+            AudioFetchResult with the downloaded file path
+
+        Raises:
+            DownloadError: If download fails
+        """
+        pass
+
 
 class FlacFetchAudioFetcher(AudioFetcher):
     """
@@ -645,6 +675,94 @@ class FlacFetchAudioFetcher(AudioFetcher):
         except Exception as e:
             raise DownloadError(f"Failed to download {artist} - {title}: {e}") from e
 
+    def download_from_url(
+        self,
+        url: str,
+        output_dir: str,
+        output_filename: Optional[str] = None,
+        artist: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> AudioFetchResult:
+        """
+        Download audio directly from a URL (e.g., YouTube URL).
+
+        Uses flacfetch's download_by_id() method which supports direct YouTube downloads.
+
+        Args:
+            url: The URL to download from (e.g., YouTube video URL)
+            output_dir: Directory to save the downloaded file
+            output_filename: Optional filename (without extension)
+            artist: Optional artist name for metadata
+            title: Optional title for metadata
+
+        Returns:
+            AudioFetchResult with the downloaded file path
+
+        Raises:
+            DownloadError: If download fails
+        """
+        import re
+
+        manager = self._get_manager()
+
+        # Ensure output directory exists
+        os.makedirs(output_dir, exist_ok=True)
+
+        # Detect source type from URL
+        source_name = "YouTube"  # Default to YouTube for now
+        source_id = None
+
+        # Extract YouTube video ID from URL
+        youtube_patterns = [
+            r'(?:youtube\.com/watch\?v=|youtu\.be/)([a-zA-Z0-9_-]{11})',
+            r'youtube\.com/embed/([a-zA-Z0-9_-]{11})',
+            r'youtube\.com/v/([a-zA-Z0-9_-]{11})',
+        ]
+        for pattern in youtube_patterns:
+            match = re.search(pattern, url)
+            if match:
+                source_id = match.group(1)
+                break
+
+        if not source_id:
+            # For other URLs, use the full URL as the source_id
+            source_id = url
+
+        # Generate filename if not provided
+        if output_filename is None:
+            if artist and title:
+                output_filename = f"{artist} - {title}"
+            else:
+                output_filename = source_id
+
+        self.logger.info(f"Downloading from URL: {url}")
+
+        try:
+            filepath = manager.download_by_id(
+                source_name=source_name,
+                source_id=source_id,
+                output_path=output_dir,
+                output_filename=output_filename,
+                download_url=url,  # Pass full URL for direct download
+            )
+
+            if not filepath:
+                raise DownloadError(f"Download returned no file path for URL: {url}")
+
+            self.logger.info(f"Downloaded to: {filepath}")
+
+            return AudioFetchResult(
+                filepath=filepath,
+                artist=artist or "",
+                title=title or "",
+                provider=source_name,
+                duration=None,  # Could extract from yt-dlp info if needed
+                quality=None,
+            )
+
+        except Exception as e:
+            raise DownloadError(f"Failed to download from URL {url}: {e}") from e
+
     def _interruptible_search(self, manager, query) -> list:
         """
         Run search in a way that can be interrupted by Ctrl+C.
@@ -1548,6 +1666,106 @@ class RemoteFlacFetchAudioFetcher(AudioFetcher):
                 print("\nCancelled")
                 raise UserCancelledError("Selection cancelled by user (Ctrl+C)")
 
+    def download_from_url(
+        self,
+        url: str,
+        output_dir: str,
+        output_filename: Optional[str] = None,
+        artist: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> AudioFetchResult:
+        """
+        Download audio directly from a URL (e.g., YouTube URL).
+
+        For YouTube URLs, this uses local flacfetch since YouTube downloads
+        don't require the remote flacfetch infrastructure (no torrents).
+
+        Args:
+            url: The URL to download from (e.g., YouTube video URL)
+            output_dir: Directory to save the downloaded file
+            output_filename: Optional filename (without extension)
+            artist: Optional artist name for metadata
+            title: Optional title for metadata
+
+        Returns:
+            AudioFetchResult with the downloaded file path
+
+        Raises:
+            DownloadError: If download fails
+        """
+        import re
+
+        self.logger.info(f"[RemoteFlacFetcher] Downloading from URL: {url}")
+        self.logger.info("[RemoteFlacFetcher] Using local flacfetch for YouTube download (no remote API needed)")
+
+        try:
+            # Use local flacfetch for YouTube downloads - no need for remote API
+            # This avoids needing yt-dlp directly in karaoke-gen
+            from flacfetch.core.manager import FetchManager
+            from flacfetch.providers.youtube import YoutubeProvider
+            from flacfetch.downloaders.youtube import YoutubeDownloader
+
+            # Create a minimal local manager for YouTube downloads
+            manager = FetchManager()
+            manager.add_provider(YoutubeProvider())
+            manager.register_downloader("YouTube", YoutubeDownloader())
+
+            # Ensure output directory exists
+            os.makedirs(output_dir, exist_ok=True)
+
+            # Extract video ID from URL
+            source_id = None
+            youtube_patterns = [
+                r'(?:youtube\.com/watch\?v=|youtu\.be/)([a-zA-Z0-9_-]{11})',
+                r'youtube\.com/embed/([a-zA-Z0-9_-]{11})',
+                r'youtube\.com/v/([a-zA-Z0-9_-]{11})',
+            ]
+            for pattern in youtube_patterns:
+                match = re.search(pattern, url)
+                if match:
+                    source_id = match.group(1)
+                    break
+
+            if not source_id:
+                source_id = url
+
+            # Generate filename if not provided
+            if output_filename is None:
+                if artist and title:
+                    output_filename = f"{artist} - {title}"
+                else:
+                    output_filename = source_id
+
+            # Use flacfetch's download_by_id for direct URL download
+            filepath = manager.download_by_id(
+                source_name="YouTube",
+                source_id=source_id,
+                output_path=output_dir,
+                output_filename=output_filename,
+                download_url=url,
+            )
+
+            if not filepath:
+                raise DownloadError(f"Download returned no file path for URL: {url}")
+
+            self.logger.info(f"[RemoteFlacFetcher] Downloaded to: {filepath}")
+
+            return AudioFetchResult(
+                filepath=filepath,
+                artist=artist or "",
+                title=title or "",
+                provider="YouTube",
+                duration=None,
+                quality=None,
+            )
+
+        except ImportError as e:
+            raise DownloadError(
+                f"flacfetch is required for URL downloads but import failed: {e}"
+            ) from e
+        except Exception as e:
+            raise DownloadError(f"Failed to download from URL {url}: {e}") from e
+
 
 # Alias for shorter name
 RemoteFlacFetcher = RemoteFlacFetchAudioFetcher

karaoke_gen/instrumental_review/static/index.html

@@ -60,8 +60,16 @@
         .logo {
             font-size: 1.25rem;
             font-weight: 600;
+            display: inline-flex;
+            align-items: center;
+            gap: 8px;
         }
-        
+
+        .logo-img {
+            height: 40px;
+            width: auto;
+        }
+
         .track-info {
             font-size: 0.9rem;
             color: var(--text-muted);
@@ -568,6 +576,143 @@
             font-size: 1.5rem;
             color: var(--success);
         }
+
+        /* Mobile responsiveness */
+        @media (max-width: 768px) {
+            .app {
+                padding: 12px;
+                gap: 8px;
+                height: auto;
+                min-height: 100vh;
+                overflow-y: auto;
+            }
+
+            body {
+                overflow: auto;
+            }
+
+            .header {
+                flex-direction: column;
+                align-items: flex-start;
+                gap: 8px;
+            }
+
+            .header-left {
+                width: 100%;
+            }
+
+            .header-right {
+                width: 100%;
+                justify-content: flex-start;
+                flex-wrap: wrap;
+            }
+
+            .logo {
+                font-size: 1rem;
+            }
+
+            .logo-img {
+                height: 32px;
+            }
+
+            .waveform-player {
+                flex: none;
+                min-height: 200px;
+            }
+
+            .waveform-toolbar {
+                flex-wrap: wrap;
+                padding: 8px 12px;
+                gap: 8px;
+            }
+
+            .toolbar-left,
+            .toolbar-center,
+            .toolbar-right {
+                flex-wrap: wrap;
+            }
+
+            .audio-toggle-group {
+                order: 10;
+                width: 100%;
+                justify-content: center;
+            }
+
+            .bottom-section {
+                flex-direction: column;
+            }
+
+            .mute-panel {
+                max-height: none;
+            }
+
+            .selection-panel {
+                width: 100%;
+            }
+
+            .selection-option {
+                padding: 12px;
+            }
+
+            .btn {
+                min-height: 44px;
+                padding: 8px 12px;
+            }
+
+            .btn-icon {
+                width: 44px;
+                height: 44px;
+            }
+
+            .audio-toggle {
+                padding: 8px 12px;
+                min-height: 40px;
+            }
+
+            .zoom-btn {
+                width: 40px;
+                height: 40px;
+            }
+
+            .time-display {
+                font-size: 0.9rem;
+            }
+        }
+
+        @media (max-width: 480px) {
+            .app {
+                padding: 8px;
+            }
+
+            .header-left {
+                flex-wrap: wrap;
+            }
+
+            .track-info {
+                width: 100%;
+                margin-top: 4px;
+            }
+
+            .waveform-toolbar {
+                padding: 6px 8px;
+            }
+
+            .toolbar-center {
+                width: 100%;
+                justify-content: center;
+                order: -1;
+            }
+
+            .toolbar-left {
+                order: 1;
+            }
+
+            .toolbar-right {
+                order: 2;
+                width: 100%;
+                justify-content: space-between;
+            }
+        }
     </style>
 </head>
 <body>
@@ -641,7 +786,8 @@
                 
                 if (waveformRes.ok) {
                     waveformData = await waveformRes.json();
-                    duration = waveformData.duration;
+                    // API returns duration_seconds, not duration
+                    duration = waveformData.duration_seconds || 0;
                 }
                 
                 // Set initial selection based on recommendation
@@ -679,7 +825,7 @@
             app.innerHTML = `
                 <div class="header">
                     <div class="header-left">
-                        <span class="logo">🎤 Instrumental Review</span>
+                        <span class="logo"><img src="https://gen.nomadkaraoke.com/nomad-karaoke-logo.svg" alt="Nomad Karaoke" class="logo-img" onerror="this.style.display='none'"> Instrumental Review</span>
                         <span class="track-info">${escapeHtml(analysisData.artist) || ''} ${analysisData.artist && analysisData.title ? '–' : ''} ${escapeHtml(analysisData.title) || ''}</span>
                     </div>
                     <div class="header-right">
@@ -969,8 +1115,14 @@
             canvas.onmousedown = (e) => {
                 const rect = canvas.getBoundingClientRect();
                 const x = e.clientX - rect.left;
+
+                // Guard against invalid duration
+                if (!Number.isFinite(duration) || duration <= 0 || !Number.isFinite(rect.width) || rect.width <= 0) {
+                    return;
+                }
+
                 const time = (x / rect.width) * duration;
-                
+
                 // Shift+drag to select mute region
                 if (e.shiftKey) {
                     isDragging = true;
@@ -993,18 +1145,26 @@
             
             const endDrag = (e) => {
                 if (!isDragging) return;
-                
+
                 const rect = canvas.getBoundingClientRect();
                 const x = e.clientX - rect.left;
+
+                // Guard against invalid duration
+                if (!Number.isFinite(duration) || duration <= 0 || !Number.isFinite(rect.width) || rect.width <= 0) {
+                    isDragging = false;
+                    showSelectionOverlay(false);
+                    return;
+                }
+
                 const time = (x / rect.width) * duration;
-                
+
                 const start = Math.min(dragStartTime, time);
                 const end = Math.max(dragStartTime, time);
-                
+
                 if (end - start > 0.5) {
                     addRegion(start, end);
                 }
-                
+
                 isDragging = false;
                 showSelectionOverlay(false);
             };
@@ -1090,14 +1250,15 @@
         
         function seekTo(time, autoPlay = true) {
             const audio = document.getElementById('audio-player');
-            if (audio) {
-                audio.currentTime = time;
-                currentTime = time;
-                updatePlayhead();
-                // Auto-play when seeking via click (if not already playing)
-                if (autoPlay && !isPlaying) {
-                    audio.play();
-                }
+            // Guard against non-finite time values (NaN, Infinity)
+            if (!audio || !Number.isFinite(time)) return;
+
+            audio.currentTime = time;
+            currentTime = time;
+            updatePlayhead();
+            // Auto-play when seeking via click (if not already playing)
+            if (autoPlay && !isPlaying) {
+                audio.play();
             }
         }
         
@@ -1155,6 +1316,8 @@
         }
         
         function formatTime(seconds) {
+            // Guard against NaN/Infinity
+            if (!Number.isFinite(seconds)) return '0:00';
             const mins = Math.floor(seconds / 60);
             const secs = Math.floor(seconds % 60);
             return `${mins}:${secs.toString().padStart(2, '0')}`;