From fcee0194e718865c5cd04325291df5e0aca31207 Mon Sep 17 00:00:00 2001 From: Broque Thomas Date: Sun, 21 Sep 2025 21:02:12 -0700 Subject: [PATCH] navidrome functionality start --- core/database_update_worker.py | 269 +++++++- core/media_scan_manager.py | 20 +- core/navidrome_client.py | 774 +++++++++++++++++++++++ main.py | 23 +- ui/components/database_updater_widget.py | 9 +- ui/pages/dashboard.py | 10 +- ui/pages/settings.py | 76 ++- web_server.py | 20 +- webui/static/script.js | 13 +- 9 files changed, 1152 insertions(+), 62 deletions(-) create mode 100644 core/navidrome_client.py diff --git a/core/database_update_worker.py b/core/database_update_worker.py index 457c17bb..ca4e3c54 100644 --- a/core/database_update_worker.py +++ b/core/database_update_worker.py @@ -53,14 +53,17 @@ class DatabaseUpdateWorker(QThread): error = pyqtSignal(str) # error_message phase_changed = pyqtSignal(str) # current_phase (artists, albums, tracks) - def __init__(self, media_client, database_path: str = "database/music_library.db", full_refresh: bool = False, server_type: str = "plex"): + def __init__(self, media_client, database_path: str = "database/music_library.db", full_refresh: bool = False, server_type: str = "plex", force_sequential: bool = False): super().__init__() - + + # Force sequential processing for web server mode to avoid threading issues + self.force_sequential = force_sequential + # Initialize signal callbacks for headless mode if not QT_AVAILABLE: self.callbacks = { 'progress_updated': [], - 'artist_processed': [], + 'artist_processed': [], 'finished': [], 'error': [], 'phase_changed': [] @@ -93,12 +96,15 @@ class DatabaseUpdateWorker(QThread): database_config = config_manager.get('database', {}) base_max_workers = database_config.get('max_workers', 5) - # Optimize worker count - reduce for database concurrency safety + # Optimize worker count - reduce for database concurrency safety if self.server_type == "jellyfin": # Reduce workers to prevent database lock issues with bulk inserts self.max_workers = min(base_max_workers, 3) # Max 3 workers for database safety if base_max_workers > 3: logger.info(f"Reducing worker count from {base_max_workers} to {self.max_workers} for Jellyfin database safety") + elif self.server_type == "navidrome": + # Navidrome uses standard worker count like Plex + self.max_workers = base_max_workers else: # Plex uses standard worker count self.max_workers = base_max_workers @@ -128,32 +134,42 @@ class DatabaseUpdateWorker(QThread): """Stop the database update process""" self.should_stop = True - # Clear Jellyfin cache when user stops scan to free memory - if self.server_type == "jellyfin" and hasattr(self, 'media_client'): + # Clear media client cache when user stops scan to free memory + if self.server_type in ["jellyfin", "navidrome"] and hasattr(self, 'media_client'): try: - cache_stats = self.media_client.get_cache_stats() + if hasattr(self.media_client, 'get_cache_stats'): + cache_stats = self.media_client.get_cache_stats() + freed_items = cache_stats.get('bulk_albums_cached', 0) + cache_stats.get('bulk_tracks_cached', 0) + else: + freed_items = "unknown" self.media_client.clear_cache() - logger.info(f"๐Ÿงน Cleared Jellyfin cache after user stop - freed ~{cache_stats.get('bulk_albums_cached', 0) + cache_stats.get('bulk_tracks_cached', 0)} items from memory") + logger.info(f"๐Ÿงน Cleared {self.server_type} cache after user stop - freed ~{freed_items} items from memory") except Exception as e: - logger.warning(f"Could not clear Jellyfin cache on stop: {e}") + logger.warning(f"Could not clear {self.server_type} cache on stop: {e}") def run(self): """Main worker thread execution""" try: # Initialize database self.database = get_database(self.database_path) - + if self.full_refresh: logger.info(f"Performing full database refresh for {self.server_type} - clearing existing {self.server_type} data") self.database.clear_server_data(self.server_type) - + # Show cache preparation phase for Jellyfin and set up progress callback if self.server_type == "jellyfin": self._emit_signal('phase_changed', "Preparing Jellyfin cache for fast processing...") # Connect Jellyfin client progress to UI if hasattr(self.media_client, 'set_progress_callback'): self.media_client.set_progress_callback(lambda msg: self._emit_signal('phase_changed', msg)) - + elif self.server_type == "navidrome": + self._emit_signal('phase_changed', "Connecting to Navidrome server...") + # Connect Navidrome client progress to UI + if hasattr(self.media_client, 'set_progress_callback'): + self.media_client.set_progress_callback(lambda msg: self._emit_signal('phase_changed', msg)) + logger.info("โœ… Connected Navidrome progress callback") + # For full refresh, get all artists artists_to_process = self._get_all_artists() if not artists_to_process: @@ -173,12 +189,13 @@ class DatabaseUpdateWorker(QThread): # Phase 2: Process artists and their albums/tracks self._emit_signal('phase_changed', "Processing artists, albums, and tracks...") - + # FAST PATH: For Jellyfin track-based incremental, process new tracks directly if self.server_type == "jellyfin" and hasattr(self, '_jellyfin_new_tracks'): self._process_jellyfin_new_tracks_directly(artists_to_process) else: # Standard artist processing for Plex or full refresh + logger.info(f"๐ŸŽฏ About to process {len(artists_to_process) if artists_to_process else 0} artists for {self.server_type}") self._process_all_artists(artists_to_process) # Record full refresh completion for tracking purposes @@ -189,14 +206,18 @@ class DatabaseUpdateWorker(QThread): except Exception as e: logger.warning(f"Could not record full refresh completion: {e}") - # Clear Jellyfin cache after full refresh to free memory - if self.full_refresh and self.server_type == "jellyfin": + # Clear cache after full refresh to free memory + if self.full_refresh and self.server_type in ["jellyfin", "navidrome"]: try: - cache_stats = self.media_client.get_cache_stats() + if hasattr(self.media_client, 'get_cache_stats'): + cache_stats = self.media_client.get_cache_stats() + freed_items = cache_stats.get('bulk_albums_cached', 0) + cache_stats.get('bulk_tracks_cached', 0) + else: + freed_items = "cache data" self.media_client.clear_cache() - logger.info(f"๐Ÿงน Cleared Jellyfin cache after full refresh - freed ~{cache_stats.get('bulk_albums_cached', 0) + cache_stats.get('bulk_tracks_cached', 0)} items from memory") + logger.info(f"๐Ÿงน Cleared {self.server_type} cache after full refresh - freed ~{freed_items} items from memory") except Exception as e: - logger.warning(f"Could not clear Jellyfin cache: {e}") + logger.warning(f"Could not clear {self.server_type} cache: {e}") # Cleanup orphaned records after incremental updates (catches fixed matches) if not self.full_refresh and self.database: @@ -236,10 +257,12 @@ class DatabaseUpdateWorker(QThread): if not self.media_client.ensure_connection(): logger.error(f"Could not connect to {self.server_type} server") return [] - + + logger.info(f"๐ŸŽฏ _get_all_artists: Calling media_client.get_all_artists() for {self.server_type}") artists = self.media_client.get_all_artists() + logger.info(f"๐ŸŽฏ _get_all_artists: Received {len(artists) if artists else 0} artists from {self.server_type}") return artists - + except Exception as e: logger.error(f"Error getting artists from {self.server_type}: {e}") return [] @@ -288,11 +311,17 @@ class DatabaseUpdateWorker(QThread): if self.server_type == "jellyfin": if hasattr(self.media_client, 'set_progress_callback'): self.media_client.set_progress_callback(lambda msg: self._emit_signal('phase_changed', f"Incremental: {msg}")) + elif self.server_type == "navidrome": + # Navidrome doesn't need cache preparation for incremental updates + logger.info("Navidrome incremental update: no caching needed") # PERFORMANCE BREAKTHROUGH: For Jellyfin, use track-based incremental (much faster) if self.server_type == "jellyfin": return self._get_artists_for_jellyfin_track_incremental_update() - + elif self.server_type == "navidrome": + # Navidrome: simple approach - get all artists and check what's new in database + return self._get_artists_for_navidrome_incremental_update() + # Plex uses album-based approach (established and working) recent_albums = self._get_recent_albums_for_server() if not recent_albums: @@ -450,6 +479,107 @@ class DatabaseUpdateWorker(QThread): logger.error(f"Error in smart incremental update: {e}") # Fallback to empty list - user can try full refresh return [] + + def _get_artists_for_navidrome_incremental_update(self) -> List: + """Get artists for Navidrome incremental update using smart early-stopping logic like Plex/Jellyfin""" + try: + logger.info("๐ŸŽต Navidrome incremental: Getting recent albums and checking for new content...") + + # Get recent albums from Navidrome (use the generic method that calls Navidrome-specific logic) + recent_albums = self._get_recent_albums_for_server() + if not recent_albums: + logger.info("No recent albums found - nothing to process") + return [] + + logger.info(f"Found {len(recent_albums)} recent albums to check") + + # Sort albums by added date (newest first) - handle None dates properly + try: + def get_sort_date(album): + date_val = getattr(album, 'addedAt', None) + if date_val is None: + return 0 # Fallback for albums with no date + return date_val + + recent_albums.sort(key=get_sort_date, reverse=True) + logger.info("Sorted albums by recently added date (newest first)") + except Exception as e: + logger.warning(f"Could not sort albums by date: {e}") + + # Extract artists from recent albums with early stopping logic (same as Plex/Jellyfin) + artists_to_process = [] + processed_artist_ids = set() + consecutive_complete_albums = 0 + total_tracks_checked = 0 + + logger.info("Checking artists from recent albums (with early stopping)...") + + for i, album in enumerate(recent_albums): + if self.should_stop: + break + + try: + # Ensure this is actually an album object + if not hasattr(album, 'tracks'): + logger.warning(f"Skipping invalid album object at index {i}: {type(album).__name__}") + continue + + album_title = getattr(album, 'title', f'Album_{i}') + album_has_new_tracks = False + + # Check if album's tracks are already in database + try: + album_tracks = album.tracks() + total_tracks_checked += len(album_tracks) + + for track in album_tracks: + if not self.database.track_exists(track.ratingKey, self.server_type): + album_has_new_tracks = True + consecutive_complete_albums = 0 # Reset counter + break + + # If no new tracks found, increment consecutive complete counter + if not album_has_new_tracks: + consecutive_complete_albums += 1 + logger.debug(f"โœ… Album '{album_title}' is up-to-date (consecutive: {consecutive_complete_albums})") + + # Early stopping after 25 consecutive complete albums (same as Plex/Jellyfin) + if consecutive_complete_albums >= 25: + logger.info(f"๐Ÿ›‘ Found 25 consecutive complete albums - stopping incremental scan after checking {total_tracks_checked} tracks from {i+1} albums") + break + + except Exception as tracks_error: + logger.warning(f"Error getting tracks for album '{album_title}': {tracks_error}") + # Assume album needs processing if we can't check tracks + album_has_new_tracks = True + consecutive_complete_albums = 0 + + # If album has new tracks, queue its artist for processing + if album_has_new_tracks: + try: + album_artist = album.artist() + if album_artist: + artist_id = str(album_artist.ratingKey) + + # Skip if we've already queued this artist + if artist_id not in processed_artist_ids: + processed_artist_ids.add(artist_id) + artists_to_process.append(album_artist) + logger.info(f"โœ… Added artist '{album_artist.title}' for processing (from album '{album_title}' with new tracks)") + except Exception as artist_error: + logger.warning(f"Error getting artist for album '{album_title}': {artist_error}") + + except Exception as e: + logger.warning(f"Error processing album at index {i}: {e}") + consecutive_complete_albums = 0 # Reset on error + continue + + logger.info(f"๐ŸŽต Navidrome incremental complete: {len(artists_to_process)} artists need processing (checked {total_tracks_checked} tracks from {len(recent_albums)} recent albums)") + return artists_to_process + + except Exception as e: + logger.error(f"Error in Navidrome incremental update: {e}") + return [] def _get_artists_for_jellyfin_track_incremental_update(self) -> List: """FAST Jellyfin incremental update using recent tracks directly (no caching needed)""" @@ -694,6 +824,8 @@ class DatabaseUpdateWorker(QThread): return self._get_recent_albums_plex() elif self.server_type == "jellyfin": return self._get_recent_albums_jellyfin() + elif self.server_type == "navidrome": + return self._get_recent_albums_navidrome() else: logger.error(f"Unknown server type: {self.server_type}") return [] @@ -782,10 +914,62 @@ class DatabaseUpdateWorker(QThread): except Exception as e: logger.error(f"Error getting recent Jellyfin albums: {e}") return [] - + + def _get_recent_albums_navidrome(self) -> List: + """Get recently added albums from Navidrome using all albums sorted by date""" + try: + logger.info("Getting recent albums from Navidrome...") + + # Navidrome doesn't have a direct "recent albums" API like Plex/Jellyfin + # So we need to get all albums and sort them by date + all_artists = self.media_client.get_all_artists() + if not all_artists: + return [] + + all_albums = [] + # Get albums from a subset of artists to avoid too much data + # Take first 200 artists to get a reasonable sample of recent albums + sample_artists = all_artists[:200] + + for artist in sample_artists: + try: + artist_albums = self.media_client.get_albums_for_artist(artist.ratingKey) + all_albums.extend(artist_albums) + except Exception as e: + logger.warning(f"Error getting albums for artist {getattr(artist, 'title', 'Unknown')}: {e}") + continue + + if not all_albums: + return [] + + # Sort by addedAt date (newest first) and take recent ones + try: + def get_sort_date(album): + date_val = getattr(album, 'addedAt', None) + if date_val is None: + return 0 + return date_val + + all_albums.sort(key=get_sort_date, reverse=True) + # Take the most recent 400 albums for incremental checking + recent_albums = all_albums[:400] + + logger.info(f"Found {len(recent_albums)} recent albums from Navidrome (from {len(all_albums)} total)") + return recent_albums + + except Exception as e: + logger.warning(f"Error sorting Navidrome albums by date: {e}") + # If sorting fails, just return the first 400 albums + return all_albums[:400] + + except Exception as e: + logger.error(f"Error getting recent Navidrome albums: {e}") + return [] + def _process_all_artists(self, artists: List): """Process all artists and their albums/tracks using thread pool""" total_artists = len(artists) + logger.info(f"๐ŸŽฏ Processing {total_artists} artists with progress tracking") def process_single_artist(artist): """Process a single artist and return results""" @@ -806,6 +990,7 @@ class DatabaseUpdateWorker(QThread): total_artists, progress_percent ) + logger.debug(f"๐Ÿ”„ Progress: {self.processed_artists}/{total_artists} ({progress_percent:.1f}%) - {artist_name}") # Process the artist success, details, album_count, track_count = self._process_artist_with_content(artist) @@ -826,25 +1011,41 @@ class DatabaseUpdateWorker(QThread): logger.error(f"Error processing artist {getattr(artist, 'title', 'Unknown')}: {e}") return (getattr(artist, 'title', 'Unknown'), False, f"Error: {str(e)}", 0, 0) - # Process artists in parallel using ThreadPoolExecutor - with ThreadPoolExecutor(max_workers=self.max_workers) as executor: - # Submit all tasks - future_to_artist = {executor.submit(process_single_artist, artist): artist - for artist in artists} - - # Process completed tasks as they finish - for future in as_completed(future_to_artist): + # Process artists - use sequential processing in web server mode to avoid threading issues + if not QT_AVAILABLE or self.force_sequential: + # Sequential processing for web server mode + for i, artist in enumerate(artists): if self.should_stop: break - - result = future.result() + + result = process_single_artist(artist) if result is None: # Task was cancelled continue - + artist_name, success, details, album_count, track_count = result - + # Emit progress signal self._emit_signal('artist_processed', artist_name, success, details, album_count, track_count) + else: + # Process artists in parallel using ThreadPoolExecutor (Qt mode only) + with ThreadPoolExecutor(max_workers=self.max_workers) as executor: + # Submit all tasks + future_to_artist = {executor.submit(process_single_artist, artist): artist + for artist in artists} + + # Process completed tasks as they finish + for future in as_completed(future_to_artist): + if self.should_stop: + break + + result = future.result() + if result is None: # Task was cancelled + continue + + artist_name, success, details, album_count, track_count = result + + # Emit progress signal + self._emit_signal('artist_processed', artist_name, success, details, album_count, track_count) def _process_artist_with_content(self, media_artist) -> tuple[bool, str, int, int]: """Process an artist and all their albums and tracks with optimized API usage""" diff --git a/core/media_scan_manager.py b/core/media_scan_manager.py index 8a3f5dd7..16acb7d8 100644 --- a/core/media_scan_manager.py +++ b/core/media_scan_manager.py @@ -59,7 +59,8 @@ class MediaScanManager: # Try to find the main window from top-level widgets main_window = None for widget in app.topLevelWidgets(): - if hasattr(widget, 'plex_client') and hasattr(widget, 'jellyfin_client'): + if (hasattr(widget, 'plex_client') and hasattr(widget, 'jellyfin_client') and + hasattr(widget, 'navidrome_client')): main_window = widget break @@ -70,7 +71,13 @@ class MediaScanManager: return client, "jellyfin" else: logger.warning("Jellyfin client not connected, falling back to Plex") - + elif active_server == "navidrome": + client = getattr(main_window, 'navidrome_client', None) + if client and client.is_connected(): + return client, "navidrome" + else: + logger.warning("Navidrome client not connected, falling back to Plex") + # Default to Plex or fallback client = getattr(main_window, 'plex_client', None) if client and client.is_connected(): @@ -88,12 +95,17 @@ class MediaScanManager: # Headless mode - try to get clients from global instances import sys for module_name, module in sys.modules.items(): - if hasattr(module, 'plex_client') and hasattr(module, 'jellyfin_client'): + if (hasattr(module, 'plex_client') and hasattr(module, 'jellyfin_client') and + hasattr(module, 'navidrome_client')): if active_server == "jellyfin": client = getattr(module, 'jellyfin_client', None) if client and hasattr(client, 'is_connected') and client.is_connected(): return client, "jellyfin" - + elif active_server == "navidrome": + client = getattr(module, 'navidrome_client', None) + if client and hasattr(client, 'is_connected') and client.is_connected(): + return client, "navidrome" + client = getattr(module, 'plex_client', None) if client and hasattr(client, 'is_connected') and client.is_connected(): return client, "plex" diff --git a/core/navidrome_client.py b/core/navidrome_client.py new file mode 100644 index 00000000..aa55a67b --- /dev/null +++ b/core/navidrome_client.py @@ -0,0 +1,774 @@ +import requests +import hashlib +import secrets +from typing import List, Optional, Dict, Any +from dataclasses import dataclass +from datetime import datetime +import json +from utils.logging_config import get_logger +from config.settings import config_manager + +logger = get_logger("navidrome_client") + +@dataclass +class NavidromeTrackInfo: + id: str + title: str + artist: str + album: str + duration: int + track_number: Optional[int] = None + year: Optional[int] = None + rating: Optional[float] = None + +@dataclass +class NavidromePlaylistInfo: + id: str + title: str + description: Optional[str] + duration: int + leaf_count: int + tracks: List[NavidromeTrackInfo] + +class NavidromeArtist: + """Wrapper class to mimic Plex artist object interface""" + def __init__(self, navidrome_data: Dict[str, Any], client: 'NavidromeClient'): + self._data = navidrome_data + self._client = client + self.ratingKey = navidrome_data.get('id', '') + self.title = navidrome_data.get('name', 'Unknown Artist') + self.addedAt = self._parse_date(navidrome_data.get('dateAdded')) + + # Create genres property from Navidrome data + self.genres = [] + # TODO: Map Navidrome genre data to match Plex format + + # Create summary property (used for timestamp storage) + self.summary = navidrome_data.get('biography', '') or '' + + def _parse_date(self, date_str: Optional[str]) -> Optional[datetime]: + """Parse Navidrome date string to datetime""" + if not date_str: + return None + try: + # Navidrome uses ISO format + return datetime.fromisoformat(date_str.replace('Z', '+00:00')) + except: + return None + + def albums(self) -> List['NavidromeAlbum']: + """Get all albums for this artist""" + return self._client.get_albums_for_artist(self.ratingKey) + +class NavidromeAlbum: + """Wrapper class to mimic Plex album object interface""" + def __init__(self, navidrome_data: Dict[str, Any], client: 'NavidromeClient'): + self._data = navidrome_data + self._client = client + self.ratingKey = navidrome_data.get('id', '') + self.title = navidrome_data.get('name', 'Unknown Album') + self.year = navidrome_data.get('year') + self.addedAt = self._parse_date(navidrome_data.get('created')) + self._artist_id = navidrome_data.get('artistId', '') + + def _parse_date(self, date_str: Optional[str]) -> Optional[datetime]: + if not date_str: + return None + try: + return datetime.fromisoformat(date_str.replace('Z', '+00:00')) + except: + return None + + def artist(self) -> Optional[NavidromeArtist]: + """Get the album artist""" + if self._artist_id: + return self._client.get_artist_by_id(self._artist_id) + return None + + def tracks(self) -> List['NavidromeTrack']: + """Get all tracks for this album""" + return self._client.get_tracks_for_album(self.ratingKey) + +class NavidromeTrack: + """Wrapper class to mimic Plex track object interface""" + def __init__(self, navidrome_data: Dict[str, Any], client: 'NavidromeClient'): + self._data = navidrome_data + self._client = client + self.ratingKey = navidrome_data.get('id', '') + self.title = navidrome_data.get('title', 'Unknown Track') + self.duration = navidrome_data.get('duration', 0) * 1000 # Convert to milliseconds + self.trackNumber = navidrome_data.get('track') + self.year = navidrome_data.get('year') + self.userRating = navidrome_data.get('userRating') + self.addedAt = self._parse_date(navidrome_data.get('created')) + + self._album_id = navidrome_data.get('albumId', '') + self._artist_id = navidrome_data.get('artistId', '') + + def _parse_date(self, date_str: Optional[str]) -> Optional[datetime]: + if not date_str: + return None + try: + return datetime.fromisoformat(date_str.replace('Z', '+00:00')) + except: + return None + + def artist(self) -> Optional[NavidromeArtist]: + """Get the track artist""" + if self._artist_id: + return self._client.get_artist_by_id(self._artist_id) + return None + + def album(self) -> Optional[NavidromeAlbum]: + """Get the track's album""" + if self._album_id: + return self._client.get_album_by_id(self._album_id) + return None + +class NavidromeClient: + def __init__(self): + self.base_url: Optional[str] = None + self.username: Optional[str] = None + self.password: Optional[str] = None + self._connection_attempted = False + self._is_connecting = False + + # Cache for performance + self._artist_cache = {} + self._album_cache = {} + self._track_cache = {} + + # Progress callback for UI updates + self._progress_callback = None + + def set_progress_callback(self, callback): + """Set callback function for progress updates""" + self._progress_callback = callback + + def ensure_connection(self) -> bool: + """Ensure connection to Navidrome server with lazy initialization.""" + if self._connection_attempted: + return self.base_url is not None and self.username is not None + + if self._is_connecting: + return False + + self._is_connecting = True + try: + self._setup_client() + return self.base_url is not None and self.username is not None + finally: + self._is_connecting = False + self._connection_attempted = True + + def _setup_client(self): + """Setup Navidrome client configuration""" + config = config_manager.get_navidrome_config() + + if not config.get('base_url'): + logger.warning("Navidrome server URL not configured") + return + + if not config.get('username') or not config.get('password'): + logger.warning("Navidrome username/password not configured") + return + + self.base_url = config['base_url'].rstrip('/') + self.username = config['username'] + self.password = config['password'] + + try: + # Test connection with ping + response = self._make_request('ping') + if response and response.get('status') == 'ok': + server_version = response.get('version', 'Unknown') + logger.info(f"Successfully connected to Navidrome server version: {server_version}") + else: + logger.error("Failed to connect to Navidrome server") + self.base_url = None + self.username = None + self.password = None + + except Exception as e: + logger.error(f"Failed to connect to Navidrome server: {e}") + self.base_url = None + self.username = None + self.password = None + + def _generate_auth_params(self) -> Dict[str, str]: + """Generate authentication parameters for Subsonic API""" + if not self.username or not self.password: + return {} + + # Generate random salt (at least 6 characters) + salt = secrets.token_hex(8) + # Calculate token: md5(password + salt) + token = hashlib.md5((self.password + salt).encode()).hexdigest() + + return { + 'u': self.username, + 't': token, + 's': salt, + 'v': '1.16.1', # API version + 'c': 'SoulSync', # Client name + 'f': 'json' # Response format + } + + def _make_request(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]: + """Make authenticated request to Navidrome Subsonic API""" + if not self.base_url or not self.username: + return None + + url = f"{self.base_url}/rest/{endpoint}" + + # Add authentication parameters + auth_params = self._generate_auth_params() + if params: + auth_params.update(params) + + try: + response = requests.get(url, params=auth_params, timeout=10) + response.raise_for_status() + + data = response.json() + + # Check for Subsonic API errors + subsonic_response = data.get('subsonic-response', {}) + if subsonic_response.get('status') == 'failed': + error = subsonic_response.get('error', {}) + error_message = error.get('message', 'Unknown error') + logger.error(f"Navidrome API error: {error_message}") + return None + + return subsonic_response + + except requests.exceptions.RequestException as e: + logger.error(f"Navidrome API request failed: {e}") + return None + except json.JSONDecodeError as e: + logger.error(f"Failed to parse Navidrome response: {e}") + return None + + def is_connected(self) -> bool: + """Check if connected to Navidrome server""" + if not self._connection_attempted: + if not self._is_connecting: + self.ensure_connection() + return (self.base_url is not None and + self.username is not None and + self.password is not None) + + def get_all_artists(self) -> List[NavidromeArtist]: + """Get all artists from the music library""" + if not self.ensure_connection(): + logger.error("Not connected to Navidrome server") + return [] + + try: + if self._progress_callback: + self._progress_callback("Fetching artists from Navidrome...") + + response = self._make_request('getArtists') + if not response: + return [] + + if self._progress_callback: + self._progress_callback("Processing artist data...") + + artists = [] + indexes = response.get('artists', {}).get('index', []) + total_indexes = len(indexes) + + for i, index in enumerate(indexes): + if self._progress_callback and total_indexes > 1: + progress_pct = int((i / total_indexes) * 100) + self._progress_callback(f"Processing artist index {i+1}/{total_indexes} ({progress_pct}%)") + + for artist_data in index.get('artist', []): + artist = NavidromeArtist(artist_data, self) + # Cache the artist for quick lookup + self._artist_cache[artist.ratingKey] = artist + artists.append(artist) + + if self._progress_callback: + self._progress_callback(f"Retrieved {len(artists)} artists from Navidrome") + + logger.info(f"Retrieved {len(artists)} artists from Navidrome") + return artists + + except Exception as e: + logger.error(f"Error getting artists from Navidrome: {e}") + return [] + + def get_albums_for_artist(self, artist_id: str) -> List[NavidromeAlbum]: + """Get all albums for a specific artist""" + # Check cache first + if artist_id in self._album_cache: + return self._album_cache[artist_id] + + if not self.ensure_connection(): + return [] + + try: + # Get artist name for progress display + artist_name = "Unknown Artist" + if hasattr(self, '_artist_cache'): + for cached_artist in self._artist_cache.values(): + if getattr(cached_artist, 'ratingKey', None) == artist_id: + artist_name = getattr(cached_artist, 'title', 'Unknown Artist') + break + + if self._progress_callback: + self._progress_callback(f"Fetching albums for artist {artist_name}...") + + response = self._make_request('getArtist', {'id': artist_id}) + if not response: + return [] + + albums = [] + artist_data = response.get('artist', {}) + album_list = artist_data.get('album', []) + + if self._progress_callback and album_list: + self._progress_callback(f"Processing {len(album_list)} albums...") + + for album_data in album_list: + albums.append(NavidromeAlbum(album_data, self)) + + # Cache the result + self._album_cache[artist_id] = albums + + return albums + + except Exception as e: + logger.error(f"Error getting albums for artist {artist_id}: {e}") + return [] + + def get_tracks_for_album(self, album_id: str) -> List[NavidromeTrack]: + """Get all tracks for a specific album""" + # Check cache first + if album_id in self._track_cache: + return self._track_cache[album_id] + + if not self.ensure_connection(): + return [] + + try: + # Get album name for progress display + album_name = "Unknown Album" + if hasattr(self, '_album_cache'): + for artist_albums in self._album_cache.values(): + for cached_album in artist_albums: + if getattr(cached_album, 'ratingKey', None) == album_id: + album_name = getattr(cached_album, 'title', 'Unknown Album') + break + if album_name != "Unknown Album": + break + + if self._progress_callback: + self._progress_callback(f"Fetching tracks for album {album_name}...") + + response = self._make_request('getAlbum', {'id': album_id}) + if not response: + return [] + + tracks = [] + album_data = response.get('album', {}) + track_list = album_data.get('song', []) + + if self._progress_callback and track_list: + self._progress_callback(f"Processing {len(track_list)} tracks...") + + for track_data in track_list: + tracks.append(NavidromeTrack(track_data, self)) + + # Cache the result + self._track_cache[album_id] = tracks + + return tracks + + except Exception as e: + logger.error(f"Error getting tracks for album {album_id}: {e}") + return [] + + def get_artist_by_id(self, artist_id: str) -> Optional[NavidromeArtist]: + """Get a specific artist by ID""" + # Check cache first + if artist_id in self._artist_cache: + return self._artist_cache[artist_id] + + if not self.ensure_connection(): + return None + + try: + response = self._make_request('getArtist', {'id': artist_id}) + if response and 'artist' in response: + artist = NavidromeArtist(response['artist'], self) + # Cache for future use + self._artist_cache[artist_id] = artist + return artist + return None + + except Exception as e: + logger.error(f"Error getting artist {artist_id}: {e}") + return None + + def get_album_by_id(self, album_id: str) -> Optional[NavidromeAlbum]: + """Get a specific album by ID""" + if not self.ensure_connection(): + return None + + try: + response = self._make_request('getAlbum', {'id': album_id}) + if response and 'album' in response: + return NavidromeAlbum(response['album'], self) + return None + + except Exception as e: + logger.error(f"Error getting album {album_id}: {e}") + return None + + def get_library_stats(self) -> Dict[str, int]: + """Get library statistics""" + if not self.ensure_connection(): + return {} + + try: + # Get counts by making API calls + stats = {} + + # Get artist count + artists = self.get_all_artists() + stats['artists'] = len(artists) + + # For albums and tracks, we'd need to iterate through all artists + # This is expensive, so let's use reasonable estimates or make separate calls + # For now, return what we can efficiently get + stats['albums'] = 0 + stats['tracks'] = 0 + + # TODO: Implement more efficient counting if Navidrome provides bulk stats + + return stats + + except Exception as e: + logger.error(f"Error getting library stats: {e}") + return {} + + def get_all_playlists(self) -> List[NavidromePlaylistInfo]: + """Get all playlists from Navidrome server""" + if not self.ensure_connection(): + return [] + + try: + response = self._make_request('getPlaylists') + if not response: + return [] + + playlists = [] + playlists_data = response.get('playlists', {}).get('playlist', []) + + for playlist_data in playlists_data: + playlist_info = NavidromePlaylistInfo( + id=playlist_data.get('id', ''), + title=playlist_data.get('name', 'Unknown Playlist'), + description=playlist_data.get('comment'), + duration=playlist_data.get('duration', 0) * 1000, # Convert to milliseconds + leaf_count=playlist_data.get('songCount', 0), + tracks=[] # Will be populated when needed + ) + playlists.append(playlist_info) + + logger.info(f"Retrieved {len(playlists)} playlists from Navidrome") + return playlists + + except Exception as e: + logger.error(f"Error getting playlists from Navidrome: {e}") + return [] + + def get_playlist_by_name(self, name: str) -> Optional[NavidromePlaylistInfo]: + """Get a specific playlist by name""" + playlists = self.get_all_playlists() + for playlist in playlists: + if playlist.title.lower() == name.lower(): + return playlist + return None + + def create_playlist(self, name: str, tracks) -> bool: + """Create a new playlist with given tracks""" + if not self.ensure_connection(): + return False + + try: + # Convert tracks to Navidrome track IDs + track_ids = [] + for track in tracks: + if hasattr(track, 'ratingKey'): + track_ids.append(str(track.ratingKey)) + elif hasattr(track, 'id'): + track_ids.append(str(track.id)) + + if not track_ids: + logger.warning(f"No valid tracks provided for playlist '{name}'") + return False + + logger.info(f"Creating Navidrome playlist '{name}' with {len(track_ids)} tracks") + + # Create playlist with tracks + params = { + 'name': name, + 'songId': track_ids # Subsonic API accepts multiple songId parameters + } + + response = self._make_request('createPlaylist', params) + + if response and response.get('status') == 'ok': + logger.info(f"โœ… Created Navidrome playlist '{name}' with {len(track_ids)} tracks") + return True + else: + logger.error(f"Failed to create Navidrome playlist '{name}'") + return False + + except Exception as e: + logger.error(f"Error creating Navidrome playlist '{name}': {e}") + return False + + def copy_playlist(self, source_name: str, target_name: str) -> bool: + """Copy a playlist to create a backup""" + if not self.ensure_connection(): + return False + + try: + # Get the source playlist + source_playlist = self.get_playlist_by_name(source_name) + if not source_playlist: + logger.error(f"Source playlist '{source_name}' not found") + return False + + # Get tracks from source playlist + source_tracks = self.get_playlist_tracks(source_playlist.id) + logger.debug(f"Retrieved {len(source_tracks) if source_tracks else 0} tracks from source playlist") + + # Validate tracks + if not source_tracks: + logger.warning(f"Source playlist '{source_name}' has no tracks to copy") + return False + + # Delete target playlist if it exists (for overwriting backup) + try: + target_playlist = self.get_playlist_by_name(target_name) + if target_playlist: + self._make_request('deletePlaylist', {'id': target_playlist.id}) + logger.info(f"Deleted existing backup playlist '{target_name}'") + except Exception: + pass # Target doesn't exist, which is fine + + # Create new playlist with copied tracks + try: + success = self.create_playlist(target_name, source_tracks) + if success: + logger.info(f"โœ… Created backup playlist '{target_name}' with {len(source_tracks)} tracks") + return True + else: + logger.error(f"Failed to create backup playlist '{target_name}'") + return False + except Exception as create_error: + logger.error(f"Failed to create backup playlist: {create_error}") + return False + + except Exception as e: + logger.error(f"Error copying playlist '{source_name}' to '{target_name}': {e}") + return False + + def get_playlist_tracks(self, playlist_id: str) -> List[NavidromeTrack]: + """Get all tracks from a specific playlist""" + if not self.ensure_connection(): + return [] + + try: + response = self._make_request('getPlaylist', {'id': playlist_id}) + if not response: + return [] + + tracks = [] + playlist_data = response.get('playlist', {}) + + for track_data in playlist_data.get('entry', []): + tracks.append(NavidromeTrack(track_data, self)) + + logger.debug(f"Retrieved {len(tracks)} tracks from playlist {playlist_id}") + return tracks + + except Exception as e: + logger.error(f"Error getting tracks for playlist {playlist_id}: {e}") + return [] + + def update_playlist(self, playlist_name: str, tracks) -> bool: + """Update an existing playlist or create it if it doesn't exist""" + if not self.ensure_connection(): + return False + + try: + existing_playlist = self.get_playlist_by_name(playlist_name) + + # Check if backup is enabled in config + from config.settings import config_manager + create_backup = config_manager.get('playlist_sync.create_backup', True) + + if existing_playlist and create_backup: + backup_name = f"{playlist_name} Backup" + logger.info(f"๐Ÿ›ก๏ธ Creating backup playlist '{backup_name}' before sync") + + if self.copy_playlist(playlist_name, backup_name): + logger.info(f"โœ… Backup created successfully") + else: + logger.warning(f"โš ๏ธ Failed to create backup, continuing with sync") + + if existing_playlist: + # Delete existing playlist + response = self._make_request('deletePlaylist', {'id': existing_playlist.id}) + if response and response.get('status') == 'ok': + logger.info(f"Deleted existing Navidrome playlist '{playlist_name}'") + else: + logger.warning(f"Could not delete existing playlist '{playlist_name}', creating anyway") + + # Create new playlist with tracks + return self.create_playlist(playlist_name, tracks) + + except Exception as e: + logger.error(f"Error updating Navidrome playlist '{playlist_name}': {e}") + return False + + def trigger_library_scan(self, library_name: str = "Music") -> bool: + """Trigger Navidrome library scan - Navidrome doesn't have scanning, always returns True""" + logger.info(f"๐ŸŽต Navidrome doesn't require library scans - library is always current") + return True + + def is_library_scanning(self, library_name: str = "Music") -> bool: + """Check if Navidrome library is currently scanning - always returns False""" + return False + + # Metadata update methods for compatibility with metadata updater + def update_artist_genres(self, artist, genres: List[str]): + """Update artist genres - not implemented for Navidrome""" + try: + logger.debug(f"Genre update not implemented for Navidrome artist: {artist.title}") + return True + except Exception as e: + logger.error(f"Error updating genres for {artist.title}: {e}") + return False + + def update_artist_poster(self, artist, image_data: bytes): + """Update artist poster image - not implemented for Navidrome""" + try: + logger.debug(f"Poster update not implemented for Navidrome artist: {artist.title}") + return True + except Exception as e: + logger.error(f"Error updating poster for {artist.title}: {e}") + return False + + def update_album_poster(self, album, image_data: bytes): + """Update album poster image - not implemented for Navidrome""" + try: + logger.debug(f"Poster update not implemented for Navidrome album: {album.title}") + return True + except Exception as e: + logger.error(f"Error updating poster for album {album.title}: {e}") + return False + + def update_artist_biography(self, artist) -> bool: + """Update artist biography - not implemented for Navidrome""" + try: + logger.debug(f"Biography update not implemented for Navidrome artist: {artist.title}") + return True + except Exception as e: + logger.error(f"Error updating biography for {artist.title}: {e}") + return False + + def needs_update_by_age(self, artist, refresh_interval_days: int) -> bool: + """Check if artist needs updating based on age threshold - simplified for Navidrome""" + try: + # For now, just return True for all artists since we don't have timestamp tracking yet + return True + except Exception as e: + logger.debug(f"Error checking update age for {artist.title}: {e}") + return True + + def is_artist_ignored(self, artist) -> bool: + """Check if artist is manually marked to be ignored - simplified for Navidrome""" + try: + # For now, no artists are ignored + return False + except Exception as e: + logger.debug(f"Error checking ignore status for {artist.title}: {e}") + return False + + def parse_update_timestamp(self, artist) -> Optional[datetime]: + """Parse the last update timestamp from artist summary - not implemented for Navidrome""" + try: + return None + except Exception as e: + logger.debug(f"Error parsing timestamp for {artist.title}: {e}") + return None + + def get_cache_stats(self): + """Get cache statistics for debugging/logging""" + return { + 'artists_cached': len(self._artist_cache), + 'albums_cached': len(self._album_cache), + 'tracks_cached': len(self._track_cache), + 'bulk_albums_cached': len(self._album_cache), # For compatibility with Jellyfin interface + 'bulk_tracks_cached': len(self._track_cache) # For compatibility with Jellyfin interface + } + + def clear_cache(self): + """Clear all caches to force fresh data on next request""" + self._artist_cache.clear() + self._album_cache.clear() + self._track_cache.clear() + logger.info("Navidrome client cache cleared") + + def search_tracks(self, title: str, artist: str, limit: int = 15) -> List[NavidromeTrackInfo]: + """Search for tracks using Navidrome search API""" + if not self.ensure_connection(): + logger.warning("Navidrome not connected. Cannot perform search.") + return [] + + try: + # Use Subsonic search3 API for music search + query = f"{artist} {title}".strip() + response = self._make_request('search3', { + 'query': query, + 'songCount': limit, + 'artistCount': 0, + 'albumCount': 0 + }) + + if not response: + return [] + + tracks = [] + search_result = response.get('searchResult3', {}) + + for track_data in search_result.get('song', []): + track_info = NavidromeTrackInfo( + id=track_data.get('id', ''), + title=track_data.get('title', ''), + artist=track_data.get('artist', ''), + album=track_data.get('album', ''), + duration=track_data.get('duration', 0) * 1000, # Convert to milliseconds + track_number=track_data.get('track'), + year=track_data.get('year'), + rating=track_data.get('userRating') + ) + + # Store reference to original track for playlist creation + track_info._original_navidrome_track = NavidromeTrack(track_data, self) + tracks.append(track_info) + + logger.info(f"Found {len(tracks)} tracks for '{title}' by '{artist}'") + return tracks + + except Exception as e: + logger.error(f"Error searching for tracks: {e}") + return [] \ No newline at end of file diff --git a/main.py b/main.py index 5588fc15..1ea71bc9 100644 --- a/main.py +++ b/main.py @@ -14,6 +14,7 @@ from utils.logging_config import setup_logging, get_logger from core.spotify_client import SpotifyClient from core.plex_client import PlexClient from core.jellyfin_client import JellyfinClient +from core.navidrome_client import NavidromeClient from core.soulseek_client import SoulseekClient from ui.sidebar import ModernSidebar @@ -29,11 +30,12 @@ logger = get_logger("main") class ServiceStatusThread(QThread): status_updated = pyqtSignal(str, bool) - def __init__(self, spotify_client, plex_client, jellyfin_client, soulseek_client): + def __init__(self, spotify_client, plex_client, jellyfin_client, navidrome_client, soulseek_client): super().__init__() self.spotify_client = spotify_client self.plex_client = plex_client self.jellyfin_client = jellyfin_client + self.navidrome_client = navidrome_client self.soulseek_client = soulseek_client self.running = True @@ -57,6 +59,10 @@ class ServiceStatusThread(QThread): # Use the JellyfinClient for status checking jellyfin_status = self.jellyfin_client.is_connected() self.status_updated.emit("jellyfin", jellyfin_status) + elif active_server == "navidrome": + # Use the NavidromeClient for status checking + navidrome_status = self.navidrome_client.is_connected() + self.status_updated.emit("navidrome", navidrome_status) # Check Soulseek connection (simplified check to avoid event loop issues) soulseek_status = self.soulseek_client.is_configured() @@ -83,6 +89,7 @@ class MainWindow(QMainWindow): self.spotify_client = SpotifyClient() self.plex_client = PlexClient() self.jellyfin_client = JellyfinClient() + self.navidrome_client = NavidromeClient() self.soulseek_client = SoulseekClient() self.status_thread = None @@ -176,11 +183,12 @@ class MainWindow(QMainWindow): self.dashboard_page = DashboardPage() self.downloads_page = DownloadsPage(self.soulseek_client) self.sync_page = SyncPage( - spotify_client=self.spotify_client, - plex_client=self.plex_client, - soulseek_client=self.soulseek_client, - downloads_page=self.downloads_page, - jellyfin_client=self.jellyfin_client + spotify_client=self.spotify_client, + plex_client=self.plex_client, + soulseek_client=self.soulseek_client, + downloads_page=self.downloads_page, + jellyfin_client=self.jellyfin_client, + navidrome_client=self.navidrome_client ) self.artists_page = ArtistsPage(downloads_page=self.downloads_page) self.settings_page = SettingsPage() @@ -192,7 +200,7 @@ class MainWindow(QMainWindow): self.settings_page.set_toast_manager(self.toast_manager) # Configure dashboard with service clients and page references - self.dashboard_page.set_service_clients(self.spotify_client, self.plex_client, self.jellyfin_client, self.soulseek_client) + self.dashboard_page.set_service_clients(self.spotify_client, self.plex_client, self.jellyfin_client, self.navidrome_client, self.soulseek_client) self.dashboard_page.set_page_references(self.downloads_page, self.sync_page) self.dashboard_page.set_app_start_time(self.app_start_time) self.dashboard_page.set_toast_manager(self.toast_manager) @@ -240,6 +248,7 @@ class MainWindow(QMainWindow): self.spotify_client, self.plex_client, self.jellyfin_client, + self.navidrome_client, self.soulseek_client ) self.status_thread.status_updated.connect(self.update_service_status) diff --git a/ui/components/database_updater_widget.py b/ui/components/database_updater_widget.py index c6598694..63f0a51d 100644 --- a/ui/components/database_updater_widget.py +++ b/ui/components/database_updater_widget.py @@ -9,7 +9,7 @@ from utils.logging_config import get_logger logger = get_logger("database_updater_widget") class DatabaseUpdaterWidget(QFrame): - """UI widget for updating SoulSync database with Plex library data""" + """UI widget for updating SoulSync database with media server library data (Plex, Jellyfin, or Navidrome)""" def __init__(self, parent=None): super().__init__(parent) @@ -37,7 +37,12 @@ class DatabaseUpdaterWidget(QFrame): try: from config.settings import config_manager active_server = config_manager.get_active_media_server() - server_name = "Jellyfin" if active_server == "jellyfin" else "Plex" + if active_server == "jellyfin": + server_name = "Jellyfin" + elif active_server == "navidrome": + server_name = "Navidrome" + else: + server_name = "Plex" except: server_name = "Plex" # Fallback diff --git a/ui/pages/dashboard.py b/ui/pages/dashboard.py index b94f37e2..60741fc3 100644 --- a/ui/pages/dashboard.py +++ b/ui/pages/dashboard.py @@ -1960,11 +1960,12 @@ class DashboardDataProvider(QObject): self.system_stats_timer.timeout.connect(self.update_system_stats) self.system_stats_timer.start(10000) # Update every 10 seconds - def set_service_clients(self, spotify_client, plex_client, jellyfin_client, soulseek_client): + def set_service_clients(self, spotify_client, plex_client, jellyfin_client, navidrome_client, soulseek_client): self.service_clients = { 'spotify_client': spotify_client, 'plex_client': plex_client, 'jellyfin_client': jellyfin_client, + 'navidrome_client': navidrome_client, 'soulseek_client': soulseek_client } @@ -2712,15 +2713,16 @@ class DashboardPage(QWidget): self.wishlist_download_modal.process_finished.connect(self.on_wishlist_modal_finished) return True - def set_service_clients(self, spotify_client, plex_client, jellyfin_client, soulseek_client, downloads_page=None): + def set_service_clients(self, spotify_client, plex_client, jellyfin_client, navidrome_client, soulseek_client, downloads_page=None): """Called from main window to provide service client references""" - self.data_provider.set_service_clients(spotify_client, plex_client, jellyfin_client, soulseek_client) - + self.data_provider.set_service_clients(spotify_client, plex_client, jellyfin_client, navidrome_client, soulseek_client) + # Store service clients for wishlist modal self.service_clients = { 'spotify_client': spotify_client, 'plex_client': plex_client, 'jellyfin_client': jellyfin_client, + 'navidrome_client': navidrome_client, 'soulseek_client': soulseek_client, 'downloads_page': downloads_page } diff --git a/ui/pages/settings.py b/ui/pages/settings.py index 3d180bf5..a4fac5d7 100644 --- a/ui/pages/settings.py +++ b/ui/pages/settings.py @@ -454,6 +454,8 @@ class ServiceTestThread(QThread): success, message = self._test_plex() elif self.service_type == "jellyfin": success, message = self._test_jellyfin() + elif self.service_type == "navidrome": + success, message = self._test_navidrome() elif self.service_type == "soulseek": success, message = self._test_soulseek() else: @@ -644,7 +646,72 @@ class ServiceTestThread(QThread): return False, "โœ— Cannot connect to Jellyfin server.\nCheck your server URL and network." except Exception as e: return False, f"โœ— Jellyfin test failed:\n{str(e)}" - + + def _test_navidrome(self): + """Test Navidrome connection""" + try: + import requests + import hashlib + import secrets + + base_url = self.test_config['base_url'] + username = self.test_config['username'] + password = self.test_config['password'] + + if not base_url: + return False, "Please enter Navidrome server URL" + + if not username: + return False, "Please enter Navidrome username" + + if not password: + return False, "Please enter Navidrome password" + + # Clean URL - remove trailing slash + if base_url.endswith('/'): + base_url = base_url[:-1] + + # Generate authentication parameters for Subsonic API + salt = secrets.token_hex(8) + token = hashlib.md5((password + salt).encode()).hexdigest() + + # Test connection with ping endpoint + params = { + 'u': username, + 't': token, + 's': salt, + 'v': '1.16.1', + 'c': 'SoulSync', + 'f': 'json' + } + + test_url = f"{base_url}/rest/ping" + response = requests.get(test_url, params=params, timeout=10) + + if response.status_code == 200: + data = response.json() + subsonic_response = data.get('subsonic-response', {}) + + if subsonic_response.get('status') == 'ok': + version = subsonic_response.get('version', 'Unknown') + message = f"โœ“ Navidrome connection successful!\nSubsonic API Version: {version}" + return True, message + elif subsonic_response.get('status') == 'failed': + error = subsonic_response.get('error', {}) + error_message = error.get('message', 'Unknown error') + return False, f"โœ— Navidrome authentication failed:\n{error_message}" + else: + return False, "โœ— Unexpected response from Navidrome server" + else: + return False, f"โœ— Navidrome connection failed.\nHTTP {response.status_code}: {response.text}" + + except requests.exceptions.Timeout: + return False, "โœ— Navidrome connection timeout.\nCheck your server URL." + except requests.exceptions.ConnectionError: + return False, "โœ— Cannot connect to Navidrome server.\nCheck your server URL and network." + except Exception as e: + return False, f"โœ— Navidrome test failed:\n{str(e)}" + def _test_soulseek(self): """Test Soulseek connection""" try: @@ -1259,6 +1326,13 @@ class SettingsPage(QWidget): 'api_key': self.jellyfin_api_key_input.text() } self.start_service_test('jellyfin', test_config) + elif active_server == 'navidrome': + test_config = { + 'base_url': self.navidrome_url_input.text(), + 'username': self.navidrome_username_input.text(), + 'password': self.navidrome_password_input.text() + } + self.start_service_test('navidrome', test_config) else: logger.warning(f"Unknown active server type: {active_server}") diff --git a/web_server.py b/web_server.py index f424a964..76788a5e 100644 --- a/web_server.py +++ b/web_server.py @@ -23,6 +23,7 @@ from config.settings import config_manager from core.spotify_client import SpotifyClient, Playlist as SpotifyPlaylist, Track as SpotifyTrack from core.plex_client import PlexClient from core.jellyfin_client import JellyfinClient +from core.navidrome_client import NavidromeClient from core.soulseek_client import SoulseekClient from core.tidal_client import TidalClient # Added import for Tidal from core.matching_engine import MusicMatchingEngine @@ -95,6 +96,7 @@ try: spotify_client = SpotifyClient() plex_client = PlexClient() jellyfin_client = JellyfinClient() + navidrome_client = NavidromeClient() soulseek_client = SoulseekClient() tidal_client = TidalClient() matching_engine = MusicMatchingEngine() @@ -102,7 +104,7 @@ try: print("โœ… Core service clients initialized.") except Exception as e: print(f"๐Ÿ”ด FATAL: Error initializing service clients: {e}") - spotify_client = plex_client = jellyfin_client = soulseek_client = tidal_client = matching_engine = sync_service = None + spotify_client = plex_client = jellyfin_client = navidrome_client = soulseek_client = tidal_client = matching_engine = sync_service = None # --- Global Streaming State Management --- # Thread-safe state tracking for streaming functionality @@ -1490,10 +1492,8 @@ def get_status(): temp_jellyfin_client = JellyfinClient() media_server_status = temp_jellyfin_client.is_connected() elif active_server == "navidrome": - # Test Navidrome connection - navidrome_config = config_manager.get('navidrome', {}) - success, _ = run_service_test('navidrome', navidrome_config) - media_server_status = success + # Test Navidrome connection using existing client instance (non-destructive) + media_server_status = navidrome_client.is_connected() media_server_response_time = (time.time() - media_server_start) * 1000 # Test Soulseek (just check if configured, no network test) @@ -5589,6 +5589,7 @@ def _process_wishlist_automatically(): # =============================== def _db_update_progress_callback(current_item, processed, total, percentage): + print(f"๐Ÿ“Š [DB Progress] {current_item} - {processed}/{total} ({percentage:.1f}%)") with db_update_lock: db_update_state.update({ "current_item": current_item, @@ -5598,6 +5599,7 @@ def _db_update_progress_callback(current_item, processed, total, percentage): }) def _db_update_phase_callback(phase): + print(f"๐Ÿ”„ [DB Phase] {phase}") with db_update_lock: db_update_state["phase"] = phase @@ -5635,6 +5637,8 @@ def _run_db_update_task(full_refresh, server_type): media_client = plex_client elif server_type == "jellyfin": media_client = jellyfin_client + elif server_type == "navidrome": + media_client = navidrome_client if not media_client: _db_update_error_callback(f"Media client for '{server_type}' not available.") @@ -5644,7 +5648,8 @@ def _run_db_update_task(full_refresh, server_type): db_update_worker = DatabaseUpdateWorker( media_client=media_client, full_refresh=full_refresh, - server_type=server_type + server_type=server_type, + force_sequential=True # Force sequential processing in web server mode ) # Connect signals to callbacks (handle both Qt and headless modes) try: @@ -5908,6 +5913,9 @@ def start_database_update(): def get_database_update_status(): """Endpoint to poll for the current update status.""" with db_update_lock: + # Debug: Log current state occasionally + if db_update_state["status"] == "running": + print(f"๐Ÿ“Š [Status Check] {db_update_state['processed']}/{db_update_state['total']} ({db_update_state['progress']:.1f}%) - {db_update_state['phase']}") return jsonify(db_update_state) @app.route('/api/database/update/stop', methods=['POST']) diff --git a/webui/static/script.js b/webui/static/script.js index 8246df0f..15d9afad 100644 --- a/webui/static/script.js +++ b/webui/static/script.js @@ -6874,6 +6874,7 @@ function stopDbStatsPolling() { function stopDbUpdatePolling() { if (dbUpdateStatusInterval) { + console.log('โน๏ธ Stopping database update polling'); clearInterval(dbUpdateStatusInterval); dbUpdateStatusInterval = null; } @@ -7155,20 +7156,24 @@ async function checkForAutoInitiatedWishlistProcess() { async function checkAndUpdateDbProgress() { try { - const response = await fetch('/api/database/update/status'); + const response = await fetch('/api/database/update/status', { + signal: AbortSignal.timeout(10000) // 10 second timeout + }); if (!response.ok) return; const state = await response.json(); + console.debug('๐Ÿ“Š DB Status:', state.status, `${state.processed}/${state.total}`, `${state.progress.toFixed(1)}%`); updateDbProgressUI(state); - if (state.status === 'running') { - // If an update is running, start polling for progress - stopDbUpdatePolling(); + // Start polling only if not already polling and status is running + if (state.status === 'running' && !dbUpdateStatusInterval) { + console.log('๐Ÿ”„ Starting database update polling (1 second interval)'); dbUpdateStatusInterval = setInterval(checkAndUpdateDbProgress, 1000); } } catch (error) { console.warn('Could not fetch DB update status:', error); + // Don't stop polling on network errors - keep trying } }