385 lines
18 KiB
Python
385 lines
18 KiB
Python
|
# tidal_dl_ng/gui_playlist.py
|
||
|
|
|
||
|
|
from typing import TYPE_CHECKING
|
||
|
|
|
||
|
|
from PySide6 import QtCore, QtWidgets
|
||
|
|
from tidalapi import Album, Mix, Playlist, UserPlaylist
|
||
|
|
from tidalapi.playlist import Folder
|
||
|
|
|
||
|
|
from tidal_dl_ng.constants import FAVORITES, TidalLists
|
||
|
|
from tidal_dl_ng.helper.gui import get_user_list_media_item, set_user_list_media
|
||
|
|
from tidal_dl_ng.helper.tidal import (
|
||
|
|
favorite_function_factory,
|
||
|
|
items_results_all,
|
||
|
|
user_media_lists,
|
||
|
|
)
|
||
|
|
from tidal_dl_ng.logger import logger_gui
|
||
|
|
from tidal_dl_ng.model.gui_data import StatusbarMessage
|
||
|
|
|
||
|
|
if TYPE_CHECKING:
|
||
|
|
from tidal_dl_ng.gui import MainWindow
|
||
|
|
|
||
|
|
|
||
|
|
class GuiPlaylistManager:
|
||
|
|
"""Manages the playlist, mixes, and favorites GUI and logic."""
|
||
|
|
|
||
|
|
def __init__(self, main_window: "MainWindow"):
|
||
|
|
"""Initialize the playlist manager."""
|
||
|
|
self.main_window: "MainWindow" = main_window
|
||
|
|
self.settings = main_window.settings
|
||
|
|
|
||
|
|
def init_ui(self):
|
||
|
|
"""Initialize UI elements related to playlists."""
|
||
|
|
self._init_tree_lists(self.main_window.tr_lists_user)
|
||
|
|
|
||
|
|
def connect_signals(self):
|
||
|
|
"""Connect signals for playlist-related widgets."""
|
||
|
|
self.main_window.pb_reload_user_lists.clicked.connect(lambda: self.main_window.thread_it(self.tidal_user_lists))
|
||
|
|
self.main_window.tr_lists_user.itemClicked.connect(self.on_list_items_show)
|
||
|
|
self.main_window.tr_lists_user.itemExpanded.connect(self.on_tr_lists_user_expanded)
|
||
|
|
self.main_window.tr_lists_user.customContextMenuRequested.connect(self.menu_context_tree_lists)
|
||
|
|
self.main_window.s_populate_tree_lists.connect(self.on_populate_tree_lists)
|
||
|
|
self.main_window.s_populate_folder_children.connect(self.on_populate_folder_children)
|
||
|
|
|
||
|
|
def _init_tree_lists(self, tree: QtWidgets.QTreeWidget) -> None:
|
||
|
|
"""Initialize the user lists tree widget."""
|
||
|
|
tree.setColumnWidth(0, 200)
|
||
|
|
tree.setColumnHidden(1, True)
|
||
|
|
tree.setColumnWidth(2, 300)
|
||
|
|
tree.expandAll()
|
||
|
|
tree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
|
||
|
|
|
||
|
|
def tidal_user_lists(self) -> None:
|
||
|
|
"""Fetch and emit user playlists, mixes, and favorites from Tidal."""
|
||
|
|
self.main_window.s_spinner_start.emit(self.main_window.tr_lists_user)
|
||
|
|
self.main_window.s_pb_reload_status.emit(False)
|
||
|
|
user_all = user_media_lists(self.main_window.tidal.session)
|
||
|
|
self.main_window.s_populate_tree_lists.emit(user_all)
|
||
|
|
|
||
|
|
def on_populate_tree_lists(self, user_lists: dict[str, list]) -> None:
|
||
|
|
"""Populate the user lists tree with playlists, mixes, and favorites."""
|
||
|
|
twi_playlists = self.main_window.tr_lists_user.findItems(TidalLists.Playlists, QtCore.Qt.MatchExactly, 0)[0]
|
||
|
|
twi_mixes = self.main_window.tr_lists_user.findItems(TidalLists.Mixes, QtCore.Qt.MatchExactly, 0)[0]
|
||
|
|
twi_favorites = self.main_window.tr_lists_user.findItems(TidalLists.Favorites, QtCore.Qt.MatchExactly, 0)[0]
|
||
|
|
|
||
|
|
for twi in [twi_playlists, twi_mixes, twi_favorites]:
|
||
|
|
for i in reversed(range(twi.childCount())):
|
||
|
|
twi.removeChild(twi.child(i))
|
||
|
|
|
||
|
|
for item in user_lists.get("playlists", []):
|
||
|
|
if isinstance(item, Folder):
|
||
|
|
twi_child = QtWidgets.QTreeWidgetItem(twi_playlists)
|
||
|
|
twi_child.setText(0, f"📁 {item.name}")
|
||
|
|
set_user_list_media(twi_child, item)
|
||
|
|
info = f"({item.total_number_of_items} items)" if item.total_number_of_items else ""
|
||
|
|
twi_child.setText(2, info)
|
||
|
|
dummy_child = QtWidgets.QTreeWidgetItem(twi_child)
|
||
|
|
dummy_child.setDisabled(True)
|
||
|
|
elif isinstance(item, UserPlaylist | Playlist):
|
||
|
|
twi_child = QtWidgets.QTreeWidgetItem(twi_playlists)
|
||
|
|
name = item.name or ""
|
||
|
|
description = f" {item.description}" if item.description else ""
|
||
|
|
info = f"({item.num_tracks + item.num_videos} Tracks){description}"
|
||
|
|
twi_child.setText(0, name)
|
||
|
|
set_user_list_media(twi_child, item)
|
||
|
|
twi_child.setText(2, info)
|
||
|
|
|
||
|
|
for item in user_lists.get("mixes", []):
|
||
|
|
if isinstance(item, Mix):
|
||
|
|
twi_child = QtWidgets.QTreeWidgetItem(twi_mixes)
|
||
|
|
twi_child.setText(0, item.title)
|
||
|
|
set_user_list_media(twi_child, item)
|
||
|
|
twi_child.setText(2, item.sub_title)
|
||
|
|
|
||
|
|
for key, favorite in FAVORITES.items():
|
||
|
|
twi_child = QtWidgets.QTreeWidgetItem(twi_favorites)
|
||
|
|
twi_child.setText(0, favorite["name"])
|
||
|
|
set_user_list_media(twi_child, key)
|
||
|
|
|
||
|
|
self.main_window.s_spinner_stop.emit()
|
||
|
|
self.main_window.s_pb_reload_status.emit(True)
|
||
|
|
|
||
|
|
def menu_context_tree_lists(self, point: QtCore.QPoint) -> None:
|
||
|
|
"""Show context menu for user lists tree."""
|
||
|
|
index = self.main_window.tr_lists_user.indexAt(point)
|
||
|
|
if not index.isValid() or not index.parent().data():
|
||
|
|
return
|
||
|
|
item = self.main_window.tr_lists_user.itemAt(point)
|
||
|
|
media = get_user_list_media_item(item)
|
||
|
|
menu = QtWidgets.QMenu()
|
||
|
|
if isinstance(media, Folder):
|
||
|
|
menu.addAction(
|
||
|
|
"Download All Playlists in Folder",
|
||
|
|
lambda: self.main_window.thread_it(self.on_download_folder_playlists, point),
|
||
|
|
)
|
||
|
|
menu.addAction(
|
||
|
|
"Download All Albums from Folder",
|
||
|
|
lambda: self.main_window.thread_it(self.on_download_folder_albums, point),
|
||
|
|
)
|
||
|
|
elif isinstance(media, str):
|
||
|
|
menu.addAction("Download All Items", lambda: self.main_window.thread_it(self.on_download_favorites, point))
|
||
|
|
menu.addAction(
|
||
|
|
"Download All Albums from Items",
|
||
|
|
lambda: self.main_window.thread_it(self.on_download_albums_from_favorites, point),
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
menu.addAction("Download Playlist", lambda: self.main_window.thread_it(self.on_download_list_media, point))
|
||
|
|
menu.addAction(
|
||
|
|
"Download All Albums in Playlist",
|
||
|
|
lambda: self.main_window.thread_it(self.on_download_all_albums_from_playlist, point),
|
||
|
|
)
|
||
|
|
menu.addAction(
|
||
|
|
"Copy Share URL", lambda: self.main_window.on_copy_url_share(self.main_window.tr_lists_user, point)
|
||
|
|
)
|
||
|
|
menu.exec_(self.main_window.tr_lists_user.mapToGlobal(point))
|
||
|
|
|
||
|
|
def on_download_list_media(self, point: QtCore.QPoint | None = None) -> None:
|
||
|
|
"""Download all media items in a selected list."""
|
||
|
|
items = (
|
||
|
|
[self.main_window.tr_lists_user.itemAt(point)] if point else self.main_window.tr_lists_user.selectedItems()
|
||
|
|
)
|
||
|
|
if not items:
|
||
|
|
logger_gui.error("Please select a mix or playlist first.")
|
||
|
|
return
|
||
|
|
for item in items:
|
||
|
|
media = get_user_list_media_item(item)
|
||
|
|
queue_dl_item = self.main_window.queue_manager.media_to_queue_download_model(media)
|
||
|
|
if queue_dl_item:
|
||
|
|
self.main_window.queue_manager.queue_download_media(queue_dl_item)
|
||
|
|
|
||
|
|
def on_download_folder_playlists(self, point: QtCore.QPoint) -> None:
|
||
|
|
"""Download all playlists in a folder."""
|
||
|
|
item = self.main_window.tr_lists_user.itemAt(point)
|
||
|
|
media = get_user_list_media_item(item)
|
||
|
|
if not isinstance(media, Folder):
|
||
|
|
logger_gui.error("Please select a folder.")
|
||
|
|
return
|
||
|
|
logger_gui.info(f"Fetching playlists from folder: {media.name}")
|
||
|
|
playlists = self._get_folder_playlists(media)
|
||
|
|
if not playlists:
|
||
|
|
logger_gui.info(f"No playlists found in folder: {media.name}")
|
||
|
|
return
|
||
|
|
logger_gui.info(f"Queueing {len(playlists)} playlists from folder: {media.name}")
|
||
|
|
for playlist in playlists:
|
||
|
|
queue_dl_item = self.main_window.queue_manager.media_to_queue_download_model(playlist)
|
||
|
|
if queue_dl_item:
|
||
|
|
self.main_window.queue_manager.queue_download_media(queue_dl_item)
|
||
|
|
logger_gui.info(f"✅ Successfully queued {len(playlists)} playlists from folder: {media.name}")
|
||
|
|
|
||
|
|
def on_download_folder_albums(self, point: QtCore.QPoint) -> None:
|
||
|
|
"""Download all unique albums from all playlists in a folder."""
|
||
|
|
item = self.main_window.tr_lists_user.itemAt(point)
|
||
|
|
media = get_user_list_media_item(item)
|
||
|
|
if not isinstance(media, Folder):
|
||
|
|
logger_gui.error("Please select a folder.")
|
||
|
|
return
|
||
|
|
playlists = self._get_folder_playlists(media)
|
||
|
|
if not playlists:
|
||
|
|
return
|
||
|
|
all_tracks = []
|
||
|
|
for playlist in playlists:
|
||
|
|
try:
|
||
|
|
tracks = self._get_playlist_tracks(playlist)
|
||
|
|
all_tracks.extend(tracks)
|
||
|
|
except Exception as e:
|
||
|
|
logger_gui.error(f"Error getting tracks from playlist '{playlist.name}': {e}")
|
||
|
|
if not all_tracks:
|
||
|
|
return
|
||
|
|
album_ids = self.main_window._extract_album_ids_from_tracks(all_tracks)
|
||
|
|
if not album_ids:
|
||
|
|
return
|
||
|
|
albums_dict = self.main_window._load_albums_with_rate_limiting(album_ids)
|
||
|
|
if not albums_dict:
|
||
|
|
return
|
||
|
|
self.main_window._queue_loaded_albums(albums_dict)
|
||
|
|
|
||
|
|
def on_download_favorites(self, point: QtCore.QPoint) -> None:
|
||
|
|
"""Download all items from a Favorites category."""
|
||
|
|
item = self.main_window.tr_lists_user.itemAt(point)
|
||
|
|
media_key = get_user_list_media_item(item)
|
||
|
|
if not isinstance(media_key, str):
|
||
|
|
logger_gui.error("Please select a favorites category.")
|
||
|
|
return
|
||
|
|
favorite_name = FAVORITES.get(media_key, {}).get("name", media_key)
|
||
|
|
logger_gui.info(f"Fetching all items from favorites: {favorite_name}")
|
||
|
|
favorite_function = favorite_function_factory(self.main_window.tidal, media_key)
|
||
|
|
media_items = favorite_function()
|
||
|
|
if not media_items:
|
||
|
|
logger_gui.info(f"No items found in favorites: {favorite_name}")
|
||
|
|
return
|
||
|
|
queued_count = 0
|
||
|
|
for media_item in media_items:
|
||
|
|
queue_dl_item = self.main_window.queue_manager.media_to_queue_download_model(media_item)
|
||
|
|
if queue_dl_item:
|
||
|
|
self.main_window.queue_manager.queue_download_media(queue_dl_item)
|
||
|
|
queued_count += 1
|
||
|
|
logger_gui.info(f"✅ Successfully queued {queued_count} items from favorites: {favorite_name}")
|
||
|
|
|
||
|
|
def _download_albums_from_fav_artists(self, media_items: list) -> None:
|
||
|
|
"""Download all albums from favorite artists."""
|
||
|
|
all_albums = {}
|
||
|
|
for artist in media_items:
|
||
|
|
try:
|
||
|
|
artist_albums = items_results_all(self.main_window.tidal.session, artist)
|
||
|
|
for album in artist_albums:
|
||
|
|
if isinstance(album, Album) and album.id:
|
||
|
|
all_albums[album.id] = album
|
||
|
|
except Exception as e:
|
||
|
|
logger_gui.error(f"Error getting albums from artist '{artist.name}': {e}")
|
||
|
|
if all_albums:
|
||
|
|
self.main_window._queue_loaded_albums(all_albums)
|
||
|
|
|
||
|
|
def _download_albums_from_fav_tracks(self, media_items: list) -> None:
|
||
|
|
"""Download all albums from favorite tracks."""
|
||
|
|
album_ids = self.main_window._extract_album_ids_from_tracks(media_items)
|
||
|
|
if album_ids:
|
||
|
|
albums_dict = self.main_window._load_albums_with_rate_limiting(album_ids)
|
||
|
|
if albums_dict:
|
||
|
|
self.main_window._queue_loaded_albums(albums_dict)
|
||
|
|
|
||
|
|
def on_download_albums_from_favorites(self, point: QtCore.QPoint) -> None:
|
||
|
|
"""Download all unique albums from items in a Favorites category."""
|
||
|
|
item = self.main_window.tr_lists_user.itemAt(point)
|
||
|
|
media_key = get_user_list_media_item(item)
|
||
|
|
if not isinstance(media_key, str):
|
||
|
|
return
|
||
|
|
favorite_function = favorite_function_factory(self.main_window.tidal, media_key)
|
||
|
|
media_items = favorite_function()
|
||
|
|
if not media_items:
|
||
|
|
return
|
||
|
|
|
||
|
|
if media_key == "fav_albums":
|
||
|
|
albums_dict = {album.id: album for album in media_items if isinstance(album, Album) and album.id}
|
||
|
|
self.main_window._queue_loaded_albums(albums_dict)
|
||
|
|
elif media_key == "fav_artists":
|
||
|
|
self._download_albums_from_fav_artists(media_items)
|
||
|
|
else:
|
||
|
|
self._download_albums_from_fav_tracks(media_items)
|
||
|
|
|
||
|
|
def on_download_all_albums_from_playlist(self, point: QtCore.QPoint) -> None:
|
||
|
|
"""Download all unique albums from tracks in a playlist."""
|
||
|
|
item = self.main_window.tr_lists_user.itemAt(point)
|
||
|
|
media_list = get_user_list_media_item(item)
|
||
|
|
if not isinstance(media_list, Playlist | UserPlaylist | Mix):
|
||
|
|
logger_gui.error("Please select a playlist or mix.")
|
||
|
|
return
|
||
|
|
media_items = items_results_all(self.main_window.tidal.session, media_list)
|
||
|
|
album_ids = self.main_window._extract_album_ids_from_tracks(media_items)
|
||
|
|
if not album_ids:
|
||
|
|
logger_gui.warning("No albums found in this playlist.")
|
||
|
|
return
|
||
|
|
albums_dict = self.main_window._load_albums_with_rate_limiting(album_ids)
|
||
|
|
if not albums_dict:
|
||
|
|
logger_gui.error("Failed to load any albums from playlist.")
|
||
|
|
return
|
||
|
|
self.main_window._queue_loaded_albums(albums_dict)
|
||
|
|
message = f"Added {len(albums_dict)} albums to download queue"
|
||
|
|
self.main_window.s_statusbar_message.emit(StatusbarMessage(message=message, timeout=3000))
|
||
|
|
|
||
|
|
def on_tr_lists_user_expanded(self, item: QtWidgets.QTreeWidgetItem) -> None:
|
||
|
|
"""Handle expansion of folders in the user lists tree."""
|
||
|
|
if item.childCount() > 0 and item.child(0).isDisabled():
|
||
|
|
self.main_window.thread_it(self.tr_lists_user_load_folder_children, item)
|
||
|
|
|
||
|
|
def tr_lists_user_load_folder_children(self, parent_item: QtWidgets.QTreeWidgetItem) -> None:
|
||
|
|
"""Load and display children of a folder in the user lists tree."""
|
||
|
|
folder = get_user_list_media_item(parent_item)
|
||
|
|
if not isinstance(folder, Folder):
|
||
|
|
return
|
||
|
|
self.main_window.s_spinner_start.emit(self.main_window.tr_lists_user)
|
||
|
|
try:
|
||
|
|
folders, playlists = self._fetch_folder_contents(folder)
|
||
|
|
self.main_window.s_populate_folder_children.emit(parent_item, folders, playlists)
|
||
|
|
finally:
|
||
|
|
self.main_window.s_spinner_stop.emit()
|
||
|
|
|
||
|
|
def on_populate_folder_children(
|
||
|
|
self, parent_item: QtWidgets.QTreeWidgetItem, folders: list[Folder], playlists: list[Playlist]
|
||
|
|
) -> None:
|
||
|
|
"""Populate folder children in the main thread."""
|
||
|
|
parent_item.takeChild(0)
|
||
|
|
for sub_folder in folders:
|
||
|
|
twi_child = QtWidgets.QTreeWidgetItem(parent_item)
|
||
|
|
twi_child.setText(0, f"📁 {sub_folder.name}")
|
||
|
|
set_user_list_media(twi_child, sub_folder)
|
||
|
|
info = f"({sub_folder.total_number_of_items} items)" if sub_folder.total_number_of_items else ""
|
||
|
|
twi_child.setText(2, info)
|
||
|
|
dummy = QtWidgets.QTreeWidgetItem(twi_child)
|
||
|
|
dummy.setDisabled(True)
|
||
|
|
for playlist in playlists:
|
||
|
|
twi_child = QtWidgets.QTreeWidgetItem(parent_item)
|
||
|
|
twi_child.setText(0, playlist.name or "")
|
||
|
|
set_user_list_media(twi_child, playlist)
|
||
|
|
info = f"({playlist.num_tracks + playlist.num_videos} Tracks)"
|
||
|
|
if playlist.description:
|
||
|
|
info += f" {playlist.description}"
|
||
|
|
twi_child.setText(2, info)
|
||
|
|
|
||
|
|
def _fetch_folder_contents(self, folder: Folder) -> tuple[list[Folder], list[Playlist]]:
|
||
|
|
"""Fetch contents of a folder."""
|
||
|
|
folder_id = folder.id or "root"
|
||
|
|
folders, playlists = [], []
|
||
|
|
offset, limit = 0, 50
|
||
|
|
while True:
|
||
|
|
batch = self.main_window.tidal.session.user.favorites.playlist_folders(
|
||
|
|
limit=limit, offset=offset, parent_folder_id=folder_id
|
||
|
|
)
|
||
|
|
if not batch:
|
||
|
|
break
|
||
|
|
folders.extend(batch)
|
||
|
|
if len(batch) < limit:
|
||
|
|
break
|
||
|
|
offset += limit
|
||
|
|
offset = 0
|
||
|
|
while True:
|
||
|
|
batch = folder.items(offset=offset, limit=limit)
|
||
|
|
if not batch:
|
||
|
|
break
|
||
|
|
playlists.extend(batch)
|
||
|
|
if len(batch) < limit:
|
||
|
|
break
|
||
|
|
offset += limit
|
||
|
|
return folders, playlists
|
||
|
|
|
||
|
|
def _get_folder_playlists(self, folder: Folder) -> list[Playlist]:
|
||
|
|
"""Fetch all playlists from a folder."""
|
||
|
|
_, playlists = self._fetch_folder_contents(folder)
|
||
|
|
return playlists
|
||
|
|
|
||
|
|
def _get_playlist_tracks(self, playlist: Playlist | UserPlaylist | Mix) -> list:
|
||
|
|
"""Fetch all tracks from a playlist."""
|
||
|
|
return [
|
||
|
|
item
|
||
|
|
for item in items_results_all(self.main_window.tidal.session, playlist)
|
||
|
|
if isinstance(item, self.main_window.tidal.session.track)
|
||
|
|
]
|
||
|
|
|
||
|
|
def on_list_items_show(self, item: QtWidgets.QTreeWidgetItem) -> None:
|
||
|
|
"""Show the items in the selected playlist or mix."""
|
||
|
|
self.main_window.thread_it(self.list_items_show, item)
|
||
|
|
|
||
|
|
def list_items_show(self, item: QtWidgets.QTreeWidgetItem) -> None:
|
||
|
|
"""Fetch and display the items in a playlist, mix, or folder."""
|
||
|
|
media_list = get_user_list_media_item(item)
|
||
|
|
if not media_list:
|
||
|
|
return
|
||
|
|
self.main_window.s_spinner_start.emit(self.main_window.tr_results)
|
||
|
|
try:
|
||
|
|
if isinstance(media_list, Folder):
|
||
|
|
self._show_folder_contents(media_list)
|
||
|
|
elif isinstance(media_list, str) and media_list.startswith("fav_"):
|
||
|
|
function_list = favorite_function_factory(self.main_window.tidal, media_list)
|
||
|
|
self.main_window.list_items_show_result(favorite_function=function_list)
|
||
|
|
else:
|
||
|
|
self.main_window.list_items_show_result(media_list)
|
||
|
|
self.main_window.thread_it(self.main_window.cover_manager.load_cover, media_list)
|
||
|
|
finally:
|
||
|
|
self.main_window.s_spinner_stop.emit()
|
||
|
|
|
||
|
|
def _show_folder_contents(self, folder: Folder) -> None:
|
||
|
|
"""Display folder contents in results pane."""
|
||
|
|
folders, playlists = self._fetch_folder_contents(folder)
|
||
|
|
items = folders + playlists
|
||
|
|
result = self.main_window.search_manager.search_result_to_model(items)
|
||
|
|
self.main_window.search_manager.populate_tree_results(result)
|