oop7
0b0e3add3c
Introduce check_ytdlp_deno_integration() in ytsage_yt_dlp.py to detect Deno integration by running `yt-dlp --verbose` and scanning debug output for JS runtimes containing "deno" (with timeout and logging/fallback). Add SystemInfoThread (QThread) in ytsage_dialogs_base.py to collect yt-dlp, ffmpeg and deno presence, versions, paths, cache timestamps and integration status in the background, emitting the gathered info via info_ready. AboutDialog now starts the thread in update_system_info() and populates the UI asynchronously via _populate_system_info(), showing a small "+ yt-dlp" integration indicator next to the Deno status when detected. Refactors usage of version/cache lookups to use the thread-provided info dictionary.
755 lines
28 KiB
Python
755 lines
28 KiB
Python
import os
|
|
import shutil
|
|
import subprocess
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
import requests
|
|
from PySide6.QtCore import Qt, QThread, Signal
|
|
from PySide6.QtGui import QIcon
|
|
from PySide6.QtWidgets import (
|
|
QDialog,
|
|
QFileDialog,
|
|
QHBoxLayout,
|
|
QLabel,
|
|
QMessageBox,
|
|
QProgressBar,
|
|
QPushButton,
|
|
QRadioButton,
|
|
QVBoxLayout,
|
|
QWidget,
|
|
)
|
|
|
|
from ..utils.ytsage_logger import logger
|
|
from ..utils.ytsage_constants import (
|
|
APP_BIN_DIR,
|
|
ICON_PATH,
|
|
OS_FULL_NAME,
|
|
OS_NAME,
|
|
SUBPROCESS_CREATIONFLAGS,
|
|
YTDLP_APP_BIN_PATH,
|
|
YTDLP_DOWNLOAD_URL,
|
|
YTDLP_SHA256_URL,
|
|
)
|
|
from .ytsage_ffmpeg import get_file_sha256
|
|
from ..utils.ytsage_localization import _
|
|
|
|
# YTDLP_URLS moved to src\utils\ytsage_constants.py
|
|
# get_ytdlp_install_dir() moved to src\utils\ytsage_constants.py
|
|
# get_ytdlp_executable_path() moved to src\utils\ytsage_constants.py
|
|
# get_os_type() moved to src\utils\ytsage_constants.py
|
|
# ensure_install_dir_exists() moved to src\utils\ytsage_constants.py
|
|
|
|
|
|
def verify_ytdlp_sha256(file_path: Path, download_url: str) -> bool:
|
|
"""
|
|
Verify yt-dlp file SHA256 hash against official checksums.
|
|
|
|
Args:
|
|
file_path: Path to the downloaded yt-dlp file
|
|
download_url: The URL used to download the file (to determine the filename)
|
|
|
|
Returns:
|
|
bool: True if verification successful, False otherwise
|
|
"""
|
|
try:
|
|
# Download the SHA2-256SUMS file
|
|
logger.info(f"Downloading SHA256 checksums from: {YTDLP_SHA256_URL}")
|
|
response = requests.get(YTDLP_SHA256_URL, timeout=10)
|
|
response.raise_for_status()
|
|
checksum_content = response.text
|
|
|
|
# Extract filename from download URL (e.g., yt-dlp.exe, yt-dlp_macos, yt-dlp)
|
|
filename = download_url.split("/")[-1]
|
|
logger.info(f"Looking for checksum for file: {filename}")
|
|
|
|
# Parse the checksum file to find the matching hash
|
|
expected_hash = None
|
|
for line in checksum_content.strip().split("\n"):
|
|
if filename in line:
|
|
# Format: "hash filename"
|
|
parts = line.strip().split()
|
|
if len(parts) >= 2 and parts[1] == filename:
|
|
expected_hash = parts[0]
|
|
break
|
|
|
|
if not expected_hash:
|
|
logger.error(f"Could not find SHA256 hash for {filename} in checksums file")
|
|
return False
|
|
|
|
# Calculate actual hash of downloaded file
|
|
logger.info("Calculating SHA256 hash of downloaded file...")
|
|
actual_hash = get_file_sha256(file_path)
|
|
|
|
# Compare hashes
|
|
if actual_hash.lower() == expected_hash.lower():
|
|
logger.info("✓ SHA256 verification successful!")
|
|
logger.info(f" Expected: {expected_hash}")
|
|
logger.info(f" Actual: {actual_hash}")
|
|
return True
|
|
else:
|
|
logger.error("✗ SHA256 verification failed!")
|
|
logger.error(f" Expected: {expected_hash}")
|
|
logger.error(f" Actual: {actual_hash}")
|
|
return False
|
|
|
|
except requests.RequestException as e:
|
|
logger.error(f"Failed to download SHA256 checksums: {e}")
|
|
return False
|
|
except Exception as e:
|
|
logger.exception(f"Error during SHA256 verification: {e}")
|
|
return False
|
|
|
|
|
|
class DownloadYtdlpThread(QThread):
|
|
progress_signal = Signal(int)
|
|
finished_signal = Signal(bool, str)
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
def run(self) -> None:
|
|
try:
|
|
# Extra logic moved to src\utils\ytsage_constants.py
|
|
exe_path = YTDLP_APP_BIN_PATH
|
|
|
|
# Download with progress reporting
|
|
logger.info(f"Downloading yt-dlp from: {YTDLP_DOWNLOAD_URL}")
|
|
response = requests.get(YTDLP_DOWNLOAD_URL, stream=True)
|
|
response.raise_for_status()
|
|
total_size = int(response.headers.get("content-length", 0))
|
|
block_size = 1024 # 1 Kibibyte
|
|
|
|
if total_size == 0:
|
|
self.progress_signal.emit(100)
|
|
|
|
with open(exe_path, "wb") as f:
|
|
downloaded = 0
|
|
for data in response.iter_content(block_size):
|
|
f.write(data)
|
|
downloaded += len(data)
|
|
if total_size > 0:
|
|
progress = int(downloaded / total_size * 100)
|
|
self.progress_signal.emit(progress)
|
|
|
|
logger.info("Download complete, verifying SHA256 hash...")
|
|
|
|
# Verify SHA256 hash
|
|
if not verify_ytdlp_sha256(exe_path, YTDLP_DOWNLOAD_URL):
|
|
# Hash verification failed - delete the downloaded file
|
|
logger.error("SHA256 verification failed! Removing downloaded file.")
|
|
if Path(exe_path).exists():
|
|
Path(exe_path).unlink()
|
|
self.finished_signal.emit(
|
|
False,
|
|
"SHA256 verification failed. The downloaded file may be corrupted or tampered with."
|
|
)
|
|
return
|
|
|
|
# Make executable on macOS and Linux
|
|
if OS_NAME != "Windows":
|
|
os.chmod(exe_path, 0o755)
|
|
|
|
logger.info("yt-dlp downloaded and verified successfully!")
|
|
self.finished_signal.emit(True, str(exe_path))
|
|
|
|
except Exception as e:
|
|
logger.exception(f"Error downloading yt-dlp: {e}")
|
|
self.finished_signal.emit(False, str(e))
|
|
|
|
|
|
class YtdlpSetupDialog(QDialog):
|
|
setup_complete = Signal(str) # Signal emitting the path to yt-dlp
|
|
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent)
|
|
self.setWindowTitle(_("ytdlp_setup.required_title"))
|
|
self.setMinimumWidth(520)
|
|
self.setMinimumHeight(350)
|
|
self.resize(520, 380)
|
|
|
|
# Set the window icon to match the main app
|
|
if parent and parent.windowIcon():
|
|
self.setWindowIcon(parent.windowIcon())
|
|
else:
|
|
# icon_path logic moved to src\utils\ytsage_constants.py
|
|
icon_path = ICON_PATH
|
|
if Path.exists(icon_path):
|
|
self.setWindowIcon(QIcon(str(icon_path)))
|
|
|
|
self.init_ui()
|
|
|
|
# Apply dark theme styling to match app
|
|
self.setStyleSheet(
|
|
"""
|
|
QDialog {
|
|
background-color: #15181b;
|
|
color: #ffffff;
|
|
}
|
|
QLabel {
|
|
color: #cccccc;
|
|
line-height: 1.4;
|
|
}
|
|
QPushButton {
|
|
padding: 10px 20px;
|
|
background-color: #c90000;
|
|
border: none;
|
|
border-radius: 6px;
|
|
color: white;
|
|
font-weight: bold;
|
|
font-size: 13px;
|
|
min-width: 120px;
|
|
min-height: 20px;
|
|
}
|
|
QPushButton:hover {
|
|
background-color: #a50000;
|
|
}
|
|
QPushButton:pressed {
|
|
background-color: #800000;
|
|
}
|
|
QPushButton:disabled {
|
|
background-color: #666666;
|
|
color: #999999;
|
|
}
|
|
QProgressBar {
|
|
border: 2px solid #1d1e22;
|
|
border-radius: 6px;
|
|
text-align: center;
|
|
color: white;
|
|
background-color: #1d1e22;
|
|
height: 25px;
|
|
font-weight: bold;
|
|
}
|
|
QProgressBar::chunk {
|
|
background: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 0,
|
|
stop: 0 #e60000, stop: 0.5 #ff3333, stop: 1 #c90000);
|
|
border-radius: 4px;
|
|
margin: 1px;
|
|
}
|
|
QRadioButton {
|
|
color: #ffffff;
|
|
spacing: 10px;
|
|
padding: 8px;
|
|
font-size: 13px;
|
|
}
|
|
QRadioButton::indicator {
|
|
width: 18px;
|
|
height: 18px;
|
|
border-radius: 9px;
|
|
}
|
|
QRadioButton::indicator:unchecked {
|
|
border: 2px solid #666666;
|
|
background: #1d1e22;
|
|
}
|
|
QRadioButton::indicator:checked {
|
|
border: 2px solid #c90000;
|
|
background: #c90000;
|
|
}
|
|
"""
|
|
)
|
|
|
|
def init_ui(self) -> None:
|
|
layout = QVBoxLayout()
|
|
layout.setSpacing(15)
|
|
layout.setContentsMargins(25, 25, 25, 25)
|
|
|
|
# Header title
|
|
title_label = QLabel(_("ytdlp_setup.required_title"))
|
|
title_label.setStyleSheet("font-size: 16px; font-weight: bold; color: #ffffff; padding: 5px 0;")
|
|
title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
layout.addWidget(title_label)
|
|
|
|
# Information label with improved styling
|
|
# os_name logic moved to src\utils\ytsage_constants.py
|
|
|
|
info_label = QLabel(
|
|
_("ytdlp_setup.description", os_name=OS_FULL_NAME)
|
|
)
|
|
info_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
info_label.setWordWrap(True)
|
|
info_label.setStyleSheet("font-size: 13px; color: #cccccc; padding: 5px; line-height: 1.4;")
|
|
layout.addWidget(info_label)
|
|
|
|
# Radio buttons with minimal spacing
|
|
option_widget = QWidget()
|
|
option_layout = QVBoxLayout(option_widget)
|
|
option_layout.setSpacing(8)
|
|
option_layout.setContentsMargins(0, 0, 0, 0)
|
|
|
|
self.auto_radio = QRadioButton(_("ytdlp_setup.option_auto"))
|
|
self.auto_radio.setChecked(True)
|
|
self.manual_radio = QRadioButton(_("ytdlp_setup.option_manual"))
|
|
|
|
option_layout.addWidget(self.auto_radio)
|
|
option_layout.addWidget(self.manual_radio)
|
|
layout.addWidget(option_widget)
|
|
|
|
# Progress bar with proper sizing
|
|
self.progress_bar = QProgressBar()
|
|
self.progress_bar.setVisible(False)
|
|
self.progress_bar.setFixedHeight(20) # Fixed height for consistency
|
|
self.progress_bar.setStyleSheet(
|
|
"""
|
|
QProgressBar {
|
|
border: 1px solid #3d3d3d;
|
|
border-radius: 8px;
|
|
background-color: #1d1e22;
|
|
text-align: center;
|
|
color: #ffffff;
|
|
font-size: 12px;
|
|
font-weight: bold;
|
|
height: 20px;
|
|
}
|
|
QProgressBar::chunk {
|
|
background-color: #c90000;
|
|
border-radius: 6px;
|
|
margin: 1px;
|
|
}
|
|
"""
|
|
)
|
|
layout.addWidget(self.progress_bar)
|
|
|
|
# Status label with better spacing
|
|
self.status_label = QLabel("")
|
|
self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
self.status_label.setStyleSheet("font-size: 12px; color: #cccccc; padding: 8px 0;")
|
|
self.status_label.setWordWrap(True)
|
|
layout.addWidget(self.status_label)
|
|
|
|
# Add stretch to push buttons to bottom
|
|
layout.addStretch()
|
|
|
|
# Button layout with improved spacing
|
|
button_layout = QHBoxLayout()
|
|
button_layout.setSpacing(15)
|
|
button_layout.setContentsMargins(0, 10, 0, 0) # Add top margin for buttons
|
|
|
|
self.setup_button = QPushButton(_("ytdlp_setup.setup_button"))
|
|
self.setup_button.clicked.connect(self.setup_ytdlp)
|
|
|
|
self.cancel_button = QPushButton(_("buttons.cancel"))
|
|
self.cancel_button.clicked.connect(self.reject)
|
|
|
|
button_layout.addWidget(self.setup_button)
|
|
button_layout.addWidget(self.cancel_button)
|
|
layout.addLayout(button_layout)
|
|
|
|
self.setLayout(layout)
|
|
|
|
def setup_ytdlp(self) -> None:
|
|
if self.auto_radio.isChecked():
|
|
self.download_ytdlp()
|
|
else:
|
|
self.select_ytdlp_path()
|
|
|
|
def download_ytdlp(self) -> None:
|
|
self.progress_bar.setVisible(True)
|
|
self.progress_bar.setValue(0)
|
|
self.status_label.setText(_("ytdlp_setup.downloading"))
|
|
self.setup_button.setEnabled(False)
|
|
self.cancel_button.setEnabled(False)
|
|
|
|
self.download_thread = DownloadYtdlpThread()
|
|
self.download_thread.progress_signal.connect(self.update_progress)
|
|
self.download_thread.finished_signal.connect(self.download_finished)
|
|
self.download_thread.start()
|
|
|
|
def update_progress(self, value) -> None:
|
|
self.progress_bar.setValue(value)
|
|
|
|
def download_finished(self, success, result) -> None:
|
|
self.setup_button.setEnabled(True)
|
|
self.cancel_button.setEnabled(True)
|
|
|
|
if success:
|
|
self.status_label.setText(_("ytdlp_setup.success"))
|
|
self.setup_complete.emit(result)
|
|
self.accept()
|
|
else:
|
|
self.status_label.setText(_("ytdlp_setup.error", error=result))
|
|
error_dialog = QMessageBox(self)
|
|
error_dialog.setIcon(QMessageBox.Icon.Critical)
|
|
error_dialog.setWindowTitle(_("ytdlp_setup.download_failed_title"))
|
|
error_dialog.setText(_("ytdlp_setup.download_failed_message", error=result))
|
|
# Set the window icon to match the main dialog
|
|
error_dialog.setWindowIcon(self.windowIcon())
|
|
error_dialog.setStyleSheet(
|
|
"""
|
|
QMessageBox {
|
|
background-color: #15181b;
|
|
color: #ffffff;
|
|
}
|
|
QLabel {
|
|
color: #ffffff;
|
|
}
|
|
QPushButton {
|
|
padding: 8px 15px;
|
|
background-color: #c90000;
|
|
border: none;
|
|
border-radius: 4px;
|
|
color: white;
|
|
font-weight: bold;
|
|
}
|
|
QPushButton:hover {
|
|
background-color: #a50000;
|
|
}
|
|
"""
|
|
)
|
|
error_dialog.exec()
|
|
|
|
def select_ytdlp_path(self) -> None:
|
|
if OS_NAME == "Windows":
|
|
file_filter = _("ytdlp_setup.file_filter_windows")
|
|
else:
|
|
file_filter = _("ytdlp_setup.file_filter_all")
|
|
|
|
# Apply style to QFileDialog
|
|
file_dialog = QFileDialog(self)
|
|
file_dialog.setStyleSheet(
|
|
"""
|
|
QFileDialog {
|
|
background-color: #15181b;
|
|
color: #ffffff;
|
|
}
|
|
QLabel, QCheckBox, QListView, QTreeView, QComboBox, QLineEdit {
|
|
color: #ffffff;
|
|
background-color: #1b2021;
|
|
}
|
|
QPushButton {
|
|
padding: 8px 15px;
|
|
background-color: #c90000;
|
|
border: none;
|
|
border-radius: 4px;
|
|
color: white;
|
|
font-weight: bold;
|
|
}
|
|
QPushButton:hover {
|
|
background-color: #a50000;
|
|
}
|
|
"""
|
|
)
|
|
|
|
file_path, _ = file_dialog.getOpenFileName(
|
|
self, _("ytdlp_setup.select_executable_title"), "", file_filter
|
|
)
|
|
|
|
if file_path:
|
|
logger.debug(f"User selected file: {file_path}")
|
|
# Verify the selected file
|
|
try:
|
|
# Extra logic moved to src\utils\ytsage_constants.py
|
|
# Try to run yt-dlp --version
|
|
logger.debug(f"Verifying file with --version command")
|
|
result = subprocess.run(
|
|
[file_path, "--version"], capture_output=True, text=True, check=False, creationflags=SUBPROCESS_CREATIONFLAGS
|
|
)
|
|
logger.debug(f"Version check result: {result.returncode}, Output: {result.stdout.strip()}")
|
|
|
|
if result.returncode == 0:
|
|
# File is valid, copy it to our app's bin directory
|
|
try:
|
|
# Ensure the bin directory exists
|
|
logger.debug(f"Install directory: {APP_BIN_DIR}")
|
|
|
|
# Determine the target filename based on OS
|
|
target_path = YTDLP_APP_BIN_PATH
|
|
logger.debug(f"Target path: {target_path}")
|
|
|
|
# Copy the file
|
|
shutil.copy2(file_path, target_path)
|
|
logger.debug(f"File copied successfully")
|
|
|
|
# Set executable permissions on Unix systems
|
|
if OS_NAME != "Windows":
|
|
os.chmod(target_path, 0o755)
|
|
logger.debug(f"Permissions set on Unix system")
|
|
|
|
# Return the path of the copied file
|
|
self.status_label.setText(_("ytdlp_setup.copied_to", path=target_path))
|
|
logger.debug(f"Emitting setup_complete signal with path: {target_path}")
|
|
self.setup_complete.emit(target_path)
|
|
self.accept()
|
|
except Exception as copy_error:
|
|
logger.debug(f"Error copying file: {copy_error}", exc_info=True)
|
|
error_dialog = QMessageBox(self)
|
|
error_dialog.setIcon(QMessageBox.Icon.Critical)
|
|
error_dialog.setWindowTitle(_("ytdlp_setup.setup_error_title"))
|
|
error_dialog.setText(_("ytdlp_setup.copy_error", error=copy_error))
|
|
error_dialog.setStyleSheet(
|
|
"""
|
|
QMessageBox {
|
|
background-color: #15181b;
|
|
color: #ffffff;
|
|
}
|
|
QLabel {
|
|
color: #ffffff;
|
|
}
|
|
QPushButton {
|
|
padding: 8px 15px;
|
|
background-color: #c90000;
|
|
border: none;
|
|
border-radius: 4px;
|
|
color: white;
|
|
font-weight: bold;
|
|
}
|
|
QPushButton:hover {
|
|
background-color: #a50000;
|
|
}
|
|
"""
|
|
)
|
|
error_dialog.exec()
|
|
else:
|
|
logger.debug(f"File verification failed with return code: {result.returncode}")
|
|
error_dialog = QMessageBox(self)
|
|
error_dialog.setIcon(QMessageBox.Icon.Warning)
|
|
error_dialog.setWindowTitle(_("ytdlp_setup.invalid_executable_title"))
|
|
error_dialog.setText(_("ytdlp_setup.invalid_executable_message"))
|
|
error_dialog.setStyleSheet(
|
|
"""
|
|
QMessageBox {
|
|
background-color: #15181b;
|
|
color: #ffffff;
|
|
}
|
|
QLabel {
|
|
color: #ffffff;
|
|
}
|
|
QPushButton {
|
|
padding: 8px 15px;
|
|
background-color: #c90000;
|
|
border: none;
|
|
border-radius: 4px;
|
|
color: white;
|
|
font-weight: bold;
|
|
}
|
|
QPushButton:hover {
|
|
background-color: #a50000;
|
|
}
|
|
"""
|
|
)
|
|
error_dialog.exec()
|
|
except Exception as e:
|
|
logger.debug(f"Exception during verification: {e}", exc_info=True)
|
|
error_dialog = QMessageBox(self)
|
|
error_dialog.setIcon(QMessageBox.Icon.Critical)
|
|
error_dialog.setWindowTitle(_("main_ui.error_title"))
|
|
error_dialog.setText(_("ytdlp_setup.verify_error", error=e))
|
|
error_dialog.setStyleSheet(
|
|
"""
|
|
QMessageBox {
|
|
background-color: #15181b;
|
|
color: #ffffff;
|
|
}
|
|
QLabel {
|
|
color: #ffffff;
|
|
}
|
|
QPushButton {
|
|
padding: 8px 15px;
|
|
background-color: #c90000;
|
|
border: none;
|
|
border-radius: 4px;
|
|
color: white;
|
|
font-weight: bold;
|
|
}
|
|
QPushButton:hover {
|
|
background-color: #a50000;
|
|
}
|
|
"""
|
|
)
|
|
error_dialog.exec()
|
|
|
|
|
|
def check_ytdlp_binary() -> Optional[Path]:
|
|
"""
|
|
Check if yt-dlp binary exists in the app's bin directory ONLY.
|
|
We now ignore system PATH and only use our managed binary.
|
|
Returns:
|
|
Path or None: Path to yt-dlp binary if found in app bin, None otherwise
|
|
"""
|
|
exe_path = YTDLP_APP_BIN_PATH
|
|
if exe_path.exists():
|
|
# Make sure it's executable on Unix systems
|
|
if OS_NAME != "Windows" and not os.access(exe_path, os.X_OK):
|
|
try:
|
|
os.chmod(exe_path, 0o755)
|
|
logger.info(f"Fixed permissions on yt-dlp at {exe_path}")
|
|
except Exception as e:
|
|
logger.exception(f"Could not set executable permissions on {exe_path}: {e}")
|
|
logger.info(f"Found yt-dlp in app bin directory: {exe_path}")
|
|
return exe_path
|
|
|
|
# Binary not found in app directory - return None to trigger setup
|
|
logger.warning(f"yt-dlp binary not found in app bin directory: {exe_path}")
|
|
return None
|
|
|
|
|
|
def check_ytdlp_installed() -> bool:
|
|
"""
|
|
Check if yt-dlp is installed and accessible.
|
|
Returns:
|
|
bool: True if yt-dlp is found and working, False otherwise
|
|
"""
|
|
try:
|
|
ytdlp_path = check_ytdlp_binary()
|
|
if ytdlp_path:
|
|
# Try to run yt-dlp --version to verify it's working
|
|
try:
|
|
# Extra logic moved to src\utils\ytsage_constants.py
|
|
result = subprocess.run(
|
|
[ytdlp_path, "--version"], capture_output=True, text=True, timeout=5, creationflags=SUBPROCESS_CREATIONFLAGS
|
|
)
|
|
return result.returncode == 0
|
|
except Exception:
|
|
return False
|
|
return False
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def get_yt_dlp_path() -> Path:
|
|
"""
|
|
Get the yt-dlp path, either from the app's bin directory or system PATH.
|
|
This replaces the function in ytsage_utils.py.
|
|
Returns:
|
|
str: Path to yt-dlp binary
|
|
"""
|
|
# First check if we have yt-dlp in our app's bin directory or system PATH
|
|
ytdlp_path = check_ytdlp_binary()
|
|
if ytdlp_path:
|
|
logger.info(f"Using yt-dlp from: {ytdlp_path}")
|
|
return ytdlp_path
|
|
|
|
# If not found anywhere, fall back to the command name as a last resort
|
|
logger.info("yt-dlp not found in app directory or PATH, falling back to command name")
|
|
return "yt-dlp" # type: ignore[return-value]
|
|
|
|
|
|
def setup_ytdlp(parent_widget=None):
|
|
"""
|
|
Show the yt-dlp setup dialog and handle the result.
|
|
Returns:
|
|
str: Path to yt-dlp binary
|
|
"""
|
|
logger.debug("Starting yt-dlp setup dialog")
|
|
dialog = YtdlpSetupDialog(parent_widget)
|
|
|
|
# Store the setup result from the signal
|
|
setup_result = {"path": None}
|
|
|
|
def on_setup_complete(path) -> None:
|
|
logger.debug(f"Received setup_complete signal with path: {path}")
|
|
setup_result["path"] = path
|
|
|
|
# Connect to the setup_complete signal
|
|
dialog.setup_complete.connect(on_setup_complete)
|
|
|
|
# Show the dialog
|
|
result = dialog.exec()
|
|
logger.debug(f"Dialog result: {result} (Accepted={QDialog.DialogCode.Accepted})")
|
|
|
|
if result == QDialog.DialogCode.Accepted:
|
|
# First check if we received a path from the signal
|
|
if setup_result["path"]:
|
|
path_obj = Path(setup_result["path"]) if isinstance(setup_result["path"], str) else setup_result["path"]
|
|
if path_obj.exists():
|
|
logger.debug(f"Using path from signal: {setup_result['path']}")
|
|
return str(setup_result["path"])
|
|
|
|
# Get the expected path for verification as fallback
|
|
expected_path = YTDLP_APP_BIN_PATH
|
|
logger.debug(f"Expected yt-dlp path: {expected_path}")
|
|
|
|
# Verify the path exists after dialog is accepted
|
|
if expected_path.exists():
|
|
logger.debug(f"yt-dlp successfully found at expected path: {expected_path}")
|
|
return str(expected_path)
|
|
else:
|
|
logger.debug(f"Expected path does not exist, trying alternate detection")
|
|
# Try to use the get_yt_dlp_path function to find yt-dlp elsewhere
|
|
yt_dlp_path = get_yt_dlp_path()
|
|
logger.debug(f"Alternate detection result: {yt_dlp_path}")
|
|
if yt_dlp_path != "yt-dlp":
|
|
path_obj = Path(yt_dlp_path) if isinstance(yt_dlp_path, str) else yt_dlp_path
|
|
if path_obj.exists():
|
|
logger.debug(f"yt-dlp found at alternate location: {yt_dlp_path}")
|
|
return str(yt_dlp_path)
|
|
|
|
# Something went wrong, show an error message
|
|
logger.debug(f"Setup failed, showing error dialog")
|
|
if parent_widget:
|
|
error_dialog = QMessageBox(parent_widget)
|
|
error_dialog.setIcon(QMessageBox.Icon.Warning)
|
|
error_dialog.setWindowTitle(_("ytdlp_setup.setup_failed_title"))
|
|
error_dialog.setText(_("ytdlp_setup.setup_failed_message"))
|
|
# Set the window icon to match the parent
|
|
error_dialog.setWindowIcon(parent_widget.windowIcon())
|
|
error_dialog.setStyleSheet(
|
|
"""
|
|
QMessageBox {
|
|
background-color: #15181b;
|
|
color: #ffffff;
|
|
}
|
|
QLabel {
|
|
color: #ffffff;
|
|
}
|
|
QPushButton {
|
|
padding: 8px 15px;
|
|
background-color: #c90000;
|
|
border: none;
|
|
border-radius: 4px;
|
|
color: white;
|
|
font-weight: bold;
|
|
}
|
|
QPushButton:hover {
|
|
background-color: #a50000;
|
|
}
|
|
"""
|
|
)
|
|
error_dialog.exec()
|
|
logger.warning(f"yt-dlp setup failed, path does not exist: {expected_path}")
|
|
else:
|
|
logger.debug("User cancelled the setup dialog")
|
|
|
|
# User cancelled or setup failed, return the fallback command
|
|
logger.debug("Returning fallback command 'yt-dlp'")
|
|
return "yt-dlp"
|
|
|
|
|
|
def check_ytdlp_deno_integration() -> bool:
|
|
"""
|
|
Check if yt-dlp is integrated with Deno by running 'yt-dlp --verbose'.
|
|
Returns:
|
|
bool: True if Deno is detected in JS runtimes, False otherwise
|
|
"""
|
|
try:
|
|
ytdlp_path = get_yt_dlp_path()
|
|
if not ytdlp_path or ytdlp_path == "yt-dlp":
|
|
return False
|
|
|
|
# Run yt-dlp --verbose to check JS runtimes
|
|
# We use a dummy URL or just --verbose with no URL (which might error but should print debug info)
|
|
# However, yt-dlp might not print debug info if no URL is provided and it errors out immediately with "usage".
|
|
# But per user example: "yt-dlp.exe: error: You must provide at least one URL." comes AFTER debug info.
|
|
|
|
result = subprocess.run(
|
|
[str(ytdlp_path), "--verbose"],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=10,
|
|
creationflags=SUBPROCESS_CREATIONFLAGS
|
|
)
|
|
|
|
# Check stderr for "[debug] JS runtimes: deno"
|
|
output = result.stderr
|
|
if "[debug] JS runtimes:" in output and "deno" in output:
|
|
# Find the line
|
|
for line in output.splitlines():
|
|
if "[debug] JS runtimes:" in line and "deno" in line:
|
|
logger.info(f"Deno integration detected: {line.strip()}")
|
|
return True
|
|
|
|
return False
|
|
|
|
except Exception as e:
|
|
logger.warning(f"Failed to check yt-dlp Deno integration: {e}")
|
|
return False
|