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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karaoke-gen
-Version: 0.72.2
+Version: 0.73.1
 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

{karaoke_gen-0.72.2 → karaoke_gen-0.73.1}/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
         )
 
@@ -325,6 +354,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,
                 )
             )
@@ -632,41 +663,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.73.1}/karaoke_gen/utils/remote_cli.py

@@ -36,6 +36,8 @@ from typing import Any, Dict, Optional
 import requests
 
 from .cli_args import create_parser, process_style_overrides, is_url, is_file
+# Use flacfetch's shared display functions for consistent formatting
+from flacfetch import print_releases, Release
 
 
 class JobStatus(str, Enum):
@@ -1517,6 +1519,47 @@ class JobMonitor:
         except Exception as e:
             self.logger.error(f"Error submitting selection: {e}")
     
+    def _convert_api_result_to_release_dict(self, result: dict) -> dict:
+        """
+        Convert API search result to a dict compatible with flacfetch's Release.from_dict().
+        
+        This enables using flacfetch's shared display functions for consistent,
+        rich formatting between local and remote CLIs.
+        """
+        # Build quality dict from API response
+        quality_data = result.get('quality_data') or {
+            "format": "OTHER",
+            "media": "OTHER",
+        }
+        
+        return {
+            "title": result.get('title', ''),
+            "artist": result.get('artist', ''),
+            "source_name": result.get('provider', 'Unknown'),
+            "download_url": result.get('url'),
+            "info_hash": result.get('source_id'),
+            "size_bytes": result.get('size_bytes'),
+            "year": result.get('year'),
+            "edition_info": result.get('edition_info'),
+            "label": result.get('label'),
+            "release_type": result.get('release_type'),
+            "seeders": result.get('seeders'),
+            "channel": result.get('channel'),
+            "view_count": result.get('view_count'),
+            "duration_seconds": result.get('duration'),
+            "target_file": result.get('target_file'),
+            "target_file_size": result.get('target_file_size'),
+            "track_pattern": result.get('track_pattern'),
+            "match_score": result.get('match_score', 0.0),
+            "quality": quality_data,
+            # Pre-computed fields
+            "formatted_size": result.get('formatted_size'),
+            "formatted_duration": result.get('formatted_duration'),
+            "formatted_views": result.get('formatted_views'),
+            "is_lossless": result.get('is_lossless', False),
+            "quality_str": result.get('quality_str') or result.get('quality', ''),
+        }
+    
     def handle_audio_selection(self, job_id: str) -> None:
         """Handle audio source selection interaction (Batch 5)."""
         self.logger.info("=" * 60)
@@ -1527,6 +1570,7 @@ class JobMonitor:
             # Get search results
             results_data = self.client.get_audio_search_results(job_id)
             results = results_data.get('results', [])
+            artist = results_data.get('artist', 'Unknown')
             
             if not results:
                 self.logger.error("No search results available")
@@ -1537,42 +1581,27 @@ class JobMonitor:
                 self.logger.info("Non-interactive mode: Auto-selecting first result")
                 selection_index = 0
             else:
-                self.logger.info("")
-                self.logger.info("Choose which audio source to download:")
-                self.logger.info("")
+                # Convert API results to Release-compatible dicts for flacfetch display
+                # This gives us the same rich, colorized output as the local CLI
+                release_dicts = [self._convert_api_result_to_release_dict(r) for r in results]
                 
-                for result in results:
-                    index = result.get('index', 0)
-                    provider = result.get('provider', 'Unknown')
-                    artist = result.get('artist', 'Unknown')
-                    title = result.get('title', 'Unknown')
-                    quality = result.get('quality', '')
-                    duration = result.get('duration')
-                    
-                    # Format duration if available
-                    duration_str = ""
-                    if duration:
-                        minutes = duration // 60
-                        seconds = duration % 60
-                        duration_str = f" [{minutes}:{seconds:02d}]"
-                    
-                    quality_str = f" ({quality})" if quality else ""
-                    
-                    self.logger.info(f"  {index + 1}) [{provider}] {artist} - {title}{quality_str}{duration_str}")
-                
-                self.logger.info("")
+                # Use flacfetch's shared display function
+                print_releases(release_dicts, target_artist=artist, use_colors=True)
                 
                 selection_index = -1
                 while selection_index < 0:
                     try:
-                        choice = input(f"Enter your choice (1-{len(results)}): ").strip()
+                        choice = input(f"\nSelect a release (1-{len(results)}, 0 to cancel): ").strip()
+                        if choice == "0":
+                            self.logger.info("Selection cancelled by user")
+                            raise KeyboardInterrupt
                         choice_num = int(choice)
                         if 1 <= choice_num <= len(results):
                             selection_index = choice_num - 1
                         else:
-                            self.logger.error(f"Please enter a number between 1 and {len(results)}")
+                            print(f"Please enter a number between 0 and {len(results)}")
                     except ValueError:
-                        self.logger.error("Please enter a valid number")
+                        print("Please enter a valid number")
                     except KeyboardInterrupt:
                         print()
                         raise

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "karaoke-gen"
-version = "0.72.2"
+version = "0.73.1"
 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"