71e4df65e3
Stripped 4,200+ emoji characters from print(), logger calls across 39 Python files. Logs are now clean text — easier to grep, more professional, no encoding issues on terminals without Unicode support. Seasonal config icons preserved for UI display.
1314 lines
No EOL
58 KiB
Python
1314 lines
No EOL
58 KiB
Python
#!/usr/bin/env python3
|
|
|
|
"""
|
|
Watchlist Status Modal - Shows live status of watchlist scanning
|
|
"""
|
|
|
|
from PyQt6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel,
|
|
QPushButton, QFrame, QScrollArea, QWidget, QProgressBar, QMessageBox, QLineEdit)
|
|
from PyQt6.QtCore import Qt, QTimer, pyqtSignal, QThread
|
|
from PyQt6.QtGui import QFont
|
|
from datetime import datetime
|
|
from typing import Optional, List
|
|
|
|
from core.spotify_client import SpotifyClient
|
|
from core.watchlist_scanner import get_watchlist_scanner, ScanResult
|
|
from database.music_database import get_database, WatchlistArtist
|
|
from utils.logging_config import get_logger
|
|
|
|
logger = get_logger("watchlist_status_modal")
|
|
|
|
class WatchlistScanWorker(QThread):
|
|
"""Background worker for watchlist scanning"""
|
|
|
|
# Signals for progress updates
|
|
scan_started = pyqtSignal()
|
|
artist_scan_started = pyqtSignal(str) # artist_name
|
|
artist_totals_discovered = pyqtSignal(str, int, int) # artist_name, total_singles_eps_releases, total_albums
|
|
album_scan_started = pyqtSignal(str, str, int) # artist_name, album_name, total_tracks
|
|
track_check_started = pyqtSignal(str, str, str) # artist_name, album_name, track_name
|
|
release_completed = pyqtSignal(str, str, int) # artist_name, album_name, total_tracks
|
|
artist_scan_completed = pyqtSignal(str, int, int, bool) # artist_name, albums_checked, new_tracks, success
|
|
scan_completed = pyqtSignal(list) # List of ScanResult
|
|
|
|
def __init__(self, spotify_client: SpotifyClient):
|
|
super().__init__()
|
|
self.spotify_client = spotify_client
|
|
self.should_stop = False
|
|
|
|
# Progress state for reconnection
|
|
self.current_scan_state = {
|
|
'total_artists': 0,
|
|
'completed_artists': 0,
|
|
'current_artist_name': '',
|
|
'current_artist_total_singles_eps': 0,
|
|
'current_artist_completed_singles_eps': 0,
|
|
'current_artist_total_albums': 0,
|
|
'current_artist_completed_albums': 0,
|
|
'scan_active': False,
|
|
'scan_completed': False
|
|
}
|
|
|
|
def stop(self):
|
|
"""Stop the scanning process"""
|
|
self.should_stop = True
|
|
self.current_scan_state['scan_active'] = False
|
|
|
|
def get_current_progress(self):
|
|
"""Get current progress state for reconnection"""
|
|
return self.current_scan_state.copy()
|
|
|
|
def run(self):
|
|
"""Run the watchlist scan with detailed progress updates"""
|
|
try:
|
|
# Initialize progress state
|
|
database = get_database()
|
|
watchlist_artists = database.get_watchlist_artists()
|
|
|
|
self.current_scan_state.update({
|
|
'total_artists': len(watchlist_artists),
|
|
'completed_artists': 0,
|
|
'scan_active': True,
|
|
'scan_completed': False
|
|
})
|
|
|
|
self.scan_started.emit()
|
|
|
|
scan_results = []
|
|
|
|
for i, artist in enumerate(watchlist_artists):
|
|
if self.should_stop:
|
|
break
|
|
|
|
# Update current artist progress state
|
|
self.current_scan_state.update({
|
|
'current_artist_name': artist.artist_name,
|
|
'current_artist_total_singles_eps': 0,
|
|
'current_artist_completed_singles_eps': 0,
|
|
'current_artist_total_albums': 0,
|
|
'current_artist_completed_albums': 0
|
|
})
|
|
|
|
self.artist_scan_started.emit(artist.artist_name)
|
|
|
|
# Perform detailed scan with progress updates
|
|
result = self._scan_artist_with_progress(artist, database)
|
|
scan_results.append(result)
|
|
|
|
# Update completed artists count
|
|
self.current_scan_state['completed_artists'] = i + 1
|
|
|
|
self.artist_scan_completed.emit(
|
|
artist.artist_name,
|
|
result.albums_checked,
|
|
result.new_tracks_found,
|
|
result.success
|
|
)
|
|
|
|
# Mark scan as completed
|
|
self.current_scan_state.update({
|
|
'scan_active': False,
|
|
'scan_completed': True
|
|
})
|
|
|
|
self.scan_completed.emit(scan_results)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in watchlist scan worker: {e}")
|
|
self.current_scan_state.update({
|
|
'scan_active': False,
|
|
'scan_completed': True
|
|
})
|
|
self.scan_completed.emit([])
|
|
|
|
def _scan_artist_with_progress(self, watchlist_artist, database):
|
|
"""Scan artist with detailed progress emissions"""
|
|
try:
|
|
# Get watchlist scanner
|
|
scanner = get_watchlist_scanner(self.spotify_client)
|
|
|
|
# Get artist discography
|
|
albums = scanner.get_artist_discography(
|
|
watchlist_artist.spotify_artist_id,
|
|
watchlist_artist.last_scan_timestamp
|
|
)
|
|
|
|
if albums is None:
|
|
return ScanResult(
|
|
artist_name=watchlist_artist.artist_name,
|
|
spotify_artist_id=watchlist_artist.spotify_artist_id,
|
|
albums_checked=0,
|
|
new_tracks_found=0,
|
|
tracks_added_to_wishlist=0,
|
|
success=False,
|
|
error_message="Failed to get artist discography from Spotify"
|
|
)
|
|
|
|
# Analyze the albums list to get total counts upfront
|
|
total_singles_eps_releases = 0
|
|
total_albums = 0
|
|
|
|
for album in albums:
|
|
try:
|
|
# Get full album data to count tracks
|
|
album_data = self.spotify_client.get_album(album.id)
|
|
if not album_data or 'tracks' not in album_data:
|
|
continue
|
|
|
|
track_count = len(album_data['tracks'].get('items', []))
|
|
|
|
# Check if user wants this type of release
|
|
if not scanner._should_include_release(track_count, watchlist_artist):
|
|
continue # Skip counting this release
|
|
|
|
# Categorize based on track count - COUNT RELEASES not tracks
|
|
if track_count >= 4:
|
|
total_albums += 1
|
|
else:
|
|
total_singles_eps_releases += 1 # Count the release, not the tracks
|
|
|
|
# Rate limiting: small delay between album fetches to avoid hitting Spotify limits
|
|
import time
|
|
time.sleep(0.1) # 100ms delay between albums
|
|
|
|
except Exception as e:
|
|
logger.warning(f"Error analyzing album {album.name} for totals: {e}")
|
|
continue
|
|
|
|
# Update current artist totals in state
|
|
self.current_scan_state.update({
|
|
'current_artist_total_singles_eps': total_singles_eps_releases,
|
|
'current_artist_total_albums': total_albums
|
|
})
|
|
|
|
# Emit the discovered totals
|
|
self.artist_totals_discovered.emit(
|
|
watchlist_artist.artist_name,
|
|
total_singles_eps_releases,
|
|
total_albums
|
|
)
|
|
|
|
new_tracks_found = 0
|
|
tracks_added_to_wishlist = 0
|
|
|
|
for album in albums:
|
|
if self.should_stop:
|
|
break
|
|
|
|
try:
|
|
# Get full album data with tracks first
|
|
album_data = self.spotify_client.get_album(album.id)
|
|
if not album_data or 'tracks' not in album_data or not album_data['tracks'].get('items'):
|
|
continue
|
|
|
|
tracks = album_data['tracks']['items']
|
|
|
|
# Check if user wants this type of release
|
|
if not scanner._should_include_release(len(tracks), watchlist_artist):
|
|
continue # Skip this release
|
|
|
|
# Emit album progress with track count
|
|
self.album_scan_started.emit(watchlist_artist.artist_name, album.name, len(tracks))
|
|
|
|
# Check each track
|
|
for track in tracks:
|
|
if self.should_stop:
|
|
break
|
|
|
|
# Emit track check progress
|
|
self.track_check_started.emit(
|
|
watchlist_artist.artist_name,
|
|
album_data.get('name', 'Unknown'),
|
|
track.get('name', 'Unknown')
|
|
)
|
|
|
|
if scanner.is_track_missing_from_library(track):
|
|
new_tracks_found += 1
|
|
|
|
# Add to wishlist
|
|
if scanner.add_track_to_wishlist(track, album_data, watchlist_artist):
|
|
tracks_added_to_wishlist += 1
|
|
|
|
# Emit release completion signal
|
|
self.release_completed.emit(watchlist_artist.artist_name, album.name, len(tracks))
|
|
|
|
# Update progress state for this completed release
|
|
if len(tracks) >= 4: # Album
|
|
self.current_scan_state['current_artist_completed_albums'] += 1
|
|
else: # Single/EP
|
|
self.current_scan_state['current_artist_completed_singles_eps'] += 1
|
|
|
|
# Rate limiting: small delay between album processing to avoid hitting Spotify limits
|
|
import time
|
|
time.sleep(0.1) # 100ms delay between albums
|
|
|
|
except Exception as e:
|
|
logger.warning(f"Error checking album {album.name}: {e}")
|
|
continue
|
|
|
|
# Update last scan timestamp
|
|
scanner.update_artist_scan_timestamp(watchlist_artist)
|
|
|
|
return ScanResult(
|
|
artist_name=watchlist_artist.artist_name,
|
|
spotify_artist_id=watchlist_artist.spotify_artist_id,
|
|
albums_checked=len(albums),
|
|
new_tracks_found=new_tracks_found,
|
|
tracks_added_to_wishlist=tracks_added_to_wishlist,
|
|
success=True
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error scanning artist {watchlist_artist.artist_name}: {e}")
|
|
return ScanResult(
|
|
artist_name=watchlist_artist.artist_name,
|
|
spotify_artist_id=watchlist_artist.spotify_artist_id,
|
|
albums_checked=0,
|
|
new_tracks_found=0,
|
|
tracks_added_to_wishlist=0,
|
|
success=False,
|
|
error_message=str(e)
|
|
)
|
|
|
|
class WatchlistStatusModal(QDialog):
|
|
"""Modal showing live watchlist scanning status"""
|
|
|
|
# Class-level shared scan worker that persists across modal instances
|
|
_shared_scan_worker = None
|
|
_scan_owner_modal = None
|
|
|
|
def __init__(self, parent=None, spotify_client: SpotifyClient = None):
|
|
super().__init__(parent)
|
|
self.spotify_client = spotify_client
|
|
self.scan_worker = None
|
|
self.current_artists = []
|
|
self.scan_in_progress = False
|
|
|
|
# Keep track of whether this modal started the scan (vs background scan)
|
|
self.is_manual_scan_owner = False
|
|
|
|
# Track when we're reconnecting to ongoing scan vs starting fresh
|
|
self.is_reconnecting_to_ongoing_scan = False
|
|
|
|
# Simple progress tracking
|
|
self.total_artists = 0
|
|
self.completed_artists = 0
|
|
|
|
# Current artist progress (resets for each artist)
|
|
self.current_artist_name = ""
|
|
self.current_artist_total_singles_eps = 0 # Total singles + EPs releases
|
|
self.current_artist_completed_singles_eps = 0 # Completed singles + EPs releases
|
|
self.current_artist_total_albums = 0 # Total albums
|
|
self.current_artist_completed_albums = 0 # Completed albums
|
|
|
|
self.setup_ui()
|
|
self.load_watchlist_data()
|
|
|
|
def setup_ui(self):
|
|
"""Setup the modal UI with clean tool-style design"""
|
|
self.setWindowTitle("Watchlist Status")
|
|
self.setFixedSize(700, 700)
|
|
self.setStyleSheet("""
|
|
QDialog {
|
|
background: #121212;
|
|
color: #ffffff;
|
|
}
|
|
""")
|
|
|
|
layout = QVBoxLayout(self)
|
|
layout.setContentsMargins(20, 20, 20, 20)
|
|
layout.setSpacing(15)
|
|
|
|
# Header
|
|
header_layout = QHBoxLayout()
|
|
|
|
title_label = QLabel("Artist Watchlist Status")
|
|
title_label.setFont(QFont("Arial", 16, QFont.Weight.Bold))
|
|
title_label.setStyleSheet("color: #ffffff; border: none;")
|
|
|
|
self.status_label = QLabel("Ready")
|
|
self.status_label.setFont(QFont("Arial", 11))
|
|
self.status_label.setStyleSheet("color: #b3b3b3; border: none;")
|
|
|
|
header_layout.addWidget(title_label)
|
|
header_layout.addStretch()
|
|
header_layout.addWidget(self.status_label)
|
|
|
|
layout.addLayout(header_layout)
|
|
|
|
# Progress section - tool style
|
|
progress_frame = QFrame()
|
|
progress_frame.setStyleSheet("""
|
|
QFrame {
|
|
background: #282828;
|
|
border-radius: 8px;
|
|
border: 1px solid #404040;
|
|
}
|
|
""")
|
|
|
|
progress_layout = QVBoxLayout(progress_frame)
|
|
progress_layout.setContentsMargins(20, 15, 20, 15)
|
|
progress_layout.setSpacing(12)
|
|
|
|
# Progress header
|
|
progress_header = QLabel("Scan Progress")
|
|
progress_header.setFont(QFont("Arial", 14, QFont.Weight.Bold))
|
|
progress_header.setStyleSheet("color: #ffffff; border: none;")
|
|
|
|
self.current_action_label = QLabel("No scan in progress")
|
|
self.current_action_label.setFont(QFont("Arial", 11))
|
|
self.current_action_label.setStyleSheet("color: #ffffff; border: none;")
|
|
|
|
# Top row: Tracks and Albums side by side
|
|
top_progress_layout = QHBoxLayout()
|
|
top_progress_layout.setSpacing(15)
|
|
|
|
# Tracks progress (left)
|
|
tracks_layout = QVBoxLayout()
|
|
tracks_layout.setSpacing(4)
|
|
|
|
singles_label = QLabel("Total Singles and EPs:")
|
|
singles_label.setFont(QFont("Arial", 9))
|
|
singles_label.setStyleSheet("color: #b3b3b3; border: none;")
|
|
|
|
self.singles_progress_bar = QProgressBar()
|
|
self.singles_progress_bar.setFixedHeight(16)
|
|
self.singles_progress_bar.setRange(0, 100)
|
|
self.singles_progress_bar.setValue(0)
|
|
self.singles_progress_bar.setStyleSheet("""
|
|
QProgressBar {
|
|
border: 1px solid #555;
|
|
border-radius: 8px;
|
|
text-align: center;
|
|
background-color: #444;
|
|
color: #fff;
|
|
font-size: 10px;
|
|
}
|
|
QProgressBar::chunk {
|
|
background-color: #ff9800;
|
|
border-radius: 7px;
|
|
}
|
|
""")
|
|
|
|
tracks_layout.addWidget(singles_label)
|
|
tracks_layout.addWidget(self.singles_progress_bar)
|
|
|
|
# Albums progress (right)
|
|
albums_layout = QVBoxLayout()
|
|
albums_layout.setSpacing(4)
|
|
|
|
albums_label = QLabel("Total Albums:")
|
|
albums_label.setFont(QFont("Arial", 9))
|
|
albums_label.setStyleSheet("color: #b3b3b3; border: none;")
|
|
|
|
self.albums_progress_bar = QProgressBar()
|
|
self.albums_progress_bar.setFixedHeight(16)
|
|
self.albums_progress_bar.setRange(0, 100)
|
|
self.albums_progress_bar.setValue(0)
|
|
self.albums_progress_bar.setStyleSheet("""
|
|
QProgressBar {
|
|
border: 1px solid #555;
|
|
border-radius: 8px;
|
|
text-align: center;
|
|
background-color: #444;
|
|
color: #fff;
|
|
font-size: 10px;
|
|
}
|
|
QProgressBar::chunk {
|
|
background-color: #ffc107;
|
|
border-radius: 7px;
|
|
}
|
|
""")
|
|
|
|
albums_layout.addWidget(albums_label)
|
|
albums_layout.addWidget(self.albums_progress_bar)
|
|
|
|
top_progress_layout.addLayout(tracks_layout)
|
|
top_progress_layout.addLayout(albums_layout)
|
|
|
|
# Overall artists progress (bottom, full width)
|
|
overall_progress_label = QLabel("Overall Progress:")
|
|
overall_progress_label.setFont(QFont("Arial", 9))
|
|
overall_progress_label.setStyleSheet("color: #b3b3b3; border: none;")
|
|
|
|
self.artists_progress_bar = QProgressBar()
|
|
self.artists_progress_bar.setFixedHeight(20)
|
|
self.artists_progress_bar.setRange(0, 100)
|
|
self.artists_progress_bar.setValue(0)
|
|
self.artists_progress_bar.setStyleSheet("""
|
|
QProgressBar {
|
|
border: 1px solid #555;
|
|
border-radius: 10px;
|
|
text-align: center;
|
|
background-color: #444;
|
|
color: #fff;
|
|
font-size: 11px;
|
|
}
|
|
QProgressBar::chunk {
|
|
background-color: #1db954;
|
|
border-radius: 9px;
|
|
}
|
|
""")
|
|
|
|
self.scan_summary_label = QLabel("")
|
|
self.scan_summary_label.setFont(QFont("Arial", 9))
|
|
self.scan_summary_label.setStyleSheet("color: #b3b3b3; border: none;")
|
|
|
|
progress_layout.addWidget(progress_header)
|
|
progress_layout.addWidget(self.current_action_label)
|
|
progress_layout.addLayout(top_progress_layout)
|
|
progress_layout.addWidget(overall_progress_label)
|
|
progress_layout.addWidget(self.artists_progress_bar)
|
|
progress_layout.addWidget(self.scan_summary_label)
|
|
|
|
layout.addWidget(progress_frame)
|
|
|
|
# Artists list
|
|
artists_header_layout = QHBoxLayout()
|
|
|
|
list_label = QLabel("Watched Artists:")
|
|
list_label.setFont(QFont("Arial", 14, QFont.Weight.Bold))
|
|
list_label.setStyleSheet("color: #ffffff; border: none;")
|
|
|
|
# Artist count label
|
|
self.artist_count_label = QLabel("0 artists")
|
|
self.artist_count_label.setFont(QFont("Arial", 10))
|
|
self.artist_count_label.setStyleSheet("color: #b3b3b3; border: none;")
|
|
|
|
artists_header_layout.addWidget(list_label)
|
|
artists_header_layout.addStretch()
|
|
artists_header_layout.addWidget(self.artist_count_label)
|
|
|
|
layout.addLayout(artists_header_layout)
|
|
|
|
# Search bar
|
|
self.search_bar = QLineEdit()
|
|
self.search_bar.setPlaceholderText("Search all artists...")
|
|
self.search_bar.setFixedHeight(32)
|
|
self.search_bar.setStyleSheet("""
|
|
QLineEdit {
|
|
background: #333333;
|
|
color: #ffffff;
|
|
border: 1px solid #555555;
|
|
border-radius: 6px;
|
|
padding: 6px 12px;
|
|
font-size: 11px;
|
|
}
|
|
QLineEdit:focus {
|
|
border: 1px solid #1db954;
|
|
}
|
|
QLineEdit::placeholder {
|
|
color: #888888;
|
|
}
|
|
""")
|
|
self.search_bar.textChanged.connect(self.filter_artists)
|
|
layout.addWidget(self.search_bar)
|
|
|
|
# Scroll area for artists
|
|
scroll_area = QScrollArea()
|
|
scroll_area.setWidgetResizable(True)
|
|
scroll_area.setStyleSheet("""
|
|
QScrollArea {
|
|
border: 1px solid #404040;
|
|
border-radius: 8px;
|
|
background: #282828;
|
|
}
|
|
QScrollBar:vertical {
|
|
background: rgba(60, 60, 60, 0.3);
|
|
width: 8px;
|
|
border-radius: 4px;
|
|
}
|
|
QScrollBar::handle:vertical {
|
|
background: #1db954;
|
|
border-radius: 4px;
|
|
min-height: 20px;
|
|
}
|
|
""")
|
|
|
|
self.artists_widget = QWidget()
|
|
self.artists_layout = QVBoxLayout(self.artists_widget)
|
|
self.artists_layout.setContentsMargins(10, 10, 10, 10)
|
|
self.artists_layout.setSpacing(8)
|
|
|
|
scroll_area.setWidget(self.artists_widget)
|
|
layout.addWidget(scroll_area)
|
|
|
|
# Buttons
|
|
button_layout = QHBoxLayout()
|
|
|
|
self.scan_button = QPushButton("Start Scan")
|
|
self.scan_button.setFixedHeight(36)
|
|
self.scan_button.clicked.connect(self.start_scan)
|
|
self.scan_button.setStyleSheet("""
|
|
QPushButton {
|
|
background: #1db954;
|
|
border: none;
|
|
border-radius: 18px;
|
|
color: #000000;
|
|
font-size: 12px;
|
|
font-weight: bold;
|
|
padding: 0 16px;
|
|
}
|
|
QPushButton:hover {
|
|
background: #1ed760;
|
|
}
|
|
QPushButton:pressed {
|
|
background: #1aa34a;
|
|
}
|
|
QPushButton:disabled {
|
|
background: #404040;
|
|
color: #666666;
|
|
}
|
|
""")
|
|
|
|
close_button = QPushButton("Close")
|
|
close_button.setFixedHeight(36)
|
|
close_button.clicked.connect(self.close)
|
|
close_button.setStyleSheet("""
|
|
QPushButton {
|
|
background: rgba(80, 80, 80, 0.6);
|
|
border: 1px solid rgba(120, 120, 120, 0.4);
|
|
border-radius: 18px;
|
|
color: #ffffff;
|
|
font-size: 12px;
|
|
font-weight: bold;
|
|
padding: 0 16px;
|
|
}
|
|
QPushButton:hover {
|
|
background: rgba(100, 100, 100, 0.8);
|
|
border: 1px solid rgba(140, 140, 140, 0.6);
|
|
}
|
|
""")
|
|
|
|
button_layout.addWidget(self.scan_button)
|
|
button_layout.addStretch()
|
|
button_layout.addWidget(close_button)
|
|
|
|
layout.addLayout(button_layout)
|
|
|
|
def load_watchlist_data(self):
|
|
"""Load and display watchlist artists"""
|
|
try:
|
|
database = get_database()
|
|
self.current_artists = database.get_watchlist_artists()
|
|
|
|
logger.info(f"Loading watchlist data: found {len(self.current_artists)} artists")
|
|
|
|
# Clear existing widgets
|
|
for i in reversed(range(self.artists_layout.count())):
|
|
child = self.artists_layout.itemAt(i).widget()
|
|
if child:
|
|
child.deleteLater()
|
|
|
|
if not self.current_artists:
|
|
no_artists_label = QLabel("No artists in watchlist")
|
|
no_artists_label.setStyleSheet("color: #888888; font-style: italic; padding: 20px; border: none;")
|
|
no_artists_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
self.artists_layout.addWidget(no_artists_label)
|
|
self.scan_button.setEnabled(False)
|
|
self.artist_count_label.setText("0 artists")
|
|
logger.info("No artists in watchlist - showing empty message")
|
|
return
|
|
|
|
self.scan_button.setEnabled(True)
|
|
|
|
# Use filter method to populate (handles initial load and filtering)
|
|
self.filter_artists()
|
|
|
|
# Update status
|
|
self.status_label.setText(f"{len(self.current_artists)} artists being monitored")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error loading watchlist data: {e}")
|
|
|
|
def filter_artists(self):
|
|
"""Filter artists based on search text"""
|
|
search_text = self.search_bar.text().lower().strip()
|
|
|
|
if not hasattr(self, 'current_artists') or not self.current_artists:
|
|
return
|
|
|
|
# Clear existing widgets
|
|
for i in reversed(range(self.artists_layout.count())):
|
|
child = self.artists_layout.itemAt(i).widget()
|
|
if child:
|
|
child.setParent(None)
|
|
|
|
# Determine which artists to show
|
|
if search_text:
|
|
# When searching: filter from ALL artists
|
|
filtered_artists = [
|
|
artist for artist in self.current_artists
|
|
if search_text in artist.artist_name.lower()
|
|
]
|
|
else:
|
|
# When empty: show only the last 5 added artists
|
|
# Artists are already sorted with most recent first (insertWidget(0))
|
|
filtered_artists = self.current_artists[:5]
|
|
|
|
# Add filtered artist cards or show empty message
|
|
if filtered_artists:
|
|
for artist in filtered_artists:
|
|
artist_card = self.create_artist_card(artist)
|
|
self.artists_layout.insertWidget(0, artist_card)
|
|
elif search_text:
|
|
# Show "no results" message when search returns no matches
|
|
no_results_label = QLabel(f"No artists found matching '{search_text}'")
|
|
no_results_label.setStyleSheet("color: #888888; font-style: italic; padding: 20px; border: none;")
|
|
no_results_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
self.artists_layout.addWidget(no_results_label)
|
|
|
|
self.artists_layout.addStretch()
|
|
|
|
# Update count labels
|
|
total_count = len(self.current_artists)
|
|
filtered_count = len(filtered_artists)
|
|
|
|
if search_text:
|
|
self.artist_count_label.setText(f"{filtered_count} of {total_count} artists")
|
|
else:
|
|
if total_count <= 5:
|
|
self.artist_count_label.setText(f"{total_count} artists")
|
|
else:
|
|
self.artist_count_label.setText(f"Showing 5 of {total_count} artists")
|
|
|
|
def get_artist_status_icon(self, artist):
|
|
"""Determine the appropriate status icon and color for an artist based on scan history"""
|
|
if not artist.last_scan_timestamp:
|
|
return "", "#888888" # Not scanned yet (gray circle)
|
|
|
|
try:
|
|
from datetime import datetime, timezone
|
|
# Check how long ago the last scan was
|
|
now = datetime.now(timezone.utc)
|
|
last_scan = artist.last_scan_timestamp
|
|
|
|
# If last_scan is naive (no timezone), assume it's UTC
|
|
if last_scan.tzinfo is None:
|
|
last_scan = last_scan.replace(tzinfo=timezone.utc)
|
|
|
|
time_diff = now - last_scan
|
|
hours_ago = time_diff.total_seconds() / 3600
|
|
|
|
# If scanned within the last 24 hours, show as up to date
|
|
# If older, show as potentially stale but still scanned
|
|
if hours_ago <= 24:
|
|
return "", "#4caf50" # Recently up to date (bright green)
|
|
else:
|
|
return "", "#888888" # Scanned but older (gray checkmark)
|
|
|
|
except Exception:
|
|
# Fallback if datetime parsing fails
|
|
return "", "#4caf50" # Default to up to date
|
|
|
|
def create_artist_card(self, artist: WatchlistArtist) -> QFrame:
|
|
"""Create a professional artist card widget"""
|
|
card = QFrame()
|
|
card.setFixedHeight(48) # Increased height for better visual hierarchy
|
|
card.setStyleSheet("""
|
|
QFrame {
|
|
background: rgba(40, 40, 40, 0.8);
|
|
border-radius: 10px;
|
|
border: 1px solid rgba(80, 80, 80, 0.4);
|
|
}
|
|
QFrame:hover {
|
|
background: rgba(45, 45, 45, 0.9);
|
|
border: 1px solid rgba(100, 100, 100, 0.6);
|
|
}
|
|
""")
|
|
|
|
layout = QHBoxLayout(card)
|
|
layout.setContentsMargins(16, 8, 16, 8)
|
|
layout.setSpacing(16)
|
|
|
|
# Status indicator with icon
|
|
status_icon, status_color = self.get_artist_status_icon(artist)
|
|
status_label = QLabel(status_icon)
|
|
status_label.setFont(QFont("Arial", 14))
|
|
status_label.setStyleSheet(f"color: {status_color}; border: none; background: transparent;")
|
|
status_label.setFixedWidth(24)
|
|
status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
|
|
# Left side: Artist info
|
|
info_layout = QVBoxLayout()
|
|
info_layout.setSpacing(2)
|
|
|
|
# Artist name with label
|
|
artist_label = QLabel(f"Artist: {artist.artist_name}")
|
|
artist_label.setFont(QFont("Arial", 12, QFont.Weight.Bold))
|
|
artist_label.setStyleSheet("color: #ffffff; border: none; background: transparent;")
|
|
|
|
# Last scan info with professional formatting
|
|
if artist.last_scan_timestamp:
|
|
try:
|
|
from datetime import datetime, timezone
|
|
# Ensure both timestamps have timezone info
|
|
now = datetime.now(timezone.utc)
|
|
last_scan = artist.last_scan_timestamp
|
|
|
|
# If last_scan is naive (no timezone), assume it's UTC
|
|
if last_scan.tzinfo is None:
|
|
last_scan = last_scan.replace(tzinfo=timezone.utc)
|
|
|
|
time_diff = now - last_scan
|
|
if time_diff.days > 0:
|
|
scan_time = f"{time_diff.days} day{'s' if time_diff.days > 1 else ''} ago"
|
|
elif time_diff.seconds > 3600:
|
|
hours = time_diff.seconds // 3600
|
|
scan_time = f"{hours} hour{'s' if hours > 1 else ''} ago"
|
|
else:
|
|
minutes = max(1, time_diff.seconds // 60)
|
|
scan_time = f"{minutes} minute{'s' if minutes > 1 else ''} ago"
|
|
except Exception as e:
|
|
# Fallback to formatted date
|
|
scan_time = last_scan.strftime("%m/%d/%Y at %I:%M %p")
|
|
else:
|
|
scan_time = "never scanned"
|
|
|
|
sync_label = QLabel(f"Last Sync: {scan_time}")
|
|
sync_label.setFont(QFont("Arial", 10))
|
|
sync_label.setStyleSheet("color: #b3b3b3; border: none; background: transparent;")
|
|
|
|
info_layout.addWidget(artist_label)
|
|
info_layout.addWidget(sync_label)
|
|
|
|
# Delete button with modern styling
|
|
delete_button = QPushButton("")
|
|
delete_button.setFixedSize(28, 28)
|
|
delete_button.setFont(QFont("Arial", 12, QFont.Weight.Bold))
|
|
delete_button.setStyleSheet("""
|
|
QPushButton {
|
|
background: rgba(244, 67, 54, 0.1);
|
|
color: #f44336;
|
|
border: 1px solid rgba(244, 67, 54, 0.3);
|
|
border-radius: 14px;
|
|
font-weight: bold;
|
|
}
|
|
QPushButton:hover {
|
|
background: rgba(244, 67, 54, 0.8);
|
|
color: white;
|
|
border: 1px solid #f44336;
|
|
}
|
|
QPushButton:pressed {
|
|
background: rgba(200, 50, 40, 1.0);
|
|
}
|
|
""")
|
|
delete_button.setToolTip(f"Remove {artist.artist_name} from watchlist")
|
|
delete_button.clicked.connect(lambda: self.delete_artist(artist))
|
|
|
|
# Store references for updates
|
|
setattr(card, 'status_indicator', status_label)
|
|
setattr(card, 'artist_id', artist.spotify_artist_id)
|
|
|
|
layout.addWidget(status_label)
|
|
layout.addLayout(info_layout)
|
|
layout.addStretch()
|
|
layout.addWidget(delete_button)
|
|
|
|
return card
|
|
|
|
def delete_artist(self, artist: WatchlistArtist):
|
|
"""Delete an artist from the watchlist with confirmation"""
|
|
try:
|
|
# Show confirmation dialog
|
|
reply = QMessageBox.question(
|
|
self,
|
|
"Remove Artist from Watchlist",
|
|
f"Are you sure you want to remove '{artist.artist_name}' from your watchlist?\n\n"
|
|
"This will stop monitoring this artist for new releases.",
|
|
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
|
|
QMessageBox.StandardButton.No
|
|
)
|
|
|
|
if reply == QMessageBox.StandardButton.Yes:
|
|
# Remove from database
|
|
database = get_database()
|
|
success = database.remove_artist_from_watchlist(artist.spotify_artist_id)
|
|
|
|
if success:
|
|
logger.info(f"Removed {artist.artist_name} from watchlist")
|
|
|
|
# Refresh the artist list to show the updated watchlist
|
|
self.load_watchlist_data()
|
|
|
|
# Update parent window if it has a watchlist count (like dashboard)
|
|
if self.parent() and hasattr(self.parent(), 'update_watchlist_button_count'):
|
|
self.parent().update_watchlist_button_count()
|
|
else:
|
|
QMessageBox.warning(
|
|
self,
|
|
"Error",
|
|
f"Failed to remove '{artist.artist_name}' from watchlist.\nPlease try again."
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error deleting artist from watchlist: {e}")
|
|
QMessageBox.critical(
|
|
self,
|
|
"Error",
|
|
f"An error occurred while removing the artist:\n{str(e)}"
|
|
)
|
|
|
|
def start_scan(self):
|
|
"""Start the watchlist scan"""
|
|
if self.scan_in_progress:
|
|
return
|
|
|
|
if not self.spotify_client:
|
|
logger.error("No Spotify client available for watchlist scan")
|
|
return
|
|
|
|
try:
|
|
self.scan_in_progress = True
|
|
self.is_manual_scan_owner = True # This modal started the scan
|
|
self.scan_button.setText("Scanning...")
|
|
self.scan_button.setEnabled(False)
|
|
|
|
# Reset artist status indicators
|
|
for i in range(self.artists_layout.count()):
|
|
item = self.artists_layout.itemAt(i)
|
|
if item and item.widget():
|
|
card = item.widget()
|
|
if hasattr(card, 'status_indicator'):
|
|
card.status_indicator.setText("") # Not scanned yet
|
|
card.status_indicator.setStyleSheet("color: #888888; border: none; background: transparent;")
|
|
|
|
# Use shared scan worker so it persists across modal close/open
|
|
WatchlistStatusModal._shared_scan_worker = WatchlistScanWorker(self.spotify_client)
|
|
WatchlistStatusModal._scan_owner_modal = self
|
|
self.scan_worker = WatchlistStatusModal._shared_scan_worker
|
|
|
|
self.scan_worker.scan_started.connect(self.on_scan_started)
|
|
self.scan_worker.artist_scan_started.connect(self.on_artist_scan_started)
|
|
self.scan_worker.artist_totals_discovered.connect(self.on_artist_totals_discovered)
|
|
self.scan_worker.album_scan_started.connect(self.on_album_scan_started)
|
|
self.scan_worker.track_check_started.connect(self.on_track_check_started)
|
|
self.scan_worker.release_completed.connect(self.on_release_completed)
|
|
self.scan_worker.artist_scan_completed.connect(self.on_artist_scan_completed)
|
|
self.scan_worker.scan_completed.connect(self.on_scan_completed)
|
|
self.scan_worker.start()
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error starting watchlist scan: {e}")
|
|
self.scan_in_progress = False
|
|
self.scan_button.setText("Start Scan")
|
|
self.scan_button.setEnabled(True)
|
|
|
|
def on_scan_started(self):
|
|
"""Handle scan start"""
|
|
# Only reset progress if this is a fresh scan, not a reconnection
|
|
if not self.is_reconnecting_to_ongoing_scan:
|
|
self.current_action_label.setText("Starting watchlist scan...")
|
|
|
|
# Reset overall counters
|
|
self.total_artists = len(self.current_artists)
|
|
self.completed_artists = 0
|
|
|
|
# Reset current artist tracking
|
|
self.current_artist_name = ""
|
|
self.current_artist_total_singles_eps = 0
|
|
self.current_artist_completed_singles_eps = 0
|
|
self.current_artist_total_albums = 0
|
|
self.current_artist_completed_albums = 0
|
|
|
|
# Reset progress bars
|
|
self.singles_progress_bar.setValue(0)
|
|
self.albums_progress_bar.setValue(0)
|
|
self.artists_progress_bar.setValue(0)
|
|
self.scan_summary_label.setText("Preparing to scan artists...")
|
|
|
|
# Clear the reconnection flag after handling
|
|
self.is_reconnecting_to_ongoing_scan = False
|
|
|
|
def on_artist_scan_started(self, artist_name: str):
|
|
"""Handle individual artist scan start"""
|
|
self.current_action_label.setText(f"Scanning: {artist_name}")
|
|
self.scan_summary_label.setText("Getting artist discography...")
|
|
|
|
# Reset for new artist
|
|
self.current_artist_name = artist_name
|
|
self.current_artist_total_singles_eps = 0
|
|
self.current_artist_completed_singles_eps = 0
|
|
self.current_artist_total_albums = 0
|
|
self.current_artist_completed_albums = 0
|
|
|
|
# Reset progress bars for new artist
|
|
self.singles_progress_bar.setValue(0)
|
|
self.albums_progress_bar.setValue(0)
|
|
|
|
# Update status indicator to yellow (scanning)
|
|
for i in range(self.artists_layout.count()):
|
|
item = self.artists_layout.itemAt(i)
|
|
if item and item.widget():
|
|
card = item.widget()
|
|
if hasattr(card, 'status_indicator') and hasattr(card, 'artist_id'):
|
|
# Find artist by name (we don't have ID in signal)
|
|
for artist in self.current_artists:
|
|
if artist.artist_name == artist_name:
|
|
card.status_indicator.setText("") # Scanning
|
|
card.status_indicator.setStyleSheet("color: #ffc107; border: none; background: transparent;")
|
|
break
|
|
|
|
def on_artist_totals_discovered(self, artist_name: str, total_singles_eps_releases: int, total_albums: int):
|
|
"""Handle discovery of artist's total release counts"""
|
|
# Set the total counts for this artist - now counting RELEASES not tracks
|
|
self.current_artist_total_singles_eps = total_singles_eps_releases
|
|
self.current_artist_total_albums = total_albums
|
|
|
|
# Reset completed counts to 0 for new artist
|
|
self.current_artist_completed_singles_eps = 0
|
|
self.current_artist_completed_albums = 0
|
|
|
|
# Update progress bars to show 0% progress with known totals
|
|
self.singles_progress_bar.setValue(0)
|
|
self.albums_progress_bar.setValue(0)
|
|
|
|
logger.debug(f"Artist {artist_name}: {total_singles_eps_releases} singles/EPs, {total_albums} albums")
|
|
|
|
def on_album_scan_started(self, artist_name: str, album_name: str, total_tracks: int):
|
|
"""Handle album/release scan start"""
|
|
self.current_action_label.setText(f"Scanning: {artist_name}")
|
|
self.scan_summary_label.setText(f"Release: {album_name}")
|
|
|
|
def on_track_check_started(self, artist_name: str, album_name: str, track_name: str):
|
|
"""Handle track check start"""
|
|
# Truncate long track names to keep UI readable
|
|
display_track = track_name[:40] + "..." if len(track_name) > 40 else track_name
|
|
self.current_action_label.setText(f"Scanning: {artist_name}")
|
|
self.scan_summary_label.setText(f"Track: {display_track}")
|
|
|
|
def on_release_completed(self, artist_name: str, album_name: str, total_tracks: int):
|
|
"""Handle when a release (album/single/EP) finishes being scanned"""
|
|
# Determine if this was a single/EP or album
|
|
if total_tracks >= 4:
|
|
# This was an album
|
|
self.current_artist_completed_albums += 1
|
|
|
|
# Update albums progress bar
|
|
if self.current_artist_total_albums > 0:
|
|
progress = int((self.current_artist_completed_albums / self.current_artist_total_albums) * 100)
|
|
self.albums_progress_bar.setValue(progress)
|
|
else:
|
|
# This was a single/EP
|
|
self.current_artist_completed_singles_eps += 1
|
|
|
|
# Update singles progress bar
|
|
if self.current_artist_total_singles_eps > 0:
|
|
progress = int((self.current_artist_completed_singles_eps / self.current_artist_total_singles_eps) * 100)
|
|
self.singles_progress_bar.setValue(progress)
|
|
|
|
def on_artist_scan_completed(self, artist_name: str, albums_checked: int, new_tracks: int, success: bool):
|
|
"""Handle individual artist scan completion"""
|
|
# Mark this artist as completed
|
|
self.completed_artists += 1
|
|
|
|
# Update overall artists progress bar
|
|
if self.total_artists > 0:
|
|
progress = int((self.completed_artists / self.total_artists) * 100)
|
|
self.artists_progress_bar.setValue(progress)
|
|
|
|
# Update status indicator
|
|
for i in range(self.artists_layout.count()):
|
|
item = self.artists_layout.itemAt(i)
|
|
if item and item.widget():
|
|
card = item.widget()
|
|
if hasattr(card, 'status_indicator'):
|
|
# Find artist by name
|
|
for artist in self.current_artists:
|
|
if artist.artist_name == artist_name:
|
|
if success:
|
|
if new_tracks > 0:
|
|
card.status_indicator.setText("") # New tracks found
|
|
card.status_indicator.setStyleSheet("color: #1db954; border: none; background: transparent;")
|
|
else:
|
|
card.status_indicator.setText("") # Up to date
|
|
card.status_indicator.setStyleSheet("color: #4caf50; border: none; background: transparent;")
|
|
else:
|
|
card.status_indicator.setText("") # Error
|
|
card.status_indicator.setStyleSheet("color: #f44336; border: none; background: transparent;")
|
|
break
|
|
|
|
def on_scan_completed(self, scan_results: List[ScanResult]):
|
|
"""Handle scan completion"""
|
|
self.scan_in_progress = False
|
|
self.is_manual_scan_owner = False # Reset ownership
|
|
self.scan_button.setText("Start Scan")
|
|
self.scan_button.setEnabled(True)
|
|
|
|
# Keep shared worker around for a bit so other modals can see completed results
|
|
# Only clear it if this modal was the owner (manual scan starter)
|
|
if (self.scan_worker == WatchlistStatusModal._shared_scan_worker
|
|
and WatchlistStatusModal._scan_owner_modal == self):
|
|
# Keep the worker alive for 30 seconds to allow other modals to see results
|
|
QTimer.singleShot(30000, self._cleanup_shared_worker_delayed)
|
|
WatchlistStatusModal._scan_owner_modal = None
|
|
|
|
# Calculate summary
|
|
successful_scans = [r for r in scan_results if r.success]
|
|
total_new_tracks = sum(r.new_tracks_found for r in successful_scans)
|
|
total_albums_checked = sum(r.albums_checked for r in successful_scans)
|
|
|
|
self.current_action_label.setText("Scan completed")
|
|
self.singles_progress_bar.setValue(100)
|
|
self.albums_progress_bar.setValue(100)
|
|
self.artists_progress_bar.setValue(100)
|
|
|
|
if scan_results:
|
|
summary = f"Scanned {len(successful_scans)}/{len(scan_results)} artists, {total_albums_checked} albums, found {total_new_tracks} new tracks"
|
|
else:
|
|
summary = "Scan failed - check logs for details"
|
|
|
|
self.scan_summary_label.setText(summary)
|
|
|
|
# Update status
|
|
if total_new_tracks > 0:
|
|
self.status_label.setText(f"Found {total_new_tracks} new tracks!")
|
|
else:
|
|
self.status_label.setText("All artists up to date")
|
|
|
|
def on_background_scan_started(self):
|
|
"""Handle background scan start from dashboard"""
|
|
if not self.scan_in_progress: # Only update if we're not already doing a manual scan
|
|
self.current_action_label.setText("Starting background scan...")
|
|
self.singles_progress_bar.setValue(0)
|
|
self.albums_progress_bar.setValue(0)
|
|
self.artists_progress_bar.setValue(0)
|
|
self.scan_summary_label.setText("Automatic watchlist scan in progress...")
|
|
self.scan_button.setText("Background Scanning...")
|
|
self.scan_button.setEnabled(False)
|
|
|
|
# Reset artist status indicators
|
|
for i in range(self.artists_layout.count()):
|
|
item = self.artists_layout.itemAt(i)
|
|
if item and item.widget():
|
|
card = item.widget()
|
|
if hasattr(card, 'status_indicator'):
|
|
card.status_indicator.setText("") # Not scanned yet
|
|
card.status_indicator.setStyleSheet("color: #888888; border: none; background: transparent;")
|
|
|
|
def on_background_scan_completed(self, total_artists: int, total_new_tracks: int, total_added_to_wishlist: int):
|
|
"""Handle background scan completion from dashboard"""
|
|
if not self.scan_in_progress: # Only update if we're not doing a manual scan
|
|
self.current_action_label.setText("Background scan completed")
|
|
|
|
if total_new_tracks > 0:
|
|
summary = f"Background scan found {total_new_tracks} new tracks from {total_artists} artists"
|
|
self.status_label.setText(f"Found {total_new_tracks} new tracks!")
|
|
else:
|
|
summary = f"Background scan completed - all {total_artists} artists up to date"
|
|
self.status_label.setText("All artists up to date")
|
|
|
|
self.scan_summary_label.setText(summary)
|
|
self.scan_button.setText("Start Scan")
|
|
self.scan_button.setEnabled(True)
|
|
|
|
# Refresh the artist list to show updated status
|
|
self.load_watchlist_data()
|
|
|
|
def showEvent(self, event):
|
|
"""Handle modal show - refresh data and connect to any ongoing scan"""
|
|
super().showEvent(event)
|
|
self.load_watchlist_data()
|
|
|
|
# First check if there's a manual scan worker (running or recently completed)
|
|
if WatchlistStatusModal._shared_scan_worker:
|
|
|
|
logger.info("Found manual watchlist scan worker - reconnecting to it")
|
|
|
|
# Reconnect to the shared manual scan worker
|
|
self.scan_worker = WatchlistStatusModal._shared_scan_worker
|
|
|
|
# Check if scan is still active
|
|
progress_state = self.scan_worker.get_current_progress()
|
|
self.scan_in_progress = progress_state.get('scan_active', False) if progress_state else False
|
|
self.is_reconnecting_to_ongoing_scan = True
|
|
|
|
try:
|
|
# Restore progress state BEFORE connecting signals to prevent reset conflicts
|
|
self._restore_progress_state(progress_state)
|
|
|
|
# Now connect to future signals
|
|
self.scan_worker.scan_started.connect(self.on_scan_started)
|
|
self.scan_worker.artist_scan_started.connect(self.on_artist_scan_started)
|
|
self.scan_worker.artist_totals_discovered.connect(self.on_artist_totals_discovered)
|
|
self.scan_worker.album_scan_started.connect(self.on_album_scan_started)
|
|
self.scan_worker.track_check_started.connect(self.on_track_check_started)
|
|
self.scan_worker.release_completed.connect(self.on_release_completed)
|
|
self.scan_worker.artist_scan_completed.connect(self.on_artist_scan_completed)
|
|
self.scan_worker.scan_completed.connect(self.on_scan_completed)
|
|
|
|
# Update UI to show reconnection status (will be overridden by _restore_progress_state if needed)
|
|
if self.scan_in_progress:
|
|
self.current_action_label.setText("Reconnected to manual scan...")
|
|
self.scan_button.setText("Scanning...")
|
|
self.scan_button.setEnabled(False)
|
|
else:
|
|
self.current_action_label.setText("Viewing completed manual scan results")
|
|
self.scan_button.setText("Start Scan")
|
|
self.scan_button.setEnabled(True)
|
|
|
|
except Exception as e:
|
|
logger.debug(f"Could not connect to manual scan signals (may already be connected): {e}")
|
|
|
|
# Otherwise check if there's a background scan already running and connect to it
|
|
elif not self.scan_in_progress:
|
|
try:
|
|
# Get the dashboard page to check for running background scan
|
|
dashboard = None
|
|
if self.parent():
|
|
# Try to find the dashboard page in the parent hierarchy
|
|
parent_widget = self.parent()
|
|
while parent_widget and not hasattr(parent_widget, 'background_watchlist_worker'):
|
|
parent_widget = parent_widget.parent()
|
|
|
|
if parent_widget and hasattr(parent_widget, 'background_watchlist_worker'):
|
|
dashboard = parent_widget
|
|
|
|
# If we found the dashboard and there's an active background worker
|
|
if (dashboard and hasattr(dashboard, 'background_watchlist_worker')
|
|
and dashboard.background_watchlist_worker
|
|
and dashboard.background_watchlist_worker.isRunning()
|
|
and hasattr(dashboard, 'auto_processing_watchlist')
|
|
and dashboard.auto_processing_watchlist):
|
|
|
|
logger.info("Found active background watchlist scan - connecting modal to live updates")
|
|
|
|
# Set reconnection flag and restore progress before connecting signals
|
|
self.is_reconnecting_to_ongoing_scan = True
|
|
|
|
# Restore progress state BEFORE connecting signals
|
|
try:
|
|
progress_state = dashboard.background_watchlist_worker.get_current_progress()
|
|
self._restore_progress_state(progress_state)
|
|
except Exception as e:
|
|
logger.debug(f"Could not restore background scan progress: {e}")
|
|
|
|
# Connect to the background worker's signals for live updates
|
|
# Now using the same WatchlistScanWorker signals (no .signals attribute needed)
|
|
try:
|
|
dashboard.background_watchlist_worker.scan_started.connect(self.on_scan_started)
|
|
dashboard.background_watchlist_worker.artist_scan_started.connect(self.on_artist_scan_started)
|
|
dashboard.background_watchlist_worker.artist_totals_discovered.connect(self.on_artist_totals_discovered)
|
|
dashboard.background_watchlist_worker.album_scan_started.connect(self.on_album_scan_started)
|
|
dashboard.background_watchlist_worker.track_check_started.connect(self.on_track_check_started)
|
|
dashboard.background_watchlist_worker.release_completed.connect(self.on_release_completed)
|
|
dashboard.background_watchlist_worker.artist_scan_completed.connect(self.on_artist_scan_completed)
|
|
|
|
# Update UI to show reconnection status
|
|
self.current_action_label.setText("Reconnected to background scan...")
|
|
self.scan_button.setText("Background Scanning...")
|
|
self.scan_button.setEnabled(False)
|
|
|
|
except Exception as e:
|
|
logger.debug(f"Could not connect to background scan signals (may already be connected): {e}")
|
|
|
|
except Exception as e:
|
|
logger.debug(f"Error checking for background scan: {e}")
|
|
# Not critical - just means we can't detect ongoing scans
|
|
|
|
@staticmethod
|
|
def _cleanup_shared_worker_delayed():
|
|
"""Clean up shared worker after delay to allow other modals to see results"""
|
|
try:
|
|
if WatchlistStatusModal._shared_scan_worker:
|
|
if not WatchlistStatusModal._shared_scan_worker.isRunning():
|
|
WatchlistStatusModal._shared_scan_worker = None
|
|
logger.debug("Cleaned up completed shared scan worker")
|
|
except Exception as e:
|
|
logger.debug(f"Error cleaning up shared worker: {e}")
|
|
|
|
def _restore_progress_state(self, progress_state):
|
|
"""Restore progress bars and UI state from worker's current progress"""
|
|
if not progress_state:
|
|
return
|
|
|
|
# Handle both active and completed scans
|
|
is_active = progress_state.get('scan_active', False)
|
|
is_completed = progress_state.get('scan_completed', False)
|
|
|
|
if not is_active and not is_completed:
|
|
return
|
|
|
|
try:
|
|
# Fully sync modal state with worker state
|
|
self.total_artists = progress_state.get('total_artists', 0)
|
|
self.completed_artists = progress_state.get('completed_artists', 0)
|
|
self.current_artist_name = progress_state.get('current_artist_name', '')
|
|
self.current_artist_total_singles_eps = progress_state.get('current_artist_total_singles_eps', 0)
|
|
self.current_artist_completed_singles_eps = progress_state.get('current_artist_completed_singles_eps', 0)
|
|
self.current_artist_total_albums = progress_state.get('current_artist_total_albums', 0)
|
|
self.current_artist_completed_albums = progress_state.get('current_artist_completed_albums', 0)
|
|
|
|
# Update UI elements
|
|
if self.total_artists > 0:
|
|
overall_progress = int((self.completed_artists / self.total_artists) * 100)
|
|
self.artists_progress_bar.setValue(overall_progress)
|
|
|
|
if self.current_artist_name:
|
|
self.current_action_label.setText(f"Scanning: {self.current_artist_name}")
|
|
|
|
# Update current artist progress bars
|
|
if self.current_artist_total_singles_eps > 0:
|
|
singles_progress = int((self.current_artist_completed_singles_eps / self.current_artist_total_singles_eps) * 100)
|
|
self.singles_progress_bar.setValue(singles_progress)
|
|
|
|
if self.current_artist_total_albums > 0:
|
|
albums_progress = int((self.current_artist_completed_albums / self.current_artist_total_albums) * 100)
|
|
self.albums_progress_bar.setValue(albums_progress)
|
|
|
|
# Update scan summary and UI state based on scan status
|
|
if is_completed:
|
|
self.scan_summary_label.setText("Scan completed - viewing final results")
|
|
self.scan_button.setText("Start Scan")
|
|
self.scan_button.setEnabled(True)
|
|
# Set progress bars to 100% for completed scans
|
|
self.artists_progress_bar.setValue(100)
|
|
if self.current_artist_total_singles_eps > 0:
|
|
self.singles_progress_bar.setValue(100)
|
|
if self.current_artist_total_albums > 0:
|
|
self.albums_progress_bar.setValue(100)
|
|
elif is_active:
|
|
remaining_artists = self.total_artists - self.completed_artists
|
|
self.scan_summary_label.setText(f"Reconnected to ongoing scan - {remaining_artists} artists remaining")
|
|
self.scan_button.setText("Scanning...")
|
|
self.scan_button.setEnabled(False)
|
|
|
|
logger.info(f"Restored progress state: {self.completed_artists}/{self.total_artists} artists, current: {self.current_artist_name}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error restoring progress state: {e}")
|
|
|
|
def closeEvent(self, event):
|
|
"""Handle modal close"""
|
|
# Only stop the scan if this modal owns it and it's not a shared manual scan
|
|
if (self.scan_worker and self.scan_worker.isRunning()
|
|
and self.is_manual_scan_owner
|
|
and self.scan_worker != WatchlistStatusModal._shared_scan_worker):
|
|
self.scan_worker.stop()
|
|
self.scan_worker.wait()
|
|
|
|
# Don't stop shared manual scans - they should continue running
|
|
|
|
# Disconnect from any background worker signals to prevent duplicates
|
|
try:
|
|
if self.parent():
|
|
parent_widget = self.parent()
|
|
while parent_widget and not hasattr(parent_widget, 'background_watchlist_worker'):
|
|
parent_widget = parent_widget.parent()
|
|
|
|
if (parent_widget and hasattr(parent_widget, 'background_watchlist_worker')
|
|
and parent_widget.background_watchlist_worker):
|
|
try:
|
|
parent_widget.background_watchlist_worker.scan_started.disconnect(self.on_scan_started)
|
|
parent_widget.background_watchlist_worker.artist_scan_started.disconnect(self.on_artist_scan_started)
|
|
parent_widget.background_watchlist_worker.artist_totals_discovered.disconnect(self.on_artist_totals_discovered)
|
|
parent_widget.background_watchlist_worker.album_scan_started.disconnect(self.on_album_scan_started)
|
|
parent_widget.background_watchlist_worker.track_check_started.disconnect(self.on_track_check_started)
|
|
parent_widget.background_watchlist_worker.release_completed.disconnect(self.on_release_completed)
|
|
parent_widget.background_watchlist_worker.artist_scan_completed.disconnect(self.on_artist_scan_completed)
|
|
except:
|
|
pass # Ignore if signals weren't connected
|
|
except:
|
|
pass # Not critical
|
|
|
|
event.accept() |