1420 lines
No EOL
57 KiB
Python
1420 lines
No EOL
57 KiB
Python
from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel,
|
|
QFrame, QGridLayout, QScrollArea, QSizePolicy, QPushButton,
|
|
QProgressBar, QTextEdit, QSpacerItem, QGroupBox, QFormLayout)
|
|
from PyQt6.QtCore import Qt, QTimer, QThread, pyqtSignal, QObject
|
|
from PyQt6.QtGui import QFont, QPalette, QColor
|
|
import time
|
|
import asyncio
|
|
import threading
|
|
from concurrent.futures import ThreadPoolExecutor, as_completed
|
|
try:
|
|
import resource
|
|
HAS_RESOURCE = True
|
|
except ImportError:
|
|
HAS_RESOURCE = False
|
|
import os
|
|
from typing import Optional, Dict, Any
|
|
from datetime import datetime
|
|
from dataclasses import dataclass
|
|
import requests
|
|
from PIL import Image
|
|
import io
|
|
from core.matching_engine import MusicMatchingEngine
|
|
|
|
class MetadataUpdateWorker(QThread):
|
|
"""Worker thread for updating Plex artist metadata using Spotify data"""
|
|
progress_updated = pyqtSignal(str, int, int, float) # current_artist, processed, total, percentage
|
|
artist_updated = pyqtSignal(str, bool, str) # artist_name, success, details
|
|
finished = pyqtSignal(int, int, int) # total_processed, successful, failed
|
|
error = pyqtSignal(str) # error_message
|
|
artists_loaded = pyqtSignal(int, int) # total_artists, artists_to_process
|
|
|
|
def __init__(self, artists, plex_client, spotify_client):
|
|
super().__init__()
|
|
self.artists = artists
|
|
self.plex_client = plex_client
|
|
self.spotify_client = spotify_client
|
|
self.matching_engine = MusicMatchingEngine()
|
|
self.should_stop = False
|
|
self.processed_count = 0
|
|
self.successful_count = 0
|
|
self.failed_count = 0
|
|
self.max_workers = 4 # Same as your previous implementation
|
|
self.thread_lock = threading.Lock()
|
|
|
|
def stop(self):
|
|
self.should_stop = True
|
|
|
|
def run(self):
|
|
"""Process all artists one by one"""
|
|
try:
|
|
# Load artists in background if not provided
|
|
if self.artists is None:
|
|
all_artists = self.plex_client.get_all_artists()
|
|
if not all_artists:
|
|
self.error.emit("No artists found in Plex library")
|
|
return
|
|
|
|
# Filter artists that need processing
|
|
artists_to_process = [artist for artist in all_artists if self.artist_needs_processing(artist)]
|
|
self.artists = artists_to_process
|
|
|
|
# Emit loaded signal
|
|
self.artists_loaded.emit(len(all_artists), len(artists_to_process))
|
|
|
|
if not artists_to_process:
|
|
self.finished.emit(0, 0, 0)
|
|
return
|
|
|
|
total_artists = len(self.artists)
|
|
|
|
# Process artists in parallel using ThreadPoolExecutor
|
|
def process_single_artist(artist):
|
|
"""Process a single artist and return results"""
|
|
if self.should_stop:
|
|
return None
|
|
|
|
artist_name = getattr(artist, 'title', 'Unknown Artist')
|
|
|
|
try:
|
|
success, details = self.update_artist_metadata(artist)
|
|
return (artist_name, success, details)
|
|
except Exception as e:
|
|
return (artist_name, False, f"Error: {str(e)}")
|
|
|
|
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 self.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 = result
|
|
|
|
with self.thread_lock:
|
|
self.processed_count += 1
|
|
if success:
|
|
self.successful_count += 1
|
|
else:
|
|
self.failed_count += 1
|
|
|
|
# Emit progress and result signals
|
|
progress_percent = (self.processed_count / total_artists) * 100
|
|
self.progress_updated.emit(artist_name, self.processed_count, total_artists, progress_percent)
|
|
self.artist_updated.emit(artist_name, success, details)
|
|
|
|
self.finished.emit(self.processed_count, self.successful_count, self.failed_count)
|
|
|
|
except Exception as e:
|
|
self.error.emit(f"Metadata update failed: {str(e)}")
|
|
|
|
def artist_needs_processing(self, artist):
|
|
"""Check if an artist needs metadata processing using smart detection"""
|
|
try:
|
|
# Check if artist has a valid photo
|
|
has_valid_photo = self.artist_has_valid_photo(artist)
|
|
|
|
# Check if artist has genres (more than just basic ones)
|
|
existing_genres = set(genre.tag if hasattr(genre, 'tag') else str(genre)
|
|
for genre in (artist.genres or []))
|
|
has_good_genres = len(existing_genres) >= 2 # At least 2 genres indicates Spotify processing
|
|
|
|
# Process if missing photo OR insufficient genres
|
|
return not has_valid_photo or not has_good_genres
|
|
|
|
except Exception as e:
|
|
print(f"Error checking artist {getattr(artist, 'title', 'Unknown')}: {e}")
|
|
return True # Process if we can't determine status
|
|
|
|
def update_artist_metadata(self, artist):
|
|
"""
|
|
Update a single artist's metadata by finding the best match on Spotify.
|
|
"""
|
|
try:
|
|
artist_name = getattr(artist, 'title', 'Unknown Artist')
|
|
|
|
# --- IMPROVED ARTIST MATCHING ---
|
|
# 1. Search for top 5 potential artists on Spotify
|
|
spotify_artists = self.spotify_client.search_artists(artist_name, limit=5)
|
|
if not spotify_artists:
|
|
return False, "Not found on Spotify"
|
|
|
|
# 2. Find the best match using the matching engine
|
|
best_match = None
|
|
highest_score = 0.0
|
|
|
|
plex_artist_normalized = self.matching_engine.normalize_string(artist_name)
|
|
|
|
for spotify_artist in spotify_artists:
|
|
spotify_artist_normalized = self.matching_engine.normalize_string(spotify_artist.name)
|
|
score = self.matching_engine.similarity_score(plex_artist_normalized, spotify_artist_normalized)
|
|
|
|
if score > highest_score:
|
|
highest_score = score
|
|
best_match = spotify_artist
|
|
|
|
# 3. If no suitable match is found, exit
|
|
if not best_match or highest_score < 0.7: # Confidence threshold
|
|
return False, f"No confident match found (best: '{getattr(best_match, 'name', 'N/A')}', score: {highest_score:.2f})"
|
|
|
|
spotify_artist = best_match
|
|
changes_made = []
|
|
|
|
# Update photo if needed
|
|
photo_updated = self.update_artist_photo(artist, spotify_artist)
|
|
if photo_updated:
|
|
changes_made.append("photo")
|
|
|
|
# Update genres
|
|
genres_updated = self.update_artist_genres(artist, spotify_artist)
|
|
if genres_updated:
|
|
changes_made.append("genres")
|
|
|
|
if changes_made:
|
|
details = f"Updated {', '.join(changes_made)} (match: '{spotify_artist.name}', score: {highest_score:.2f})"
|
|
return True, details
|
|
else:
|
|
return True, "Already up to date"
|
|
|
|
except Exception as e:
|
|
return False, str(e)
|
|
|
|
def update_artist_photo(self, artist, spotify_artist):
|
|
"""Update artist photo from Spotify"""
|
|
try:
|
|
# Check if artist already has a good photo
|
|
if self.artist_has_valid_photo(artist):
|
|
return False
|
|
|
|
# Get the image URL from Spotify
|
|
if not spotify_artist.image_url:
|
|
return False
|
|
|
|
image_url = spotify_artist.image_url
|
|
|
|
# Download and validate image
|
|
response = requests.get(image_url, timeout=10)
|
|
response.raise_for_status()
|
|
|
|
# Validate and convert image
|
|
image_data = self.validate_and_convert_image(response.content)
|
|
if not image_data:
|
|
return False
|
|
|
|
# Upload to Plex
|
|
return self.upload_artist_poster(artist, image_data)
|
|
|
|
except Exception as e:
|
|
print(f"Error updating photo for {getattr(artist, 'title', 'Unknown')}: {e}")
|
|
return False
|
|
|
|
def update_artist_genres(self, artist, spotify_artist):
|
|
"""Update artist genres from Spotify and albums"""
|
|
try:
|
|
# Get existing genres
|
|
existing_genres = set(genre.tag if hasattr(genre, 'tag') else str(genre)
|
|
for genre in (artist.genres or []))
|
|
|
|
# Get Spotify artist genres
|
|
spotify_genres = set(spotify_artist.genres or [])
|
|
|
|
# Get genres from all albums
|
|
album_genres = set()
|
|
try:
|
|
for album in artist.albums():
|
|
if hasattr(album, 'genres') and album.genres:
|
|
album_genres.update(genre.tag if hasattr(genre, 'tag') else str(genre)
|
|
for genre in album.genres)
|
|
except Exception:
|
|
pass # Albums might not be accessible
|
|
|
|
# Combine all genres (prioritize Spotify genres)
|
|
all_genres = spotify_genres.union(album_genres)
|
|
|
|
# Filter out empty/invalid genres
|
|
all_genres = {g for g in all_genres if g and g.strip() and len(g.strip()) > 1}
|
|
|
|
print(f"[DEBUG] Artist '{artist.title}': Existing={existing_genres}, Spotify={spotify_genres}, Albums={album_genres}, Combined={all_genres}")
|
|
|
|
# Only update if we have new genres and they're different
|
|
if all_genres and (not existing_genres or all_genres != existing_genres):
|
|
# Convert to list and limit to 10 genres
|
|
genre_list = list(all_genres)[:10]
|
|
|
|
print(f"[DEBUG] Updating genres for '{artist.title}' to: {genre_list}")
|
|
|
|
# Use Plex API to update genres
|
|
success = self.plex_client.update_artist_genres(artist, genre_list)
|
|
if success:
|
|
print(f"[DEBUG] Successfully updated genres for '{artist.title}'")
|
|
return True
|
|
else:
|
|
print(f"[DEBUG] Failed to update genres for '{artist.title}'")
|
|
return False
|
|
else:
|
|
print(f"[DEBUG] No genre update needed for '{artist.title}' - already has good genres")
|
|
return False
|
|
|
|
except Exception as e:
|
|
print(f"Error updating genres for {getattr(artist, 'title', 'Unknown')}: {e}")
|
|
return False
|
|
|
|
def artist_has_valid_photo(self, artist):
|
|
"""Check if artist has a valid photo"""
|
|
try:
|
|
if not hasattr(artist, 'thumb') or not artist.thumb:
|
|
return False
|
|
|
|
thumb_url = str(artist.thumb)
|
|
if 'default' in thumb_url.lower() or len(thumb_url) < 50:
|
|
return False
|
|
|
|
return True
|
|
|
|
except Exception:
|
|
return False
|
|
|
|
def validate_and_convert_image(self, image_data):
|
|
"""Validate and convert image for Plex compatibility"""
|
|
try:
|
|
# Open and validate image
|
|
image = Image.open(io.BytesIO(image_data))
|
|
|
|
# Check minimum dimensions
|
|
width, height = image.size
|
|
if width < 200 or height < 200:
|
|
return None
|
|
|
|
# Convert to JPEG for consistency
|
|
if image.format != 'JPEG':
|
|
buffer = io.BytesIO()
|
|
image.convert('RGB').save(buffer, format='JPEG', quality=95)
|
|
return buffer.getvalue()
|
|
|
|
return image_data
|
|
|
|
except Exception:
|
|
return None
|
|
|
|
def upload_artist_poster(self, artist, image_data):
|
|
"""Upload poster to Plex"""
|
|
try:
|
|
# Use Plex client's update method if available
|
|
if hasattr(self.plex_client, 'update_artist_poster'):
|
|
return self.plex_client.update_artist_poster(artist, image_data)
|
|
|
|
# Fallback: direct Plex API call
|
|
server = self.plex_client.server
|
|
upload_url = f"{server._baseurl}/library/metadata/{artist.ratingKey}/posters"
|
|
headers = {
|
|
'X-Plex-Token': server._token,
|
|
'Content-Type': 'image/jpeg'
|
|
}
|
|
|
|
response = requests.post(upload_url, data=image_data, headers=headers)
|
|
response.raise_for_status()
|
|
|
|
# Refresh artist to see changes
|
|
artist.refresh()
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"Error uploading poster: {e}")
|
|
return False
|
|
|
|
@dataclass
|
|
class ServiceStatus:
|
|
name: str
|
|
connected: bool
|
|
last_check: datetime
|
|
response_time: float = 0.0
|
|
error: Optional[str] = None
|
|
|
|
@dataclass
|
|
class DownloadStats:
|
|
active_count: int = 0
|
|
finished_count: int = 0
|
|
total_speed: float = 0.0
|
|
total_transferred: int = 0
|
|
|
|
@dataclass
|
|
class MetadataProgress:
|
|
is_running: bool = False
|
|
current_artist: str = ""
|
|
processed_count: int = 0
|
|
total_count: int = 0
|
|
progress_percentage: float = 0.0
|
|
|
|
class DashboardDataProvider(QObject):
|
|
# Signals for real-time updates
|
|
service_status_updated = pyqtSignal(str, bool, float, str) # service, connected, response_time, error
|
|
download_stats_updated = pyqtSignal(int, int, float) # active, finished, speed
|
|
metadata_progress_updated = pyqtSignal(bool, str, int, int, float) # running, artist, processed, total, percentage
|
|
sync_progress_updated = pyqtSignal(str, int) # current_playlist, progress
|
|
system_stats_updated = pyqtSignal(str, str) # uptime, memory
|
|
activity_item_added = pyqtSignal(str, str, str, str) # icon, title, subtitle, time
|
|
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent)
|
|
self.service_clients = {}
|
|
self.downloads_page = None
|
|
self.sync_page = None
|
|
self.app_start_time = None
|
|
|
|
# Data storage
|
|
self.service_status = {
|
|
'spotify': ServiceStatus('Spotify', False, datetime.now()),
|
|
'plex': ServiceStatus('Plex', False, datetime.now()),
|
|
'soulseek': ServiceStatus('Soulseek', False, datetime.now())
|
|
}
|
|
self.download_stats = DownloadStats()
|
|
self.metadata_progress = MetadataProgress()
|
|
|
|
# Session-based counters (reset on app restart)
|
|
self.session_completed_downloads = 0
|
|
|
|
# Update timers with different frequencies
|
|
self.download_stats_timer = QTimer()
|
|
self.download_stats_timer.timeout.connect(self.update_download_stats)
|
|
self.download_stats_timer.start(2000) # Update every 2 seconds
|
|
|
|
self.system_stats_timer = QTimer()
|
|
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, soulseek_client):
|
|
self.service_clients = {
|
|
'spotify': spotify_client,
|
|
'plex': plex_client,
|
|
'soulseek': soulseek_client
|
|
}
|
|
|
|
def set_page_references(self, downloads_page, sync_page):
|
|
self.downloads_page = downloads_page
|
|
self.sync_page = sync_page
|
|
|
|
def set_app_start_time(self, start_time):
|
|
self.app_start_time = start_time
|
|
|
|
def increment_completed_downloads(self, title="Unknown Track", artist="Unknown Artist"):
|
|
"""Increment the session completed downloads counter"""
|
|
self.session_completed_downloads += 1
|
|
|
|
# Emit signal for activity feed with specific track info
|
|
self.activity_item_added.emit("📥", "Download Complete", f"'{title}' by {artist}", "Now")
|
|
|
|
def update_service_status(self, service: str, connected: bool, response_time: float = 0.0, error: str = ""):
|
|
if service in self.service_status:
|
|
self.service_status[service].connected = connected
|
|
self.service_status[service].last_check = datetime.now()
|
|
self.service_status[service].response_time = response_time
|
|
self.service_status[service].error = error
|
|
self.service_status_updated.emit(service, connected, response_time, error)
|
|
|
|
def update_download_stats(self):
|
|
if self.downloads_page and hasattr(self.downloads_page, 'download_queue'):
|
|
try:
|
|
active_count = len(self.downloads_page.download_queue.active_queue.download_items)
|
|
finished_count = len(self.downloads_page.download_queue.finished_queue.download_items)
|
|
|
|
# Calculate total speed from active downloads (in bytes/sec)
|
|
total_speed = 0.0
|
|
for item in self.downloads_page.download_queue.active_queue.download_items:
|
|
if hasattr(item, 'download_speed') and isinstance(item.download_speed, (int, float)) and item.download_speed > 0:
|
|
# download_speed is already in bytes/sec from slskd API
|
|
total_speed += float(item.download_speed)
|
|
|
|
self.download_stats.active_count = active_count
|
|
self.download_stats.finished_count = self.session_completed_downloads # Use session counter
|
|
self.download_stats.total_speed = total_speed
|
|
|
|
self.download_stats_updated.emit(active_count, self.session_completed_downloads, total_speed)
|
|
except Exception as e:
|
|
pass # Silent failure for stats updates
|
|
|
|
# Update sync stats
|
|
if self.sync_page and hasattr(self.sync_page, 'active_sync_workers'):
|
|
try:
|
|
active_syncs = len(self.sync_page.active_sync_workers)
|
|
self.sync_progress_updated.emit("", active_syncs)
|
|
except Exception as e:
|
|
pass # Silent failure for stats updates
|
|
|
|
def update_system_stats(self):
|
|
"""Update system statistics (uptime and memory)"""
|
|
try:
|
|
uptime_str = self.get_uptime_string()
|
|
memory_str = self.get_memory_usage()
|
|
self.system_stats_updated.emit(uptime_str, memory_str)
|
|
except Exception as e:
|
|
pass
|
|
|
|
def get_uptime_string(self):
|
|
"""Get formatted uptime string"""
|
|
if not self.app_start_time:
|
|
return "Unknown"
|
|
|
|
try:
|
|
uptime_seconds = time.time() - self.app_start_time
|
|
|
|
if uptime_seconds < 60:
|
|
return f"{int(uptime_seconds)}s"
|
|
elif uptime_seconds < 3600:
|
|
minutes = int(uptime_seconds / 60)
|
|
return f"{minutes}m"
|
|
elif uptime_seconds < 86400:
|
|
hours = int(uptime_seconds / 3600)
|
|
minutes = int((uptime_seconds % 3600) / 60)
|
|
return f"{hours}h {minutes}m"
|
|
else:
|
|
days = int(uptime_seconds / 86400)
|
|
hours = int((uptime_seconds % 86400) / 3600)
|
|
return f"{days}d {hours}h"
|
|
except Exception:
|
|
return "Unknown"
|
|
|
|
def get_memory_usage(self):
|
|
"""Get formatted memory usage string"""
|
|
try:
|
|
# Try using resource module first (Unix-like systems)
|
|
if HAS_RESOURCE and hasattr(resource, 'RUSAGE_SELF'):
|
|
usage = resource.getrusage(resource.RUSAGE_SELF)
|
|
# ru_maxrss is in KB on Linux, bytes on macOS
|
|
max_rss = usage.ru_maxrss
|
|
|
|
# Detect platform and convert accordingly
|
|
import platform
|
|
if platform.system() == 'Darwin': # macOS
|
|
memory_mb = max_rss / (1024 * 1024)
|
|
else: # Linux
|
|
memory_mb = max_rss / 1024
|
|
|
|
return f"~{memory_mb:.0f} MB"
|
|
|
|
# Windows fallback: try psutil if available
|
|
try:
|
|
import psutil
|
|
process = psutil.Process(os.getpid())
|
|
memory_mb = process.memory_info().rss / (1024 * 1024)
|
|
return f"~{memory_mb:.0f} MB"
|
|
except ImportError:
|
|
pass
|
|
|
|
# Linux fallback: try reading /proc/self/status
|
|
if os.path.exists('/proc/self/status'):
|
|
with open('/proc/self/status', 'r') as f:
|
|
for line in f:
|
|
if line.startswith('VmRSS:'):
|
|
kb = int(line.split()[1])
|
|
return f"~{kb / 1024:.0f} MB"
|
|
|
|
return "N/A"
|
|
except Exception:
|
|
return "N/A"
|
|
|
|
def test_service_connection(self, service: str):
|
|
"""Test connection to a specific service"""
|
|
print(f"DEBUG: Testing {service} connection")
|
|
print(f"DEBUG: Available service clients: {list(self.service_clients.keys())}")
|
|
|
|
if service not in self.service_clients:
|
|
print(f"DEBUG: Service {service} not found in service_clients")
|
|
return
|
|
|
|
print(f"DEBUG: Service client for {service}: {self.service_clients[service]}")
|
|
|
|
# Clean up any existing test thread for this service
|
|
if hasattr(self, '_test_threads') and service in self._test_threads:
|
|
old_thread = self._test_threads[service]
|
|
if old_thread.isRunning():
|
|
old_thread.quit()
|
|
old_thread.wait()
|
|
old_thread.deleteLater()
|
|
|
|
# Initialize test threads dict if needed
|
|
if not hasattr(self, '_test_threads'):
|
|
self._test_threads = {}
|
|
|
|
# Run connection test in background thread
|
|
test_thread = ServiceTestThread(service, self.service_clients[service])
|
|
test_thread.test_completed.connect(self.on_service_test_completed)
|
|
test_thread.finished.connect(lambda: self._cleanup_test_thread(service))
|
|
self._test_threads[service] = test_thread
|
|
print(f"DEBUG: Starting test thread for {service}")
|
|
test_thread.start()
|
|
|
|
def _cleanup_test_thread(self, service: str):
|
|
"""Clean up completed test thread"""
|
|
if hasattr(self, '_test_threads') and service in self._test_threads:
|
|
thread = self._test_threads[service]
|
|
if thread.isRunning():
|
|
thread.quit()
|
|
thread.wait(1000) # Wait up to 1 second
|
|
thread.deleteLater()
|
|
del self._test_threads[service]
|
|
|
|
def on_service_test_completed(self, service: str, connected: bool, response_time: float, error: str):
|
|
self.update_service_status(service, connected, response_time, error)
|
|
|
|
class ServiceTestThread(QThread):
|
|
test_completed = pyqtSignal(str, bool, float, str) # service, connected, response_time, error
|
|
|
|
def __init__(self, service: str, client, parent=None):
|
|
super().__init__(parent)
|
|
self.service = service
|
|
self.client = client
|
|
|
|
def run(self):
|
|
start_time = time.time()
|
|
connected = False
|
|
error = ""
|
|
|
|
try:
|
|
if self.service == 'spotify':
|
|
connected = self.client.is_authenticated()
|
|
elif self.service == 'plex':
|
|
connected = self.client.is_connected()
|
|
elif self.service == 'soulseek':
|
|
# Run async method in new event loop
|
|
loop = asyncio.new_event_loop()
|
|
asyncio.set_event_loop(loop)
|
|
try:
|
|
connected = loop.run_until_complete(self.client.check_connection())
|
|
finally:
|
|
loop.close()
|
|
except Exception as e:
|
|
error = str(e)
|
|
connected = False
|
|
|
|
response_time = (time.time() - start_time) * 1000 # Convert to milliseconds
|
|
self.test_completed.emit(self.service, connected, response_time, error)
|
|
|
|
# Ensure thread finishes properly
|
|
self.quit()
|
|
|
|
class StatCard(QFrame):
|
|
def __init__(self, title: str, value: str, subtitle: str = "", clickable: bool = False, parent=None):
|
|
super().__init__(parent)
|
|
self.clickable = clickable
|
|
self.title_text = title
|
|
self.setup_ui(title, value, subtitle)
|
|
|
|
def setup_ui(self, title: str, value: str, subtitle: str):
|
|
self.setFixedHeight(120)
|
|
hover_style = "border: 1px solid #1db954;" if self.clickable else ""
|
|
self.setStyleSheet(f"""
|
|
StatCard {{
|
|
background: #282828;
|
|
border-radius: 8px;
|
|
border: 1px solid #404040;
|
|
}}
|
|
StatCard:hover {{
|
|
background: #333333;
|
|
{hover_style}
|
|
}}
|
|
""")
|
|
|
|
layout = QVBoxLayout(self)
|
|
layout.setContentsMargins(20, 15, 20, 15)
|
|
layout.setSpacing(5)
|
|
|
|
# Title
|
|
self.title_label = QLabel(title)
|
|
self.title_label.setFont(QFont("Arial", 10))
|
|
self.title_label.setStyleSheet("color: #b3b3b3;")
|
|
|
|
# Value
|
|
self.value_label = QLabel(value)
|
|
self.value_label.setFont(QFont("Arial", 24, QFont.Weight.Bold))
|
|
self.value_label.setStyleSheet("color: #ffffff;")
|
|
|
|
# Subtitle
|
|
self.subtitle_label = None
|
|
if subtitle:
|
|
self.subtitle_label = QLabel(subtitle)
|
|
self.subtitle_label.setFont(QFont("Arial", 9))
|
|
self.subtitle_label.setStyleSheet("color: #b3b3b3;")
|
|
layout.addWidget(self.subtitle_label)
|
|
|
|
layout.addWidget(self.title_label)
|
|
layout.addWidget(self.value_label)
|
|
layout.addStretch()
|
|
|
|
def update_values(self, value: str, subtitle: str = ""):
|
|
self.value_label.setText(value)
|
|
if self.subtitle_label and subtitle:
|
|
self.subtitle_label.setText(subtitle)
|
|
|
|
def mousePressEvent(self, event):
|
|
if self.clickable:
|
|
self.parent().on_stat_card_clicked(self.title_text)
|
|
super().mousePressEvent(event)
|
|
|
|
class ServiceStatusCard(QFrame):
|
|
def __init__(self, service_name: str, parent=None):
|
|
super().__init__(parent)
|
|
self.service_name = service_name
|
|
self.setup_ui()
|
|
|
|
def setup_ui(self):
|
|
self.setFixedHeight(140)
|
|
self.setStyleSheet("""
|
|
ServiceStatusCard {
|
|
background: #282828;
|
|
border-radius: 8px;
|
|
border: 1px solid #404040;
|
|
}
|
|
ServiceStatusCard:hover {
|
|
background: #333333;
|
|
}
|
|
""")
|
|
|
|
layout = QVBoxLayout(self)
|
|
layout.setContentsMargins(15, 12, 15, 12)
|
|
layout.setSpacing(8)
|
|
|
|
# Header with service name and status indicator
|
|
header_layout = QHBoxLayout()
|
|
header_layout.setSpacing(10)
|
|
|
|
self.service_label = QLabel(self.service_name)
|
|
self.service_label.setFont(QFont("Arial", 12, QFont.Weight.Bold))
|
|
self.service_label.setStyleSheet("color: #ffffff;")
|
|
|
|
self.status_indicator = QLabel("●")
|
|
self.status_indicator.setFont(QFont("Arial", 16))
|
|
self.status_indicator.setStyleSheet("color: #ff4444;") # Red by default
|
|
|
|
header_layout.addWidget(self.service_label)
|
|
header_layout.addStretch()
|
|
header_layout.addWidget(self.status_indicator)
|
|
|
|
# Status details
|
|
self.status_text = QLabel("Disconnected")
|
|
self.status_text.setFont(QFont("Arial", 9))
|
|
self.status_text.setStyleSheet("color: #b3b3b3;")
|
|
|
|
self.response_time_label = QLabel("Response: --")
|
|
self.response_time_label.setFont(QFont("Arial", 8))
|
|
self.response_time_label.setStyleSheet("color: #888888;")
|
|
|
|
# Test connection button
|
|
self.test_button = QPushButton("Test Connection")
|
|
self.test_button.setFixedHeight(24)
|
|
self.test_button.setFont(QFont("Arial", 8))
|
|
self.test_button.setStyleSheet("""
|
|
QPushButton {
|
|
background: #1db954;
|
|
color: white;
|
|
border: none;
|
|
border-radius: 4px;
|
|
padding: 4px 8px;
|
|
}
|
|
QPushButton:hover {
|
|
background: #1ed760;
|
|
}
|
|
QPushButton:pressed {
|
|
background: #169c46;
|
|
}
|
|
QPushButton:disabled {
|
|
background: #555555;
|
|
color: #999999;
|
|
}
|
|
""")
|
|
|
|
layout.addLayout(header_layout)
|
|
layout.addWidget(self.status_text)
|
|
layout.addWidget(self.response_time_label)
|
|
layout.addStretch()
|
|
layout.addWidget(self.test_button)
|
|
|
|
def update_status(self, connected: bool, response_time: float = 0.0, error: str = ""):
|
|
if connected:
|
|
self.status_indicator.setStyleSheet("color: #1db954;") # Green
|
|
self.status_text.setText("Connected")
|
|
self.response_time_label.setText(f"Response: {response_time:.0f}ms")
|
|
else:
|
|
self.status_indicator.setStyleSheet("color: #ff4444;") # Red
|
|
self.status_text.setText("Disconnected")
|
|
if error:
|
|
self.status_text.setText(f"Error: {error[:30]}..." if len(error) > 30 else f"Error: {error}")
|
|
self.response_time_label.setText("Response: --")
|
|
|
|
# Brief visual feedback
|
|
self.test_button.setText("Testing..." if not connected and error == "" else "Test Connection")
|
|
self.test_button.setEnabled(True)
|
|
|
|
class MetadataUpdaterWidget(QFrame):
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent)
|
|
self.setup_ui()
|
|
|
|
def setup_ui(self):
|
|
self.setStyleSheet("""
|
|
MetadataUpdaterWidget {
|
|
background: #282828;
|
|
border-radius: 8px;
|
|
border: 1px solid #404040;
|
|
}
|
|
""")
|
|
|
|
layout = QVBoxLayout(self)
|
|
layout.setContentsMargins(20, 15, 20, 15)
|
|
layout.setSpacing(12)
|
|
|
|
# Header
|
|
header_label = QLabel("Plex Metadata Updater")
|
|
header_label.setFont(QFont("Arial", 14, QFont.Weight.Bold))
|
|
header_label.setStyleSheet("color: #ffffff;")
|
|
|
|
# Control section
|
|
control_layout = QHBoxLayout()
|
|
control_layout.setSpacing(15)
|
|
|
|
self.start_button = QPushButton("Begin Metadata Update")
|
|
self.start_button.setFixedHeight(36)
|
|
self.start_button.setFont(QFont("Arial", 10, QFont.Weight.Medium))
|
|
self.start_button.setStyleSheet("""
|
|
QPushButton {
|
|
background: #1db954;
|
|
color: white;
|
|
border: none;
|
|
border-radius: 6px;
|
|
padding: 8px 16px;
|
|
}
|
|
QPushButton:hover {
|
|
background: #1ed760;
|
|
}
|
|
QPushButton:pressed {
|
|
background: #169c46;
|
|
}
|
|
QPushButton:disabled {
|
|
background: #555555;
|
|
color: #999999;
|
|
}
|
|
""")
|
|
|
|
# Current artist display
|
|
artist_info_layout = QVBoxLayout()
|
|
|
|
current_label = QLabel("Current Artist:")
|
|
current_label.setFont(QFont("Arial", 9))
|
|
current_label.setStyleSheet("color: #b3b3b3;")
|
|
|
|
self.current_artist_label = QLabel("Not running")
|
|
self.current_artist_label.setFont(QFont("Arial", 11, QFont.Weight.Medium))
|
|
self.current_artist_label.setStyleSheet("color: #ffffff;")
|
|
|
|
artist_info_layout.addWidget(current_label)
|
|
artist_info_layout.addWidget(self.current_artist_label)
|
|
|
|
control_layout.addWidget(self.start_button)
|
|
control_layout.addLayout(artist_info_layout)
|
|
control_layout.addStretch()
|
|
|
|
# Progress section
|
|
progress_layout = QVBoxLayout()
|
|
progress_layout.setSpacing(8)
|
|
|
|
progress_info_layout = QHBoxLayout()
|
|
|
|
self.progress_label = QLabel("Progress: 0%")
|
|
self.progress_label.setFont(QFont("Arial", 10))
|
|
self.progress_label.setStyleSheet("color: #ffffff;")
|
|
|
|
self.count_label = QLabel("0 / 0 artists")
|
|
self.count_label.setFont(QFont("Arial", 9))
|
|
self.count_label.setStyleSheet("color: #b3b3b3;")
|
|
|
|
progress_info_layout.addWidget(self.progress_label)
|
|
progress_info_layout.addStretch()
|
|
progress_info_layout.addWidget(self.count_label)
|
|
|
|
self.progress_bar = QProgressBar()
|
|
self.progress_bar.setFixedHeight(8)
|
|
self.progress_bar.setRange(0, 100)
|
|
self.progress_bar.setValue(0)
|
|
self.progress_bar.setStyleSheet("""
|
|
QProgressBar {
|
|
border: none;
|
|
border-radius: 4px;
|
|
background: #555555;
|
|
}
|
|
QProgressBar::chunk {
|
|
background: #1db954;
|
|
border-radius: 4px;
|
|
}
|
|
""")
|
|
|
|
progress_layout.addLayout(progress_info_layout)
|
|
progress_layout.addWidget(self.progress_bar)
|
|
|
|
layout.addWidget(header_label)
|
|
layout.addLayout(control_layout)
|
|
layout.addLayout(progress_layout)
|
|
|
|
def update_progress(self, is_running: bool, current_artist: str, processed: int, total: int, percentage: float):
|
|
if is_running:
|
|
self.start_button.setText("Stop Update")
|
|
self.start_button.setEnabled(True)
|
|
self.current_artist_label.setText(current_artist if current_artist else "Initializing...")
|
|
self.progress_label.setText(f"Progress: {percentage:.1f}%")
|
|
self.count_label.setText(f"{processed} / {total} artists")
|
|
self.progress_bar.setValue(int(percentage))
|
|
else:
|
|
self.start_button.setText("Begin Metadata Update")
|
|
self.start_button.setEnabled(True)
|
|
self.current_artist_label.setText("Not running")
|
|
self.progress_label.setText("Progress: 0%")
|
|
self.count_label.setText("0 / 0 artists")
|
|
self.progress_bar.setValue(0)
|
|
|
|
class ActivityItem(QWidget):
|
|
def __init__(self, icon: str, title: str, subtitle: str, time: str, parent=None):
|
|
super().__init__(parent)
|
|
self.setup_ui(icon, title, subtitle, time)
|
|
|
|
def setup_ui(self, icon: str, title: str, subtitle: str, time: str):
|
|
self.setFixedHeight(60)
|
|
|
|
layout = QHBoxLayout(self)
|
|
layout.setContentsMargins(15, 10, 15, 10)
|
|
layout.setSpacing(15)
|
|
|
|
# Icon
|
|
icon_label = QLabel(icon)
|
|
icon_label.setFixedSize(32, 32)
|
|
icon_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
icon_label.setStyleSheet("""
|
|
QLabel {
|
|
color: #1db954;
|
|
font-size: 18px;
|
|
background: rgba(29, 185, 84, 0.1);
|
|
border-radius: 16px;
|
|
}
|
|
""")
|
|
|
|
# Text content
|
|
text_layout = QVBoxLayout()
|
|
text_layout.setSpacing(2)
|
|
|
|
self.title_label = QLabel(title)
|
|
self.title_label.setFont(QFont("Arial", 10, QFont.Weight.Medium))
|
|
self.title_label.setStyleSheet("color: #ffffff;")
|
|
|
|
self.subtitle_label = QLabel(subtitle)
|
|
self.subtitle_label.setFont(QFont("Arial", 9))
|
|
self.subtitle_label.setStyleSheet("color: #b3b3b3;")
|
|
|
|
text_layout.addWidget(self.title_label)
|
|
text_layout.addWidget(self.subtitle_label)
|
|
|
|
# Time
|
|
time_label = QLabel(time)
|
|
time_label.setFont(QFont("Arial", 9))
|
|
time_label.setStyleSheet("color: #b3b3b3;")
|
|
time_label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignTop)
|
|
|
|
layout.addWidget(icon_label)
|
|
layout.addLayout(text_layout)
|
|
layout.addStretch()
|
|
layout.addWidget(time_label)
|
|
|
|
class DashboardPage(QWidget):
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent)
|
|
|
|
# Initialize data provider
|
|
self.data_provider = DashboardDataProvider()
|
|
self.data_provider.service_status_updated.connect(self.on_service_status_updated)
|
|
self.data_provider.download_stats_updated.connect(self.on_download_stats_updated)
|
|
self.data_provider.metadata_progress_updated.connect(self.on_metadata_progress_updated)
|
|
self.data_provider.sync_progress_updated.connect(self.on_sync_progress_updated)
|
|
self.data_provider.system_stats_updated.connect(self.on_system_stats_updated)
|
|
self.data_provider.activity_item_added.connect(self.add_activity_item)
|
|
|
|
# Service status cards
|
|
self.service_cards = {}
|
|
|
|
# Track previous service status to only show changes in activity
|
|
self.previous_service_status = {}
|
|
|
|
# Track if placeholder exists
|
|
self.has_placeholder = True
|
|
|
|
# Stats cards
|
|
self.stats_cards = {}
|
|
|
|
self.setup_ui()
|
|
|
|
def set_service_clients(self, spotify_client, plex_client, soulseek_client):
|
|
"""Called from main window to provide service client references"""
|
|
self.data_provider.set_service_clients(spotify_client, plex_client, soulseek_client)
|
|
|
|
def set_page_references(self, downloads_page, sync_page):
|
|
"""Called from main window to provide page references for live data"""
|
|
self.data_provider.set_page_references(downloads_page, sync_page)
|
|
|
|
def set_app_start_time(self, start_time):
|
|
"""Called from main window to provide app start time for uptime calculation"""
|
|
self.data_provider.set_app_start_time(start_time)
|
|
|
|
def setup_ui(self):
|
|
self.setStyleSheet("""
|
|
DashboardPage {
|
|
background: #191414;
|
|
}
|
|
""")
|
|
|
|
# Main scroll area
|
|
scroll_area = QScrollArea()
|
|
scroll_area.setWidgetResizable(True)
|
|
scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
|
|
scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
|
|
scroll_area.setStyleSheet("""
|
|
QScrollArea {
|
|
border: none;
|
|
background: #191414;
|
|
}
|
|
QScrollBar:vertical {
|
|
background: #333333;
|
|
width: 12px;
|
|
border-radius: 6px;
|
|
}
|
|
QScrollBar::handle:vertical {
|
|
background: #555555;
|
|
border-radius: 6px;
|
|
min-height: 20px;
|
|
}
|
|
QScrollBar::handle:vertical:hover {
|
|
background: #666666;
|
|
}
|
|
""")
|
|
|
|
# Scroll content widget
|
|
scroll_content = QWidget()
|
|
scroll_area.setWidget(scroll_content)
|
|
|
|
main_layout = QVBoxLayout(scroll_content)
|
|
main_layout.setContentsMargins(30, 30, 30, 30)
|
|
main_layout.setSpacing(25)
|
|
|
|
# Header
|
|
header = self.create_header()
|
|
main_layout.addWidget(header)
|
|
|
|
# Service Status Section
|
|
service_section = self.create_service_status_section()
|
|
main_layout.addWidget(service_section)
|
|
|
|
# System Stats Section
|
|
stats_section = self.create_stats_section()
|
|
main_layout.addWidget(stats_section)
|
|
|
|
# Plex Metadata Updater
|
|
metadata_section = self.create_metadata_section()
|
|
main_layout.addWidget(metadata_section)
|
|
|
|
# Recent Activity
|
|
activity_section = self.create_activity_section()
|
|
main_layout.addWidget(activity_section)
|
|
|
|
main_layout.addStretch()
|
|
|
|
# Set main layout
|
|
page_layout = QVBoxLayout(self)
|
|
page_layout.setContentsMargins(0, 0, 0, 0)
|
|
page_layout.addWidget(scroll_area)
|
|
|
|
def create_header(self):
|
|
header = QWidget()
|
|
layout = QVBoxLayout(header)
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
layout.setSpacing(5)
|
|
|
|
# Welcome message
|
|
welcome_label = QLabel("System Dashboard")
|
|
welcome_label.setFont(QFont("Arial", 28, QFont.Weight.Bold))
|
|
welcome_label.setStyleSheet("color: #ffffff;")
|
|
|
|
# Subtitle
|
|
subtitle_label = QLabel("Monitor your music system health and manage operations")
|
|
subtitle_label.setFont(QFont("Arial", 14))
|
|
subtitle_label.setStyleSheet("color: #b3b3b3;")
|
|
|
|
layout.addWidget(welcome_label)
|
|
layout.addWidget(subtitle_label)
|
|
|
|
return header
|
|
|
|
def create_service_status_section(self):
|
|
section = QWidget()
|
|
layout = QVBoxLayout(section)
|
|
layout.setSpacing(15)
|
|
|
|
# Section header
|
|
header_label = QLabel("Service Status")
|
|
header_label.setFont(QFont("Arial", 16, QFont.Weight.Bold))
|
|
header_label.setStyleSheet("color: #ffffff;")
|
|
|
|
# Service cards grid
|
|
cards_layout = QHBoxLayout()
|
|
cards_layout.setSpacing(20)
|
|
|
|
# Create service status cards
|
|
services = ['Spotify', 'Plex', 'Soulseek']
|
|
for service in services:
|
|
card = ServiceStatusCard(service)
|
|
card.test_button.clicked.connect(lambda checked, s=service.lower(): self.test_service_connection(s))
|
|
self.service_cards[service.lower()] = card
|
|
cards_layout.addWidget(card)
|
|
|
|
cards_layout.addStretch()
|
|
|
|
layout.addWidget(header_label)
|
|
layout.addLayout(cards_layout)
|
|
|
|
return section
|
|
|
|
def create_stats_section(self):
|
|
section = QWidget()
|
|
layout = QVBoxLayout(section)
|
|
layout.setSpacing(15)
|
|
|
|
# Section header
|
|
header_label = QLabel("System Statistics")
|
|
header_label.setFont(QFont("Arial", 16, QFont.Weight.Bold))
|
|
header_label.setStyleSheet("color: #ffffff;")
|
|
|
|
# Stats grid
|
|
stats_grid = QGridLayout()
|
|
stats_grid.setSpacing(20)
|
|
|
|
# Create stats cards
|
|
stats_data = [
|
|
("Active Downloads", "0", "Currently downloading", "active_downloads"),
|
|
("Finished Downloads", "0", "Completed today", "finished_downloads"),
|
|
("Download Speed", "0 KB/s", "Combined speed", "download_speed"),
|
|
("Active Syncs", "0", "Playlists syncing", "active_syncs"),
|
|
("System Uptime", "0m", "Application runtime", "uptime"),
|
|
("Memory Usage", "--", "Current usage", "memory")
|
|
]
|
|
|
|
for i, (title, value, subtitle, key) in enumerate(stats_data):
|
|
card = StatCard(title, value, subtitle, clickable=False)
|
|
self.stats_cards[key] = card
|
|
stats_grid.addWidget(card, i // 3, i % 3)
|
|
|
|
layout.addWidget(header_label)
|
|
layout.addLayout(stats_grid)
|
|
|
|
return section
|
|
|
|
def create_metadata_section(self):
|
|
section = QWidget()
|
|
layout = QVBoxLayout(section)
|
|
layout.setSpacing(15)
|
|
|
|
# Section header
|
|
header_label = QLabel("Tools & Operations")
|
|
header_label.setFont(QFont("Arial", 16, QFont.Weight.Bold))
|
|
header_label.setStyleSheet("color: #ffffff;")
|
|
|
|
# Metadata updater widget
|
|
self.metadata_widget = MetadataUpdaterWidget()
|
|
self.metadata_widget.start_button.clicked.connect(self.toggle_metadata_update)
|
|
|
|
layout.addWidget(header_label)
|
|
layout.addWidget(self.metadata_widget)
|
|
|
|
return section
|
|
|
|
def create_activity_section(self):
|
|
activity_widget = QWidget()
|
|
layout = QVBoxLayout(activity_widget)
|
|
layout.setSpacing(15)
|
|
|
|
# Section header
|
|
header_label = QLabel("Recent Activity")
|
|
header_label.setFont(QFont("Arial", 16, QFont.Weight.Bold))
|
|
header_label.setStyleSheet("color: #ffffff;")
|
|
|
|
# Activity container
|
|
activity_container = QFrame()
|
|
activity_container.setStyleSheet("""
|
|
QFrame {
|
|
background: #282828;
|
|
border-radius: 8px;
|
|
border: 1px solid #404040;
|
|
}
|
|
""")
|
|
|
|
activity_layout = QVBoxLayout(activity_container)
|
|
activity_layout.setContentsMargins(0, 0, 0, 0)
|
|
activity_layout.setSpacing(1)
|
|
|
|
# Activity feed will be populated dynamically
|
|
self.activity_layout = activity_layout
|
|
|
|
# Add initial placeholder
|
|
placeholder_item = ActivityItem("📊", "System Started", "Dashboard initialized successfully", "Now")
|
|
activity_layout.addWidget(placeholder_item)
|
|
|
|
layout.addWidget(header_label)
|
|
layout.addWidget(activity_container)
|
|
|
|
return activity_widget
|
|
|
|
def test_service_connection(self, service: str):
|
|
"""Test connection to a specific service"""
|
|
if service in self.service_cards:
|
|
card = self.service_cards[service]
|
|
|
|
# Prevent multiple simultaneous tests
|
|
if hasattr(self.data_provider, '_test_threads') and service in self.data_provider._test_threads:
|
|
if self.data_provider._test_threads[service].isRunning():
|
|
return
|
|
|
|
card.test_button.setText("Testing...")
|
|
card.test_button.setEnabled(False)
|
|
|
|
# Update status to testing state
|
|
card.status_indicator.setStyleSheet("color: #ffaa00;") # Orange
|
|
card.status_text.setText("Testing connection...")
|
|
|
|
# Add activity item for test initiation
|
|
self.add_activity_item("🔍", f"Testing {service.capitalize()}", "Connection test initiated", "Now")
|
|
|
|
# Start test
|
|
self.data_provider.test_service_connection(service)
|
|
|
|
def toggle_metadata_update(self):
|
|
"""Toggle metadata update process"""
|
|
current_text = self.metadata_widget.start_button.text()
|
|
if "Begin" in current_text:
|
|
# Start metadata update
|
|
self.start_metadata_update()
|
|
else:
|
|
# Stop metadata update
|
|
self.stop_metadata_update()
|
|
|
|
def start_metadata_update(self):
|
|
"""Start the Plex metadata update process"""
|
|
if not hasattr(self, 'data_provider') or not self.data_provider.service_clients.get('plex'):
|
|
self.add_activity_item("❌", "Metadata Update", "Plex client not available", "Now")
|
|
return
|
|
|
|
if not self.data_provider.service_clients.get('spotify'):
|
|
self.add_activity_item("❌", "Metadata Update", "Spotify client not available", "Now")
|
|
return
|
|
|
|
try:
|
|
# Start the metadata update worker (it will handle artist retrieval in background)
|
|
self.metadata_worker = MetadataUpdateWorker(
|
|
None, # Artists will be loaded in the worker thread
|
|
self.data_provider.service_clients['plex'],
|
|
self.data_provider.service_clients['spotify']
|
|
)
|
|
|
|
# Connect signals
|
|
self.metadata_worker.progress_updated.connect(self.on_metadata_progress)
|
|
self.metadata_worker.artist_updated.connect(self.on_artist_updated)
|
|
self.metadata_worker.finished.connect(self.on_metadata_finished)
|
|
self.metadata_worker.error.connect(self.on_metadata_error)
|
|
self.metadata_worker.artists_loaded.connect(self.on_artists_loaded)
|
|
|
|
# Update UI and start
|
|
self.metadata_widget.update_progress(True, "Loading artists...", 0, 0, 0.0)
|
|
self.add_activity_item("🎵", "Metadata Update", "Loading artists from Plex library...", "Now")
|
|
|
|
self.metadata_worker.start()
|
|
|
|
except Exception as e:
|
|
self.add_activity_item("❌", "Metadata Update", f"Failed to start: {str(e)}", "Now")
|
|
|
|
def on_artists_loaded(self, total_artists, artists_to_process):
|
|
"""Handle when artists are loaded and filtered"""
|
|
if artists_to_process == 0:
|
|
self.add_activity_item("✅", "Metadata Update", "All artists already have good metadata", "Now")
|
|
else:
|
|
self.add_activity_item("🎵", "Metadata Update", f"Processing {artists_to_process} of {total_artists} artists", "Now")
|
|
|
|
def stop_metadata_update(self):
|
|
"""Stop the metadata update process"""
|
|
if hasattr(self, 'metadata_worker') and self.metadata_worker.isRunning():
|
|
self.metadata_worker.stop()
|
|
self.metadata_worker.wait(3000) # Wait up to 3 seconds
|
|
if self.metadata_worker.isRunning():
|
|
self.metadata_worker.terminate()
|
|
|
|
self.metadata_widget.update_progress(False, "", 0, 0, 0.0)
|
|
self.add_activity_item("⏹️", "Metadata Update", "Stopped metadata update process", "Now")
|
|
|
|
def artist_needs_processing(self, artist):
|
|
"""Check if an artist needs metadata processing using smart detection"""
|
|
try:
|
|
# Check if artist has a valid photo
|
|
has_valid_photo = self.artist_has_valid_photo(artist)
|
|
|
|
# Check if artist has genres (more than just basic ones)
|
|
existing_genres = set(genre.tag if hasattr(genre, 'tag') else str(genre)
|
|
for genre in (artist.genres or []))
|
|
has_good_genres = len(existing_genres) >= 2 # At least 2 genres indicates Spotify processing
|
|
|
|
# Process if missing photo OR insufficient genres
|
|
return not has_valid_photo or not has_good_genres
|
|
|
|
except Exception as e:
|
|
print(f"Error checking artist {getattr(artist, 'title', 'Unknown')}: {e}")
|
|
return True # Process if we can't determine status
|
|
|
|
def artist_has_valid_photo(self, artist):
|
|
"""Check if artist has a valid photo"""
|
|
try:
|
|
if not hasattr(artist, 'thumb') or not artist.thumb:
|
|
return False
|
|
|
|
# Quick check for suspicious URLs (default Plex placeholders often contain 'default' or are very short)
|
|
thumb_url = str(artist.thumb)
|
|
if 'default' in thumb_url.lower() or len(thumb_url) < 50:
|
|
return False
|
|
|
|
return True
|
|
|
|
except Exception:
|
|
return False
|
|
|
|
def on_metadata_progress(self, current_artist, processed, total, percentage):
|
|
"""Handle metadata update progress"""
|
|
self.metadata_widget.update_progress(True, current_artist, processed, total, percentage)
|
|
|
|
def on_artist_updated(self, artist_name, success, details):
|
|
"""Handle individual artist update completion"""
|
|
if success:
|
|
self.add_activity_item("✅", "Artist Updated", f"'{artist_name}' - {details}", "Now")
|
|
else:
|
|
self.add_activity_item("❌", "Artist Failed", f"'{artist_name}' - {details}", "Now")
|
|
|
|
def on_metadata_finished(self, total_processed, successful, failed):
|
|
"""Handle metadata update completion"""
|
|
self.metadata_widget.update_progress(False, "", 0, 0, 0.0)
|
|
summary = f"Processed {total_processed} artists: {successful} updated, {failed} failed"
|
|
self.add_activity_item("🎵", "Metadata Complete", summary, "Now")
|
|
|
|
def on_metadata_error(self, error_message):
|
|
"""Handle metadata update error"""
|
|
self.metadata_widget.update_progress(False, "", 0, 0, 0.0)
|
|
self.add_activity_item("❌", "Metadata Error", error_message, "Now")
|
|
|
|
def on_service_status_updated(self, service: str, connected: bool, response_time: float, error: str):
|
|
"""Handle service status updates from data provider"""
|
|
if service in self.service_cards:
|
|
self.service_cards[service].update_status(connected, response_time, error)
|
|
|
|
# Only add activity item if status actually changed
|
|
if service not in self.previous_service_status or self.previous_service_status[service] != connected:
|
|
self.previous_service_status[service] = connected
|
|
|
|
status = "Connected" if connected else "Disconnected"
|
|
icon = "✅" if connected else "❌"
|
|
self.add_activity_item(icon, f"{service.capitalize()} {status}",
|
|
f"Response time: {response_time:.0f}ms" if connected else f"Error: {error}" if error else "Connection test completed",
|
|
"Now")
|
|
|
|
def on_download_stats_updated(self, active_count: int, finished_count: int, total_speed: float):
|
|
"""Handle download statistics updates"""
|
|
if 'active_downloads' in self.stats_cards:
|
|
self.stats_cards['active_downloads'].update_values(str(active_count), "Currently downloading")
|
|
|
|
if 'finished_downloads' in self.stats_cards:
|
|
self.stats_cards['finished_downloads'].update_values(str(finished_count), "Completed today")
|
|
|
|
if 'download_speed' in self.stats_cards:
|
|
# Format speed based on magnitude
|
|
if total_speed <= 0:
|
|
speed_text = "0 B/s"
|
|
elif total_speed >= 1024 * 1024: # MB/s
|
|
speed_text = f"{total_speed / (1024 * 1024):.1f} MB/s"
|
|
elif total_speed >= 1024: # KB/s
|
|
speed_text = f"{total_speed / 1024:.1f} KB/s"
|
|
else:
|
|
speed_text = f"{total_speed:.0f} B/s"
|
|
self.stats_cards['download_speed'].update_values(speed_text, "Combined speed")
|
|
|
|
def on_metadata_progress_updated(self, is_running: bool, current_artist: str, processed: int, total: int, percentage: float):
|
|
"""Handle metadata update progress"""
|
|
self.metadata_widget.update_progress(is_running, current_artist, processed, total, percentage)
|
|
|
|
def on_sync_progress_updated(self, current_playlist: str, active_syncs: int):
|
|
"""Handle sync progress updates"""
|
|
if 'active_syncs' in self.stats_cards:
|
|
self.stats_cards['active_syncs'].update_values(str(active_syncs), "Playlists syncing")
|
|
|
|
def on_system_stats_updated(self, uptime: str, memory: str):
|
|
"""Handle system statistics updates"""
|
|
if 'uptime' in self.stats_cards:
|
|
self.stats_cards['uptime'].update_values(uptime, "Application runtime")
|
|
|
|
if 'memory' in self.stats_cards:
|
|
self.stats_cards['memory'].update_values(memory, "Current usage")
|
|
|
|
def on_stat_card_clicked(self, card_title: str):
|
|
"""Handle stat card clicks for detailed views"""
|
|
# This can be implemented later for detailed views
|
|
pass
|
|
|
|
def add_activity_item(self, icon: str, title: str, subtitle: str, time_ago: str = "Now"):
|
|
"""Add new activity item to the feed"""
|
|
# Remove placeholder if it exists
|
|
if self.has_placeholder:
|
|
# Clear the entire layout
|
|
while self.activity_layout.count():
|
|
item = self.activity_layout.takeAt(0)
|
|
if item.widget():
|
|
item.widget().deleteLater()
|
|
self.has_placeholder = False
|
|
|
|
# Add separator if there are existing items
|
|
if self.activity_layout.count() > 0:
|
|
separator = QFrame()
|
|
separator.setFixedHeight(1)
|
|
separator.setStyleSheet("background: #404040;")
|
|
self.activity_layout.insertWidget(0, separator)
|
|
|
|
# Add new activity item at the top
|
|
new_item = ActivityItem(icon, title, subtitle, time_ago)
|
|
self.activity_layout.insertWidget(0, new_item)
|
|
|
|
# Limit to 5 most recent items (5 items + 4 separators = 9 total)
|
|
while self.activity_layout.count() > 9:
|
|
item = self.activity_layout.takeAt(self.activity_layout.count() - 1)
|
|
if item.widget():
|
|
item.widget().deleteLater()
|
|
|
|
def closeEvent(self, event):
|
|
"""Clean up threads when dashboard is closed"""
|
|
self.cleanup_threads()
|
|
super().closeEvent(event)
|
|
|
|
def cleanup_threads(self):
|
|
"""Clean up all running test threads"""
|
|
if hasattr(self.data_provider, '_test_threads'):
|
|
for service, thread in self.data_provider._test_threads.items():
|
|
if thread.isRunning():
|
|
thread.quit()
|
|
thread.wait(1000) # Wait up to 1 second
|
|
thread.deleteLater()
|
|
self.data_provider._test_threads.clear()
|
|
|
|
# Stop the data provider timers
|
|
if hasattr(self.data_provider, 'download_stats_timer'):
|
|
self.data_provider.download_stats_timer.stop()
|
|
if hasattr(self.data_provider, 'system_stats_timer'):
|
|
self.data_provider.system_stats_timer.stop() |