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.
11364 lines
No EOL
511 KiB
Python
11364 lines
No EOL
511 KiB
Python
from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel,
|
||
QFrame, QPushButton, QProgressBar, QListWidget,
|
||
QListWidgetItem, QComboBox, QLineEdit, QScrollArea, QMessageBox,
|
||
QSplitter, QSizePolicy, QSpacerItem, QTabWidget, QDialog, QGridLayout)
|
||
from PyQt6.QtCore import Qt, QThread, pyqtSignal, QTimer, QUrl, QPropertyAnimation, QEasingCurve, QParallelAnimationGroup, QFileSystemWatcher, pyqtProperty, QObject, QRunnable, QThreadPool
|
||
from PyQt6.QtGui import QFont, QPainter, QPen, QColor, QPixmap
|
||
from PyQt6.QtMultimedia import QMediaPlayer, QAudioOutput
|
||
import functools # For fixing lambda memory leaks
|
||
import os
|
||
import threading
|
||
from threading import RLock, Lock
|
||
from queue import Queue, Empty
|
||
from config.settings import config_manager
|
||
# Import the new search result classes
|
||
from core.soulseek_client import TrackResult, AlbumResult
|
||
from core.spotify_client import SpotifyClient, Artist, Album
|
||
from core.matching_engine import MusicMatchingEngine
|
||
from core.lyrics_client import LyricsClient
|
||
import requests
|
||
from typing import List, Optional
|
||
from dataclasses import dataclass
|
||
# Metadata enhancement imports
|
||
from mutagen import File as MutagenFile
|
||
from mutagen.id3 import ID3, TIT2, TPE1, TALB, TDRC, TRCK, TCON, TPE2, TPOS, TXXX, APIC
|
||
from mutagen.flac import FLAC, Picture
|
||
from mutagen.mp4 import MP4, MP4Cover
|
||
from mutagen.oggvorbis import OggVorbis
|
||
import urllib.request
|
||
import mimetypes
|
||
|
||
@dataclass
|
||
class ArtistMatch:
|
||
"""Represents an artist match with confidence score"""
|
||
artist: Artist
|
||
confidence: float
|
||
match_reason: str = ""
|
||
|
||
@dataclass
|
||
class AlbumMatch:
|
||
"""Represents an album match with confidence score"""
|
||
album: Album
|
||
confidence: float
|
||
match_reason: str = ""
|
||
|
||
|
||
class ImageDownloaderSignals(QObject):
|
||
"""Signals for the ImageDownloader worker."""
|
||
finished = pyqtSignal(QLabel, QPixmap)
|
||
error = pyqtSignal(str)
|
||
|
||
class ImageDownloader(QRunnable):
|
||
"""Worker to download an image in the background."""
|
||
def __init__(self, url: str, target_label: QLabel):
|
||
super().__init__()
|
||
self.signals = ImageDownloaderSignals()
|
||
self.url = url
|
||
self.target_label = target_label
|
||
|
||
def run(self):
|
||
try:
|
||
if not self.url:
|
||
self.signals.error.emit("No image URL provided.")
|
||
return
|
||
|
||
response = requests.get(self.url, stream=True, timeout=10)
|
||
response.raise_for_status()
|
||
|
||
pixmap = QPixmap()
|
||
pixmap.loadFromData(response.content)
|
||
|
||
if not pixmap.isNull():
|
||
self.signals.finished.emit(self.target_label, pixmap)
|
||
else:
|
||
self.signals.error.emit("Failed to load image from data.")
|
||
|
||
except requests.RequestException as e:
|
||
self.signals.error.emit(f"Network error downloading image: {e}")
|
||
except Exception as e:
|
||
self.signals.error.emit(f"Error processing image: {e}")
|
||
|
||
|
||
class DownloadCompletionWorkerSignals(QObject):
|
||
"""Signals for the download completion worker"""
|
||
completed = pyqtSignal(object, str) # download_item, organized_path
|
||
error = pyqtSignal(object, str) # download_item, error_message
|
||
|
||
class DownloadCompletionWorker(QRunnable):
|
||
"""Background worker to handle download completion processing without blocking UI"""
|
||
|
||
def __init__(self, download_item, absolute_file_path, organize_func):
|
||
super().__init__()
|
||
self.download_item = download_item
|
||
self.absolute_file_path = absolute_file_path
|
||
self.organize_func = organize_func
|
||
self.signals = DownloadCompletionWorkerSignals()
|
||
|
||
def run(self):
|
||
"""Process download completion in background thread"""
|
||
try:
|
||
print(f"Background worker processing: '{self.download_item.title}' by '{self.download_item.matched_artist.name}'")
|
||
|
||
# Add a small delay to ensure file is fully written
|
||
import time
|
||
time.sleep(1)
|
||
|
||
# Organize the file into Transfer folder structure
|
||
organized_path = self.organize_func(self.download_item, self.absolute_file_path)
|
||
|
||
# Emit completion signal
|
||
self.signals.completed.emit(self.download_item, organized_path or self.absolute_file_path)
|
||
|
||
except Exception as e:
|
||
print(f"Error in background worker: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
# Emit error signal
|
||
self.signals.error.emit(self.download_item, str(e))
|
||
|
||
|
||
# OPTIMIZATION: This worker runs the existing status update logic in the background.
|
||
class StatusProcessingWorkerSignals(QObject):
|
||
"""Defines the signals available from the StatusProcessingWorker."""
|
||
completed = pyqtSignal(list)
|
||
error = pyqtSignal(str)
|
||
|
||
class StatusProcessingWorker(QRunnable):
|
||
"""
|
||
Runs the expensive download status processing in a background thread to prevent UI lag.
|
||
It performs all the matching and logic, then returns a list of actions for the main thread to execute.
|
||
"""
|
||
def __init__(self, soulseek_client, download_items):
|
||
super().__init__()
|
||
self.signals = StatusProcessingWorkerSignals()
|
||
self.soulseek_client = soulseek_client
|
||
# We operate on a copy of the item data to avoid thread conflicts
|
||
self.download_items_data = [{
|
||
'widget_id': id(item),
|
||
'download_id': item.download_id,
|
||
'title': item.title,
|
||
'artist': item.artist,
|
||
'file_path': item.file_path,
|
||
'status': item.status,
|
||
'matched_artist': getattr(item, 'matched_artist', None)
|
||
} for item in download_items]
|
||
|
||
def run(self):
|
||
"""The main logic of the background worker."""
|
||
try:
|
||
# This is the core of your original update_download_status method.
|
||
import asyncio
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
transfers_data = loop.run_until_complete(
|
||
self.soulseek_client._make_request('GET', 'transfers/downloads')
|
||
)
|
||
loop.close()
|
||
|
||
results = []
|
||
if not transfers_data:
|
||
self.signals.completed.emit([])
|
||
return
|
||
|
||
all_transfers = [
|
||
file for user_data in transfers_data if 'directories' in user_data
|
||
for directory in user_data['directories'] if 'files' in directory
|
||
for file in directory['files']
|
||
]
|
||
|
||
# Create a lookup for faster matching
|
||
transfers_by_id = {t['id']: t for t in all_transfers}
|
||
|
||
# --- This is your existing, working logic, now running in the background ---
|
||
for item_data in self.download_items_data:
|
||
if item_data['status'].lower() in ['completed', 'finished', 'cancelled', 'failed']:
|
||
continue
|
||
|
||
matching_transfer = transfers_by_id.get(item_data['download_id'])
|
||
|
||
if not matching_transfer:
|
||
# Fallback to filename matching if ID match fails
|
||
import os
|
||
dl_filename = os.path.basename(item_data['file_path']).lower()
|
||
for t in all_transfers:
|
||
if os.path.basename(t.get('filename', '')).lower() == dl_filename:
|
||
matching_transfer = t
|
||
break
|
||
|
||
if matching_transfer:
|
||
state = matching_transfer.get('state', 'Unknown')
|
||
progress = matching_transfer.get('percentComplete', 0)
|
||
new_status = 'queued'
|
||
|
||
# Determine the new status with the correct order of checks.
|
||
# Terminal states like Cancelled and Failed must be checked BEFORE Completed.
|
||
if 'Cancelled' in state or 'Canceled' in state:
|
||
new_status = 'cancelled'
|
||
elif 'Failed' in state or 'Errored' in state:
|
||
new_status = 'failed'
|
||
elif 'Completed' in state or 'Succeeded' in state:
|
||
new_status = 'completed'
|
||
elif 'InProgress' in state:
|
||
new_status = 'downloading'
|
||
else:
|
||
new_status = 'queued'
|
||
|
||
# **CRITICAL FIX:** Package all necessary data for the main thread.
|
||
payload = {
|
||
'widget_id': item_data['widget_id'],
|
||
'status': new_status,
|
||
'progress': int(progress),
|
||
'speed': int(matching_transfer.get('averageSpeed', 0)),
|
||
'path': matching_transfer.get('filename', item_data['file_path']),
|
||
'transfer_id': matching_transfer.get('id'), # This is key for cleanup
|
||
'username': matching_transfer.get('username') # Also key for cleanup
|
||
}
|
||
|
||
if new_status == 'completed' and item_data['matched_artist']:
|
||
payload['action'] = 'process_matched_completion'
|
||
|
||
results.append(payload)
|
||
else:
|
||
# This handles downloads that have disappeared from the API (e.g., failed, cancelled by user).
|
||
# We add a grace period before marking as failed to handle temporary API glitches.
|
||
item_data['api_missing_count'] = item_data.get('api_missing_count', 0) + 1
|
||
|
||
if item_data['api_missing_count'] >= 3:
|
||
# After being missing for 3 update cycles (3 seconds), mark it as failed.
|
||
payload = {
|
||
'widget_id': item_data['widget_id'],
|
||
'status': 'failed',
|
||
'progress': item_data.get('progress', 0),
|
||
'speed': 0,
|
||
'path': item_data['file_path'],
|
||
'transfer_id': item_data['download_id'],
|
||
'username': item_data['artist']
|
||
}
|
||
results.append(payload)
|
||
|
||
self.signals.completed.emit(results)
|
||
except Exception as e:
|
||
import traceback
|
||
traceback.print_exc()
|
||
self.signals.error.emit(str(e))
|
||
|
||
class OptimizedDownloadCompletionWorker(QRunnable):
|
||
"""OPTIMIZATION v2: Non-blocking background worker for download completion processing"""
|
||
|
||
def __init__(self, download_item, absolute_file_path, organize_func):
|
||
super().__init__()
|
||
self.download_item = download_item
|
||
self.absolute_file_path = absolute_file_path
|
||
self.organize_func = organize_func
|
||
self.signals = DownloadCompletionWorkerSignals()
|
||
|
||
def run(self):
|
||
"""Process download completion without blocking operations"""
|
||
try:
|
||
# OPTIMIZATION: Use file system monitoring instead of sleep
|
||
import os
|
||
from pathlib import Path
|
||
|
||
# Verify file exists and is not being written to
|
||
file_path = Path(self.absolute_file_path)
|
||
if file_path.exists():
|
||
initial_size = file_path.stat().st_size
|
||
# Quick non-blocking check for file stability
|
||
import time
|
||
time.sleep(0.1) # Minimal delay
|
||
if file_path.exists() and file_path.stat().st_size == initial_size:
|
||
# File is stable, proceed with organization
|
||
organized_path = self.organize_func(self.download_item, self.absolute_file_path)
|
||
self.signals.completed.emit(self.download_item, organized_path or self.absolute_file_path)
|
||
else:
|
||
# File still being written, retry with shorter delay
|
||
time.sleep(0.5)
|
||
organized_path = self.organize_func(self.download_item, self.absolute_file_path)
|
||
self.signals.completed.emit(self.download_item, organized_path or self.absolute_file_path)
|
||
else:
|
||
raise FileNotFoundError(f"Download file not found: {self.absolute_file_path}")
|
||
|
||
except Exception as e:
|
||
print(f"Error in optimized worker: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
self.signals.error.emit(self.download_item, str(e))
|
||
|
||
class ThreadSafeQueueManager:
|
||
"""OPTIMIZATION v2: Thread-safe queue management system to prevent race conditions"""
|
||
|
||
def __init__(self):
|
||
self._download_items_lock = RLock() # Reentrant lock for nested operations
|
||
self._state_transition_lock = Lock() # Lock for atomic state changes
|
||
self._id_mapping_lock = Lock() # Lock for ID mapping operations
|
||
self._download_items = []
|
||
self._pending_operations = Queue() # Queue for pending operations
|
||
|
||
def add_download_item_safe(self, download_item):
|
||
"""Thread-safe addition of download items"""
|
||
with self._download_items_lock:
|
||
self._download_items.append(download_item)
|
||
|
||
def remove_download_item_safe(self, download_item):
|
||
"""Thread-safe removal of download items"""
|
||
with self._download_items_lock:
|
||
if download_item in self._download_items:
|
||
self._download_items.remove(download_item)
|
||
return True
|
||
return False
|
||
|
||
def get_download_items_copy(self):
|
||
"""Get thread-safe copy of download items"""
|
||
with self._download_items_lock:
|
||
return self._download_items.copy()
|
||
|
||
def find_item_by_id_safe(self, download_id):
|
||
"""Thread-safe search for download item by ID"""
|
||
with self._download_items_lock:
|
||
for item in self._download_items:
|
||
if hasattr(item, 'download_id') and item.download_id == download_id:
|
||
return item
|
||
return None
|
||
|
||
def atomic_state_transition(self, download_item, new_status, callback=None):
|
||
"""Perform atomic state transitions to prevent inconsistencies"""
|
||
with self._state_transition_lock:
|
||
old_status = getattr(download_item, 'status', 'unknown')
|
||
download_item.status = new_status
|
||
if callback:
|
||
callback(download_item, old_status, new_status)
|
||
|
||
def update_id_mapping_safe(self, download_item, new_id):
|
||
"""Thread-safe ID mapping updates"""
|
||
with self._id_mapping_lock:
|
||
old_id = getattr(download_item, 'download_id', None)
|
||
download_item.download_id = new_id
|
||
|
||
class SpotifyMatchingModal(QDialog):
|
||
"""A redesigned modal for matching downloads to Spotify artists and albums."""
|
||
|
||
match_confirmed = pyqtSignal(Artist, Album)
|
||
cancelled = pyqtSignal()
|
||
|
||
def __init__(self, original_result: object, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine, parent=None, is_album=False, album_result=None):
|
||
super().__init__(parent)
|
||
self.original_result = original_result
|
||
self.spotify_client = spotify_client
|
||
self.matching_engine = matching_engine
|
||
self.is_album = is_album
|
||
self.album_result = album_result
|
||
self.image_download_pool = QThreadPool()
|
||
self.image_download_pool.setMaxThreadCount(4)
|
||
self.selected_artist: Optional[Artist] = None
|
||
self.selected_album: Optional[Album] = None
|
||
|
||
self.setWindowTitle("Match Download to Spotify")
|
||
self.setModal(True)
|
||
self.resize(1100, 750)
|
||
|
||
self.setStyleSheet("""
|
||
QDialog { background-color: #121212; border: none; }
|
||
QLabel { color: #FFFFFF; }
|
||
QPushButton {
|
||
background-color: #1DB954; color: #FFFFFF; border: none;
|
||
border-radius: 15px; padding: 10px 20px; font-size: 14px; font-weight: 600;
|
||
}
|
||
QPushButton:hover { background-color: #1ED760; }
|
||
QPushButton:disabled { background-color: #2A2A2A; color: #535353; }
|
||
QPushButton#cancel, QPushButton#skip { background-color: #535353; }
|
||
QPushButton#cancel:hover, QPushButton#skip:hover { background-color: #6A6A6A; }
|
||
QLineEdit {
|
||
background-color: #2A2A2A; border: 2px solid #535353; border-radius: 15px;
|
||
color: white; padding: 12px; font-size: 14px;
|
||
}
|
||
QLineEdit:focus { border: 2px solid #1DB954; }
|
||
QFrame#card {
|
||
background-color: #1E1E1E; border: 2px solid #2A2A2A; border-radius: 12px;
|
||
}
|
||
QFrame#card:hover { border: 2px solid #1DB954; background-color: #282828; }
|
||
""")
|
||
|
||
self.current_stage = "artist"
|
||
self.setup_ui()
|
||
self.generate_auto_artist_suggestions()
|
||
|
||
def setup_ui(self):
|
||
main_layout = QVBoxLayout(self)
|
||
main_layout.setContentsMargins(20, 20, 20, 20)
|
||
main_layout.setSpacing(15)
|
||
|
||
# Different header text based on mode
|
||
if self.is_album:
|
||
header_text = "Step 1: Select the correct Artist"
|
||
else:
|
||
header_text = "Select the correct Artist for this Single"
|
||
self.header_label = QLabel(header_text)
|
||
self.header_label.setStyleSheet("font-size: 22px; font-weight: bold; color: #1DB954;")
|
||
main_layout.addWidget(self.header_label)
|
||
|
||
auto_title = QLabel("Top Suggestions")
|
||
auto_title.setStyleSheet("font-size: 16px; color: #B3B3B3;")
|
||
self.auto_suggestions_layout = QHBoxLayout()
|
||
self.auto_suggestions_layout.setSpacing(20)
|
||
|
||
main_layout.addWidget(auto_title)
|
||
main_layout.addLayout(self.auto_suggestions_layout)
|
||
|
||
manual_title = QLabel("Or, Search Manually")
|
||
manual_title.setStyleSheet("font-size: 16px; color: #B3B3B3; margin-top: 15px;")
|
||
self.search_input = QLineEdit()
|
||
self.search_input.setPlaceholderText("Manually search for an artist...")
|
||
self.search_input.textChanged.connect(self.on_search_text_changed)
|
||
self.manual_results_layout = QHBoxLayout()
|
||
self.manual_results_layout.setSpacing(20)
|
||
|
||
main_layout.addWidget(manual_title)
|
||
main_layout.addWidget(self.search_input)
|
||
main_layout.addLayout(self.manual_results_layout)
|
||
main_layout.addStretch()
|
||
|
||
button_layout = QHBoxLayout()
|
||
self.confirm_btn = QPushButton("Confirm Selection")
|
||
self.confirm_btn.clicked.connect(self.confirm_selection)
|
||
self.confirm_btn.setEnabled(False)
|
||
|
||
skip_btn = QPushButton("Skip Matching")
|
||
skip_btn.setObjectName("skip")
|
||
skip_btn.clicked.connect(self.skip_matching)
|
||
|
||
cancel_btn = QPushButton("Cancel")
|
||
cancel_btn.setObjectName("cancel")
|
||
cancel_btn.clicked.connect(self.reject)
|
||
|
||
button_layout.addWidget(skip_btn)
|
||
button_layout.addStretch()
|
||
button_layout.addWidget(self.confirm_btn)
|
||
button_layout.addWidget(cancel_btn)
|
||
main_layout.addLayout(button_layout)
|
||
|
||
self.search_timer = QTimer()
|
||
self.search_timer.setSingleShot(True)
|
||
self.search_timer.timeout.connect(self.perform_manual_search)
|
||
|
||
def download_and_set_image(self, url: str, target_label: QLabel):
|
||
"""Starts a background worker to download and set an image."""
|
||
worker = ImageDownloader(url, target_label)
|
||
worker.signals.finished.connect(self._on_image_downloaded)
|
||
worker.signals.error.connect(lambda msg: print(f"Image Error: {msg} for url {url}"))
|
||
self.image_download_pool.start(worker)
|
||
|
||
def _on_image_downloaded(self, target_label: QLabel, pixmap: QPixmap):
|
||
"""Slot to apply the downloaded pixmap to the target label."""
|
||
if target_label and not pixmap.isNull():
|
||
# Scale pixmap to fill the label, cropping if necessary
|
||
scaled_pixmap = pixmap.scaled(target_label.size(),
|
||
Qt.AspectRatioMode.KeepAspectRatioByExpanding,
|
||
Qt.TransformationMode.SmoothTransformation)
|
||
target_label.setPixmap(scaled_pixmap)
|
||
|
||
def generate_auto_artist_suggestions(self):
|
||
self._clear_layout(self.auto_suggestions_layout)
|
||
self._show_loading_cards(self.auto_suggestions_layout, "Finding artist...")
|
||
self.suggestion_thread = ArtistSuggestionThread(
|
||
self.original_result, self.spotify_client, self.matching_engine, self.is_album, self.album_result
|
||
)
|
||
self.suggestion_thread.suggestions_ready.connect(self.display_artist_suggestions)
|
||
self.suggestion_thread.start()
|
||
|
||
def generate_auto_album_suggestions(self):
|
||
self._clear_layout(self.auto_suggestions_layout)
|
||
self._show_loading_cards(self.auto_suggestions_layout, "Finding album...")
|
||
|
||
# Use the correct result object for album suggestions.
|
||
# If it's an album download, use the full album_result for context.
|
||
# Otherwise, use the original_result (a single track).
|
||
context_result = self.album_result if self.is_album and self.album_result else self.original_result
|
||
|
||
self.album_suggestion_thread = AlbumSuggestionThread(
|
||
self.selected_artist, context_result, self.spotify_client, self.matching_engine
|
||
)
|
||
self.album_suggestion_thread.suggestions_ready.connect(self.display_album_suggestions)
|
||
self.album_suggestion_thread.start()
|
||
|
||
def display_artist_suggestions(self, suggestions: List[ArtistMatch]):
|
||
self._clear_layout(self.auto_suggestions_layout)
|
||
if not suggestions:
|
||
self.auto_suggestions_layout.addWidget(QLabel("No automatic artist matches found."))
|
||
return
|
||
self.auto_suggestions_layout.addStretch()
|
||
for suggestion in suggestions[:4]:
|
||
self.auto_suggestions_layout.addWidget(self.create_artist_card(suggestion.artist, suggestion.confidence))
|
||
self.auto_suggestions_layout.addStretch()
|
||
|
||
def display_album_suggestions(self, suggestions: List[AlbumMatch]):
|
||
self._clear_layout(self.auto_suggestions_layout)
|
||
if not suggestions:
|
||
self.auto_suggestions_layout.addWidget(QLabel(f"No automatic album matches found for {self.selected_artist.name}."))
|
||
return
|
||
self.auto_suggestions_layout.addStretch()
|
||
for suggestion in suggestions[:4]:
|
||
self.auto_suggestions_layout.addWidget(self.create_album_card(suggestion.album, suggestion.confidence))
|
||
self.auto_suggestions_layout.addStretch()
|
||
|
||
def on_search_text_changed(self):
|
||
self.search_timer.stop()
|
||
if len(self.search_input.text().strip()) >= 2:
|
||
self.search_timer.start(400)
|
||
|
||
def perform_manual_search(self):
|
||
query = self.search_input.text().strip()
|
||
if not query: return
|
||
|
||
self._clear_layout(self.manual_results_layout)
|
||
|
||
if self.current_stage == "artist":
|
||
self._show_loading_cards(self.manual_results_layout, "Searching artists...")
|
||
self.search_thread = ArtistSearchThread(query, self.spotify_client, self.matching_engine, self.original_result)
|
||
self.search_thread.search_results.connect(self.display_manual_artist_results)
|
||
self.search_thread.start()
|
||
else:
|
||
self._show_loading_cards(self.manual_results_layout, "Searching albums...")
|
||
self.search_thread = AlbumSearchThread(query, self.selected_artist, self.spotify_client, self.matching_engine)
|
||
self.search_thread.search_results.connect(self.display_manual_album_results)
|
||
self.search_thread.start()
|
||
|
||
def display_manual_artist_results(self, results: List[ArtistMatch]):
|
||
self._clear_layout(self.manual_results_layout)
|
||
if not results:
|
||
self.manual_results_layout.addWidget(QLabel("No artists found."))
|
||
return
|
||
self.manual_results_layout.addStretch()
|
||
for result in results[:4]:
|
||
self.manual_results_layout.addWidget(self.create_artist_card(result.artist, result.confidence))
|
||
self.manual_results_layout.addStretch()
|
||
|
||
def display_manual_album_results(self, results: List[AlbumMatch]):
|
||
self._clear_layout(self.manual_results_layout)
|
||
if not results:
|
||
self.manual_results_layout.addWidget(QLabel("No albums found."))
|
||
return
|
||
self.manual_results_layout.addStretch()
|
||
for result in results[:4]:
|
||
self.manual_results_layout.addWidget(self.create_album_card(result.album, result.confidence))
|
||
self.manual_results_layout.addStretch()
|
||
|
||
def select_artist(self, artist: Artist):
|
||
self.selected_artist = artist
|
||
print(f"Artist selected: {artist.name}")
|
||
|
||
# For singles mode, we can confirm with just the artist selection
|
||
if not self.is_album:
|
||
self.confirm_btn.setEnabled(True)
|
||
self.confirm_btn.setText(f"Confirm: {artist.name[:30]}...")
|
||
# Update header to indicate completion
|
||
self.header_label.setText("Artist Selected - Ready to Download")
|
||
else:
|
||
# For album mode, proceed to album selection
|
||
self.transition_to_album_stage()
|
||
|
||
def select_album(self, album: Album):
|
||
self.selected_album = album
|
||
print(f"Album selected: {album.name}")
|
||
self.confirm_btn.setEnabled(True)
|
||
self.confirm_btn.setText(f"Confirm: {album.name[:25]}...")
|
||
|
||
def transition_to_album_stage(self):
|
||
self.current_stage = "album"
|
||
self.header_label.setText(f"Step 2: Select Album for {self.selected_artist.name}")
|
||
self.search_input.setPlaceholderText("Manually search for an album...")
|
||
self.search_input.clear()
|
||
self.confirm_btn.setEnabled(False)
|
||
self.confirm_btn.setText("Confirm Selection")
|
||
self._clear_layout(self.manual_results_layout)
|
||
self.generate_auto_album_suggestions()
|
||
|
||
def confirm_selection(self):
|
||
if self.selected_artist:
|
||
# For singles mode, we only need the artist
|
||
if not self.is_album:
|
||
# Create a dummy album object for singles mode
|
||
dummy_album = Album(
|
||
id="singles-dummy",
|
||
name="Singles Collection",
|
||
artists=[self.selected_artist.name],
|
||
total_tracks=1,
|
||
release_date="",
|
||
album_type="single"
|
||
)
|
||
self.match_confirmed.emit(self.selected_artist, dummy_album)
|
||
self.accept()
|
||
# For album mode, we need both artist and album
|
||
elif self.selected_album:
|
||
self.match_confirmed.emit(self.selected_artist, self.selected_album)
|
||
self.accept()
|
||
|
||
def skip_matching(self):
|
||
self.skipped_matching = True
|
||
self.reject()
|
||
|
||
def reject(self):
|
||
if not hasattr(self, 'skipped_matching'):
|
||
self.skipped_matching = False
|
||
# Clean up the image download pool
|
||
self.image_download_pool.clear()
|
||
self.image_download_pool.waitForDone(5000) # Wait max 5 seconds for tasks to finish
|
||
self.cancelled.emit()
|
||
super().reject()
|
||
|
||
def create_artist_card(self, artist: Artist, confidence: float) -> QFrame:
|
||
card = QFrame()
|
||
card.setObjectName("card")
|
||
card.setFixedSize(220, 130)
|
||
# The main card needs a layout to stack widgets
|
||
card_layout = QGridLayout(card)
|
||
card_layout.setContentsMargins(0, 0, 0, 0)
|
||
|
||
# 1. Background Layer (for the image)
|
||
background_label = QLabel()
|
||
background_label.setScaledContents(True)
|
||
background_label.setStyleSheet("border-radius: 12px;")
|
||
|
||
# 2. Gradient Overlay Layer (for text readability)
|
||
gradient_overlay = QWidget()
|
||
gradient_overlay.setStyleSheet("""
|
||
QWidget {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(18, 18, 18, 0.4),
|
||
stop:0.6 rgba(18, 18, 18, 0.7),
|
||
stop:1 rgba(18, 18, 18, 0.9));
|
||
border-radius: 12px;
|
||
}
|
||
""")
|
||
|
||
# 3. Content Layer (the text)
|
||
content_layout = QVBoxLayout(gradient_overlay)
|
||
content_layout.setContentsMargins(12, 12, 12, 12)
|
||
|
||
name = QLabel(artist.name)
|
||
name.setWordWrap(True)
|
||
name.setStyleSheet("font-size: 16px; font-weight: bold; color: white; background: transparent; border: none;")
|
||
|
||
confidence_label = QLabel(f"{confidence:.0%} match")
|
||
confidence_label.setStyleSheet("color: #B3B3B3; font-size: 12px; background: transparent; border: none;")
|
||
|
||
content_layout.addWidget(name)
|
||
content_layout.addStretch()
|
||
content_layout.addWidget(confidence_label)
|
||
|
||
# Stack the layers
|
||
card_layout.addWidget(background_label, 0, 0)
|
||
card_layout.addWidget(gradient_overlay, 0, 0)
|
||
|
||
# Set up interaction
|
||
card.mousePressEvent = lambda event: self.select_artist(artist)
|
||
|
||
# Fetch the artist image in the background
|
||
if hasattr(artist, 'image_url') and artist.image_url:
|
||
self.download_and_set_image(artist.image_url, background_label)
|
||
|
||
return card
|
||
|
||
def create_album_card(self, album: Album, confidence: float) -> QFrame:
|
||
card = QFrame()
|
||
card.setObjectName("card")
|
||
card.setFixedSize(220, 130)
|
||
# The main card needs a layout to stack widgets
|
||
card_layout = QGridLayout(card)
|
||
card_layout.setContentsMargins(0, 0, 0, 0)
|
||
|
||
# 1. Background Layer (for the image)
|
||
background_label = QLabel()
|
||
background_label.setScaledContents(True)
|
||
background_label.setStyleSheet("border-radius: 12px;")
|
||
|
||
# 2. Gradient Overlay Layer (for text readability)
|
||
gradient_overlay = QWidget()
|
||
gradient_overlay.setStyleSheet("""
|
||
QWidget {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(18, 18, 18, 0.4),
|
||
stop:0.6 rgba(18, 18, 18, 0.7),
|
||
stop:1 rgba(18, 18, 18, 0.9));
|
||
border-radius: 12px;
|
||
}
|
||
""")
|
||
|
||
# 3. Content Layer (the text)
|
||
content_layout = QVBoxLayout(gradient_overlay)
|
||
content_layout.setContentsMargins(12, 12, 12, 12)
|
||
|
||
name = QLabel(album.name)
|
||
name.setWordWrap(True)
|
||
name.setStyleSheet("font-size: 14px; font-weight: bold; color: white; background: transparent; border: none;")
|
||
|
||
year = album.release_date.split('-')[0] if album.release_date else ""
|
||
details = QLabel(f"{album.album_type.title()} • {year}")
|
||
details.setStyleSheet("color: #B3B3B3; font-size: 12px; background: transparent; border: none;")
|
||
|
||
content_layout.addWidget(name)
|
||
content_layout.addWidget(details)
|
||
content_layout.addStretch()
|
||
|
||
# Stack the layers
|
||
card_layout.addWidget(background_label, 0, 0)
|
||
card_layout.addWidget(gradient_overlay, 0, 0)
|
||
|
||
# Set up interaction
|
||
card.mousePressEvent = lambda event: self.select_album(album)
|
||
|
||
# Fetch the album image in the background
|
||
if hasattr(album, 'image_url') and album.image_url:
|
||
self.download_and_set_image(album.image_url, background_label)
|
||
|
||
return card
|
||
|
||
def _show_loading_cards(self, layout: QHBoxLayout, text: str):
|
||
layout.addStretch()
|
||
for _ in range(4):
|
||
loading_card = QFrame()
|
||
loading_card.setObjectName("card")
|
||
loading_card.setFixedSize(220, 130)
|
||
card_layout = QVBoxLayout(loading_card)
|
||
card_layout.addWidget(QLabel(text), 0, Qt.AlignmentFlag.AlignCenter)
|
||
layout.addWidget(loading_card)
|
||
layout.addStretch()
|
||
|
||
def _clear_layout(self, layout: QHBoxLayout):
|
||
while layout.count():
|
||
child = layout.takeAt(0)
|
||
if child.widget():
|
||
child.widget().deleteLater()
|
||
|
||
class ArtistSuggestionThread(QThread):
|
||
"""Background thread for generating artist suggestions"""
|
||
|
||
suggestions_ready = pyqtSignal(list)
|
||
|
||
def __init__(self, track_result: TrackResult, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine, is_album=False, album_result=None):
|
||
super().__init__()
|
||
self.track_result = track_result
|
||
self.spotify_client = spotify_client
|
||
self.matching_engine = matching_engine
|
||
self.is_album = is_album
|
||
self.album_result = album_result
|
||
|
||
def run(self):
|
||
"""Generate artist suggestions"""
|
||
try:
|
||
print(f"Starting auto suggestions for: {self.track_result.artist} - {self.track_result.title}")
|
||
suggestions = self.generate_artist_suggestions()
|
||
print(f"Generated {len(suggestions)} auto suggestions")
|
||
self.suggestions_ready.emit(suggestions)
|
||
except Exception as e:
|
||
print(f"Error generating suggestions: {e}")
|
||
self.suggestions_ready.emit([])
|
||
|
||
def generate_artist_suggestions(self) -> List[ArtistMatch]:
|
||
"""Generate artist suggestions using multiple strategies"""
|
||
suggestions = []
|
||
|
||
# Debug logging
|
||
print(f"[DEBUG] Auto suggestion input data:")
|
||
print(f" track_result.artist: '{getattr(self.track_result, 'artist', 'NOT_FOUND')}'")
|
||
print(f" track_result.title: '{getattr(self.track_result, 'title', 'NOT_FOUND')}'")
|
||
print(f" track_result.album: '{getattr(self.track_result, 'album', 'NOT_FOUND')}'")
|
||
print(f" track_result type: {type(self.track_result)}")
|
||
print(f" spotify_client available: {self.spotify_client is not None}")
|
||
print(f" matching_engine available: {self.matching_engine is not None}")
|
||
if self.spotify_client:
|
||
print(f" spotify_client.is_authenticated(): {self.spotify_client.is_authenticated()}")
|
||
print(f" track_result attributes: {[attr for attr in dir(self.track_result) if not attr.startswith('_')]}")
|
||
|
||
# Special handling for albums - use album title to find artist instead of track data
|
||
if self.is_album and self.album_result and self.album_result.album_title:
|
||
print(f"[DEBUG] Album mode detected - using album title for artist search")
|
||
print(f" album_title: '{self.album_result.album_title}'")
|
||
print(f" album_artist: '{getattr(self.album_result, 'artist', 'NOT_FOUND')}'")
|
||
|
||
# Clean album title for searching (remove year prefixes like "(2005)")
|
||
album_title = self.album_result.album_title
|
||
import re
|
||
clean_album_title = re.sub(r'^\(\d{4}\)\s*', '', album_title).strip()
|
||
print(f" clean_album_title: '{clean_album_title}'")
|
||
|
||
# Strategy: Search tracks using album title to find the artist
|
||
print(f"Album Strategy: Searching tracks for album '{clean_album_title}'")
|
||
tracks = self.spotify_client.search_tracks(clean_album_title, limit=20)
|
||
print(f"Found {len(tracks)} tracks from album search")
|
||
|
||
# Collect unique artist names and their associated tracks/albums first
|
||
unique_artists = {} # artist_name -> list of (track, album) tuples
|
||
for track in tracks:
|
||
for artist_name in track.artists:
|
||
if artist_name not in unique_artists:
|
||
unique_artists[artist_name] = []
|
||
unique_artists[artist_name].append((track, track.album))
|
||
|
||
print(f"[PERF] Found {len(unique_artists)} unique artists to lookup (down from {sum(len(track.artists) for track in tracks)} total)")
|
||
|
||
# Batch fetch artist objects using concurrent futures for speed
|
||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||
import time
|
||
|
||
start_time = time.time()
|
||
artist_objects = {} # artist_name -> Artist object
|
||
|
||
def fetch_artist(artist_name):
|
||
"""Fetch single artist with error handling"""
|
||
try:
|
||
matches = self.spotify_client.search_artists(artist_name, limit=1)
|
||
if matches:
|
||
return artist_name, matches[0]
|
||
except Exception as e:
|
||
print(f"Error fetching artist '{artist_name}': {e}")
|
||
return artist_name, None
|
||
|
||
# Use limited concurrency to respect rate limits while improving speed
|
||
with ThreadPoolExecutor(max_workers=3) as executor:
|
||
future_to_artist = {executor.submit(fetch_artist, name): name for name in unique_artists.keys()}
|
||
|
||
for future in as_completed(future_to_artist):
|
||
artist_name, artist_obj = future.result()
|
||
if artist_obj:
|
||
artist_objects[artist_name] = artist_obj
|
||
|
||
fetch_time = time.time() - start_time
|
||
print(f"[PERF] Fetched {len(artist_objects)} artists in {fetch_time:.2f}s using concurrent API calls")
|
||
|
||
# Now calculate confidence scores for each artist
|
||
artist_scores = {}
|
||
for artist_name, track_album_pairs in unique_artists.items():
|
||
if artist_name not in artist_objects:
|
||
continue
|
||
|
||
artist = artist_objects[artist_name]
|
||
best_confidence = 0
|
||
best_album_match = ""
|
||
|
||
# Find the best confidence score across all albums for this artist
|
||
for track, album in track_album_pairs:
|
||
# Calculate confidence based on album title match
|
||
confidence = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(clean_album_title),
|
||
self.matching_engine.normalize_string(album)
|
||
)
|
||
|
||
# Boost confidence if album artist matches
|
||
if hasattr(self.album_result, 'artist') and self.album_result.artist:
|
||
artist_confidence = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(self.album_result.artist),
|
||
self.matching_engine.normalize_string(artist.name)
|
||
)
|
||
confidence = max(confidence, artist_confidence)
|
||
|
||
# Keep highest confidence for this artist
|
||
if confidence > best_confidence:
|
||
best_confidence = confidence
|
||
best_album_match = album
|
||
|
||
# Store the artist with their best confidence
|
||
artist_scores[artist.id] = {
|
||
'artist': artist,
|
||
'confidence': best_confidence,
|
||
'album_match': best_album_match
|
||
}
|
||
|
||
# Add high-confidence album artists to suggestions
|
||
for artist_data in artist_scores.values():
|
||
if artist_data['confidence'] >= 0.6: # Higher threshold for album matches
|
||
print(f"Added album artist match: {artist_data['artist'].name} ({artist_data['confidence']:.2f}) via '{artist_data['album_match']}'")
|
||
suggestions.append(ArtistMatch(
|
||
artist=artist_data['artist'],
|
||
confidence=artist_data['confidence'],
|
||
match_reason=f"Album match via '{artist_data['album_match']}'"
|
||
))
|
||
|
||
print(f"[DEBUG] Album strategy generated {len(suggestions)} suggestions")
|
||
|
||
# If we found good album matches, return them (don't try track-based strategies)
|
||
if suggestions:
|
||
# Remove duplicates and sort by confidence
|
||
unique_suggestions = {}
|
||
for suggestion in suggestions:
|
||
if suggestion.artist.id not in unique_suggestions or unique_suggestions[suggestion.artist.id].confidence < suggestion.confidence:
|
||
unique_suggestions[suggestion.artist.id] = suggestion
|
||
|
||
final_suggestions = sorted(unique_suggestions.values(), key=lambda x: x.confidence, reverse=True)
|
||
print(f"[DEBUG] Returning {len(final_suggestions)} album-based suggestions")
|
||
return final_suggestions[:5]
|
||
|
||
# Try to get artist name from different sources (for singles or fallback)
|
||
artist_name = None
|
||
if self.track_result.artist and self.track_result.artist != "Unknown Artist":
|
||
artist_name = self.track_result.artist
|
||
elif hasattr(self.track_result, 'user') and self.track_result.user:
|
||
# Sometimes the artist might be in the user field
|
||
artist_name = self.track_result.user
|
||
elif hasattr(self.track_result, 'filename') and self.track_result.filename:
|
||
# Try to extract artist from filename
|
||
import os
|
||
filename = os.path.basename(self.track_result.filename)
|
||
if ' - ' in filename:
|
||
artist_name = filename.split(' - ')[0].strip()
|
||
|
||
print(f"[DEBUG] Determined artist name: '{artist_name}'")
|
||
|
||
# Strategy 1: Search for the artist name directly
|
||
if artist_name and artist_name != "Unknown Artist":
|
||
artist_query = self.matching_engine.normalize_string(artist_name)
|
||
print(f"Strategy 1: Searching for artist '{artist_query}'")
|
||
artists = self.spotify_client.search_artists(artist_query, limit=10)
|
||
print(f"Found {len(artists)} artists from Spotify")
|
||
|
||
for artist in artists:
|
||
confidence = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(artist_name),
|
||
self.matching_engine.normalize_string(artist.name)
|
||
)
|
||
|
||
if confidence >= 0.3: # Minimum threshold
|
||
print(f"Added artist match: {artist.name} ({confidence:.2f})")
|
||
suggestions.append(ArtistMatch(
|
||
artist=artist,
|
||
confidence=confidence,
|
||
match_reason="Artist name match"
|
||
))
|
||
else:
|
||
print(f"Strategy 1 skipped: artist_name='{artist_name}', original_artist='{getattr(self.track_result, 'artist', 'NO_ATTR')}'")
|
||
|
||
# Strategy 2: Search for "artist - title" combination
|
||
if artist_name and self.track_result.title:
|
||
combined_query = f"{artist_name} {self.track_result.title}"
|
||
print(f"Strategy 2: Searching for combined query '{combined_query}'")
|
||
tracks = self.spotify_client.search_tracks(combined_query, limit=10)
|
||
print(f"Found {len(tracks)} tracks from Spotify")
|
||
|
||
for track in tracks:
|
||
for artist_name in track.artists:
|
||
# Find matching artist
|
||
artist_matches = self.spotify_client.search_artists(artist_name, limit=1)
|
||
if artist_matches:
|
||
artist = artist_matches[0]
|
||
|
||
# Calculate combined confidence based on artist and title match
|
||
artist_confidence = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(artist_name),
|
||
self.matching_engine.normalize_string(artist.name)
|
||
)
|
||
title_confidence = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(self.track_result.title),
|
||
self.matching_engine.normalize_string(track.name)
|
||
)
|
||
|
||
combined_confidence = (artist_confidence * 0.7 + title_confidence * 0.3)
|
||
|
||
if combined_confidence >= 0.4:
|
||
suggestions.append(ArtistMatch(
|
||
artist=artist,
|
||
confidence=combined_confidence,
|
||
match_reason="Track match"
|
||
))
|
||
|
||
# Remove duplicates and sort by confidence
|
||
unique_suggestions = {}
|
||
for suggestion in suggestions:
|
||
if suggestion.artist.id not in unique_suggestions or unique_suggestions[suggestion.artist.id].confidence < suggestion.confidence:
|
||
unique_suggestions[suggestion.artist.id] = suggestion
|
||
|
||
final_suggestions = sorted(unique_suggestions.values(), key=lambda x: x.confidence, reverse=True)
|
||
|
||
# Debug final results
|
||
print(f"[DEBUG] Final suggestions count: {len(final_suggestions)}")
|
||
for i, suggestion in enumerate(final_suggestions[:5]):
|
||
print(f" {i+1}. {suggestion.artist.name} ({suggestion.confidence:.2f}) - {suggestion.match_reason}")
|
||
|
||
return final_suggestions[:5]
|
||
|
||
class ArtistSearchThread(QThread):
|
||
"""Background thread for manual artist search"""
|
||
|
||
search_results = pyqtSignal(list)
|
||
|
||
def __init__(self, query: str, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine, track_result: TrackResult):
|
||
super().__init__()
|
||
self.query = query
|
||
self.spotify_client = spotify_client
|
||
self.matching_engine = matching_engine
|
||
self.track_result = track_result
|
||
|
||
def run(self):
|
||
"""Perform artist search"""
|
||
try:
|
||
artists = self.spotify_client.search_artists(self.query, limit=10)
|
||
results = []
|
||
|
||
for artist in artists:
|
||
# Calculate confidence based on search query match
|
||
confidence = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(self.query),
|
||
self.matching_engine.normalize_string(artist.name)
|
||
)
|
||
|
||
# Boost confidence if it also matches the original track artist
|
||
if self.track_result.artist:
|
||
original_match = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(self.track_result.artist),
|
||
self.matching_engine.normalize_string(artist.name)
|
||
)
|
||
confidence = max(confidence, original_match)
|
||
|
||
results.append(ArtistMatch(
|
||
artist=artist,
|
||
confidence=confidence,
|
||
match_reason="Search result"
|
||
))
|
||
|
||
# Sort by confidence
|
||
results.sort(key=lambda x: x.confidence, reverse=True)
|
||
self.search_results.emit(results)
|
||
|
||
except Exception as e:
|
||
print(f"Error searching artists: {e}")
|
||
self.search_results.emit([])
|
||
|
||
class AlbumSearchThread(QThread):
|
||
"""Background thread for album search by artist"""
|
||
|
||
search_results = pyqtSignal(list)
|
||
|
||
def __init__(self, query: str, artist: Artist, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine):
|
||
super().__init__()
|
||
self.query = query
|
||
self.artist = artist
|
||
self.spotify_client = spotify_client
|
||
self.matching_engine = matching_engine
|
||
|
||
def run(self):
|
||
"""Perform album search"""
|
||
try:
|
||
# Search for albums by the selected artist
|
||
search_query = f"artist:{self.artist.name} {self.query}"
|
||
albums = self.spotify_client.search_albums(search_query, limit=10)
|
||
results = []
|
||
|
||
for album in albums:
|
||
# Check if this album is actually by our selected artist
|
||
artist_match = False
|
||
for album_artist in album.artists:
|
||
if self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(self.artist.name),
|
||
self.matching_engine.normalize_string(album_artist)
|
||
) >= 0.8:
|
||
artist_match = True
|
||
break
|
||
|
||
if artist_match:
|
||
# Calculate confidence based on search query match with album name
|
||
confidence = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(self.query),
|
||
self.matching_engine.normalize_string(album.name)
|
||
)
|
||
|
||
results.append(AlbumMatch(
|
||
album=album,
|
||
confidence=confidence,
|
||
match_reason="Album search result"
|
||
))
|
||
|
||
# Sort by confidence
|
||
results.sort(key=lambda x: x.confidence, reverse=True)
|
||
self.search_results.emit(results)
|
||
|
||
except Exception as e:
|
||
print(f"Error searching albums: {e}")
|
||
self.search_results.emit([])
|
||
|
||
class AlbumSuggestionThread(QThread):
|
||
"""Background thread for generating automatic album suggestions for a given artist."""
|
||
|
||
suggestions_ready = pyqtSignal(list)
|
||
|
||
def __init__(self, selected_artist: Artist, original_result: object, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine):
|
||
super().__init__()
|
||
self.artist = selected_artist
|
||
self.original_result = original_result
|
||
self.spotify_client = spotify_client
|
||
self.matching_engine = matching_engine
|
||
|
||
def run(self):
|
||
"""Fetch albums for the artist and find the best matches."""
|
||
try:
|
||
import re # Import the regular expression module
|
||
|
||
target_album_name = ""
|
||
if isinstance(self.original_result, AlbumResult):
|
||
target_album_name = self.original_result.album_title
|
||
print(f"Album context for auto-match from AlbumResult: '{target_album_name}'")
|
||
elif hasattr(self.original_result, 'album') and self.original_result.album:
|
||
target_album_name = self.original_result.album
|
||
print(f"Album context for auto-match from TrackResult: '{target_album_name}'")
|
||
else:
|
||
target_album_name = self.original_result.title
|
||
print(f"Album context for auto-match using fallback to track title: '{target_album_name}'")
|
||
|
||
if not target_album_name:
|
||
self.suggestions_ready.emit([])
|
||
return
|
||
|
||
# More aggressive cleaning for the search query.
|
||
# 1. Remove bracketed content like [flac], (Explicit), [2024], etc.
|
||
cleaned_search_term = re.sub(r'\s*[\[\(].*?[\]\)]', '', target_album_name).strip()
|
||
|
||
# 2. Remove the artist's name from the string if it's present.
|
||
artist_pattern = r'^' + re.escape(self.artist.name) + r'\s*-\s*'
|
||
cleaned_search_term = re.sub(artist_pattern, '', cleaned_search_term, flags=re.IGNORECASE)
|
||
|
||
# 3. Clean up any remaining leading/trailing dashes or spaces.
|
||
cleaned_search_term = cleaned_search_term.strip(' -')
|
||
|
||
print(f"Cleaned album search term: '{target_album_name}' -> '{cleaned_search_term}'")
|
||
|
||
search_query = f"artist:{self.artist.name} album:{cleaned_search_term}"
|
||
print(f"Searching Spotify for albums with query: '{search_query}'")
|
||
|
||
spotify_albums = self.spotify_client.search_albums(search_query, limit=10)
|
||
print(f"Found {len(spotify_albums)} potential albums from Spotify search.")
|
||
|
||
suggestions = []
|
||
for album in spotify_albums:
|
||
is_correct_artist = any(self.matching_engine.similarity_score(self.artist.name, art) > 0.85 for art in album.artists)
|
||
|
||
if not is_correct_artist:
|
||
print(f"Skipping album '{album.name}' as artist does not match '{self.artist.name}'")
|
||
continue
|
||
|
||
confidence = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(target_album_name),
|
||
self.matching_engine.normalize_string(album.name)
|
||
)
|
||
|
||
if self.matching_engine.normalize_string(cleaned_search_term) in self.matching_engine.normalize_string(album.name):
|
||
confidence = max(confidence, 0.95)
|
||
|
||
if confidence >= 0.5:
|
||
print(f"Found album match: '{album.name}' with confidence {confidence:.2f}")
|
||
suggestions.append(AlbumMatch(
|
||
album=album,
|
||
confidence=confidence,
|
||
match_reason="Direct album search"
|
||
))
|
||
|
||
# **IMPROVEMENT**: Intelligently de-duplicate results with the same name.
|
||
# This prefers versions marked as 'album' and those with more tracks.
|
||
unique_suggestions = {}
|
||
for suggestion in suggestions:
|
||
album_key = self.matching_engine.normalize_string(suggestion.album.name)
|
||
|
||
if album_key not in unique_suggestions:
|
||
unique_suggestions[album_key] = suggestion
|
||
else:
|
||
existing_suggestion = unique_suggestions[album_key]
|
||
is_new_better = False
|
||
|
||
# Higher confidence is always better
|
||
if suggestion.confidence > existing_suggestion.confidence:
|
||
is_new_better = True
|
||
elif suggestion.confidence == existing_suggestion.confidence:
|
||
# 'album' type is preferred over 'single'
|
||
if suggestion.album.album_type == 'album' and existing_suggestion.album.album_type != 'album':
|
||
is_new_better = True
|
||
# More tracks is better if types are the same
|
||
elif suggestion.album.album_type == existing_suggestion.album.album_type and hasattr(suggestion.album, 'total_tracks') and hasattr(existing_suggestion.album, 'total_tracks') and suggestion.album.total_tracks > existing_suggestion.album.total_tracks:
|
||
is_new_better = True
|
||
|
||
if is_new_better:
|
||
print(f"Replacing duplicate album '{album_key}' with a better version (type: {suggestion.album.album_type}, tracks: {getattr(suggestion.album, 'total_tracks', 'N/A')})")
|
||
unique_suggestions[album_key] = suggestion
|
||
|
||
final_suggestions = sorted(unique_suggestions.values(), key=lambda x: x.confidence, reverse=True)
|
||
|
||
print(f"Generated {len(final_suggestions)} final album suggestions.")
|
||
self.suggestions_ready.emit(final_suggestions[:4])
|
||
|
||
except Exception as e:
|
||
print(f"Error generating album suggestions: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
self.suggestions_ready.emit([])
|
||
|
||
|
||
class BouncingDotsWidget(QWidget):
|
||
"""Animated bouncing dots loading indicator"""
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__(parent)
|
||
self.setFixedSize(60, 20)
|
||
self.dots = ['●', '●', '●']
|
||
self._current_dot = 0
|
||
|
||
# Animation setup
|
||
self.setup_animation()
|
||
|
||
def setup_animation(self):
|
||
"""Set up the bouncing animation sequence"""
|
||
self.timer = QTimer()
|
||
self.timer.timeout.connect(self.update_dots)
|
||
|
||
def start_animation(self):
|
||
"""Start the bouncing animation"""
|
||
self.timer.start(400) # Update every 400ms for smoother bouncing
|
||
|
||
def stop_animation(self):
|
||
"""Stop the bouncing animation"""
|
||
if hasattr(self, 'timer'):
|
||
self.timer.stop()
|
||
self._current_dot = 0
|
||
self.update()
|
||
|
||
def update_dots(self):
|
||
"""Update which dot is bouncing"""
|
||
self._current_dot = (self._current_dot + 1) % 3
|
||
self.update()
|
||
|
||
def get_current_dot(self):
|
||
return self._current_dot
|
||
|
||
def set_current_dot(self, value):
|
||
self._current_dot = value
|
||
self.update()
|
||
|
||
# Create the Qt property for animation system
|
||
current_dot = pyqtProperty(int, get_current_dot, set_current_dot)
|
||
|
||
def paintEvent(self, event):
|
||
"""Custom paint event to draw the bouncing dots"""
|
||
painter = QPainter(self)
|
||
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
|
||
|
||
# Set color and font
|
||
painter.setPen(QPen(Qt.GlobalColor.white, 2))
|
||
font = painter.font()
|
||
font.setPointSize(12)
|
||
painter.setFont(font)
|
||
|
||
# Draw three dots with bouncing effect
|
||
dot_width = 20
|
||
for i in range(3):
|
||
x = i * dot_width
|
||
y = 15 if i == self._current_dot else 10 # Bounce effect
|
||
|
||
# Make current dot larger and brighter
|
||
if i == self._current_dot:
|
||
painter.setPen(QPen(Qt.GlobalColor.green, 3))
|
||
else:
|
||
painter.setPen(QPen(Qt.GlobalColor.gray, 2))
|
||
|
||
painter.drawText(x, y, self.dots[i])
|
||
|
||
class SpinningCircleWidget(QWidget):
|
||
"""Animated spinning circle loading indicator"""
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__(parent)
|
||
self.setFixedSize(60, 60) # Increased from 30x30 to 60x60
|
||
self._angle = 0
|
||
|
||
# Animation setup
|
||
self.animation = QPropertyAnimation(self, b"rotation_angle")
|
||
self.animation.setDuration(1000) # 1 second per rotation
|
||
self.animation.setStartValue(0)
|
||
self.animation.setEndValue(360)
|
||
self.animation.setLoopCount(-1) # Infinite loop
|
||
self.animation.setEasingCurve(QEasingCurve.Type.Linear)
|
||
|
||
def start_animation(self):
|
||
"""Start the spinning animation"""
|
||
self.animation.start()
|
||
|
||
def stop_animation(self):
|
||
"""Stop the spinning animation"""
|
||
self.animation.stop()
|
||
self._angle = 0
|
||
self.update()
|
||
|
||
def get_rotation_angle(self):
|
||
return self._angle
|
||
|
||
def set_rotation_angle(self, angle):
|
||
self._angle = angle
|
||
self.update()
|
||
|
||
rotation_angle = pyqtProperty(float, get_rotation_angle, set_rotation_angle)
|
||
|
||
def paintEvent(self, event):
|
||
"""Custom paint event to draw the spinning circle"""
|
||
painter = QPainter(self)
|
||
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
|
||
|
||
# Set up the painting area
|
||
rect = self.rect()
|
||
center_x = rect.width() // 2
|
||
center_y = rect.height() // 2
|
||
radius = min(center_x, center_y) - 2
|
||
|
||
# Rotate the painter
|
||
painter.translate(center_x, center_y)
|
||
painter.rotate(self._angle)
|
||
|
||
# Draw circle segments with varying opacity
|
||
pen = QPen(Qt.GlobalColor.green, 3)
|
||
painter.setPen(pen)
|
||
|
||
# Draw 8 dots around the circle
|
||
import math
|
||
for i in range(8):
|
||
angle_step = 2 * math.pi / 8
|
||
dot_angle = i * angle_step
|
||
|
||
# Calculate position for each dot
|
||
x = radius * 0.7 * math.cos(dot_angle)
|
||
y = radius * 0.7 * math.sin(dot_angle)
|
||
|
||
# Fade effect - dots further from current position are dimmer
|
||
distance = abs(i - (self._angle / 45)) % 8
|
||
opacity = max(0.2, 1.0 - distance * 0.15)
|
||
|
||
# Set color with proper opacity using QColor and alpha channel
|
||
color = QColor(29, 185, 84) # App's green theme color
|
||
color.setAlpha(int(opacity * 255)) # Apply calculated opacity
|
||
pen.setColor(color)
|
||
painter.setPen(pen)
|
||
|
||
painter.drawEllipse(int(x-2), int(y-2), 4, 4)
|
||
|
||
class AudioPlayer(QMediaPlayer):
|
||
"""Simple audio player for streaming music files"""
|
||
playback_finished = pyqtSignal()
|
||
playback_error = pyqtSignal(str)
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__(parent)
|
||
|
||
# Set up audio output
|
||
self.audio_output = QAudioOutput()
|
||
self.setAudioOutput(self.audio_output)
|
||
|
||
# Connect signals
|
||
self.mediaStatusChanged.connect(self._on_media_status_changed)
|
||
self.errorOccurred.connect(self._on_error_occurred)
|
||
self.playbackStateChanged.connect(self._on_playback_state_changed)
|
||
|
||
# Track current file
|
||
self.current_file_path = None
|
||
self.is_playing = False
|
||
|
||
def _on_playback_state_changed(self, state):
|
||
"""Keep is_playing flag synchronized with actual playback state"""
|
||
from PyQt6.QtMultimedia import QMediaPlayer
|
||
state_names = {
|
||
QMediaPlayer.PlaybackState.StoppedState: "STOPPED",
|
||
QMediaPlayer.PlaybackState.PlayingState: "PLAYING",
|
||
QMediaPlayer.PlaybackState.PausedState: "PAUSED"
|
||
}
|
||
print(f"AudioPlayer state changed to: {state_names.get(state, 'UNKNOWN')}")
|
||
self.is_playing = (state == QMediaPlayer.PlaybackState.PlayingState)
|
||
|
||
def play_file(self, file_path):
|
||
"""Play an audio file from the given path"""
|
||
try:
|
||
if not file_path or not os.path.exists(file_path):
|
||
self.playback_error.emit(f"File not found: {file_path}")
|
||
return False
|
||
|
||
# Stop any current playback
|
||
self.stop()
|
||
|
||
# Set the new media source
|
||
self.current_file_path = file_path
|
||
self.setSource(QUrl.fromLocalFile(file_path))
|
||
|
||
# Start playback
|
||
self.play()
|
||
# is_playing will be set automatically by _on_playback_state_changed
|
||
|
||
print(f"Started playing: {os.path.basename(file_path)}")
|
||
return True
|
||
|
||
except Exception as e:
|
||
error_msg = f"Error playing audio file: {str(e)}"
|
||
print(error_msg)
|
||
self.playback_error.emit(error_msg)
|
||
return False
|
||
|
||
def toggle_playback(self):
|
||
"""Toggle between play and pause"""
|
||
current_state = self.playbackState()
|
||
print(f"toggle_playback() - Current state: {current_state}")
|
||
print(f"toggle_playback() - Current source: {self.source().toString()}")
|
||
|
||
if current_state == QMediaPlayer.PlaybackState.PlayingState:
|
||
print("AudioPlayer: Pausing playback")
|
||
self.pause()
|
||
# is_playing will be set automatically by _on_playback_state_changed
|
||
return False # Now paused
|
||
else:
|
||
print("AudioPlayer: Attempting to resume/play")
|
||
|
||
# Check if we have a valid source to play
|
||
if not self.source().isValid() and self.current_file_path:
|
||
print(f"AudioPlayer: No source set, restoring from: {self.current_file_path}")
|
||
self.setSource(QUrl.fromLocalFile(self.current_file_path))
|
||
|
||
self.play()
|
||
# is_playing will be set automatically by _on_playback_state_changed
|
||
return True # Now playing
|
||
|
||
def stop_playback(self):
|
||
"""Stop playback and reset"""
|
||
print("AudioPlayer: stop_playback() called")
|
||
self.stop()
|
||
# is_playing will be set automatically by _on_playback_state_changed
|
||
self.release_file()
|
||
|
||
def release_file(self, clear_file_path=True):
|
||
"""Release the current file handle by clearing the media source
|
||
|
||
Args:
|
||
clear_file_path (bool): Whether to clear the stored file path.
|
||
Set to False to keep the path for potential resuming.
|
||
"""
|
||
print(f"AudioPlayer: release_file() called - clearing source: {self.source().toString()}")
|
||
self.setSource(QUrl()) # Clear the media source to release file handle
|
||
if clear_file_path:
|
||
self.current_file_path = None
|
||
print("Released audio file handle")
|
||
|
||
def _on_media_status_changed(self, status):
|
||
"""Handle media status changes"""
|
||
if status == QMediaPlayer.MediaStatus.EndOfMedia:
|
||
print("Playback finished")
|
||
# is_playing will be set automatically by _on_playback_state_changed
|
||
self.playback_finished.emit()
|
||
elif status == QMediaPlayer.MediaStatus.InvalidMedia:
|
||
error_msg = "Invalid media file or unsupported format"
|
||
print(f"{error_msg}")
|
||
# is_playing will be set automatically by _on_playback_state_changed
|
||
self.playback_error.emit(error_msg)
|
||
|
||
def _on_error_occurred(self, error, error_string):
|
||
"""Handle playback errors"""
|
||
error_msg = f"Audio playback error: {error_string}"
|
||
print(f"{error_msg}")
|
||
# is_playing will be set automatically by _on_playback_state_changed
|
||
self.playback_error.emit(error_msg)
|
||
|
||
class DownloadThread(QThread):
|
||
download_completed = pyqtSignal(str, object) # Download ID or success message, download_item
|
||
download_failed = pyqtSignal(str, object) # Error message, download_item
|
||
download_progress = pyqtSignal(str, object) # Progress message, download_item
|
||
|
||
def __init__(self, soulseek_client, search_result, download_item):
|
||
super().__init__()
|
||
self.soulseek_client = soulseek_client
|
||
self.search_result = search_result
|
||
self.download_item = download_item
|
||
self._stop_requested = False
|
||
|
||
def run(self):
|
||
loop = None
|
||
try:
|
||
import asyncio
|
||
self.download_progress.emit(f"Starting download: {self.search_result.filename}", self.download_item)
|
||
|
||
# Create a completely fresh event loop for this thread
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
# Perform download with proper error handling
|
||
download_id = loop.run_until_complete(self._do_download())
|
||
|
||
if not self._stop_requested:
|
||
if download_id:
|
||
self.download_completed.emit(f"Download started: {download_id}", self.download_item)
|
||
else:
|
||
self.download_failed.emit("Download failed to start", self.download_item)
|
||
|
||
# Give signals time to be processed before thread exits
|
||
import time
|
||
time.sleep(0.1)
|
||
|
||
except Exception as e:
|
||
if not self._stop_requested:
|
||
self.download_failed.emit(str(e), self.download_item)
|
||
# Give error signal time to be processed
|
||
import time
|
||
time.sleep(0.1)
|
||
finally:
|
||
# Ensure proper cleanup
|
||
if loop:
|
||
try:
|
||
# Close any remaining tasks
|
||
pending = asyncio.all_tasks(loop)
|
||
for task in pending:
|
||
task.cancel()
|
||
|
||
if pending:
|
||
loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
|
||
|
||
loop.close()
|
||
except Exception as e:
|
||
print(f"Error cleaning up download event loop: {e}")
|
||
|
||
async def _do_download(self):
|
||
"""Perform the actual download with proper async handling"""
|
||
return await self.soulseek_client.download(
|
||
self.search_result.username,
|
||
self.search_result.filename,
|
||
self.search_result.size
|
||
)
|
||
|
||
def stop(self):
|
||
"""Stop the download gracefully"""
|
||
self._stop_requested = True
|
||
|
||
class SessionInfoThread(QThread):
|
||
session_info_completed = pyqtSignal(dict) # Session info dict
|
||
session_info_failed = pyqtSignal(str) # Error message
|
||
|
||
def __init__(self, soulseek_client):
|
||
super().__init__()
|
||
self.soulseek_client = soulseek_client
|
||
self._stop_requested = False
|
||
|
||
def run(self):
|
||
loop = None
|
||
try:
|
||
import asyncio
|
||
|
||
# Create a completely fresh event loop for this thread
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
# Check if stop was requested before starting
|
||
if self._stop_requested:
|
||
return
|
||
|
||
# Get session info
|
||
session_info = loop.run_until_complete(self._get_session_info())
|
||
|
||
# Only emit if not stopped
|
||
if not self._stop_requested:
|
||
self.session_info_completed.emit(session_info or {})
|
||
|
||
except Exception as e:
|
||
if not self._stop_requested:
|
||
self.session_info_failed.emit(str(e))
|
||
finally:
|
||
# Ensure proper cleanup
|
||
if loop:
|
||
try:
|
||
# Close any remaining tasks
|
||
pending = asyncio.all_tasks(loop)
|
||
for task in pending:
|
||
task.cancel()
|
||
|
||
if pending:
|
||
loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
|
||
|
||
loop.close()
|
||
except Exception as e:
|
||
print(f"Error cleaning up session info event loop: {e}")
|
||
|
||
async def _get_session_info(self):
|
||
"""Get the session information"""
|
||
return await self.soulseek_client.get_session_info()
|
||
|
||
def stop(self):
|
||
"""Stop the session info gathering gracefully"""
|
||
self._stop_requested = True
|
||
|
||
class ExploreApiThread(QThread):
|
||
exploration_completed = pyqtSignal(dict) # API info dict
|
||
exploration_failed = pyqtSignal(str) # Error message
|
||
|
||
def __init__(self, soulseek_client):
|
||
super().__init__()
|
||
self.soulseek_client = soulseek_client
|
||
self._stop_requested = False
|
||
|
||
def run(self):
|
||
loop = None
|
||
try:
|
||
import asyncio
|
||
|
||
# Create a completely fresh event loop for this thread
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
# Check if stop was requested before starting
|
||
if self._stop_requested:
|
||
return
|
||
|
||
# Explore the API
|
||
api_info = loop.run_until_complete(self._explore_api())
|
||
|
||
# Only emit if not stopped
|
||
if not self._stop_requested:
|
||
self.exploration_completed.emit(api_info)
|
||
|
||
except Exception as e:
|
||
if not self._stop_requested:
|
||
self.exploration_failed.emit(str(e))
|
||
finally:
|
||
# Ensure proper cleanup
|
||
if loop:
|
||
try:
|
||
# Close any remaining tasks
|
||
pending = asyncio.all_tasks(loop)
|
||
for task in pending:
|
||
task.cancel()
|
||
|
||
if pending:
|
||
loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
|
||
|
||
loop.close()
|
||
except Exception as e:
|
||
print(f"Error cleaning up exploration event loop: {e}")
|
||
|
||
async def _explore_api(self):
|
||
"""Perform the actual API exploration"""
|
||
return await self.soulseek_client.explore_api_endpoints()
|
||
|
||
def stop(self):
|
||
"""Stop the exploration gracefully"""
|
||
self._stop_requested = True
|
||
|
||
class TransferStatusThread(QThread):
|
||
"""Thread for fetching real-time download transfer status from slskd API"""
|
||
transfer_status_completed = pyqtSignal(object) # Transfer data from API
|
||
transfer_status_failed = pyqtSignal(str) # Error message
|
||
|
||
def __init__(self, soulseek_client):
|
||
super().__init__()
|
||
self.soulseek_client = soulseek_client
|
||
self._stop_requested = False
|
||
|
||
def run(self):
|
||
loop = None
|
||
try:
|
||
import asyncio
|
||
|
||
# Create a fresh event loop for this thread
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
# Check if stop was requested before starting
|
||
if self._stop_requested:
|
||
return
|
||
|
||
# Get transfer status data from /api/v0/transfers/downloads
|
||
transfer_data = loop.run_until_complete(self._get_transfer_status())
|
||
|
||
# Only emit if not stopped
|
||
if not self._stop_requested:
|
||
self.transfer_status_completed.emit(transfer_data or [])
|
||
|
||
except Exception as e:
|
||
if not self._stop_requested:
|
||
self.transfer_status_failed.emit(str(e))
|
||
finally:
|
||
# Ensure proper cleanup
|
||
if loop:
|
||
try:
|
||
# Close any remaining tasks
|
||
pending = asyncio.all_tasks(loop)
|
||
for task in pending:
|
||
task.cancel()
|
||
|
||
if pending:
|
||
loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
|
||
|
||
loop.close()
|
||
except Exception as e:
|
||
print(f"Error cleaning up transfer status event loop: {e}")
|
||
|
||
async def _get_transfer_status(self):
|
||
"""Get the transfer status from slskd API"""
|
||
try:
|
||
# Use the soulseek client's _make_request method to get transfer data
|
||
response_data = await self.soulseek_client._make_request('GET', 'transfers/downloads')
|
||
return response_data
|
||
except Exception as e:
|
||
print(f"Error fetching transfer status: {e}")
|
||
return []
|
||
|
||
def stop(self):
|
||
"""Stop the transfer status gathering gracefully"""
|
||
self._stop_requested = True
|
||
|
||
class ApiCleanupThread(QThread):
|
||
"""Thread for signaling download completion to slskd API without blocking UI"""
|
||
cleanup_completed = pyqtSignal(bool, str, str) # success, download_id, username
|
||
|
||
def __init__(self, soulseek_client, download_id, username):
|
||
super().__init__()
|
||
self.soulseek_client = soulseek_client
|
||
self.download_id = download_id
|
||
self.username = username
|
||
|
||
def run(self):
|
||
"""Signal download completion in background thread"""
|
||
loop = None
|
||
try:
|
||
import asyncio
|
||
|
||
# Create a fresh event loop for this thread
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
# Signal download completion
|
||
success = loop.run_until_complete(
|
||
self.soulseek_client.signal_download_completion(
|
||
self.download_id,
|
||
self.username,
|
||
remove=True
|
||
)
|
||
)
|
||
|
||
# Emit completion signal
|
||
self.cleanup_completed.emit(success, self.download_id, self.username)
|
||
|
||
except Exception as e:
|
||
print(f"Error in API cleanup thread: {e}")
|
||
self.cleanup_completed.emit(False, self.download_id, self.username)
|
||
finally:
|
||
# Ensure proper cleanup
|
||
if loop:
|
||
try:
|
||
# Close any remaining tasks
|
||
pending = asyncio.all_tasks(loop)
|
||
for task in pending:
|
||
task.cancel()
|
||
|
||
if pending:
|
||
loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
|
||
|
||
loop.close()
|
||
except Exception as e:
|
||
print(f"Error cleaning up API cleanup event loop: {e}")
|
||
|
||
class SearchThread(QThread):
|
||
search_completed = pyqtSignal(object) # Tuple of (tracks, albums) or list for backward compatibility
|
||
search_failed = pyqtSignal(str) # Error message
|
||
search_progress = pyqtSignal(str) # Progress message
|
||
search_results_partial = pyqtSignal(object, object, int) # tracks, albums, response count
|
||
|
||
def __init__(self, soulseek_client, query):
|
||
super().__init__()
|
||
self.soulseek_client = soulseek_client
|
||
self.query = query
|
||
self._stop_requested = False
|
||
|
||
def progress_callback(self, tracks, albums, response_count):
|
||
"""Callback function for progressive search results"""
|
||
if not self._stop_requested:
|
||
# Emit live results immediately
|
||
self.search_results_partial.emit(tracks, albums, response_count)
|
||
# Update progress message with current count
|
||
self.search_progress.emit(f"Found {len(tracks)} tracks, {len(albums)} albums from {response_count} responses")
|
||
|
||
def run(self):
|
||
loop = None
|
||
try:
|
||
import asyncio
|
||
self.search_progress.emit(f"Searching for: {self.query}")
|
||
|
||
# Create a completely fresh event loop for this thread
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
# Perform search with progressive callback
|
||
results = loop.run_until_complete(self._do_search())
|
||
|
||
if not self._stop_requested:
|
||
# Emit final completion with proper tuple format
|
||
# results should be a tuple (tracks, albums) from the search client
|
||
self.search_completed.emit(results)
|
||
|
||
except Exception as e:
|
||
if not self._stop_requested:
|
||
self.search_failed.emit(str(e))
|
||
finally:
|
||
# Ensure proper cleanup
|
||
if loop:
|
||
try:
|
||
# Close any remaining tasks
|
||
pending = asyncio.all_tasks(loop)
|
||
for task in pending:
|
||
task.cancel()
|
||
|
||
if pending:
|
||
loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
|
||
|
||
loop.close()
|
||
except Exception as e:
|
||
print(f"Error cleaning up event loop: {e}")
|
||
|
||
async def _do_search(self):
|
||
"""Perform the actual search with progressive callback"""
|
||
return await self.soulseek_client.search(self.query, progress_callback=self.progress_callback)
|
||
|
||
def stop(self):
|
||
"""Stop the search gracefully"""
|
||
self._stop_requested = True
|
||
|
||
class TrackedStatusUpdateThread(QThread):
|
||
"""Tracked status update thread that can be properly stopped and cleaned up"""
|
||
status_updated = pyqtSignal(list)
|
||
|
||
def __init__(self, soulseek_client, parent=None):
|
||
super().__init__(parent)
|
||
self.soulseek_client = soulseek_client
|
||
self._stop_requested = False
|
||
|
||
def run(self):
|
||
loop = None
|
||
try:
|
||
import asyncio
|
||
|
||
# Check if stop was requested before starting
|
||
if self._stop_requested:
|
||
return
|
||
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
downloads = loop.run_until_complete(self.soulseek_client.get_all_downloads())
|
||
|
||
# Only emit if not stopped
|
||
if not self._stop_requested:
|
||
self.status_updated.emit(downloads or [])
|
||
|
||
except Exception as e:
|
||
if not self._stop_requested:
|
||
print(f"Error fetching download status: {e}")
|
||
self.status_updated.emit([])
|
||
finally:
|
||
# Ensure proper cleanup
|
||
if loop:
|
||
try:
|
||
# Close any remaining tasks
|
||
pending = asyncio.all_tasks(loop)
|
||
for task in pending:
|
||
task.cancel()
|
||
|
||
if pending:
|
||
loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
|
||
|
||
loop.close()
|
||
except Exception as e:
|
||
print(f"Error cleaning up status update event loop: {e}")
|
||
|
||
def stop(self):
|
||
"""Stop the status update thread gracefully"""
|
||
self._stop_requested = True
|
||
|
||
class StreamingThread(QThread):
|
||
"""Thread for streaming audio files without saving them permanently"""
|
||
streaming_started = pyqtSignal(str, object) # Message, search_result
|
||
streaming_finished = pyqtSignal(str, object) # Message, search_result
|
||
streaming_failed = pyqtSignal(str, object) # Error message, search_result
|
||
streaming_progress = pyqtSignal(float, object) # Progress percentage (0-100), search_result
|
||
streaming_queued = pyqtSignal(str, object) # Queue message, search_result
|
||
|
||
def __init__(self, soulseek_client, search_result):
|
||
super().__init__()
|
||
self.soulseek_client = soulseek_client
|
||
self.search_result = search_result
|
||
self._stop_requested = False
|
||
|
||
def run(self):
|
||
loop = None
|
||
try:
|
||
import asyncio
|
||
import os
|
||
import time
|
||
import shutil
|
||
import glob
|
||
from pathlib import Path
|
||
|
||
self.streaming_started.emit(f"Starting stream: {self.search_result.filename}", self.search_result)
|
||
|
||
# Create a fresh event loop for this thread
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
# Get paths
|
||
from config.settings import config_manager
|
||
download_path = config_manager.get('soulseek.download_path', './downloads')
|
||
|
||
# Use the Stream folder in project root (not inside downloads)
|
||
project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__))) # Go up from ui/pages/
|
||
stream_folder = os.path.join(project_root, 'Stream')
|
||
|
||
# Ensure Stream directory exists
|
||
os.makedirs(stream_folder, exist_ok=True)
|
||
|
||
# Clear any existing files in Stream folder (only one file at a time)
|
||
for existing_file in glob.glob(os.path.join(stream_folder, '*')):
|
||
try:
|
||
if os.path.isfile(existing_file):
|
||
os.remove(existing_file)
|
||
elif os.path.isdir(existing_file):
|
||
shutil.rmtree(existing_file)
|
||
except Exception as e:
|
||
print(f"Warning: Could not remove existing stream file: {e}")
|
||
|
||
# Start the download (goes to normal downloads folder initially)
|
||
download_result = loop.run_until_complete(self._do_stream_download())
|
||
|
||
if not self._stop_requested:
|
||
if download_result:
|
||
self.streaming_started.emit(f"Downloading for stream: {self.search_result.filename}", self.search_result)
|
||
|
||
# Standard streaming - wait for complete download
|
||
max_wait_time = 45 # Wait up to 45 seconds
|
||
poll_interval = 2 # Check every 2 seconds
|
||
|
||
last_progress_sent = 0.0
|
||
found_file = None # Initialize found_file outside the loop
|
||
|
||
# Queue state tracking
|
||
queue_start_time = None
|
||
queue_timeout = 15.0 # 15 seconds max in queue
|
||
last_download_state = None
|
||
actively_downloading = False
|
||
|
||
for wait_count in range(max_wait_time // poll_interval):
|
||
if self._stop_requested:
|
||
break
|
||
|
||
# Only use real API progress data - no time-based estimation
|
||
|
||
# Check download progress via slskd API
|
||
api_progress = None
|
||
download_state = None
|
||
try:
|
||
# Use the same API call as download queue monitoring for consistency
|
||
transfers_data = loop.run_until_complete(self.soulseek_client._make_request('GET', 'transfers/downloads'))
|
||
download_status = self._find_streaming_download_in_transfers(transfers_data)
|
||
if download_status:
|
||
api_progress = download_status.get('percentComplete', 0)
|
||
download_state = download_status.get('state', '').lower()
|
||
print(f"API Download - State: {download_status.get('state')}, Progress: {api_progress:.1f}%")
|
||
|
||
# Categorize download state (aligned with download queue logic)
|
||
original_state = download_status.get('state', '') # Keep original case for completion check
|
||
is_queued = any(keyword in download_state for keyword in ['queued', 'initializing', 'remote'])
|
||
is_downloading = 'inprogress' in download_state
|
||
is_completed = ('Succeeded' in original_state or ('Completed' in original_state and 'Errored' not in original_state)) or api_progress >= 100
|
||
|
||
# Track queue state timing
|
||
if is_queued and queue_start_time is None:
|
||
queue_start_time = time.time()
|
||
print(f"Download entered queue state: {original_state}")
|
||
self.streaming_queued.emit(f"Queuing with uploader...", self.search_result)
|
||
elif is_downloading and not actively_downloading:
|
||
actively_downloading = True
|
||
queue_start_time = None # Reset queue timer
|
||
print(f"Download started actively downloading: {original_state}")
|
||
# Emit a progress update to indicate downloading has started
|
||
if api_progress > 0:
|
||
self.streaming_progress.emit(api_progress, self.search_result)
|
||
|
||
# Check for queue timeout
|
||
if is_queued and queue_start_time:
|
||
queue_elapsed = time.time() - queue_start_time
|
||
if queue_elapsed > queue_timeout:
|
||
print(f"⏰ Queue timeout after {queue_elapsed:.1f}s - download stuck in queue")
|
||
self.streaming_failed.emit(f"Queue timeout - uploader not responding. Try another source.", self.search_result)
|
||
return
|
||
|
||
# Check if download is complete
|
||
if is_completed:
|
||
print(f"Download completed via API status: {original_state}")
|
||
# Try to find the actual file - with retries for file system sync
|
||
for retry_count in range(5): # Try up to 5 times with delays
|
||
found_file = self._find_downloaded_file(download_path)
|
||
if found_file:
|
||
print(f"Found completed file after {retry_count} retries: {found_file}")
|
||
break
|
||
else:
|
||
print(f"File not found yet, waiting... (retry {retry_count + 1}/5)")
|
||
time.sleep(1) # Wait 1 second for file system to sync
|
||
|
||
if found_file:
|
||
print(f"Found downloaded file: {found_file}")
|
||
|
||
# Move the file to Stream folder with original filename
|
||
original_filename = os.path.basename(found_file)
|
||
stream_path = os.path.join(stream_folder, original_filename)
|
||
|
||
try:
|
||
# Move file to Stream folder
|
||
shutil.move(found_file, stream_path)
|
||
print(f"Moved file to stream folder: {stream_path}")
|
||
|
||
# Clean up empty directories left behind
|
||
self._cleanup_empty_directories(download_path, found_file)
|
||
|
||
# Signal that streaming is ready (100% progress)
|
||
self.streaming_progress.emit(100.0, self.search_result)
|
||
self.streaming_finished.emit(f"Stream ready: {os.path.basename(found_file)}", self.search_result)
|
||
self.temp_file_path = stream_path
|
||
print(f"Stream file ready for playback: {stream_path}")
|
||
|
||
# Signal API that download is complete
|
||
try:
|
||
download_id = download_status.get('id', '')
|
||
if download_id and self.search_result.username:
|
||
import asyncio
|
||
from services.service_manager import service_manager
|
||
soulseek_client = service_manager.get_soulseek_client()
|
||
if soulseek_client:
|
||
# Run the async API call
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
success = loop.run_until_complete(
|
||
soulseek_client.signal_download_completion(download_id, self.search_result.username, remove=True)
|
||
)
|
||
loop.close()
|
||
if success:
|
||
print(f"Successfully signaled completion for download {download_id}")
|
||
else:
|
||
print(f"Failed to signal completion for download {download_id}")
|
||
except Exception as e:
|
||
print(f"Error signaling download completion: {e}")
|
||
|
||
break # Exit main polling loop
|
||
|
||
except Exception as e:
|
||
print(f"Error moving file to stream folder: {e}")
|
||
self.streaming_failed.emit(f"Failed to prepare stream file: {e}", self.search_result)
|
||
break
|
||
else:
|
||
# Handle progress updates for active downloads
|
||
if is_downloading and actively_downloading and api_progress is not None and api_progress > 0:
|
||
if api_progress != last_progress_sent:
|
||
self.streaming_progress.emit(api_progress, self.search_result)
|
||
print(f"Progress update: {api_progress:.1f}% (Real API data)")
|
||
last_progress_sent = api_progress
|
||
except Exception as e:
|
||
print(f"Warning: Could not check download progress: {e}")
|
||
# Continue to next iteration if API call fails
|
||
continue
|
||
|
||
# Search for the downloaded file in the downloads directory
|
||
found_file = self._find_downloaded_file(download_path)
|
||
|
||
if found_file:
|
||
print(f"Found downloaded file: {found_file}")
|
||
|
||
# Move the file to Stream folder with original filename
|
||
original_filename = os.path.basename(found_file)
|
||
stream_path = os.path.join(stream_folder, original_filename)
|
||
|
||
try:
|
||
# Move file to Stream folder
|
||
shutil.move(found_file, stream_path)
|
||
print(f"Moved file to stream folder: {stream_path}")
|
||
|
||
# Clean up empty directories left behind
|
||
self._cleanup_empty_directories(download_path, found_file)
|
||
|
||
# Signal that streaming is ready (100% progress)
|
||
self.streaming_progress.emit(100.0, self.search_result)
|
||
self.streaming_finished.emit(f"Stream ready: {os.path.basename(found_file)}", self.search_result)
|
||
self.temp_file_path = stream_path
|
||
print(f"Stream file ready for playback: {stream_path}")
|
||
break
|
||
|
||
except Exception as e:
|
||
print(f"Error moving file to stream folder: {e}")
|
||
self.streaming_failed.emit(f"Failed to prepare stream file: {e}", self.search_result)
|
||
break
|
||
else:
|
||
# Still downloading, wait a bit more
|
||
print(f"Waiting for download to complete... ({wait_count * poll_interval}s elapsed)")
|
||
time.sleep(poll_interval)
|
||
else:
|
||
# Timed out waiting for file
|
||
print(f"Polling loop completed, timeout reached. found_file = {found_file}")
|
||
self.streaming_failed.emit("Stream download timed out - file not found", self.search_result)
|
||
|
||
else:
|
||
self.streaming_failed.emit("Streaming failed to start", self.search_result)
|
||
|
||
except Exception as e:
|
||
if not self._stop_requested:
|
||
self.streaming_failed.emit(str(e), self.search_result)
|
||
finally:
|
||
# Ensure proper cleanup
|
||
if loop:
|
||
try:
|
||
# Close any remaining tasks
|
||
pending = asyncio.all_tasks(loop)
|
||
for task in pending:
|
||
task.cancel()
|
||
|
||
if pending:
|
||
loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
|
||
|
||
loop.close()
|
||
except Exception as e:
|
||
print(f"Error cleaning up streaming event loop: {e}")
|
||
|
||
def _find_streaming_download_in_transfers(self, transfers_data):
|
||
"""Find streaming download in transfer data using same logic as download queue"""
|
||
try:
|
||
if not transfers_data:
|
||
return None
|
||
|
||
# Flatten the transfers data structure (same as download queue logic)
|
||
all_transfers = []
|
||
for user_data in transfers_data:
|
||
if 'directories' in user_data:
|
||
for directory in user_data['directories']:
|
||
if 'files' in directory:
|
||
all_transfers.extend(directory['files'])
|
||
|
||
# Look for our specific file by filename and username
|
||
target_filename = os.path.basename(self.search_result.filename)
|
||
target_username = self.search_result.username
|
||
|
||
print(f"Looking for streaming download - Target: {target_username}:{target_filename}")
|
||
print(f"Found {len(all_transfers)} total transfers in API")
|
||
|
||
for i, transfer in enumerate(all_transfers):
|
||
transfer_filename = os.path.basename(transfer.get('filename', ''))
|
||
transfer_username = transfer.get('username', '')
|
||
|
||
print(f"Transfer {i+1}: {transfer_username}:{transfer_filename} - State: {transfer.get('state')} - Progress: {transfer.get('percentComplete', 0):.1f}%")
|
||
|
||
if (transfer_filename == target_filename and
|
||
transfer_username == target_username):
|
||
print(f"Found matching streaming download: {transfer.get('state')} - {transfer.get('percentComplete', 0):.1f}%")
|
||
return transfer
|
||
|
||
print(f"No matching streaming download found for {target_username}:{target_filename}")
|
||
return None
|
||
except Exception as e:
|
||
print(f"Error finding streaming download in transfers: {e}")
|
||
return None
|
||
|
||
def _find_downloaded_file(self, download_path):
|
||
"""Find the downloaded audio file in the downloads directory tree"""
|
||
import os
|
||
|
||
# Audio file extensions to look for
|
||
audio_extensions = {'.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav', '.m4a'}
|
||
|
||
# Get the base filename without path
|
||
target_filename = os.path.basename(self.search_result.filename)
|
||
|
||
try:
|
||
# Walk through the downloads directory to find the file
|
||
for root, dirs, files in os.walk(download_path):
|
||
for file in files:
|
||
# Check if this is our target file
|
||
if file == target_filename:
|
||
file_path = os.path.join(root, file)
|
||
# Verify it's an audio file and has content
|
||
if (os.path.splitext(file)[1].lower() in audio_extensions and
|
||
os.path.getsize(file_path) > 1024): # At least 1KB
|
||
return file_path
|
||
|
||
# Also check for any audio files that might match partially
|
||
# (in case filename is slightly different)
|
||
file_lower = file.lower()
|
||
target_lower = target_filename.lower()
|
||
|
||
# Remove common variations
|
||
target_clean = target_lower.replace(' ', '').replace('-', '').replace('_', '')
|
||
file_clean = file_lower.replace(' ', '').replace('-', '').replace('_', '')
|
||
|
||
if (os.path.splitext(file)[1].lower() in audio_extensions and
|
||
len(file_clean) > 10 and # Reasonable filename length
|
||
(target_clean in file_clean or file_clean in target_clean) and
|
||
os.path.getsize(os.path.join(root, file)) > 1024):
|
||
return os.path.join(root, file)
|
||
|
||
except Exception as e:
|
||
print(f"Error searching for downloaded file: {e}")
|
||
|
||
return None
|
||
|
||
def _cleanup_empty_directories(self, download_path, moved_file_path):
|
||
"""Clean up empty directories left after moving a file"""
|
||
import os
|
||
|
||
try:
|
||
# Get the directory that contained the moved file
|
||
file_dir = os.path.dirname(moved_file_path)
|
||
|
||
# Only clean up if it's a subdirectory of downloads (not the downloads folder itself)
|
||
if file_dir != download_path and file_dir.startswith(download_path):
|
||
# Check if directory is empty
|
||
if os.path.isdir(file_dir) and not os.listdir(file_dir):
|
||
print(f"Removing empty directory: {file_dir}")
|
||
os.rmdir(file_dir)
|
||
|
||
# Recursively check parent directories
|
||
parent_dir = os.path.dirname(file_dir)
|
||
if (parent_dir != download_path and
|
||
parent_dir.startswith(download_path) and
|
||
os.path.isdir(parent_dir) and
|
||
not os.listdir(parent_dir)):
|
||
print(f"Removing empty parent directory: {parent_dir}")
|
||
os.rmdir(parent_dir)
|
||
|
||
except Exception as e:
|
||
print(f"Warning: Could not clean up empty directories: {e}")
|
||
|
||
async def _do_stream_download(self):
|
||
"""Perform the streaming download using normal download mechanism"""
|
||
# Use the same download mechanism as regular downloads
|
||
# The file will be downloaded to the normal downloads folder first
|
||
return await self.soulseek_client.download(
|
||
self.search_result.username,
|
||
self.search_result.filename,
|
||
self.search_result.size
|
||
)
|
||
|
||
|
||
def stop(self):
|
||
"""Stop the streaming gracefully"""
|
||
self._stop_requested = True
|
||
|
||
class TrackItem(QFrame):
|
||
"""Individual track item within an album"""
|
||
track_download_requested = pyqtSignal(object) # TrackResult object
|
||
track_stream_requested = pyqtSignal(object) # TrackResult object
|
||
|
||
def __init__(self, track_result, parent=None):
|
||
super().__init__(parent)
|
||
self.track_result = track_result
|
||
self.setup_ui()
|
||
|
||
def setup_ui(self):
|
||
self.setFixedHeight(50)
|
||
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
|
||
|
||
self.setStyleSheet("""
|
||
TrackItem {
|
||
background: rgba(40, 40, 40, 0.5);
|
||
border-radius: 8px;
|
||
border: 1px solid rgba(60, 60, 60, 0.3);
|
||
margin: 2px 8px;
|
||
}
|
||
TrackItem:hover {
|
||
background: rgba(50, 50, 50, 0.7);
|
||
border: 1px solid rgba(29, 185, 84, 0.5);
|
||
}
|
||
""")
|
||
|
||
layout = QHBoxLayout(self)
|
||
layout.setContentsMargins(12, 8, 12, 8)
|
||
layout.setSpacing(12)
|
||
|
||
# Track info
|
||
track_info = QVBoxLayout()
|
||
track_info.setSpacing(2)
|
||
|
||
# Track title
|
||
title = QLabel(self.track_result.title or "Unknown Title")
|
||
title.setFont(QFont("Arial", 11, QFont.Weight.Bold))
|
||
title.setStyleSheet("color: #ffffff;")
|
||
|
||
# Track details - enhanced with more information including prominent artist display
|
||
details = []
|
||
if self.track_result.track_number:
|
||
details.append(f"#{self.track_result.track_number:02d}")
|
||
|
||
# Always show artist information prominently for tracks within albums
|
||
if self.track_result.artist:
|
||
details.append(f"{self.track_result.artist}")
|
||
|
||
details.append(self.track_result.quality.upper())
|
||
if self.track_result.bitrate:
|
||
details.append(f"{self.track_result.bitrate}kbps")
|
||
|
||
# Add duration if available
|
||
if self.track_result.duration:
|
||
duration_mins = self.track_result.duration // 60
|
||
duration_secs = self.track_result.duration % 60
|
||
details.append(f"{duration_mins}:{duration_secs:02d}")
|
||
|
||
details.append(f"{self.track_result.size // (1024*1024)}MB")
|
||
|
||
details_text = " • ".join(details)
|
||
track_details = QLabel(details_text)
|
||
track_details.setFont(QFont("Arial", 9))
|
||
track_details.setStyleSheet("color: rgba(179, 179, 179, 0.8);")
|
||
|
||
track_info.addWidget(title)
|
||
track_info.addWidget(track_details)
|
||
|
||
# Control buttons
|
||
button_layout = QHBoxLayout()
|
||
button_layout.setSpacing(8)
|
||
|
||
# Play button
|
||
play_btn = QPushButton("")
|
||
play_btn.setFixedSize(32, 32)
|
||
play_btn.clicked.connect(self.request_stream)
|
||
play_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(29, 185, 84, 0.8);
|
||
border: none;
|
||
border-radius: 16px;
|
||
color: #000000;
|
||
font-size: 12px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background: rgba(30, 215, 96, 1.0);
|
||
}
|
||
""")
|
||
|
||
# Download button
|
||
download_btn = QPushButton("⬇️")
|
||
download_btn.setFixedSize(32, 32)
|
||
download_btn.clicked.connect(self.request_download)
|
||
download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(64, 64, 64, 0.8);
|
||
border: 1px solid rgba(29, 185, 84, 0.6);
|
||
border-radius: 16px;
|
||
color: #1db954;
|
||
font-size: 10px;
|
||
}
|
||
QPushButton:hover {
|
||
background: rgba(29, 185, 84, 0.2);
|
||
}
|
||
""")
|
||
|
||
# Matched Download button
|
||
matched_download_btn = QPushButton("")
|
||
matched_download_btn.setFixedSize(32, 32)
|
||
matched_download_btn.clicked.connect(self.request_matched_download)
|
||
matched_download_btn.setToolTip("Download with Spotify Matching")
|
||
matched_download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(64, 64, 64, 0.8);
|
||
border: 1px solid rgba(147, 51, 234, 0.6);
|
||
border-radius: 16px;
|
||
color: #9333ea;
|
||
font-size: 10px;
|
||
}
|
||
QPushButton:hover {
|
||
background: rgba(147, 51, 234, 0.2);
|
||
}
|
||
""")
|
||
|
||
button_layout.addWidget(play_btn)
|
||
button_layout.addWidget(download_btn)
|
||
button_layout.addWidget(matched_download_btn)
|
||
|
||
# Store button references for state management
|
||
self.play_btn = play_btn
|
||
self.download_btn = download_btn
|
||
self.matched_download_btn = matched_download_btn
|
||
|
||
# Assembly
|
||
layout.addLayout(track_info, 1)
|
||
layout.addLayout(button_layout)
|
||
|
||
def request_stream(self):
|
||
"""Request streaming of this track"""
|
||
self.track_stream_requested.emit(self.track_result)
|
||
|
||
def request_download(self):
|
||
"""Request download of this track"""
|
||
self.track_download_requested.emit(self.track_result)
|
||
|
||
def request_matched_download(self):
|
||
"""Request a matched download with Spotify integration"""
|
||
# Get reference to the DownloadsPage to handle matched download
|
||
downloads_page = self.get_downloads_page()
|
||
if downloads_page:
|
||
downloads_page.start_matched_download(self.track_result)
|
||
|
||
def get_downloads_page(self):
|
||
"""Get reference to the parent DownloadsPage"""
|
||
parent = self.parent()
|
||
while parent:
|
||
if hasattr(parent, 'audio_player'): # DownloadsPage has audio_player
|
||
return parent
|
||
parent = parent.parent()
|
||
return None
|
||
|
||
def set_loading_state(self):
|
||
"""Set play button to loading state"""
|
||
self.play_btn.setText("")
|
||
self.play_btn.setEnabled(False)
|
||
|
||
def set_queue_state(self):
|
||
"""Set play button to queue state"""
|
||
self.play_btn.setText("")
|
||
self.play_btn.setEnabled(False)
|
||
self.play_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(255, 165, 0, 0.2);
|
||
border: 1px solid rgba(255, 165, 0, 0.4);
|
||
border-radius: 18px;
|
||
color: rgba(255, 165, 0, 0.8);
|
||
font-size: 12px;
|
||
}
|
||
""")
|
||
|
||
def set_download_queued_state(self):
|
||
"""Set download button to queued state (disabled, shows queued)"""
|
||
self.download_btn.setText("")
|
||
self.download_btn.setEnabled(False)
|
||
self.download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(100, 100, 100, 0.5);
|
||
border: 1px solid rgba(150, 150, 150, 0.3);
|
||
border-radius: 16px;
|
||
color: rgba(255, 255, 255, 0.6);
|
||
font-size: 10px;
|
||
}
|
||
""")
|
||
|
||
def set_download_downloading_state(self):
|
||
"""Set download button to downloading state"""
|
||
self.download_btn.setText("")
|
||
self.download_btn.setEnabled(False)
|
||
self.download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(29, 185, 84, 0.3);
|
||
border: 1px solid rgba(29, 185, 84, 0.6);
|
||
border-radius: 16px;
|
||
color: #1db954;
|
||
font-size: 10px;
|
||
}
|
||
""")
|
||
|
||
def set_download_completed_state(self):
|
||
"""Set download button to completed state"""
|
||
self.download_btn.setText("")
|
||
self.download_btn.setEnabled(False)
|
||
self.download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(40, 167, 69, 0.3);
|
||
border: 1px solid rgba(40, 167, 69, 0.6);
|
||
border-radius: 16px;
|
||
color: #28a745;
|
||
font-size: 10px;
|
||
}
|
||
""")
|
||
|
||
def reset_download_state(self):
|
||
"""Reset download button to default state"""
|
||
self.download_btn.setText("⬇️")
|
||
self.download_btn.setEnabled(True)
|
||
self.download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(64, 64, 64, 0.8);
|
||
border: 1px solid rgba(29, 185, 84, 0.6);
|
||
border-radius: 16px;
|
||
color: #1db954;
|
||
font-size: 10px;
|
||
}
|
||
QPushButton:hover {
|
||
background: rgba(29, 185, 84, 0.2);
|
||
}
|
||
""")
|
||
|
||
def set_playing_state(self):
|
||
"""Set play button to playing/pause state"""
|
||
self.play_btn.setText("")
|
||
self.play_btn.setEnabled(True)
|
||
|
||
def reset_play_state(self):
|
||
"""Reset play button to default state"""
|
||
self.play_btn.setText("")
|
||
self.play_btn.setEnabled(True)
|
||
|
||
class AlbumResultItem(QFrame):
|
||
"""Expandable UI component for displaying album search results"""
|
||
album_download_requested = pyqtSignal(object) # AlbumResult object
|
||
matched_album_download_requested = pyqtSignal(object) # AlbumResult object for matched download
|
||
track_download_requested = pyqtSignal(object) # TrackResult object
|
||
track_stream_requested = pyqtSignal(object, object) # TrackResult object, TrackItem object
|
||
|
||
def __init__(self, album_result, parent=None):
|
||
super().__init__(parent)
|
||
self.album_result = album_result
|
||
self.is_expanded = False
|
||
self.track_items = []
|
||
self.tracks_container = None
|
||
self.setup_ui()
|
||
|
||
def setup_ui(self):
|
||
# Dynamic height based on expansion state with better proportions
|
||
self.collapsed_height = 110 # Increased from 80px for better breathing room
|
||
self.setFixedHeight(self.collapsed_height)
|
||
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
|
||
|
||
# Enable mouse tracking for click detection
|
||
self.setMouseTracking(True)
|
||
|
||
self.setStyleSheet("""
|
||
AlbumResultItem {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(52, 52, 58, 0.95),
|
||
stop:1 rgba(42, 42, 48, 0.98));
|
||
border-radius: 20px;
|
||
border: 1px solid rgba(75, 75, 82, 0.5);
|
||
margin: 10px 5px;
|
||
}
|
||
AlbumResultItem:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(60, 60, 68, 0.98),
|
||
stop:1 rgba(50, 50, 58, 1.0));
|
||
border: 1px solid rgba(29, 185, 84, 0.8);
|
||
}
|
||
""")
|
||
|
||
# Main vertical layout for album header + tracks
|
||
main_layout = QVBoxLayout(self)
|
||
main_layout.setContentsMargins(0, 0, 0, 0)
|
||
main_layout.setSpacing(0)
|
||
|
||
# Album header (always visible, clickable)
|
||
self.header_widget = QWidget()
|
||
self.header_widget.setFixedHeight(90) # Increased to match collapsed_height
|
||
self.header_widget.setStyleSheet("QWidget { background: transparent; }")
|
||
header_layout = QHBoxLayout(self.header_widget)
|
||
header_layout.setContentsMargins(16, 12, 16, 16) # More balanced padding - reduced top, added bottom
|
||
header_layout.setSpacing(16) # Consistent spacing with other elements
|
||
|
||
# Album icon with expand indicator
|
||
icon_container = QVBoxLayout()
|
||
album_icon = QLabel("")
|
||
album_icon.setFixedSize(48, 48) # Larger for better presence
|
||
album_icon.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
album_icon.setStyleSheet("""
|
||
QLabel {
|
||
font-size: 24px;
|
||
background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
|
||
stop:0 rgba(29, 185, 84, 0.2),
|
||
stop:1 rgba(24, 156, 71, 0.15));
|
||
border-radius: 24px;
|
||
border: 2px solid rgba(29, 185, 84, 0.4);
|
||
color: rgba(29, 185, 84, 1.0);
|
||
}
|
||
""")
|
||
|
||
# Expand indicator
|
||
self.expand_indicator = QLabel("")
|
||
self.expand_indicator.setFixedSize(20, 20) # Slightly larger
|
||
self.expand_indicator.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.expand_indicator.setStyleSheet("""
|
||
QLabel {
|
||
color: rgba(29, 185, 84, 0.9);
|
||
font-size: 14px;
|
||
font-weight: bold;
|
||
background: rgba(29, 185, 84, 0.1);
|
||
border-radius: 10px;
|
||
border: 1px solid rgba(29, 185, 84, 0.2);
|
||
}
|
||
""")
|
||
|
||
icon_container.addWidget(album_icon)
|
||
icon_container.addWidget(self.expand_indicator)
|
||
|
||
# Album info section
|
||
info_section = QVBoxLayout()
|
||
info_section.setSpacing(2)
|
||
info_section.setContentsMargins(0, 0, 0, 0)
|
||
|
||
# Album title
|
||
album_title = QLabel(self.album_result.album_title)
|
||
album_title.setFont(QFont("Arial", 12, QFont.Weight.Bold))
|
||
album_title.setStyleSheet("color: #ffffff;")
|
||
|
||
# Artist and details - with prominent artist display
|
||
details = []
|
||
|
||
# Make artist more prominent by placing it first and with better formatting
|
||
if self.album_result.artist:
|
||
details.append(f"{self.album_result.artist}")
|
||
|
||
details.append(f"{self.album_result.track_count} tracks")
|
||
details.append(f"{self.album_result.size_mb}MB")
|
||
details.append(self.album_result.dominant_quality.upper())
|
||
if self.album_result.year:
|
||
details.append(f"({self.album_result.year})")
|
||
|
||
# Add speed information
|
||
speed_info = self._get_album_speed_display()
|
||
if speed_info:
|
||
details.append(speed_info)
|
||
|
||
details_text = " • ".join(details)
|
||
album_details = QLabel(details_text)
|
||
album_details.setFont(QFont("Arial", 10))
|
||
album_details.setStyleSheet("color: rgba(179, 179, 179, 0.9);")
|
||
|
||
# User info
|
||
user_info = QLabel(f"{self.album_result.username}")
|
||
user_info.setFont(QFont("Arial", 9))
|
||
user_info.setStyleSheet("color: rgba(29, 185, 84, 0.8);")
|
||
|
||
info_section.addWidget(album_title)
|
||
info_section.addWidget(album_details)
|
||
info_section.addWidget(user_info)
|
||
|
||
# Download buttons layout
|
||
download_buttons_layout = QVBoxLayout()
|
||
download_buttons_layout.setSpacing(4)
|
||
|
||
# Download button
|
||
self.download_btn = QPushButton("⬇️ Download Album")
|
||
self.download_btn.setFixedSize(160, 36) # Slightly larger for better presence
|
||
self.download_btn.clicked.connect(self.request_album_download)
|
||
self.download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(29, 185, 84, 0.95),
|
||
stop:1 rgba(24, 156, 71, 0.9));
|
||
border: 2px solid rgba(29, 185, 84, 0.3);
|
||
border-radius: 18px;
|
||
color: #000000;
|
||
font-size: 12px;
|
||
font-weight: bold;
|
||
padding: 8px 12px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(30, 215, 96, 1.0),
|
||
stop:1 rgba(25, 180, 80, 1.0));
|
||
border: 2px solid rgba(29, 185, 84, 0.6);
|
||
}
|
||
QPushButton:pressed {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(20, 150, 70, 1.0),
|
||
stop:1 rgba(15, 120, 60, 1.0));
|
||
}
|
||
""")
|
||
|
||
# Matched Download button
|
||
self.matched_download_btn = QPushButton("Matched Album")
|
||
self.matched_download_btn.setFixedSize(160, 36) # Match the other button
|
||
self.matched_download_btn.clicked.connect(self.request_matched_album_download)
|
||
self.matched_download_btn.setToolTip("Download Album with Spotify Matching")
|
||
self.matched_download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(147, 51, 234, 0.95),
|
||
stop:1 rgba(124, 43, 200, 0.9));
|
||
border: 2px solid rgba(147, 51, 234, 0.3);
|
||
border-radius: 18px;
|
||
color: #ffffff;
|
||
font-size: 12px;
|
||
font-weight: bold;
|
||
padding: 8px 12px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(167, 71, 254, 1.0),
|
||
stop:1 rgba(144, 63, 220, 1.0));
|
||
border: 2px solid rgba(147, 51, 234, 0.6);
|
||
}
|
||
QPushButton:pressed {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(120, 50, 200, 1.0),
|
||
stop:1 rgba(100, 40, 180, 1.0));
|
||
}
|
||
""")
|
||
|
||
download_buttons_layout.addWidget(self.download_btn)
|
||
download_buttons_layout.addWidget(self.matched_download_btn)
|
||
|
||
# Set minimum width to ensure buttons always visible
|
||
self.setMinimumWidth(420) # Increased to accommodate larger buttons
|
||
|
||
# Assembly header
|
||
header_layout.addLayout(icon_container)
|
||
header_layout.addLayout(info_section, 1) # Flexible content area
|
||
header_layout.addLayout(download_buttons_layout, 0) # Fixed button area, always visible
|
||
|
||
# Tracks container (hidden by default)
|
||
self.tracks_container = QWidget()
|
||
self.tracks_container.setVisible(False)
|
||
tracks_layout = QVBoxLayout(self.tracks_container)
|
||
tracks_layout.setContentsMargins(16, 8, 16, 16)
|
||
tracks_layout.setSpacing(4)
|
||
|
||
# Create track items
|
||
for track in self.album_result.tracks:
|
||
track_item = TrackItem(track)
|
||
track_item.track_download_requested.connect(self.track_download_requested.emit)
|
||
# Use lambda to pass both track result and track item reference
|
||
track_item.track_stream_requested.connect(
|
||
lambda track_result, item=track_item: self.handle_track_stream_request(track_result, item)
|
||
)
|
||
tracks_layout.addWidget(track_item)
|
||
self.track_items.append(track_item)
|
||
|
||
# Assembly main layout
|
||
main_layout.addWidget(self.header_widget)
|
||
main_layout.addWidget(self.tracks_container)
|
||
|
||
# Make header clickable
|
||
self.header_widget.mousePressEvent = self.toggle_expansion
|
||
|
||
def request_album_download(self):
|
||
"""Request download of the entire album"""
|
||
self.download_btn.setText("")
|
||
self.download_btn.setEnabled(False)
|
||
self.album_download_requested.emit(self.album_result)
|
||
|
||
def request_matched_album_download(self):
|
||
"""Request matched download of the entire album with Spotify integration"""
|
||
self.matched_download_btn.setText("")
|
||
self.matched_download_btn.setEnabled(False)
|
||
self.matched_album_download_requested.emit(self.album_result)
|
||
|
||
def toggle_expansion(self, event):
|
||
"""Toggle album expansion to show/hide tracks"""
|
||
self.is_expanded = not self.is_expanded
|
||
|
||
if self.is_expanded:
|
||
# Expand to show tracks
|
||
self.tracks_container.setVisible(True)
|
||
self.expand_indicator.setText("▼")
|
||
# Calculate height: header + (tracks * track_height) + padding
|
||
track_height = 54 # 50px + margin
|
||
total_height = self.collapsed_height + (len(self.track_items) * track_height) + 24
|
||
self.setFixedHeight(total_height)
|
||
else:
|
||
# Collapse to hide tracks
|
||
self.tracks_container.setVisible(False)
|
||
self.expand_indicator.setText("")
|
||
self.setFixedHeight(self.collapsed_height)
|
||
|
||
# Force layout update
|
||
self.updateGeometry()
|
||
if self.parent():
|
||
self.parent().updateGeometry()
|
||
|
||
def handle_track_stream_request(self, track_result, track_item):
|
||
"""Handle stream request from a track item, passing the correct button reference"""
|
||
# Emit the stream request with the track item that contains the button
|
||
self.track_stream_requested.emit(track_result, track_item)
|
||
|
||
def _get_album_speed_display(self):
|
||
"""Get formatted speed display for album cards"""
|
||
# Get speed data from album result
|
||
speed = getattr(self.album_result, 'upload_speed', None) or 0
|
||
slots = getattr(self.album_result, 'free_upload_slots', None) or 0
|
||
|
||
if speed > 0:
|
||
# Use same logic as Singles but return text only (no icons for inline display)
|
||
if speed > 200:
|
||
icon = ""
|
||
elif speed > 100:
|
||
icon = "" if slots > 0 else ""
|
||
elif speed > 50:
|
||
icon = ""
|
||
else:
|
||
icon = ""
|
||
|
||
# Convert to MB/s and format
|
||
speed_mb = speed / 1024
|
||
if speed_mb >= 1:
|
||
return f"{icon} {speed_mb:.1f}MB/s"
|
||
else:
|
||
return f"{icon} {speed}KB/s"
|
||
|
||
return None # No speed data
|
||
|
||
class SearchResultItem(QFrame):
|
||
download_requested = pyqtSignal(object) # SearchResult object
|
||
stream_requested = pyqtSignal(object) # SearchResult object for streaming
|
||
expansion_requested = pyqtSignal(object) # Signal when this item wants to expand
|
||
|
||
def __init__(self, search_result, parent=None):
|
||
super().__init__(parent)
|
||
self.search_result = search_result
|
||
self.is_downloading = False
|
||
self.is_expanded = False
|
||
self.setup_ui()
|
||
|
||
def setup_ui(self):
|
||
# Dynamic height based on state (compact: 85px, expanded: 200px for better visual breathing room)
|
||
self.compact_height = 85 # Increased from 75px to match Albums proportions
|
||
self.expanded_height = 200 # Increased from 180px for more comfortable content layout
|
||
self.setFixedHeight(self.compact_height)
|
||
|
||
# Ensure consistent sizing and layout behavior
|
||
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
|
||
|
||
# Enable mouse tracking for click detection
|
||
self.setMouseTracking(True)
|
||
|
||
self.setStyleSheet("""
|
||
SearchResultItem {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(48, 48, 52, 0.95),
|
||
stop:1 rgba(38, 38, 42, 0.98));
|
||
border-radius: 18px;
|
||
border: 1px solid rgba(70, 70, 76, 0.5);
|
||
margin: 8px 4px;
|
||
}
|
||
SearchResultItem:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(55, 55, 60, 0.98),
|
||
stop:1 rgba(45, 45, 50, 1.0));
|
||
border: 1px solid rgba(29, 185, 84, 0.8);
|
||
}
|
||
""")
|
||
|
||
layout = QHBoxLayout(self)
|
||
layout.setContentsMargins(16, 16, 16, 16) # Match Albums margins for consistency
|
||
layout.setSpacing(16) # Increased spacing for better visual separation
|
||
|
||
# Left section: Music icon + filename
|
||
left_section = QHBoxLayout()
|
||
left_section.setSpacing(12) # Increased from 8px for better separation
|
||
|
||
# Enhanced music icon with modern styling
|
||
music_icon = QLabel("")
|
||
music_icon.setFixedSize(44, 44) # Slightly larger for better presence
|
||
music_icon.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
music_icon.setStyleSheet("""
|
||
QLabel {
|
||
background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
|
||
stop:0 rgba(29, 185, 84, 0.3),
|
||
stop:1 rgba(24, 156, 71, 0.2));
|
||
border-radius: 22px;
|
||
border: 2px solid rgba(29, 185, 84, 0.4);
|
||
font-size: 18px;
|
||
color: rgba(29, 185, 84, 1.0);
|
||
}
|
||
QLabel:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
|
||
stop:0 rgba(29, 185, 84, 0.5),
|
||
stop:1 rgba(24, 156, 71, 0.3));
|
||
border: 2px solid rgba(29, 185, 84, 0.7);
|
||
}
|
||
""")
|
||
|
||
# Content area that will change based on expanded state
|
||
self.content_widget = QWidget()
|
||
self.content_layout = QVBoxLayout(self.content_widget)
|
||
self.content_layout.setContentsMargins(0, 4, 0, 4) # Increased vertical margins for better centering
|
||
self.content_layout.setSpacing(2) # Reduced spacing to prevent text cut-off
|
||
|
||
# Extract song info
|
||
primary_info = self._extract_song_info()
|
||
|
||
# Create both compact and expanded content but show only one
|
||
self.create_persistent_content(primary_info)
|
||
|
||
# Right section: Play and download buttons
|
||
buttons_layout = QHBoxLayout()
|
||
buttons_layout.setSpacing(8) # Increased from 4px for better button separation
|
||
|
||
# Play button for streaming preview
|
||
self.play_btn = QPushButton("")
|
||
self.play_btn.setFixedSize(46, 46) # Larger for better accessibility
|
||
self.play_btn.clicked.connect(self.request_stream)
|
||
self.play_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(255, 193, 7, 0.95),
|
||
stop:1 rgba(255, 152, 0, 0.9));
|
||
border: 2px solid rgba(255, 193, 7, 0.3);
|
||
border-radius: 23px;
|
||
color: #000000;
|
||
font-size: 18px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(255, 213, 79, 1.0),
|
||
stop:1 rgba(255, 171, 64, 1.0));
|
||
border: 2px solid rgba(255, 193, 7, 0.6);
|
||
}
|
||
QPushButton:pressed {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(255, 152, 0, 1.0),
|
||
stop:1 rgba(245, 124, 0, 1.0));
|
||
}
|
||
""")
|
||
|
||
# Download button
|
||
self.download_btn = QPushButton("⬇️")
|
||
self.download_btn.setFixedSize(46, 46) # Match play button size
|
||
self.download_btn.clicked.connect(self.request_download)
|
||
self.download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(29, 185, 84, 0.95),
|
||
stop:1 rgba(24, 156, 71, 0.9));
|
||
border: 2px solid rgba(29, 185, 84, 0.3);
|
||
border-radius: 23px;
|
||
color: #000000;
|
||
font-size: 18px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(30, 215, 96, 1.0),
|
||
stop:1 rgba(25, 180, 80, 1.0));
|
||
border: 2px solid rgba(29, 185, 84, 0.6);
|
||
}
|
||
QPushButton:pressed {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(24, 156, 71, 1.0),
|
||
stop:1 rgba(20, 130, 60, 1.0));
|
||
}
|
||
""")
|
||
|
||
# Matched Download button
|
||
self.matched_download_btn = QPushButton("")
|
||
self.matched_download_btn.setFixedSize(46, 46) # Match other buttons
|
||
self.matched_download_btn.clicked.connect(self.request_matched_download)
|
||
self.matched_download_btn.setToolTip("Download with Spotify Matching")
|
||
self.matched_download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(147, 51, 234, 0.95),
|
||
stop:1 rgba(124, 43, 200, 0.9));
|
||
border: 2px solid rgba(147, 51, 234, 0.3);
|
||
border-radius: 23px;
|
||
color: #ffffff;
|
||
font-size: 18px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(167, 71, 254, 1.0),
|
||
stop:1 rgba(144, 63, 220, 1.0));
|
||
border: 2px solid rgba(147, 51, 234, 0.6);
|
||
}
|
||
QPushButton:pressed {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(124, 43, 200, 1.0),
|
||
stop:1 rgba(104, 33, 180, 1.0));
|
||
}
|
||
""")
|
||
|
||
# Assemble the layout
|
||
left_section.addWidget(music_icon)
|
||
left_section.addWidget(self.content_widget, 1)
|
||
|
||
buttons_layout.addWidget(self.play_btn)
|
||
buttons_layout.addWidget(self.download_btn)
|
||
buttons_layout.addWidget(self.matched_download_btn)
|
||
|
||
# Set minimum width to ensure buttons always visible
|
||
self.setMinimumWidth(300) # Ensure minimum space for content + buttons
|
||
|
||
layout.addLayout(left_section, 1) # Flexible content area
|
||
layout.addLayout(buttons_layout, 0) # Fixed button area, always visible
|
||
|
||
def create_persistent_content(self, primary_info):
|
||
"""Create both compact and expanded content with visibility control"""
|
||
# Title row (always visible) with character limit and ellipsis
|
||
title_text = primary_info['title']
|
||
if len(title_text) > 55: # Increased character limit since smaller font fits more text
|
||
title_text = title_text[:52] + "..."
|
||
|
||
self.title_label = QLabel(title_text)
|
||
self.title_label.setFont(QFont("Arial", 12, QFont.Weight.Bold)) # 12px matches Albums and prevents cut-off
|
||
self.title_label.setStyleSheet("color: #ffffff; letter-spacing: 0.2px;")
|
||
self.title_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
|
||
# Ensure text doesn't overflow the label and allow click-through
|
||
self.title_label.setWordWrap(False)
|
||
# Remove text selection to allow clicks to propagate to parent widget
|
||
self.title_label.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction)
|
||
|
||
# Expand indicator with enhanced styling
|
||
self.expand_indicator = QLabel("⏵")
|
||
self.expand_indicator.setFixedSize(20, 20) # Increased size for better visibility
|
||
self.expand_indicator.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.expand_indicator.setStyleSheet("""
|
||
QLabel {
|
||
color: rgba(255, 255, 255, 0.7);
|
||
font-size: 12px;
|
||
background: rgba(255, 255, 255, 0.1);
|
||
border-radius: 10px;
|
||
}
|
||
QLabel:hover {
|
||
color: rgba(29, 185, 84, 0.9);
|
||
background: rgba(29, 185, 84, 0.15);
|
||
}
|
||
""")
|
||
|
||
# Quality badge (now visible in compact view)
|
||
self.quality_badge = self._create_compact_quality_badge()
|
||
|
||
# Create uploader info label for compact view with artist information
|
||
result = self.search_result[0] if isinstance(self.search_result, list) else self.search_result
|
||
|
||
# Build secondary info with artist prominently displayed (excluding uploader)
|
||
info_parts = []
|
||
|
||
# Add artist information if available
|
||
if hasattr(result, 'artist') and result.artist:
|
||
info_parts.append(f"{result.artist}")
|
||
|
||
# Add quality info
|
||
quality_text = result.quality.upper()
|
||
if result.bitrate:
|
||
quality_text += f" • {result.bitrate}kbps"
|
||
info_parts.append(quality_text)
|
||
|
||
# Add size info
|
||
size_mb = result.size // (1024*1024)
|
||
info_parts.append(f"{size_mb}MB")
|
||
|
||
secondary_info_text = " • ".join(info_parts)
|
||
self.secondary_info = QLabel(secondary_info_text)
|
||
self.secondary_info.setFont(QFont("Arial", 9, QFont.Weight.Normal))
|
||
self.secondary_info.setStyleSheet("color: rgba(179, 179, 179, 0.8); letter-spacing: 0.1px;")
|
||
self.secondary_info.setWordWrap(False)
|
||
self.secondary_info.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction)
|
||
|
||
# Create separate uploader info with green styling like albums
|
||
self.uploader_info = QLabel(f"{result.username}")
|
||
self.uploader_info.setFont(QFont("Arial", 9))
|
||
self.uploader_info.setStyleSheet("color: rgba(29, 185, 84, 0.8);")
|
||
self.uploader_info.setWordWrap(False)
|
||
self.uploader_info.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction)
|
||
|
||
title_row = QHBoxLayout()
|
||
title_row.setContentsMargins(0, 0, 0, 0)
|
||
title_row.addWidget(self.title_label)
|
||
title_row.addWidget(self.quality_badge)
|
||
title_row.addWidget(self.expand_indicator)
|
||
|
||
# Add secondary info row for compact view with uploader info
|
||
secondary_row = QHBoxLayout()
|
||
secondary_row.setContentsMargins(0, 0, 0, 0) # Remove margins to prevent cut-off
|
||
secondary_row.addWidget(self.secondary_info)
|
||
secondary_row.addStretch() # Push text to left
|
||
secondary_row.addWidget(self.uploader_info) # Add green uploader info on the right
|
||
|
||
# Expanded content (initially hidden)
|
||
self.expanded_content = QWidget()
|
||
expanded_layout = QVBoxLayout(self.expanded_content)
|
||
expanded_layout.setContentsMargins(0, 4, 0, 4) # Small margins for better text positioning
|
||
expanded_layout.setSpacing(4) # Increased from 1px to 4px for better readability
|
||
|
||
# Expanded content shows only unique information not in compact view
|
||
# Duration info (if available) - this is unique to expanded view
|
||
expanded_details = []
|
||
if self.search_result.duration:
|
||
duration_mins = self.search_result.duration // 60
|
||
duration_secs = self.search_result.duration % 60
|
||
expanded_details.append(f"Duration: {duration_mins}:{duration_secs:02d}")
|
||
|
||
# Full file path info (unique to expanded view)
|
||
result = self.search_result[0] if isinstance(self.search_result, list) else self.search_result
|
||
if hasattr(result, 'filename'):
|
||
expanded_details.append(f"File: {result.filename}")
|
||
|
||
if expanded_details:
|
||
self.expanded_details = QLabel(" • ".join(expanded_details))
|
||
self.expanded_details.setFont(QFont("Arial", 10))
|
||
self.expanded_details.setStyleSheet("color: rgba(136, 136, 136, 0.8); letter-spacing: 0.1px;")
|
||
self.expanded_details.setWordWrap(True) # Allow wrapping for long filenames
|
||
expanded_layout.addWidget(self.expanded_details)
|
||
|
||
# Speed indicator (unique to expanded view)
|
||
self.speed_indicator = self._create_compact_speed_indicator()
|
||
speed_row = QHBoxLayout()
|
||
speed_row.addWidget(self.speed_indicator)
|
||
speed_row.addStretch()
|
||
expanded_layout.addLayout(speed_row)
|
||
|
||
# Initially hide expanded content
|
||
self.expanded_content.hide()
|
||
|
||
# Add to main layout
|
||
self.content_layout.addLayout(title_row)
|
||
self.content_layout.addLayout(secondary_row) # Add secondary info row
|
||
self.content_layout.addWidget(self.expanded_content)
|
||
|
||
def update_expanded_state(self):
|
||
"""Update UI based on expanded state without recreating widgets"""
|
||
if self.is_expanded:
|
||
self.expand_indicator.setText("⏷")
|
||
self.expand_indicator.setStyleSheet("""
|
||
QLabel {
|
||
color: rgba(29, 185, 84, 0.9);
|
||
font-size: 14px;
|
||
background: rgba(29, 185, 84, 0.15);
|
||
border-radius: 10px;
|
||
}
|
||
""")
|
||
self.expanded_content.show()
|
||
else:
|
||
self.expand_indicator.setText("⏵")
|
||
self.expand_indicator.setStyleSheet("""
|
||
QLabel {
|
||
color: rgba(255, 255, 255, 0.7);
|
||
font-size: 14px;
|
||
background: rgba(255, 255, 255, 0.1);
|
||
border-radius: 10px;
|
||
}
|
||
QLabel:hover {
|
||
color: rgba(29, 185, 84, 0.9);
|
||
background: rgba(29, 185, 84, 0.15);
|
||
}
|
||
""")
|
||
self.expanded_content.hide()
|
||
|
||
# Quality badge is now always visible in compact view
|
||
|
||
def mousePressEvent(self, event):
|
||
"""Handle mouse clicks to toggle expand/collapse"""
|
||
# Only respond to left clicks and avoid clicks on the download button
|
||
if event.button() == Qt.MouseButton.LeftButton:
|
||
# Check if click is on download button (more precise detection)
|
||
button_rect = self.download_btn.geometry()
|
||
# Add some padding to the button area to be more forgiving
|
||
button_rect.adjust(-5, -5, 5, 5)
|
||
if not button_rect.contains(event.pos()):
|
||
# Emit signal to parent to handle accordion behavior
|
||
self.expansion_requested.emit(self)
|
||
super().mousePressEvent(event)
|
||
|
||
def set_expanded(self, expanded, animate=True):
|
||
"""Set expanded state externally (called by parent for accordion behavior)"""
|
||
if self.is_expanded == expanded:
|
||
return # No change needed
|
||
|
||
self.is_expanded = expanded
|
||
|
||
if animate:
|
||
self._animate_to_state()
|
||
else:
|
||
# Immediate state change without animation
|
||
if self.is_expanded:
|
||
self.setFixedHeight(self.expanded_height)
|
||
else:
|
||
self.setFixedHeight(self.compact_height)
|
||
self.update_expanded_state()
|
||
|
||
def toggle_expanded(self):
|
||
"""Toggle between compact and expanded states with animation"""
|
||
self.set_expanded(not self.is_expanded, animate=True)
|
||
|
||
def _animate_to_state(self):
|
||
"""Animate to the current expanded state with enhanced easing"""
|
||
from PyQt6.QtCore import QPropertyAnimation, QEasingCurve
|
||
|
||
# Start height animation with smoother easing
|
||
self.animation = QPropertyAnimation(self, b"minimumHeight")
|
||
self.animation.setDuration(300) # Slightly longer for smoother feel
|
||
self.animation.setEasingCurve(QEasingCurve.Type.OutQuart) # More elegant easing curve
|
||
|
||
if self.is_expanded:
|
||
# Expand animation
|
||
self.animation.setStartValue(self.compact_height)
|
||
self.animation.setEndValue(self.expanded_height)
|
||
# Show content immediately for expand (feels more responsive)
|
||
self.update_expanded_state()
|
||
else:
|
||
# Collapse animation
|
||
self.animation.setStartValue(self.expanded_height)
|
||
self.animation.setEndValue(self.compact_height)
|
||
# Hide content immediately for collapse (cleaner look)
|
||
self.update_expanded_state()
|
||
|
||
# Update fixed height when animation completes
|
||
self.animation.finished.connect(self._finalize_height)
|
||
self.animation.start()
|
||
|
||
def _finalize_height(self):
|
||
"""Set final height after animation completes"""
|
||
if self.is_expanded:
|
||
self.setFixedHeight(self.expanded_height)
|
||
else:
|
||
self.setFixedHeight(self.compact_height)
|
||
|
||
# Force parent layout update to ensure proper spacing
|
||
if self.parent():
|
||
self.parent().updateGeometry()
|
||
|
||
def sizeHint(self):
|
||
"""Provide consistent size hint for layout calculations"""
|
||
if self.is_expanded:
|
||
return self.size().expandedTo(self.minimumSize()).boundedTo(self.maximumSize())
|
||
else:
|
||
return self.size().expandedTo(self.minimumSize()).boundedTo(self.maximumSize())
|
||
|
||
def _truncate_file_path(self, username, filename):
|
||
"""Truncate file path to show max 3 levels: file + parent + grandparent folder"""
|
||
import os
|
||
|
||
# If username looks like a simple username (no path separators), return as-is
|
||
if '/' not in username and '\\' not in username:
|
||
return username
|
||
|
||
# Get filename without extension for comparison
|
||
file_base = os.path.splitext(os.path.basename(filename))[0]
|
||
|
||
# Split path using both Windows and Unix separators
|
||
path_parts = username.replace('\\', '/').split('/')
|
||
|
||
# Remove empty parts
|
||
path_parts = [part for part in path_parts if part.strip()]
|
||
|
||
# If path is already short, return as-is
|
||
if len(path_parts) <= 3:
|
||
return '/'.join(path_parts)
|
||
|
||
# Take last 3 components (file + parent + grandparent)
|
||
truncated_parts = path_parts[-3:]
|
||
|
||
# If we truncated, add ellipsis at the beginning
|
||
if len(path_parts) > 3:
|
||
return '.../' + '/'.join(truncated_parts)
|
||
else:
|
||
return '/'.join(truncated_parts)
|
||
|
||
def _extract_song_info(self):
|
||
"""Extract song title and artist from TrackResult"""
|
||
# Handle case where search_result is a list (shouldn't happen but be defensive)
|
||
if isinstance(self.search_result, list):
|
||
if len(self.search_result) > 0:
|
||
# Take the first item if it's a list
|
||
actual_result = self.search_result[0]
|
||
else:
|
||
# Empty list, return defaults
|
||
return {'title': 'Unknown Title', 'artist': 'Unknown Artist'}
|
||
else:
|
||
actual_result = self.search_result
|
||
|
||
# TrackResult objects have parsed metadata available
|
||
if hasattr(actual_result, 'title') and hasattr(actual_result, 'artist'):
|
||
# Use parsed metadata from TrackResult
|
||
return {
|
||
'title': actual_result.title or 'Unknown Title',
|
||
'artist': actual_result.artist or 'Unknown Artist'
|
||
}
|
||
|
||
# Fallback: parse from filename if metadata not available
|
||
if hasattr(actual_result, 'filename'):
|
||
filename = actual_result.filename
|
||
|
||
# Remove file extension
|
||
name_without_ext = filename.rsplit('.', 1)[0]
|
||
|
||
# Common patterns for artist - title separation
|
||
separators = [' - ', ' – ', ' — ', '_-_', ' | ']
|
||
|
||
for sep in separators:
|
||
if sep in name_without_ext:
|
||
parts = name_without_ext.split(sep, 1)
|
||
return {
|
||
'title': parts[1].strip(),
|
||
'artist': parts[0].strip()
|
||
}
|
||
|
||
# If no separator found, use filename as title
|
||
return {
|
||
'title': name_without_ext,
|
||
'artist': 'Unknown Artist'
|
||
}
|
||
else:
|
||
# No filename attribute, return defaults
|
||
return {
|
||
'title': 'Unknown Title',
|
||
'artist': 'Unknown Artist'
|
||
}
|
||
|
||
def _create_compact_quality_badge(self):
|
||
"""Create a compact quality indicator badge"""
|
||
# Handle list case defensively
|
||
result = self.search_result[0] if isinstance(self.search_result, list) else self.search_result
|
||
|
||
quality = result.quality.upper()
|
||
bitrate = result.bitrate
|
||
|
||
if quality == 'FLAC':
|
||
badge_text = "FLAC"
|
||
badge_color = "#1db954"
|
||
elif bitrate and bitrate >= 320:
|
||
badge_text = f"{bitrate}k"
|
||
badge_color = "#1db954"
|
||
elif bitrate and bitrate >= 256:
|
||
badge_text = f"{bitrate}k"
|
||
badge_color = "#ffa500"
|
||
elif bitrate and bitrate >= 192:
|
||
badge_text = f"{bitrate}k"
|
||
badge_color = "#ffaa00"
|
||
else:
|
||
badge_text = quality[:3] # Truncate for compact display
|
||
badge_color = "#e22134"
|
||
|
||
badge = QLabel(badge_text)
|
||
badge.setFont(QFont("Arial", 8, QFont.Weight.Bold))
|
||
badge.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
badge.setFixedSize(40, 16)
|
||
badge.setStyleSheet(f"""
|
||
QLabel {{
|
||
background: {badge_color};
|
||
color: #000000;
|
||
border-radius: 8px;
|
||
padding: 1px 4px;
|
||
}}
|
||
""")
|
||
|
||
return badge
|
||
|
||
def _create_compact_speed_indicator(self):
|
||
"""Create compact upload speed indicator"""
|
||
# Handle list case defensively
|
||
result = self.search_result[0] if isinstance(self.search_result, list) else self.search_result
|
||
|
||
# Get speed and slots data with fallback handling
|
||
speed = getattr(result, 'upload_speed', None) or 0
|
||
slots = getattr(result, 'free_upload_slots', None) or 0
|
||
|
||
# Debug: Print actual values to see what we're getting
|
||
print(f"[DEBUG] Speed indicator - speed: {speed}, slots: {slots}, user: {getattr(result, 'username', 'unknown')}")
|
||
|
||
# Speed-focused logic (slots as bonus, not requirement)
|
||
if speed > 200:
|
||
indicator_color = "#1db954"
|
||
icon = ""
|
||
tooltip = f"Very Fast: {speed} KB/s" + (f", {slots} slots" if slots > 0 else "")
|
||
elif speed > 100:
|
||
indicator_color = "#1db954" if slots > 0 else "#4CAF50"
|
||
icon = "" if slots > 0 else ""
|
||
tooltip = f"Fast: {speed} KB/s" + (f", {slots} slots" if slots > 0 else "")
|
||
elif speed > 50:
|
||
indicator_color = "#ffa500"
|
||
icon = ""
|
||
tooltip = f"Good: {speed} KB/s" + (f", {slots} slots" if slots > 0 else "")
|
||
elif speed > 0:
|
||
indicator_color = "#ffaa00"
|
||
icon = ""
|
||
tooltip = f"Slow: {speed} KB/s" + (f", {slots} slots" if slots > 0 else "")
|
||
else:
|
||
indicator_color = "#e22134"
|
||
icon = ""
|
||
tooltip = "No speed data available"
|
||
|
||
# Convert KB/s to MB/s and format nicely
|
||
if speed > 0:
|
||
speed_mb = speed / 1024 # Convert KB to MB
|
||
if speed_mb >= 1:
|
||
speed_display = f"{speed_mb:.1f}MB/s"
|
||
else:
|
||
speed_display = f"{speed}KB/s"
|
||
speed_text = f"{icon} {speed_display}"
|
||
else:
|
||
speed_text = icon
|
||
|
||
indicator = QLabel(speed_text)
|
||
indicator.setFont(QFont("Arial", 9)) # Slightly smaller to fit text
|
||
indicator.setStyleSheet(f"color: {indicator_color};")
|
||
indicator.setToolTip(tooltip) # Add tooltip for debugging
|
||
indicator.setMinimumWidth(60) # Allow space for icon + speed text
|
||
indicator.setFixedHeight(16)
|
||
|
||
return indicator
|
||
|
||
def _create_quality_badge(self):
|
||
"""Create a quality indicator badge (legacy - kept for compatibility)"""
|
||
return self._create_compact_quality_badge()
|
||
|
||
def _create_speed_indicator(self):
|
||
"""Create upload speed indicator (legacy - kept for compatibility)"""
|
||
return self._create_compact_speed_indicator()
|
||
|
||
def request_download(self):
|
||
if not self.is_downloading:
|
||
self.is_downloading = True
|
||
self.download_btn.setText("")
|
||
self.download_btn.setEnabled(False)
|
||
self.download_requested.emit(self.search_result)
|
||
|
||
def request_matched_download(self):
|
||
"""Request a matched download with Spotify integration"""
|
||
if not self.is_downloading:
|
||
# Get reference to the DownloadsPage to handle matched download
|
||
downloads_page = self.get_downloads_page()
|
||
if downloads_page:
|
||
downloads_page.start_matched_download(self.search_result)
|
||
|
||
def request_stream(self):
|
||
"""Request streaming of this audio file"""
|
||
# Check if file is a valid audio type
|
||
audio_extensions = ['.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav']
|
||
filename_lower = self.search_result.filename.lower()
|
||
|
||
is_audio = any(filename_lower.endswith(ext) for ext in audio_extensions)
|
||
|
||
if is_audio:
|
||
# Get reference to the DownloadsPage to check audio player state
|
||
downloads_page = self.get_downloads_page()
|
||
|
||
# If this button is currently playing, toggle pause/resume
|
||
if (downloads_page and
|
||
downloads_page.currently_playing_button == self and
|
||
downloads_page.audio_player.is_playing):
|
||
|
||
# Toggle playback (pause/resume)
|
||
is_playing = downloads_page.audio_player.toggle_playback()
|
||
if is_playing:
|
||
self.set_playing_state()
|
||
else:
|
||
self.play_btn.setText("") # Play icon when paused
|
||
self.play_btn.setEnabled(True)
|
||
return
|
||
|
||
# Otherwise, start new streaming
|
||
# Change button state to indicate streaming is starting
|
||
self.play_btn.setText("") # Pause icon to indicate playing
|
||
self.play_btn.setEnabled(False)
|
||
|
||
# Emit streaming request
|
||
self.stream_requested.emit(self.search_result)
|
||
|
||
# Note: Button state will be managed by the audio player callbacks
|
||
# No timer reset - the audio player will handle state changes
|
||
else:
|
||
print(f"Cannot stream non-audio file: {self.search_result.filename}")
|
||
|
||
def get_downloads_page(self):
|
||
"""Get reference to the parent DownloadsPage"""
|
||
parent = self.parent()
|
||
while parent:
|
||
if hasattr(parent, 'audio_player'): # DownloadsPage has audio_player
|
||
return parent
|
||
parent = parent.parent()
|
||
return None
|
||
|
||
def reset_play_state(self, original_text=""):
|
||
"""Reset the play button state"""
|
||
self.play_btn.setText(original_text)
|
||
self.play_btn.setEnabled(True)
|
||
|
||
def set_playing_state(self):
|
||
"""Set button to playing state"""
|
||
self.play_btn.setText("")
|
||
self.play_btn.setEnabled(True)
|
||
|
||
def set_loading_state(self):
|
||
"""Set button to loading state"""
|
||
self.play_btn.setText("⌛")
|
||
self.play_btn.setEnabled(False)
|
||
|
||
def set_queue_state(self):
|
||
"""Set play button to queue state"""
|
||
self.play_btn.setText("")
|
||
self.play_btn.setEnabled(False)
|
||
self.play_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(255, 165, 0, 0.2);
|
||
border: 1px solid rgba(255, 165, 0, 0.4);
|
||
border-radius: 18px;
|
||
color: rgba(255, 165, 0, 0.8);
|
||
font-size: 12px;
|
||
}
|
||
""")
|
||
|
||
def reset_download_state(self):
|
||
"""Reset the download button state"""
|
||
self.is_downloading = False
|
||
self.download_btn.setText("⬇️")
|
||
self.download_btn.setEnabled(True)
|
||
|
||
class DownloadItem(QFrame):
|
||
def __init__(self, title: str, artist: str, status: str, progress: int = 0,
|
||
file_size: int = 0, download_speed: int = 0, file_path: str = "",
|
||
download_id: str = "", soulseek_client=None, parent=None):
|
||
super().__init__(parent)
|
||
self.title = title
|
||
self.artist = artist
|
||
self.status = status
|
||
self.progress = progress
|
||
self.file_size = file_size
|
||
self.download_speed = download_speed
|
||
self.file_path = file_path
|
||
self.download_id = download_id # Track download ID for cancellation
|
||
self.soulseek_client = soulseek_client # For cancellation functionality
|
||
|
||
# Add completion tracking to prevent duplicate processing
|
||
self._completion_processed = False
|
||
self._completion_lock = threading.Lock()
|
||
|
||
self.setup_ui()
|
||
|
||
def mark_completion_processed(self) -> bool:
|
||
"""Thread-safe method to mark download as completion-processed.
|
||
Returns True if this is the first time marking completion, False if already processed."""
|
||
with self._completion_lock:
|
||
if self._completion_processed:
|
||
return False # Already processed
|
||
self._completion_processed = True
|
||
return True # First time processing
|
||
|
||
def is_completion_processed(self) -> bool:
|
||
"""Check if completion has already been processed."""
|
||
with self._completion_lock:
|
||
return self._completion_processed
|
||
|
||
def setup_ui(self):
|
||
self.setFixedHeight(85) # More generous height for better spacing
|
||
self.setStyleSheet("""
|
||
DownloadItem {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(40, 40, 40, 0.95),
|
||
stop:1 rgba(32, 32, 32, 0.95));
|
||
border-radius: 12px;
|
||
border: 1px solid rgba(64, 64, 64, 0.4);
|
||
margin: 6px 4px;
|
||
}
|
||
DownloadItem:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(50, 50, 50, 0.95),
|
||
stop:1 rgba(40, 40, 40, 0.98));
|
||
border: 1px solid rgba(29, 185, 84, 0.7);
|
||
}
|
||
""")
|
||
|
||
# Main horizontal layout
|
||
layout = QHBoxLayout(self)
|
||
layout.setContentsMargins(16, 12, 16, 12)
|
||
layout.setSpacing(16)
|
||
|
||
# Left section: Filename + uploader (flexible)
|
||
left_section = QVBoxLayout()
|
||
left_section.setSpacing(4)
|
||
|
||
# Extract filename with extension from file_path
|
||
filename_with_ext = "Unknown File"
|
||
if self.file_path:
|
||
from pathlib import Path
|
||
try:
|
||
filename_with_ext = Path(self.file_path).name
|
||
except:
|
||
filename_with_ext = self.title # fallback
|
||
else:
|
||
filename_with_ext = self.title # fallback
|
||
|
||
# Filename with extension (main info)
|
||
filename_label = QLabel(filename_with_ext)
|
||
filename_label.setFont(QFont("Segoe UI", 13, QFont.Weight.Bold))
|
||
filename_label.setStyleSheet("color: #ffffff;")
|
||
filename_label.setWordWrap(False)
|
||
filename_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
|
||
|
||
# Uploader info
|
||
uploader_label = QLabel(f"from {self.artist}")
|
||
uploader_label.setFont(QFont("Segoe UI", 10))
|
||
uploader_label.setStyleSheet("color: #b3b3b3;")
|
||
uploader_label.setWordWrap(False)
|
||
uploader_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
|
||
|
||
left_section.addWidget(filename_label)
|
||
left_section.addWidget(uploader_label)
|
||
|
||
# Middle section: Progress (fixed width)
|
||
progress_widget = QWidget()
|
||
progress_widget.setFixedWidth(120)
|
||
progress_layout = QVBoxLayout(progress_widget)
|
||
progress_layout.setSpacing(6)
|
||
progress_layout.setContentsMargins(0, 0, 0, 0)
|
||
|
||
# Progress bar
|
||
self.progress_bar = QProgressBar()
|
||
self.progress_bar.setFixedHeight(8)
|
||
self.progress_bar.setValue(self.progress)
|
||
self.progress_bar.setStyleSheet("""
|
||
QProgressBar {
|
||
border: none;
|
||
border-radius: 4px;
|
||
background: #404040;
|
||
}
|
||
QProgressBar::chunk {
|
||
background: #1db954;
|
||
border-radius: 4px;
|
||
}
|
||
""")
|
||
|
||
# Status text
|
||
status_mapping = {
|
||
"completed, succeeded": "Finished",
|
||
"completed, cancelled": "Cancelled",
|
||
"completed": "Finished",
|
||
"cancelled": "Cancelled",
|
||
"downloading": "Downloading",
|
||
"failed": "Failed",
|
||
"queued": "Queued"
|
||
}
|
||
|
||
clean_status = status_mapping.get(self.status.lower(), self.status.title())
|
||
if self.status.lower() in ["downloading", "queued"]:
|
||
status_text = f"{clean_status} - {self.progress}%"
|
||
else:
|
||
status_text = clean_status
|
||
|
||
self.status_label = QLabel(status_text)
|
||
self.status_label.setFont(QFont("Segoe UI", 9))
|
||
self.status_label.setStyleSheet("color: #b3b3b3;")
|
||
self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
|
||
progress_layout.addWidget(self.progress_bar)
|
||
progress_layout.addWidget(self.status_label)
|
||
|
||
# Right section: Action button (fixed width)
|
||
self.action_btn = QPushButton()
|
||
self.action_btn.setFixedSize(90, 36)
|
||
|
||
if self.status == "downloading":
|
||
self.action_btn.setText("Cancel")
|
||
self.action_btn.clicked.connect(self.cancel_download)
|
||
self.action_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(220, 53, 69, 0.8),
|
||
stop:1 rgba(220, 53, 69, 1.0));
|
||
color: white;
|
||
border: none;
|
||
border-radius: 8px;
|
||
font-weight: bold;
|
||
font-size: 11px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(200, 33, 49, 0.9),
|
||
stop:1 rgba(200, 33, 49, 1.0));
|
||
}
|
||
""")
|
||
elif self.status == "failed":
|
||
self.action_btn.setText("Retry")
|
||
self.action_btn.clicked.connect(self.retry_download)
|
||
self.action_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(255, 193, 7, 0.8),
|
||
stop:1 rgba(255, 193, 7, 1.0));
|
||
color: #000;
|
||
border: none;
|
||
border-radius: 8px;
|
||
font-weight: bold;
|
||
font-size: 11px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(235, 173, 0, 0.9),
|
||
stop:1 rgba(235, 173, 0, 1.0));
|
||
}
|
||
""")
|
||
else:
|
||
self.action_btn.setText("Open")
|
||
self.action_btn.clicked.connect(self.open_download_location)
|
||
self.action_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(40, 167, 69, 0.8),
|
||
stop:1 rgba(40, 167, 69, 1.0));
|
||
color: white;
|
||
border: none;
|
||
border-radius: 8px;
|
||
font-weight: bold;
|
||
font-size: 11px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(20, 147, 49, 0.9),
|
||
stop:1 rgba(20, 147, 49, 1.0));
|
||
}
|
||
""")
|
||
|
||
# Add everything to main layout
|
||
layout.addLayout(left_section, 1) # Flexible
|
||
layout.addWidget(progress_widget) # Fixed width
|
||
layout.addWidget(self.action_btn) # Fixed width
|
||
|
||
def open_download_location(self):
|
||
"""Open the download location in file explorer"""
|
||
import os
|
||
import platform
|
||
from pathlib import Path
|
||
|
||
if not self.file_path:
|
||
return
|
||
|
||
try:
|
||
file_path = Path(self.file_path)
|
||
if file_path.exists():
|
||
# Open the folder containing the file
|
||
folder_path = file_path.parent
|
||
|
||
system = platform.system()
|
||
if system == "Windows":
|
||
os.startfile(str(folder_path))
|
||
elif system == "Darwin": # macOS
|
||
os.system(f'open "{folder_path}"')
|
||
else: # Linux
|
||
os.system(f'xdg-open "{folder_path}"')
|
||
else:
|
||
# If file doesn't exist, try to open the download directory from config
|
||
from config.settings import config_manager
|
||
download_path = config_manager.get('soulseek.download_path', './downloads')
|
||
|
||
system = platform.system()
|
||
if system == "Windows":
|
||
os.startfile(download_path)
|
||
elif system == "Darwin": # macOS
|
||
os.system(f'open "{download_path}"')
|
||
else: # Linux
|
||
os.system(f'xdg-open "{download_path}"')
|
||
|
||
except Exception as e:
|
||
print(f"Error opening download location: {e}")
|
||
|
||
def update_status(self, status: str, progress: int = None, download_speed: int = None, file_path: str = None):
|
||
"""SAFE UPDATE: Update download item status without UI destruction"""
|
||
# Update properties
|
||
self.status = status
|
||
if progress is not None:
|
||
self.progress = progress
|
||
if download_speed is not None:
|
||
self.download_speed = download_speed
|
||
if file_path:
|
||
self.file_path = file_path
|
||
|
||
# SAFE UI UPDATES: Update widgets directly instead of recreating
|
||
try:
|
||
# Update progress bar safely
|
||
if hasattr(self, 'progress_bar') and self.progress_bar:
|
||
self.progress_bar.setValue(self.progress)
|
||
|
||
# Update status label safely
|
||
if hasattr(self, 'status_label') and self.status_label:
|
||
# Clean up status text display
|
||
status_mapping = {
|
||
"completed, succeeded": "Finished",
|
||
"completed, cancelled": "Cancelled",
|
||
"completed": "Finished",
|
||
"cancelled": "Cancelled",
|
||
"downloading": "Downloading",
|
||
"failed": "Failed",
|
||
"queued": "Queued"
|
||
}
|
||
|
||
clean_status = status_mapping.get(self.status.lower(), self.status.title())
|
||
status_text = clean_status
|
||
|
||
if self.status.lower() in ["downloading", "queued"]:
|
||
status_text += f" - {self.progress}%"
|
||
|
||
self.status_label.setText(status_text)
|
||
|
||
# Update action button based on status
|
||
if hasattr(self, 'action_btn') and self.action_btn:
|
||
if self.status == "downloading":
|
||
self.action_btn.setText("Cancel")
|
||
# Disconnect old connections
|
||
self.action_btn.clicked.disconnect()
|
||
self.action_btn.clicked.connect(self.cancel_download)
|
||
self.action_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(220, 53, 69, 0.8),
|
||
stop:1 rgba(220, 53, 69, 1.0));
|
||
color: white;
|
||
border: none;
|
||
border-radius: 8px;
|
||
font-weight: bold;
|
||
font-size: 11px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(200, 33, 49, 0.9),
|
||
stop:1 rgba(200, 33, 49, 1.0));
|
||
}
|
||
""")
|
||
elif self.status == "failed":
|
||
self.action_btn.setText("Retry")
|
||
# Disconnect old connections
|
||
self.action_btn.clicked.disconnect()
|
||
self.action_btn.clicked.connect(self.retry_download)
|
||
self.action_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(255, 193, 7, 0.8),
|
||
stop:1 rgba(255, 193, 7, 1.0));
|
||
color: #000;
|
||
border: none;
|
||
border-radius: 8px;
|
||
font-weight: bold;
|
||
font-size: 11px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(235, 173, 0, 0.9),
|
||
stop:1 rgba(235, 173, 0, 1.0));
|
||
}
|
||
""")
|
||
else:
|
||
self.action_btn.setText("Open")
|
||
# Disconnect old connections
|
||
self.action_btn.clicked.disconnect()
|
||
self.action_btn.clicked.connect(self.open_download_location)
|
||
self.action_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(40, 167, 69, 0.8),
|
||
stop:1 rgba(40, 167, 69, 1.0));
|
||
color: white;
|
||
border: none;
|
||
border-radius: 8px;
|
||
font-weight: bold;
|
||
font-size: 11px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(20, 147, 49, 0.9),
|
||
stop:1 rgba(20, 147, 49, 1.0));
|
||
}
|
||
""")
|
||
|
||
except Exception as e:
|
||
print(f"Error updating download item UI: {e}")
|
||
# Fallback: only recreate if safe update fails
|
||
self.setup_ui()
|
||
|
||
def cancel_download(self):
|
||
"""Cancel the download using the SoulseekClient"""
|
||
if not self.soulseek_client or not self.download_id:
|
||
print(f"Cannot cancel download: missing client or download ID")
|
||
return
|
||
|
||
# Find the parent DownloadsPage to use its async helper
|
||
parent_page = self.parent()
|
||
while parent_page and not hasattr(parent_page, '_run_async_operation'):
|
||
parent_page = parent_page.parent()
|
||
|
||
if parent_page:
|
||
# Use the parent's async helper for safe event loop management
|
||
def on_success(result):
|
||
if result:
|
||
print(f"Successfully cancelled download: {self.title}")
|
||
self.update_status("cancelled", progress=0)
|
||
|
||
# Find the parent TabbedDownloadManager and move to finished tab
|
||
parent_widget = self.parent()
|
||
while parent_widget:
|
||
if hasattr(parent_widget, 'move_to_finished'):
|
||
parent_widget.move_to_finished(self)
|
||
break
|
||
parent_widget = parent_widget.parent()
|
||
|
||
else:
|
||
print(f"Failed to cancel download: {self.title}")
|
||
|
||
def on_error(error):
|
||
print(f"Error cancelling download {self.title}: {error}")
|
||
|
||
parent_page._run_async_operation(
|
||
self.soulseek_client.cancel_download,
|
||
self.download_id,
|
||
success_callback=on_success,
|
||
error_callback=on_error
|
||
)
|
||
else:
|
||
print(f"[ERROR] Could not find parent DownloadsPage for async operation")
|
||
|
||
def retry_download(self):
|
||
"""Retry a failed download"""
|
||
# For now, just update status back to downloading
|
||
# In a full implementation, this would restart the download
|
||
self.update_status("downloading", progress=0)
|
||
print(f"Retry requested for: {self.title}")
|
||
|
||
def show_details(self):
|
||
"""Show download details"""
|
||
details = f"""
|
||
Download Details:
|
||
Title: {self.title}
|
||
Artist: {self.artist}
|
||
Status: {self.status}
|
||
Progress: {self.progress}%
|
||
File Size: {self.file_size // (1024*1024)}MB
|
||
Download ID: {self.download_id}
|
||
File Path: {self.file_path}
|
||
"""
|
||
print(details)
|
||
|
||
class CompactDownloadItem(QFrame):
|
||
"""Compact download item optimized for queue display"""
|
||
def __init__(self, title: str, artist: str, status: str = "queued",
|
||
progress: int = 0, file_size: int = 0, download_speed: int = 0,
|
||
file_path: str = "", download_id: str = "", username: str = "",
|
||
soulseek_client=None, queue_type: str = "active",
|
||
album: str = None, track_number: int = None,
|
||
parent=None):
|
||
super().__init__(parent)
|
||
self.title = title
|
||
self.artist = artist
|
||
self.status = status
|
||
self.progress = progress
|
||
self.file_size = file_size
|
||
self.download_speed = download_speed
|
||
self.file_path = file_path
|
||
self.download_id = download_id
|
||
self.username = username
|
||
self.soulseek_client = soulseek_client
|
||
self.queue_type = queue_type # "active" or "finished"
|
||
|
||
# Album metadata for matched downloads
|
||
self.album = album
|
||
self.track_number = track_number
|
||
|
||
# Add completion tracking to prevent duplicate processing
|
||
self._completion_processed = False
|
||
self._completion_lock = threading.Lock()
|
||
|
||
self.setup_ui()
|
||
|
||
def mark_completion_processed(self) -> bool:
|
||
"""Thread-safe method to mark download as completion-processed.
|
||
Returns True if this is the first time marking completion, False if already processed."""
|
||
with self._completion_lock:
|
||
if self._completion_processed:
|
||
return False # Already processed
|
||
self._completion_processed = True
|
||
return True # First time processing
|
||
|
||
def is_completion_processed(self) -> bool:
|
||
"""Check if completion has already been processed."""
|
||
with self._completion_lock:
|
||
return self._completion_processed
|
||
|
||
def setup_ui(self):
|
||
self.setMinimumHeight(85) # Further increased minimum to give more room for artist names
|
||
self.setMaximumHeight(140) # Increased maximum for better text accommodation
|
||
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
|
||
self.setStyleSheet("""
|
||
CompactDownloadItem {
|
||
background: rgba(45, 45, 45, 0.95);
|
||
border-radius: 6px;
|
||
border: 1px solid rgba(60, 60, 60, 0.6);
|
||
margin: 2px 1px;
|
||
}
|
||
CompactDownloadItem:hover {
|
||
background: rgba(55, 55, 55, 1.0);
|
||
border: 1px solid rgba(29, 185, 84, 0.5);
|
||
}
|
||
""")
|
||
|
||
# Main vertical layout for better space utilization
|
||
layout = QVBoxLayout(self)
|
||
layout.setContentsMargins(12, 12, 12, 12) # Further increased margins for better text spacing
|
||
layout.setSpacing(10) # Increased spacing between filename and bottom row
|
||
|
||
# Top row: Filename with text wrapping
|
||
filename_with_ext = self.get_display_filename()
|
||
self.filename_label = QLabel(filename_with_ext)
|
||
self.filename_label.setFont(QFont("Segoe UI", 10, QFont.Weight.Medium))
|
||
self.filename_label.setStyleSheet("color: #ffffff; background: transparent;")
|
||
self.filename_label.setWordWrap(True) # Enable text wrapping
|
||
self.filename_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
|
||
self.filename_label.setToolTip(filename_with_ext)
|
||
|
||
# Bottom row: Uploader, Progress/Status, and Action button
|
||
bottom_layout = QHBoxLayout()
|
||
bottom_layout.setContentsMargins(0, 2, 0, 0) # Added small top margin for better spacing
|
||
bottom_layout.setSpacing(10) # Increased spacing between elements
|
||
|
||
# Uploader info - remove fixed width constraint and allow text wrapping
|
||
self.uploader_label = QLabel()
|
||
self.uploader_label.setFont(QFont("Segoe UI", 9, QFont.Weight.Normal))
|
||
self.uploader_label.setStyleSheet("color: #b8b8b8; background: transparent;")
|
||
self.uploader_label.setWordWrap(True) # Enable text wrapping
|
||
self.uploader_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum) # Changed from Fixed to Minimum
|
||
self.uploader_label.setMinimumHeight(20) # Ensure minimum height for text visibility
|
||
self.uploader_label.setToolTip(f"Uploader: {self.artist}")
|
||
self.uploader_label.setText(self.artist) # Set text directly instead of using ellipsis function
|
||
|
||
# Conditional layout based on queue type - PRESERVE ALL EXISTING BUTTON CODE
|
||
if self.queue_type == "active":
|
||
# Section 3: Progress (KEEP EXISTING PROGRESS WIDGET EXACTLY AS IS)
|
||
progress_widget = QWidget()
|
||
progress_widget.setFixedWidth(90)
|
||
progress_layout = QVBoxLayout(progress_widget)
|
||
progress_layout.setContentsMargins(0, 0, 0, 0)
|
||
progress_layout.setSpacing(1)
|
||
|
||
# Compact progress bar - COMPLETELY UNCHANGED
|
||
self.progress_bar = QProgressBar()
|
||
self.progress_bar.setFixedHeight(6)
|
||
self.progress_bar.setValue(self.progress)
|
||
self.progress_bar.setStyleSheet("""
|
||
QProgressBar {
|
||
border: none;
|
||
border-radius: 3px;
|
||
background: rgba(60, 60, 60, 0.8);
|
||
}
|
||
QProgressBar::chunk {
|
||
background: rgba(29, 185, 84, 1.0);
|
||
border-radius: 3px;
|
||
}
|
||
""")
|
||
|
||
# Progress percentage - COMPLETELY UNCHANGED
|
||
self.progress_label = QLabel(f"{self.progress}%")
|
||
self.progress_label.setFont(QFont("Segoe UI", 8))
|
||
self.progress_label.setStyleSheet("color: #c0c0c0;")
|
||
self.progress_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
|
||
progress_layout.addWidget(self.progress_bar)
|
||
progress_layout.addWidget(self.progress_label)
|
||
|
||
# Section 4: Cancel button - PRESERVE EXACTLY AS IS, NO CHANGES
|
||
self.cancel_btn = QPushButton("Cancel")
|
||
self.cancel_btn.setFixedSize(60, 35)
|
||
self.cancel_btn.clicked.connect(self.cancel_download)
|
||
self.cancel_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(220, 53, 69, 0.9);
|
||
color: white;
|
||
border: 1px solid rgba(220, 53, 69, 0.6);
|
||
border-radius: 4px;
|
||
font-size: 9px;
|
||
font-weight: 500;
|
||
}
|
||
QPushButton:hover {
|
||
background: rgba(240, 73, 89, 1.0);
|
||
}
|
||
QPushButton:pressed {
|
||
background: rgba(200, 43, 58, 1.0);
|
||
}
|
||
""")
|
||
|
||
# Add to bottom layout
|
||
bottom_layout.addWidget(self.uploader_label, 1)
|
||
bottom_layout.addWidget(progress_widget)
|
||
bottom_layout.addWidget(self.cancel_btn)
|
||
|
||
else:
|
||
# Finished downloads - display a different widget based on the final status.
|
||
self.progress_bar = None
|
||
self.progress_label = None
|
||
|
||
final_status = self.status.lower()
|
||
|
||
action_widget = QWidget()
|
||
action_layout = QHBoxLayout(action_widget)
|
||
action_layout.setContentsMargins(0, 0, 0, 0)
|
||
action_layout.setAlignment(Qt.AlignmentFlag.AlignRight)
|
||
action_widget.setFixedWidth(70)
|
||
|
||
if 'completed' in final_status or 'succeeded' in final_status:
|
||
# For successfully completed downloads, show the 'Open' button.
|
||
open_btn = QPushButton("Open")
|
||
open_btn.setFixedSize(60, 35)
|
||
open_btn.clicked.connect(self.open_download_location)
|
||
open_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(40, 167, 69, 0.9); color: white; border: 1px solid rgba(29, 185, 84, 0.6);
|
||
border-radius: 4px; font-size: 9px; font-weight: 500;
|
||
}
|
||
QPushButton:hover { background: rgba(50, 187, 79, 1.0); }
|
||
QPushButton:pressed { background: rgba(32, 140, 58, 1.0); }
|
||
""")
|
||
action_layout.addWidget(open_btn)
|
||
|
||
elif 'cancelled' in final_status or 'canceled' in final_status:
|
||
# For cancelled downloads, show a "Cancelled" label.
|
||
status_label = QLabel("Cancelled")
|
||
status_label.setStyleSheet("color: #ffa500; font-weight: bold; font-size: 10px;")
|
||
status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
action_layout.addWidget(status_label)
|
||
|
||
elif 'failed' in final_status or 'errored' in final_status:
|
||
# For failed or errored downloads, show a "Failed" label.
|
||
status_label = QLabel("Failed")
|
||
status_label.setStyleSheet("color: #e22134; font-weight: bold; font-size: 10px;")
|
||
status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
action_layout.addWidget(status_label)
|
||
|
||
else: # Fallback for any other unexpected status
|
||
open_btn = QPushButton("Open")
|
||
open_btn.setFixedSize(60, 35)
|
||
open_btn.clicked.connect(self.open_download_location)
|
||
action_layout.addWidget(open_btn)
|
||
|
||
# Add the uploader label and the new action_widget to the layout.
|
||
bottom_layout.addWidget(self.uploader_label, 1)
|
||
bottom_layout.addWidget(action_widget)
|
||
|
||
# Add both sections to main layout
|
||
layout.addWidget(self.filename_label)
|
||
layout.addLayout(bottom_layout)
|
||
|
||
def _set_ellipsis_text(self, label, text, max_width):
|
||
"""Set text with ellipsis if it's too long for the given width"""
|
||
font_metrics = label.fontMetrics()
|
||
# Reserve some padding space (8px total)
|
||
available_width = max_width - 8
|
||
|
||
if font_metrics.horizontalAdvance(text) <= available_width:
|
||
label.setText(text)
|
||
else:
|
||
# Truncate with ellipsis
|
||
ellipsis_width = font_metrics.horizontalAdvance("...")
|
||
available_for_text = available_width - ellipsis_width
|
||
|
||
# Binary search for the right length
|
||
left, right = 0, len(text)
|
||
while left < right:
|
||
mid = (left + right + 1) // 2
|
||
if font_metrics.horizontalAdvance(text[:mid]) <= available_for_text:
|
||
left = mid
|
||
else:
|
||
right = mid - 1
|
||
|
||
truncated_text = text[:left] + "..."
|
||
label.setText(truncated_text)
|
||
|
||
def get_display_filename(self):
|
||
"""Extract just the filename with extension for display"""
|
||
if self.file_path:
|
||
from pathlib import Path
|
||
try:
|
||
return Path(self.file_path).name
|
||
except:
|
||
pass
|
||
# Fallback to title if no file_path or error
|
||
return self.title if self.title else "Unknown File"
|
||
|
||
def get_status_text(self):
|
||
"""Get appropriate status text for display"""
|
||
status_mapping = {
|
||
"completed, succeeded": "Done",
|
||
"completed, cancelled": "Cancelled",
|
||
"completed": "Done",
|
||
"cancelled": "Cancelled",
|
||
"downloading": f"{self.progress}%",
|
||
"failed": "Failed",
|
||
"queued": "Queued"
|
||
}
|
||
return status_mapping.get(self.status.lower(), self.status.title())
|
||
|
||
def update_status(self, status: str, progress: int = None, download_speed: int = None, file_path: str = None):
|
||
"""Update the status and progress of the download item"""
|
||
self.status = status
|
||
if progress is not None:
|
||
self.progress = progress
|
||
if download_speed is not None:
|
||
self.download_speed = download_speed
|
||
if file_path:
|
||
self.file_path = file_path
|
||
# Update filename display if file_path changed
|
||
if hasattr(self, 'filename_label') and self.filename_label:
|
||
try:
|
||
filename_with_ext = self.get_display_filename()
|
||
self.filename_label.setText(filename_with_ext)
|
||
self.filename_label.setToolTip(filename_with_ext)
|
||
except RuntimeError:
|
||
# Qt object has been deleted, skip update
|
||
pass
|
||
|
||
# Update progress components for active downloads only
|
||
if self.queue_type == "active":
|
||
if hasattr(self, 'progress_bar') and self.progress_bar:
|
||
try:
|
||
self.progress_bar.setValue(self.progress)
|
||
except RuntimeError:
|
||
# Qt object has been deleted, skip update
|
||
pass
|
||
if hasattr(self, 'progress_label') and self.progress_label:
|
||
try:
|
||
self.progress_label.setText(f"{self.progress}%")
|
||
except RuntimeError:
|
||
# Qt object has been deleted, skip update
|
||
pass
|
||
|
||
# Update cancel button state based on status
|
||
if hasattr(self, 'cancel_btn') and self.cancel_btn:
|
||
try:
|
||
if status.lower() in ['cancelled', 'canceled', 'failed']:
|
||
# Disable button and update text for cancelled/failed downloads
|
||
self.cancel_btn.setText("Cancelled")
|
||
self.cancel_btn.setEnabled(False)
|
||
self.cancel_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(100, 100, 100, 0.5);
|
||
color: rgba(255, 255, 255, 0.6);
|
||
border: 1px solid rgba(100, 100, 100, 0.4);
|
||
border-radius: 4px;
|
||
font-size: 9px;
|
||
font-weight: 500;
|
||
}
|
||
""")
|
||
elif status.lower() in ['downloading', 'queued']:
|
||
# Re-enable button for active downloads
|
||
self.cancel_btn.setText("Cancel")
|
||
self.cancel_btn.setEnabled(True)
|
||
self.cancel_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(220, 53, 69, 0.9);
|
||
color: white;
|
||
border: 1px solid rgba(220, 53, 69, 0.6);
|
||
border-radius: 4px;
|
||
font-size: 9px;
|
||
font-weight: 500;
|
||
}
|
||
QPushButton:hover {
|
||
background: rgba(240, 73, 89, 1.0);
|
||
}
|
||
QPushButton:pressed {
|
||
background: rgba(200, 43, 58, 1.0);
|
||
}
|
||
""")
|
||
except RuntimeError:
|
||
# Qt object has been deleted, skip update
|
||
pass
|
||
|
||
def cancel_download(self):
|
||
"""Cancel the download using soulseek client"""
|
||
print(f"[DEBUG] Cancel button clicked - download_id: {self.download_id}, username: {self.username}, title: {self.title}")
|
||
if self.soulseek_client and self.download_id:
|
||
print(f"Cancelling download: {self.download_id}")
|
||
|
||
# Find the parent DownloadsPage to use its async helper
|
||
parent_page = self.parent()
|
||
while parent_page and not hasattr(parent_page, '_run_async_operation'):
|
||
parent_page = parent_page.parent()
|
||
|
||
if parent_page:
|
||
# Use the parent's async helper for safe event loop management
|
||
def on_success(result):
|
||
print(f"[DEBUG] Cancel result: {result}")
|
||
if result:
|
||
print(f"Successfully cancelled download: {self.title}")
|
||
self.update_status("cancelled")
|
||
else:
|
||
print(f"Failed to cancel download: {self.title}")
|
||
|
||
def on_error(error):
|
||
print(f"Failed to cancel download: {error}")
|
||
|
||
parent_page._run_async_operation(
|
||
self.soulseek_client.cancel_download,
|
||
self.download_id, self.username,
|
||
success_callback=on_success,
|
||
error_callback=on_error
|
||
)
|
||
else:
|
||
print(f"[ERROR] Could not find parent DownloadsPage for async operation")
|
||
else:
|
||
print(f"[DEBUG] Cancel failed - soulseek_client: {self.soulseek_client}, download_id: {self.download_id}")
|
||
|
||
def retry_download(self):
|
||
"""Retry a failed download"""
|
||
print(f"Retrying download: {self.title}")
|
||
# This would trigger a new download attempt
|
||
# Implementation depends on how retries are handled in the main system
|
||
self.update_status("queued", 0)
|
||
|
||
def open_download_location(self):
|
||
"""Open the download location in file explorer"""
|
||
import os
|
||
import platform
|
||
from pathlib import Path
|
||
|
||
print(f"[DEBUG] Open button clicked - file_path: {self.file_path}, title: {self.title}")
|
||
|
||
if not self.file_path:
|
||
print(f"[DEBUG] No file_path set for download: {self.title}")
|
||
# Fallback to opening the general downloads folder
|
||
try:
|
||
from config.settings import config_manager
|
||
download_path = config_manager.get('soulseek.download_path', './downloads')
|
||
|
||
system = platform.system()
|
||
if system == "Windows":
|
||
os.startfile(download_path)
|
||
elif system == "Darwin": # macOS
|
||
os.system(f'open "{download_path}"')
|
||
else: # Linux
|
||
os.system(f'xdg-open "{download_path}"')
|
||
|
||
print(f"Opened downloads folder: {download_path}")
|
||
except Exception as e:
|
||
print(f"Failed to open downloads folder: {e}")
|
||
return
|
||
|
||
try:
|
||
file_path = Path(self.file_path)
|
||
print(f"[DEBUG] Checking file existence: {file_path}")
|
||
|
||
if file_path.exists():
|
||
folder_path = file_path.parent
|
||
print(f"[DEBUG] Opening folder: {folder_path}")
|
||
|
||
system = platform.system()
|
||
if system == "Windows":
|
||
os.startfile(folder_path)
|
||
elif system == "Darwin": # macOS
|
||
os.system(f"open '{folder_path}'")
|
||
else: # Linux
|
||
os.system(f"xdg-open '{folder_path}'")
|
||
|
||
print(f"Opened folder: {folder_path}")
|
||
else:
|
||
print(f"File not found: {file_path}")
|
||
# Try to find the file in the downloads directory using the filename
|
||
filename = os.path.basename(self.file_path)
|
||
print(f"[DEBUG] Searching for file: {filename}")
|
||
|
||
from config.settings import config_manager
|
||
download_path = config_manager.get('soulseek.download_path', './downloads')
|
||
|
||
# Search for the file in the downloads directory tree
|
||
found_file = None
|
||
for root, dirs, files in os.walk(download_path):
|
||
for file in files:
|
||
if file == filename:
|
||
found_file = os.path.join(root, file)
|
||
print(f"[DEBUG] Found file at: {found_file}")
|
||
break
|
||
if found_file:
|
||
break
|
||
|
||
if found_file:
|
||
folder_path = os.path.dirname(found_file)
|
||
print(f"[DEBUG] Opening found folder: {folder_path}")
|
||
|
||
system = platform.system()
|
||
if system == "Windows":
|
||
os.startfile(folder_path)
|
||
elif system == "Darwin": # macOS
|
||
os.system(f'open "{folder_path}"')
|
||
else: # Linux
|
||
os.system(f'xdg-open "{folder_path}"')
|
||
|
||
print(f"Opened folder: {folder_path}")
|
||
else:
|
||
print(f"Could not find file {filename} in downloads directory")
|
||
# Fallback to opening the downloads folder
|
||
system = platform.system()
|
||
if system == "Windows":
|
||
os.startfile(download_path)
|
||
elif system == "Darwin": # macOS
|
||
os.system(f'open "{download_path}"')
|
||
else: # Linux
|
||
os.system(f'xdg-open "{download_path}"')
|
||
|
||
print(f"Opened downloads folder as fallback: {download_path}")
|
||
|
||
except Exception as e:
|
||
print(f"Failed to open download location: {e}")
|
||
|
||
class DownloadQueue(QFrame):
|
||
def __init__(self, title="Download Queue", queue_type="active", parent=None):
|
||
super().__init__(parent)
|
||
self.queue_title = title
|
||
self.queue_type = queue_type # "active" or "finished"
|
||
|
||
# Widget lifecycle optimization - batch widget deletions
|
||
self.deletion_timer = QTimer()
|
||
self.deletion_timer.setSingleShot(True)
|
||
self.deletion_timer.timeout.connect(self._process_pending_deletions)
|
||
self.deletion_timer.setInterval(100) # 100ms delay for batching
|
||
self.pending_deletions = []
|
||
|
||
self.setup_ui()
|
||
|
||
def setup_ui(self):
|
||
self.setStyleSheet("""
|
||
DownloadQueue {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(45, 45, 45, 0.9),
|
||
stop:1 rgba(35, 35, 35, 0.95));
|
||
border-radius: 10px;
|
||
border: 1px solid rgba(80, 80, 80, 0.5);
|
||
}
|
||
""")
|
||
|
||
layout = QVBoxLayout(self)
|
||
layout.setContentsMargins(12, 8, 12, 12) # Slightly increased top padding
|
||
layout.setSpacing(8) # Increased spacing for better visual breathing room
|
||
|
||
# Header
|
||
header_layout = QHBoxLayout()
|
||
header_layout.setContentsMargins(0, 0, 0, 0)
|
||
|
||
self.title_label = QLabel(self.queue_title)
|
||
self.title_label.setFont(QFont("Segoe UI", 11, QFont.Weight.Bold))
|
||
self.title_label.setStyleSheet("""
|
||
color: rgba(255, 255, 255, 0.95);
|
||
font-weight: 600;
|
||
padding: 0;
|
||
margin: 0;
|
||
""")
|
||
|
||
queue_count = QLabel("Empty")
|
||
queue_count.setFont(QFont("Segoe UI", 9))
|
||
queue_count.setStyleSheet("""
|
||
color: rgba(255, 255, 255, 0.6);
|
||
padding: 0;
|
||
margin: 0;
|
||
""")
|
||
|
||
header_layout.addWidget(self.title_label)
|
||
header_layout.addStretch()
|
||
header_layout.addWidget(queue_count)
|
||
|
||
# Queue list
|
||
queue_scroll = QScrollArea()
|
||
queue_scroll.setWidgetResizable(True)
|
||
queue_scroll.setMinimumHeight(200)
|
||
queue_scroll.setStyleSheet("""
|
||
QScrollArea {
|
||
border: none;
|
||
background: transparent;
|
||
padding: 0px;
|
||
margin: 0px;
|
||
}
|
||
QScrollArea > QWidget > QWidget {
|
||
background: transparent;
|
||
}
|
||
QScrollBar:vertical {
|
||
background: #404040;
|
||
width: 8px;
|
||
border-radius: 4px;
|
||
margin: 0px;
|
||
}
|
||
QScrollBar::handle:vertical {
|
||
background: #1db954;
|
||
border-radius: 4px;
|
||
margin: 0px;
|
||
}
|
||
QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {
|
||
border: none;
|
||
background: none;
|
||
height: 0px;
|
||
}
|
||
""")
|
||
|
||
queue_widget = QWidget()
|
||
queue_layout = QVBoxLayout(queue_widget)
|
||
queue_layout.setContentsMargins(0, 0, 0, 0) # Remove any internal margins
|
||
queue_layout.setSpacing(6) # Increased spacing between download items for better readability
|
||
|
||
# Dynamic download items - initially empty
|
||
self.queue_layout = queue_layout
|
||
self.queue_count_label = queue_count
|
||
self.download_items = []
|
||
|
||
# Add initial message when queue is empty
|
||
self.empty_message = QLabel("No downloads yet.")
|
||
self.empty_message.setFont(QFont("Arial", 10))
|
||
self.empty_message.setStyleSheet("color: rgba(255, 255, 255, 0.5); padding: 15px; text-align: center;")
|
||
self.empty_message.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
queue_layout.addWidget(self.empty_message)
|
||
|
||
queue_layout.addStretch()
|
||
queue_scroll.setWidget(queue_widget)
|
||
|
||
layout.addLayout(header_layout)
|
||
layout.addWidget(queue_scroll)
|
||
|
||
def add_download_item(self, title: str, artist: str, status: str = "queued",
|
||
progress: int = 0, file_size: int = 0, download_speed: int = 0,
|
||
file_path: str = "", download_id: str = "", username: str = "",
|
||
soulseek_client=None, album: str = None, track_number: int = None):
|
||
"""Add a new download item to the queue"""
|
||
# Hide empty message if this is the first item
|
||
if len(self.download_items) == 0:
|
||
self.empty_message.hide()
|
||
|
||
# Create new compact download item with queue type
|
||
item = CompactDownloadItem(title, artist, status, progress, file_size, download_speed,
|
||
file_path, download_id, username, soulseek_client, self.queue_type,
|
||
album, track_number)
|
||
self.download_items.append(item)
|
||
|
||
# Insert before the stretch (which is always last)
|
||
insert_index = self.queue_layout.count() - 1
|
||
self.queue_layout.insertWidget(insert_index, item)
|
||
|
||
# Update count
|
||
self.update_queue_count()
|
||
|
||
return item
|
||
|
||
def update_queue_count(self):
|
||
"""Update the queue count label"""
|
||
count = len(self.download_items)
|
||
if count == 0:
|
||
self.queue_count_label.setText("Empty")
|
||
if not self.empty_message.isHidden():
|
||
self.empty_message.show()
|
||
else:
|
||
self.queue_count_label.setText(f"{count} item{'s' if count != 1 else ''}")
|
||
|
||
def remove_download_item(self, item):
|
||
"""Remove a download item from the queue"""
|
||
print(f"[DEBUG] remove_download_item() called for '{item.title}' with status '{item.status}'")
|
||
print(f"[DEBUG] Queue has {len(self.download_items)} items before removal")
|
||
|
||
if item in self.download_items:
|
||
print(f"[DEBUG] Item found in download_items list, removing...")
|
||
self.download_items.remove(item)
|
||
print(f"[DEBUG] Removed from download_items list. New count: {len(self.download_items)}")
|
||
|
||
print(f"[DEBUG] Removing widget from queue_layout...")
|
||
self.queue_layout.removeWidget(item)
|
||
print(f"[DEBUG] Scheduling widget deletion...")
|
||
self._schedule_widget_deletion(item)
|
||
|
||
print(f"[DEBUG] Updating queue count...")
|
||
self.update_queue_count()
|
||
|
||
# Notify parent download manager to update tab counts
|
||
print(f"[DEBUG] Finding parent to update tab counts...")
|
||
parent_widget = self.parent()
|
||
while parent_widget and not hasattr(parent_widget, 'update_tab_counts'):
|
||
parent_widget = parent_widget.parent()
|
||
if parent_widget and hasattr(parent_widget, 'update_tab_counts'):
|
||
print(f"[DEBUG] Calling parent.update_tab_counts()...")
|
||
parent_widget.update_tab_counts()
|
||
else:
|
||
print(f"[DEBUG] No parent with update_tab_counts found")
|
||
|
||
print(f"[DEBUG] remove_download_item() completed for '{item.title}'")
|
||
else:
|
||
print(f"[DEBUG] Item '{item.title}' NOT found in download_items list!")
|
||
|
||
def _schedule_widget_deletion(self, widget):
|
||
"""Schedule a widget for batched deletion to improve performance"""
|
||
self.pending_deletions.append(widget)
|
||
if not self.deletion_timer.isActive():
|
||
self.deletion_timer.start()
|
||
|
||
def _process_pending_deletions(self):
|
||
"""Process all pending widget deletions in a batch"""
|
||
print(f"[DEBUG] Processing {len(self.pending_deletions)} pending widget deletions")
|
||
for widget in self.pending_deletions:
|
||
try:
|
||
widget.deleteLater()
|
||
except Exception as e:
|
||
print(f"[DEBUG] Error deleting widget: {e}")
|
||
self.pending_deletions.clear()
|
||
|
||
def clear_completed_downloads(self):
|
||
"""Remove all completed and cancelled download items"""
|
||
print(f"[DEBUG] DownloadQueue.clear_completed_downloads() called with {len(self.download_items)} items")
|
||
items_to_remove = []
|
||
|
||
for item in self.download_items:
|
||
print(f"[DEBUG] Checking item '{item.title}' with status '{item.status}'")
|
||
|
||
# Normalize status for comparison (handle compound statuses like "Completed, Succeeded")
|
||
status_lower = item.status.lower()
|
||
should_remove = False
|
||
|
||
# Check for exact matches
|
||
# Check for terminal states with the correct priority to ensure proper cleanup.
|
||
# Cancelled and Failed must be checked BEFORE more general states like Completed.
|
||
if any(keyword in status_lower for keyword in ["cancelled", "canceled", "failed", "errored"]):
|
||
should_remove = True
|
||
print(f"[DEBUG] Matched terminal state (Cancelled/Failed): '{item.status}'")
|
||
elif any(keyword in status_lower for keyword in ["completed", "finished", "succeeded"]):
|
||
should_remove = True
|
||
print(f"[DEBUG] Matched terminal state (Completed): '{item.status}'")
|
||
|
||
if should_remove:
|
||
print(f"[DEBUG] Item '{item.title}' marked for removal (status: '{item.status}')")
|
||
items_to_remove.append(item)
|
||
else:
|
||
print(f"[DEBUG] Item '{item.title}' NOT marked for removal (status: '{item.status}')")
|
||
|
||
print(f"[DEBUG] Removing {len(items_to_remove)} items from queue")
|
||
for item in items_to_remove:
|
||
print(f"[DEBUG] Removing item: '{item.title}'")
|
||
self.remove_download_item(item)
|
||
|
||
print(f"[DEBUG] DownloadQueue.clear_completed_downloads() finished. Remaining items: {len(self.download_items)}")
|
||
|
||
class TabbedDownloadManager(QTabWidget):
|
||
"""Tabbed interface for managing active and finished downloads"""
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__(parent)
|
||
|
||
# UI update batching to prevent excessive updates during transitions
|
||
self.update_timer = QTimer()
|
||
self.update_timer.setSingleShot(True)
|
||
self.update_timer.timeout.connect(self._perform_batched_update)
|
||
self.update_timer.setInterval(50) # 50ms batch window
|
||
self.pending_updates = set()
|
||
|
||
self.setup_ui()
|
||
|
||
def setup_ui(self):
|
||
"""Setup the tabbed interface with active and finished download queues"""
|
||
self.setStyleSheet("""
|
||
QTabWidget::pane {
|
||
border: 1px solid #404040;
|
||
border-radius: 8px;
|
||
background: #282828;
|
||
padding: 0px;
|
||
margin: 0px;
|
||
}
|
||
QTabWidget::tab-bar {
|
||
alignment: center;
|
||
}
|
||
QTabBar::tab {
|
||
background: #404040;
|
||
color: #ffffff;
|
||
border: 1px solid #606060;
|
||
border-bottom: none;
|
||
border-top-left-radius: 8px;
|
||
border-top-right-radius: 8px;
|
||
padding: 6px 12px;
|
||
margin-right: 1px;
|
||
font-size: 10px;
|
||
font-weight: bold;
|
||
min-width: 80px;
|
||
}
|
||
QTabBar::tab:selected {
|
||
background: #1db954;
|
||
color: #000000;
|
||
border: 1px solid #1db954;
|
||
}
|
||
QTabBar::tab:hover:!selected {
|
||
background: #505050;
|
||
}
|
||
""")
|
||
|
||
# Create two download queues with appropriate titles and queue types
|
||
self.active_queue = DownloadQueue("Active Downloads", "active")
|
||
self.finished_queue = DownloadQueue("Finished Downloads", "finished")
|
||
|
||
# Update the finished queue count label
|
||
self.finished_queue.queue_count_label.setText("Empty")
|
||
|
||
# Add tabs
|
||
self.addTab(self.active_queue, "Download Queue")
|
||
self.addTab(self.finished_queue, "Finished Downloads")
|
||
|
||
# Set initial tab counts
|
||
self.update_tab_counts()
|
||
|
||
def add_download_item(self, title: str, artist: str, status: str = "queued",
|
||
progress: int = 0, file_size: int = 0, download_speed: int = 0,
|
||
file_path: str = "", download_id: str = "", username: str = "",
|
||
soulseek_client=None, album: str = None, track_number: int = None):
|
||
"""Add a new download item to the active queue"""
|
||
item = self.active_queue.add_download_item(
|
||
title, artist, status, progress, file_size, download_speed,
|
||
file_path, download_id, username, soulseek_client, album, track_number
|
||
)
|
||
self.update_tab_counts()
|
||
return item
|
||
|
||
def move_to_finished(self, download_item):
|
||
"""Move a download item from active to finished queue"""
|
||
|
||
# Performance monitoring
|
||
import time
|
||
start_time = time.time()
|
||
|
||
if download_item in self.active_queue.download_items:
|
||
# Remove from active queue
|
||
self.active_queue.remove_download_item(download_item)
|
||
|
||
# Ensure completed downloads have 100% progress
|
||
final_progress = download_item.progress
|
||
if download_item.status == 'completed':
|
||
final_progress = 100
|
||
print(f"[DEBUG] Ensuring completed download '{download_item.title}' has 100% progress")
|
||
|
||
# Add to finished queue
|
||
finished_item = self.finished_queue.add_download_item(
|
||
title=download_item.title,
|
||
artist=download_item.artist,
|
||
status=download_item.status,
|
||
progress=final_progress,
|
||
file_size=download_item.file_size,
|
||
download_speed=download_item.download_speed,
|
||
file_path=download_item.file_path,
|
||
download_id=download_item.download_id,
|
||
username=download_item.username,
|
||
soulseek_client=download_item.soulseek_client
|
||
)
|
||
|
||
# Signal API that download is complete (only for completed downloads)
|
||
# Note: Cancelled downloads already have their API signal sent by cancel_download()
|
||
try:
|
||
if (download_item.status == 'completed' and
|
||
download_item.download_id and download_item.username and download_item.soulseek_client):
|
||
|
||
# PERFORMANCE FIX: Use dedicated thread for API cleanup to prevent UI blocking
|
||
# Find the parent DownloadsPage that manages the API cleanup threads
|
||
parent_page = self.parent()
|
||
while parent_page and not hasattr(parent_page, 'api_cleanup_threads'):
|
||
parent_page = parent_page.parent()
|
||
|
||
if parent_page and hasattr(parent_page, 'api_cleanup_threads'):
|
||
# Create and start API cleanup thread
|
||
cleanup_thread = ApiCleanupThread(
|
||
download_item.soulseek_client,
|
||
download_item.download_id,
|
||
download_item.username
|
||
)
|
||
cleanup_thread.cleanup_completed.connect(parent_page.api_cleanup_finished)
|
||
cleanup_thread.finished.connect(lambda: self._cleanup_api_thread(cleanup_thread))
|
||
|
||
# Track the thread
|
||
parent_page.api_cleanup_threads.append(cleanup_thread)
|
||
|
||
# Start the thread
|
||
cleanup_thread.start()
|
||
|
||
print(f"Started API cleanup thread for download {download_item.download_id}")
|
||
else:
|
||
print(f"Cannot find parent DownloadsPage for API cleanup thread")
|
||
# Fallback: Skip API cleanup to prevent blocking
|
||
print(f"Skipping API cleanup for download {download_item.download_id}")
|
||
|
||
except Exception as e:
|
||
print(f"Error setting up download completion cleanup: {e}")
|
||
|
||
self.update_tab_counts()
|
||
|
||
# Emit signal for session download tracking
|
||
parent_page = self.parent()
|
||
while parent_page and not hasattr(parent_page, 'download_session_completed'):
|
||
parent_page = parent_page.parent()
|
||
if parent_page and hasattr(parent_page, 'download_session_completed'):
|
||
parent_page.download_session_completed.emit(download_item.title, download_item.artist)
|
||
|
||
# Performance monitoring
|
||
end_time = time.time()
|
||
duration_ms = (end_time - start_time) * 1000
|
||
print(f"⏱️ move_to_finished completed in {duration_ms:.2f}ms for '{download_item.title}'")
|
||
|
||
return finished_item
|
||
|
||
# Performance monitoring for early return
|
||
end_time = time.time()
|
||
duration_ms = (end_time - start_time) * 1000
|
||
print(f"⏱️ move_to_finished early return in {duration_ms:.2f}ms (item not in active queue)")
|
||
return None
|
||
|
||
def _cleanup_api_thread(self, thread):
|
||
"""Clean up API cleanup thread when it finishes"""
|
||
try:
|
||
# Find the parent DownloadsPage that manages the API cleanup threads
|
||
parent_page = self.parent()
|
||
while parent_page and not hasattr(parent_page, 'api_cleanup_threads'):
|
||
parent_page = parent_page.parent()
|
||
|
||
if parent_page and hasattr(parent_page, 'api_cleanup_threads'):
|
||
if thread in parent_page.api_cleanup_threads:
|
||
parent_page.api_cleanup_threads.remove(thread)
|
||
|
||
# Clean up the thread
|
||
if thread.isRunning():
|
||
thread.wait(1000) # Wait up to 1 second for completion
|
||
thread.deleteLater()
|
||
|
||
print(f"Cleaned up API cleanup thread")
|
||
except Exception as e:
|
||
print(f"Error cleaning up API cleanup thread: {e}")
|
||
|
||
def update_tab_counts(self):
|
||
"""Schedule a batched tab count update to prevent excessive UI updates"""
|
||
self.pending_updates.add('tab_counts')
|
||
if not self.update_timer.isActive():
|
||
self.update_timer.start()
|
||
|
||
def _perform_batched_update(self):
|
||
"""Perform all pending UI updates in a single batch"""
|
||
if 'tab_counts' in self.pending_updates:
|
||
self._update_tab_counts_immediate()
|
||
|
||
# Clear pending updates
|
||
self.pending_updates.clear()
|
||
|
||
def _update_tab_counts_immediate(self):
|
||
"""Immediately update tab labels with current counts (internal use only)"""
|
||
active_count = len(self.active_queue.download_items)
|
||
finished_count = len(self.finished_queue.download_items)
|
||
|
||
self.setTabText(0, f"Download Queue ({active_count})")
|
||
self.setTabText(1, f"Finished Downloads ({finished_count})")
|
||
|
||
# Also update the download manager stats if they exist
|
||
# Find the DownloadsPage in the parent hierarchy
|
||
parent_widget = self.parent()
|
||
while parent_widget and not hasattr(parent_widget, 'update_download_manager_stats'):
|
||
parent_widget = parent_widget.parent()
|
||
|
||
if parent_widget and hasattr(parent_widget, 'update_download_manager_stats'):
|
||
parent_widget.update_download_manager_stats(active_count, finished_count)
|
||
else:
|
||
print(f"[DEBUG] Could not find parent with update_download_manager_stats method")
|
||
|
||
def clear_completed_downloads(self):
|
||
"""Clear completed and cancelled downloads from both slskd backend and local queues"""
|
||
# Delegate to parent (DownloadsPage) which has access to soulseek_client
|
||
if hasattr(self.parent(), 'clear_completed_downloads'):
|
||
self.parent().clear_completed_downloads()
|
||
else:
|
||
# Fallback to local clearing if parent method not available
|
||
print("[DEBUG] No parent clear method found, clearing locally only")
|
||
# Clear from both active and finished queues
|
||
self.active_queue.clear_completed_downloads()
|
||
self.finished_queue.clear_completed_downloads()
|
||
self.update_tab_counts()
|
||
|
||
def clear_local_queues_only(self):
|
||
"""Clear only the local UI queues without backend operations (for use by parent)"""
|
||
print("[DEBUG] TabbedDownloadManager.clear_local_queues_only() called")
|
||
print(f"[DEBUG] Active queue has {len(self.active_queue.download_items)} items")
|
||
print(f"[DEBUG] Finished queue has {len(self.finished_queue.download_items)} items")
|
||
|
||
# Clear from both active and finished queues
|
||
print("[DEBUG] Clearing active queue...")
|
||
self.active_queue.clear_completed_downloads()
|
||
print("[DEBUG] Clearing finished queue...")
|
||
self.finished_queue.clear_completed_downloads()
|
||
print("[DEBUG] Updating tab counts...")
|
||
self.update_tab_counts()
|
||
|
||
print(f"[DEBUG] After clearing - Active: {len(self.active_queue.download_items)}, Finished: {len(self.finished_queue.download_items)}")
|
||
|
||
@property
|
||
def download_items(self):
|
||
"""Return all download items from active queue for compatibility"""
|
||
return self.active_queue.download_items
|
||
|
||
class DownloadsPage(QWidget):
|
||
# Signals for media player communication
|
||
track_started = pyqtSignal(object) # Track result object
|
||
track_paused = pyqtSignal()
|
||
track_resumed = pyqtSignal()
|
||
track_stopped = pyqtSignal()
|
||
track_finished = pyqtSignal()
|
||
track_position_updated = pyqtSignal(float, float) # current_position, duration in seconds
|
||
track_loading_started = pyqtSignal(object) # Track result object when streaming starts
|
||
track_loading_finished = pyqtSignal(object) # Track result object when streaming completes
|
||
track_loading_progress = pyqtSignal(float, object) # Progress percentage (0-100), track result object
|
||
|
||
# Signal for dashboard stats tracking
|
||
download_session_completed = pyqtSignal(str, str) # Emitted when a download completes (title, artist)
|
||
|
||
# Signals for dashboard activity tracking
|
||
download_activity = pyqtSignal(str, str, str, str) # icon, title, subtitle, time
|
||
|
||
# Signal for clear completed downloads completion (thread-safe communication)
|
||
clear_completed_finished = pyqtSignal(bool, object) # backend_success, ui_callback
|
||
|
||
# Signal for API cleanup completion (thread-safe communication)
|
||
api_cleanup_finished = pyqtSignal(bool, str, str) # success, download_id, username
|
||
|
||
def __init__(self, soulseek_client=None, parent=None):
|
||
super().__init__(parent)
|
||
self.soulseek_client = soulseek_client
|
||
|
||
# --- FIX: Ensure the soulseek_client uses the download path from config ---
|
||
if self.soulseek_client:
|
||
from config.settings import config_manager
|
||
download_path = config_manager.get('soulseek.download_path')
|
||
if download_path and hasattr(self.soulseek_client, 'download_path'):
|
||
self.soulseek_client.download_path = download_path
|
||
print(f"Set soulseek_client download path to: {download_path}")
|
||
# --- END FIX ---
|
||
|
||
self.search_thread = None
|
||
self.explore_thread = None
|
||
self.session_thread = None
|
||
self.download_threads = []
|
||
self.status_update_threads = []
|
||
self.api_cleanup_threads = []
|
||
self.search_results = []
|
||
self.current_filtered_results = []
|
||
self.download_items = []
|
||
self.displayed_results = 0
|
||
self.results_per_page = 15
|
||
self.is_loading_more = False
|
||
self._results_to_load_queue = []
|
||
self.status_processing_pool = QThreadPool()
|
||
self.status_processing_pool.setMaxThreadCount(1)
|
||
self._is_status_update_running = False
|
||
|
||
self.spotify_client = SpotifyClient()
|
||
self.matching_engine = MusicMatchingEngine()
|
||
|
||
import threading
|
||
from concurrent.futures import ThreadPoolExecutor
|
||
self.album_cache_lock = threading.Lock()
|
||
self.album_groups = {}
|
||
self.album_artists = {}
|
||
self.album_editions = {}
|
||
self.album_name_cache = {}
|
||
|
||
self.api_thread_pool = ThreadPoolExecutor(max_workers=3, thread_name_prefix="SpotifyAPI")
|
||
self.active_suggestion_threads = set()
|
||
|
||
self.completion_thread_pool = QThreadPool()
|
||
self.completion_thread_pool.setMaxThreadCount(2)
|
||
|
||
self._optimized_api_pool = ThreadPoolExecutor(max_workers=8, thread_name_prefix="OptimizedAPI")
|
||
self._optimized_completion_pool = QThreadPool()
|
||
self._optimized_completion_pool.setMaxThreadCount(4)
|
||
self._cleanup_pools = []
|
||
|
||
self._queue_manager = ThreadSafeQueueManager()
|
||
self._queue_consistency_lock = RLock()
|
||
|
||
self.audio_player = AudioPlayer(self)
|
||
self.audio_player.playback_finished.connect(self.on_audio_playback_finished)
|
||
self.audio_player.playback_error.connect(self.on_audio_playback_error)
|
||
self.currently_playing_button = None
|
||
self.currently_expanded_item = None
|
||
|
||
self.download_status_timer = QTimer()
|
||
self.download_status_timer.timeout.connect(self.update_download_status)
|
||
self.download_status_timer.start(1000)
|
||
|
||
self._use_optimized_systems = False
|
||
|
||
self._polling_intervals = {
|
||
'active': 1500,
|
||
'idle': 3000,
|
||
'bulk_pause': 5000
|
||
}
|
||
self._current_polling_mode = 'active'
|
||
self._bulk_operation_active = False
|
||
self._last_active_count = 0
|
||
|
||
self.downloads_to_cleanup = set()
|
||
self.individual_downloads_to_cleanup = []
|
||
|
||
self.clear_completed_finished.connect(self._handle_clear_completion)
|
||
|
||
self.api_cleanup_finished.connect(self._handle_api_cleanup_completion)
|
||
|
||
self.setup_ui()
|
||
|
||
def set_toast_manager(self, toast_manager):
|
||
"""Set the toast manager for showing notifications"""
|
||
self.toast_manager = toast_manager
|
||
|
||
|
||
|
||
def setup_ui(self):
|
||
self.setStyleSheet("""
|
||
DownloadsPage {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(25, 20, 20, 1.0),
|
||
stop:1 rgba(15, 15, 15, 1.0));
|
||
}
|
||
""")
|
||
|
||
main_layout = QVBoxLayout(self)
|
||
# Responsive margins that adapt to window size
|
||
main_layout.setContentsMargins(20, 16, 20, 20) # Increased for better breathing room
|
||
main_layout.setSpacing(16) # Increased spacing for better visual hierarchy
|
||
|
||
# Elegant Header
|
||
header = self.create_elegant_header()
|
||
main_layout.addWidget(header)
|
||
|
||
# Main Content Area with responsive splitter
|
||
content_splitter = QSplitter(Qt.Orientation.Horizontal)
|
||
content_splitter.setChildrenCollapsible(False) # Prevent panels from collapsing completely
|
||
|
||
# LEFT: Search & Results section
|
||
search_and_results = self.create_search_and_results_section()
|
||
search_and_results.setMinimumWidth(400) # Minimum width for usability
|
||
content_splitter.addWidget(search_and_results)
|
||
|
||
# RIGHT: Controls Panel
|
||
controls_panel = self.create_collapsible_controls_panel()
|
||
controls_panel.setMinimumWidth(280) # Minimum width for controls
|
||
controls_panel.setMaximumWidth(400) # Maximum width to prevent overgrowth
|
||
content_splitter.addWidget(controls_panel)
|
||
|
||
# Set initial splitter proportions (roughly 70/30)
|
||
content_splitter.setSizes([700, 300])
|
||
content_splitter.setStretchFactor(0, 1) # Search results gets priority for extra space
|
||
content_splitter.setStretchFactor(1, 0) # Controls panel stays fixed width when possible
|
||
|
||
main_layout.addWidget(content_splitter)
|
||
|
||
def create_elegant_header(self):
|
||
"""Create an elegant, minimal header"""
|
||
header = QFrame()
|
||
header.setMinimumHeight(80) # Minimum height, can grow if needed
|
||
header.setMaximumHeight(120) # Maximum to prevent overgrowth
|
||
header.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
|
||
header.setStyleSheet("""
|
||
QFrame {
|
||
background: transparent;
|
||
border: none;
|
||
}
|
||
""")
|
||
|
||
layout = QHBoxLayout(header)
|
||
layout.setContentsMargins(20, 16, 20, 16) # Increased padding for better header prominence
|
||
layout.setSpacing(16) # Increased spacing for better hierarchy
|
||
|
||
# Icon and Title
|
||
title_section = QVBoxLayout()
|
||
title_section.setSpacing(6) # Increased for better title hierarchy
|
||
|
||
title_label = QLabel("Music Downloads")
|
||
title_label.setFont(QFont("Segoe UI", 28, QFont.Weight.Bold)) # Larger for better prominence
|
||
title_label.setStyleSheet("""
|
||
color: #ffffff;
|
||
font-weight: 700;
|
||
letter-spacing: 1px;
|
||
""")
|
||
|
||
subtitle_label = QLabel("Search, discover, and download high-quality music")
|
||
subtitle_label.setFont(QFont("Segoe UI", 13))
|
||
subtitle_label.setStyleSheet("""
|
||
color: rgba(255, 255, 255, 0.85);
|
||
font-weight: 300;
|
||
letter-spacing: 0.5px;
|
||
margin-top: 4px;
|
||
""")
|
||
|
||
title_section.addWidget(title_label)
|
||
title_section.addWidget(subtitle_label)
|
||
|
||
layout.addLayout(title_section)
|
||
layout.addStretch()
|
||
|
||
return header
|
||
|
||
def create_search_and_results_section(self):
|
||
"""Create the main search and results area - the star of the show"""
|
||
section = QFrame()
|
||
section.setStyleSheet("""
|
||
QFrame {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(40, 40, 40, 0.4),
|
||
stop:1 rgba(30, 30, 30, 0.6));
|
||
border-radius: 16px;
|
||
border: 1px solid rgba(64, 64, 64, 0.3);
|
||
}
|
||
""")
|
||
|
||
layout = QVBoxLayout(section)
|
||
layout.setContentsMargins(16, 12, 16, 12) # Responsive spacing consistent with main layout
|
||
layout.setSpacing(12) # Consistent 12px spacing
|
||
|
||
# Elegant Search Bar
|
||
search_container = self.create_elegant_search_bar()
|
||
layout.addWidget(search_container)
|
||
|
||
# Filter Controls (initially hidden until we have results)
|
||
self.filter_container = self.create_filter_controls()
|
||
self.filter_container.setVisible(False) # Hide until we have search results
|
||
layout.addWidget(self.filter_container)
|
||
|
||
# Search Status with better visual feedback and loading animations
|
||
status_container = QWidget()
|
||
status_layout = QHBoxLayout(status_container)
|
||
status_layout.setContentsMargins(10, 8, 10, 8)
|
||
status_layout.setSpacing(12)
|
||
|
||
# Search status label
|
||
self.search_status = QLabel("Ready to search • Enter artist, song, or album name")
|
||
self.search_status.setFont(QFont("Arial", 11))
|
||
self.search_status.setStyleSheet("""
|
||
color: rgba(255, 255, 255, 0.7);
|
||
padding: 2px 8px;
|
||
""")
|
||
|
||
# Loading animations (initially hidden)
|
||
self.bouncing_dots = BouncingDotsWidget()
|
||
self.bouncing_dots.setVisible(False)
|
||
|
||
self.spinning_circle = SpinningCircleWidget()
|
||
self.spinning_circle.setVisible(False)
|
||
|
||
# Add to status layout
|
||
status_layout.addWidget(self.spinning_circle)
|
||
status_layout.addWidget(self.search_status)
|
||
status_layout.addWidget(self.bouncing_dots)
|
||
status_layout.addStretch()
|
||
|
||
# Style the container
|
||
status_container.setStyleSheet("""
|
||
QWidget {
|
||
background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
|
||
stop:0 rgba(29, 185, 84, 0.12),
|
||
stop:1 rgba(29, 185, 84, 0.08));
|
||
border-radius: 10px;
|
||
border: 1px solid rgba(29, 185, 84, 0.25);
|
||
}
|
||
""")
|
||
|
||
layout.addWidget(status_container)
|
||
|
||
# Search Results - The main attraction
|
||
results_container = QFrame()
|
||
results_container.setStyleSheet("""
|
||
QFrame {
|
||
background: rgba(20, 20, 20, 0.3);
|
||
border-radius: 12px;
|
||
border: 1px solid rgba(64, 64, 64, 0.2);
|
||
}
|
||
""")
|
||
|
||
results_layout = QVBoxLayout(results_container)
|
||
results_layout.setContentsMargins(16, 12, 16, 16) # Improved responsive spacing for better breathing room
|
||
results_layout.setSpacing(12) # Increased spacing for better visual hierarchy
|
||
|
||
# Results header
|
||
results_header = QLabel("Search Results")
|
||
results_header.setFont(QFont("Segoe UI", 14, QFont.Weight.Bold))
|
||
results_header.setStyleSheet("""
|
||
color: rgba(255, 255, 255, 0.95);
|
||
font-weight: 600;
|
||
padding: 4px 8px;
|
||
""")
|
||
results_layout.addWidget(results_header)
|
||
|
||
# Scrollable results area - this gets ALL remaining space
|
||
self.search_results_scroll = QScrollArea()
|
||
self.search_results_scroll.setWidgetResizable(True)
|
||
self.search_results_scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
|
||
self.search_results_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
|
||
self.search_results_scroll.setStyleSheet("""
|
||
QScrollArea {
|
||
border: none;
|
||
background: transparent;
|
||
border-radius: 8px;
|
||
}
|
||
QScrollBar:vertical {
|
||
background: rgba(64, 64, 64, 0.3);
|
||
width: 8px;
|
||
border-radius: 4px;
|
||
margin: 0;
|
||
}
|
||
QScrollBar::handle:vertical {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(29, 185, 84, 0.8),
|
||
stop:1 rgba(29, 185, 84, 0.6));
|
||
border-radius: 4px;
|
||
min-height: 20px;
|
||
}
|
||
QScrollBar::handle:vertical:hover {
|
||
background: rgba(29, 185, 84, 1.0);
|
||
}
|
||
""")
|
||
|
||
self.search_results_widget = QWidget()
|
||
self.search_results_layout = QVBoxLayout(self.search_results_widget)
|
||
self.search_results_layout.setSpacing(8) # Reduced spacing for more compact search results
|
||
self.search_results_layout.setContentsMargins(12, 12, 12, 12) # Increased for better edge spacing
|
||
|
||
# Add centered loading animation for search results area
|
||
self.results_loading_container = QWidget()
|
||
results_loading_layout = QVBoxLayout(self.results_loading_container)
|
||
results_loading_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
|
||
self.results_spinning_circle = SpinningCircleWidget()
|
||
self.results_loading_label = QLabel("Searching for results...")
|
||
self.results_loading_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.results_loading_label.setStyleSheet("""
|
||
color: rgba(255, 255, 255, 0.7);
|
||
font-size: 14px;
|
||
margin-top: 10px;
|
||
""")
|
||
|
||
results_loading_layout.addWidget(self.results_spinning_circle, 0, Qt.AlignmentFlag.AlignCenter)
|
||
results_loading_layout.addWidget(self.results_loading_label, 0, Qt.AlignmentFlag.AlignCenter)
|
||
self.results_loading_container.setVisible(False) # Initially hidden
|
||
|
||
# Add to main results layout
|
||
self.search_results_layout.addWidget(self.results_loading_container)
|
||
self.search_results_layout.addStretch()
|
||
self.search_results_scroll.setWidget(self.search_results_widget)
|
||
|
||
# Connect scroll detection for automatic loading
|
||
scroll_bar = self.search_results_scroll.verticalScrollBar()
|
||
scroll_bar.valueChanged.connect(self.on_scroll_changed)
|
||
|
||
results_layout.addWidget(self.search_results_scroll)
|
||
layout.addWidget(results_container, 1) # This takes all remaining space
|
||
|
||
return section
|
||
|
||
def create_elegant_search_bar(self):
|
||
"""Create a beautiful, modern search bar"""
|
||
container = QFrame()
|
||
container.setFixedHeight(70)
|
||
container.setStyleSheet("""
|
||
QFrame {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(50, 50, 50, 0.8),
|
||
stop:1 rgba(40, 40, 40, 0.9));
|
||
border-radius: 12px;
|
||
border: 1px solid rgba(29, 185, 84, 0.3);
|
||
}
|
||
""")
|
||
|
||
layout = QHBoxLayout(container)
|
||
layout.setContentsMargins(20, 16, 20, 16) # Increased responsive spacing for better visual balance
|
||
layout.setSpacing(16) # Increased spacing for better visual hierarchy
|
||
|
||
# Search input with enhanced styling
|
||
self.search_input = QLineEdit()
|
||
self.search_input.setPlaceholderText("Search for music... (e.g., 'Virtual Mage', 'Queen Bohemian Rhapsody')")
|
||
self.search_input.setFixedHeight(40)
|
||
self.search_input.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed) # Responsive width
|
||
self.search_input.returnPressed.connect(self.perform_search)
|
||
self.search_input.setStyleSheet("""
|
||
QLineEdit {
|
||
background: rgba(60, 60, 60, 0.7);
|
||
border: 2px solid rgba(100, 100, 100, 0.3);
|
||
border-radius: 20px;
|
||
padding: 0 20px;
|
||
color: #ffffff;
|
||
font-size: 14px;
|
||
font-weight: 500;
|
||
}
|
||
QLineEdit:focus {
|
||
border: 2px solid rgba(29, 185, 84, 0.8);
|
||
background: rgba(70, 70, 70, 0.9);
|
||
}
|
||
QLineEdit::placeholder {
|
||
color: rgba(255, 255, 255, 0.5);
|
||
}
|
||
""")
|
||
|
||
# Enhanced search button
|
||
self.search_btn = QPushButton("Search")
|
||
self.search_btn.setFixedSize(120, 40)
|
||
self.search_btn.clicked.connect(self.perform_search)
|
||
self.search_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(29, 185, 84, 1.0),
|
||
stop:1 rgba(24, 156, 71, 1.0));
|
||
border: none;
|
||
border-radius: 20px;
|
||
color: #000000;
|
||
font-size: 13px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(30, 215, 96, 1.0),
|
||
stop:1 rgba(25, 180, 80, 1.0));
|
||
}
|
||
QPushButton:pressed {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(24, 156, 71, 1.0),
|
||
stop:1 rgba(20, 130, 60, 1.0));
|
||
}
|
||
QPushButton:disabled {
|
||
background: rgba(100, 100, 100, 0.3);
|
||
color: rgba(255, 255, 255, 0.3);
|
||
}
|
||
""")
|
||
|
||
# Cancel search button (initially hidden)
|
||
self.cancel_search_btn = QPushButton("Cancel")
|
||
self.cancel_search_btn.setFixedSize(100, 40)
|
||
self.cancel_search_btn.clicked.connect(self.cancel_search)
|
||
self.cancel_search_btn.setVisible(False) # Hidden by default
|
||
self.cancel_search_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(220, 53, 69, 0.9),
|
||
stop:1 rgba(200, 43, 58, 0.9));
|
||
border: none;
|
||
border-radius: 20px;
|
||
color: #ffffff;
|
||
font-size: 13px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(240, 73, 89, 1.0),
|
||
stop:1 rgba(220, 63, 79, 1.0));
|
||
}
|
||
QPushButton:pressed {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(200, 43, 58, 1.0),
|
||
stop:1 rgba(180, 33, 48, 1.0));
|
||
}
|
||
""")
|
||
|
||
layout.addWidget(self.search_input)
|
||
layout.addWidget(self.cancel_search_btn)
|
||
layout.addWidget(self.search_btn)
|
||
|
||
return container
|
||
|
||
def create_filter_controls(self):
|
||
"""Create elegant collapsible filter controls for Albums vs Singles, File Formats, and Sorting"""
|
||
container = QFrame()
|
||
container.setStyleSheet("""
|
||
QFrame {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(45, 45, 45, 0.6),
|
||
stop:1 rgba(35, 35, 35, 0.8));
|
||
border-radius: 10px;
|
||
border: 1px solid rgba(80, 80, 80, 0.25);
|
||
}
|
||
""")
|
||
|
||
main_layout = QVBoxLayout(container)
|
||
main_layout.setContentsMargins(16, 8, 16, 8)
|
||
main_layout.setSpacing(6)
|
||
|
||
# Initialize collapse state
|
||
self.filters_collapsed = True
|
||
|
||
# Toggle button row
|
||
toggle_row = QHBoxLayout()
|
||
toggle_row.setSpacing(8)
|
||
|
||
self.filter_toggle_btn = QPushButton("⏷ Filters")
|
||
self.filter_toggle_btn.setFixedHeight(32)
|
||
self.filter_toggle_btn.setMinimumWidth(100)
|
||
self.filter_toggle_btn.clicked.connect(self.toggle_filter_panel)
|
||
self.filter_toggle_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(80, 80, 80, 0.9),
|
||
stop:1 rgba(70, 70, 70, 0.95));
|
||
border: 1px solid rgba(100, 100, 100, 0.3);
|
||
border-radius: 6px;
|
||
color: rgba(255, 255, 255, 0.8);
|
||
font-size: 11px;
|
||
font-weight: 600;
|
||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
|
||
letter-spacing: 0.3px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(90, 90, 90, 0.9),
|
||
stop:1 rgba(80, 80, 80, 0.95));
|
||
color: rgba(255, 255, 255, 0.9);
|
||
}
|
||
QPushButton:pressed {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(60, 60, 60, 0.9),
|
||
stop:1 rgba(50, 50, 50, 0.95));
|
||
}
|
||
""")
|
||
|
||
toggle_row.addWidget(self.filter_toggle_btn)
|
||
toggle_row.addStretch()
|
||
main_layout.addLayout(toggle_row)
|
||
|
||
# Collapsible content container
|
||
self.filter_content = QWidget()
|
||
self.filter_content_layout = QVBoxLayout(self.filter_content)
|
||
self.filter_content_layout.setContentsMargins(0, 0, 0, 0)
|
||
self.filter_content_layout.setSpacing(6)
|
||
|
||
# First row: Type filters (Albums vs Singles)
|
||
type_row = QHBoxLayout()
|
||
type_row.setSpacing(8)
|
||
|
||
type_label = QLabel("Type:")
|
||
type_label.setStyleSheet("""
|
||
QLabel {
|
||
color: rgba(255, 255, 255, 0.8);
|
||
font-size: 11px;
|
||
font-weight: 600;
|
||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
|
||
letter-spacing: 0.3px;
|
||
}
|
||
""")
|
||
|
||
# Initialize filter and sort state
|
||
self.current_filter = "all" # "all", "albums", "singles"
|
||
self.current_format_filter = "all" # "all", "flac", "mp3", "ogg", "aac", "wma"
|
||
self.current_sort = "relevance" # "relevance", "quality", "size", "name", "uploader", "bitrate", "duration", "availability", "speed"
|
||
self.reverse_order = False # False = normal order, True = reverse order
|
||
self.current_search_query = "" # Store search query for relevance calculation
|
||
|
||
# Type filter buttons
|
||
self.filter_all_btn = QPushButton("All")
|
||
self.filter_albums_btn = QPushButton("Albums")
|
||
self.filter_singles_btn = QPushButton("Singles")
|
||
|
||
# Store type buttons for easy access
|
||
self.filter_buttons = {
|
||
"all": self.filter_all_btn,
|
||
"albums": self.filter_albums_btn,
|
||
"singles": self.filter_singles_btn
|
||
}
|
||
|
||
# Connect type button signals
|
||
self.filter_all_btn.clicked.connect(lambda: self.set_filter("all"))
|
||
self.filter_albums_btn.clicked.connect(lambda: self.set_filter("albums"))
|
||
self.filter_singles_btn.clicked.connect(lambda: self.set_filter("singles"))
|
||
|
||
# Apply styling to type buttons
|
||
for btn_key, btn in self.filter_buttons.items():
|
||
btn.setFixedHeight(28)
|
||
btn.setMinimumWidth(60)
|
||
self.update_filter_button_style(btn, btn_key == "all")
|
||
|
||
type_row.addWidget(type_label)
|
||
type_row.addWidget(self.filter_all_btn)
|
||
type_row.addWidget(self.filter_albums_btn)
|
||
type_row.addWidget(self.filter_singles_btn)
|
||
type_row.addStretch()
|
||
|
||
# Second row: Format filters
|
||
format_row = QHBoxLayout()
|
||
format_row.setSpacing(8)
|
||
|
||
format_label = QLabel("Format:")
|
||
format_label.setStyleSheet("""
|
||
QLabel {
|
||
color: rgba(255, 255, 255, 0.8);
|
||
font-size: 11px;
|
||
font-weight: 600;
|
||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
|
||
letter-spacing: 0.3px;
|
||
}
|
||
""")
|
||
|
||
# Format filter buttons
|
||
self.format_all_btn = QPushButton("All")
|
||
self.format_flac_btn = QPushButton("FLAC")
|
||
self.format_mp3_btn = QPushButton("MP3")
|
||
self.format_ogg_btn = QPushButton("OGG")
|
||
self.format_aac_btn = QPushButton("AAC")
|
||
self.format_wma_btn = QPushButton("WMA")
|
||
|
||
# Store format buttons for easy access
|
||
self.format_buttons = {
|
||
"all": self.format_all_btn,
|
||
"flac": self.format_flac_btn,
|
||
"mp3": self.format_mp3_btn,
|
||
"ogg": self.format_ogg_btn,
|
||
"aac": self.format_aac_btn,
|
||
"wma": self.format_wma_btn
|
||
}
|
||
|
||
# Connect format button signals
|
||
self.format_all_btn.clicked.connect(lambda: self.set_format_filter("all"))
|
||
self.format_flac_btn.clicked.connect(lambda: self.set_format_filter("flac"))
|
||
self.format_mp3_btn.clicked.connect(lambda: self.set_format_filter("mp3"))
|
||
self.format_ogg_btn.clicked.connect(lambda: self.set_format_filter("ogg"))
|
||
self.format_aac_btn.clicked.connect(lambda: self.set_format_filter("aac"))
|
||
self.format_wma_btn.clicked.connect(lambda: self.set_format_filter("wma"))
|
||
|
||
# Apply styling to format buttons
|
||
for btn_key, btn in self.format_buttons.items():
|
||
btn.setFixedHeight(28)
|
||
btn.setMinimumWidth(50)
|
||
self.update_filter_button_style(btn, btn_key == "all")
|
||
|
||
format_row.addWidget(format_label)
|
||
format_row.addWidget(self.format_all_btn)
|
||
format_row.addWidget(self.format_flac_btn)
|
||
format_row.addWidget(self.format_mp3_btn)
|
||
format_row.addWidget(self.format_ogg_btn)
|
||
format_row.addWidget(self.format_aac_btn)
|
||
format_row.addWidget(self.format_wma_btn)
|
||
format_row.addStretch()
|
||
|
||
# Third row: Sorting controls
|
||
sort_row = QHBoxLayout()
|
||
sort_row.setSpacing(8)
|
||
|
||
sort_label = QLabel("Sort by:")
|
||
sort_label.setStyleSheet("""
|
||
QLabel {
|
||
color: rgba(255, 255, 255, 0.8);
|
||
font-size: 11px;
|
||
font-weight: 600;
|
||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
|
||
letter-spacing: 0.3px;
|
||
}
|
||
""")
|
||
|
||
# Reverse order toggle button - simple arrows
|
||
self.reverse_order_btn = QPushButton("↓")
|
||
self.reverse_order_btn.setFixedSize(28, 28) # Square button
|
||
self.reverse_order_btn.clicked.connect(self.toggle_reverse_order)
|
||
self.update_filter_button_style(self.reverse_order_btn, False) # Start inactive
|
||
|
||
# Sort buttons
|
||
self.sort_relevance_btn = QPushButton("Relevance")
|
||
self.sort_quality_btn = QPushButton("Quality")
|
||
self.sort_size_btn = QPushButton("Size")
|
||
self.sort_name_btn = QPushButton("Name")
|
||
self.sort_uploader_btn = QPushButton("Uploader")
|
||
self.sort_bitrate_btn = QPushButton("Bitrate")
|
||
self.sort_duration_btn = QPushButton("Duration")
|
||
self.sort_availability_btn = QPushButton("Available")
|
||
self.sort_speed_btn = QPushButton("Speed")
|
||
|
||
# Store sort buttons for easy access
|
||
self.sort_buttons = {
|
||
"relevance": self.sort_relevance_btn,
|
||
"quality": self.sort_quality_btn,
|
||
"size": self.sort_size_btn,
|
||
"name": self.sort_name_btn,
|
||
"uploader": self.sort_uploader_btn,
|
||
"bitrate": self.sort_bitrate_btn,
|
||
"duration": self.sort_duration_btn,
|
||
"availability": self.sort_availability_btn,
|
||
"speed": self.sort_speed_btn
|
||
}
|
||
|
||
# Connect sort button signals
|
||
self.sort_relevance_btn.clicked.connect(lambda: self.set_sort("relevance"))
|
||
self.sort_quality_btn.clicked.connect(lambda: self.set_sort("quality"))
|
||
self.sort_size_btn.clicked.connect(lambda: self.set_sort("size"))
|
||
self.sort_name_btn.clicked.connect(lambda: self.set_sort("name"))
|
||
self.sort_uploader_btn.clicked.connect(lambda: self.set_sort("uploader"))
|
||
self.sort_bitrate_btn.clicked.connect(lambda: self.set_sort("bitrate"))
|
||
self.sort_duration_btn.clicked.connect(lambda: self.set_sort("duration"))
|
||
self.sort_availability_btn.clicked.connect(lambda: self.set_sort("availability"))
|
||
self.sort_speed_btn.clicked.connect(lambda: self.set_sort("speed"))
|
||
|
||
# Apply styling to sort buttons
|
||
for btn_key, btn in self.sort_buttons.items():
|
||
btn.setFixedHeight(28)
|
||
btn.setMinimumWidth(55)
|
||
self.update_filter_button_style(btn, btn_key == "relevance")
|
||
|
||
sort_row.addWidget(sort_label)
|
||
sort_row.addWidget(self.reverse_order_btn)
|
||
sort_row.addWidget(self.sort_relevance_btn)
|
||
sort_row.addWidget(self.sort_quality_btn)
|
||
sort_row.addWidget(self.sort_size_btn)
|
||
sort_row.addWidget(self.sort_name_btn)
|
||
sort_row.addWidget(self.sort_uploader_btn)
|
||
sort_row.addWidget(self.sort_bitrate_btn)
|
||
sort_row.addWidget(self.sort_duration_btn)
|
||
sort_row.addWidget(self.sort_availability_btn)
|
||
sort_row.addWidget(self.sort_speed_btn)
|
||
sort_row.addStretch()
|
||
|
||
# Add all filter rows to the collapsible content
|
||
self.filter_content_layout.addLayout(type_row)
|
||
self.filter_content_layout.addLayout(format_row)
|
||
self.filter_content_layout.addLayout(sort_row)
|
||
|
||
# Add collapsible content to main layout
|
||
main_layout.addWidget(self.filter_content)
|
||
|
||
# Start collapsed
|
||
self.filter_content.setVisible(False)
|
||
container.setFixedHeight(50) # Height for toggle button only
|
||
|
||
return container
|
||
|
||
def toggle_filter_panel(self):
|
||
"""Toggle the filter panel between collapsed and expanded states"""
|
||
self.filters_collapsed = not self.filters_collapsed
|
||
|
||
if self.filters_collapsed:
|
||
# Collapse
|
||
self.filter_content.setVisible(False)
|
||
self.filter_toggle_btn.setText("⏷ Filters")
|
||
self.filter_container.setFixedHeight(50)
|
||
else:
|
||
# Expand
|
||
self.filter_content.setVisible(True)
|
||
self.filter_toggle_btn.setText("⏶ Filters")
|
||
self.filter_container.setFixedHeight(175) # Height for all content
|
||
|
||
def update_filter_button_style(self, button, is_active):
|
||
"""Update the visual style of filter buttons based on active state"""
|
||
if is_active:
|
||
button.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 #1ed760,
|
||
stop:1 #1db954);
|
||
border: none;
|
||
border-radius: 16px;
|
||
color: #000000;
|
||
font-size: 11px;
|
||
font-weight: 700;
|
||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
|
||
padding: 0 12px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 #1fdf64,
|
||
stop:1 #1ed760);
|
||
}
|
||
QPushButton:pressed {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 #1ca851,
|
||
stop:1 #169c46);
|
||
}
|
||
""")
|
||
else:
|
||
button.setStyleSheet("""
|
||
QPushButton {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(80, 80, 80, 0.4),
|
||
stop:1 rgba(60, 60, 60, 0.6));
|
||
border: 1px solid rgba(120, 120, 120, 0.3);
|
||
border-radius: 16px;
|
||
color: rgba(255, 255, 255, 0.8);
|
||
font-size: 11px;
|
||
font-weight: 500;
|
||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
|
||
padding: 0 12px;
|
||
}
|
||
QPushButton:hover {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(100, 100, 100, 0.5),
|
||
stop:1 rgba(80, 80, 80, 0.7));
|
||
border: 1px solid rgba(140, 140, 140, 0.4);
|
||
color: rgba(255, 255, 255, 0.9);
|
||
}
|
||
QPushButton:pressed {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(60, 60, 60, 0.6),
|
||
stop:1 rgba(40, 40, 40, 0.8));
|
||
}
|
||
""")
|
||
|
||
def set_filter(self, filter_type):
|
||
"""Set the active filter and update UI"""
|
||
self.current_filter = filter_type
|
||
|
||
# Update button styles
|
||
for btn_key, btn in self.filter_buttons.items():
|
||
self.update_filter_button_style(btn, btn_key == filter_type)
|
||
|
||
# Apply the filter to current results
|
||
self.apply_filter()
|
||
|
||
def set_format_filter(self, format_type):
|
||
"""Set the current format filter and update button styles"""
|
||
self.current_format_filter = format_type
|
||
|
||
# Update format button styles
|
||
for btn_key, btn in self.format_buttons.items():
|
||
self.update_filter_button_style(btn, btn_key == format_type)
|
||
|
||
# Apply the filter to current results
|
||
self.apply_filter()
|
||
|
||
def set_sort(self, sort_type):
|
||
"""Set the current sort type and update button styles"""
|
||
self.current_sort = sort_type
|
||
|
||
# Update sort button styles
|
||
for btn_key, btn in self.sort_buttons.items():
|
||
self.update_filter_button_style(btn, btn_key == sort_type)
|
||
|
||
# Apply the sort to current results
|
||
self.apply_filter()
|
||
|
||
def toggle_reverse_order(self):
|
||
"""Toggle the reverse order setting and update button styles"""
|
||
self.reverse_order = not self.reverse_order
|
||
|
||
# Update arrow direction and button style
|
||
if self.reverse_order:
|
||
self.reverse_order_btn.setText("↑") # Up arrow for reverse order
|
||
else:
|
||
self.reverse_order_btn.setText("↓") # Down arrow for normal order
|
||
|
||
self.update_filter_button_style(self.reverse_order_btn, self.reverse_order)
|
||
|
||
# Apply the new sort order to current results
|
||
self.apply_filter()
|
||
|
||
def sort_results(self, results):
|
||
"""Sort search results based on current sort type and reverse order setting"""
|
||
if not results or not hasattr(self, 'current_sort'):
|
||
return results
|
||
|
||
# Define default reverse logic for each sort type (normal behavior)
|
||
default_reverse_logic = {
|
||
"relevance": True, # High relevance first
|
||
"quality": True, # High quality first
|
||
"size": True, # Large files first
|
||
"name": False, # A-Z alphabetical
|
||
"uploader": False, # A-Z alphabetical
|
||
"bitrate": True, # High bitrate first
|
||
"duration": True, # Long duration first
|
||
"availability": True, # More available first
|
||
"speed": True # Fast speed first
|
||
}
|
||
|
||
# Get the default reverse setting for current sort type
|
||
default_reverse = default_reverse_logic.get(self.current_sort, False)
|
||
|
||
# Apply user's reverse order toggle (XOR logic)
|
||
# If reverse_order is True, flip the default behavior
|
||
final_reverse = default_reverse if not self.reverse_order else not default_reverse
|
||
|
||
# Apply the appropriate sorting
|
||
if self.current_sort == "relevance":
|
||
sorted_results = sorted(results, key=self._sort_by_relevance, reverse=final_reverse)
|
||
elif self.current_sort == "quality":
|
||
sorted_results = sorted(results, key=self._sort_by_quality, reverse=final_reverse)
|
||
elif self.current_sort == "size":
|
||
sorted_results = sorted(results, key=self._sort_by_size, reverse=final_reverse)
|
||
elif self.current_sort == "name":
|
||
sorted_results = sorted(results, key=self._sort_by_name, reverse=final_reverse)
|
||
elif self.current_sort == "uploader":
|
||
sorted_results = sorted(results, key=self._sort_by_uploader, reverse=final_reverse)
|
||
elif self.current_sort == "bitrate":
|
||
sorted_results = sorted(results, key=self._sort_by_bitrate, reverse=final_reverse)
|
||
elif self.current_sort == "duration":
|
||
sorted_results = sorted(results, key=self._sort_by_duration, reverse=final_reverse)
|
||
elif self.current_sort == "availability":
|
||
sorted_results = sorted(results, key=self._sort_by_availability, reverse=final_reverse)
|
||
elif self.current_sort == "speed":
|
||
sorted_results = sorted(results, key=self._sort_by_speed, reverse=final_reverse)
|
||
else:
|
||
sorted_results = results
|
||
|
||
return sorted_results
|
||
|
||
def _sort_by_relevance(self, result):
|
||
"""Sort by relevance score combining search matching, quality, completeness, and availability"""
|
||
if not hasattr(self, 'current_search_query') or not self.current_search_query:
|
||
# Fallback to quality score if no search query
|
||
return self._sort_by_quality(result)
|
||
|
||
score = 0.0
|
||
query_terms = self.current_search_query.lower().split()
|
||
|
||
# 1. Search Term Matching (40% weight - 0.4 max)
|
||
search_score = self._calculate_search_match_score(result, query_terms)
|
||
score += search_score * 0.4
|
||
|
||
# 2. Quality Score (25% weight - 0.25 max)
|
||
quality_score = self._sort_by_quality(result)
|
||
score += quality_score * 0.25
|
||
|
||
# 3. File Completeness (20% weight - 0.2 max)
|
||
completeness_score = self._calculate_completeness_score(result)
|
||
score += completeness_score * 0.2
|
||
|
||
# 4. User Reliability (10% weight - 0.1 max)
|
||
reliability_score = self._calculate_reliability_score(result)
|
||
score += reliability_score * 0.1
|
||
|
||
# 5. File Freshness (5% weight - 0.05 max)
|
||
freshness_score = self._calculate_freshness_score(result)
|
||
score += freshness_score * 0.05
|
||
|
||
return score
|
||
|
||
def _calculate_search_match_score(self, result, query_terms):
|
||
"""Calculate search term matching score (0.0 to 1.0)"""
|
||
if not query_terms:
|
||
return 0.0
|
||
|
||
# Get searchable text
|
||
searchable_text = ""
|
||
if hasattr(result, 'album_title'): # AlbumResult
|
||
searchable_text = f"{result.album_title} {result.artist or ''}"
|
||
elif hasattr(result, 'filename'): # TrackResult
|
||
searchable_text = f"{result.filename} {result.artist or ''} {result.title or ''} {result.album or ''}"
|
||
|
||
searchable_text = searchable_text.lower()
|
||
full_query = self.current_search_query.lower()
|
||
|
||
score = 0.0
|
||
|
||
# Exact match bonus (1.0 points)
|
||
if full_query in searchable_text:
|
||
score += 1.0
|
||
|
||
# Individual term matches (0.5 points each)
|
||
term_matches = 0
|
||
for term in query_terms:
|
||
if term in searchable_text:
|
||
term_matches += 1
|
||
score += (term_matches / len(query_terms)) * 0.5
|
||
|
||
# Position bonus (0.3 points if terms appear early)
|
||
position_bonus = 0.0
|
||
for term in query_terms:
|
||
pos = searchable_text.find(term)
|
||
if pos >= 0:
|
||
# Earlier positions get higher bonus
|
||
position_bonus += max(0, (50 - pos) / 50) * 0.3
|
||
score += position_bonus / len(query_terms)
|
||
|
||
return min(score, 1.0)
|
||
|
||
def _calculate_completeness_score(self, result):
|
||
"""Calculate file completeness score (0.0 to 1.0)"""
|
||
score = 0.0
|
||
|
||
if hasattr(result, 'tracks'): # AlbumResult
|
||
# Complete albums bonus
|
||
track_count = len(result.tracks)
|
||
if 8 <= track_count <= 20:
|
||
score += 0.8
|
||
elif 5 <= track_count <= 25:
|
||
score += 0.6
|
||
elif track_count > 25:
|
||
score += 0.4
|
||
else:
|
||
score += 0.2
|
||
|
||
# Album metadata bonus
|
||
if result.artist and result.album_title:
|
||
score += 0.2
|
||
else: # TrackResult
|
||
# Popular song length bonus
|
||
if hasattr(result, 'duration') and result.duration:
|
||
if 180 <= result.duration <= 300: # 3-5 minutes
|
||
score += 0.6
|
||
elif 120 <= result.duration <= 360: # 2-6 minutes
|
||
score += 0.4
|
||
else:
|
||
score += 0.2
|
||
else:
|
||
score += 0.3 # Default if no duration
|
||
|
||
# Track metadata bonus
|
||
if result.artist and result.title:
|
||
score += 0.4
|
||
elif result.artist or result.title:
|
||
score += 0.2
|
||
|
||
return min(score, 1.0)
|
||
|
||
def _calculate_reliability_score(self, result):
|
||
"""Calculate user reliability score (0.0 to 1.0)"""
|
||
score = 0.0
|
||
|
||
# High upload speed bonus
|
||
if hasattr(result, 'upload_speed'):
|
||
if result.upload_speed > 500:
|
||
score += 0.3
|
||
elif result.upload_speed > 200:
|
||
score += 0.2
|
||
elif result.upload_speed > 100:
|
||
score += 0.1
|
||
|
||
# Available slots bonus
|
||
if hasattr(result, 'free_upload_slots') and result.free_upload_slots > 0:
|
||
score += 0.2
|
||
|
||
# Low queue bonus
|
||
if hasattr(result, 'queue_length'):
|
||
if result.queue_length < 5:
|
||
score += 0.1
|
||
elif result.queue_length > 20:
|
||
score -= 0.1
|
||
|
||
return max(0.0, min(score, 1.0))
|
||
|
||
def _calculate_freshness_score(self, result):
|
||
"""Calculate file freshness/naming quality score (0.0 to 1.0)"""
|
||
score = 0.0
|
||
|
||
filename = ""
|
||
if hasattr(result, 'album_title'): # AlbumResult
|
||
filename = result.album_title
|
||
elif hasattr(result, 'filename'): # TrackResult
|
||
filename = result.filename
|
||
|
||
if filename:
|
||
# Proper naming patterns bonus
|
||
if any(pattern in filename.lower() for pattern in [' - ', '_', ' / ', ' & ']):
|
||
score += 0.2
|
||
|
||
# Standard format bonus
|
||
if any(ext in filename.lower() for ext in ['.flac', '.mp3', '.ogg', '.aac']):
|
||
score += 0.1
|
||
|
||
# Avoid weird characters penalty
|
||
if any(char in filename for char in ['@', '#', '$', '%', '!', '?']):
|
||
score -= 0.1
|
||
|
||
# Length bonus (not too short, not too long)
|
||
if 10 <= len(filename) <= 100:
|
||
score += 0.1
|
||
|
||
return max(0.0, min(score, 1.0))
|
||
|
||
def _sort_by_quality(self, result):
|
||
"""Sort by quality score (higher is better)"""
|
||
if hasattr(result, 'quality_score'):
|
||
return result.quality_score
|
||
return 0
|
||
|
||
def _sort_by_size(self, result):
|
||
"""Sort by file/album size (larger first)"""
|
||
size = 0
|
||
if hasattr(result, 'total_size'): # AlbumResult
|
||
size = result.total_size
|
||
elif hasattr(result, 'size'): # TrackResult
|
||
size = result.size
|
||
return size
|
||
|
||
def _sort_by_name(self, result):
|
||
"""Sort alphabetically by filename/album title"""
|
||
name = ""
|
||
if hasattr(result, 'album_title'): # AlbumResult
|
||
name = result.album_title.lower()
|
||
elif hasattr(result, 'filename'): # TrackResult
|
||
name = result.filename.lower()
|
||
return name
|
||
|
||
def _sort_by_uploader(self, result):
|
||
"""Sort alphabetically by username"""
|
||
return result.username.lower() if hasattr(result, 'username') else ""
|
||
|
||
def _sort_by_bitrate(self, result):
|
||
"""Sort by bitrate (higher first)"""
|
||
if hasattr(result, 'bitrate') and result.bitrate:
|
||
return result.bitrate
|
||
# For albums, get average bitrate from tracks
|
||
elif hasattr(result, 'tracks') and result.tracks:
|
||
bitrates = [track.bitrate for track in result.tracks if track.bitrate]
|
||
return sum(bitrates) / len(bitrates) if bitrates else 0
|
||
return 0
|
||
|
||
def _sort_by_duration(self, result):
|
||
"""Sort by duration (longer first)"""
|
||
if hasattr(result, 'duration') and result.duration:
|
||
return result.duration
|
||
# For albums, sum all track durations
|
||
elif hasattr(result, 'tracks') and result.tracks:
|
||
durations = [track.duration for track in result.tracks if track.duration]
|
||
return sum(durations) if durations else 0
|
||
return 0
|
||
|
||
def _sort_by_availability(self, result):
|
||
"""Sort by availability (free slots high, queue length low is better)"""
|
||
free_slots = result.free_upload_slots if hasattr(result, 'free_upload_slots') else 0
|
||
queue_length = result.queue_length if hasattr(result, 'queue_length') else 0
|
||
# Higher free slots and lower queue length = more available
|
||
return free_slots - (queue_length * 0.1)
|
||
|
||
def _sort_by_speed(self, result):
|
||
"""Sort by upload speed (faster first)"""
|
||
return result.upload_speed if hasattr(result, 'upload_speed') else 0
|
||
|
||
def apply_filter(self):
|
||
"""Apply the current type and format filters to search results"""
|
||
if not hasattr(self, '_temp_tracks') or not hasattr(self, '_temp_albums'):
|
||
return
|
||
|
||
# First, filter by type (Albums vs Singles)
|
||
if self.current_filter == "all":
|
||
type_filtered = self._temp_albums + self._temp_tracks
|
||
elif self.current_filter == "albums":
|
||
type_filtered = self._temp_albums
|
||
elif self.current_filter == "singles":
|
||
type_filtered = self._temp_tracks
|
||
else:
|
||
type_filtered = self._temp_albums + self._temp_tracks
|
||
|
||
# Then, filter by format
|
||
if self.current_format_filter == "all":
|
||
filtered_results = type_filtered
|
||
else:
|
||
# Filter results by file format
|
||
filtered_results = []
|
||
for result in type_filtered:
|
||
# For albums, check if any tracks match the format
|
||
if hasattr(result, 'tracks') and result.tracks:
|
||
# Album result - check if any tracks match format
|
||
matching_tracks = [track for track in result.tracks
|
||
if track.quality.lower() == self.current_format_filter.lower()]
|
||
if matching_tracks:
|
||
# Create a copy of the album with only matching tracks
|
||
filtered_album = result
|
||
filtered_album.tracks = matching_tracks
|
||
filtered_results.append(filtered_album)
|
||
else:
|
||
# Single track result - check format directly
|
||
if hasattr(result, 'quality') and result.quality.lower() == self.current_format_filter.lower():
|
||
filtered_results.append(result)
|
||
|
||
# Apply sorting to filtered results
|
||
sorted_results = self.sort_results(filtered_results)
|
||
# Update the filtered results cache for pagination
|
||
self.current_filtered_results = sorted_results
|
||
|
||
# Clear current display
|
||
self.clear_search_results()
|
||
self.displayed_results = 0
|
||
self.currently_expanded_item = None # Reset expanded state when applying filters
|
||
|
||
# Show sorted results (respecting pagination)
|
||
remaining_slots = self.results_per_page
|
||
results_to_show = sorted_results[:remaining_slots]
|
||
|
||
# Temporarily disable layout updates for smoother batch loading
|
||
self.search_results_widget.setUpdatesEnabled(False)
|
||
|
||
for result in results_to_show:
|
||
if isinstance(result, AlbumResult):
|
||
# Create expandable album result item
|
||
result_item = AlbumResultItem(result)
|
||
result_item.album_download_requested.connect(self.start_album_download)
|
||
result_item.matched_album_download_requested.connect(self.start_matched_album_download)
|
||
result_item.track_download_requested.connect(self.start_download)
|
||
result_item.track_stream_requested.connect(lambda search_result, track_item: self.start_stream(search_result, track_item))
|
||
else:
|
||
# Create individual track result item
|
||
result_item = SearchResultItem(result)
|
||
result_item.download_requested.connect(self.start_download)
|
||
result_item.stream_requested.connect(lambda search_result, item=result_item: self.start_stream(search_result, item))
|
||
result_item.expansion_requested.connect(self.handle_expansion_request)
|
||
|
||
# Insert before the stretch
|
||
insert_position = self.search_results_layout.count() - 1
|
||
self.search_results_layout.insertWidget(insert_position, result_item)
|
||
|
||
self.displayed_results = len(results_to_show)
|
||
|
||
# Re-enable layout updates
|
||
self.search_results_widget.setUpdatesEnabled(True)
|
||
|
||
# Update status to show filter results
|
||
total_albums = len(self._temp_albums)
|
||
total_tracks = len(self._temp_tracks)
|
||
total_filtered = len(sorted_results)
|
||
|
||
if self.current_filter == "all":
|
||
filter_status = f"Showing all {total_filtered} results"
|
||
elif self.current_filter == "albums":
|
||
filter_status = f"Showing {total_albums} albums"
|
||
elif self.current_filter == "singles":
|
||
filter_status = f"Showing {total_tracks} singles"
|
||
else:
|
||
filter_status = f"Showing {total_filtered} results"
|
||
|
||
# Update the search status to reflect filtering
|
||
if total_filtered > 0:
|
||
if total_filtered > self.results_per_page:
|
||
filter_status += f" (showing first {len(results_to_show)})"
|
||
self.search_status.setText(f"{filter_status} • {total_albums} albums, {total_tracks} singles")
|
||
else:
|
||
self.search_status.setText(f"No results found for '{self.current_filter}' filter")
|
||
|
||
def create_collapsible_controls_panel(self):
|
||
"""Create a compact, elegant controls panel"""
|
||
panel = QFrame()
|
||
panel.setStyleSheet("""
|
||
QFrame {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(40, 40, 40, 0.85),
|
||
stop:1 rgba(25, 25, 25, 0.95));
|
||
border-radius: 18px;
|
||
border: 1px solid rgba(80, 80, 80, 0.4);
|
||
}
|
||
""")
|
||
|
||
layout = QVBoxLayout(panel)
|
||
layout.setContentsMargins(8, 14, 8, 16) # Reduced side margins for wider download queue
|
||
layout.setSpacing(14) # Increased spacing for better section separation
|
||
|
||
# Panel header
|
||
header = QLabel("Download Manager")
|
||
header.setFont(QFont("Arial", 12, QFont.Weight.Bold))
|
||
header.setStyleSheet("color: rgba(255, 255, 255, 0.9); padding: 6px 0; margin: 0;")
|
||
layout.addWidget(header)
|
||
|
||
# Quick stats with improved styling
|
||
stats_frame = QFrame()
|
||
stats_frame.setStyleSheet("""
|
||
QFrame {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(45, 45, 45, 0.7),
|
||
stop:1 rgba(35, 35, 35, 0.8));
|
||
border-radius: 10px;
|
||
border: 1px solid rgba(80, 80, 80, 0.3);
|
||
}
|
||
""")
|
||
stats_layout = QVBoxLayout(stats_frame)
|
||
stats_layout.setContentsMargins(10, 8, 10, 8)
|
||
stats_layout.setSpacing(4)
|
||
|
||
self.active_downloads_label = QLabel("• Active Downloads: 0")
|
||
self.active_downloads_label.setFont(QFont("Arial", 9))
|
||
self.active_downloads_label.setStyleSheet("color: rgba(255, 255, 255, 0.8); margin: 0; padding: 2px 0;")
|
||
|
||
self.finished_downloads_label = QLabel("• Finished Downloads: 0")
|
||
self.finished_downloads_label.setFont(QFont("Arial", 9))
|
||
self.finished_downloads_label.setStyleSheet("color: rgba(255, 255, 255, 0.8); margin: 0; padding: 2px 0;")
|
||
|
||
stats_layout.addWidget(self.active_downloads_label)
|
||
stats_layout.addWidget(self.finished_downloads_label)
|
||
layout.addWidget(stats_frame)
|
||
|
||
# Control buttons with enhanced styling
|
||
controls_frame = QFrame()
|
||
controls_frame.setStyleSheet("""
|
||
QFrame {
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba(50, 50, 50, 0.6),
|
||
stop:1 rgba(30, 30, 30, 0.7));
|
||
border-radius: 10px;
|
||
border: 1px solid rgba(70, 70, 70, 0.4);
|
||
}
|
||
""")
|
||
controls_layout = QVBoxLayout(controls_frame)
|
||
controls_layout.setContentsMargins(10, 10, 10, 10)
|
||
controls_layout.setSpacing(6)
|
||
|
||
clear_btn = QPushButton("Clear Completed")
|
||
clear_btn.setFixedHeight(28)
|
||
clear_btn.clicked.connect(self.clear_completed_downloads)
|
||
clear_btn.setStyleSheet(self._get_control_button_style("#e22134"))
|
||
|
||
controls_layout.addWidget(clear_btn)
|
||
layout.addWidget(controls_frame)
|
||
|
||
# Download Queue Section - Now with tabs for active and finished downloads
|
||
queue_container = QFrame()
|
||
queue_container.setStyleSheet("""
|
||
QFrame {
|
||
background: transparent;
|
||
border: none;
|
||
margin-top: 5px;
|
||
}
|
||
""")
|
||
queue_layout = QVBoxLayout(queue_container)
|
||
queue_layout.setContentsMargins(0, 0, 0, 0)
|
||
|
||
self.download_queue = TabbedDownloadManager(self)
|
||
queue_layout.addWidget(self.download_queue)
|
||
layout.addWidget(queue_container)
|
||
|
||
# Force initial counter update after queue is set up
|
||
if self.download_queue:
|
||
self.download_queue.update_tab_counts()
|
||
|
||
# Initialize stats display
|
||
self.update_download_manager_stats(0, 0)
|
||
|
||
|
||
return panel
|
||
|
||
def update_download_manager_stats(self, active_count, finished_count):
|
||
"""Update the download manager statistics display"""
|
||
if hasattr(self, 'active_downloads_label'):
|
||
self.active_downloads_label.setText(f"• Active Downloads: {active_count}")
|
||
if hasattr(self, 'finished_downloads_label'):
|
||
self.finished_downloads_label.setText(f"• Finished Downloads: {finished_count}")
|
||
|
||
def create_compact_status_bar(self):
|
||
"""Create a minimal status bar"""
|
||
status_bar = QFrame()
|
||
status_bar.setFixedHeight(40)
|
||
status_bar.setStyleSheet("""
|
||
QFrame {
|
||
background: rgba(20, 20, 20, 0.8);
|
||
border-radius: 8px;
|
||
border: 1px solid rgba(64, 64, 64, 0.2);
|
||
}
|
||
""")
|
||
|
||
layout = QHBoxLayout(status_bar)
|
||
layout.setContentsMargins(16, 8, 16, 8)
|
||
layout.setSpacing(12)
|
||
|
||
connection_status = QLabel("slskd Connected")
|
||
connection_status.setFont(QFont("Arial", 10))
|
||
connection_status.setStyleSheet("color: rgba(29, 185, 84, 0.9);")
|
||
|
||
layout.addWidget(connection_status)
|
||
layout.addStretch()
|
||
|
||
download_path_info = QLabel(f"Downloads: {self.soulseek_client.download_path if self.soulseek_client else './downloads'}")
|
||
download_path_info.setFont(QFont("Arial", 9))
|
||
download_path_info.setStyleSheet("color: rgba(255, 255, 255, 0.6);")
|
||
layout.addWidget(download_path_info)
|
||
|
||
return status_bar
|
||
|
||
def _get_control_button_style(self, color):
|
||
"""Get consistent button styling with improved aesthetics"""
|
||
return f"""
|
||
QPushButton {{
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (40,)},
|
||
stop:1 rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (25,)});
|
||
border: 1px solid rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (80,)};
|
||
border-radius: 14px;
|
||
color: {color};
|
||
font-size: 10px;
|
||
font-weight: 600;
|
||
padding: 5px 10px;
|
||
text-align: center;
|
||
}}
|
||
QPushButton:hover {{
|
||
background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
|
||
stop:0 rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (60,)},
|
||
stop:1 rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (40,)});
|
||
border: 1px solid {color};
|
||
color: #ffffff;
|
||
}}
|
||
QPushButton:pressed {{
|
||
background: rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (80,)};
|
||
border: 1px solid {color};
|
||
}}
|
||
"""
|
||
|
||
def create_search_section(self):
|
||
section = QFrame()
|
||
section.setFixedHeight(350)
|
||
section.setStyleSheet("""
|
||
QFrame {
|
||
background: #282828;
|
||
border-radius: 8px;
|
||
border: 1px solid #404040;
|
||
}
|
||
""")
|
||
|
||
layout = QVBoxLayout(section)
|
||
layout.setContentsMargins(20, 20, 20, 20)
|
||
layout.setSpacing(15)
|
||
|
||
# Search header
|
||
search_header = QLabel("Search & Download")
|
||
search_header.setFont(QFont("Arial", 16, QFont.Weight.Bold))
|
||
search_header.setStyleSheet("color: #ffffff;")
|
||
|
||
# Search input and button
|
||
search_layout = QHBoxLayout()
|
||
|
||
self.search_input = QLineEdit()
|
||
self.search_input.setPlaceholderText("Search for music (e.g., 'Artist - Song Title')")
|
||
self.search_input.setFixedHeight(40)
|
||
self.search_input.returnPressed.connect(self.perform_search)
|
||
self.search_input.setStyleSheet("""
|
||
QLineEdit {
|
||
background: #404040;
|
||
border: 1px solid #606060;
|
||
border-radius: 20px;
|
||
padding: 0 15px;
|
||
color: #ffffff;
|
||
font-size: 12px;
|
||
}
|
||
QLineEdit:focus {
|
||
border: 1px solid #1db954;
|
||
}
|
||
""")
|
||
|
||
self.search_btn = QPushButton("Search")
|
||
self.search_btn.setFixedSize(100, 40)
|
||
self.search_btn.clicked.connect(self.perform_search)
|
||
self.search_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: #1db954;
|
||
border: none;
|
||
border-radius: 20px;
|
||
color: #000000;
|
||
font-size: 12px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background: #1ed760;
|
||
}
|
||
QPushButton:disabled {
|
||
background: #404040;
|
||
color: #666666;
|
||
}
|
||
""")
|
||
|
||
search_layout.addWidget(self.search_input)
|
||
search_layout.addWidget(self.search_btn)
|
||
|
||
# Search status
|
||
self.search_status = QLabel("Enter a search term and click Search")
|
||
self.search_status.setFont(QFont("Arial", 10))
|
||
self.search_status.setStyleSheet("color: #b3b3b3;")
|
||
|
||
# Search results
|
||
self.search_results_scroll = QScrollArea()
|
||
self.search_results_scroll.setWidgetResizable(True)
|
||
self.search_results_scroll.setStyleSheet("""
|
||
QScrollArea {
|
||
border: none;
|
||
background: transparent;
|
||
}
|
||
QScrollBar:vertical {
|
||
background: #404040;
|
||
width: 8px;
|
||
border-radius: 4px;
|
||
}
|
||
QScrollBar::handle:vertical {
|
||
background: #1db954;
|
||
border-radius: 4px;
|
||
}
|
||
""")
|
||
|
||
self.search_results_widget = QWidget()
|
||
self.search_results_layout = QVBoxLayout(self.search_results_widget)
|
||
self.search_results_layout.setSpacing(5)
|
||
|
||
# Just add stretch - no load more button needed with auto-scroll
|
||
self.search_results_layout.addStretch()
|
||
self.search_results_scroll.setWidget(self.search_results_widget)
|
||
|
||
layout.addWidget(search_header)
|
||
layout.addLayout(search_layout)
|
||
layout.addWidget(self.search_status)
|
||
layout.addWidget(self.search_results_scroll)
|
||
|
||
return section
|
||
|
||
def perform_search(self):
|
||
query = self.search_input.text().strip()
|
||
if not query:
|
||
self.update_search_status("Please enter a search term", "#ffa500")
|
||
return
|
||
|
||
if not self.soulseek_client:
|
||
self.update_search_status("Soulseek client not available", "#e22134")
|
||
return
|
||
|
||
# Stop any existing search
|
||
if self.search_thread and self.search_thread.isRunning():
|
||
self.search_thread.stop()
|
||
self.search_thread.wait(1000) # Wait up to 1 second
|
||
if self.search_thread.isRunning():
|
||
self.search_thread.terminate()
|
||
|
||
# Clear previous results and reset state
|
||
self.clear_search_results()
|
||
self.displayed_results = 0
|
||
self.is_loading_more = False
|
||
self.currently_expanded_item = None # Reset expanded state
|
||
|
||
# Reset filter to "all" and sort to "relevance", hide filter controls
|
||
self.current_filter = "all"
|
||
self.current_sort = "relevance"
|
||
self.reverse_order = False # Reset reverse order to normal
|
||
self.current_search_query = query # Store search query for relevance calculation
|
||
if hasattr(self, 'filter_buttons'):
|
||
for btn_key, btn in self.filter_buttons.items():
|
||
self.update_filter_button_style(btn, btn_key == "all")
|
||
if hasattr(self, 'format_buttons'):
|
||
for btn_key, btn in self.format_buttons.items():
|
||
self.update_filter_button_style(btn, btn_key == "all")
|
||
if hasattr(self, 'sort_buttons'):
|
||
for btn_key, btn in self.sort_buttons.items():
|
||
self.update_filter_button_style(btn, btn_key == "relevance")
|
||
if hasattr(self, 'reverse_order_btn'):
|
||
self.reverse_order_btn.setText("↓") # Reset to down arrow
|
||
self.update_filter_button_style(self.reverse_order_btn, False) # Reset to inactive
|
||
self.filter_container.setVisible(False)
|
||
|
||
# Enhanced searching state with animation
|
||
self.search_btn.setText("Searching...")
|
||
self.search_btn.setEnabled(False)
|
||
self.update_search_status(f"Searching for '{query}'... Results will appear as they are found", "#1db954")
|
||
|
||
# Emit activity signal for search start
|
||
self.download_activity.emit("", "Search Started", f"Searching for '{query}'", "Now")
|
||
|
||
# Show loading animations
|
||
self.start_search_animations()
|
||
|
||
# Start new search thread
|
||
self.search_thread = SearchThread(self.soulseek_client, query)
|
||
self.search_thread.search_completed.connect(self.on_search_completed)
|
||
self.search_thread.search_failed.connect(self.on_search_failed)
|
||
self.search_thread.search_progress.connect(self.on_search_progress)
|
||
self.search_thread.search_results_partial.connect(self.on_search_results_partial)
|
||
self.search_thread.finished.connect(self.on_search_thread_finished)
|
||
self.search_thread.start()
|
||
|
||
# Show cancel button and hide search button during search
|
||
self.cancel_search_btn.setVisible(True)
|
||
self.search_btn.setVisible(False)
|
||
|
||
def cancel_search(self):
|
||
"""Cancel the current search operation"""
|
||
if self.search_thread and self.search_thread.isRunning():
|
||
# Stop the search thread
|
||
self.search_thread.stop()
|
||
self.search_thread.wait(1000) # Wait up to 1 second
|
||
if self.search_thread.isRunning():
|
||
self.search_thread.terminate()
|
||
|
||
# Reset UI state
|
||
self.search_btn.setText("Search")
|
||
self.search_btn.setEnabled(True)
|
||
self.search_btn.setVisible(True)
|
||
self.cancel_search_btn.setVisible(False)
|
||
|
||
# Stop animations and update status
|
||
self.stop_search_animations()
|
||
self.update_search_status("Search cancelled", "#ffa500")
|
||
|
||
def update_search_status(self, message, color="#ffffff"):
|
||
"""Update search status with enhanced styling"""
|
||
self.search_status.setText(message)
|
||
|
||
if color == "#1db954": # Success/searching
|
||
bg_color = "rgba(29, 185, 84, 0.15)"
|
||
border_color = "rgba(29, 185, 84, 0.3)"
|
||
elif color == "#ffa500": # Warning
|
||
bg_color = "rgba(255, 165, 0, 0.15)"
|
||
border_color = "rgba(255, 165, 0, 0.3)"
|
||
elif color == "#e22134": # Error
|
||
bg_color = "rgba(226, 33, 52, 0.15)"
|
||
border_color = "rgba(226, 33, 52, 0.3)"
|
||
else: # Default
|
||
bg_color = "rgba(100, 100, 100, 0.1)"
|
||
border_color = "rgba(100, 100, 100, 0.2)"
|
||
|
||
self.search_status.setStyleSheet(f"""
|
||
color: {color};
|
||
padding: 2px 8px;
|
||
""")
|
||
|
||
def start_search_animations(self):
|
||
"""Start all search loading animations"""
|
||
# Show and start status area animations
|
||
self.spinning_circle.setVisible(True)
|
||
self.spinning_circle.start_animation()
|
||
self.bouncing_dots.setVisible(True)
|
||
self.bouncing_dots.start_animation()
|
||
|
||
# Show and start results area loading
|
||
self.results_loading_container.setVisible(True)
|
||
self.results_spinning_circle.start_animation()
|
||
|
||
def stop_search_animations(self):
|
||
"""Stop and hide all search loading animations"""
|
||
# Stop and hide status area animations
|
||
self.spinning_circle.stop_animation()
|
||
self.spinning_circle.setVisible(False)
|
||
self.bouncing_dots.stop_animation()
|
||
self.bouncing_dots.setVisible(False)
|
||
|
||
# Stop and hide results area loading
|
||
self.results_spinning_circle.stop_animation()
|
||
self.results_loading_container.setVisible(False)
|
||
|
||
def on_search_thread_finished(self):
|
||
"""Clean up when search thread finishes"""
|
||
if self.search_thread:
|
||
self.search_thread.deleteLater()
|
||
self.search_thread = None
|
||
|
||
def clear_search_results(self):
|
||
# Remove all result items except the stretch
|
||
for i in reversed(range(self.search_results_layout.count())):
|
||
item = self.search_results_layout.itemAt(i)
|
||
if item.widget():
|
||
item.widget().deleteLater()
|
||
elif item.spacerItem():
|
||
continue # Keep the stretch spacer
|
||
else:
|
||
self.search_results_layout.removeItem(item)
|
||
|
||
def on_search_results_partial(self, tracks, albums, response_count):
|
||
"""Handle progressive search results as they come in"""
|
||
# Combine tracks and albums into a single list for display (albums first, then tracks)
|
||
combined_results = albums + tracks
|
||
|
||
# Initialize temp results if not exists
|
||
if not hasattr(self, '_temp_search_results'):
|
||
self._temp_search_results = []
|
||
if not hasattr(self, '_temp_tracks'):
|
||
self._temp_tracks = []
|
||
if not hasattr(self, '_temp_albums'):
|
||
self._temp_albums = []
|
||
|
||
# Store tracks and albums separately and combined
|
||
self._temp_tracks = tracks.copy() # Replace with full updated list
|
||
self._temp_albums = albums.copy() # Replace with full updated list
|
||
self._temp_search_results = combined_results.copy()
|
||
|
||
# Update filtered results cache to match current filter and apply sorting
|
||
if hasattr(self, 'current_filter'):
|
||
if self.current_filter == "all":
|
||
filtered_results = combined_results.copy()
|
||
elif self.current_filter == "albums":
|
||
filtered_results = albums.copy()
|
||
elif self.current_filter == "singles":
|
||
filtered_results = tracks.copy()
|
||
else:
|
||
filtered_results = combined_results.copy()
|
||
else:
|
||
filtered_results = combined_results.copy()
|
||
|
||
# Apply sorting to filtered results
|
||
self.current_filtered_results = self.sort_results(filtered_results)
|
||
|
||
# Clear existing results and display the updated complete set
|
||
# This ensures proper sorting and no duplicates
|
||
self.clear_search_results()
|
||
self.displayed_results = 0
|
||
|
||
# Only display up to the current page limit
|
||
remaining_slots = self.results_per_page
|
||
results_to_show = combined_results[:remaining_slots]
|
||
|
||
# Temporarily disable layout updates for smoother batch loading
|
||
self.search_results_widget.setUpdatesEnabled(False)
|
||
|
||
for result in results_to_show:
|
||
if isinstance(result, AlbumResult):
|
||
# Create expandable album result item
|
||
result_item = AlbumResultItem(result)
|
||
result_item.album_download_requested.connect(self.start_album_download)
|
||
result_item.matched_album_download_requested.connect(self.start_matched_album_download)
|
||
result_item.track_download_requested.connect(self.start_download) # Individual track downloads
|
||
result_item.track_stream_requested.connect(lambda search_result, track_item: self.start_stream(search_result, track_item)) # Individual track streaming
|
||
else:
|
||
# Create individual track result item
|
||
result_item = SearchResultItem(result)
|
||
result_item.download_requested.connect(self.start_download)
|
||
result_item.stream_requested.connect(lambda search_result, item=result_item: self.start_stream(search_result, item))
|
||
result_item.expansion_requested.connect(self.handle_expansion_request)
|
||
|
||
# Insert before the stretch
|
||
insert_position = self.search_results_layout.count() - 1
|
||
self.search_results_layout.insertWidget(insert_position, result_item)
|
||
|
||
# Re-enable updates and force layout refresh
|
||
self.search_results_widget.setUpdatesEnabled(True)
|
||
self.search_results_widget.updateGeometry()
|
||
self.search_results_layout.update()
|
||
self.search_results_scroll.updateGeometry()
|
||
|
||
self.displayed_results = len(results_to_show)
|
||
|
||
# Show filter controls during live search when we have meaningful results
|
||
total_results = len(tracks) + len(albums)
|
||
should_show_filters = (
|
||
# Show if we have both albums and tracks (diverse results)
|
||
(len(albums) > 0 and len(tracks) > 0) or
|
||
# Or if we have enough results to make filtering useful
|
||
total_results >= 5
|
||
)
|
||
|
||
if should_show_filters and not self.filter_container.isVisible():
|
||
self.filter_container.setVisible(True)
|
||
|
||
# Update status message with real-time feedback
|
||
if self.displayed_results < self.results_per_page:
|
||
self.update_search_status(f"Found {total_results} results ({len(tracks)} tracks, {len(albums)} albums) from {response_count} users • Live updating...", "#1db954")
|
||
else:
|
||
self.update_search_status(f"Found {total_results} results ({len(tracks)} tracks, {len(albums)} albums) from {response_count} users • Showing first {self.results_per_page} (scroll for more)", "#1db954")
|
||
|
||
def on_search_completed(self, results):
|
||
self.search_btn.setText("Search")
|
||
self.search_btn.setEnabled(True)
|
||
self.search_btn.setVisible(True)
|
||
self.cancel_search_btn.setVisible(False)
|
||
|
||
# Stop loading animations
|
||
self.stop_search_animations()
|
||
|
||
# Use the temp results that have been accumulating during live updates
|
||
if hasattr(self, '_temp_tracks') and hasattr(self, '_temp_albums'):
|
||
tracks = self._temp_tracks
|
||
albums = self._temp_albums
|
||
combined_results = self._temp_search_results
|
||
elif isinstance(results, tuple) and len(results) == 2:
|
||
# Fallback to final results if temp not available
|
||
tracks, albums = results
|
||
combined_results = albums + tracks
|
||
else:
|
||
# Fallback for old list format or empty results
|
||
tracks = results or []
|
||
albums = []
|
||
combined_results = results or []
|
||
|
||
# Store final results
|
||
self.search_results = combined_results
|
||
self.current_filtered_results = self.sort_results(combined_results) # Initialize with sorted results
|
||
self.track_results = tracks
|
||
self.album_results = albums
|
||
|
||
total_results = len(combined_results)
|
||
|
||
if total_results == 0:
|
||
if self.displayed_results == 0:
|
||
self.update_search_status("No results found • Try a different search term or artist name", "#ffa500")
|
||
else:
|
||
self.update_search_status(f"Search completed • Found {self.displayed_results} total results", "#1db954")
|
||
# Hide filter controls when no results
|
||
self.filter_container.setVisible(False)
|
||
return
|
||
|
||
# Update status with album/track breakdown
|
||
album_count = len(albums)
|
||
track_count = len(tracks)
|
||
|
||
status_parts = []
|
||
if album_count > 0:
|
||
status_parts.append(f"{album_count} album{'s' if album_count != 1 else ''}")
|
||
if track_count > 0:
|
||
status_parts.append(f"{track_count} track{'s' if track_count != 1 else ''}")
|
||
|
||
result_summary = " • ".join(status_parts) if status_parts else f"{total_results} results"
|
||
|
||
# Show filter controls when we have results
|
||
self.filter_container.setVisible(True)
|
||
|
||
# Emit activity signal for search completion
|
||
search_query = self.search_input.text().strip()
|
||
self.download_activity.emit("", "Search Complete", f"Found {total_results} results for '{search_query}'", "Now")
|
||
|
||
# Update status based on whether there are more results to load
|
||
if self.displayed_results < total_results:
|
||
remaining = total_results - self.displayed_results
|
||
self.update_search_status(f"Search completed • Found {result_summary} • Showing first {self.displayed_results} (scroll down for {remaining} more)", "#1db954")
|
||
else:
|
||
self.update_search_status(f"Search completed • Found {result_summary}", "#1db954")
|
||
|
||
def clear_search_results(self):
|
||
"""Clear all search result items from the layout"""
|
||
# Remove all SearchResultItem and AlbumResultItem widgets (but keep stretch)
|
||
items_to_remove = []
|
||
for i in range(self.search_results_layout.count()):
|
||
item = self.search_results_layout.itemAt(i)
|
||
if item and item.widget():
|
||
widget = item.widget()
|
||
if isinstance(widget, (SearchResultItem, AlbumResultItem)):
|
||
items_to_remove.append(widget)
|
||
|
||
for widget in items_to_remove:
|
||
self.search_results_layout.removeWidget(widget)
|
||
widget.deleteLater()
|
||
|
||
def on_scroll_changed(self, value):
|
||
"""Handle scroll changes to implement lazy loading"""
|
||
if self.is_loading_more or not self.current_filtered_results:
|
||
return
|
||
|
||
scroll_bar = self.search_results_scroll.verticalScrollBar()
|
||
|
||
# Check if we're near the bottom (90% scrolled)
|
||
if scroll_bar.maximum() > 0:
|
||
scroll_percentage = value / scroll_bar.maximum()
|
||
|
||
if scroll_percentage >= 0.9 and self.displayed_results < len(self.current_filtered_results):
|
||
self.load_more_results()
|
||
|
||
# In downloads.py, find and REPLACE the existing load_more_results method with this:
|
||
|
||
def load_more_results(self):
|
||
"""
|
||
Prepares a batch of results and initiates the staggered loading process.
|
||
"""
|
||
if self.is_loading_more or not self.current_filtered_results:
|
||
return
|
||
|
||
self.is_loading_more = True
|
||
|
||
# Calculate how many more results to show
|
||
start_index = self.displayed_results
|
||
end_index = min(start_index + self.results_per_page, len(self.current_filtered_results))
|
||
|
||
# Get the batch of results to load and add them to our queue
|
||
results_to_add = self.current_filtered_results[start_index:end_index]
|
||
self._results_to_load_queue.extend(results_to_add)
|
||
|
||
# Update status to show that we are loading more
|
||
self.update_search_status(f"Loading more results...", "#1db954")
|
||
|
||
# Kick off the staggered loading process by loading the first item
|
||
if self._results_to_load_queue:
|
||
QTimer.singleShot(0, self._load_next_result_item)
|
||
else:
|
||
self.is_loading_more = False
|
||
|
||
|
||
def handle_expansion_request(self, requesting_item):
|
||
"""Handle accordion-style expansion where only one item can be expanded at a time"""
|
||
# If there's a currently expanded item and it's not the requesting item, collapse it
|
||
if self.currently_expanded_item and self.currently_expanded_item != requesting_item:
|
||
try:
|
||
self.currently_expanded_item.set_expanded(False, animate=True)
|
||
except RuntimeError:
|
||
# Widget has been deleted, just clear the reference
|
||
self.currently_expanded_item = None
|
||
|
||
# Toggle the requesting item
|
||
new_expanded_state = not requesting_item.is_expanded
|
||
requesting_item.set_expanded(new_expanded_state, animate=True)
|
||
|
||
# Update tracking
|
||
if new_expanded_state:
|
||
self.currently_expanded_item = requesting_item
|
||
else:
|
||
self.currently_expanded_item = None
|
||
|
||
def on_search_failed(self, error_msg):
|
||
self.search_btn.setText("Search")
|
||
self.search_btn.setEnabled(True)
|
||
self.search_btn.setVisible(True)
|
||
self.cancel_search_btn.setVisible(False)
|
||
|
||
# Stop loading animations
|
||
self.stop_search_animations()
|
||
|
||
self.update_search_status(f"Search failed: {error_msg}", "#e22134")
|
||
|
||
def on_search_progress(self, message):
|
||
self.update_search_status(f"{message}", "#1db954")
|
||
|
||
def start_download(self, search_result):
|
||
"""Start downloading a search result using threaded approach"""
|
||
try:
|
||
# Extract track info for queue display
|
||
full_filename = search_result.filename
|
||
|
||
# Extract just the filename part (without directory path)
|
||
import os
|
||
filename = os.path.basename(full_filename)
|
||
|
||
# Use TrackResult's parsed metadata if available, otherwise parse filename
|
||
if hasattr(search_result, 'title') and search_result.title:
|
||
title = search_result.title
|
||
print(f"[DEBUG] Using TrackResult title: '{title}'")
|
||
else:
|
||
# Fallback: Parse title from filename
|
||
name_without_ext = filename
|
||
if '.' in name_without_ext:
|
||
name_without_ext = '.'.join(name_without_ext.split('.')[:-1])
|
||
|
||
# Check for track number prefix and remove it
|
||
import re
|
||
track_number_match = re.match(r'^(\d+)\.\s*(.+)', name_without_ext)
|
||
if track_number_match:
|
||
name_without_track_num = track_number_match.group(2)
|
||
else:
|
||
name_without_track_num = name_without_ext
|
||
|
||
# Extract just the title (remove artist if present)
|
||
parts = name_without_track_num.split(' - ')
|
||
if len(parts) >= 2:
|
||
title = ' - '.join(parts[1:]).strip() # Everything after first " - "
|
||
else:
|
||
title = name_without_track_num.strip()
|
||
|
||
print(f"[DEBUG] Parsed title from filename: '{title}'")
|
||
|
||
# Use TrackResult's artist if available, otherwise parse or use username
|
||
if hasattr(search_result, 'artist') and search_result.artist:
|
||
artist = search_result.artist
|
||
print(f"[DEBUG] Using TrackResult artist: '{artist}'")
|
||
else:
|
||
# Fallback: Parse artist from filename or use uploader
|
||
name_without_ext = filename
|
||
if '.' in name_without_ext:
|
||
name_without_ext = '.'.join(name_without_ext.split('.')[:-1])
|
||
|
||
# Remove track number prefix - handle multiple formats
|
||
import re
|
||
name_without_track_num = name_without_ext
|
||
|
||
# Try different track number patterns
|
||
track_patterns = [
|
||
r'^(\d+)\.\s*(.+)', # "06. Artist - Track"
|
||
r'^(\d+)\s*-\s*(.+)', # "06 - Artist - Track"
|
||
r'^(\d+)\s+(.+)' # "06 Artist - Track"
|
||
]
|
||
|
||
for pattern in track_patterns:
|
||
match = re.match(pattern, name_without_ext)
|
||
if match:
|
||
name_without_track_num = match.group(2)
|
||
break
|
||
|
||
# Extract artist (first part before " - ")
|
||
parts = name_without_track_num.split(' - ')
|
||
if len(parts) >= 2:
|
||
# First part is artist, second part is track title
|
||
artist = parts[0].strip()
|
||
# Verify this doesn't look like a track number
|
||
if re.match(r'^\d+$', artist.strip()):
|
||
# If first part is just a number, use username as fallback
|
||
artist = search_result.username
|
||
else:
|
||
artist = search_result.username
|
||
|
||
print(f"[DEBUG] Parsed artist from filename: '{artist}'")
|
||
|
||
# Final cleanup - ensure we have meaningful values
|
||
if not title or title == '':
|
||
title = filename # Ultimate fallback
|
||
if not artist or artist == '':
|
||
artist = search_result.username # Ultimate fallback
|
||
|
||
print(f"[DEBUG] Extracted title info from '{full_filename}' -> title: '{title}', artist: '{artist}'")
|
||
|
||
# Extract album context from search_result if available (for matched album downloads)
|
||
album_name = None
|
||
track_number = None
|
||
|
||
if hasattr(search_result, 'album') and search_result.album:
|
||
album_name = search_result.album
|
||
print(f"[DEBUG] Found album context: '{album_name}'")
|
||
|
||
if hasattr(search_result, 'track_number') and search_result.track_number:
|
||
track_number = search_result.track_number
|
||
print(f"[DEBUG] Found track number: {track_number}")
|
||
|
||
# Generate a unique download ID for tracking and cancellation
|
||
import time
|
||
import uuid
|
||
timestamp = time.time()
|
||
unique_suffix = str(uuid.uuid4())[:8] # Short unique identifier
|
||
download_id = f"{search_result.username}_{filename}_{int(timestamp)}_{unique_suffix}"
|
||
|
||
# Add to download queue immediately as "downloading" with album context
|
||
download_item = self.download_queue.add_download_item(
|
||
title=title,
|
||
artist=artist,
|
||
status="downloading",
|
||
progress=0,
|
||
file_size=search_result.size,
|
||
download_id=download_id,
|
||
username=search_result.username,
|
||
file_path=full_filename, # Store the full path for matching
|
||
soulseek_client=self.soulseek_client,
|
||
album=album_name,
|
||
track_number=track_number
|
||
)
|
||
|
||
print(f"[DEBUG] Created download item with album context: album='{album_name}', track_number={track_number}")
|
||
|
||
# Emit activity signal for download start
|
||
self.download_activity.emit("", "Download Started", f"'{title}' by {artist}", "Now")
|
||
|
||
# Create and start download thread
|
||
download_thread = DownloadThread(self.soulseek_client, search_result, download_item)
|
||
download_thread.download_completed.connect(self.on_download_completed, Qt.ConnectionType.QueuedConnection)
|
||
download_thread.download_failed.connect(self.on_download_failed, Qt.ConnectionType.QueuedConnection)
|
||
download_thread.download_progress.connect(self.on_download_progress, Qt.ConnectionType.QueuedConnection)
|
||
download_thread.finished.connect(
|
||
functools.partial(self.on_download_thread_finished, download_thread),
|
||
Qt.ConnectionType.QueuedConnection
|
||
)
|
||
|
||
# Track the thread
|
||
self.download_threads.append(download_thread)
|
||
|
||
# Start the download
|
||
download_thread.start()
|
||
|
||
# Download started - feedback will appear in download queue
|
||
|
||
except Exception as e:
|
||
print(f"Failed to start download: {str(e)}")
|
||
|
||
def start_album_download(self, album_result):
|
||
"""Start downloading all tracks in an album"""
|
||
try:
|
||
print(f"Starting album download: {album_result.album_title} by {album_result.artist}")
|
||
|
||
# First, find and disable all track download buttons for this album
|
||
self.disable_album_track_buttons(album_result)
|
||
|
||
# Download each track in the album
|
||
for track in album_result.tracks:
|
||
self.start_download(track)
|
||
|
||
print(f"Queued {len(album_result.tracks)} tracks for download from album: {album_result.album_title}")
|
||
|
||
except Exception as e:
|
||
print(f"Failed to start album download: {str(e)}")
|
||
|
||
def disable_album_track_buttons(self, album_result):
|
||
"""Disable all track download buttons for an album to prevent duplicate downloads"""
|
||
# Find the AlbumResultItem that contains these tracks
|
||
for album_item in self.findChildren(AlbumResultItem):
|
||
if (album_item.album_result.album_title == album_result.album_title and
|
||
album_item.album_result.artist == album_result.artist):
|
||
|
||
# Disable all track download buttons in this album
|
||
for track_item in album_item.track_items:
|
||
track_item.set_download_queued_state()
|
||
print(f"[DEBUG] Disabled {len(album_item.track_items)} track download buttons for album: {album_result.album_title}")
|
||
break
|
||
|
||
def start_matched_download(self, search_result):
|
||
"""Start a matched download for a single track using the new modal."""
|
||
try:
|
||
if not self.spotify_client.is_authenticated():
|
||
self.start_download(search_result)
|
||
return
|
||
|
||
modal = SpotifyMatchingModal(search_result, self.spotify_client, self.matching_engine, self, is_album=False)
|
||
# Use a lambda to pass the original search_result to the handler
|
||
modal.match_confirmed.connect(
|
||
lambda artist, album: self._handle_match_confirmed(search_result, artist, album, is_album_download=False)
|
||
)
|
||
|
||
if modal.exec() == QDialog.DialogCode.Accepted:
|
||
print("Match confirmed via modal.")
|
||
elif hasattr(modal, 'skipped_matching') and modal.skipped_matching:
|
||
print("Matching skipped, proceeding with normal download.")
|
||
self.start_download(search_result)
|
||
else:
|
||
print("Match process cancelled by user.")
|
||
|
||
except Exception as e:
|
||
print(f"Error in matched download process: {e}")
|
||
self.start_download(search_result)
|
||
|
||
def start_matched_album_download(self, album_result):
|
||
"""Start a matched download for a full album using the new modal."""
|
||
try:
|
||
if not self.spotify_client.is_authenticated():
|
||
self.start_album_download(album_result)
|
||
return
|
||
|
||
# Use the first track as a reference for the modal
|
||
first_track = album_result.tracks[0] if album_result.tracks else None
|
||
if not first_track:
|
||
print("Cannot start matched download for an empty album.")
|
||
self.start_album_download(album_result)
|
||
return
|
||
|
||
modal = SpotifyMatchingModal(first_track, self.spotify_client, self.matching_engine, self, is_album=True, album_result=album_result)
|
||
modal.match_confirmed.connect(
|
||
lambda artist, album: self._handle_match_confirmed(album_result, artist, album, is_album_download=True)
|
||
)
|
||
|
||
if modal.exec() == QDialog.DialogCode.Accepted:
|
||
print("Album match confirmed via modal.")
|
||
elif hasattr(modal, 'skipped_matching') and modal.skipped_matching:
|
||
print("Album matching skipped, proceeding with normal download.")
|
||
self.start_album_download(album_result)
|
||
else:
|
||
print("Album match process cancelled by user.")
|
||
|
||
except Exception as e:
|
||
print(f"Error in matched album download process: {e}")
|
||
self.start_album_download(album_result)
|
||
|
||
|
||
def _handle_matched_download(self, search_result, artist: Artist):
|
||
"""Handle the download after artist selection from modal"""
|
||
try:
|
||
print(f"Starting matched download for '{search_result.title}' by '{artist.name}'")
|
||
|
||
# Store the selected artist metadata with the search result
|
||
search_result.matched_artist = artist
|
||
|
||
# Start the download with normal process but enhanced with Spotify metadata
|
||
download_item = self._start_download_with_artist(search_result, artist)
|
||
|
||
if download_item:
|
||
print(f"Successfully created matched download for '{download_item.title}'")
|
||
else:
|
||
print(f"Failed to create matched download, falling back to normal download")
|
||
self.start_download(search_result)
|
||
|
||
except Exception as e:
|
||
print(f"Error handling matched download: {e}")
|
||
# Fallback to normal download
|
||
self.start_download(search_result)
|
||
|
||
def _handle_match_confirmed(self, original_result, artist: Artist, album: Album, is_album_download=False):
|
||
"""
|
||
Handles the final confirmed match from the modal for both single tracks and full albums.
|
||
"""
|
||
try:
|
||
if is_album_download:
|
||
# This is a full album download
|
||
print(f"Confirmed album match: '{album.name}' by '{artist.name}'")
|
||
# Now, we process each track in the original album_result
|
||
for track in original_result.tracks:
|
||
track.matched_artist = artist
|
||
track.matched_album = album
|
||
track.album = album.name # Overwrite album name for consistency
|
||
self._start_download_with_artist(track, artist)
|
||
else:
|
||
# This is a single track download
|
||
print(f"Confirmed single track match: '{original_result.title}' -> Artist: '{artist.name}', Album: '{album.name}'")
|
||
original_result.matched_artist = artist
|
||
original_result.matched_album = album
|
||
|
||
# For singles-only mode, don't overwrite with dummy album name
|
||
if album.id != "singles-dummy":
|
||
original_result.album = album.name
|
||
# If it's our dummy album, keep the original album name from the search result
|
||
|
||
self._start_download_with_artist(original_result, artist)
|
||
|
||
except Exception as e:
|
||
print(f"Error handling confirmed match: {e}")
|
||
# Fallback to normal download
|
||
if is_album_download:
|
||
self.start_album_download(original_result)
|
||
else:
|
||
self.start_download(original_result)
|
||
|
||
|
||
def _start_download_with_artist(self, search_result, artist: Artist):
|
||
"""Start download and immediately assign matched artist - no race conditions"""
|
||
try:
|
||
# Extract track info for queue display (same as start_download)
|
||
full_filename = search_result.filename
|
||
import os
|
||
filename = os.path.basename(full_filename)
|
||
|
||
# Use TrackResult's parsed metadata if available, otherwise parse filename
|
||
if hasattr(search_result, 'title') and search_result.title:
|
||
title = search_result.title
|
||
else:
|
||
# Fallback parsing logic (copied from start_download)
|
||
name_without_ext = filename
|
||
if '.' in name_without_ext:
|
||
name_without_ext = '.'.join(name_without_ext.split('.')[:-1])
|
||
|
||
import re
|
||
track_number_match = re.match(r'^(\d+)\.\s*(.+)', name_without_ext)
|
||
if track_number_match:
|
||
name_without_track_num = track_number_match.group(2)
|
||
else:
|
||
name_without_track_num = name_without_ext
|
||
|
||
parts = name_without_track_num.split(' - ')
|
||
if len(parts) >= 2:
|
||
title = ' - '.join(parts[1:]).strip()
|
||
else:
|
||
title = name_without_track_num.strip()
|
||
|
||
# Use TrackResult's artist if available, otherwise parse or use username
|
||
if hasattr(search_result, 'artist') and search_result.artist:
|
||
original_artist = search_result.artist
|
||
else:
|
||
# Same fallback logic as start_download
|
||
name_without_ext = filename
|
||
if '.' in name_without_ext:
|
||
name_without_ext = '.'.join(name_without_ext.split('.')[:-1])
|
||
|
||
import re
|
||
name_without_track_num = name_without_ext
|
||
|
||
# Try different track number patterns
|
||
track_patterns = [
|
||
r'^(\d+)\.\s*(.+)', # "06. Artist - Track"
|
||
r'^(\d+)\s*-\s*(.+)', # "06 - Artist - Track"
|
||
r'^(\d+)\s+(.+)' # "06 Artist - Track"
|
||
]
|
||
|
||
for pattern in track_patterns:
|
||
match = re.match(pattern, name_without_ext)
|
||
if match:
|
||
name_without_track_num = match.group(2)
|
||
break
|
||
|
||
parts = name_without_track_num.split(' - ')
|
||
if len(parts) >= 2:
|
||
original_artist = parts[0].strip()
|
||
# Verify this doesn't look like a track number
|
||
if re.match(r'^\d+$', original_artist.strip()):
|
||
# If first part is just a number, use username as fallback
|
||
original_artist = search_result.username
|
||
else:
|
||
original_artist = search_result.username
|
||
|
||
# Final cleanup
|
||
if not title or title == '':
|
||
title = filename
|
||
if not original_artist or original_artist == '':
|
||
original_artist = search_result.username
|
||
|
||
# Extract album context
|
||
album_name = getattr(search_result, 'album', None)
|
||
track_number = getattr(search_result, 'track_number', None)
|
||
|
||
# If no track number found, try to extract from filename
|
||
if not track_number:
|
||
track_number = self._extract_track_number_from_filename(filename, title)
|
||
if track_number:
|
||
print(f"Extracted track number from filename: {track_number}")
|
||
else:
|
||
print(f"Could not extract track number from filename: '{filename}'")
|
||
|
||
# Generate download ID
|
||
import time
|
||
import uuid
|
||
timestamp = time.time()
|
||
unique_suffix = str(uuid.uuid4())[:8] # Short unique identifier
|
||
download_id = f"{search_result.username}_{filename}_{int(timestamp)}_{unique_suffix}"
|
||
|
||
# Create download item with matched artist immediately
|
||
download_item = self.download_queue.add_download_item(
|
||
title=title,
|
||
artist=original_artist,
|
||
status="downloading",
|
||
progress=0,
|
||
file_size=search_result.size,
|
||
download_id=download_id,
|
||
username=search_result.username,
|
||
file_path=full_filename,
|
||
soulseek_client=self.soulseek_client,
|
||
album=album_name,
|
||
track_number=track_number
|
||
)
|
||
|
||
# Immediately assign the matched artist - no timing delays
|
||
if download_item:
|
||
download_item.matched_artist = artist
|
||
print(f"Matched artist '{artist.name}' assigned to download item '{download_item.title}'")
|
||
|
||
# Emit activity signal for download start (with matched artist)
|
||
self.download_activity.emit("", "Download Started", f"'{title}' by {artist.name if artist else original_artist}", "Now")
|
||
|
||
# Start the download thread
|
||
download_thread = DownloadThread(self.soulseek_client, search_result, download_item)
|
||
download_thread.download_completed.connect(self.on_download_completed, Qt.ConnectionType.QueuedConnection)
|
||
download_thread.download_failed.connect(self.on_download_failed, Qt.ConnectionType.QueuedConnection)
|
||
download_thread.download_progress.connect(self.on_download_progress, Qt.ConnectionType.QueuedConnection)
|
||
download_thread.finished.connect(
|
||
functools.partial(self.on_download_thread_finished, download_thread),
|
||
Qt.ConnectionType.QueuedConnection
|
||
)
|
||
|
||
self.download_threads.append(download_thread)
|
||
download_thread.start()
|
||
|
||
return download_item
|
||
|
||
except Exception as e:
|
||
print(f"Failed to start download with artist: {str(e)}")
|
||
return None
|
||
|
||
def _ensure_album_consistency(self, download_items, artist: Artist, album_name: str):
|
||
"""Ensure all download items have consistent album naming for proper grouping"""
|
||
try:
|
||
with self.album_cache_lock:
|
||
# Create cache key for this album
|
||
album_key = f"{artist.name}::{album_name}"
|
||
|
||
# Store the definitive album name
|
||
self.album_name_cache[album_key] = album_name
|
||
|
||
print(f"Cached album name: '{album_name}' for key: '{album_key}'")
|
||
|
||
# Ensure all download items use the same album name
|
||
for download_item in download_items:
|
||
if hasattr(download_item, 'album'):
|
||
download_item.album = album_name
|
||
print(f" Set album name for '{download_item.title}': '{album_name}'")
|
||
|
||
except Exception as e:
|
||
print(f"Error ensuring album consistency: {e}")
|
||
|
||
def _assign_matched_artist_to_download_item(self, search_result, artist: Artist):
|
||
"""Assign matched artist to the corresponding download item"""
|
||
try:
|
||
print(f"Looking for download item matching: '{search_result.title}' by '{search_result.artist}'")
|
||
print(f"Current download items: {len(self.download_queue.download_items)}")
|
||
|
||
matched = False
|
||
# Find the download item for this search result
|
||
for i, download_item in enumerate(self.download_queue.download_items):
|
||
print(f" Item {i}: '{getattr(download_item, 'title', 'NO_TITLE')}' by '{getattr(download_item, 'artist', 'NO_ARTIST')}'")
|
||
|
||
if (hasattr(download_item, 'title') and download_item.title == search_result.title and
|
||
hasattr(download_item, 'artist') and download_item.artist == search_result.artist):
|
||
download_item.matched_artist = artist
|
||
print(f"Assigned matched artist '{artist.name}' to download item '{download_item.title}'")
|
||
matched = True
|
||
break
|
||
|
||
if not matched:
|
||
print(f"Could not find matching download item for '{search_result.title}' by '{search_result.artist}'")
|
||
# Try a more lenient search
|
||
for i, download_item in enumerate(self.download_queue.download_items):
|
||
if (hasattr(download_item, 'title') and
|
||
self.matching_engine.normalize_string(download_item.title) == self.matching_engine.normalize_string(search_result.title)):
|
||
download_item.matched_artist = artist
|
||
print(f"Assigned matched artist '{artist.name}' to download item '{download_item.title}' (lenient match)")
|
||
matched = True
|
||
break
|
||
|
||
if not matched:
|
||
print(f"Still could not find matching download item - assignment failed")
|
||
|
||
except Exception as e:
|
||
print(f"Error assigning matched artist to download item: {e}")
|
||
|
||
def _handle_matched_album_download(self, album_result, artist: Artist):
|
||
"""Handle the album download after artist selection from modal"""
|
||
# OPTIMIZATION v2: Use optimized version if enabled
|
||
if hasattr(self, '_use_optimized_systems') and self._use_optimized_systems:
|
||
return self._handle_matched_album_download_v2(album_result, artist)
|
||
|
||
try:
|
||
print(f"Starting matched album download for '{album_result.album_title}' by '{artist.name}'")
|
||
print(f"Processing {len(album_result.tracks)} tracks with matched artist")
|
||
|
||
# Store the selected artist metadata and album context with each track
|
||
print(f"Album context being set:")
|
||
print(f" Album result title: '{album_result.album_title}'")
|
||
print(f" Matched artist: '{artist.name}'")
|
||
|
||
# Clean up the album title - remove "Album - Artist -" prefix if present
|
||
clean_album_title = self._clean_album_title(album_result.album_title, artist.name)
|
||
print(f" Cleaned album title: '{clean_album_title}'")
|
||
|
||
for track_index, track in enumerate(album_result.tracks, 1):
|
||
track.matched_artist = artist
|
||
|
||
# Preserve album context - this is CRITICAL for proper album detection
|
||
track.album = clean_album_title # Use cleaned album title
|
||
|
||
# Extract original track number from filename instead of using sequential index
|
||
if hasattr(track, 'filename'):
|
||
import os
|
||
filename = os.path.basename(track.filename)
|
||
original_track_num = self._extract_track_number_from_filename(filename, track.title)
|
||
if original_track_num:
|
||
track.track_number = original_track_num
|
||
print(f" Preserved original track number: {original_track_num}")
|
||
else:
|
||
# Only use sequential as fallback if no original number found
|
||
track.track_number = track_index
|
||
print(f" Using fallback sequential track number: {track_index}")
|
||
else:
|
||
# Fallback to sequential numbering if no filename available
|
||
track.track_number = track_index
|
||
print(f" Using fallback sequential track number (no filename): {track_index}")
|
||
|
||
# Clean up track title - remove artist prefix if present
|
||
clean_track_title = self._clean_track_title(track.title, artist.name)
|
||
track.title = clean_track_title
|
||
|
||
print(f" Track {track_index}: '{clean_track_title}' -> Artist: '{artist.name}', Album: '{clean_album_title}', Track#: {track.track_number}")
|
||
|
||
# Start downloading all tracks with matched artist immediately
|
||
import time
|
||
download_items = []
|
||
for track_index, track in enumerate(album_result.tracks, 1):
|
||
print(f"Starting download {track_index}/{len(album_result.tracks)}: {track.title}")
|
||
download_item = self._start_download_with_artist(track, artist)
|
||
if download_item:
|
||
download_items.append(download_item)
|
||
# Small delay between downloads to avoid overwhelming Soulseek
|
||
time.sleep(0.1)
|
||
|
||
print(f"Successfully queued {len(download_items)}/{len(album_result.tracks)} tracks with matched artist")
|
||
|
||
# Pre-calculate and cache the album name to ensure consistency
|
||
if download_items:
|
||
self._ensure_album_consistency(download_items, artist, clean_album_title)
|
||
|
||
print(f"Queued {len(album_result.tracks)} tracks for matched download from album: {album_result.album_title}")
|
||
print(f"All tracks have album context preserved: '{album_result.album_title}'")
|
||
|
||
except Exception as e:
|
||
print(f"Error handling matched album download: {e}")
|
||
# Fallback to normal album download
|
||
self.start_album_download(album_result)
|
||
|
||
def _handle_matched_album_download_v2(self, album_result, artist: Artist):
|
||
"""OPTIMIZATION v2: Handle album download with non-blocking batch processing"""
|
||
try:
|
||
|
||
# Set bulk operation flag for adaptive polling
|
||
self._bulk_operation_active = True
|
||
|
||
# Clean up the album title
|
||
clean_album_title = self._clean_album_title(album_result.album_title, artist.name)
|
||
|
||
# Prepare all tracks with metadata (no blocking operations)
|
||
prepared_tracks = []
|
||
for track_index, track in enumerate(album_result.tracks, 1):
|
||
track.matched_artist = artist
|
||
track.album = clean_album_title
|
||
|
||
# Extract track number without blocking
|
||
if hasattr(track, 'filename'):
|
||
import os
|
||
filename = os.path.basename(track.filename)
|
||
original_track_num = self._extract_track_number_from_filename(filename, track.title)
|
||
if original_track_num:
|
||
track.track_number = original_track_num
|
||
else:
|
||
track.track_number = track_index
|
||
else:
|
||
track.track_number = track_index
|
||
|
||
prepared_tracks.append(track)
|
||
|
||
# Use background thread pool for batch download initiation
|
||
def batch_download_tracks():
|
||
download_items = []
|
||
for track_index, track in enumerate(prepared_tracks, 1):
|
||
try:
|
||
download_item = self._start_download_with_artist(track, artist)
|
||
if download_item:
|
||
download_items.append(download_item)
|
||
# No sleep - let the system handle queuing naturally
|
||
except Exception as e:
|
||
print(f"Failed to start download for track {track.title}: {e}")
|
||
|
||
# Ensure album consistency in background
|
||
if download_items:
|
||
self._ensure_album_consistency(download_items, artist, clean_album_title)
|
||
|
||
# Reset bulk operation flag
|
||
self._bulk_operation_active = False
|
||
|
||
print(f"Queued {len(download_items)}/{len(prepared_tracks)} tracks")
|
||
return download_items
|
||
|
||
# Submit to optimized thread pool
|
||
self._optimized_api_pool.submit(batch_download_tracks)
|
||
|
||
except Exception as e:
|
||
print(f"Optimized album download failed: {e}")
|
||
self._bulk_operation_active = False
|
||
# Fallback to original method
|
||
self._handle_matched_album_download(album_result, artist)
|
||
|
||
def _handle_matched_album_download_with_album(self, album_result, artist: Artist, selected_album: Album):
|
||
"""Handle the album download after both artist and album selection from modal"""
|
||
try:
|
||
print(f"Starting matched album download with FORCED album selection")
|
||
print(f" Original album: '{album_result.album_title}'")
|
||
print(f" Selected artist: '{artist.name}'")
|
||
print(f" Selected album: '{selected_album.name}'")
|
||
print(f" ALL tracks will be forced into: '{selected_album.name}'")
|
||
|
||
# Fetch official track titles from Spotify album
|
||
print(f"Fetching official track titles from Spotify album...")
|
||
spotify_tracks = self._get_spotify_album_tracks(selected_album)
|
||
|
||
download_items = []
|
||
|
||
# Process all tracks and FORCE them into the selected album
|
||
for track_index, track in enumerate(album_result.tracks, 1):
|
||
track.matched_artist = artist
|
||
track.album = selected_album.name # FORCE album name
|
||
track.matched_album = selected_album # Store the full album object
|
||
track._force_album_name = selected_album.name # Flag to prevent album detection override
|
||
track._force_album_mode = True # Flag to skip individual Spotify lookups
|
||
|
||
# Extract original track number from filename
|
||
if hasattr(track, 'filename'):
|
||
import os
|
||
filename = os.path.basename(track.filename)
|
||
original_track_num = self._extract_track_number_from_filename(filename, track.title)
|
||
if original_track_num:
|
||
track.track_number = original_track_num
|
||
else:
|
||
track.track_number = track_index
|
||
|
||
# Match to Spotify track title if available
|
||
spotify_title = self._match_track_to_spotify_title(track, spotify_tracks)
|
||
if spotify_title:
|
||
print(f" Track {track_index}: '{track.title}' -> Spotify title: '{spotify_title}'")
|
||
track._spotify_title = spotify_title # Store the official Spotify title
|
||
track._spotify_clean_title = spotify_title # This will be used for file naming
|
||
else:
|
||
print(f" Track {track_index}: '{track.title}' -> No Spotify match found, using original")
|
||
|
||
print(f" FORCED into Album: {selected_album.name}")
|
||
|
||
# Start individual track download with enhanced metadata
|
||
download_item = self._start_download_with_artist(track, artist)
|
||
if download_item:
|
||
# Also apply the forced album to the download item
|
||
download_item._force_album_name = selected_album.name
|
||
download_item._force_album_mode = True
|
||
|
||
# Apply Spotify title to download item if available
|
||
if hasattr(track, '_spotify_clean_title'):
|
||
download_item._spotify_clean_title = track._spotify_clean_title
|
||
print(f"Applied Spotify title to download item: '{track._spotify_clean_title}'")
|
||
|
||
download_items.append(download_item)
|
||
print(f"Successfully queued track: {track.title}")
|
||
else:
|
||
print(f"Failed to queue track: {track.title}")
|
||
|
||
# Ensure all download items have consistent album information
|
||
for download_item in download_items:
|
||
if hasattr(download_item, 'matched_artist'):
|
||
download_item._force_album_name = selected_album.name
|
||
download_item._force_album_mode = True
|
||
|
||
print(f"Queued {len(album_result.tracks)} tracks for matched download - ALL FORCED into album: {selected_album.name}")
|
||
|
||
except Exception as e:
|
||
print(f"Error handling matched album download with album selection: {e}")
|
||
# Fallback to normal album download
|
||
self.start_album_download(album_result)
|
||
|
||
def _assign_matched_artist_to_album_downloads(self, album_result, artist: Artist):
|
||
"""Assign matched artist to all download items for an album"""
|
||
try:
|
||
print(f"Assigning matched artist '{artist.name}' to all album download items")
|
||
print(f"Album has {len(album_result.tracks)} tracks")
|
||
print(f"Current download queue has {len(self.download_queue.download_items)} items")
|
||
|
||
assigned_count = 0
|
||
|
||
# Find download items for all tracks in this album
|
||
for track_idx, track in enumerate(album_result.tracks):
|
||
print(f"Looking for track {track_idx + 1}: '{track.title}' by '{track.artist}'")
|
||
|
||
matched = False
|
||
for download_item in self.download_queue.download_items:
|
||
if (hasattr(download_item, 'title') and download_item.title == track.title and
|
||
hasattr(download_item, 'artist') and download_item.artist == track.artist):
|
||
download_item.matched_artist = artist
|
||
assigned_count += 1
|
||
print(f" Assigned to: {download_item.title}")
|
||
matched = True
|
||
break
|
||
|
||
if not matched:
|
||
print(f" Could not find download item for: {track.title}")
|
||
# Try a more lenient search
|
||
for download_item in self.download_queue.download_items:
|
||
if (hasattr(download_item, 'title') and
|
||
self.matching_engine.normalize_string(download_item.title) == self.matching_engine.normalize_string(track.title)):
|
||
download_item.matched_artist = artist
|
||
assigned_count += 1
|
||
print(f" Assigned to: {download_item.title} (lenient match)")
|
||
matched = True
|
||
break
|
||
|
||
if not matched:
|
||
print(f" Still could not find download item for: {track.title}")
|
||
|
||
print(f"Successfully assigned matched artist to {assigned_count}/{len(album_result.tracks)} album tracks")
|
||
|
||
# If we didn't assign to all tracks, let's try again with a longer delay
|
||
if assigned_count < len(album_result.tracks):
|
||
print(f"⏰ Some assignments failed, will retry in 1 second...")
|
||
QTimer.singleShot(1000, lambda: self._retry_album_assignment(album_result, artist, assigned_count))
|
||
|
||
except Exception as e:
|
||
print(f"Error assigning matched artist to album download items: {e}")
|
||
|
||
def _retry_album_assignment(self, album_result, artist: Artist, previous_count: int):
|
||
"""Retry assignment for album tracks that failed the first time"""
|
||
try:
|
||
print(f"Retrying album assignment for remaining tracks...")
|
||
new_assigned = 0
|
||
|
||
for track in album_result.tracks:
|
||
# Only try to assign if not already assigned
|
||
found_assigned = False
|
||
for download_item in self.download_queue.download_items:
|
||
if (hasattr(download_item, 'title') and download_item.title == track.title and
|
||
hasattr(download_item, 'matched_artist') and download_item.matched_artist):
|
||
found_assigned = True
|
||
break
|
||
|
||
if not found_assigned:
|
||
# Try to find and assign
|
||
for download_item in self.download_queue.download_items:
|
||
if (hasattr(download_item, 'title') and
|
||
self.matching_engine.normalize_string(download_item.title) == self.matching_engine.normalize_string(track.title)):
|
||
download_item.matched_artist = artist
|
||
new_assigned += 1
|
||
print(f" Retry assigned to: {download_item.title}")
|
||
break
|
||
|
||
total_assigned = previous_count + new_assigned
|
||
print(f"Retry complete: {total_assigned}/{len(album_result.tracks)} tracks now assigned")
|
||
|
||
except Exception as e:
|
||
print(f"Error in retry assignment: {e}")
|
||
|
||
def _handle_modal_cancelled(self, search_result):
|
||
"""Handle when modal is cancelled for single track downloads"""
|
||
print(f"Modal cancelled for track: {search_result.title}")
|
||
# Re-enable any disabled download buttons for this track
|
||
# Since track downloads don't disable buttons, this is mainly for consistency
|
||
|
||
def _handle_album_modal_cancelled(self, album_result):
|
||
"""Handle when modal is cancelled for album downloads - re-enable buttons"""
|
||
print(f"Album modal cancelled for: {album_result.album_title}")
|
||
|
||
# Re-enable all track download buttons for this album
|
||
self._enable_album_track_buttons(album_result)
|
||
|
||
def _enable_album_track_buttons(self, album_result):
|
||
"""Re-enable all track download buttons for an album"""
|
||
try:
|
||
# Find the AlbumResultItem and re-enable its buttons
|
||
for i in range(self.search_results_layout.count()):
|
||
item = self.search_results_layout.itemAt(i)
|
||
if item and item.widget():
|
||
widget = item.widget()
|
||
if hasattr(widget, 'album_result') and widget.album_result == album_result:
|
||
# Re-enable the matched download button
|
||
if hasattr(widget, 'matched_download_btn'):
|
||
widget.matched_download_btn.setText("Download w/ Matching")
|
||
widget.matched_download_btn.setEnabled(True)
|
||
|
||
# Re-enable the regular download button
|
||
if hasattr(widget, 'download_btn'):
|
||
widget.download_btn.setText("⬇️ Download Album")
|
||
widget.download_btn.setEnabled(True)
|
||
|
||
print(f"Re-enabled buttons for album: {album_result.album_title}")
|
||
break
|
||
except Exception as e:
|
||
print(f"Error re-enabling album buttons: {e}")
|
||
|
||
|
||
def _cleanup_empty_directories(self, download_path, moved_file_path):
|
||
"""
|
||
Clean up empty directories left after moving a file, ignoring hidden files.
|
||
Walks up the directory tree until it finds a non-empty folder or the root download path.
|
||
"""
|
||
import os
|
||
|
||
try:
|
||
# Start with the directory that contained the moved file
|
||
# For you, this will be 'downloads/SomeAlbumFolder'
|
||
current_dir = os.path.dirname(moved_file_path)
|
||
|
||
# This loop will continue as long as the directory is inside the main download path
|
||
while current_dir != download_path and current_dir.startswith(download_path):
|
||
# Check if the directory is empty, IGNORING hidden files like .DS_Store
|
||
is_empty = True
|
||
for entry in os.listdir(current_dir):
|
||
if not entry.startswith('.'): # This is the key fix
|
||
is_empty = False
|
||
break
|
||
|
||
if is_empty:
|
||
print(f"Removing empty directory (ignoring hidden files): {current_dir}")
|
||
try:
|
||
os.rmdir(current_dir)
|
||
# After deleting, move up to the parent to check it too
|
||
current_dir = os.path.dirname(current_dir)
|
||
except OSError as e:
|
||
print(f"Warning: Could not remove directory {current_dir}: {e}")
|
||
break # Stop if we can't remove a directory
|
||
else:
|
||
# If the directory is not empty, the job is done.
|
||
print(f"Stopping cleanup at non-empty directory: {current_dir}")
|
||
break
|
||
|
||
except Exception as e:
|
||
print(f"Warning: An error occurred during directory cleanup: {e}")
|
||
|
||
|
||
def _organize_matched_download(self, download_item, original_file_path: str) -> Optional[str]:
|
||
"""Organize a matched download into the Transfer folder structure"""
|
||
try:
|
||
import os
|
||
import shutil
|
||
from pathlib import Path
|
||
|
||
if not hasattr(download_item, 'matched_artist'):
|
||
print("No matched artist information found")
|
||
return None
|
||
|
||
artist = download_item.matched_artist
|
||
print(f"Organizing download for artist: {artist.name}")
|
||
|
||
# --- FIX: Get transfer directory from config instead of hardcoding ---
|
||
# OLD CODE:
|
||
# project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
|
||
# transfer_dir = os.path.join(project_root, 'Transfer')
|
||
|
||
# NEW CODE:
|
||
transfer_dir = config_manager.get('soulseek.transfer_path', './Transfer')
|
||
os.makedirs(transfer_dir, exist_ok=True)
|
||
|
||
# Create artist directory
|
||
artist_dir = os.path.join(transfer_dir, self._sanitize_filename(artist.name))
|
||
os.makedirs(artist_dir, exist_ok=True)
|
||
|
||
# Determine if this is a single or album track
|
||
album_info = self._detect_album_info(download_item, artist)
|
||
|
||
# Resolve consistent album name for grouping tracks from same album
|
||
if album_info and album_info['is_album']:
|
||
print(f"\nSMART ALBUM GROUPING for track: '{download_item.title}'")
|
||
print(f" Original album: '{getattr(download_item, 'album', 'None')}'")
|
||
print(f" Detected album: '{album_info.get('album_name', 'None')}'")
|
||
|
||
consistent_album_name = self._resolve_album_group(download_item, artist, album_info)
|
||
album_info['album_name'] = consistent_album_name
|
||
|
||
print(f" Final album name: '{consistent_album_name}'")
|
||
print(f"Album grouping complete!\n")
|
||
|
||
if album_info and album_info['is_album']:
|
||
# Album track structure: Transfer/ARTIST/ARTIST - ALBUM/TRACK# TRACK.ext
|
||
print(f"Creating album folder:")
|
||
print(f" Artist name: '{artist.name}'")
|
||
print(f" Album name from album_info: '{album_info['album_name']}'")
|
||
print(f" Original download item title: '{download_item.title}'")
|
||
|
||
# Use the Spotify title information if available (most accurate for matched tracks)
|
||
clean_track_name = download_item.title
|
||
if hasattr(download_item, '_spotify_clean_title') and download_item._spotify_clean_title:
|
||
clean_track_name = download_item._spotify_clean_title
|
||
elif album_info.get('clean_track_name'):
|
||
clean_track_name = album_info['clean_track_name']
|
||
|
||
print(f" Clean track name to use: '{clean_track_name}'")
|
||
|
||
album_folder_name = f"{self._sanitize_filename(artist.name)} - {self._sanitize_filename(album_info['album_name'])}"
|
||
album_dir = os.path.join(artist_dir, album_folder_name)
|
||
os.makedirs(album_dir, exist_ok=True)
|
||
|
||
# Create track filename with number (just track number + clean title, NO artist)
|
||
file_ext = os.path.splitext(original_file_path)[1]
|
||
track_number = album_info.get('track_number', 1)
|
||
track_filename = f"{track_number:02d} - {self._sanitize_filename(clean_track_name)}{file_ext}"
|
||
new_file_path = os.path.join(album_dir, track_filename)
|
||
|
||
print(f"Album folder created: '{album_folder_name}'")
|
||
print(f"Track filename: '{track_filename}'")
|
||
|
||
else:
|
||
# Single track structure: Transfer/ARTIST/ARTIST - SINGLE/SINGLE.ext
|
||
# Use the Spotify title information if available (most accurate for matched tracks)
|
||
clean_track_name = download_item.title
|
||
if hasattr(download_item, '_spotify_clean_title') and download_item._spotify_clean_title:
|
||
clean_track_name = download_item._spotify_clean_title
|
||
elif album_info and album_info.get('clean_track_name'):
|
||
clean_track_name = album_info['clean_track_name']
|
||
|
||
print(f" Original download item title: '{download_item.title}'")
|
||
print(f" Clean track name to use: '{clean_track_name}'")
|
||
|
||
single_folder_name = f"{self._sanitize_filename(artist.name)} - {self._sanitize_filename(clean_track_name)}"
|
||
single_dir = os.path.join(artist_dir, single_folder_name)
|
||
os.makedirs(single_dir, exist_ok=True)
|
||
|
||
# Create single filename with clean track name
|
||
file_ext = os.path.splitext(original_file_path)[1]
|
||
single_filename = f"{self._sanitize_filename(clean_track_name)}{file_ext}"
|
||
new_file_path = os.path.join(single_dir, single_filename)
|
||
|
||
print(f"Single track: {single_folder_name}/{single_filename}")
|
||
|
||
# Check if source file exists, and try to find it if not
|
||
if not os.path.exists(original_file_path):
|
||
print(f"Source file not found: {original_file_path}")
|
||
|
||
# Try to find the file using different methods
|
||
found_file = self._find_downloaded_file(original_file_path, download_item)
|
||
if found_file:
|
||
print(f"Found file at: {found_file}")
|
||
original_file_path = found_file
|
||
else:
|
||
print(f"Could not locate downloaded file anywhere")
|
||
return None
|
||
|
||
# File organization and overwrite logic will be handled after metadata enhancement
|
||
|
||
# 🆕 METADATA ENHANCEMENT - Enhance BEFORE moving to avoid race conditions
|
||
if self._enhance_file_metadata(original_file_path, download_item, artist, album_info):
|
||
print(f"Metadata enhanced with Spotify data")
|
||
else:
|
||
print(f"Metadata enhancement failed, using original tags")
|
||
|
||
# Verify source file exists before attempting move
|
||
if not os.path.exists(original_file_path):
|
||
print(f"Source file not found: {original_file_path}")
|
||
return None
|
||
|
||
# Explicit overwrite: check if file exists, remove it, then move
|
||
if os.path.isfile(new_file_path):
|
||
os.remove(new_file_path)
|
||
|
||
# Move the enhanced file to destination
|
||
shutil.move(original_file_path, new_file_path)
|
||
|
||
# Verify the move was successful
|
||
if not os.path.exists(new_file_path):
|
||
print(f"File move failed - destination file not found: {new_file_path}")
|
||
return None
|
||
|
||
if os.path.exists(original_file_path):
|
||
try:
|
||
os.remove(original_file_path)
|
||
except Exception as cleanup_error:
|
||
print(f"Could not remove original file: {cleanup_error}")
|
||
|
||
# Clean up any empty directories left in the downloads folder
|
||
try:
|
||
downloads_path = config_manager.get('soulseek.download_path', './Downloads')
|
||
self._cleanup_empty_directories(downloads_path, original_file_path)
|
||
except Exception as cleanup_error:
|
||
print(f"Could not clean up empty directories: {cleanup_error}")
|
||
|
||
# Download cover art for both albums and singles
|
||
if album_info and album_info['is_album']:
|
||
# Album track - download to album directory
|
||
self._download_cover_art(artist, album_info, os.path.dirname(new_file_path))
|
||
else:
|
||
# Single track - create minimal album_info for cover art download
|
||
single_album_info = self._create_single_track_album_info(download_item, artist)
|
||
if single_album_info:
|
||
self._download_cover_art(artist, single_album_info, os.path.dirname(new_file_path))
|
||
|
||
# Generate LRC lyrics file at final location (elegant addition)
|
||
self._generate_lrc_file(new_file_path, download_item, artist, album_info)
|
||
|
||
print(f"Successfully organized matched download: {new_file_path}")
|
||
return new_file_path
|
||
|
||
except Exception as e:
|
||
print(f"Error organizing matched download: {e}")
|
||
return None
|
||
|
||
|
||
|
||
|
||
def _sanitize_filename(self, filename: str) -> str:
|
||
"""Sanitize filename for file system compatibility"""
|
||
import re
|
||
# Replace invalid characters with underscores
|
||
sanitized = re.sub(r'[<>:"/\\|?*]', '_', filename)
|
||
# Remove multiple spaces and trim
|
||
sanitized = re.sub(r'\s+', ' ', sanitized).strip()
|
||
# Windows forbids trailing dots/spaces on files and folders
|
||
sanitized = sanitized.rstrip('. ') or '_'
|
||
# Windows reserved device names
|
||
if re.match(r'^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\.|$)', sanitized, re.IGNORECASE):
|
||
sanitized = '_' + sanitized
|
||
# Limit length to avoid filesystem issues
|
||
return sanitized[:200] if len(sanitized) > 200 else sanitized
|
||
|
||
def _clean_album_title(self, album_title: str, artist_name: str) -> str:
|
||
"""Clean up album title by removing common prefixes, suffixes, and artist redundancy"""
|
||
import re
|
||
|
||
# Start with the original title
|
||
original = album_title.strip()
|
||
cleaned = original
|
||
print(f"Album Title Cleaning: '{original}' (artist: '{artist_name}')")
|
||
|
||
# Remove "Album - " prefix
|
||
cleaned = re.sub(r'^Album\s*-\s*', '', cleaned, flags=re.IGNORECASE)
|
||
|
||
# Remove artist name prefix if it appears at the beginning
|
||
# This handles cases like "Kendrick Lamar - good kid, m.A.A.d city"
|
||
artist_pattern = re.escape(artist_name) + r'\s*-\s*'
|
||
cleaned = re.sub(f'^{artist_pattern}', '', cleaned, flags=re.IGNORECASE)
|
||
|
||
# Remove common Soulseek suffixes in square brackets and parentheses
|
||
# Examples: [Deluxe Edition] [2012] [320 Kbps] [Album+iTunes+Bonus Tracks] [F10]
|
||
# (Deluxe Edition) (2012) (320 Kbps) etc.
|
||
# Remove year patterns like [2012], (2020), etc.
|
||
cleaned = re.sub(r'\s*[\[\(]\d{4}[\]\)]\s*', ' ', cleaned)
|
||
|
||
# Remove quality/format indicators
|
||
quality_patterns = [
|
||
r'\s*[\[\(][0-9]+\s*kbps[\]\)]\s*',
|
||
r'\s*[\[\(][0-9]+k[\]\)]\s*',
|
||
r'\s*[\[\(]320[\]\)]\s*',
|
||
r'\s*[\[\(]flac[\]\)]\s*',
|
||
r'\s*[\[\(]mp3[\]\)]\s*',
|
||
r'\s*[\[\(]wav[\]\)]\s*',
|
||
r'\s*[\[\(]lossless[\]\)]\s*'
|
||
]
|
||
for pattern in quality_patterns:
|
||
cleaned = re.sub(pattern, ' ', cleaned, flags=re.IGNORECASE)
|
||
|
||
# Remove source/torrent indicators
|
||
source_patterns = [
|
||
r'\s*[\[\(]album[\]\)]\s*',
|
||
r'\s*[\[\(]itunes[\]\)]\s*',
|
||
r'\s*[\[\(]spotify[\]\)]\s*',
|
||
r'\s*[\[\(]cd[\]\)]\s*',
|
||
r'\s*[\[\(]web[\]\)]\s*',
|
||
r'\s*[\[\(]f\d+[\]\)]\s*', # [F10], [F24], etc.
|
||
r'\s*[\[\(]bonus\s*tracks?[\]\)]\s*',
|
||
r'\s*[\[\(]remaster(ed)?[\]\)]\s*',
|
||
r'\s*[\[\(]clean[\]\)]\s*',
|
||
r'\s*[\[\(]explicit[\]\)]\s*',
|
||
r'\s*[\[\(]album\+itunes\+bonus\s*tracks?[\]\)]\s*', # [Album+iTunes+Bonus Tracks]
|
||
r'\s*[\[\(]itunes\+bonus[\]\)]\s*',
|
||
r'\s*[\[\(]bonus[\]\)]\s*'
|
||
]
|
||
for pattern in source_patterns:
|
||
cleaned = re.sub(pattern, ' ', cleaned, flags=re.IGNORECASE)
|
||
|
||
# Remove edition indicators but preserve meaningful ones like "Deluxe Edition"
|
||
# Only remove if they're standalone or with obvious non-meaningful text
|
||
cleaned = re.sub(r'\s*[\[\(](deluxe\s*edition|special\s*edition|expanded\s*edition)[\]\)]\s*', r' (\1)', cleaned, flags=re.IGNORECASE)
|
||
|
||
# Clean up multiple spaces, leading/trailing spaces and dashes
|
||
cleaned = re.sub(r'\s+', ' ', cleaned)
|
||
cleaned = re.sub(r'^[-\s]+', '', cleaned)
|
||
cleaned = re.sub(r'[-\s]+$', '', cleaned)
|
||
cleaned = cleaned.strip()
|
||
|
||
# If everything was removed, try a more conservative approach
|
||
if not cleaned or len(cleaned) < 3:
|
||
# Extract just the main album name before any brackets
|
||
fallback = re.split(r'[\[\(]', album_title)[0].strip()
|
||
# Remove artist prefix from fallback
|
||
fallback = re.sub(f'^{re.escape(artist_name)}\\s*-\\s*', '', fallback, flags=re.IGNORECASE)
|
||
cleaned = fallback.strip() if fallback.strip() else album_title
|
||
print(f"Album Title used fallback: '{fallback}'")
|
||
|
||
print(f"Album Title Result: '{original}' -> '{cleaned}'")
|
||
return cleaned
|
||
|
||
def _clean_track_title(self, track_title: str, artist_name: str) -> str:
|
||
"""Clean up track title by removing artist prefix and other unwanted elements"""
|
||
import re
|
||
|
||
# Start with the original title
|
||
original = track_title.strip()
|
||
cleaned = original
|
||
print(f"Track Title Cleaning: '{original}' (artist: '{artist_name}')")
|
||
|
||
# Remove track numbers from the beginning if present
|
||
# Handles cases like "01 - Track Name", "1. Track Name", "01. Track Name"
|
||
cleaned = re.sub(r'^\d{1,2}[\.\s\-]+', '', cleaned)
|
||
|
||
# Remove artist name prefix if it appears at the beginning
|
||
# This handles cases like "Kendrick Lamar - Track Name"
|
||
artist_pattern = re.escape(artist_name) + r'\s*-\s*'
|
||
cleaned = re.sub(f'^{artist_pattern}', '', cleaned, flags=re.IGNORECASE)
|
||
|
||
# Remove album name prefix if it appears (e.g., "GNX - 01 - wacced out murals")
|
||
# Look for pattern: "WORD - NUMBER - actual_title"
|
||
cleaned = re.sub(r'^[A-Za-z0-9\.]+\s*-\s*\d{1,2}\s*-\s*', '', cleaned)
|
||
|
||
# Remove common file quality indicators from track titles
|
||
quality_patterns = [
|
||
r'\s*[\[\(][0-9]+\s*kbps[\]\)]\s*',
|
||
r'\s*[\[\(]flac[\]\)]\s*',
|
||
r'\s*[\[\(]mp3[\]\)]\s*',
|
||
r'\s*[\[\(]320[\]\)]\s*'
|
||
]
|
||
for pattern in quality_patterns:
|
||
cleaned = re.sub(pattern, '', cleaned, flags=re.IGNORECASE)
|
||
|
||
# Clean up any remaining extra spaces, dashes, or dots at the start/end
|
||
cleaned = re.sub(r'^[-\s\.]+', '', cleaned)
|
||
cleaned = re.sub(r'[-\s\.]+$', '', cleaned)
|
||
cleaned = re.sub(r'\s+', ' ', cleaned).strip()
|
||
|
||
# If everything was removed, try more conservative approach
|
||
if not cleaned or len(cleaned) < 2:
|
||
# Remove just the most obvious prefixes
|
||
fallback = track_title.strip()
|
||
fallback = re.sub(r'^\d{1,2}[\.\s\-]+', '', fallback) # Remove track numbers
|
||
fallback = re.sub(f'^{re.escape(artist_name)}\\s*-\\s*', '', fallback, flags=re.IGNORECASE)
|
||
cleaned = fallback.strip() if fallback.strip() else track_title
|
||
print(f"Track Title used fallback: '{fallback}'")
|
||
|
||
print(f"Track Title Result: '{original}' -> '{cleaned}'")
|
||
return cleaned
|
||
|
||
def _resolve_album_group(self, download_item, artist: Artist, album_info: dict) -> str:
|
||
"""
|
||
Smart album grouping: Start with standard, upgrade to deluxe if ANY track is deluxe.
|
||
This ensures all tracks from the same album get the same folder name.
|
||
"""
|
||
try:
|
||
with self.album_cache_lock:
|
||
# Get the original album name from the download item (if it has one)
|
||
original_album = getattr(download_item, 'album', None)
|
||
detected_album = album_info.get('album_name', '')
|
||
|
||
# Extract base album name (without edition indicators)
|
||
if album_info.get('spotify_track'):
|
||
# Use Spotify album name for base
|
||
base_album = self._get_base_album_name(detected_album)
|
||
elif original_album:
|
||
# Clean the original Soulseek album name
|
||
cleaned_original = self._clean_album_title(original_album, artist.name)
|
||
base_album = self._get_base_album_name(cleaned_original)
|
||
else:
|
||
base_album = self._get_base_album_name(detected_album)
|
||
|
||
# Normalize the base name (handle case variations, etc.)
|
||
base_album = self._normalize_base_album_name(base_album, artist.name)
|
||
|
||
# Create a key for this album group (artist + base album)
|
||
album_key = f"{artist.name}::{base_album}"
|
||
|
||
# Check if we already have a cached result for this album
|
||
if album_key in self.album_name_cache:
|
||
cached_name = self.album_name_cache[album_key]
|
||
print(f"Using cached album name for '{album_key}': '{cached_name}'")
|
||
return cached_name
|
||
|
||
print(f"Album grouping - Key: '{album_key}', Detected: '{detected_album}'")
|
||
|
||
# Check if this track indicates a deluxe edition
|
||
is_deluxe_track = False
|
||
if album_info.get('spotify_track'):
|
||
is_deluxe_track = self._detect_deluxe_edition(detected_album)
|
||
elif original_album:
|
||
is_deluxe_track = self._detect_deluxe_edition(original_album)
|
||
|
||
# Get current edition level for this album group (default to standard)
|
||
current_edition = self.album_editions.get(album_key, "standard")
|
||
|
||
# SMART ALGORITHM: Upgrade to deluxe if this track is deluxe
|
||
if is_deluxe_track and current_edition == "standard":
|
||
print(f"UPGRADE: Album '{base_album}' upgraded from standard to deluxe!")
|
||
self.album_editions[album_key] = "deluxe"
|
||
current_edition = "deluxe"
|
||
|
||
# Build final album name based on edition level
|
||
if current_edition == "deluxe":
|
||
final_album_name = f"{base_album} (Deluxe Edition)"
|
||
else:
|
||
final_album_name = base_album
|
||
|
||
# Store the resolution in both caches
|
||
self.album_groups[album_key] = final_album_name
|
||
self.album_name_cache[album_key] = final_album_name
|
||
self.album_artists[album_key] = artist.name
|
||
|
||
print(f"Album resolution: '{detected_album}' -> '{final_album_name}' (edition: {current_edition})")
|
||
|
||
return final_album_name
|
||
|
||
except Exception as e:
|
||
print(f"Error resolving album group: {e}")
|
||
return album_info.get('album_name', download_item.title)
|
||
|
||
def _normalize_base_album_name(self, base_album: str, artist_name: str) -> str:
|
||
"""
|
||
Normalize the base album name to handle case variations and known corrections.
|
||
"""
|
||
import re
|
||
|
||
# Apply known album corrections for consistent naming
|
||
normalized_lower = base_album.lower().strip()
|
||
|
||
known_corrections = {
|
||
'good kid maad city': 'good kid, m.A.A.d city',
|
||
'good kid m.a.a.d city': 'good kid, m.A.A.d city',
|
||
'good kid m.a.a.d. city': 'good kid, m.A.A.d city',
|
||
'good kid m a a d city': 'good kid, m.A.A.d city',
|
||
'good kid m.a.a.d city': 'good kid, m.A.A.d city'
|
||
}
|
||
|
||
for key, correction in known_corrections.items():
|
||
if key == normalized_lower:
|
||
print(f"Base album correction: '{base_album}' -> '{correction}'")
|
||
return correction
|
||
|
||
# If no specific correction, return cleaned version
|
||
return base_album.strip()
|
||
|
||
def _normalize_spotify_album_variants(self, album_name: str, artist_name: str) -> str:
|
||
"""
|
||
Normalize different Spotify album variants to a consistent name.
|
||
E.g., 'good kid, m.A.A.d city' and 'good kid, m.A.A.d city (Deluxe)'
|
||
should both resolve to 'good kid, m.A.A.d city (Deluxe Edition)'
|
||
"""
|
||
import re
|
||
|
||
normalized = album_name.strip()
|
||
|
||
# Convert various deluxe indicators to standard format
|
||
deluxe_patterns = [
|
||
(r'\s*\(deluxe\)\s*$', ' (Deluxe Edition)'),
|
||
(r'\s*\[deluxe\]\s*$', ' (Deluxe Edition)'),
|
||
(r'\s*deluxe\s*$', ' (Deluxe Edition)'),
|
||
(r'\s*\(deluxe\s+edition\)\s*$', ' (Deluxe Edition)'),
|
||
(r'\s*\[deluxe\s+edition\]\s*$', ' (Deluxe Edition)')
|
||
]
|
||
|
||
for pattern, replacement in deluxe_patterns:
|
||
if re.search(pattern, normalized, re.IGNORECASE):
|
||
normalized = re.sub(pattern, replacement, normalized, flags=re.IGNORECASE)
|
||
break
|
||
|
||
# Normalize case inconsistencies for known albums
|
||
# This handles cases like "good kid, m.A.A.d city" vs "Good Kid M.A.A.D City"
|
||
known_album_corrections = {
|
||
'good kid maad city': 'good kid, m.A.A.d city',
|
||
'good kid m.a.a.d city': 'good kid, m.A.A.d city',
|
||
'good kid m.a.a.d. city': 'good kid, m.A.A.d city',
|
||
'good kid m.a.a.d city': 'good kid, m.A.A.d city',
|
||
'good kid m a a d city': 'good kid, m.A.A.d city'
|
||
}
|
||
|
||
normalized_lower = normalized.lower()
|
||
for key, correction in known_album_corrections.items():
|
||
if key in normalized_lower:
|
||
# Preserve any edition suffix
|
||
suffix = ''
|
||
if '(deluxe edition)' in normalized_lower:
|
||
suffix = ' (Deluxe Edition)'
|
||
elif '(deluxe)' in normalized_lower:
|
||
suffix = ' (Deluxe Edition)'
|
||
|
||
normalized = correction + suffix
|
||
break
|
||
|
||
print(f"Album variant normalization: '{album_name}' -> '{normalized}'")
|
||
return normalized
|
||
|
||
def _detect_deluxe_edition(self, album_name: str) -> bool:
|
||
"""
|
||
Detect if an album name indicates a deluxe/special edition.
|
||
Returns True if it's a deluxe variant, False for standard.
|
||
"""
|
||
if not album_name:
|
||
return False
|
||
|
||
album_lower = album_name.lower()
|
||
|
||
# Check for deluxe indicators
|
||
deluxe_indicators = [
|
||
'deluxe',
|
||
'deluxe edition',
|
||
'special edition',
|
||
'expanded edition',
|
||
'extended edition',
|
||
'bonus',
|
||
'remastered',
|
||
'anniversary',
|
||
'collectors edition',
|
||
'limited edition'
|
||
]
|
||
|
||
for indicator in deluxe_indicators:
|
||
if indicator in album_lower:
|
||
print(f"Detected deluxe edition: '{album_name}' contains '{indicator}'")
|
||
return True
|
||
|
||
return False
|
||
|
||
def _get_base_album_name(self, album_name: str) -> str:
|
||
"""
|
||
Extract the base album name without edition indicators.
|
||
E.g., 'good kid, m.A.A.d city (Deluxe Edition)' -> 'good kid, m.A.A.d city'
|
||
"""
|
||
import re
|
||
|
||
# Remove common edition suffixes
|
||
base_name = album_name
|
||
|
||
# Remove edition indicators in parentheses or brackets
|
||
base_name = re.sub(r'\s*[\[\(](deluxe|special|expanded|extended|bonus|remastered|anniversary|collectors?|limited).*?[\]\)]\s*$', '', base_name, flags=re.IGNORECASE)
|
||
|
||
# Remove standalone edition words at the end
|
||
base_name = re.sub(r'\s+(deluxe|special|expanded|extended|bonus|remastered|anniversary|collectors?|limited)\s*(edition)?\s*$', '', base_name, flags=re.IGNORECASE)
|
||
|
||
return base_name.strip()
|
||
|
||
def _detect_album_info(self, download_item, artist: Artist) -> Optional[dict]:
|
||
"""Detect if track is part of an album using Spotify API as primary source"""
|
||
try:
|
||
print(f"Album detection for '{download_item.title}' by '{artist.name}':")
|
||
print(f" Has album attr: {hasattr(download_item, 'album')}")
|
||
if hasattr(download_item, 'album'):
|
||
print(f" Album value: '{download_item.album}'")
|
||
|
||
# CHECK FOR FORCED ALBUM MODE FIRST
|
||
if hasattr(download_item, '_force_album_mode') and download_item._force_album_mode:
|
||
print(f"FORCED ALBUM MODE DETECTED - Using forced album name")
|
||
forced_album = getattr(download_item, '_force_album_name', 'Unknown Album')
|
||
print(f" Forced album: '{forced_album}'")
|
||
|
||
# Try to get album image URL from matched_album if available
|
||
album_image_url = None
|
||
if hasattr(download_item, 'matched_album') and download_item.matched_album:
|
||
album_image_url = download_item.matched_album.image_url
|
||
|
||
return {
|
||
'is_album': True,
|
||
'album_name': forced_album,
|
||
'track_number': getattr(download_item, 'track_number', 1),
|
||
'clean_track_name': download_item.title,
|
||
'confidence': 1.0, # 100% confidence since it's forced
|
||
'source': 'forced_user_selection',
|
||
'album_image_url': album_image_url
|
||
}
|
||
|
||
# PRIORITY 1: Try album-aware search if we have album context
|
||
if hasattr(download_item, 'album') and download_item.album and download_item.album.strip() and download_item.album != "Unknown Album":
|
||
print(f"ALBUM-AWARE SEARCH: Looking for '{download_item.title}' in album '{download_item.album}'")
|
||
album_result = self._search_track_in_album_context(download_item, artist)
|
||
if album_result:
|
||
print(f"Found track in album context - using album classification")
|
||
return album_result
|
||
else:
|
||
print(f"Track not found in album context, falling back to individual search")
|
||
|
||
# PRIORITY 2: Fallback to individual track search for clean metadata
|
||
print(f"Searching Spotify for individual track info (PRIORITY 2)...")
|
||
|
||
# Clean the track title before searching - remove artist prefix
|
||
clean_title = self._clean_track_title(download_item.title, artist.name)
|
||
print(f"Cleaned title: '{download_item.title}' -> '{clean_title}'")
|
||
|
||
# Search for the track by artist and cleaned title
|
||
query = f"artist:{artist.name} track:{clean_title}"
|
||
tracks = self.spotify_client.search_tracks(query, limit=5)
|
||
|
||
# Find the best matching track
|
||
best_match = None
|
||
best_confidence = 0
|
||
|
||
if tracks:
|
||
for track in tracks:
|
||
# Calculate confidence based on artist and title similarity
|
||
artist_confidence = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(artist.name),
|
||
self.matching_engine.normalize_string(track.artists[0])
|
||
)
|
||
title_confidence = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(clean_title),
|
||
self.matching_engine.normalize_string(track.name)
|
||
)
|
||
|
||
combined_confidence = (artist_confidence * 0.6 + title_confidence * 0.4)
|
||
|
||
if combined_confidence > best_confidence and combined_confidence > 0.6: # Lower threshold for better matches
|
||
best_match = track
|
||
best_confidence = combined_confidence
|
||
|
||
# If we found a good Spotify match, use it for clean metadata
|
||
if best_match and best_confidence > 0.6:
|
||
print(f"Found matching Spotify track: '{best_match.name}' - Album: '{best_match.album}' (confidence: {best_confidence:.2f})")
|
||
|
||
# Get detailed track information using Spotify's track API
|
||
detailed_track = None
|
||
if hasattr(best_match, 'id') and best_match.id:
|
||
print(f"Getting detailed track info from Spotify API for track ID: {best_match.id}")
|
||
detailed_track = self.spotify_client.get_track_details(best_match.id)
|
||
|
||
# Use detailed track data if available
|
||
if detailed_track:
|
||
print(f"Got detailed track data from Spotify API")
|
||
album_name = self._clean_album_title(detailed_track['album']['name'], artist.name)
|
||
clean_track_name = detailed_track['name'] # Use Spotify's clean track name
|
||
album_type = detailed_track['album'].get('album_type', 'album')
|
||
total_tracks = detailed_track['album'].get('total_tracks', 1)
|
||
spotify_track_number = detailed_track.get('track_number', 1)
|
||
|
||
print(f"Spotify album info: '{album_name}' (type: {album_type}, total_tracks: {total_tracks}, track#: {spotify_track_number})")
|
||
print(f"Clean track name from Spotify: '{clean_track_name}'")
|
||
|
||
# Enhanced album detection using detailed API data
|
||
is_album = (
|
||
# Album type is 'album' (not 'single')
|
||
album_type == 'album' and
|
||
# Album has multiple tracks
|
||
total_tracks > 1 and
|
||
# Album name different from track name
|
||
self.matching_engine.normalize_string(album_name) != self.matching_engine.normalize_string(clean_track_name) and
|
||
# Album name is not just the artist name
|
||
self.matching_engine.normalize_string(album_name) != self.matching_engine.normalize_string(artist.name)
|
||
)
|
||
|
||
track_num = spotify_track_number
|
||
print(f"Using Spotify track number: {track_num}")
|
||
|
||
# Store the clean Spotify track name for use in file organization (only if not already set)
|
||
if not hasattr(download_item, '_spotify_clean_title') or not download_item._spotify_clean_title:
|
||
download_item._spotify_clean_title = clean_track_name
|
||
download_item._spotify_clean_album = album_name
|
||
|
||
# Extract album image URL from detailed track data
|
||
album_image_url = None
|
||
if detailed_track.get('album', {}).get('images'):
|
||
# Get the largest image (first one in Spotify's array)
|
||
album_image_url = detailed_track['album']['images'][0]['url']
|
||
|
||
if is_album:
|
||
print(f"Spotify detection: Album track - '{album_name}'")
|
||
return {
|
||
'is_album': True,
|
||
'album_name': album_name,
|
||
'track_number': track_num,
|
||
'spotify_track': best_match,
|
||
'clean_track_name': clean_track_name,
|
||
'album_image_url': album_image_url
|
||
}
|
||
else:
|
||
print(f"Spotify detection: Single track - using clean track name")
|
||
return {
|
||
'is_album': False,
|
||
'album_name': clean_track_name, # Use clean track name for single structure
|
||
'track_number': 1,
|
||
'spotify_track': best_match,
|
||
'clean_track_name': clean_track_name,
|
||
'album_image_url': album_image_url
|
||
}
|
||
|
||
else:
|
||
print(f"Could not get detailed track data, using basic Spotify search data")
|
||
album_name = self._clean_album_title(best_match.album, artist.name)
|
||
clean_track_name = best_match.name
|
||
|
||
# Fallback album detection logic
|
||
is_album = (
|
||
# Album name different from track name (indicates multi-track album)
|
||
self.matching_engine.normalize_string(album_name) != self.matching_engine.normalize_string(clean_track_name) and
|
||
# Album name doesn't contain "single" or similar terms
|
||
not any(term in album_name.lower() for term in ['single', 'ep']) and
|
||
# Album name is not just the artist name
|
||
self.matching_engine.normalize_string(album_name) != self.matching_engine.normalize_string(artist.name)
|
||
)
|
||
|
||
# Get track number from metadata or filename as fallback
|
||
track_num = self._extract_track_number(download_item)
|
||
|
||
# Only set if not already set (preserve original Spotify title from modal)
|
||
if not hasattr(download_item, '_spotify_clean_title') or not download_item._spotify_clean_title:
|
||
download_item._spotify_clean_title = clean_track_name
|
||
download_item._spotify_clean_album = album_name
|
||
|
||
# Try to get album image URL from matched_album if available
|
||
album_image_url = None
|
||
if hasattr(download_item, 'matched_album') and download_item.matched_album:
|
||
album_image_url = download_item.matched_album.image_url
|
||
|
||
return {
|
||
'is_album': is_album,
|
||
'album_name': album_name if is_album else clean_track_name,
|
||
'track_number': track_num if is_album else 1,
|
||
'spotify_track': best_match,
|
||
'clean_track_name': clean_track_name,
|
||
'album_image_url': album_image_url
|
||
}
|
||
|
||
# PRIORITY 3: Fallback to Soulseek album context if Spotify search failed
|
||
print(f"No good Spotify match found (confidence: {best_confidence:.2f}), checking Soulseek album context...")
|
||
|
||
if hasattr(download_item, 'album') and download_item.album and download_item.album != "Unknown Album":
|
||
clean_album = self._clean_album_title(download_item.album, artist.name)
|
||
clean_title = self._clean_track_title(download_item.title, artist.name)
|
||
track_num = self._extract_track_number(download_item)
|
||
|
||
print(f"Using cleaned Soulseek album context: '{clean_album}' (cleaned from '{download_item.album}')")
|
||
print(f"Cleaned track title: '{clean_title}' (cleaned from '{download_item.title}')")
|
||
|
||
# Only set if not already set (preserve original Spotify title from modal)
|
||
if not hasattr(download_item, '_spotify_clean_title') or not download_item._spotify_clean_title:
|
||
download_item._spotify_clean_title = clean_title
|
||
download_item._spotify_clean_album = clean_album
|
||
|
||
# Try to get album image URL from matched_album if available
|
||
album_image_url = None
|
||
if hasattr(download_item, 'matched_album') and download_item.matched_album:
|
||
album_image_url = download_item.matched_album.image_url
|
||
|
||
return {
|
||
'is_album': True,
|
||
'album_name': clean_album,
|
||
'track_number': track_num,
|
||
'spotify_track': None,
|
||
'clean_track_name': clean_title,
|
||
'album_image_url': album_image_url
|
||
}
|
||
|
||
# PRIORITY 4: Complete fallback - single track with cleaned title
|
||
print(f"No album context found, defaulting to single track structure with cleaned title")
|
||
clean_title = self._clean_track_title(download_item.title, artist.name)
|
||
|
||
# Only set if not already set (preserve original Spotify title from modal)
|
||
if not hasattr(download_item, '_spotify_clean_title') or not download_item._spotify_clean_title:
|
||
download_item._spotify_clean_title = clean_title
|
||
|
||
# Try to get album image URL from matched_album if available
|
||
album_image_url = None
|
||
if hasattr(download_item, 'matched_album') and download_item.matched_album:
|
||
album_image_url = download_item.matched_album.image_url
|
||
|
||
return {
|
||
'is_album': False,
|
||
'album_name': clean_title, # Use clean track name as single name
|
||
'track_number': 1,
|
||
'spotify_track': None,
|
||
'clean_track_name': clean_title,
|
||
'album_image_url': album_image_url
|
||
}
|
||
|
||
except Exception as e:
|
||
print(f"Error detecting album info: {e}")
|
||
# Emergency fallback to single structure with basic cleaning
|
||
clean_title = self._clean_track_title(download_item.title, artist.name)
|
||
|
||
# Try to get album image URL from matched_album if available
|
||
album_image_url = None
|
||
if hasattr(download_item, 'matched_album') and download_item.matched_album:
|
||
album_image_url = download_item.matched_album.image_url
|
||
|
||
return {
|
||
'is_album': False,
|
||
'album_name': clean_title,
|
||
'track_number': 1,
|
||
'spotify_track': None,
|
||
'clean_track_name': clean_title,
|
||
'album_image_url': album_image_url
|
||
}
|
||
|
||
def _search_track_in_album_context(self, download_item, artist: Artist) -> Optional[dict]:
|
||
"""Search for a track within its album context to avoid promotional single confusion"""
|
||
try:
|
||
album_name = download_item.album
|
||
track_title = download_item.title
|
||
|
||
print(f"Album-aware search: '{track_title}' in album '{album_name}' by '{artist.name}'")
|
||
|
||
# Clean the album name for better search results
|
||
clean_album = self._clean_album_title(album_name, artist.name)
|
||
clean_track = self._clean_track_title(track_title, artist.name)
|
||
|
||
# Search for the specific album first
|
||
album_query = f"album:{clean_album} artist:{artist.name}"
|
||
print(f"Searching albums: {album_query}")
|
||
albums = self.spotify_client.search_albums(album_query, limit=5)
|
||
|
||
if not albums:
|
||
print(f"No albums found for query: {album_query}")
|
||
return None
|
||
|
||
# Check each album to see if our track is in it
|
||
for album in albums:
|
||
print(f"Checking album: '{album.name}' ({album.total_tracks} tracks)")
|
||
|
||
# Get tracks from this album
|
||
album_tracks_data = self.spotify_client.get_album_tracks(album.id)
|
||
if not album_tracks_data or 'items' not in album_tracks_data:
|
||
print(f"Could not get tracks for album: {album.name}")
|
||
continue
|
||
|
||
# Check if our track is in this album
|
||
for track_data in album_tracks_data['items']:
|
||
track_name = track_data['name']
|
||
track_number = track_data['track_number']
|
||
|
||
# Calculate similarity between our track and this album track
|
||
similarity = self.matching_engine.similarity_score(
|
||
self.matching_engine.normalize_string(clean_track),
|
||
self.matching_engine.normalize_string(track_name)
|
||
)
|
||
|
||
# Use higher threshold for remix matching to ensure precision
|
||
is_remix = any(word in clean_track.lower() for word in ['remix', 'mix', 'edit', 'version'])
|
||
threshold = 0.9 if is_remix else 0.7 # Much stricter for remixes
|
||
|
||
if similarity > threshold:
|
||
print(f"FOUND: '{track_name}' (track #{track_number}) matches '{clean_track}' (similarity: {similarity:.2f})")
|
||
print(f"Forcing album classification for track in '{album.name}'")
|
||
|
||
# Return album info - force album classification!
|
||
return {
|
||
'is_album': True, # Always true - we found it in an album!
|
||
'album_name': album.name,
|
||
'track_number': track_number,
|
||
'clean_track_name': clean_track, # Use the ORIGINAL download title, not the database match
|
||
'album_image_url': album.image_url,
|
||
'confidence': similarity,
|
||
'source': 'album_context_search'
|
||
}
|
||
|
||
print(f"Track '{clean_track}' not found in album '{album.name}'")
|
||
|
||
print(f"Track '{clean_track}' not found in any matching albums")
|
||
return None
|
||
|
||
except Exception as e:
|
||
print(f"Error in album-aware search: {e}")
|
||
return None
|
||
|
||
def _download_cover_art(self, artist: Artist, album_info: dict, target_dir: str):
|
||
"""Download cover art for the album, prioritizing album artwork from Spotify"""
|
||
try:
|
||
import requests
|
||
import os
|
||
|
||
cover_path = os.path.join(target_dir, "cover.jpg")
|
||
|
||
# Skip if cover already exists
|
||
if os.path.exists(cover_path):
|
||
print("Cover art already exists")
|
||
return
|
||
|
||
image_url = None
|
||
source_description = ""
|
||
|
||
# Priority 1: Use album artwork from album_info if available
|
||
if album_info.get('album_image_url'):
|
||
image_url = album_info['album_image_url']
|
||
source_description = f"album artwork for '{album_info.get('album_name', 'Unknown Album')}'"
|
||
print(f"Using album artwork from album_info")
|
||
|
||
# Priority 2: Try to get album artwork via Spotify search if we have album name
|
||
elif album_info.get('album_name') and hasattr(self, 'spotify_client'):
|
||
try:
|
||
print(f"Searching Spotify for album artwork: '{album_info['album_name']}' by '{artist.name}'")
|
||
# Search for the specific album
|
||
search_query = f"album:{album_info['album_name']} artist:{artist.name}"
|
||
albums = self.spotify_client.search_albums(search_query, limit=1)
|
||
|
||
if albums and len(albums) > 0:
|
||
album = albums[0]
|
||
if album.image_url:
|
||
image_url = album.image_url
|
||
source_description = f"Spotify album artwork for '{album.name}'"
|
||
print(f"Found album artwork via Spotify search")
|
||
else:
|
||
print(f"Album found but no image available")
|
||
else:
|
||
print(f"No album found in Spotify search")
|
||
except Exception as e:
|
||
print(f"Error searching Spotify for album artwork: {e}")
|
||
|
||
# Priority 3: Fall back to artist image
|
||
if not image_url and artist.image_url:
|
||
image_url = artist.image_url
|
||
source_description = f"artist image for '{artist.name}'"
|
||
print(f"Falling back to artist image")
|
||
|
||
# No image available
|
||
if not image_url:
|
||
print("No cover art available (no album artwork or artist image)")
|
||
return
|
||
|
||
print(f"Downloading {source_description} from: {image_url}")
|
||
response = requests.get(image_url, timeout=10)
|
||
response.raise_for_status()
|
||
|
||
with open(cover_path, 'wb') as f:
|
||
f.write(response.content)
|
||
|
||
print(f"Cover art downloaded: {cover_path}")
|
||
|
||
except Exception as e:
|
||
print(f"Error downloading cover art: {e}")
|
||
|
||
def _create_single_track_album_info(self, download_item, artist: Artist) -> Optional[dict]:
|
||
"""Create album_info dict for single track cover art download"""
|
||
try:
|
||
# Check if we have matched_album from Spotify matching
|
||
if hasattr(download_item, 'matched_album') and download_item.matched_album:
|
||
album = download_item.matched_album
|
||
print(f"Single track has matched album: '{album.name}' with image: {bool(album.image_url)}")
|
||
return {
|
||
'album_name': album.name,
|
||
'album_image_url': album.image_url,
|
||
'is_album': False, # This is still a single track
|
||
'track_number': 1,
|
||
'clean_track_name': download_item.title
|
||
}
|
||
|
||
# If no matched_album, try to detect from track title or existing album field
|
||
album_name = None
|
||
if hasattr(download_item, 'album') and download_item.album and download_item.album.strip():
|
||
album_name = download_item.album.strip()
|
||
print(f"Using album name from download_item: '{album_name}'")
|
||
else:
|
||
print(f"No album information available for single track")
|
||
return None
|
||
|
||
# Create basic album_info for cover art search
|
||
return {
|
||
'album_name': album_name,
|
||
'album_image_url': None, # Will be searched in _download_cover_art
|
||
'is_album': False, # This is still a single track
|
||
'track_number': 1,
|
||
'clean_track_name': download_item.title
|
||
}
|
||
|
||
except Exception as e:
|
||
print(f"Error creating single track album info: {e}")
|
||
return None
|
||
|
||
def _generate_lrc_file(self, file_path: str, download_item, artist, album_info: dict) -> bool:
|
||
"""
|
||
Generate LRC lyrics file using LRClib API.
|
||
Elegant addition to post-processing - extracts metadata from existing context.
|
||
"""
|
||
try:
|
||
# Initialize lyrics client if not already done
|
||
if not hasattr(self, 'lyrics_client'):
|
||
self.lyrics_client = LyricsClient()
|
||
|
||
if not self.lyrics_client:
|
||
return False
|
||
|
||
# Get track metadata from download_item
|
||
track_name = getattr(download_item, 'title', 'Unknown Track')
|
||
|
||
# Handle artist parameter (can be dict or object)
|
||
if isinstance(artist, dict):
|
||
artist_name = artist.get('name', 'Unknown Artist')
|
||
elif hasattr(artist, 'name'):
|
||
artist_name = artist.name
|
||
else:
|
||
artist_name = str(artist) if artist else 'Unknown Artist'
|
||
|
||
album_name = None
|
||
duration_seconds = None
|
||
|
||
# Get album name if available
|
||
if album_info and album_info.get('is_album'):
|
||
album_name = album_info.get('album_name')
|
||
|
||
# Get duration from download_item if available
|
||
if hasattr(download_item, 'duration') and download_item.duration:
|
||
try:
|
||
duration_seconds = int(download_item.duration)
|
||
except (ValueError, TypeError):
|
||
pass
|
||
|
||
# Generate LRC file using lyrics client
|
||
success = self.lyrics_client.create_lrc_file(
|
||
audio_file_path=file_path,
|
||
track_name=track_name,
|
||
artist_name=artist_name,
|
||
album_name=album_name,
|
||
duration_seconds=duration_seconds
|
||
)
|
||
|
||
if success:
|
||
print(f"LRC file generated for: {track_name}")
|
||
else:
|
||
print(f"No lyrics found for: {track_name}")
|
||
|
||
return success
|
||
|
||
except Exception as e:
|
||
print(f"Error generating LRC file for {file_path}: {e}")
|
||
return False
|
||
|
||
def _extract_track_number(self, download_item, spotify_track=None) -> int:
|
||
"""Extract track number from various sources"""
|
||
try:
|
||
print(f"Extracting track number for: '{download_item.title}'")
|
||
|
||
# Method 1: Check if download_item has track_number attribute (explicit metadata)
|
||
if hasattr(download_item, 'track_number') and download_item.track_number:
|
||
track_num = int(download_item.track_number)
|
||
print(f" Found track_number attribute: {track_num}")
|
||
return track_num
|
||
|
||
# Method 2: Parse from filename (e.g., "01. Track Name.mp3", "01 - Track Name.flac")
|
||
if hasattr(download_item, 'title'):
|
||
import re
|
||
# Look for patterns like "01. ", "01 ", "01-", "1. ", etc.
|
||
patterns = [
|
||
r'^(\d{1,2})[\.\s\-]+', # "01. " or "01 " or "01-"
|
||
r'(\d{1,2})\s*[\.\-]\s*', # "01." or "01-" with optional spaces
|
||
]
|
||
|
||
for pattern in patterns:
|
||
match = re.match(pattern, download_item.title.strip())
|
||
if match:
|
||
track_num = int(match.group(1))
|
||
print(f" Parsed from title pattern '{pattern}': {track_num}")
|
||
return track_num
|
||
|
||
# Method 3: Parse from filename if available
|
||
if hasattr(download_item, 'filename'):
|
||
import re
|
||
import os
|
||
# Get just the filename without extension and path
|
||
base_name = os.path.splitext(os.path.basename(download_item.filename))[0]
|
||
|
||
patterns = [
|
||
r'^(\d{1,2})[\.\s\-]+', # "01. " or "01 " or "01-"
|
||
r'(\d{1,2})\s*[\.\-]\s*', # "01." or "01-" with optional spaces
|
||
]
|
||
|
||
for pattern in patterns:
|
||
match = re.match(pattern, base_name.strip())
|
||
if match:
|
||
track_num = int(match.group(1))
|
||
print(f" Parsed from filename pattern '{pattern}': {track_num}")
|
||
return track_num
|
||
|
||
# Method 4: Get from Spotify track data (would need album API call)
|
||
if spotify_track:
|
||
# This would require additional Spotify API call to get full album
|
||
# For now, we'll skip this but could be enhanced later
|
||
print(f" Spotify track data available but not implemented yet")
|
||
pass
|
||
|
||
# Default to 1 if no track number found
|
||
print(f" No track number found, defaulting to 1")
|
||
return 1
|
||
|
||
except Exception as e:
|
||
print(f"Error extracting track number: {e}")
|
||
return 1
|
||
|
||
def _find_downloaded_file(self, original_file_path: str, download_item) -> Optional[str]:
|
||
"""Try to find the downloaded file using various methods"""
|
||
try:
|
||
import os
|
||
import glob
|
||
from pathlib import Path
|
||
|
||
print(f"Searching for downloaded file...")
|
||
print(f" Original path: {original_file_path}")
|
||
|
||
# Get the download directory
|
||
download_dir = self.soulseek_client.download_path if self.soulseek_client else './downloads'
|
||
print(f" Download directory: {download_dir}")
|
||
|
||
# Normalize path separators (convert Windows \\ to /)
|
||
normalized_path = original_file_path.replace('\\', '/')
|
||
|
||
# Extract filename from the API path
|
||
api_filename = os.path.basename(normalized_path)
|
||
print(f" Looking for filename: {api_filename}")
|
||
|
||
# Method 1: Try the exact path first (but normalized)
|
||
if os.path.exists(original_file_path):
|
||
print(f" Found exact path: {original_file_path}")
|
||
return original_file_path
|
||
|
||
# Method 2: Search in the download directory recursively
|
||
search_patterns = [
|
||
os.path.join(download_dir, "**", api_filename),
|
||
os.path.join(download_dir, "**", f"*{download_item.title}*"),
|
||
os.path.join(download_dir, "**", f"*{download_item.artist}*")
|
||
]
|
||
|
||
for pattern in search_patterns:
|
||
print(f" Searching pattern: {pattern}")
|
||
matches = glob.glob(pattern, recursive=True)
|
||
if matches:
|
||
# Filter for audio files
|
||
audio_extensions = {'.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav', '.m4a'}
|
||
audio_matches = [f for f in matches if os.path.splitext(f)[1].lower() in audio_extensions]
|
||
|
||
if audio_matches:
|
||
# Return the first match that exists and has reasonable size
|
||
for match in audio_matches:
|
||
if os.path.exists(match) and os.path.getsize(match) > 1024: # At least 1KB
|
||
print(f" Found match: {match}")
|
||
return match
|
||
|
||
# Method 3: Look for recently modified files in download directory
|
||
print(f" Searching for recent files in download directory...")
|
||
recent_files = []
|
||
audio_extensions = {'.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav', '.m4a'}
|
||
|
||
# Debug: List all files in download directory
|
||
print(f" Files in download directory:")
|
||
for root, dirs, files in os.walk(download_dir):
|
||
for file in files:
|
||
file_path = os.path.join(root, file)
|
||
rel_path = os.path.relpath(file_path, download_dir)
|
||
file_size = os.path.getsize(file_path) if os.path.exists(file_path) else 0
|
||
print(f" {rel_path} ({file_size} bytes)")
|
||
|
||
if os.path.splitext(file)[1].lower() in audio_extensions:
|
||
# Check if file was modified recently (within last 5 minutes)
|
||
import time
|
||
if time.time() - os.path.getmtime(file_path) < 300: # 5 minutes
|
||
recent_files.append((file_path, os.path.getmtime(file_path)))
|
||
|
||
# Sort by modification time (most recent first)
|
||
recent_files.sort(key=lambda x: x[1], reverse=True)
|
||
|
||
for file_path, _ in recent_files[:5]: # Check top 5 most recent
|
||
print(f" Checking recent file: {file_path}")
|
||
# Simple filename matching
|
||
if (download_item.title.lower() in os.path.basename(file_path).lower() or
|
||
download_item.artist.lower() in os.path.basename(file_path).lower()):
|
||
print(f" Found recent match: {file_path}")
|
||
return file_path
|
||
|
||
print(f" No matching files found")
|
||
return None
|
||
|
||
except Exception as e:
|
||
print(f"Error searching for downloaded file: {e}")
|
||
return None
|
||
|
||
def update_album_track_button_states(self, download_item, status):
|
||
"""Update track download button states based on download progress"""
|
||
|
||
# Find the track item that corresponds to this download
|
||
album_items_found = self.findChildren(AlbumResultItem)
|
||
|
||
for album_item in album_items_found:
|
||
|
||
for track_item in album_item.track_items:
|
||
track_title = track_item.track_result.title
|
||
track_artist = track_item.track_result.artist
|
||
|
||
|
||
# Match by track title and artist
|
||
if (track_title == download_item.title and track_artist == download_item.artist):
|
||
|
||
|
||
# Update button state based on download status
|
||
if status == 'downloading':
|
||
track_item.set_download_downloading_state()
|
||
print(f"[DEBUG] Set button to downloading state ()")
|
||
elif status in ['completed', 'finished']:
|
||
track_item.set_download_completed_state()
|
||
print(f"[DEBUG] Set button to completed state ()")
|
||
elif status in ['queued', 'initializing']:
|
||
track_item.set_download_queued_state()
|
||
print(f"[DEBUG] Set button to queued state ()")
|
||
elif status in ['failed', 'cancelled', 'canceled']:
|
||
track_item.reset_download_state() # Allow retry
|
||
print(f"[DEBUG] RESET button to downloadable state (⬇️) - track can now be downloaded again!")
|
||
else:
|
||
print(f"[DEBUG] Unknown status '{status}' - no button update performed")
|
||
|
||
return
|
||
|
||
|
||
def start_stream(self, search_result, result_item=None):
|
||
"""Start streaming a search result using StreamingThread or toggle if same track"""
|
||
try:
|
||
# Check if this is the same track that's currently playing
|
||
current_track_id = getattr(self, 'current_track_id', None)
|
||
new_track_id = f"{search_result.username}:{search_result.filename}"
|
||
|
||
print(f"start_stream() called for: {search_result.filename}")
|
||
print(f"Current track ID: {current_track_id}")
|
||
print(f"New track ID: {new_track_id}")
|
||
print(f"Currently playing button: {self.currently_playing_button}")
|
||
print(f"Result item: {result_item}")
|
||
print(f"Button match: {self.currently_playing_button == result_item}")
|
||
print(f"Track ID match: {current_track_id == new_track_id}")
|
||
|
||
if current_track_id == new_track_id and self.currently_playing_button == result_item:
|
||
# Same track clicked - toggle playback
|
||
print(f"Toggling playback for: {search_result.filename}")
|
||
|
||
toggle_result = self.audio_player.toggle_playback()
|
||
print(f"toggle_playback() returned: {toggle_result}")
|
||
|
||
if toggle_result:
|
||
# Now playing
|
||
result_item.set_playing_state()
|
||
self.track_resumed.emit()
|
||
print("Song card: Resumed playback")
|
||
else:
|
||
# Now paused
|
||
result_item.set_loading_state() # Use loading as "paused" state
|
||
self.track_paused.emit()
|
||
print("Song card: Paused playback")
|
||
|
||
return
|
||
else:
|
||
print(f"🆕 Different track or button - starting new stream")
|
||
|
||
print(f"Starting stream: {search_result.filename} from {search_result.username}")
|
||
|
||
# Different track - stop current and start new
|
||
if self.currently_playing_button:
|
||
self.audio_player.stop_playback()
|
||
try:
|
||
self.currently_playing_button.reset_play_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
|
||
# Stop any existing streaming threads AND cancel their downloads
|
||
self._stop_all_streaming_threads()
|
||
self._cancel_current_streaming_download_sync()
|
||
|
||
# Track the new currently playing button and track
|
||
self.currently_playing_button = result_item
|
||
self.current_track_id = new_track_id
|
||
self.current_track_result = search_result
|
||
|
||
# Clear Stream folder before starting new stream (release current file since we're switching)
|
||
self.clear_stream_folder(release_current_file=True)
|
||
|
||
# Check if file is a valid audio type
|
||
audio_extensions = ['.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav']
|
||
filename_lower = search_result.filename.lower()
|
||
|
||
is_audio = any(filename_lower.endswith(ext) for ext in audio_extensions)
|
||
|
||
if is_audio:
|
||
print(f"Streaming audio file: {search_result.filename}")
|
||
print(f" Quality: {search_result.quality}")
|
||
print(f" Size: {search_result.size // (1024*1024)}MB")
|
||
print(f" User: {search_result.username}")
|
||
|
||
# Track current streaming download for potential cancellation
|
||
self.current_streaming_download = {
|
||
'username': search_result.username,
|
||
'filename': search_result.filename,
|
||
'download_id': None # Will be set when download starts
|
||
}
|
||
print(f"Tracking new streaming download: {search_result.username}:{search_result.filename}")
|
||
|
||
# Create and start streaming thread
|
||
streaming_thread = StreamingThread(self.soulseek_client, search_result)
|
||
streaming_thread.streaming_started.connect(self.on_streaming_started, Qt.ConnectionType.QueuedConnection)
|
||
streaming_thread.streaming_finished.connect(self.on_streaming_finished, Qt.ConnectionType.QueuedConnection)
|
||
streaming_thread.streaming_progress.connect(self.on_streaming_progress, Qt.ConnectionType.QueuedConnection)
|
||
streaming_thread.streaming_queued.connect(self.on_streaming_queued, Qt.ConnectionType.QueuedConnection)
|
||
streaming_thread.streaming_failed.connect(self.on_streaming_failed, Qt.ConnectionType.QueuedConnection)
|
||
streaming_thread.finished.connect(
|
||
functools.partial(self.on_streaming_thread_finished, streaming_thread),
|
||
Qt.ConnectionType.QueuedConnection
|
||
)
|
||
|
||
# Track the streaming thread
|
||
if not hasattr(self, 'streaming_threads'):
|
||
self.streaming_threads = []
|
||
self.streaming_threads.append(streaming_thread)
|
||
|
||
# Start the streaming
|
||
streaming_thread.start()
|
||
|
||
else:
|
||
print(f"Cannot stream non-audio file: {search_result.filename}")
|
||
|
||
except Exception as e:
|
||
print(f"Failed to start stream: {str(e)}")
|
||
|
||
def on_streaming_started(self, message, search_result):
|
||
"""Handle streaming start"""
|
||
print(f"Streaming started: {message}")
|
||
# Set button to loading state while file is being prepared
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.set_loading_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
|
||
# Emit signal for media player loading animation
|
||
self.track_loading_started.emit(search_result)
|
||
|
||
def on_streaming_finished(self, message, search_result):
|
||
"""Handle streaming completion - start actual audio playback"""
|
||
print(f"Streaming finished: {message}")
|
||
|
||
# Check if this streaming result is for the currently requested track
|
||
# Prevent old downloads from interrupting new songs
|
||
if hasattr(self, 'current_track_result') and self.current_track_result:
|
||
current_track_id = f"{self.current_track_result.username}:{self.current_track_result.filename}"
|
||
finished_track_id = f"{search_result.username}:{search_result.filename}"
|
||
|
||
if current_track_id != finished_track_id:
|
||
print(f"Ignoring old streaming result for: {search_result.filename}")
|
||
print(f" Current track: {current_track_id}")
|
||
print(f" Finished track: {finished_track_id}")
|
||
return
|
||
|
||
try:
|
||
# Find the stream file in the Stream folder
|
||
project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__))) # Go up from ui/pages/
|
||
stream_folder = os.path.join(project_root, 'Stream')
|
||
|
||
# Find any audio file in the stream folder (should only be one)
|
||
stream_file = None
|
||
audio_extensions = {'.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav', '.m4a'}
|
||
|
||
for filename in os.listdir(stream_folder):
|
||
file_path = os.path.join(stream_folder, filename)
|
||
if (os.path.isfile(file_path) and
|
||
os.path.splitext(filename)[1].lower() in audio_extensions):
|
||
stream_file = file_path
|
||
break
|
||
|
||
if stream_file and os.path.exists(stream_file):
|
||
# Start audio playback
|
||
success = self.audio_player.play_file(stream_file)
|
||
if success:
|
||
print(f"Started audio playback: {os.path.basename(stream_file)}")
|
||
# Set button to playing state
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.set_playing_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
# Emit track started signal for sidebar media player
|
||
if hasattr(self, 'current_track_result') and self.current_track_result:
|
||
self.track_loading_finished.emit(self.current_track_result)
|
||
self.track_started.emit(self.current_track_result)
|
||
else:
|
||
print(f"Failed to start audio playback")
|
||
# Reset button on failure
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.reset_play_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
self.currently_playing_button = None
|
||
else:
|
||
print(f"Stream file not found in {stream_folder}")
|
||
# Reset button on failure
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.reset_play_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
self.currently_playing_button = None
|
||
|
||
except Exception as e:
|
||
print(f"Error starting audio playback: {e}")
|
||
# Reset button on error
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.reset_play_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
self.currently_playing_button = None
|
||
|
||
def on_streaming_progress(self, progress_percent, search_result):
|
||
"""Handle streaming progress updates"""
|
||
print(f"Streaming progress: {progress_percent:.1f}% for {search_result.filename}")
|
||
|
||
# Check if this progress is for the currently requested track
|
||
if hasattr(self, 'current_track_result') and self.current_track_result:
|
||
current_track_id = f"{self.current_track_result.username}:{self.current_track_result.filename}"
|
||
progress_track_id = f"{search_result.username}:{search_result.filename}"
|
||
|
||
if current_track_id == progress_track_id:
|
||
# Emit progress signal for media player
|
||
self.track_loading_progress.emit(progress_percent, search_result)
|
||
else:
|
||
print(f"Ignoring progress for old streaming result: {search_result.filename}")
|
||
|
||
def on_streaming_queued(self, queue_msg, search_result):
|
||
"""Handle streaming queue state updates"""
|
||
print(f"Queue status: {queue_msg} for {search_result.filename}")
|
||
|
||
# Check if this queue status is for the currently requested track
|
||
if hasattr(self, 'current_track_result') and self.current_track_result:
|
||
current_track_id = f"{self.current_track_result.username}:{self.current_track_result.filename}"
|
||
queued_track_id = f"{search_result.username}:{search_result.filename}"
|
||
|
||
if current_track_id == queued_track_id:
|
||
# Show queue status in button
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.set_queue_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
print(f"Showing queue status for current track")
|
||
else:
|
||
print(f"Ignoring queue status for old streaming result: {search_result.filename}")
|
||
|
||
def on_streaming_failed(self, error_msg, search_result):
|
||
"""Handle streaming failure"""
|
||
print(f"Streaming failed: {error_msg}")
|
||
# Reset any play button that might be waiting
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.reset_play_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
self.currently_playing_button = None
|
||
|
||
def _stop_all_streaming_threads(self):
|
||
"""Stop all active streaming threads to prevent old downloads from interrupting new streams"""
|
||
if hasattr(self, 'streaming_threads'):
|
||
print(f"Stopping {len(self.streaming_threads)} active streaming threads")
|
||
|
||
for thread in self.streaming_threads[:]: # Use slice copy to avoid modification during iteration
|
||
try:
|
||
if thread.isRunning():
|
||
print(f"Stopping streaming thread for: {getattr(thread.search_result, 'filename', 'unknown')}")
|
||
thread.stop() # Request stop
|
||
|
||
# Give thread more time to stop gracefully (3 seconds)
|
||
if not thread.wait(3000): # Wait up to 3 seconds
|
||
print(f"Streaming thread taking longer to stop, giving more time...")
|
||
# Try one more time with longer wait
|
||
if not thread.wait(2000): # Additional 2 seconds
|
||
print(f"Force terminating unresponsive streaming thread")
|
||
thread.terminate()
|
||
thread.wait(1000) # Wait for termination
|
||
else:
|
||
print(f"Streaming thread stopped gracefully (delayed)")
|
||
else:
|
||
print(f"Streaming thread stopped gracefully")
|
||
|
||
# Remove from list
|
||
if thread in self.streaming_threads:
|
||
self.streaming_threads.remove(thread)
|
||
|
||
except Exception as e:
|
||
print(f"Error stopping streaming thread: {e}")
|
||
|
||
print(f"All streaming threads stopped")
|
||
|
||
async def _cancel_current_streaming_download(self):
|
||
"""Cancel the current streaming download via slskd API to prevent queue clogging"""
|
||
if not hasattr(self, 'current_streaming_download') or not self.current_streaming_download:
|
||
return
|
||
|
||
try:
|
||
username = self.current_streaming_download['username']
|
||
filename = self.current_streaming_download['filename']
|
||
print(f"Attempting to cancel streaming download: {username}:{os.path.basename(filename)}")
|
||
|
||
# Find the download ID by searching current transfers
|
||
all_transfers = await self.soulseek_client._make_request('GET', 'transfers/downloads')
|
||
download_id = None
|
||
|
||
if all_transfers:
|
||
# Flatten transfer data to find our download
|
||
for user_data in all_transfers:
|
||
if user_data.get('username') == username:
|
||
for directory in user_data.get('directories', []):
|
||
for file_data in directory.get('files', []):
|
||
if os.path.basename(file_data.get('filename', '')) == os.path.basename(filename):
|
||
download_id = file_data.get('id')
|
||
break
|
||
if download_id:
|
||
break
|
||
if download_id:
|
||
break
|
||
|
||
if download_id:
|
||
print(f"Found streaming download ID: {download_id}")
|
||
# Cancel the download with remove=False (slskd won't allow remove=True for active downloads)
|
||
success = await self.soulseek_client.cancel_download(download_id, username, remove=False)
|
||
if success:
|
||
print(f"Successfully cancelled streaming download: {os.path.basename(filename)}")
|
||
else:
|
||
print(f"Failed to cancel streaming download: {os.path.basename(filename)}")
|
||
# Try without remove flag as fallback
|
||
try:
|
||
success = await self.soulseek_client.cancel_download(download_id, username, remove=False)
|
||
if success:
|
||
print(f"Cancelled streaming download with fallback method: {os.path.basename(filename)}")
|
||
except Exception as fallback_e:
|
||
print(f"Fallback cancellation also failed: {fallback_e}")
|
||
else:
|
||
print(f"Could not find download ID for streaming download: {os.path.basename(filename)}")
|
||
|
||
except Exception as e:
|
||
print(f"Error cancelling streaming download: {e}")
|
||
# Continue with graceful fallback - don't let cancellation errors break streaming
|
||
print(f"Continuing with new stream despite cancellation error")
|
||
finally:
|
||
# Clean up any partial files from the cancelled streaming download
|
||
if hasattr(self, 'current_streaming_download') and self.current_streaming_download:
|
||
await self._cleanup_cancelled_streaming_files(self.current_streaming_download)
|
||
|
||
# Clear tracking regardless of success to prevent stuck state
|
||
self.current_streaming_download = None
|
||
print(f"Cleared streaming download tracking")
|
||
|
||
# Also clean up any completed streaming downloads to prevent queue clogging
|
||
await self._cleanup_completed_streaming_downloads()
|
||
|
||
async def _cleanup_completed_streaming_downloads(self):
|
||
"""Remove completed streaming downloads from slskd to prevent queue clogging"""
|
||
try:
|
||
print(f"Cleaning up completed streaming downloads...")
|
||
|
||
# Get current transfers to find completed ones
|
||
all_transfers = await self.soulseek_client._make_request('GET', 'transfers/downloads')
|
||
completed_streaming_downloads = []
|
||
|
||
if all_transfers:
|
||
# Look for completed downloads that might be from streaming
|
||
for user_data in all_transfers:
|
||
username = user_data.get('username', '')
|
||
for directory in user_data.get('directories', []):
|
||
for file_data in directory.get('files', []):
|
||
state = file_data.get('state', '')
|
||
filename = file_data.get('filename', '')
|
||
download_id = file_data.get('id', '')
|
||
|
||
# Check if this is a completed download
|
||
if ('Completed' in state and 'Succeeded' in state) and download_id:
|
||
# Consider audio files as potential streaming downloads
|
||
audio_extensions = {'.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav', '.m4a'}
|
||
file_ext = os.path.splitext(filename)[1].lower()
|
||
|
||
if file_ext in audio_extensions:
|
||
completed_streaming_downloads.append({
|
||
'id': download_id,
|
||
'username': username,
|
||
'filename': filename
|
||
})
|
||
|
||
# Remove completed streaming downloads (limit to prevent excessive cleanup)
|
||
max_cleanup = 5 # Only clean up 5 at a time to be conservative
|
||
for download in completed_streaming_downloads[:max_cleanup]:
|
||
try:
|
||
success = await self.soulseek_client.cancel_download(
|
||
download['id'], download['username'], remove=True
|
||
)
|
||
if success:
|
||
print(f"Cleaned up completed streaming download: {os.path.basename(download['filename'])}")
|
||
else:
|
||
print(f"Failed to clean up: {os.path.basename(download['filename'])}")
|
||
except Exception as e:
|
||
print(f"Error cleaning up download {download['id']}: {e}")
|
||
|
||
if completed_streaming_downloads:
|
||
print(f"Completed streaming download cleanup: {len(completed_streaming_downloads[:max_cleanup])} items removed")
|
||
else:
|
||
print(f"No completed streaming downloads found to clean up")
|
||
|
||
except Exception as e:
|
||
print(f"Error during streaming download cleanup: {e}")
|
||
|
||
async def _cleanup_cancelled_streaming_files(self, download_info):
|
||
"""Clean up partial files from cancelled streaming downloads"""
|
||
try:
|
||
username = download_info.get('username', '')
|
||
filename = download_info.get('filename', '')
|
||
|
||
if not username or not filename:
|
||
return
|
||
|
||
print(f"Cleaning up cancelled streaming files for: {os.path.basename(filename)}")
|
||
|
||
# Get downloads directory from config
|
||
from config.settings import config_manager
|
||
downloads_config = config_manager.get_downloads_config()
|
||
download_path = downloads_config.get('path', './downloads')
|
||
|
||
# Look for partial/completed files in downloads directory
|
||
filename_base = os.path.splitext(os.path.basename(filename))[0]
|
||
|
||
# Search for files that might match this download
|
||
for root, dirs, files in os.walk(download_path):
|
||
for file in files:
|
||
# Check if this file could be from our cancelled download
|
||
if (filename_base.lower() in file.lower() or
|
||
os.path.basename(filename).lower() == file.lower()):
|
||
|
||
file_path = os.path.join(root, file)
|
||
try:
|
||
print(f"Removing cancelled streaming file: {file_path}")
|
||
os.remove(file_path)
|
||
|
||
# Clean up empty directories
|
||
self._cleanup_empty_directories(download_path, file_path)
|
||
|
||
except Exception as e:
|
||
print(f"Error removing file {file_path}: {e}")
|
||
|
||
except Exception as e:
|
||
print(f"Error cleaning up cancelled streaming files: {e}")
|
||
|
||
def _cancel_current_streaming_download_sync(self):
|
||
"""Synchronous wrapper for cancelling current streaming download"""
|
||
if hasattr(self, 'current_streaming_download') and self.current_streaming_download:
|
||
# Use async event loop to run the cancellation
|
||
import asyncio
|
||
import threading
|
||
|
||
try:
|
||
# Try to get existing event loop first
|
||
try:
|
||
loop = asyncio.get_running_loop()
|
||
# Loop is already running, we need to run in a thread
|
||
def run_in_thread():
|
||
new_loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(new_loop)
|
||
try:
|
||
new_loop.run_until_complete(self._cancel_current_streaming_download())
|
||
finally:
|
||
new_loop.close()
|
||
|
||
thread = threading.Thread(target=run_in_thread)
|
||
thread.start()
|
||
thread.join(timeout=5.0) # Wait max 5 seconds
|
||
return
|
||
except RuntimeError:
|
||
# No event loop in current thread
|
||
pass
|
||
|
||
# Create and use new event loop
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
try:
|
||
loop.run_until_complete(self._cancel_current_streaming_download())
|
||
finally:
|
||
loop.close()
|
||
|
||
except Exception as e:
|
||
print(f"Error in sync streaming download cancellation: {e}")
|
||
print(f"Continuing with new stream despite sync cancellation error")
|
||
# Clear tracking as fallback to prevent stuck state
|
||
self.current_streaming_download = None
|
||
|
||
def on_streaming_thread_finished(self, thread):
|
||
"""Clean up when streaming thread finishes"""
|
||
try:
|
||
if hasattr(self, 'streaming_threads') and thread in self.streaming_threads:
|
||
self.streaming_threads.remove(thread)
|
||
|
||
# Disconnect all signals to prevent stale connections
|
||
try:
|
||
thread.streaming_started.disconnect()
|
||
thread.streaming_finished.disconnect()
|
||
thread.streaming_failed.disconnect()
|
||
thread.finished.disconnect()
|
||
except Exception:
|
||
pass # Ignore if signals are already disconnected
|
||
|
||
# Ensure thread is properly stopped before deletion
|
||
if thread.isRunning():
|
||
thread.stop()
|
||
thread.wait(1000) # Wait up to 1 second
|
||
|
||
# Use QTimer.singleShot for delayed cleanup
|
||
QTimer.singleShot(100, thread.deleteLater)
|
||
|
||
except Exception as e:
|
||
print(f"Error cleaning up finished streaming thread: {e}")
|
||
|
||
def on_audio_playback_finished(self):
|
||
"""Handle when audio playback finishes"""
|
||
print("Audio playback completed")
|
||
# Reset the play button to play state
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.reset_play_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
self.currently_playing_button = None
|
||
|
||
# Emit track finished signal for sidebar media player
|
||
self.track_finished.emit()
|
||
|
||
# Clear Stream folder when playback finishes (release file since playback is done)
|
||
self.clear_stream_folder(release_current_file=True)
|
||
|
||
# Clear track state
|
||
self.current_track_id = None
|
||
self.current_track_result = None
|
||
|
||
def on_audio_playback_error(self, error_msg):
|
||
"""Handle audio playback errors"""
|
||
print(f"Audio playback error: {error_msg}")
|
||
# Reset the play button to play state
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.reset_play_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
self.currently_playing_button = None
|
||
|
||
# Emit track stopped signal for sidebar media player
|
||
self.track_stopped.emit()
|
||
|
||
# Clear Stream folder when playback errors (release file since there's an error)
|
||
self.clear_stream_folder(release_current_file=True)
|
||
|
||
# Clear track state
|
||
self.current_track_id = None
|
||
self.current_track_result = None
|
||
|
||
def handle_sidebar_play_pause(self):
|
||
"""Handle play/pause request from sidebar media player"""
|
||
# Use the actual QMediaPlayer state instead of manual flag
|
||
from PyQt6.QtMultimedia import QMediaPlayer
|
||
|
||
current_state = self.audio_player.playbackState()
|
||
print(f"handle_sidebar_play_pause() - Current state: {current_state}")
|
||
print(f"handle_sidebar_play_pause() - Current source: {self.audio_player.source().toString()}")
|
||
|
||
if current_state == QMediaPlayer.PlaybackState.PlayingState:
|
||
print("Sidebar: Pausing playback")
|
||
self.audio_player.pause()
|
||
# is_playing will be set automatically by _on_playback_state_changed
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.set_loading_state() # Use as "paused" state
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
self.track_paused.emit()
|
||
print("Paused from sidebar")
|
||
else:
|
||
print("Sidebar: Attempting to resume/play")
|
||
self.audio_player.play()
|
||
# is_playing will be set automatically by _on_playback_state_changed
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.set_playing_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
self.track_resumed.emit()
|
||
print("Resumed from sidebar")
|
||
|
||
def handle_sidebar_stop(self):
|
||
"""Handle stop request from sidebar media player"""
|
||
self.audio_player.stop_playback()
|
||
if self.currently_playing_button:
|
||
try:
|
||
self.currently_playing_button.reset_play_state()
|
||
except RuntimeError:
|
||
# Button was deleted, ignore
|
||
pass
|
||
self.currently_playing_button = None
|
||
|
||
# Emit track stopped signal
|
||
self.track_stopped.emit()
|
||
|
||
# Clear Stream folder when stopping (release file since user explicitly stopped)
|
||
self.clear_stream_folder(release_current_file=True)
|
||
|
||
# Clear track state
|
||
self.current_track_id = None
|
||
self.current_track_result = None
|
||
print("Stopped from sidebar")
|
||
|
||
def handle_sidebar_volume(self, volume):
|
||
"""Handle volume change from sidebar media player"""
|
||
self.audio_player.audio_output.setVolume(volume)
|
||
print(f"Volume set to {int(volume * 100)}% from sidebar")
|
||
|
||
def clear_stream_folder(self, release_current_file=True):
|
||
"""Clear all files from the Stream folder to prevent playing wrong files
|
||
|
||
Args:
|
||
release_current_file (bool): Whether to release the current audio file handle.
|
||
Set to False if you want to clear old files but keep current playback.
|
||
"""
|
||
try:
|
||
# Only release file handles if explicitly requested
|
||
if release_current_file and hasattr(self, 'audio_player') and self.audio_player:
|
||
self.audio_player.release_file()
|
||
print("Released audio player file handle before clearing")
|
||
|
||
project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__))) # Go up from ui/pages/
|
||
stream_folder = os.path.join(project_root, 'Stream')
|
||
|
||
if os.path.exists(stream_folder):
|
||
for filename in os.listdir(stream_folder):
|
||
file_path = os.path.join(stream_folder, filename)
|
||
if os.path.isfile(file_path):
|
||
try:
|
||
os.remove(file_path)
|
||
print(f"Cleared old stream file: {filename}")
|
||
except Exception as e:
|
||
print(f"Could not remove stream file {filename}: {e}")
|
||
|
||
except Exception as e:
|
||
print(f"Error clearing stream folder: {e}")
|
||
|
||
def on_download_completed(self, message, download_item):
|
||
"""Handle successful download start (NOT completion)"""
|
||
print(f"Download started: {message}")
|
||
|
||
# Extract download ID from message if available
|
||
if "Download started:" in message and download_item:
|
||
# Message format is "Download started: <download_id>"
|
||
download_id_part = message.replace("Download started:", "").strip()
|
||
|
||
# Check if this looks like a UUID (real download ID) vs filename
|
||
import re
|
||
uuid_pattern = r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
|
||
if re.match(uuid_pattern, download_id_part, re.IGNORECASE):
|
||
download_item.download_id = download_id_part
|
||
print(f"[DEBUG] Stored real download ID: {download_id_part}")
|
||
else:
|
||
print(f"[DEBUG] Using filename as download ID: {download_id_part}")
|
||
download_item.download_id = download_id_part
|
||
|
||
# Set status to downloading, not completed!
|
||
download_item.status = "downloading"
|
||
download_item.progress = 0
|
||
|
||
def on_download_failed(self, error_msg, download_item):
|
||
"""Handle download failure"""
|
||
print(f"Download failed: {error_msg}")
|
||
# Update download item status to failed
|
||
download_item.status = "failed"
|
||
download_item.progress = 0
|
||
|
||
# Emit activity signal for download failure
|
||
self.download_activity.emit("", "Download Failed", f"'{download_item.title}' - {error_msg}", "Now")
|
||
|
||
# Error logged to console for debugging
|
||
|
||
def on_download_progress(self, message, download_item):
|
||
"""Handle download progress updates"""
|
||
print(f"Download progress: {message}")
|
||
# Extract progress percentage if available from message
|
||
# For now just show as downloading
|
||
download_item.status = "downloading"
|
||
|
||
def on_download_thread_finished(self, thread):
|
||
"""Clean up when download thread finishes"""
|
||
try:
|
||
if thread in self.download_threads:
|
||
self.download_threads.remove(thread)
|
||
|
||
# Disconnect all signals to prevent stale connections
|
||
try:
|
||
thread.download_completed.disconnect()
|
||
thread.download_failed.disconnect()
|
||
thread.download_progress.disconnect()
|
||
thread.finished.disconnect()
|
||
except Exception:
|
||
pass # Ignore if signals are already disconnected
|
||
|
||
# Ensure thread is properly stopped before deletion
|
||
if thread.isRunning():
|
||
thread.stop()
|
||
thread.wait(1000) # Wait up to 1 second
|
||
|
||
# Use QTimer.singleShot for delayed cleanup to ensure signal processing is complete
|
||
QTimer.singleShot(100, thread.deleteLater)
|
||
|
||
except Exception as e:
|
||
print(f"Error cleaning up finished download thread: {e}")
|
||
|
||
def _run_async_operation(self, async_func, *args, success_callback=None, error_callback=None):
|
||
"""Helper method to run async operations safely with proper event loop management"""
|
||
import asyncio
|
||
import threading
|
||
|
||
def run_operation():
|
||
"""Run the async operation in a separate thread with its own event loop"""
|
||
try:
|
||
# Create a fresh event loop for this thread
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
# Run the async operation
|
||
result = loop.run_until_complete(async_func(*args))
|
||
|
||
# Schedule success callback on main thread if provided
|
||
if success_callback:
|
||
QTimer.singleShot(0, lambda: success_callback(result))
|
||
|
||
return result
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Exception in async operation: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
# Schedule error callback on main thread if provided
|
||
if error_callback:
|
||
# Capture the error in a closure to avoid lambda variable issues
|
||
def call_error_callback(error=e):
|
||
error_callback(error)
|
||
QTimer.singleShot(0, call_error_callback)
|
||
|
||
return False
|
||
|
||
finally:
|
||
# Always close the loop we created
|
||
try:
|
||
loop.close()
|
||
except Exception as close_e:
|
||
print(f"[WARNING] Error closing event loop: {close_e}")
|
||
|
||
try:
|
||
# Run the operation in a separate thread
|
||
operation_thread = threading.Thread(target=run_operation, daemon=True)
|
||
operation_thread.start()
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Exception starting async operation thread: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
def clear_completed_downloads(self):
|
||
"""Clear completed and cancelled downloads from both slskd backend and local queues"""
|
||
print("[DEBUG] DownloadsPage.clear_completed_downloads() method called!")
|
||
print(f"[DEBUG] Current download queue stats:")
|
||
print(f"[DEBUG] - Active queue: {len(self.download_queue.active_queue.download_items)} items")
|
||
print(f"[DEBUG] - Finished queue: {len(self.download_queue.finished_queue.download_items)} items")
|
||
|
||
if not self.soulseek_client:
|
||
print("[ERROR] No soulseek client available for clearing downloads")
|
||
return
|
||
|
||
# Run async clear operation using threading to avoid event loop conflicts
|
||
import asyncio
|
||
import threading
|
||
|
||
# Define UI update callback outside the thread (with proper self reference)
|
||
def update_ui_callback():
|
||
"""UI update callback that runs on main thread"""
|
||
print("[DEBUG] *** UI CALLBACK EXECUTED *** - Starting UI clear operations...")
|
||
try:
|
||
# Step 1: Clear local queues
|
||
print("[DEBUG] Step 1: Calling clear_local_queues_only()...")
|
||
self.download_queue.clear_local_queues_only()
|
||
print("[DEBUG] Step 1 completed successfully")
|
||
|
||
# Step 2: Update download status
|
||
print("[DEBUG] Step 2: Calling update_download_status()...")
|
||
self.update_download_status()
|
||
print("[DEBUG] Step 2 completed successfully")
|
||
|
||
print("[DEBUG] *** UI CALLBACK COMPLETED *** - All UI clear operations finished")
|
||
except Exception as e:
|
||
print(f"[ERROR] Exception in UI callback: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
# Even if there's an error, try to update the display
|
||
try:
|
||
print("[DEBUG] Attempting fallback queue update...")
|
||
if hasattr(self, 'download_queue'):
|
||
self.download_queue.update_tab_counts()
|
||
except Exception as fallback_e:
|
||
print(f"[ERROR] Fallback update also failed: {fallback_e}")
|
||
|
||
def run_clear_operation():
|
||
"""Run the clear operation in a separate thread with its own event loop"""
|
||
success = False
|
||
try:
|
||
# Create a fresh event loop for this thread
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
print("[DEBUG] Clearing all completed/cancelled downloads from slskd backend...")
|
||
success = loop.run_until_complete(self.soulseek_client.clear_all_completed_downloads())
|
||
|
||
if success:
|
||
print("[DEBUG] Successfully cleared completed/cancelled downloads from backend")
|
||
else:
|
||
print("[WARNING] Backend reported failure, but proceeding with UI clearing anyway")
|
||
print("[WARNING] (Web UI may have cleared successfully despite backend failure report)")
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Exception during clear completed downloads: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
finally:
|
||
# Always close the loop we created
|
||
try:
|
||
loop.close()
|
||
except Exception as close_e:
|
||
print(f"[WARNING] Error closing event loop: {close_e}")
|
||
|
||
# CRITICAL: Use signal to communicate with main thread (thread-safe)
|
||
print("[DEBUG] Thread completed, emitting completion signal...")
|
||
self.clear_completed_finished.emit(success, update_ui_callback)
|
||
|
||
try:
|
||
# Run the clear operation in a separate thread
|
||
clear_thread = threading.Thread(target=run_clear_operation, daemon=True)
|
||
clear_thread.start()
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Exception starting clear completed downloads thread: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
def _handle_clear_completion(self, backend_success, ui_callback):
|
||
"""Handle completion of clear operation on main thread"""
|
||
print(f"[DEBUG] _handle_clear_completion called on main thread - backend_success: {backend_success}")
|
||
|
||
# ALWAYS clear UI regardless of backend success/failure
|
||
# This ensures UI stays in sync even if backend reports false negatives
|
||
print("[DEBUG] Executing UI callback on main thread...")
|
||
try:
|
||
ui_callback()
|
||
except Exception as e:
|
||
print(f"[ERROR] Exception executing UI callback: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
def _handle_api_cleanup_completion(self, success, download_id, username):
|
||
"""Handle completion of API cleanup operation on main thread"""
|
||
if success:
|
||
print(f"Successfully signaled completion for download {download_id}")
|
||
else:
|
||
print(f"Failed to signal completion for download {download_id}")
|
||
|
||
def _on_download_completion_finished(self, download_item, organized_path):
|
||
"""Handle successful completion of background download processing"""
|
||
print(f"Background processing completed for '{download_item.title}' -> {organized_path}")
|
||
|
||
# Update the download item status and progress on main thread
|
||
download_item.update_status(
|
||
status='completed',
|
||
progress=100,
|
||
download_speed=0,
|
||
file_path=organized_path
|
||
)
|
||
|
||
# Move completed items to finished queue on main thread
|
||
print(f"[DEBUG] Moving completed download '{download_item.title}' to finished queue")
|
||
self.download_queue.move_to_finished(download_item)
|
||
|
||
def _on_download_completion_error(self, download_item, error_message):
|
||
"""Handle error in background download processing"""
|
||
print(f"Background processing failed for '{download_item.title}': {error_message}")
|
||
|
||
# Still mark as completed but with original path, move to finished queue
|
||
download_item.update_status(
|
||
status='completed',
|
||
progress=100,
|
||
download_speed=0,
|
||
file_path=download_item.file_path # Keep original path on error
|
||
)
|
||
|
||
# Move to finished queue even on error
|
||
print(f"[DEBUG] Moving download '{download_item.title}' to finished queue after error")
|
||
self.download_queue.move_to_finished(download_item)
|
||
|
||
def _update_adaptive_polling(self):
|
||
"""OPTIMIZATION v2: Update polling frequency based on download activity"""
|
||
try:
|
||
active_downloads = len([item for item in self.download_queue.download_items
|
||
if item.status.lower() in ['downloading', 'queued', 'initializing']])
|
||
|
||
# Determine optimal polling mode
|
||
new_mode = 'idle'
|
||
if self._bulk_operation_active:
|
||
new_mode = 'bulk_pause'
|
||
elif active_downloads > 0:
|
||
new_mode = 'active'
|
||
|
||
# Update timer if mode changed
|
||
if new_mode != self._current_polling_mode:
|
||
new_interval = self._polling_intervals[new_mode]
|
||
self.download_status_timer.setInterval(new_interval)
|
||
self._current_polling_mode = new_mode
|
||
|
||
self._last_active_count = active_downloads
|
||
|
||
except Exception as e:
|
||
pass # Silent adaptive polling failures
|
||
|
||
def update_download_status_v2(self):
|
||
"""OPTIMIZATION v2: Robust queue state management with thread safety"""
|
||
if not self.soulseek_client:
|
||
return
|
||
|
||
# Use thread-safe access to download items
|
||
download_items = self._queue_manager.get_download_items_copy()
|
||
if not download_items:
|
||
return
|
||
|
||
# Update adaptive polling
|
||
self._update_adaptive_polling()
|
||
|
||
def handle_status_update_v2(transfers_data):
|
||
"""Enhanced status update handler with robust state management"""
|
||
import time
|
||
try:
|
||
if not transfers_data:
|
||
return
|
||
|
||
# Flatten transfers data efficiently
|
||
all_transfers = []
|
||
for user_data in transfers_data:
|
||
if 'directories' in user_data:
|
||
for directory in user_data['directories']:
|
||
if 'files' in directory:
|
||
all_transfers.extend(directory['files'])
|
||
|
||
|
||
# Use thread-safe operations throughout
|
||
with self._queue_consistency_lock:
|
||
matched_transfer_ids = set()
|
||
|
||
# Process each download item with improved matching
|
||
for download_item in download_items:
|
||
if download_item.status.lower() in ['completed', 'finished', 'cancelled', 'failed']:
|
||
continue
|
||
|
||
# Enhanced ID-based matching
|
||
matching_transfer = self._find_matching_transfer_v2(
|
||
download_item, all_transfers, matched_transfer_ids
|
||
)
|
||
|
||
if matching_transfer:
|
||
matched_transfer_ids.add(matching_transfer.get('id'))
|
||
self._process_transfer_match_v2(download_item, matching_transfer)
|
||
else:
|
||
self._handle_missing_transfer_v2(download_item)
|
||
|
||
# Update UI counters
|
||
self.download_queue.update_tab_counts()
|
||
|
||
# Enhanced logging: periodic queue health summary
|
||
if not hasattr(self, '_last_queue_summary_time'):
|
||
self._last_queue_summary_time = 0
|
||
if time.time() - self._last_queue_summary_time > 30: # Every 30 seconds
|
||
self._log_queue_health_summary(download_items)
|
||
self._last_queue_summary_time = time.time()
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Status update v2 failed: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
# Create status thread with error handling
|
||
try:
|
||
status_thread = TransferStatusThread(self.soulseek_client)
|
||
status_thread.transfer_status_completed.connect(handle_status_update_v2)
|
||
status_thread.finished.connect(lambda: self._cleanup_status_thread_v2(status_thread))
|
||
|
||
# Track threads for cleanup
|
||
if not hasattr(self, '_active_status_threads_v2'):
|
||
self._active_status_threads_v2 = set()
|
||
self._active_status_threads_v2.add(status_thread)
|
||
|
||
status_thread.start()
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Failed to start status update thread v2: {e}")
|
||
|
||
def _log_queue_health_summary(self, download_items):
|
||
"""Log periodic queue health summary for debugging stuck downloads"""
|
||
import time
|
||
|
||
try:
|
||
if not download_items:
|
||
return
|
||
|
||
# Count downloads by status
|
||
status_counts = {}
|
||
stuck_downloads = []
|
||
|
||
for item in download_items:
|
||
status = item.status.lower()
|
||
status_counts[status] = status_counts.get(status, 0) + 1
|
||
|
||
# Check for potentially stuck downloads
|
||
if hasattr(item, 'queue_start_time') and item.queue_start_time:
|
||
queue_age = time.time() - item.queue_start_time
|
||
if queue_age > 15: # More than 15 seconds in queue
|
||
stuck_downloads.append((item.title, queue_age))
|
||
|
||
# Check for items with high API missing counts
|
||
if hasattr(item, 'api_missing_count_v2') and item.api_missing_count_v2 > 1:
|
||
stuck_downloads.append((item.title, f"API missing {item.api_missing_count_v2} cycles"))
|
||
|
||
# Log summary
|
||
print(f"Queue Health: {status_counts}")
|
||
if stuck_downloads:
|
||
print(f"Potentially stuck downloads: {len(stuck_downloads)}")
|
||
for title, issue in stuck_downloads[:3]: # Show first 3
|
||
if isinstance(issue, str):
|
||
print(f" - {title}: {issue}")
|
||
else:
|
||
print(f" - {title}: queued for {issue:.1f}s")
|
||
|
||
except Exception as e:
|
||
pass # Silent logging failures
|
||
|
||
def _find_matching_transfer_v2(self, download_item, all_transfers, matched_ids):
|
||
"""Enhanced transfer matching with better ID tracking"""
|
||
# Primary: ID-based matching
|
||
if hasattr(download_item, 'download_id') and download_item.download_id:
|
||
for transfer in all_transfers:
|
||
transfer_id = transfer.get('id')
|
||
if transfer_id == download_item.download_id and transfer_id not in matched_ids:
|
||
return transfer
|
||
|
||
# Fallback: Enhanced filename matching (simplified for performance)
|
||
for transfer in all_transfers:
|
||
transfer_id = transfer.get('id')
|
||
if transfer_id in matched_ids:
|
||
continue
|
||
|
||
filename = transfer.get('filename', '').lower()
|
||
title = download_item.title.lower()
|
||
|
||
# Quick contains check for performance
|
||
if title in filename or any(word in filename for word in title.split() if len(word) > 3):
|
||
return transfer
|
||
|
||
return None
|
||
|
||
def _process_transfer_match_v2(self, download_item, transfer):
|
||
"""Process matched transfer with atomic state updates and progressive timeout logic"""
|
||
import time
|
||
|
||
state = transfer.get('state', 'Unknown')
|
||
progress = min(100, max(0, transfer.get('percentComplete', 0)))
|
||
|
||
# Initialize queue tracking if needed
|
||
if not hasattr(download_item, 'queue_start_time'):
|
||
download_item.queue_start_time = None
|
||
|
||
# Determine new status
|
||
if 'Completed' in state or 'Succeeded' in state:
|
||
new_status = 'completed'
|
||
progress = 100
|
||
elif 'Cancelled' in state or 'Canceled' in state:
|
||
new_status = 'cancelled'
|
||
elif 'Failed' in state or 'Errored' in state:
|
||
new_status = 'failed'
|
||
elif 'InProgress' in state:
|
||
new_status = 'downloading'
|
||
else:
|
||
new_status = 'queued'
|
||
|
||
# Track queue state transitions for progressive timeout
|
||
if new_status in ['queued', 'initializing'] and download_item.queue_start_time is None:
|
||
download_item.queue_start_time = time.time()
|
||
print(f"Download entered queue: {download_item.title}")
|
||
elif new_status in ['downloading', 'completed', 'cancelled', 'failed']:
|
||
if download_item.queue_start_time:
|
||
queue_duration = time.time() - download_item.queue_start_time
|
||
print(f"⏱️ Download '{download_item.title}' was in queue for {queue_duration:.1f}s")
|
||
download_item.queue_start_time = None # Reset queue timer
|
||
|
||
# Atomic status update
|
||
self._queue_manager.atomic_state_transition(
|
||
download_item, new_status,
|
||
callback=lambda item, old, new: self._handle_status_change_v2(item, old, new, transfer)
|
||
)
|
||
|
||
# Update progress and metadata
|
||
download_item.update_status(
|
||
status=new_status,
|
||
progress=int(progress),
|
||
download_speed=int(transfer.get('averageSpeed', 0)),
|
||
file_path=transfer.get('filename', download_item.file_path)
|
||
)
|
||
|
||
# Reset API missing count when transfer is found and add enhanced logging
|
||
if hasattr(download_item, 'api_missing_count_v2') and download_item.api_missing_count_v2 > 0:
|
||
print(f"Download reconnected to API after {download_item.api_missing_count_v2} missing cycles: {download_item.title}")
|
||
download_item.api_missing_count_v2 = 0
|
||
|
||
# Update ID mapping if needed
|
||
transfer_id = transfer.get('id')
|
||
if transfer_id and (not hasattr(download_item, 'download_id') or download_item.download_id != transfer_id):
|
||
self._queue_manager.update_id_mapping_safe(download_item, transfer_id)
|
||
|
||
def _handle_status_change_v2(self, download_item, old_status, new_status, transfer):
|
||
"""Handle status change transitions"""
|
||
if new_status in ['completed', 'cancelled', 'failed']:
|
||
# Move to finished queue
|
||
self.download_queue.move_to_finished(download_item)
|
||
|
||
# Emit specific activity signal for failures
|
||
if new_status == 'failed':
|
||
self.download_activity.emit("", "Download Failed", f"'{download_item.title}' by {download_item.artist}", "Now")
|
||
elif new_status == 'cancelled':
|
||
self.download_activity.emit("", "Download Cancelled", f"'{download_item.title}' by {download_item.artist}", "Now")
|
||
|
||
# Cleanup API if needed
|
||
if new_status in ['cancelled', 'failed'] and hasattr(download_item, 'download_id'):
|
||
self._schedule_api_cleanup_v2(download_item)
|
||
|
||
# Schedule fallback cleanup check for errored downloads
|
||
if new_status == 'failed':
|
||
self._schedule_fallback_cleanup_check()
|
||
|
||
def _handle_missing_transfer_v2(self, download_item):
|
||
"""Handle downloads missing from API with improved grace period and queue age tracking"""
|
||
import time
|
||
|
||
# Initialize tracking attributes
|
||
if not hasattr(download_item, 'api_missing_count_v2'):
|
||
download_item.api_missing_count_v2 = 0
|
||
if not hasattr(download_item, 'queue_start_time'):
|
||
download_item.queue_start_time = None
|
||
|
||
# Track when downloads first enter queued state
|
||
current_status = download_item.status.lower()
|
||
if current_status in ['queued', 'initializing'] and download_item.queue_start_time is None:
|
||
download_item.queue_start_time = time.time()
|
||
print(f"Started tracking queue time for: {download_item.title}")
|
||
elif current_status not in ['queued', 'initializing']:
|
||
download_item.queue_start_time = None # Reset if no longer queued
|
||
|
||
download_item.api_missing_count_v2 += 1
|
||
|
||
# Enhanced timeout logic with queue age consideration
|
||
queue_timeout_exceeded = False
|
||
if download_item.queue_start_time:
|
||
queue_age = time.time() - download_item.queue_start_time
|
||
queue_timeout = 180.0 # 3 minutes max in queue
|
||
if queue_age > queue_timeout:
|
||
queue_timeout_exceeded = True
|
||
print(f"⏰ Queue timeout exceeded: {download_item.title} stuck in queue for {queue_age:.1f}s")
|
||
|
||
# Fail download if API missing for 3 cycles OR queue timeout exceeded
|
||
if download_item.api_missing_count_v2 >= 3 or queue_timeout_exceeded:
|
||
if queue_timeout_exceeded:
|
||
print(f"Download failed due to queue timeout: {download_item.title}")
|
||
else:
|
||
print(f"Download missing from API for {download_item.api_missing_count_v2} cycles: {download_item.title}")
|
||
self._queue_manager.atomic_state_transition(download_item, 'failed')
|
||
self.download_queue.move_to_finished(download_item)
|
||
|
||
def _schedule_api_cleanup_v2(self, download_item):
|
||
"""Schedule API cleanup with robust retry mechanism"""
|
||
def cleanup_task_with_retry():
|
||
import time
|
||
import asyncio
|
||
|
||
max_retries = 3
|
||
retry_delays = [2, 5, 10] # Progressive delays in seconds
|
||
|
||
for attempt in range(max_retries):
|
||
try:
|
||
if not (hasattr(download_item, 'download_id') and download_item.soulseek_client):
|
||
return
|
||
|
||
# Wait before cleanup to let API stabilize
|
||
if attempt == 0:
|
||
time.sleep(1) # Initial delay for API stabilization
|
||
else:
|
||
time.sleep(retry_delays[attempt - 1])
|
||
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
try:
|
||
success = loop.run_until_complete(
|
||
download_item.soulseek_client.cancel_download(
|
||
download_item.download_id,
|
||
getattr(download_item, 'username', ''),
|
||
remove=True
|
||
)
|
||
)
|
||
|
||
if success:
|
||
return # Success, exit retry loop
|
||
else:
|
||
if attempt == max_retries - 1:
|
||
print(f"API cleanup failed after {max_retries} attempts: {download_item.title}")
|
||
|
||
finally:
|
||
loop.close()
|
||
|
||
except Exception as e:
|
||
if attempt == max_retries - 1:
|
||
print(f"API cleanup failed after {max_retries} attempts: {e}")
|
||
# Continue to next retry
|
||
|
||
self._optimized_api_pool.submit(cleanup_task_with_retry)
|
||
|
||
def _schedule_fallback_cleanup_check(self):
|
||
"""Schedule a fallback cleanup check for persistent errored entries"""
|
||
def fallback_cleanup_task():
|
||
import time
|
||
import asyncio
|
||
|
||
# Wait longer before fallback cleanup
|
||
time.sleep(30) # 30 second delay
|
||
|
||
try:
|
||
if not self.soulseek_client:
|
||
return
|
||
|
||
# Get current transfers to find persistent errored entries
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
|
||
try:
|
||
transfers_data = loop.run_until_complete(
|
||
self.soulseek_client.get_all_downloads()
|
||
)
|
||
|
||
if transfers_data:
|
||
# Find errored entries that should have been cleaned up
|
||
persistent_errors = []
|
||
for user_data in transfers_data:
|
||
if 'directories' in user_data:
|
||
for directory in user_data['directories']:
|
||
if 'files' in directory:
|
||
for transfer in directory['files']:
|
||
state = transfer.get('state', '')
|
||
if any(error_state in state for error_state in ['Failed', 'Errored', 'Cancelled']):
|
||
persistent_errors.append(transfer)
|
||
|
||
# Clean up persistent errors (max 5 at a time to be conservative)
|
||
for transfer in persistent_errors[:5]:
|
||
try:
|
||
success = loop.run_until_complete(
|
||
self.soulseek_client.cancel_download(
|
||
transfer.get('id'),
|
||
transfer.get('username', ''),
|
||
remove=True
|
||
)
|
||
)
|
||
if success:
|
||
print(f"Fallback cleanup successful for persistent error")
|
||
except Exception as e:
|
||
pass # Silent fallback failures
|
||
|
||
finally:
|
||
loop.close()
|
||
|
||
except Exception as e:
|
||
pass # Silent fallback failures
|
||
|
||
# Schedule fallback cleanup
|
||
self._optimized_api_pool.submit(fallback_cleanup_task)
|
||
|
||
def _cleanup_status_thread_v2(self, thread):
|
||
"""Clean up status threads"""
|
||
try:
|
||
if hasattr(self, '_active_status_threads_v2') and thread in self._active_status_threads_v2:
|
||
self._active_status_threads_v2.remove(thread)
|
||
thread.deleteLater()
|
||
except Exception as e:
|
||
pass # Silent thread cleanup failures
|
||
|
||
def enable_optimized_systems(self):
|
||
"""Enable all v2 optimization systems"""
|
||
self._use_optimized_systems = True
|
||
print("Enabled optimized download systems")
|
||
|
||
# Switch to optimized timer callback
|
||
self.download_status_timer.timeout.disconnect()
|
||
self.download_status_timer.timeout.connect(self.update_download_status_v2)
|
||
|
||
# Update timer interval for initial adaptive mode
|
||
self.download_status_timer.setInterval(self._polling_intervals['active'])
|
||
|
||
def disable_optimized_systems(self):
|
||
"""Disable v2 optimizations and revert to original behavior"""
|
||
self._use_optimized_systems = False
|
||
print("Disabled optimizations, reverted to original system")
|
||
|
||
# Revert to original timer callback
|
||
self.download_status_timer.timeout.disconnect()
|
||
self.download_status_timer.timeout.connect(self.update_download_status)
|
||
self.download_status_timer.setInterval(1000) # Back to 1 second
|
||
|
||
# In class DownloadsPage, REPLACE your old update_download_status method with this one.
|
||
|
||
def update_download_status(self):
|
||
"""
|
||
Starts the background worker to process download statuses without blocking the UI.
|
||
This method is called by the QTimer.
|
||
"""
|
||
if self._is_status_update_running or not self.soulseek_client:
|
||
return # Don't start a new worker if one is already processing.
|
||
|
||
# Check if there are any active downloads to process
|
||
active_items = [item for item in self.download_queue.active_queue.download_items]
|
||
if not active_items:
|
||
self._is_status_update_running = False
|
||
return
|
||
|
||
self._is_status_update_running = True
|
||
|
||
# Create and start the background worker
|
||
worker = StatusProcessingWorker(
|
||
soulseek_client=self.soulseek_client,
|
||
download_items=active_items
|
||
)
|
||
|
||
# Connect signals from the worker to the main thread handler
|
||
worker.signals.completed.connect(self._handle_processed_status_updates)
|
||
worker.signals.error.connect(lambda e: print(f"Status Worker Error: {e}"))
|
||
|
||
# The worker will automatically be cleaned up by the thread pool.
|
||
self.status_processing_pool.start(worker)
|
||
|
||
|
||
def _periodic_cleanup_check(self):
|
||
"""Check for completed downloads and clean them up intelligently"""
|
||
if not self.soulseek_client:
|
||
return
|
||
|
||
try:
|
||
# Clean up bulk downloads found in previous tick
|
||
if self.downloads_to_cleanup:
|
||
print(f"[CLEANUP] Bulk cleaning {len(self.downloads_to_cleanup)} completed downloads from backend")
|
||
self._cleanup_backend_downloads(self.downloads_to_cleanup)
|
||
self.downloads_to_cleanup.clear()
|
||
|
||
# Clean up individual downloads found in previous tick (errored ones)
|
||
if self.individual_downloads_to_cleanup:
|
||
print(f"[CLEANUP] Individually cleaning {len(self.individual_downloads_to_cleanup)} errored downloads from backend")
|
||
self._cleanup_individual_downloads(self.individual_downloads_to_cleanup)
|
||
self.individual_downloads_to_cleanup.clear()
|
||
|
||
# Find new completed downloads for next tick
|
||
self._find_completed_downloads_for_cleanup()
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Error in periodic cleanup: {e}")
|
||
|
||
def _find_completed_downloads_for_cleanup(self):
|
||
"""Find downloads that need cleanup in the next tick"""
|
||
try:
|
||
# Get current downloads from backend
|
||
async def check_backend_downloads():
|
||
try:
|
||
result = await self.soulseek_client.get_all_downloads()
|
||
if result:
|
||
bulk_cleanup_states = {'Completed, Succeeded', 'Completed, Cancelled', 'Cancelled', 'Canceled'}
|
||
individual_cleanup_states = {'Completed, Errored', 'Failed', 'Errored'}
|
||
|
||
new_bulk_cleanup = set()
|
||
new_individual_cleanup = []
|
||
|
||
for download in result:
|
||
if download.state in bulk_cleanup_states:
|
||
# These can be cleared with bulk clear operation
|
||
download_key = f"{download.username}:{download.id}"
|
||
new_bulk_cleanup.add(download_key)
|
||
elif download.state in individual_cleanup_states:
|
||
# These need individual removal calls
|
||
download_info = {
|
||
'username': download.username,
|
||
'id': download.id,
|
||
'state': download.state
|
||
}
|
||
new_individual_cleanup.append(download_info)
|
||
|
||
if new_bulk_cleanup or new_individual_cleanup:
|
||
print(f"[CLEANUP] Found {len(new_bulk_cleanup)} bulk + {len(new_individual_cleanup)} individual downloads needing cleanup")
|
||
self.downloads_to_cleanup.update(new_bulk_cleanup)
|
||
if new_individual_cleanup:
|
||
# Store individual cleanup items separately
|
||
if not hasattr(self, 'individual_downloads_to_cleanup'):
|
||
self.individual_downloads_to_cleanup = []
|
||
self.individual_downloads_to_cleanup.extend(new_individual_cleanup)
|
||
except Exception as e:
|
||
print(f"[ERROR] Error checking backend downloads: {e}")
|
||
|
||
# Run in background to avoid blocking UI
|
||
def run_check():
|
||
import asyncio
|
||
try:
|
||
loop = asyncio.new_event_loop()
|
||
asyncio.set_event_loop(loop)
|
||
loop.run_until_complete(check_backend_downloads())
|
||
finally:
|
||
try:
|
||
loop.close()
|
||
except Exception:
|
||
pass
|
||
|
||
from concurrent.futures import ThreadPoolExecutor
|
||
with ThreadPoolExecutor(max_workers=1) as executor:
|
||
executor.submit(run_check)
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Error finding downloads for cleanup: {e}")
|
||
|
||
def _cleanup_backend_downloads(self, download_keys):
|
||
"""Clean up specific downloads from backend"""
|
||
try:
|
||
def do_cleanup():
|
||
try:
|
||
# Use the existing clear all completed downloads method
|
||
# This is simpler and more reliable than individual cleanup
|
||
success = self.soulseek_client.clear_all_completed_downloads()
|
||
if success:
|
||
print(f"[CLEANUP] Successfully cleared completed downloads from backend")
|
||
else:
|
||
print(f"[CLEANUP] Failed to clear completed downloads from backend")
|
||
except Exception as e:
|
||
print(f"[ERROR] Error during backend cleanup: {e}")
|
||
|
||
# Run cleanup in background
|
||
from concurrent.futures import ThreadPoolExecutor
|
||
with ThreadPoolExecutor(max_workers=1) as executor:
|
||
executor.submit(do_cleanup)
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Error in cleanup backend downloads: {e}")
|
||
|
||
def _cleanup_individual_downloads(self, download_infos):
|
||
"""Clean up specific errored downloads individually using cancel_download with remove=True"""
|
||
try:
|
||
def do_individual_cleanup():
|
||
try:
|
||
import asyncio
|
||
|
||
async def cleanup_downloads():
|
||
success_count = 0
|
||
for download_info in download_infos:
|
||
try:
|
||
username = download_info['username']
|
||
download_id = download_info['id']
|
||
state = download_info['state']
|
||
|
||
print(f"[CLEANUP] Removing {state} download: {username}/{download_id}")
|
||
success = await self.soulseek_client.cancel_download(
|
||
download_id=download_id,
|
||
username=username,
|
||
remove=True
|
||
)
|
||
|
||
if success:
|
||
success_count += 1
|
||
print(f"[CLEANUP] Successfully removed {state} download: {username}/{download_id}")
|
||
else:
|
||
print(f"[CLEANUP] Failed to remove {state} download: {username}/{download_id}")
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Error removing individual download {download_info}: {e}")
|
||
|
||
print(f"[CLEANUP] Individual cleanup completed: {success_count}/{len(download_infos)} removed")
|
||
|
||
# Run the async cleanup
|
||
asyncio.run(cleanup_downloads())
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Error during individual cleanup: {e}")
|
||
|
||
# Run cleanup in background
|
||
from concurrent.futures import ThreadPoolExecutor
|
||
with ThreadPoolExecutor(max_workers=1) as executor:
|
||
executor.submit(do_individual_cleanup)
|
||
|
||
except Exception as e:
|
||
print(f"[ERROR] Error in cleanup individual downloads: {e}")
|
||
|
||
|
||
def cleanup_all_threads(self):
|
||
"""Stop and cleanup all active threads"""
|
||
try:
|
||
# Stop download status timer first
|
||
if hasattr(self, 'download_status_timer'):
|
||
self.download_status_timer.stop()
|
||
|
||
# Stop search thread
|
||
if self.search_thread and self.search_thread.isRunning():
|
||
self.search_thread.stop()
|
||
self.search_thread.wait(2000) # Wait up to 2 seconds
|
||
if self.search_thread.isRunning():
|
||
self.search_thread.terminate()
|
||
self.search_thread.wait(1000)
|
||
self.search_thread.deleteLater()
|
||
self.search_thread = None
|
||
|
||
# Stop explore thread
|
||
if self.explore_thread and self.explore_thread.isRunning():
|
||
self.explore_thread.stop()
|
||
self.explore_thread.wait(2000) # Wait up to 2 seconds
|
||
if self.explore_thread.isRunning():
|
||
self.explore_thread.terminate()
|
||
self.explore_thread.wait(1000)
|
||
self.explore_thread.deleteLater()
|
||
self.explore_thread = None
|
||
|
||
# Stop session thread
|
||
if self.session_thread and self.session_thread.isRunning():
|
||
self.session_thread.stop()
|
||
self.session_thread.wait(2000) # Wait up to 2 seconds
|
||
if self.session_thread.isRunning():
|
||
self.session_thread.terminate()
|
||
self.session_thread.wait(1000)
|
||
self.session_thread.deleteLater()
|
||
self.session_thread = None
|
||
|
||
# CRITICAL FIX: Stop all status update threads
|
||
for status_thread in self.status_update_threads[:]: # Copy list to avoid modification during iteration
|
||
try:
|
||
# Disconnect signals first
|
||
try:
|
||
status_thread.status_updated.disconnect()
|
||
status_thread.finished.disconnect()
|
||
except Exception:
|
||
pass # Ignore if signals are already disconnected
|
||
|
||
if status_thread.isRunning():
|
||
status_thread.stop()
|
||
status_thread.wait(2000) # Wait up to 2 seconds
|
||
if status_thread.isRunning():
|
||
status_thread.terminate()
|
||
status_thread.wait(1000)
|
||
status_thread.deleteLater()
|
||
except Exception as e:
|
||
print(f"Error cleaning up status update thread: {e}")
|
||
|
||
self.status_update_threads.clear()
|
||
|
||
# Stop all download threads with proper cleanup
|
||
for download_thread in self.download_threads[:]: # Copy list to avoid modification during iteration
|
||
try:
|
||
# Disconnect signals first
|
||
try:
|
||
download_thread.download_completed.disconnect()
|
||
download_thread.download_failed.disconnect()
|
||
download_thread.download_progress.disconnect()
|
||
download_thread.finished.disconnect()
|
||
except Exception:
|
||
pass # Ignore if signals are already disconnected
|
||
|
||
if download_thread.isRunning():
|
||
download_thread.stop()
|
||
download_thread.wait(2000) # Wait up to 2 seconds
|
||
if download_thread.isRunning():
|
||
download_thread.terminate()
|
||
download_thread.wait(1000)
|
||
download_thread.deleteLater()
|
||
except Exception as e:
|
||
print(f"Error cleaning up download thread: {e}")
|
||
|
||
self.download_threads.clear()
|
||
|
||
# Stop all API cleanup threads
|
||
for cleanup_thread in self.api_cleanup_threads[:]: # Copy list to avoid modification during iteration
|
||
try:
|
||
# Disconnect signals first
|
||
try:
|
||
cleanup_thread.cleanup_completed.disconnect()
|
||
cleanup_thread.finished.disconnect()
|
||
except Exception:
|
||
pass # Ignore if signals are already disconnected
|
||
|
||
if cleanup_thread.isRunning():
|
||
cleanup_thread.wait(2000) # Wait up to 2 seconds for completion
|
||
if cleanup_thread.isRunning():
|
||
cleanup_thread.terminate()
|
||
cleanup_thread.wait(1000)
|
||
cleanup_thread.deleteLater()
|
||
except Exception as e:
|
||
print(f"Error cleaning up API cleanup thread: {e}")
|
||
|
||
self.api_cleanup_threads.clear()
|
||
|
||
except Exception as e:
|
||
print(f"Error during thread cleanup: {e}")
|
||
|
||
def closeEvent(self, event):
|
||
"""Handle widget close event"""
|
||
self.cleanup_all_threads()
|
||
super().closeEvent(event)
|
||
|
||
def __del__(self):
|
||
"""Destructor - ensure cleanup happens even if closeEvent isn't called"""
|
||
try:
|
||
self.cleanup_all_threads()
|
||
except:
|
||
pass # Ignore errors during destruction
|
||
|
||
def on_paths_updated(self, key: str, value: str):
|
||
"""Handle settings path updates for immediate effect"""
|
||
# No action needed - paths are fetched dynamically via config_manager.get()
|
||
# This method exists for future extensibility if caching is added later
|
||
pass
|
||
|
||
def create_controls_section(self):
|
||
section = QWidget()
|
||
layout = QVBoxLayout(section)
|
||
layout.setSpacing(20)
|
||
|
||
# Download controls
|
||
controls_frame = QFrame()
|
||
controls_frame.setStyleSheet("""
|
||
QFrame {
|
||
background: #282828;
|
||
border-radius: 8px;
|
||
border: 1px solid #404040;
|
||
}
|
||
""")
|
||
|
||
controls_layout = QVBoxLayout(controls_frame)
|
||
controls_layout.setContentsMargins(20, 20, 20, 20)
|
||
controls_layout.setSpacing(15)
|
||
|
||
# Controls title
|
||
controls_title = QLabel("Download Controls")
|
||
controls_title.setFont(QFont("Arial", 14, QFont.Weight.Bold))
|
||
controls_title.setStyleSheet("color: #ffffff;")
|
||
|
||
# Pause/Resume button
|
||
pause_btn = QPushButton("Pause Downloads")
|
||
pause_btn.setFixedHeight(40)
|
||
pause_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: #1db954;
|
||
border: none;
|
||
border-radius: 20px;
|
||
color: #000000;
|
||
font-size: 12px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background: #1ed760;
|
||
}
|
||
""")
|
||
|
||
# Clear completed button
|
||
clear_btn = QPushButton("Clear Completed")
|
||
clear_btn.setFixedHeight(35)
|
||
clear_btn.clicked.connect(self.clear_completed_downloads) # Connect to the clearing method
|
||
clear_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: transparent;
|
||
border: 1px solid #e22134;
|
||
border-radius: 17px;
|
||
color: #e22134;
|
||
font-size: 11px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background: rgba(226, 33, 52, 0.1);
|
||
}
|
||
""")
|
||
|
||
controls_layout.addWidget(controls_title)
|
||
controls_layout.addWidget(pause_btn)
|
||
controls_layout.addWidget(clear_btn)
|
||
|
||
# Download stats
|
||
stats_frame = QFrame()
|
||
stats_frame.setStyleSheet("""
|
||
QFrame {
|
||
background: #282828;
|
||
border-radius: 8px;
|
||
border: 1px solid #404040;
|
||
}
|
||
""")
|
||
|
||
stats_layout = QVBoxLayout(stats_frame)
|
||
stats_layout.setContentsMargins(20, 20, 20, 20)
|
||
stats_layout.setSpacing(15)
|
||
|
||
# Stats title
|
||
stats_title = QLabel("Download Statistics")
|
||
stats_title.setFont(QFont("Arial", 14, QFont.Weight.Bold))
|
||
stats_title.setStyleSheet("color: #ffffff;")
|
||
|
||
# Stats items
|
||
stats_items = [
|
||
("Total Downloads", "247"),
|
||
("Completed", "238"),
|
||
("Failed", "4"),
|
||
("In Progress", "2"),
|
||
("Queued", "3")
|
||
]
|
||
|
||
stats_layout.addWidget(stats_title)
|
||
|
||
for label, value in stats_items:
|
||
item_layout = QHBoxLayout()
|
||
|
||
label_widget = QLabel(label)
|
||
label_widget.setFont(QFont("Arial", 11))
|
||
label_widget.setStyleSheet("color: #b3b3b3;")
|
||
|
||
value_widget = QLabel(value)
|
||
value_widget.setFont(QFont("Arial", 11, QFont.Weight.Bold))
|
||
value_widget.setStyleSheet("color: #ffffff;")
|
||
|
||
item_layout.addWidget(label_widget)
|
||
item_layout.addStretch()
|
||
item_layout.addWidget(value_widget)
|
||
|
||
stats_layout.addLayout(item_layout)
|
||
|
||
layout.addWidget(controls_frame)
|
||
layout.addWidget(stats_frame)
|
||
layout.addStretch()
|
||
|
||
return section
|
||
|
||
def create_missing_tracks_section(self):
|
||
section = QFrame()
|
||
section.setFixedHeight(250)
|
||
section.setStyleSheet("""
|
||
QFrame {
|
||
background: #282828;
|
||
border-radius: 8px;
|
||
border: 1px solid #404040;
|
||
}
|
||
""")
|
||
|
||
layout = QVBoxLayout(section)
|
||
layout.setContentsMargins(20, 20, 20, 20)
|
||
layout.setSpacing(15)
|
||
|
||
# Header
|
||
header_layout = QHBoxLayout()
|
||
|
||
title_label = QLabel("Missing Tracks")
|
||
title_label.setFont(QFont("Arial", 16, QFont.Weight.Bold))
|
||
title_label.setStyleSheet("color: #ffffff;")
|
||
|
||
count_label = QLabel("23 tracks")
|
||
count_label.setFont(QFont("Arial", 11))
|
||
count_label.setStyleSheet("color: #b3b3b3;")
|
||
|
||
download_all_btn = QPushButton("Download All")
|
||
download_all_btn.setFixedSize(150, 35)
|
||
download_all_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: #1db954;
|
||
border: none;
|
||
border-radius: 17px;
|
||
color: #000000;
|
||
font-size: 11px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background: #1ed760;
|
||
}
|
||
""")
|
||
|
||
header_layout.addWidget(title_label)
|
||
header_layout.addWidget(count_label)
|
||
header_layout.addStretch()
|
||
header_layout.addWidget(download_all_btn)
|
||
|
||
# Missing tracks scroll area
|
||
missing_scroll = QScrollArea()
|
||
missing_scroll.setWidgetResizable(True)
|
||
missing_scroll.setStyleSheet("""
|
||
QScrollArea {
|
||
border: none;
|
||
background: transparent;
|
||
}
|
||
QScrollBar:vertical {
|
||
background: #404040;
|
||
width: 6px;
|
||
border-radius: 3px;
|
||
}
|
||
QScrollBar::handle:vertical {
|
||
background: #1db954;
|
||
border-radius: 3px;
|
||
}
|
||
""")
|
||
|
||
missing_widget = QWidget()
|
||
missing_layout = QVBoxLayout(missing_widget)
|
||
missing_layout.setSpacing(8)
|
||
missing_layout.setContentsMargins(0, 0, 0, 0)
|
||
|
||
# Sample missing tracks with playlist info
|
||
missing_tracks = [
|
||
("Song Title 1", "Artist Name 1", "Liked Songs"),
|
||
("Another Track", "Different Artist", "Road Trip Mix"),
|
||
("Cool Song", "Band Name", "Workout Playlist"),
|
||
("Missing Hit", "Popular Artist", "Discover Weekly"),
|
||
("Rare Track", "Indie Artist", "Chill Vibes")
|
||
]
|
||
|
||
for track_title, artist, playlist in missing_tracks:
|
||
track_item = self.create_missing_track_item(track_title, artist, playlist)
|
||
missing_layout.addWidget(track_item)
|
||
|
||
missing_layout.addStretch()
|
||
missing_scroll.setWidget(missing_widget)
|
||
|
||
layout.addLayout(header_layout)
|
||
layout.addWidget(missing_scroll)
|
||
|
||
return section
|
||
|
||
def create_missing_track_item(self, track_title: str, artist: str, playlist: str):
|
||
item = QFrame()
|
||
item.setFixedHeight(45)
|
||
item.setStyleSheet("""
|
||
QFrame {
|
||
background: #333333;
|
||
border-radius: 6px;
|
||
border: 1px solid #404040;
|
||
}
|
||
QFrame:hover {
|
||
background: #3a3a3a;
|
||
border: 1px solid #1db954;
|
||
}
|
||
""")
|
||
|
||
layout = QHBoxLayout(item)
|
||
layout.setContentsMargins(12, 8, 12, 8)
|
||
layout.setSpacing(10)
|
||
|
||
# Track info
|
||
info_layout = QVBoxLayout()
|
||
info_layout.setSpacing(2)
|
||
|
||
track_label = QLabel(f"{track_title} - {artist}")
|
||
track_label.setFont(QFont("Arial", 10, QFont.Weight.Medium))
|
||
track_label.setStyleSheet("color: #ffffff;")
|
||
|
||
playlist_label = QLabel(f"from: {playlist}")
|
||
playlist_label.setFont(QFont("Arial", 9))
|
||
playlist_label.setStyleSheet("color: #1db954;")
|
||
|
||
info_layout.addWidget(track_label)
|
||
info_layout.addWidget(playlist_label)
|
||
|
||
# Download button
|
||
download_btn = QPushButton("")
|
||
download_btn.setFixedSize(30, 30)
|
||
download_btn.setStyleSheet("""
|
||
QPushButton {
|
||
background: rgba(29, 185, 84, 0.2);
|
||
border: 1px solid #1db954;
|
||
border-radius: 15px;
|
||
color: #1db954;
|
||
font-size: 12px;
|
||
}
|
||
QPushButton:hover {
|
||
background: #1db954;
|
||
color: #000000;
|
||
}
|
||
""")
|
||
|
||
layout.addLayout(info_layout)
|
||
layout.addStretch()
|
||
layout.addWidget(download_btn)
|
||
|
||
return item
|
||
|
||
def _extract_track_number_from_filename(self, filename: str, title: str = None) -> Optional[int]:
|
||
"""Extract track number from filename or title"""
|
||
try:
|
||
import re
|
||
import os
|
||
|
||
# Try extracting from title first if available
|
||
if title:
|
||
patterns = [
|
||
r'^(\d{1,2})[\.\s\-_]+', # "01. " or "01 " or "01-" or "01_"
|
||
r'^(\d{1,2})\s*[\.\-_]\s*', # "01." or "01-" or "01_" with optional spaces
|
||
r'^(\d{1,2})\s+', # "01 " (space only)
|
||
r'^(\d{1,2})[\)\]\}]\s*', # "01) " or "01] " or "01} "
|
||
r'^\[(\d{1,2})\]', # "[01]" bracket format
|
||
r'^\((\d{1,2})\)', # "(01)" parenthesis format
|
||
]
|
||
|
||
for pattern in patterns:
|
||
match = re.match(pattern, title.strip())
|
||
if match:
|
||
track_num = int(match.group(1))
|
||
print(f" Found track number in title '{title}': {track_num}")
|
||
return track_num
|
||
|
||
# Try extracting from filename
|
||
base_name = os.path.splitext(filename)[0] # Remove extension
|
||
|
||
patterns = [
|
||
r'^(\d{1,2})[\.\s\-_]+', # "01. " or "01 " or "01-" or "01_"
|
||
r'^(\d{1,2})\s*[\.\-_]\s*', # "01." or "01-" or "01_" with optional spaces
|
||
r'^(\d{1,2})\s+', # "01 " (space only)
|
||
r'^(\d{1,2})[\)\]\}]\s*', # "01) " or "01] " or "01} "
|
||
r'^\[(\d{1,2})\]', # "[01]" bracket format
|
||
r'^\((\d{1,2})\)', # "(01)" parenthesis format
|
||
r'^Track\s*(\d{1,2})', # "Track 01" or "Track01"
|
||
r'^T(\d{1,2})', # "T01" format
|
||
]
|
||
|
||
for pattern in patterns:
|
||
match = re.match(pattern, base_name.strip())
|
||
if match:
|
||
track_num = int(match.group(1))
|
||
print(f" Found track number in filename '{filename}': {track_num}")
|
||
return track_num
|
||
|
||
print(f" No track number found in filename: '{filename}'")
|
||
return None
|
||
|
||
except Exception as e:
|
||
print(f"Error extracting track number from filename: {e}")
|
||
return None
|
||
|
||
def _get_spotify_album_tracks(self, selected_album: Album) -> List[dict]:
|
||
"""Fetch all tracks from the selected Spotify album"""
|
||
try:
|
||
print(f"Fetching tracks from Spotify album: {selected_album.name}")
|
||
tracks_data = self.spotify_client.get_album_tracks(selected_album.id)
|
||
|
||
if tracks_data and 'items' in tracks_data:
|
||
tracks = []
|
||
for track_data in tracks_data['items']:
|
||
tracks.append({
|
||
'name': track_data['name'],
|
||
'track_number': track_data['track_number'],
|
||
'duration_ms': track_data['duration_ms'],
|
||
'id': track_data['id']
|
||
})
|
||
print(f"Found {len(tracks)} tracks in Spotify album")
|
||
return tracks
|
||
else:
|
||
print(f"No tracks found in Spotify album")
|
||
return []
|
||
|
||
except Exception as e:
|
||
print(f"Error fetching Spotify album tracks: {e}")
|
||
return []
|
||
|
||
def _match_track_to_spotify_title(self, track, spotify_tracks: List[dict]) -> Optional[str]:
|
||
"""Match a downloaded track to a Spotify track title using similarity scoring"""
|
||
try:
|
||
if not spotify_tracks:
|
||
return None
|
||
|
||
original_title = track.title
|
||
print(f"Matching track: '{original_title}'")
|
||
|
||
# Clean the original title by removing track number prefixes
|
||
import re
|
||
cleaned_original = original_title
|
||
track_num_match = re.match(r'^(\d+)\s*[\.\-_]\s*(.+)', cleaned_original.strip())
|
||
if track_num_match:
|
||
cleaned_original = track_num_match.group(2).strip()
|
||
print(f" Cleaned title (removed track number): '{cleaned_original}'")
|
||
|
||
best_match = None
|
||
best_score = 0.0
|
||
|
||
# Try matching by track number first (most reliable)
|
||
if hasattr(track, 'track_number') and track.track_number:
|
||
for spotify_track in spotify_tracks:
|
||
if spotify_track['track_number'] == track.track_number:
|
||
print(f"Matched by track number {track.track_number}: '{spotify_track['name']}'")
|
||
return spotify_track['name']
|
||
|
||
# Fallback to title similarity matching using cleaned titles
|
||
for spotify_track in spotify_tracks:
|
||
# Normalize both titles for comparison (use cleaned original)
|
||
normalized_original = self.matching_engine.normalize_string(cleaned_original)
|
||
normalized_spotify = self.matching_engine.normalize_string(spotify_track['name'])
|
||
|
||
print(f" Comparing: '{normalized_original}' vs '{normalized_spotify}'")
|
||
|
||
# Calculate similarity score
|
||
score = self.matching_engine.similarity_score(normalized_original, normalized_spotify)
|
||
|
||
if score > best_score:
|
||
best_score = score
|
||
best_match = spotify_track
|
||
print(f" New best match ({score:.2f}): '{spotify_track['name']}'")
|
||
|
||
# Only return match if confidence is high enough
|
||
if best_match and best_score >= 0.6: # 60% similarity threshold
|
||
print(f"Matched by title similarity ({best_score:.2f}): '{best_match['name']}'")
|
||
return best_match['name']
|
||
else:
|
||
print(f"No good title match found (best score: {best_score:.2f})")
|
||
return None
|
||
|
||
except Exception as e:
|
||
print(f"Error matching track to Spotify title: {e}")
|
||
return None
|
||
|
||
# In downloads.py, add this new method inside the DownloadsPage class (e.g., after load_more_results)
|
||
|
||
def _load_next_result_item(self):
|
||
"""
|
||
Processes one item from the loading queue and schedules the next.
|
||
This breaks up the work into small, non-blocking chunks.
|
||
"""
|
||
if not self._results_to_load_queue:
|
||
self.is_loading_more = False
|
||
return
|
||
|
||
# Pop one result from the front of the queue
|
||
result = self._results_to_load_queue.pop(0)
|
||
|
||
# Create the appropriate widget for the result
|
||
if isinstance(result, AlbumResult):
|
||
result_item = AlbumResultItem(result)
|
||
result_item.album_download_requested.connect(self.start_album_download)
|
||
result_item.matched_album_download_requested.connect(self.start_matched_album_download)
|
||
result_item.track_download_requested.connect(self.start_download)
|
||
result_item.track_stream_requested.connect(lambda r, i=result_item: self.start_stream(r, i))
|
||
else:
|
||
result_item = SearchResultItem(result)
|
||
result_item.download_requested.connect(self.start_download)
|
||
result_item.stream_requested.connect(lambda r, i=result_item: self.start_stream(r, i))
|
||
result_item.expansion_requested.connect(self.handle_expansion_request)
|
||
|
||
# Insert the newly created widget into the layout
|
||
insert_position = self.search_results_layout.count() - 1
|
||
self.search_results_layout.insertWidget(insert_position, result_item)
|
||
self.displayed_results += 1
|
||
|
||
# If there are more items in the queue, schedule the next one immediately
|
||
if self._results_to_load_queue:
|
||
QTimer.singleShot(0, self._load_next_result_item)
|
||
else:
|
||
# All items for this batch are loaded
|
||
self.is_loading_more = False
|
||
# Update the status message now that loading is complete
|
||
total_filtered = len(self.current_filtered_results)
|
||
if self.displayed_results < total_filtered:
|
||
remaining = total_filtered - self.displayed_results
|
||
self.update_search_status(f"Showing {self.displayed_results} of {total_filtered} results (scroll for {remaining} more)", "#1db954")
|
||
else:
|
||
self.update_search_status(f"Showing all {total_filtered} results", "#1db954")
|
||
|
||
# In class DownloadsPage, add this new method
|
||
|
||
def _handle_processed_status_updates(self, results):
|
||
"""
|
||
This runs on the main thread and applies updates from the background worker.
|
||
It crucially updates download_id and username before moving items to ensure
|
||
API cleanup works correctly.
|
||
"""
|
||
# Create a lookup for active items by their memory ID for fast access
|
||
items_by_id = {id(item): item for item in self.download_queue.active_queue.download_items}
|
||
|
||
items_to_move = []
|
||
|
||
# Batch UI updates to prevent multiple repaints
|
||
self.download_queue.setUpdatesEnabled(False)
|
||
|
||
for result in results:
|
||
download_item = items_by_id.get(result['widget_id'])
|
||
if not download_item:
|
||
continue
|
||
|
||
# **THE CRITICAL FIX IS HERE:**
|
||
# Update the item with the real transfer ID and username from the API.
|
||
# This ensures that when move_to_finished is called, it has the correct data for API cleanup.
|
||
if result.get('transfer_id'):
|
||
download_item.download_id = result['transfer_id']
|
||
if result.get('username'):
|
||
download_item.username = result['username']
|
||
|
||
# Update the item's visual status
|
||
download_item.update_status(
|
||
status=result['status'],
|
||
progress=result['progress'],
|
||
download_speed=result['speed'],
|
||
file_path=result['path']
|
||
)
|
||
|
||
action = result.get('action')
|
||
new_status = result['status']
|
||
|
||
if new_status == 'completed' and action == 'process_matched_completion':
|
||
# This is a matched download that just finished.
|
||
if download_item.mark_completion_processed():
|
||
worker = DownloadCompletionWorker(
|
||
download_item=download_item,
|
||
absolute_file_path=result['path'],
|
||
organize_func=self._organize_matched_download
|
||
)
|
||
worker.signals.completed.connect(self._on_download_completion_finished)
|
||
worker.signals.error.connect(self._on_download_completion_error)
|
||
self.completion_thread_pool.start(worker)
|
||
|
||
elif new_status in ['completed', 'failed', 'cancelled']:
|
||
# For regular completed items or any failed/cancelled item.
|
||
if download_item not in items_to_move:
|
||
items_to_move.append(download_item)
|
||
|
||
# Now, move all the items that need moving in one go
|
||
for item in items_to_move:
|
||
self.download_queue.move_to_finished(item)
|
||
|
||
# Re-enable UI updates and trigger a single repaint
|
||
self.download_queue.setUpdatesEnabled(True)
|
||
self.download_queue.update()
|
||
self.download_queue.update_tab_counts()
|
||
|
||
# Allow the next worker to run
|
||
self._is_status_update_running = False
|
||
|
||
# =====================================
|
||
# METADATA ENHANCEMENT SYSTEM
|
||
# =====================================
|
||
|
||
def _enhance_file_metadata(self, file_path: str, download_item, artist: Artist, album_info: dict) -> bool:
|
||
"""
|
||
Core function to enhance audio file metadata using Spotify data
|
||
|
||
Args:
|
||
file_path: Path to the audio file in Transfer folder
|
||
download_item: Original search result with attached Spotify metadata
|
||
artist: Matched Spotify Artist object
|
||
album_info: Album detection results with track numbering
|
||
|
||
Returns:
|
||
bool: Success/failure of metadata enhancement
|
||
"""
|
||
try:
|
||
# Check if metadata enhancement is enabled
|
||
if not config_manager.get('metadata_enhancement.enabled', True):
|
||
print("Metadata enhancement disabled in config")
|
||
return True
|
||
|
||
print(f"Enhancing metadata for: {os.path.basename(file_path)}")
|
||
|
||
# Load the audio file
|
||
audio_file = MutagenFile(file_path)
|
||
if audio_file is None:
|
||
print(f"Could not load audio file with Mutagen: {file_path}")
|
||
return False
|
||
|
||
# Extract comprehensive metadata from Spotify
|
||
metadata = self._extract_spotify_metadata(download_item, artist, album_info)
|
||
if not metadata:
|
||
print(f"Could not extract Spotify metadata, preserving original tags")
|
||
return True
|
||
|
||
# Determine file format and apply appropriate tags
|
||
file_format = self._detect_audio_format(file_path, audio_file)
|
||
success = False
|
||
|
||
if file_format == 'mp3':
|
||
print(f"Applying ID3 tags for {file_path}")
|
||
success = self._apply_id3_tags(audio_file, metadata, file_path)
|
||
elif file_format == 'flac':
|
||
print(f"Applying FLAC tags for {file_path}")
|
||
success = self._apply_flac_tags(audio_file, metadata, file_path)
|
||
elif file_format in ['mp4', 'm4a']:
|
||
print(f"Applying MP4 tags for {file_path}")
|
||
success = self._apply_mp4_tags(audio_file, metadata, file_path)
|
||
elif file_format == 'ogg':
|
||
print(f"Applying OGG tags for {file_path}")
|
||
success = self._apply_ogg_tags(audio_file, metadata, file_path)
|
||
else:
|
||
print(f"Unsupported audio format for metadata enhancement: {file_format}")
|
||
return True
|
||
|
||
if success:
|
||
# Optionally embed album art
|
||
if config_manager.get('metadata_enhancement.embed_album_art', True):
|
||
self._embed_album_art_metadata(file_path, audio_file, metadata, file_format)
|
||
|
||
print(f"Metadata enhanced with Spotify data")
|
||
return True
|
||
else:
|
||
print(f"Metadata enhancement failed, original tags preserved")
|
||
return False
|
||
|
||
except Exception as e:
|
||
print(f"Error enhancing metadata for {file_path}: {e}")
|
||
return False
|
||
|
||
def _extract_spotify_metadata(self, download_item, artist: Artist, album_info: dict) -> dict:
|
||
"""
|
||
Extract comprehensive metadata from Spotify objects
|
||
|
||
Returns complete metadata dictionary with:
|
||
- Basic tags (title, artist, album, year, track#)
|
||
- Advanced tags (genres, album artist, total tracks)
|
||
- Plex-specific optimizations
|
||
- Album art URL for embedding
|
||
- Spotify IDs for future enhancements
|
||
"""
|
||
try:
|
||
metadata = {}
|
||
|
||
# Debug: Log what we're working with
|
||
print(f"Extracting metadata for: {download_item.title}")
|
||
print(f" - Artist: {artist.name if artist else 'None'}")
|
||
print(f" - Album info: {album_info}")
|
||
print(f" - Has _spotify_clean_title: {hasattr(download_item, '_spotify_clean_title')}")
|
||
print(f" - Has matched_album: {hasattr(download_item, 'matched_album')}")
|
||
|
||
if not artist:
|
||
print(f"No artist provided for metadata extraction")
|
||
return {}
|
||
|
||
# Basic track information
|
||
metadata['title'] = getattr(download_item, '_spotify_clean_title', download_item.title)
|
||
metadata['artist'] = artist.name
|
||
metadata['album_artist'] = artist.name # Critical for Plex
|
||
|
||
# Album information
|
||
if album_info and album_info.get('is_album'):
|
||
metadata['album'] = album_info.get('album_name', 'Unknown Album')
|
||
metadata['track_number'] = album_info.get('track_number', 1)
|
||
metadata['total_tracks'] = album_info.get('total_tracks', 1)
|
||
if album_info.get('disc_number'):
|
||
metadata['disc_number'] = album_info['disc_number']
|
||
else:
|
||
# Single track
|
||
metadata['album'] = metadata['title'] # For singles, album = title
|
||
metadata['track_number'] = 1
|
||
metadata['total_tracks'] = 1
|
||
|
||
# Release date
|
||
if hasattr(download_item, 'matched_album') and download_item.matched_album:
|
||
if hasattr(download_item.matched_album, 'release_date'):
|
||
metadata['date'] = download_item.matched_album.release_date[:4] if download_item.matched_album.release_date else None
|
||
|
||
# Genre information from artist
|
||
if hasattr(artist, 'genres') and artist.genres:
|
||
# Use first genre or combine multiple
|
||
if len(artist.genres) == 1:
|
||
metadata['genre'] = artist.genres[0]
|
||
else:
|
||
# Combine up to 3 genres
|
||
metadata['genre'] = ', '.join(artist.genres[:3])
|
||
|
||
# Album art URL
|
||
if hasattr(download_item, 'matched_album') and download_item.matched_album:
|
||
if hasattr(download_item.matched_album, 'image_url') and download_item.matched_album.image_url:
|
||
metadata['album_art_url'] = download_item.matched_album.image_url
|
||
|
||
# Spotify IDs for future enhancements
|
||
metadata['spotify_artist_id'] = artist.id if hasattr(artist, 'id') else None
|
||
if hasattr(download_item, 'matched_album') and download_item.matched_album:
|
||
metadata['spotify_album_id'] = getattr(download_item.matched_album, 'id', None)
|
||
|
||
print(f"Extracted metadata summary:")
|
||
print(f" - Title: {metadata.get('title')}")
|
||
print(f" - Artist: {metadata.get('artist')}")
|
||
print(f" - Album: {metadata.get('album')}")
|
||
print(f" - Track #: {metadata.get('track_number')}")
|
||
print(f" - Date: {metadata.get('date')}")
|
||
print(f" - Genre: {metadata.get('genre')}")
|
||
print(f" - Album art: {'Yes' if metadata.get('album_art_url') else 'No'}")
|
||
print(f" - Total fields: {len(metadata)}")
|
||
|
||
# Special debugging for problematic tracks
|
||
if metadata.get('title') == 'Tell Me What You Want' or metadata.get('track_number') == 13:
|
||
print(f"[DEBUG] Special track detected - Tell Me What You Want:")
|
||
print(f" - Full metadata dict: {metadata}")
|
||
print(f" - Album info dict: {album_info}")
|
||
print(f" - Artist object: {artist}")
|
||
if hasattr(download_item, 'matched_album'):
|
||
print(f" - matched_album: {download_item.matched_album}")
|
||
else:
|
||
print(f" - No matched_album attribute")
|
||
|
||
return metadata
|
||
|
||
except Exception as e:
|
||
print(f"Error extracting Spotify metadata: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return {}
|
||
|
||
def _detect_audio_format(self, file_path: str, audio_file) -> str:
|
||
"""Detect the audio format for appropriate tag handling"""
|
||
try:
|
||
file_ext = os.path.splitext(file_path)[1].lower()
|
||
|
||
# Direct extension mapping
|
||
format_map = {
|
||
'.mp3': 'mp3',
|
||
'.flac': 'flac',
|
||
'.m4a': 'm4a',
|
||
'.mp4': 'mp4',
|
||
'.ogg': 'ogg',
|
||
'.oga': 'ogg'
|
||
}
|
||
|
||
if file_ext in format_map:
|
||
return format_map[file_ext]
|
||
|
||
# Fallback to mutagen detection
|
||
if hasattr(audio_file, 'mime'):
|
||
mime_type = audio_file.mime[0] if audio_file.mime else ''
|
||
if 'mp3' in mime_type or 'mpeg' in mime_type:
|
||
return 'mp3'
|
||
elif 'flac' in mime_type:
|
||
return 'flac'
|
||
elif 'mp4' in mime_type or 'm4a' in mime_type:
|
||
return 'mp4'
|
||
elif 'ogg' in mime_type:
|
||
return 'ogg'
|
||
|
||
return 'unknown'
|
||
|
||
except Exception as e:
|
||
print(f"Could not detect audio format: {e}")
|
||
return 'unknown'
|
||
|
||
def _apply_id3_tags(self, audio_file, metadata: dict, file_path: str) -> bool:
|
||
"""Handle MP3 ID3v2.4 tags with full Unicode support"""
|
||
try:
|
||
# Ensure ID3 tags exist
|
||
if not hasattr(audio_file, 'tags') or audio_file.tags is None:
|
||
audio_file.add_tags()
|
||
|
||
tags = audio_file.tags
|
||
|
||
# Basic tags
|
||
tags.setall('TIT2', [TIT2(encoding=3, text=metadata.get('title', ''))]) # Title
|
||
tags.setall('TPE1', [TPE1(encoding=3, text=metadata.get('artist', ''))]) # Artist
|
||
tags.setall('TPE2', [TPE2(encoding=3, text=metadata.get('album_artist', ''))]) # Album Artist
|
||
tags.setall('TALB', [TALB(encoding=3, text=metadata.get('album', ''))]) # Album
|
||
|
||
# Date
|
||
if metadata.get('date'):
|
||
tags.setall('TDRC', [TDRC(encoding=3, text=metadata['date'])])
|
||
|
||
# Track number
|
||
track_text = f"{metadata.get('track_number', 1)}/{metadata.get('total_tracks', 1)}"
|
||
tags.setall('TRCK', [TRCK(encoding=3, text=track_text)])
|
||
|
||
# Genre
|
||
if metadata.get('genre'):
|
||
tags.setall('TCON', [TCON(encoding=3, text=metadata['genre'])])
|
||
|
||
# Disc number
|
||
if metadata.get('disc_number'):
|
||
tags.setall('TPOS', [TPOS(encoding=3, text=str(metadata['disc_number']))])
|
||
|
||
# Spotify IDs for future reference
|
||
if metadata.get('spotify_artist_id'):
|
||
tags.setall('TXXX:Spotify Artist ID', [TXXX(encoding=3, desc='Spotify Artist ID', text=metadata['spotify_artist_id'])])
|
||
if metadata.get('spotify_album_id'):
|
||
tags.setall('TXXX:Spotify Album ID', [TXXX(encoding=3, desc='Spotify Album ID', text=metadata['spotify_album_id'])])
|
||
|
||
|
||
|
||
audio_file.save()
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"Error applying ID3 tags: {e}")
|
||
return False
|
||
|
||
def _apply_flac_tags(self, audio_file, metadata: dict, file_path: str) -> bool:
|
||
"""Handle FLAC Vorbis comments for lossless files"""
|
||
try:
|
||
print(f"Applying FLAC tags with {len(metadata)} metadata fields")
|
||
|
||
# Read existing tags first to preserve non-empty values
|
||
existing_title = audio_file.get('TITLE', [''])[0] if audio_file.get('TITLE') else ''
|
||
existing_artist = audio_file.get('ARTIST', [''])[0] if audio_file.get('ARTIST') else ''
|
||
existing_album = audio_file.get('ALBUM', [''])[0] if audio_file.get('ALBUM') else ''
|
||
existing_date = audio_file.get('DATE', [''])[0] if audio_file.get('DATE') else ''
|
||
existing_genre = audio_file.get('GENRE', [''])[0] if audio_file.get('GENRE') else ''
|
||
|
||
print(f" - Existing tags: Title='{existing_title}', Artist='{existing_artist}', Album='{existing_album}'")
|
||
|
||
# Only update if we have non-empty Spotify data OR if existing tag is empty
|
||
if metadata.get('title') and metadata.get('title').strip():
|
||
audio_file['TITLE'] = metadata['title']
|
||
print(f" - Updated TITLE: '{existing_title}' → '{metadata['title']}'")
|
||
elif existing_title:
|
||
print(f" - Preserving existing TITLE: '{existing_title}' (Spotify data empty)")
|
||
|
||
if metadata.get('artist') and metadata.get('artist').strip():
|
||
audio_file['ARTIST'] = metadata['artist']
|
||
print(f" - Updated ARTIST: '{existing_artist}' → '{metadata['artist']}'")
|
||
elif existing_artist:
|
||
print(f" - Preserving existing ARTIST: '{existing_artist}' (Spotify data empty)")
|
||
|
||
if metadata.get('album_artist') and metadata.get('album_artist').strip():
|
||
audio_file['ALBUMARTIST'] = metadata['album_artist']
|
||
elif not audio_file.get('ALBUMARTIST'):
|
||
audio_file['ALBUMARTIST'] = metadata.get('album_artist', '')
|
||
|
||
if metadata.get('album') and metadata.get('album').strip():
|
||
audio_file['ALBUM'] = metadata['album']
|
||
print(f" - Updated ALBUM: '{existing_album}' → '{metadata['album']}'")
|
||
elif existing_album:
|
||
print(f" - Preserving existing ALBUM: '{existing_album}' (Spotify data empty)")
|
||
|
||
# Date - only update if we have a date and existing is empty OR we have better data
|
||
if metadata.get('date') and metadata.get('date').strip():
|
||
audio_file['DATE'] = metadata['date']
|
||
print(f" - Updated DATE: '{existing_date}' → '{metadata['date']}'")
|
||
elif existing_date:
|
||
print(f" - Preserving existing DATE: '{existing_date}' (Spotify data empty)")
|
||
|
||
# Track number - always update since this comes from album detection
|
||
audio_file['TRACKNUMBER'] = str(metadata.get('track_number', 1))
|
||
audio_file['TRACKTOTAL'] = str(metadata.get('total_tracks', 1))
|
||
|
||
# Genre - only update if we have genre data and existing is empty OR we have better data
|
||
if metadata.get('genre') and metadata.get('genre').strip():
|
||
audio_file['GENRE'] = metadata['genre']
|
||
print(f" - Updated GENRE: '{existing_genre}' → '{metadata['genre']}'")
|
||
elif existing_genre:
|
||
print(f" - Preserving existing GENRE: '{existing_genre}' (Spotify data empty)")
|
||
|
||
# Disc number
|
||
if metadata.get('disc_number'):
|
||
audio_file['DISCNUMBER'] = str(metadata['disc_number'])
|
||
|
||
# Spotify IDs
|
||
if metadata.get('spotify_artist_id'):
|
||
audio_file['SPOTIFY_ARTIST_ID'] = metadata['spotify_artist_id']
|
||
if metadata.get('spotify_album_id'):
|
||
audio_file['SPOTIFY_ALBUM_ID'] = metadata['spotify_album_id']
|
||
|
||
|
||
print(f" - Saving FLAC file with enhanced metadata...")
|
||
audio_file.save()
|
||
print(f" - FLAC tags saved successfully")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"Error applying FLAC tags: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def _apply_mp4_tags(self, audio_file, metadata: dict, file_path: str) -> bool:
|
||
"""Handle MP4/M4A iTunes-style tags"""
|
||
try:
|
||
# Basic tags
|
||
audio_file['\xa9nam'] = [metadata.get('title', '')] # Title
|
||
audio_file['\xa9ART'] = [metadata.get('artist', '')] # Artist
|
||
audio_file['aART'] = [metadata.get('album_artist', '')] # Album Artist
|
||
audio_file['\xa9alb'] = [metadata.get('album', '')] # Album
|
||
|
||
# Date
|
||
if metadata.get('date'):
|
||
audio_file['\xa9day'] = [metadata['date']]
|
||
|
||
# Track number
|
||
track_num = metadata.get('track_number', 1)
|
||
total_tracks = metadata.get('total_tracks', 1)
|
||
audio_file['trkn'] = [(track_num, total_tracks)]
|
||
|
||
# Genre
|
||
if metadata.get('genre'):
|
||
audio_file['\xa9gen'] = [metadata['genre']]
|
||
|
||
# Disc number
|
||
if metadata.get('disc_number'):
|
||
audio_file['disk'] = [(metadata['disc_number'], 0)]
|
||
|
||
# Spotify IDs (using custom tags)
|
||
if metadata.get('spotify_artist_id'):
|
||
audio_file['----:com.apple.iTunes:Spotify Artist ID'] = [metadata['spotify_artist_id'].encode('utf-8')]
|
||
if metadata.get('spotify_album_id'):
|
||
audio_file['----:com.apple.iTunes:Spotify Album ID'] = [metadata['spotify_album_id'].encode('utf-8')]
|
||
|
||
|
||
|
||
audio_file.save()
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"Error applying MP4 tags: {e}")
|
||
return False
|
||
|
||
def _apply_ogg_tags(self, audio_file, metadata: dict, file_path: str) -> bool:
|
||
"""Handle OGG Vorbis comments"""
|
||
try:
|
||
# Basic tags
|
||
audio_file['TITLE'] = metadata.get('title', '')
|
||
audio_file['ARTIST'] = metadata.get('artist', '')
|
||
audio_file['ALBUMARTIST'] = metadata.get('album_artist', '')
|
||
audio_file['ALBUM'] = metadata.get('album', '')
|
||
|
||
# Date
|
||
if metadata.get('date'):
|
||
audio_file['DATE'] = metadata['date']
|
||
|
||
# Track number
|
||
audio_file['TRACKNUMBER'] = str(metadata.get('track_number', 1))
|
||
audio_file['TRACKTOTAL'] = str(metadata.get('total_tracks', 1))
|
||
|
||
# Genre
|
||
if metadata.get('genre'):
|
||
audio_file['GENRE'] = metadata['genre']
|
||
|
||
# Disc number
|
||
if metadata.get('disc_number'):
|
||
audio_file['DISCNUMBER'] = str(metadata['disc_number'])
|
||
|
||
# Spotify IDs
|
||
if metadata.get('spotify_artist_id'):
|
||
audio_file['SPOTIFY_ARTIST_ID'] = metadata['spotify_artist_id']
|
||
if metadata.get('spotify_album_id'):
|
||
audio_file['SPOTIFY_ALBUM_ID'] = metadata['spotify_album_id']
|
||
|
||
audio_file.save()
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"Error applying OGG tags: {e}")
|
||
return False
|
||
|
||
def _embed_album_art_metadata(self, file_path: str, audio_file, metadata: dict, file_format: str) -> bool:
|
||
"""Download and embed high-quality Spotify album art"""
|
||
try:
|
||
if not metadata.get('album_art_url'):
|
||
print("No album art URL available for embedding")
|
||
return True
|
||
|
||
print(f"Downloading album art for embedding...")
|
||
|
||
# Download album art
|
||
album_art_url = metadata['album_art_url']
|
||
response = urllib.request.urlopen(album_art_url, timeout=10)
|
||
image_data = response.read()
|
||
|
||
if not image_data:
|
||
print("Failed to download album art data")
|
||
return False
|
||
|
||
# Determine image format
|
||
image_format = 'image/jpeg' # Spotify typically uses JPEG
|
||
|
||
# Embed based on format
|
||
if file_format == 'mp3':
|
||
if not hasattr(audio_file, 'tags') or audio_file.tags is None:
|
||
audio_file.add_tags()
|
||
|
||
audio_file.tags.setall('APIC', [APIC(
|
||
encoding=3, # UTF-8
|
||
mime=image_format,
|
||
type=3, # Cover (front)
|
||
desc='Cover',
|
||
data=image_data
|
||
)])
|
||
|
||
elif file_format == 'flac':
|
||
picture = Picture()
|
||
picture.data = image_data
|
||
picture.type = 3 # Cover (front)
|
||
picture.mime = image_format
|
||
picture.width = 640
|
||
picture.height = 640
|
||
picture.depth = 24
|
||
audio_file.add_picture(picture)
|
||
|
||
elif file_format in ['mp4', 'm4a']:
|
||
if image_format == 'image/jpeg':
|
||
audio_file['covr'] = [MP4Cover(image_data, imageformat=MP4Cover.FORMAT_JPEG)]
|
||
else:
|
||
audio_file['covr'] = [MP4Cover(image_data, imageformat=MP4Cover.FORMAT_PNG)]
|
||
|
||
# Save with embedded art
|
||
audio_file.save()
|
||
print(f"Album art successfully embedded")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"Error embedding album art: {e}")
|
||
return False
|
||
|
||
def cleanup_resources(self):
|
||
"""Clean up resources when page is destroyed"""
|
||
try:
|
||
# Shutdown thread pools
|
||
if hasattr(self, 'api_thread_pool'):
|
||
self.api_thread_pool.shutdown(wait=False)
|
||
print("API thread pool shutdown")
|
||
|
||
if hasattr(self, 'completion_thread_pool'):
|
||
self.completion_thread_pool.waitForDone(3000) # Wait up to 3 seconds for completion
|
||
print("Completion thread pool shutdown")
|
||
except Exception as e:
|
||
print(f"Error during resource cleanup: {e}") |