1380 lines
50 KiB
Python
1380 lines
50 KiB
Python
import copy
|
|
import datetime
|
|
import json
|
|
import logging
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import threading
|
|
import traceback
|
|
import webbrowser
|
|
from pathlib import Path
|
|
from yt_dlp.networking.exceptions import HTTPError
|
|
from typing import Callable
|
|
import click
|
|
import requests
|
|
from yt_dlp import YoutubeDL
|
|
from utils import save_json, read_json, check_url_scheme, parser_url_scheme, find_mpv_path, find_http_status
|
|
|
|
# Qt
|
|
from PySide6.QtWidgets import (
|
|
QApplication, QMainWindow, QWidget, QDialog,
|
|
QLabel, QPushButton, QFrame, QScrollArea,
|
|
QVBoxLayout, QHBoxLayout, QGridLayout,
|
|
QMessageBox, QInputDialog, QSizePolicy, QFileDialog,
|
|
)
|
|
from PySide6.QtCore import Qt, QTimer, Signal, QObject, QThread, QSize, QUrl
|
|
from PySide6.QtGui import QPixmap, QFont, QImage, QIcon, QDesktopServices
|
|
|
|
VERSION = "Alpha-2-QtTest"
|
|
PROGRAM_DIR = Path(__file__).parent
|
|
|
|
work_dir = None
|
|
|
|
logger = logging.getLogger(__name__)
|
|
logger.setLevel(logging.INFO)
|
|
|
|
YT_PLAYLISTS_URL = "https://www.youtube.com/feed/playlists"
|
|
|
|
def sanitize_filename(value: str):
|
|
invalid_chars = '<>:"/\\|?*'
|
|
return "".join("_" if char in invalid_chars else char for char in value)
|
|
|
|
|
|
def fetch_video_details(video_url: str, opts):
|
|
opts = copy.deepcopy(opts)
|
|
opts.update({"extract_flat": True, })
|
|
|
|
try:
|
|
with YoutubeDL(opts) as ydl:
|
|
info = ydl.extract_info(video_url, download=False)
|
|
except Exception as e:
|
|
logger.error(f"Unable to fetch video details: {e}\nURL:{video_url}")
|
|
return None
|
|
|
|
return info
|
|
|
|
|
|
def resolve_video_page_url(video: dict):
|
|
return (
|
|
video.get("webpage_url")
|
|
or video.get("url")
|
|
or (f"https://www.youtube.com/watch?v={video.get('id')}" if video.get("id") else None)
|
|
)
|
|
|
|
|
|
def download_file(url, dest: Path):
|
|
try:
|
|
dest.parent.mkdir(parents=True, exist_ok=True)
|
|
with requests.get(url, stream=True) as r:
|
|
with dest.open(mode="wb") as f:
|
|
for chunk in r.iter_content(chunk_size=8192):
|
|
f.write(chunk)
|
|
return True
|
|
except Exception as e:
|
|
logger.error("Unable to download file: %s", e)
|
|
return False
|
|
|
|
|
|
fetch_playlist_lock = threading.Lock()
|
|
|
|
class PlaylistFetchException(Exception):
|
|
def __init__(self, url, title, reason, enable_option=False, options=None, no_cancel=False):
|
|
super().__init__()
|
|
self.url = url
|
|
self.title = title
|
|
self.reason = reason
|
|
self.qt_options = {
|
|
"enable": enable_option,
|
|
"options": options,
|
|
"noCancelOption": no_cancel,
|
|
}
|
|
|
|
def create_messagebox(self, master):
|
|
box = QMessageBox(master)
|
|
box.setWindowTitle(self.title)
|
|
box.setText(self.reason or self.title)
|
|
box.setIcon(QMessageBox.Icon.Critical)
|
|
|
|
is_custom_option_enabled = self.qt_options["enable"] is True and type(self.qt_options["options"]) is list
|
|
|
|
if is_custom_option_enabled:
|
|
for option in self.qt_options["options"]:
|
|
label = option.get("label", None)
|
|
action_func = option.get("action", None)
|
|
role = option.get("role", QMessageBox.ButtonRole.AcceptRole)
|
|
|
|
# Some type check
|
|
if label is None or (action_func is None or not callable(action_func)):
|
|
logger.warning(f"Skipping {option} ({action_func}) because its label or action is not set yet or not callable.")
|
|
continue
|
|
|
|
if not isinstance(role, QMessageBox.ButtonRole):
|
|
logger.warning(f"Skipping {option} ({role}) because its role type is not QMessageBox.ButtonRole.")
|
|
continue
|
|
|
|
btn = box.addButton(label, role)
|
|
option["button"] = btn
|
|
|
|
if not self.qt_options["noCancelOption"]:
|
|
box.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
|
|
elif not is_custom_option_enabled:
|
|
box.addButton(QMessageBox.StandardButton.Ok)
|
|
|
|
box.exec()
|
|
|
|
clicked = box.clickedButton()
|
|
|
|
# If the option's button is clicked, Call the target action function
|
|
if is_custom_option_enabled:
|
|
for option in self.qt_options["options"]:
|
|
btn = option.get("button")
|
|
action_func = option.get("action")
|
|
|
|
if clicked == btn:
|
|
return action_func()
|
|
|
|
return None
|
|
|
|
def fetch_playlists_data(url_schema, cookie_file_path: Path, opts, callback: Callable):
|
|
check_url_scheme(os.path.abspath(__file__), work_dir)
|
|
|
|
error = None
|
|
|
|
if url_schema is not None:
|
|
try:
|
|
parser_url_scheme(url_schema, cookie_path=cookie_file_path)
|
|
except Exception as e:
|
|
logger.error("Unable to parse URL scheme: %s", e)
|
|
input("Press enter to continue...")
|
|
|
|
playlists_data = None
|
|
|
|
with fetch_playlist_lock:
|
|
opts = copy.deepcopy(opts)
|
|
opts.update({
|
|
'extract_flat': True,
|
|
'skip_download': True,
|
|
})
|
|
|
|
try:
|
|
with YoutubeDL(opts) as ydl:
|
|
playlists_data = ydl.extract_info(YT_PLAYLISTS_URL, download=False)
|
|
except Exception as e:
|
|
status_code = find_http_status(e)
|
|
if status_code == 401:
|
|
error = "Cookie are expired. Reopen the tool again in browser!", None
|
|
elif status_code == 403:
|
|
error = "Server forbidden. Did you logged in?", None
|
|
elif status_code == 429:
|
|
error = "Too many requests. Try again later.", None
|
|
elif status_code == 503:
|
|
error = "Server unavailable. Try again later.", None
|
|
elif status_code == 522:
|
|
error = "Connection timed out.", None
|
|
else:
|
|
error = (f"Unexpected error: {e} (Type: {type(e)})\n"
|
|
f"Traceback: {traceback.format_exc()}", None)
|
|
|
|
if playlists_data is None:
|
|
logger.error(f"Unable to fetch playlists: {error}")
|
|
playlists_data = {"entries": []}
|
|
|
|
pf_exec = None
|
|
if error is not None:
|
|
reason = error[0] if isinstance(error, tuple) else error
|
|
pf_exec = PlaylistFetchException(
|
|
url=YT_PLAYLISTS_URL,
|
|
title="Playlists Fetch Error",
|
|
reason=reason,
|
|
enable_option=True,
|
|
options=[
|
|
{"label": "Reopen browser",
|
|
"action": lambda: webbrowser.open(YT_PLAYLISTS_URL)},
|
|
],
|
|
)
|
|
|
|
callback(playlists_data, pf_exec)
|
|
|
|
|
|
class PlaylistSaver(QApplication):
|
|
DEFAULT_PROFILE_NAME = "default"
|
|
THUMBNAIL_SIZE = QSize(144, 81)
|
|
mpv_processes = {}
|
|
|
|
def __init__(self, url_schema=None, cookie_file: str | None = None):
|
|
super().__init__()
|
|
self.setApplicationName("PlaylistSaver")
|
|
|
|
self.url_schema = url_schema
|
|
self.cookie_file = cookie_file
|
|
|
|
# Path
|
|
self.save_path = Path(work_dir, "save")
|
|
self.temp_path = Path(work_dir, "temp")
|
|
self.profiles_meta_path = Path(self.save_path, "profiles.json")
|
|
self.profiles_path = Path(self.save_path, "profiles")
|
|
self.cookie_path = Path(self.profiles_path, self.DEFAULT_PROFILE_NAME, "cookies.txt")
|
|
|
|
# Profile
|
|
self.active_profile_name = self.DEFAULT_PROFILE_NAME
|
|
|
|
# Data
|
|
self.playlists: dict[str, list] = {
|
|
"entries": []
|
|
}
|
|
|
|
self.window = self.MainWindow(self)
|
|
|
|
self.init()
|
|
self.window.show()
|
|
|
|
class MainWindow(QMainWindow):
|
|
def __init__(self, parent):
|
|
super().__init__()
|
|
self.parent = parent
|
|
self.child_windows = []
|
|
self.setWindowTitle("PlaylistSaver")
|
|
self.resize(700, 800)
|
|
|
|
# Central widget
|
|
self.central_widget = QWidget(self)
|
|
self.setCentralWidget(self.central_widget)
|
|
|
|
# Layouts
|
|
self.main_layout = QHBoxLayout(self.central_widget)
|
|
self.main_layout.setContentsMargins(12, 12, 12, 12)
|
|
self.main_layout.setSpacing(12)
|
|
|
|
self.right_layout = QVBoxLayout()
|
|
self.right_layout.setContentsMargins(12, 12, 12, 12)
|
|
self.right_layout.setSpacing(10)
|
|
|
|
self.playlists_layout = QVBoxLayout()
|
|
self.playlists_layout.setContentsMargins(10, 10, 10, 10)
|
|
self.playlists_layout.setSpacing(8)
|
|
|
|
# Frame
|
|
self.playlists_scroll = QScrollArea(self)
|
|
self.playlists_scroll.setWidgetResizable(True)
|
|
self.playlists_scroll.setFrameShape(QFrame.NoFrame)
|
|
|
|
self.playlists_frame = QFrame(self.playlists_scroll)
|
|
self.playlists_frame.setLayout(self.playlists_layout)
|
|
self.playlists_scroll.setWidget(self.playlists_frame)
|
|
|
|
self.playlists_scroll.setMinimumWidth(400)
|
|
|
|
self.right_panel = QFrame(self.central_widget)
|
|
self.right_panel.setObjectName("rightPanel")
|
|
self.right_panel.setFixedWidth(190)
|
|
self.right_panel.setLayout(self.right_layout)
|
|
|
|
# Items
|
|
self.profile_label = QLabel(f"Current Profile: {self.parent.get_active_profile_name()}",)
|
|
self.profile_label.setObjectName("profileLabel")
|
|
self.profile_label.setWordWrap(True)
|
|
|
|
self.loading_label = QLabel("Loading...")
|
|
self.loading_label.setObjectName("loadingLabel")
|
|
self.loading_label.setAlignment(Qt.AlignCenter)
|
|
|
|
self.switch_profile_btn = QPushButton("Switch Profile")
|
|
self.refresh_playlists_btn = QPushButton("Refresh playlists")
|
|
self.switch_profile_btn.setMinimumHeight(34)
|
|
self.refresh_playlists_btn.setMinimumHeight(34)
|
|
|
|
self.version_label = QLabel(f"v{VERSION}")
|
|
self.version_label.setObjectName("versionLabel")
|
|
|
|
self.playlist_items_layout = QVBoxLayout()
|
|
self.playlist_items_layout.setContentsMargins(0, 0, 0, 0)
|
|
self.playlist_items_layout.setSpacing(8)
|
|
|
|
self.playlists_layout.addWidget(self.loading_label, 0, Qt.AlignHCenter)
|
|
self.playlists_layout.addLayout(self.playlist_items_layout)
|
|
|
|
# Bind item
|
|
self.left_layout = QVBoxLayout()
|
|
self.left_layout.setContentsMargins(0, 0, 0, 0)
|
|
self.left_layout.setSpacing(10)
|
|
self.left_layout.addWidget(self.playlists_scroll, 1)
|
|
|
|
self.right_layout.addWidget(self.profile_label)
|
|
self.right_layout.addWidget(self.switch_profile_btn)
|
|
self.right_layout.addWidget(self.refresh_playlists_btn)
|
|
self.right_layout.addStretch(1)
|
|
self.right_layout.addWidget(self.version_label, 0, Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignHCenter)
|
|
|
|
self.main_layout.addLayout(self.left_layout, 1)
|
|
self.main_layout.addWidget(self.right_panel)
|
|
|
|
self.setStyleSheet("""
|
|
QMainWindow {
|
|
background-color: #202020;
|
|
}
|
|
|
|
QScrollArea, QFrame {
|
|
background-color: #242424;
|
|
}
|
|
|
|
QLabel {
|
|
background-color: transparent;
|
|
}
|
|
|
|
#rightPanel {
|
|
background-color: #2b2b2b;
|
|
border: 1px solid #3c3c3c;
|
|
border-radius: 8px;
|
|
}
|
|
|
|
#profileLabel {
|
|
color: #f0f0f0;
|
|
font-weight: 600;
|
|
padding-bottom: 6px;
|
|
}
|
|
|
|
#loadingLabel {
|
|
color: #a8a8a8;
|
|
padding: 4px;
|
|
}
|
|
|
|
QPushButton {
|
|
background-color: #3a3a3a;
|
|
color: #f0f0f0;
|
|
border: 1px solid #505050;
|
|
border-radius: 6px;
|
|
padding: 7px 10px;
|
|
}
|
|
|
|
QPushButton:hover {
|
|
background-color: #464646;
|
|
}
|
|
|
|
QPushButton:pressed {
|
|
background-color: #303030;
|
|
}
|
|
""")
|
|
|
|
# Bind signals function
|
|
self.signals = self.PlaylistWorkerSignals()
|
|
self.signals.playlists_ready.connect(self.build_ui)
|
|
self.signals.error.connect(self.show_error)
|
|
self.signals.playlist_fetch_error.connect(self.show_playlist_fetch_error)
|
|
|
|
self.switch_profile_btn.clicked.connect(self.open_switch_profile_dialog)
|
|
self.refresh_playlists_btn.clicked.connect(self.parent.reload_playlists)
|
|
|
|
class PlaylistWorkerSignals(QObject):
|
|
# Signals
|
|
playlists_ready = Signal(dict)
|
|
profile_delete = Signal(str)
|
|
|
|
# playlist
|
|
playlist_clicked = Signal(dict)
|
|
video_clicked = Signal(str)
|
|
|
|
# error
|
|
error = Signal(str)
|
|
playlist_fetch_error = Signal(object)
|
|
|
|
def build_ui(self, playlists: dict[str, list]):
|
|
self.clear_layout(self.playlist_items_layout)
|
|
|
|
playlists = playlists.get("entries", [])
|
|
|
|
playlists = [playlist for playlist in playlists if playlist is not None] # ignore None item
|
|
|
|
for playlist in playlists:
|
|
plist_id = playlist.get("id", None)
|
|
title = playlist.get("title", "Title not found")
|
|
|
|
item = self.PlaylistItem(
|
|
self.playlists_frame,
|
|
playlist,
|
|
title=title,
|
|
)
|
|
|
|
if len(playlist.get("thumbnails", [])) > 0:
|
|
thumbnail_url = playlist.get("thumbnails", [])[0].get('url', None)
|
|
thumbnail_resolution = playlist.get("thumbnails", [])[0].get('resolution', None)
|
|
|
|
thumbnail_path = Path(work_dir, "temp", "thumbnails",
|
|
f"thumbnail_{plist_id}_{thumbnail_resolution}.jpg")
|
|
|
|
result = download_file(thumbnail_url, thumbnail_path)
|
|
|
|
if result or (thumbnail_path.exists() and thumbnail_path.is_file()):
|
|
item.set_thumbnail(thumbnail_path)
|
|
|
|
item.clicked.connect(self.open_playlist_window)
|
|
self.playlist_items_layout.addWidget(item)
|
|
|
|
self.loading_label.setText("Done")
|
|
|
|
@staticmethod
|
|
def clear_layout(layout):
|
|
while layout.count():
|
|
item = layout.takeAt(0)
|
|
child_layout = item.layout()
|
|
widget = item.widget()
|
|
if child_layout:
|
|
PlaylistSaver.MainWindow.clear_layout(child_layout)
|
|
if widget:
|
|
widget.deleteLater()
|
|
|
|
def open_playlist_window(self, playlist: dict):
|
|
window = self.PlaylistWindow(self, playlist)
|
|
self.child_windows.append(window)
|
|
window.destroyed.connect(
|
|
lambda _obj=None, w=window: self.child_windows.remove(w) if w in self.child_windows else None)
|
|
window.show()
|
|
|
|
def show_error(self, message: str):
|
|
QMessageBox.critical(self, "Error", message)
|
|
|
|
def show_playlist_fetch_error(self, error: PlaylistFetchException):
|
|
error.create_messagebox(self)
|
|
|
|
def open_video_player(self, video: dict):
|
|
video_url = resolve_video_page_url(video)
|
|
if not video_url:
|
|
QMessageBox.critical(self, "Error", "Unable to resolve video URL.")
|
|
return
|
|
|
|
dialog = self.PlayerDialog(self, video)
|
|
self.child_windows.append(dialog)
|
|
dialog.destroyed.connect(
|
|
lambda _obj=None, w=dialog: self.child_windows.remove(w) if w in self.child_windows else None)
|
|
dialog.show()
|
|
|
|
def open_switch_profile_dialog(self):
|
|
dialog = self.SwitchProfileDialog(self)
|
|
dialog.profile_changed.connect(self.apply_profile_switch)
|
|
dialog.exec()
|
|
|
|
def apply_profile_switch(self, profile_name: str):
|
|
self.parent.set_active_profile(profile_name)
|
|
self.profile_label.setText(f"Current Profile: {profile_name}")
|
|
|
|
class PlaylistItem(QFrame):
|
|
clicked = Signal(dict)
|
|
|
|
def __init__(self, parent, data, title: str = "", thumbnail_path: str | Path | None = None):
|
|
super().__init__(parent)
|
|
self.setObjectName("playlistItem")
|
|
self.original_thumbnail = None
|
|
|
|
self.layout = QHBoxLayout(self)
|
|
self.layout.setContentsMargins(12, 10, 12, 10)
|
|
self.layout.setSpacing(12)
|
|
|
|
self.setMinimumHeight(92)
|
|
self.setMaximumHeight(120)
|
|
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
|
|
|
|
# item
|
|
self.title_label = QLabel(title, self)
|
|
self.title_label.setObjectName("playlistTitle")
|
|
self.title_label.setWordWrap(True)
|
|
self.title_label.setAlignment(Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft)
|
|
self.title_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
|
|
|
|
self.thumbnail_label = QLabel(self)
|
|
self.thumbnail_label.setObjectName("thumbnailLabel")
|
|
self.thumbnail_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
self.thumbnail_label.setFixedSize(PlaylistSaver.THUMBNAIL_SIZE)
|
|
self.thumbnail_label.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
|
|
|
|
# bind
|
|
self.layout.addWidget(self.title_label, 1)
|
|
self.layout.addWidget(self.thumbnail_label)
|
|
|
|
if thumbnail_path:
|
|
self.set_thumbnail(thumbnail_path)
|
|
|
|
self.setStyleSheet("""
|
|
QFrame#playlistItem {
|
|
background-color: #2b2b2b;
|
|
border: 1px solid #3c3c3c;
|
|
border-radius: 8px;
|
|
}
|
|
|
|
QFrame#playlistItem:hover {
|
|
background-color: #4f0202;
|
|
border-color: #555555;
|
|
}
|
|
|
|
QLabel {
|
|
background-color: transparent;
|
|
border: none;
|
|
color: #f0f0f0;
|
|
}
|
|
|
|
#playlistTitle {
|
|
font-weight: 600;
|
|
}
|
|
|
|
#thumbnailLabel {
|
|
background-color: #1f1f1f;
|
|
border: 1px solid #3a3a3a;
|
|
border-radius: 6px;
|
|
}
|
|
""")
|
|
|
|
# Playlist data
|
|
self.data = data
|
|
|
|
@property
|
|
def app(self):
|
|
return self.parent()
|
|
|
|
def set_thumbnail(self, thumbnail_path: str | Path):
|
|
pixmap = QPixmap(str(thumbnail_path))
|
|
if pixmap.isNull():
|
|
self.thumbnail_label.hide()
|
|
return
|
|
|
|
self.original_thumbnail = pixmap
|
|
self.thumbnail_label.show()
|
|
self.update_thumbnail_size()
|
|
|
|
def update_thumbnail_size(self):
|
|
if not self.original_thumbnail:
|
|
return
|
|
|
|
scaled = self.original_thumbnail.scaled(
|
|
self.thumbnail_label.size(),
|
|
Qt.AspectRatioMode.KeepAspectRatio,
|
|
Qt.TransformationMode.SmoothTransformation,
|
|
)
|
|
self.thumbnail_label.setPixmap(scaled)
|
|
|
|
def resizeEvent(self, event):
|
|
super().resizeEvent(event)
|
|
self.update_thumbnail_size()
|
|
|
|
def mousePressEvent(self, event):
|
|
if event.button() == Qt.MouseButton.LeftButton:
|
|
self.clicked.emit(self.data)
|
|
super().mousePressEvent(event)
|
|
|
|
class VideoItem(QFrame):
|
|
clicked = Signal(dict)
|
|
|
|
def __init__(self, parent, video: dict, index: int = 0, thumbnail_path: str | Path | None = None):
|
|
super().__init__(parent)
|
|
self.setObjectName("videoItem")
|
|
self.original_thumbnail = None
|
|
self.video = video
|
|
self.id = video.get("id")
|
|
self.url = resolve_video_page_url(video)
|
|
|
|
title = video.get("title", "Unnamed Video")
|
|
if index:
|
|
title = f"{index}. {title}"
|
|
|
|
if video.get("duration"):
|
|
duration = str(datetime.timedelta(seconds=video.get("duration")))
|
|
else:
|
|
duration = "Fetching duration..."
|
|
|
|
self.layout = QHBoxLayout(self)
|
|
self.layout.setContentsMargins(12, 10, 12, 10)
|
|
self.layout.setSpacing(12)
|
|
|
|
self.setMinimumHeight(92)
|
|
self.setMaximumHeight(120)
|
|
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
|
|
|
|
# item
|
|
self.title_label = QLabel(title, self)
|
|
self.title_label.setObjectName("videoTitle")
|
|
self.title_label.setWordWrap(True)
|
|
self.title_label.setAlignment(Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft)
|
|
self.title_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
|
|
|
|
self.duration_label = QLabel(duration, self)
|
|
self.duration_label.setObjectName("durationLabel")
|
|
self.duration_label.setAlignment(Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignLeft)
|
|
|
|
self.download_button = QPushButton("Download", self)
|
|
self.download_button.setObjectName("downloadButton")
|
|
|
|
self.thumbnail_label = QLabel(self)
|
|
self.thumbnail_label.setObjectName("thumbnailLabel")
|
|
self.thumbnail_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
self.thumbnail_label.setFixedSize(PlaylistSaver.THUMBNAIL_SIZE)
|
|
self.thumbnail_label.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
|
|
self.thumbnail_label.hide()
|
|
|
|
# bind
|
|
self.text_layout = QVBoxLayout()
|
|
self.text_layout.setContentsMargins(0, 0, 0, 0)
|
|
self.text_layout.setSpacing(6)
|
|
self.text_layout.addWidget(self.title_label, 1)
|
|
self.text_layout.addWidget(self.duration_label)
|
|
self.text_layout.addWidget(self.download_button, 1,
|
|
Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignRight)
|
|
|
|
self.layout.addLayout(self.text_layout, 1)
|
|
self.layout.addWidget(self.thumbnail_label)
|
|
|
|
if thumbnail_path:
|
|
self.set_thumbnail(thumbnail_path)
|
|
|
|
self.setStyleSheet("""
|
|
QFrame#videoItem {
|
|
background-color: #2b2b2b;
|
|
border: 1px solid #3c3c3c;
|
|
border-radius: 8px;
|
|
}
|
|
|
|
QFrame#videoItem:hover {
|
|
background-color: #333333;
|
|
border-color: #555555;
|
|
}
|
|
|
|
QLabel {
|
|
background-color: transparent;
|
|
border: none;
|
|
color: #f0f0f0;
|
|
}
|
|
|
|
#videoTitle {
|
|
font-weight: 600;
|
|
}
|
|
|
|
#thumbnailLabel {
|
|
background-color: #1f1f1f;
|
|
border: 1px solid #3a3a3a;
|
|
border-radius: 6px;
|
|
}
|
|
|
|
#downloadButton {
|
|
max-height: 30px;
|
|
}
|
|
""")
|
|
|
|
self.setCursor(Qt.CursorShape.PointingHandCursor)
|
|
|
|
def set_thumbnail(self, thumbnail_path: str | Path):
|
|
pixmap = QPixmap(str(thumbnail_path))
|
|
if pixmap.isNull():
|
|
self.thumbnail_label.hide()
|
|
return
|
|
|
|
self.original_thumbnail = pixmap
|
|
self.thumbnail_label.show()
|
|
self.update_thumbnail_size()
|
|
|
|
def update_thumbnail_size(self):
|
|
if not self.original_thumbnail:
|
|
return
|
|
|
|
scaled = self.original_thumbnail.scaled(
|
|
self.thumbnail_label.size(),
|
|
Qt.AspectRatioMode.KeepAspectRatio,
|
|
Qt.TransformationMode.SmoothTransformation,
|
|
)
|
|
self.thumbnail_label.setPixmap(scaled)
|
|
|
|
def resizeEvent(self, event):
|
|
super().resizeEvent(event)
|
|
self.update_thumbnail_size()
|
|
|
|
def mousePressEvent(self, event):
|
|
if event.button() == Qt.MouseButton.LeftButton:
|
|
self.clicked.emit(self.video)
|
|
super().mousePressEvent(event)
|
|
|
|
def set_duration(self, duration: str):
|
|
self.duration_label.setText(duration)
|
|
|
|
class PlaylistWindow(QDialog):
|
|
class LoadSignals(QObject):
|
|
playlist_ready = Signal(dict)
|
|
error = Signal(str)
|
|
|
|
def __init__(self, parent, playlist: dict):
|
|
QDialog.__init__(self, parent)
|
|
self.parent = parent
|
|
self.playlist = playlist
|
|
self.setWindowTitle(playlist.get("title", "Playlist"))
|
|
self.resize(760, 640)
|
|
self.signals = self.LoadSignals()
|
|
self.signals.playlist_ready.connect(self.render_videos)
|
|
self.signals.error.connect(self.show_error)
|
|
|
|
# Layout
|
|
self.layout = QVBoxLayout(self)
|
|
self.layout.setContentsMargins(16, 16, 16, 16)
|
|
self.layout.setSpacing(12)
|
|
|
|
self.header_label = QLabel(playlist.get("title", "Playlist"), self)
|
|
self.header_label.setObjectName("playlistTitle")
|
|
self.header_label.setWordWrap(True)
|
|
|
|
self.info_label = QLabel("Loading playlist videos...", self)
|
|
self.info_label.setObjectName("playlistInfo")
|
|
|
|
self.content_layout = QHBoxLayout()
|
|
self.content_layout.setSpacing(12)
|
|
|
|
# Scroll area and frame for video items
|
|
self.scroll_area = QScrollArea(self)
|
|
self.scroll_area.setWidgetResizable(True)
|
|
self.scroll_area.setFrameShape(QFrame.NoFrame)
|
|
|
|
self.list_frame = QFrame(self.scroll_area)
|
|
self.list_frame.setObjectName("playlistFrame")
|
|
self.list_layout = QVBoxLayout(self.list_frame)
|
|
self.list_layout.setContentsMargins(8, 8, 8, 8)
|
|
self.list_layout.setSpacing(8)
|
|
self.scroll_area.setWidget(self.list_frame)
|
|
|
|
self.control_panel = QFrame(self)
|
|
self.control_panel.setObjectName("playlistControls")
|
|
self.control_panel.setFixedWidth(150)
|
|
self.control_layout = QVBoxLayout(self.control_panel)
|
|
self.control_layout.setContentsMargins(12, 12, 12, 12)
|
|
self.control_layout.setSpacing(10)
|
|
|
|
self.reload_playlist_btn = QPushButton("Reload")
|
|
self.reload_playlist_btn.setMinimumHeight(34)
|
|
self.reload_playlist_btn.clicked.connect(self.render_playlist)
|
|
|
|
self.control_layout.addWidget(self.reload_playlist_btn)
|
|
self.control_layout.addStretch(1)
|
|
|
|
self.content_layout.addWidget(self.scroll_area, 1)
|
|
self.content_layout.addWidget(self.control_panel)
|
|
|
|
self.layout.addWidget(self.header_label)
|
|
self.layout.addWidget(self.info_label)
|
|
self.layout.addLayout(self.content_layout, 1)
|
|
|
|
self.render_playlist()
|
|
|
|
self.setStyleSheet("""
|
|
QDialog {
|
|
background-color: #202020;
|
|
}
|
|
|
|
QScrollArea, #playlistFrame {
|
|
background-color: #242424;
|
|
}
|
|
|
|
#playlistTitle {
|
|
color: #f0f0f0;
|
|
font-size: 20px;
|
|
font-weight: 700;
|
|
}
|
|
|
|
#playlistInfo {
|
|
color: #a8a8a8;
|
|
}
|
|
|
|
#playlistControls {
|
|
background-color: #2b2b2b;
|
|
border: 1px solid #3c3c3c;
|
|
border-radius: 8px;
|
|
}
|
|
|
|
QLabel {
|
|
background-color: transparent;
|
|
color: #f0f0f0;
|
|
}
|
|
|
|
QPushButton {
|
|
background-color: #3a3a3a;
|
|
color: #f0f0f0;
|
|
border: 1px solid #505050;
|
|
border-radius: 6px;
|
|
padding: 7px 10px;
|
|
}
|
|
|
|
QPushButton:hover {
|
|
background-color: #464646;
|
|
}
|
|
|
|
QPushButton:disabled {
|
|
color: #999999;
|
|
background-color: #303030;
|
|
}
|
|
""")
|
|
|
|
@property
|
|
def app(self):
|
|
return self.parent.parent
|
|
|
|
def render_playlist(self):
|
|
self.reload_playlist_btn.setEnabled(False)
|
|
self.info_label.setText("Loading playlist videos...")
|
|
PlaylistSaver.MainWindow.clear_layout(self.list_layout)
|
|
|
|
threading.Thread(target=self.load_playlist_worker, daemon=True).start()
|
|
|
|
def load_playlist_worker(self):
|
|
try:
|
|
playlist_data = self.app.fetch_playlist_videos(self.playlist)
|
|
except Exception as e:
|
|
logger.error("Unable to load playlist videos: %s", e)
|
|
self.signals.error.emit(str(e))
|
|
return
|
|
|
|
if playlist_data is None:
|
|
playlist_data = {"entries": []}
|
|
|
|
self.signals.playlist_ready.emit(playlist_data)
|
|
|
|
def render_videos(self, playlist_data: dict):
|
|
PlaylistSaver.MainWindow.clear_layout(self.list_layout)
|
|
self.reload_playlist_btn.setEnabled(True)
|
|
|
|
entries = [entry for entry in playlist_data.get("entries", []) if entry is not None]
|
|
self.info_label.setText(f"{len(entries)} videos")
|
|
|
|
if not entries:
|
|
self.list_layout.addWidget(QLabel("No videos found.", self.list_frame))
|
|
self.list_layout.addStretch(1)
|
|
return
|
|
|
|
for index, video in enumerate(entries, start=1):
|
|
thumbnail_path = self.get_video_thumbnail_path(video)
|
|
item = PlaylistSaver.MainWindow.VideoItem(self.list_frame, video, index, thumbnail_path)
|
|
item.clicked.connect(self.parent.open_video_player)
|
|
self.list_layout.addWidget(item)
|
|
|
|
self.list_layout.addStretch(1)
|
|
|
|
def show_error(self, message: str):
|
|
self.reload_playlist_btn.setEnabled(True)
|
|
self.info_label.setText("Unable to load playlist.")
|
|
QMessageBox.critical(self, "Error", f"Unable to load playlist: {message}")
|
|
|
|
def get_video_thumbnail_path(self, video: dict):
|
|
thumbnails = video.get("thumbnails") or []
|
|
if not thumbnails:
|
|
return None
|
|
|
|
thumbnail = thumbnails[0]
|
|
thumbnail_url = thumbnail.get("url")
|
|
if not thumbnail_url:
|
|
return None
|
|
|
|
thumbnail_resolution = thumbnail.get("resolution", "unknown")
|
|
video_id = video.get("id") or "unknown"
|
|
thumbnail_path = Path(work_dir, "temp", "thumbnails",
|
|
f"thumbnail_{video_id}_{thumbnail_resolution}.jpg")
|
|
|
|
if thumbnail_path.exists():
|
|
return thumbnail_path
|
|
|
|
if download_file(thumbnail_url, thumbnail_path):
|
|
return thumbnail_path
|
|
|
|
return None
|
|
|
|
class PlayerDialog(QDialog):
|
|
status_changed = Signal(str)
|
|
|
|
def __init__(self, parent, video: dict):
|
|
QDialog.__init__(self, parent)
|
|
self.parent = parent
|
|
self.video = video
|
|
self.video_url = resolve_video_page_url(video)
|
|
self.process = None
|
|
self.setWindowTitle(video.get("title", "Video"))
|
|
self.resize(440, 190)
|
|
|
|
self.status_changed.connect(self.set_status)
|
|
|
|
self.layout = QVBoxLayout(self)
|
|
self.layout.setContentsMargins(16, 16, 16, 16)
|
|
self.layout.setSpacing(10)
|
|
|
|
self.title_label = QLabel(video.get("title", "Video"), self)
|
|
self.title_label.setWordWrap(True)
|
|
|
|
self.status_label = QLabel("Launching mpv...", self)
|
|
self.url_label = QLabel(self.video_url or "", self)
|
|
self.url_label.setWordWrap(True)
|
|
|
|
self.close_btn = QPushButton("Close Player", self)
|
|
self.close_btn.clicked.connect(self.close)
|
|
|
|
self.layout.addWidget(self.title_label)
|
|
self.layout.addWidget(self.status_label)
|
|
self.layout.addWidget(self.url_label)
|
|
self.layout.addWidget(self.close_btn)
|
|
|
|
self.setStyleSheet("""
|
|
QDialog {
|
|
background-color: #202020;
|
|
}
|
|
|
|
QLabel {
|
|
background-color: transparent;
|
|
color: #f0f0f0;
|
|
}
|
|
|
|
QPushButton {
|
|
background-color: #3a3a3a;
|
|
color: #f0f0f0;
|
|
border: 1px solid #505050;
|
|
border-radius: 6px;
|
|
padding: 7px 10px;
|
|
}
|
|
|
|
QPushButton:hover {
|
|
background-color: #464646;
|
|
}
|
|
""")
|
|
|
|
threading.Thread(target=self.run_mpv, daemon=True).start()
|
|
|
|
def set_status(self, message: str):
|
|
self.status_label.setText(message)
|
|
|
|
def run_mpv(self):
|
|
mpv_path = find_mpv_path(PROGRAM_DIR)
|
|
if not mpv_path:
|
|
self.status_changed.emit("mpv not found in bin/ or PATH.")
|
|
return
|
|
|
|
try:
|
|
self.process = subprocess.Popen(
|
|
[
|
|
mpv_path,
|
|
# "--force-window=immediate",
|
|
"--focus-on=open",
|
|
self.video_url,
|
|
],
|
|
stdout=subprocess.DEVNULL,
|
|
stderr=subprocess.DEVNULL,
|
|
creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
|
|
)
|
|
except Exception as e:
|
|
logger.error("Unable to start mpv: %s", e)
|
|
self.status_changed.emit(f"Unable to start mpv: {e}")
|
|
return
|
|
|
|
self.parent.parent.mpv_processes[self] = self.process
|
|
self.status_changed.emit("Playing in mpv...")
|
|
self.process.wait()
|
|
self.parent.parent.mpv_processes.pop(self, None)
|
|
self.status_changed.emit("Playback finished.")
|
|
|
|
def closeEvent(self, event):
|
|
process = self.parent.parent.mpv_processes.pop(self, None)
|
|
if process and process.poll() is None:
|
|
process.terminate()
|
|
event.accept()
|
|
|
|
class SwitchProfileDialog(QDialog):
|
|
profile_changed = Signal(str)
|
|
|
|
def __init__(self, parent):
|
|
QDialog.__init__(self, parent)
|
|
self.parent = parent
|
|
self.setWindowTitle("Switch Profile")
|
|
self.resize(420, 420)
|
|
|
|
# Layout
|
|
self.layout = QVBoxLayout(self)
|
|
self.layout.setContentsMargins(16, 16, 16, 16)
|
|
self.layout.setSpacing(12)
|
|
|
|
# Items
|
|
self.current_profile_label = QLabel(f"Current: {self.app.get_active_profile_name()}")
|
|
self.current_profile_label.setWordWrap(True)
|
|
self.current_profile_label.setObjectName("currentProfile")
|
|
|
|
# Scroll are and frame (for profile item)
|
|
self.scroll_area = QScrollArea(self)
|
|
self.scroll_area.setWidgetResizable(True)
|
|
self.scroll_area.setFrameShape(QFrame.NoFrame)
|
|
|
|
self.list_frame = QFrame(self.scroll_area)
|
|
self.list_frame.setObjectName("profileList")
|
|
self.list_layout = QVBoxLayout(self.list_frame)
|
|
self.list_layout.setContentsMargins(8, 8, 8, 8)
|
|
self.list_layout.setSpacing(8)
|
|
self.scroll_area.setWidget(self.list_frame)
|
|
|
|
self.create_profile_btn = QPushButton("Create Profile")
|
|
self.create_profile_btn.setMinimumHeight(34)
|
|
self.create_profile_btn.clicked.connect(self.create_profile)
|
|
|
|
self.layout.addWidget(self.current_profile_label)
|
|
self.layout.addWidget(self.scroll_area, 1)
|
|
self.layout.addWidget(self.create_profile_btn)
|
|
|
|
self.render_profiles()
|
|
|
|
self.setStyleSheet("""
|
|
QDialog {
|
|
background-color: #202020;
|
|
}
|
|
|
|
QScrollArea, #profileList {
|
|
background-color: #242424;
|
|
}
|
|
|
|
#currentProfile {
|
|
background-color: transparent;
|
|
color: #f0f0f0;
|
|
font-weight: 600;
|
|
padding-bottom: 4px;
|
|
}
|
|
|
|
QFrame#profileRow {
|
|
background-color: #2b2b2b;
|
|
border: 1px solid #3c3c3c;
|
|
border-radius: 8px;
|
|
}
|
|
|
|
QLabel {
|
|
background-color: transparent;
|
|
color: #f0f0f0;
|
|
}
|
|
|
|
QPushButton {
|
|
background-color: #3a3a3a;
|
|
color: #f0f0f0;
|
|
border: 1px solid #505050;
|
|
border-radius: 6px;
|
|
padding: 7px 10px;
|
|
}
|
|
|
|
QPushButton:hover {
|
|
background-color: #464646;
|
|
}
|
|
|
|
QPushButton:disabled {
|
|
color: #999999;
|
|
background-color: #303030;
|
|
}
|
|
""")
|
|
|
|
@property
|
|
def app(self):
|
|
return self.parent.parent
|
|
|
|
def clear_profiles(self):
|
|
while self.list_layout.count():
|
|
item = self.list_layout.takeAt(0)
|
|
widget = item.widget()
|
|
if widget:
|
|
widget.deleteLater()
|
|
|
|
class ProfileRow(QFrame):
|
|
def __init__(self, parent, profile_name: str, active_profile: str,
|
|
switch_profile, delete_profile):
|
|
QFrame.__init__(self, parent)
|
|
self.setObjectName("profileRow")
|
|
|
|
self.row_layout = QHBoxLayout(self)
|
|
self.row_layout.setContentsMargins(10, 8, 10, 8)
|
|
self.row_layout.setSpacing(8)
|
|
|
|
self.name_label = QLabel(profile_name)
|
|
self.name_label.setWordWrap(True)
|
|
|
|
self.switch_btn = QPushButton("Current" if profile_name == active_profile else "Switch")
|
|
self.switch_btn.setMinimumWidth(88)
|
|
self.switch_btn.setEnabled(profile_name != active_profile)
|
|
self.switch_btn.clicked.connect(lambda _checked=False, name=profile_name: switch_profile(name))
|
|
|
|
self.delete_btn = QPushButton("Delete")
|
|
self.delete_btn.setMinimumWidth(88)
|
|
self.delete_btn.setDisabled(profile_name == "Default")
|
|
self.delete_btn.clicked.connect(lambda _checked=False, name=profile_name: delete_profile(name))
|
|
|
|
self.row_layout.addWidget(self.name_label, 1)
|
|
self.row_layout.addWidget(self.switch_btn)
|
|
self.row_layout.addWidget(self.delete_btn)
|
|
|
|
def render_profiles(self):
|
|
self.clear_profiles()
|
|
|
|
meta = self.app.load_profiles_meta()
|
|
active_profile = meta["active_profile"]
|
|
|
|
for profile_name in meta["profiles"]:
|
|
row = self.ProfileRow(self, profile_name, active_profile, self.switch_profile, self.delete_profile)
|
|
self.list_layout.addWidget(row)
|
|
|
|
self.list_layout.addStretch(1)
|
|
|
|
def switch_profile(self, profile_name: str):
|
|
self.profile_changed.emit(profile_name)
|
|
self.accept()
|
|
|
|
def delete_profile(self, profile_name: str):
|
|
meta = self.app.load_profiles_meta()
|
|
|
|
if profile_name == meta["active_profile"]:
|
|
QMessageBox.critical(self, "Error", "Cannot delete the active profile.")
|
|
return
|
|
|
|
if profile_name == self.app.DEFAULT_PROFILE_NAME:
|
|
QMessageBox.critical(self, "Error", "Cannot delete the default profile.")
|
|
return
|
|
|
|
reply = QMessageBox.question(
|
|
self,
|
|
"Delete Profile",
|
|
f"Delete profile '{profile_name}'?",
|
|
QMessageBox.Yes | QMessageBox.No,
|
|
QMessageBox.No,
|
|
)
|
|
|
|
if reply != QMessageBox.Yes:
|
|
return
|
|
|
|
meta["profiles"] = [
|
|
name for name in meta["profiles"]
|
|
if name != profile_name
|
|
]
|
|
|
|
self.app.save_profiles_meta(meta)
|
|
self.render_profiles()
|
|
|
|
def create_profile(self):
|
|
profile_name, ok = QInputDialog.getText(self, "Create Profile", "Profile name:")
|
|
|
|
if not ok:
|
|
return
|
|
|
|
profile_name = profile_name.strip()
|
|
if not profile_name:
|
|
QMessageBox.critical(self, "Error", "Profile name cannot be empty.")
|
|
return
|
|
|
|
self.app.ensure_profile_exists(profile_name)
|
|
self.render_profiles()
|
|
|
|
def init(self):
|
|
self.initialize_profiles()
|
|
# Start background thread after root is ready for UI callbacks.
|
|
self.reload_playlists()
|
|
|
|
def reload_playlists(self):
|
|
self.window.loading_label.setText("Loading playlists...")
|
|
|
|
threading.Thread(
|
|
target=fetch_playlists_data,
|
|
args=(self.url_schema, self.get_profile_cookie_path(self.active_profile_name), self.get_ydl_opts(), self.on_data_ready),
|
|
daemon=True,
|
|
).start()
|
|
|
|
#
|
|
# Profile
|
|
#
|
|
def initialize_profiles(self):
|
|
try:
|
|
self.profiles_path.parent.mkdir(parents=True, exist_ok=True)
|
|
except Exception as e:
|
|
logger.error("Unable to create profiles folder:", e)
|
|
QMessageBox.critical(self.window, "Error",
|
|
"Unable to create profiles folder.\n"
|
|
f"At path: {self.profiles_path.as_posix()}\n"
|
|
f"Reason: {e}\n"
|
|
f"Solution: Try to remove profiles folder manually and try again.")
|
|
|
|
active_name = self.get_active_profile_name()
|
|
self.ensure_profile_exists(active_name)
|
|
self.set_active_profile(active_name)
|
|
|
|
def ensure_profile_exists(self, profile_name: str):
|
|
meta = self.load_profiles_meta()
|
|
profiles = meta["profiles"]
|
|
|
|
if profile_name not in profiles:
|
|
profiles.append(profile_name)
|
|
meta["profiles"] = profiles
|
|
self.save_profiles_meta(meta)
|
|
|
|
self.get_profile_dir(profile_name).parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
def get_active_profile_name(self):
|
|
meta = self.load_profiles_meta()
|
|
self.active_profile_name = meta.get("active_profile", None)
|
|
return self.active_profile_name
|
|
|
|
def load_profiles_meta(self):
|
|
meta = read_json(self.profiles_meta_path)
|
|
if not meta:
|
|
return {
|
|
"active_profile": self.DEFAULT_PROFILE_NAME,
|
|
"profiles": [self.DEFAULT_PROFILE_NAME],
|
|
}
|
|
|
|
profiles = meta.get("profiles") or [self.DEFAULT_PROFILE_NAME]
|
|
active_profile = meta.get("active_profile") or profiles[0]
|
|
|
|
if active_profile not in profiles:
|
|
profiles.insert(0, active_profile)
|
|
|
|
return {
|
|
"active_profile": active_profile,
|
|
"profiles": profiles,
|
|
}
|
|
|
|
def set_active_profile(self, profile_name: str):
|
|
meta = self.load_profiles_meta()
|
|
profiles = meta["profiles"]
|
|
|
|
if profile_name not in profiles:
|
|
profiles.append(profile_name)
|
|
|
|
meta["profiles"] = profiles
|
|
meta["active_profile"] = profile_name
|
|
self.save_profiles_meta(meta)
|
|
|
|
self.active_profile_name = profile_name
|
|
self.cookie_path = self.get_profile_cookie_path(profile_name)
|
|
self.cookie_path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
def save_profiles_meta(self, meta: dict):
|
|
save_json(meta, self.profiles_meta_path)
|
|
|
|
def delete_profile(self, profile_name: str):
|
|
meta = self.load_profiles_meta()
|
|
|
|
if not profile_name in meta["profiles"]:
|
|
return
|
|
|
|
meta["profiles"].remove(profile_name)
|
|
|
|
self.save_profiles_meta(meta)
|
|
|
|
#
|
|
# Path
|
|
#
|
|
def get_profile_cookie_path(self, profile_name: str):
|
|
return Path(self.get_profile_dir(profile_name), "cookies.txt")
|
|
|
|
def get_profile_dir(self, profile_name: str):
|
|
return Path(self.profiles_path, sanitize_filename(profile_name))
|
|
|
|
def get_profile_temp_dir(self, profile_name: str | None = None):
|
|
profile_name = profile_name or self.active_profile_name
|
|
return self.temp_path / sanitize_filename(profile_name)
|
|
|
|
def get_playlist_cache_path(self, playlist_id: str):
|
|
safe_id = sanitize_filename(playlist_id or "unknown")
|
|
return self.get_profile_temp_dir() / "playlists" / f"{safe_id}.json"
|
|
|
|
#
|
|
# PlaylistData
|
|
#
|
|
def on_data_ready(self, data, error):
|
|
if isinstance(error, PlaylistFetchException):
|
|
self.window.signals.playlist_fetch_error.emit(error)
|
|
if data is None:
|
|
data = {"entries": []}
|
|
|
|
self.playlists["entries"] = data.get("entries", [])
|
|
self.window.signals.playlists_ready.emit(self.playlists)
|
|
|
|
def load_playlist_videos(self, playlist_id: str):
|
|
cache_path = self.get_playlist_cache_path(playlist_id)
|
|
if os.path.exists(cache_path):
|
|
return read_json(cache_path)
|
|
return None
|
|
|
|
def fetch_playlist_videos(self, playlist: dict):
|
|
playlist_id = playlist.get("id")
|
|
playlist_url = playlist.get("url") or playlist.get("webpage_url")
|
|
|
|
if not playlist_url and playlist_id and not str(playlist_id).startswith("VL"):
|
|
playlist_url = f"https://www.youtube.com/playlist?list={playlist_id}"
|
|
|
|
if not playlist_url:
|
|
raise ValueError("Playlist URL not found.")
|
|
|
|
cached_data = self.load_playlist_videos(playlist_id)
|
|
if cached_data:
|
|
return cached_data
|
|
|
|
opts = self.get_ydl_opts()
|
|
|
|
opts.update({"extract_flat": True,
|
|
"skip_download": True,
|
|
"quiet": True, })
|
|
|
|
with fetch_playlist_lock:
|
|
with YoutubeDL(opts) as ydl:
|
|
data = ydl.extract_info(playlist_url, download=False)
|
|
|
|
self.save_playlist_videos(playlist_id, data)
|
|
return data
|
|
|
|
def save_playlist_videos(self, playlist_id: str, data: dict):
|
|
save_json(data, self.get_playlist_cache_path(playlist_id))
|
|
|
|
def get_ydl_opts(self):
|
|
return {
|
|
'cookiefile': self.get_profile_cookie_path(self.active_profile_name),
|
|
'verbose': True,
|
|
'download': False,
|
|
'js_runtimes': {"node": {}},
|
|
'extract_flat': False,
|
|
'lazy_playlist': False,
|
|
"ignoreerrors": False
|
|
}
|
|
|
|
|
|
@click.command()
|
|
@click.argument("url_schema", default=None, required=False)
|
|
@click.option("--cookie-file", "-cf", required=False, default=None, help="Cookies file",
|
|
type=click.Path(exists=True))
|
|
@click.option("--new-work-dir", "-wd", required=False, default=None, help="New working directory",
|
|
type=click.Path(exists=True))
|
|
def main(url_schema, cookie_file: str, new_work_dir: str):
|
|
global work_dir
|
|
|
|
icon_path = PROGRAM_DIR / "assets" / "icon.ico"
|
|
|
|
if new_work_dir:
|
|
work_dir = Path(new_work_dir)
|
|
|
|
if work_dir is None:
|
|
app = QApplication(sys.argv)
|
|
|
|
if icon_path.exists():
|
|
app.setWindowIcon(QIcon(icon_path.as_posix()))
|
|
|
|
folder = QFileDialog.getExistingDirectory(
|
|
None, "Select a folder as the new working directory"
|
|
)
|
|
|
|
if folder:
|
|
work_dir = Path(folder)
|
|
else:
|
|
QMessageBox.warning(
|
|
None,
|
|
"Warning",
|
|
"PlaylistSaver requires a working directory to store files. Please specify a working directory"
|
|
" using argument \"--new-work-dir\".",
|
|
)
|
|
sys.exit(1)
|
|
|
|
app.shutdown()
|
|
|
|
app = PlaylistSaver(
|
|
url_schema,
|
|
cookie_file,
|
|
)
|
|
if icon_path.exists():
|
|
app.setWindowIcon(QIcon(icon_path.as_posix()))
|
|
sys.exit(app.exec())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|