mirror of
https://github.com/Yuvi9587/Kemono-Downloader.git
synced 2025-12-17 15:36:51 +00:00
2048 lines
108 KiB
Python
2048 lines
108 KiB
Python
import sys
|
||
import os
|
||
import time
|
||
import requests
|
||
import re
|
||
import threading
|
||
import queue # Standard library queue, not directly used for the new link queue
|
||
import hashlib
|
||
import http.client
|
||
import traceback
|
||
import random # <-- Import random for generating delays
|
||
from collections import deque # <-- Import deque for the link queue
|
||
|
||
from concurrent.futures import ThreadPoolExecutor, CancelledError, Future
|
||
|
||
from PyQt5.QtGui import (
|
||
QIcon,
|
||
QIntValidator
|
||
)
|
||
from PyQt5.QtWidgets import (
|
||
QApplication, QWidget, QLabel, QLineEdit, QTextEdit, QPushButton,
|
||
QVBoxLayout, QHBoxLayout, QFileDialog, QMessageBox, QListWidget,
|
||
QRadioButton, QButtonGroup, QCheckBox, QSplitter, QSizePolicy, QDialog
|
||
)
|
||
# Ensure QTimer is imported
|
||
from PyQt5.QtCore import Qt, QThread, pyqtSignal, QMutex, QMutexLocker, QObject, QTimer
|
||
from urllib.parse import urlparse
|
||
|
||
try:
|
||
from PIL import Image
|
||
except ImportError:
|
||
Image = None
|
||
|
||
from io import BytesIO
|
||
|
||
# --- Import from downloader_utils ---
|
||
try:
|
||
print("Attempting to import from downloader_utils...")
|
||
# Assuming downloader_utils_link_text is the correct version
|
||
from downloader_utils import (
|
||
KNOWN_NAMES,
|
||
clean_folder_name,
|
||
extract_post_info,
|
||
download_from_api,
|
||
PostProcessorSignals,
|
||
PostProcessorWorker,
|
||
DownloadThread as BackendDownloadThread
|
||
)
|
||
print("Successfully imported names from downloader_utils.")
|
||
except ImportError as e:
|
||
print(f"--- IMPORT ERROR ---")
|
||
print(f"Failed to import from 'downloader_utils.py': {e}")
|
||
# ... (rest of error handling as in your original file) ...
|
||
KNOWN_NAMES = []
|
||
PostProcessorSignals = QObject
|
||
PostProcessorWorker = object
|
||
BackendDownloadThread = QThread
|
||
def clean_folder_name(n): return str(n) # Fallback
|
||
def extract_post_info(u): return None, None, None
|
||
def download_from_api(*a, **k): yield []
|
||
except Exception as e:
|
||
print(f"--- UNEXPECTED IMPORT ERROR ---")
|
||
print(f"An unexpected error occurred during import: {e}")
|
||
traceback.print_exc()
|
||
print(f"-----------------------------", file=sys.stderr)
|
||
sys.exit(1)
|
||
# --- End Import ---
|
||
|
||
# --- Import Tour Dialog ---
|
||
try:
|
||
from tour import TourDialog
|
||
print("Successfully imported TourDialog from tour.py.")
|
||
except ImportError as e:
|
||
print(f"--- TOUR IMPORT ERROR ---")
|
||
print(f"Failed to import TourDialog from 'tour.py': {e}")
|
||
print("Tour functionality will be unavailable.")
|
||
TourDialog = None # Fallback if tour.py is missing
|
||
except Exception as e:
|
||
print(f"--- UNEXPECTED TOUR IMPORT ERROR ---")
|
||
print(f"An unexpected error occurred during tour import: {e}")
|
||
traceback.print_exc()
|
||
TourDialog = None
|
||
# --- End Tour Import ---
|
||
|
||
|
||
# --- Constants for Thread Limits ---
|
||
MAX_THREADS = 200 # Absolute maximum allowed by the input validator
|
||
RECOMMENDED_MAX_THREADS = 50 # Threshold for showing the informational warning
|
||
# --- END ---
|
||
|
||
# --- ADDED: Prefix for HTML messages in main log ---
|
||
HTML_PREFIX = "<!HTML!>" # Used to identify HTML lines for insertHtml
|
||
# --- END ADDED ---
|
||
|
||
class DownloaderApp(QWidget):
|
||
character_prompt_response_signal = pyqtSignal(bool)
|
||
log_signal = pyqtSignal(str)
|
||
add_character_prompt_signal = pyqtSignal(str)
|
||
overall_progress_signal = pyqtSignal(int, int)
|
||
finished_signal = pyqtSignal(int, int, bool)
|
||
# Signal now carries link_text (ensure this matches downloader_utils)
|
||
external_link_signal = pyqtSignal(str, str, str, str) # post_title, link_text, link_url, platform
|
||
file_progress_signal = pyqtSignal(str, int, int)
|
||
|
||
|
||
def __init__(self):
|
||
super().__init__()
|
||
self.config_file = "Known.txt"
|
||
self.download_thread = None
|
||
self.thread_pool = None
|
||
self.cancellation_event = threading.Event()
|
||
self.active_futures = []
|
||
self.total_posts_to_process = 0
|
||
self.processed_posts_count = 0
|
||
self.download_counter = 0
|
||
self.skip_counter = 0
|
||
self.worker_signals = PostProcessorSignals() # Instance of signals for multi-thread workers
|
||
self.prompt_mutex = QMutex()
|
||
self._add_character_response = None
|
||
self.downloaded_files = set()
|
||
self.downloaded_files_lock = threading.Lock()
|
||
self.downloaded_file_hashes = set()
|
||
self.downloaded_file_hashes_lock = threading.Lock()
|
||
# self.external_links = [] # This list seems unused now
|
||
self.show_external_links = False
|
||
|
||
# --- For sequential delayed link display ---
|
||
self.external_link_queue = deque()
|
||
self._is_processing_external_link_queue = False
|
||
self._current_link_post_title = None # Track title for grouping
|
||
self.extracted_links_cache = [] # Store all links when in "Only Links" mode
|
||
# --- END ---
|
||
|
||
# --- For Log Verbosity ---
|
||
self.basic_log_mode = False # Start with full log (basic_log_mode is False)
|
||
self.log_verbosity_button = None
|
||
# --- END ---
|
||
|
||
self.main_log_output = None
|
||
self.external_log_output = None
|
||
self.log_splitter = None # This is the VERTICAL splitter for logs
|
||
self.main_splitter = None # This will be the main HORIZONTAL splitter
|
||
self.reset_button = None
|
||
self.progress_log_label = None # To change title
|
||
|
||
# --- For Link Search ---
|
||
self.link_search_input = None
|
||
self.link_search_button = None
|
||
# --- END ---
|
||
|
||
# --- For Export Links ---
|
||
self.export_links_button = None
|
||
# --- END ---
|
||
|
||
self.manga_mode_checkbox = None
|
||
self.radio_only_links = None # Define radio button attribute
|
||
|
||
self.load_known_names_from_util()
|
||
self.setWindowTitle("Kemono Downloader v2.9 (Manga Mode - No Skip Button)")
|
||
self.setGeometry(150, 150, 1050, 820) # Initial size
|
||
self.setStyleSheet(self.get_dark_theme())
|
||
self.init_ui()
|
||
self._connect_signals()
|
||
self.log_signal.emit("ℹ️ Local API server functionality has been removed.")
|
||
self.log_signal.emit("ℹ️ 'Skip Current File' button has been removed.")
|
||
self.character_input.setToolTip("Enter one or more character names, separated by commas (e.g., yor, makima)")
|
||
|
||
|
||
def _connect_signals(self):
|
||
# Signals from the worker_signals object (used by PostProcessorWorker in multi-threaded mode)
|
||
if hasattr(self.worker_signals, 'progress_signal'):
|
||
self.worker_signals.progress_signal.connect(self.handle_main_log)
|
||
if hasattr(self.worker_signals, 'file_progress_signal'):
|
||
self.worker_signals.file_progress_signal.connect(self.update_file_progress_display)
|
||
# Connect the external_link_signal from worker_signals to the queue handler
|
||
if hasattr(self.worker_signals, 'external_link_signal'):
|
||
self.worker_signals.external_link_signal.connect(self.handle_external_link_signal)
|
||
|
||
# App's own signals (some of which might be emitted by DownloadThread which then connects to these handlers)
|
||
self.log_signal.connect(self.handle_main_log)
|
||
self.add_character_prompt_signal.connect(self.prompt_add_character)
|
||
self.character_prompt_response_signal.connect(self.receive_add_character_result)
|
||
self.overall_progress_signal.connect(self.update_progress_display)
|
||
self.finished_signal.connect(self.download_finished)
|
||
# Connect the app's external_link_signal also to the queue handler
|
||
self.external_link_signal.connect(self.handle_external_link_signal)
|
||
self.file_progress_signal.connect(self.update_file_progress_display)
|
||
|
||
|
||
self.character_search_input.textChanged.connect(self.filter_character_list)
|
||
self.external_links_checkbox.toggled.connect(self.update_external_links_setting)
|
||
self.thread_count_input.textChanged.connect(self.update_multithreading_label)
|
||
self.use_subfolder_per_post_checkbox.toggled.connect(self.update_ui_for_subfolders)
|
||
|
||
# --- MODIFIED: Connect multithreading checkbox toggle ---
|
||
self.use_multithreading_checkbox.toggled.connect(self._handle_multithreading_toggle)
|
||
# --- END MODIFIED ---
|
||
|
||
# --- MODIFIED: Connect radio group toggle ---
|
||
if self.radio_group:
|
||
self.radio_group.buttonToggled.connect(self._handle_filter_mode_change) # Use buttonToggled for group signal
|
||
# --- END MODIFIED ---
|
||
|
||
if self.reset_button:
|
||
self.reset_button.clicked.connect(self.reset_application_state)
|
||
|
||
# Connect log verbosity button if it exists
|
||
if self.log_verbosity_button:
|
||
self.log_verbosity_button.clicked.connect(self.toggle_log_verbosity)
|
||
|
||
# --- ADDED: Connect link search elements ---
|
||
if self.link_search_button:
|
||
self.link_search_button.clicked.connect(self._filter_links_log)
|
||
if self.link_search_input:
|
||
self.link_search_input.returnPressed.connect(self._filter_links_log)
|
||
self.link_search_input.textChanged.connect(self._filter_links_log) # Real-time filtering
|
||
# --- END ADDED ---
|
||
|
||
# --- ADDED: Connect export links button ---
|
||
if self.export_links_button:
|
||
self.export_links_button.clicked.connect(self._export_links_to_file)
|
||
# --- END ADDED ---
|
||
|
||
if self.manga_mode_checkbox:
|
||
self.manga_mode_checkbox.toggled.connect(self.update_ui_for_manga_mode)
|
||
self.link_input.textChanged.connect(lambda: self.update_ui_for_manga_mode(self.manga_mode_checkbox.isChecked() if self.manga_mode_checkbox else False))
|
||
|
||
# --- load_known_names_from_util, save_known_names, closeEvent ---
|
||
# These methods remain unchanged from your original file
|
||
|
||
def load_known_names_from_util(self):
|
||
global KNOWN_NAMES
|
||
if os.path.exists(self.config_file):
|
||
try:
|
||
with open(self.config_file, 'r', encoding='utf-8') as f:
|
||
raw_names = [line.strip() for line in f]
|
||
# Filter out empty strings before setting KNOWN_NAMES
|
||
KNOWN_NAMES[:] = sorted(list(set(filter(None, raw_names))))
|
||
log_msg = f"ℹ️ Loaded {len(KNOWN_NAMES)} known names from {self.config_file}"
|
||
except Exception as e:
|
||
log_msg = f"❌ Error loading config '{self.config_file}': {e}"
|
||
QMessageBox.warning(self, "Config Load Error", f"Could not load list from {self.config_file}:\n{e}")
|
||
KNOWN_NAMES[:] = []
|
||
else:
|
||
log_msg = f"ℹ️ Config file '{self.config_file}' not found. Starting empty."
|
||
KNOWN_NAMES[:] = []
|
||
|
||
self.log_signal.emit(log_msg)
|
||
|
||
if hasattr(self, 'character_list'): # Ensure character_list widget exists
|
||
self.character_list.clear()
|
||
self.character_list.addItems(KNOWN_NAMES)
|
||
|
||
|
||
def save_known_names(self):
|
||
global KNOWN_NAMES
|
||
try:
|
||
# Ensure KNOWN_NAMES contains unique, non-empty, sorted strings
|
||
unique_sorted_names = sorted(list(set(filter(None, KNOWN_NAMES))))
|
||
KNOWN_NAMES[:] = unique_sorted_names # Update global list in place
|
||
|
||
with open(self.config_file, 'w', encoding='utf-8') as f:
|
||
for name in unique_sorted_names:
|
||
f.write(name + '\n')
|
||
self.log_signal.emit(f"💾 Saved {len(unique_sorted_names)} known names to {self.config_file}")
|
||
except Exception as e:
|
||
log_msg = f"❌ Error saving config '{self.config_file}': {e}"
|
||
self.log_signal.emit(log_msg)
|
||
QMessageBox.warning(self, "Config Save Error", f"Could not save list to {self.config_file}:\n{e}")
|
||
|
||
def closeEvent(self, event):
|
||
self.save_known_names()
|
||
should_exit = True
|
||
is_downloading = (self.download_thread and self.download_thread.isRunning()) or \
|
||
(self.thread_pool is not None and any(not f.done() for f in self.active_futures if f is not None))
|
||
|
||
|
||
if is_downloading:
|
||
reply = QMessageBox.question(self, "Confirm Exit",
|
||
"Download in progress. Are you sure you want to exit and cancel?",
|
||
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
|
||
if reply == QMessageBox.Yes:
|
||
self.log_signal.emit("⚠️ Cancelling active download due to application exit...")
|
||
self.cancel_download() # Signal cancellation
|
||
# --- MODIFICATION START: Wait for threads to finish ---
|
||
self.log_signal.emit(" Waiting briefly for threads to acknowledge cancellation...")
|
||
# Wait for the single thread if it exists
|
||
if self.download_thread and self.download_thread.isRunning():
|
||
self.download_thread.wait(3000) # Wait up to 3 seconds
|
||
if self.download_thread.isRunning():
|
||
self.log_signal.emit(" ⚠️ Single download thread did not terminate gracefully.")
|
||
# Wait for the thread pool if it exists
|
||
if self.thread_pool:
|
||
# Shutdown was already initiated by cancel_download, just wait here
|
||
# Use wait=True here for cleaner exit
|
||
self.thread_pool.shutdown(wait=True, cancel_futures=True)
|
||
self.log_signal.emit(" Thread pool shutdown complete.")
|
||
self.thread_pool = None # Clear reference
|
||
# --- MODIFICATION END ---
|
||
else:
|
||
should_exit = False
|
||
self.log_signal.emit("ℹ️ Application exit cancelled.")
|
||
event.ignore()
|
||
return
|
||
|
||
if should_exit:
|
||
self.log_signal.emit("ℹ️ Application closing.")
|
||
# Ensure thread pool is None if already shut down above
|
||
if self.thread_pool:
|
||
self.log_signal.emit(" Final thread pool check: Shutting down...")
|
||
self.cancellation_event.set()
|
||
self.thread_pool.shutdown(wait=True, cancel_futures=True)
|
||
self.thread_pool = None
|
||
self.log_signal.emit("👋 Exiting application.")
|
||
event.accept()
|
||
|
||
def init_ui(self):
|
||
# --- MODIFIED: Use QSplitter for main layout ---
|
||
self.main_splitter = QSplitter(Qt.Horizontal)
|
||
|
||
# Create container widgets for left and right panels
|
||
left_panel_widget = QWidget()
|
||
right_panel_widget = QWidget()
|
||
|
||
# Setup layouts for the panels
|
||
left_layout = QVBoxLayout(left_panel_widget) # Apply layout to widget
|
||
right_layout = QVBoxLayout(right_panel_widget) # Apply layout to widget
|
||
left_layout.setContentsMargins(10, 10, 10, 10) # Add some margins
|
||
right_layout.setContentsMargins(10, 10, 10, 10)
|
||
|
||
# --- Populate Left Panel (Controls) ---
|
||
# (All the QLineEdit, QCheckBox, QPushButton, etc. setup code goes here, adding to left_layout)
|
||
# URL and Page Range Input
|
||
url_page_layout = QHBoxLayout()
|
||
url_page_layout.setContentsMargins(0,0,0,0)
|
||
url_page_layout.addWidget(QLabel("🔗 Kemono Creator/Post URL:"))
|
||
self.link_input = QLineEdit()
|
||
self.link_input.setPlaceholderText("e.g., https://kemono.su/patreon/user/12345 or .../post/98765")
|
||
self.link_input.textChanged.connect(self.update_custom_folder_visibility)
|
||
# self.link_input.setFixedWidth(int(self.width() * 0.45)) # Remove fixed width for splitter
|
||
url_page_layout.addWidget(self.link_input, 1) # Give it stretch factor
|
||
|
||
self.page_range_label = QLabel("Page Range:")
|
||
self.page_range_label.setStyleSheet("font-weight: bold; padding-left: 10px;")
|
||
self.start_page_input = QLineEdit()
|
||
self.start_page_input.setPlaceholderText("Start")
|
||
self.start_page_input.setFixedWidth(50)
|
||
self.start_page_input.setValidator(QIntValidator(1, 99999)) # Min 1
|
||
self.to_label = QLabel("to")
|
||
self.end_page_input = QLineEdit()
|
||
self.end_page_input.setPlaceholderText("End")
|
||
self.end_page_input.setFixedWidth(50)
|
||
self.end_page_input.setValidator(QIntValidator(1, 99999)) # Min 1
|
||
url_page_layout.addWidget(self.page_range_label)
|
||
url_page_layout.addWidget(self.start_page_input)
|
||
url_page_layout.addWidget(self.to_label)
|
||
url_page_layout.addWidget(self.end_page_input)
|
||
# url_page_layout.addStretch(1) # No need for stretch with splitter
|
||
left_layout.addLayout(url_page_layout)
|
||
|
||
# Download Directory Input
|
||
left_layout.addWidget(QLabel("📁 Download Location:"))
|
||
self.dir_input = QLineEdit()
|
||
self.dir_input.setPlaceholderText("Select folder where downloads will be saved")
|
||
self.dir_button = QPushButton("Browse...")
|
||
self.dir_button.clicked.connect(self.browse_directory)
|
||
dir_layout = QHBoxLayout()
|
||
dir_layout.addWidget(self.dir_input, 1) # Input takes more space
|
||
dir_layout.addWidget(self.dir_button)
|
||
left_layout.addLayout(dir_layout)
|
||
|
||
# Custom Folder Name (for single post)
|
||
self.custom_folder_widget = QWidget() # Use a widget to hide/show group
|
||
custom_folder_layout = QVBoxLayout(self.custom_folder_widget)
|
||
custom_folder_layout.setContentsMargins(0, 5, 0, 0) # No top margin if hidden
|
||
self.custom_folder_label = QLabel("🗄️ Custom Folder Name (Single Post Only):")
|
||
self.custom_folder_input = QLineEdit()
|
||
self.custom_folder_input.setPlaceholderText("Optional: Save this post to specific folder")
|
||
custom_folder_layout.addWidget(self.custom_folder_label)
|
||
custom_folder_layout.addWidget(self.custom_folder_input)
|
||
self.custom_folder_widget.setVisible(False) # Initially hidden
|
||
left_layout.addWidget(self.custom_folder_widget)
|
||
|
||
# Character Filter Input
|
||
self.character_filter_widget = QWidget()
|
||
character_filter_layout = QVBoxLayout(self.character_filter_widget)
|
||
character_filter_layout.setContentsMargins(0,5,0,0)
|
||
self.character_label = QLabel("🎯 Filter by Character(s) (comma-separated):")
|
||
self.character_input = QLineEdit()
|
||
self.character_input.setPlaceholderText("e.g., yor, Tifa, Reyna")
|
||
character_filter_layout.addWidget(self.character_label)
|
||
character_filter_layout.addWidget(self.character_input)
|
||
self.character_filter_widget.setVisible(True) # Visible by default
|
||
left_layout.addWidget(self.character_filter_widget)
|
||
|
||
# Skip Words Input
|
||
left_layout.addWidget(QLabel("🚫 Skip Posts/Files with Words (comma-separated):"))
|
||
self.skip_words_input = QLineEdit()
|
||
self.skip_words_input.setPlaceholderText("e.g., WM, WIP, sketch, preview")
|
||
left_layout.addWidget(self.skip_words_input)
|
||
|
||
# --- MODIFIED: File Type Filter Radio Buttons ---
|
||
file_filter_layout = QVBoxLayout() # Group label and radio buttons
|
||
file_filter_layout.setContentsMargins(0,0,0,0) # Compact
|
||
file_filter_layout.addWidget(QLabel("Filter Files:"))
|
||
radio_button_layout = QHBoxLayout()
|
||
radio_button_layout.setSpacing(10)
|
||
self.radio_group = QButtonGroup(self) # Ensures one selection
|
||
self.radio_all = QRadioButton("All")
|
||
self.radio_images = QRadioButton("Images/GIFs")
|
||
self.radio_videos = QRadioButton("Videos")
|
||
self.radio_only_links = QRadioButton("🔗 Only Links") # New button
|
||
self.radio_all.setChecked(True)
|
||
self.radio_group.addButton(self.radio_all)
|
||
self.radio_group.addButton(self.radio_images)
|
||
self.radio_group.addButton(self.radio_videos)
|
||
self.radio_group.addButton(self.radio_only_links) # Add to group
|
||
radio_button_layout.addWidget(self.radio_all)
|
||
radio_button_layout.addWidget(self.radio_images)
|
||
radio_button_layout.addWidget(self.radio_videos)
|
||
radio_button_layout.addWidget(self.radio_only_links) # Add to layout
|
||
radio_button_layout.addStretch(1) # Pushes buttons to left
|
||
file_filter_layout.addLayout(radio_button_layout)
|
||
left_layout.addLayout(file_filter_layout)
|
||
# --- END MODIFIED ---
|
||
|
||
# Checkboxes Group
|
||
checkboxes_group_layout = QVBoxLayout()
|
||
checkboxes_group_layout.setSpacing(10) # Spacing between rows of checkboxes
|
||
|
||
row1_layout = QHBoxLayout() # First row of checkboxes
|
||
row1_layout.setSpacing(10)
|
||
self.skip_zip_checkbox = QCheckBox("Skip .zip")
|
||
self.skip_zip_checkbox.setChecked(True)
|
||
row1_layout.addWidget(self.skip_zip_checkbox)
|
||
self.skip_rar_checkbox = QCheckBox("Skip .rar")
|
||
self.skip_rar_checkbox.setChecked(True)
|
||
row1_layout.addWidget(self.skip_rar_checkbox)
|
||
self.download_thumbnails_checkbox = QCheckBox("Download Thumbnails Only")
|
||
self.download_thumbnails_checkbox.setChecked(False)
|
||
self.download_thumbnails_checkbox.setToolTip("Thumbnail download functionality is currently limited without the API.")
|
||
row1_layout.addWidget(self.download_thumbnails_checkbox)
|
||
self.compress_images_checkbox = QCheckBox("Compress Large Images (to WebP)")
|
||
self.compress_images_checkbox.setChecked(False)
|
||
self.compress_images_checkbox.setToolTip("Compress images > 1.5MB to WebP format (requires Pillow).")
|
||
row1_layout.addWidget(self.compress_images_checkbox)
|
||
row1_layout.addStretch(1) # Pushes checkboxes to left
|
||
checkboxes_group_layout.addLayout(row1_layout)
|
||
|
||
# Advanced Settings Section
|
||
advanced_settings_label = QLabel("⚙️ Advanced Settings:")
|
||
checkboxes_group_layout.addWidget(advanced_settings_label)
|
||
|
||
advanced_row1_layout = QHBoxLayout() # Subfolders options
|
||
advanced_row1_layout.setSpacing(10)
|
||
self.use_subfolders_checkbox = QCheckBox("Separate Folders by Name/Title")
|
||
self.use_subfolders_checkbox.setChecked(True)
|
||
self.use_subfolders_checkbox.toggled.connect(self.update_ui_for_subfolders)
|
||
advanced_row1_layout.addWidget(self.use_subfolders_checkbox)
|
||
self.use_subfolder_per_post_checkbox = QCheckBox("Subfolder per Post")
|
||
self.use_subfolder_per_post_checkbox.setChecked(False)
|
||
self.use_subfolder_per_post_checkbox.setToolTip("Creates a subfolder for each post inside the character/title folder.")
|
||
self.use_subfolder_per_post_checkbox.toggled.connect(self.update_ui_for_subfolders) # Also update UI
|
||
advanced_row1_layout.addWidget(self.use_subfolder_per_post_checkbox)
|
||
advanced_row1_layout.addStretch(1)
|
||
checkboxes_group_layout.addLayout(advanced_row1_layout)
|
||
|
||
advanced_row2_layout = QHBoxLayout() # Multithreading, External Links, Manga Mode
|
||
advanced_row2_layout.setSpacing(10)
|
||
multithreading_layout = QHBoxLayout() # Group multithreading checkbox and input
|
||
multithreading_layout.setContentsMargins(0,0,0,0)
|
||
self.use_multithreading_checkbox = QCheckBox("Use Multithreading")
|
||
self.use_multithreading_checkbox.setChecked(True)
|
||
self.use_multithreading_checkbox.setToolTip("Speeds up downloads for full creator pages.\nSingle post URLs always use one thread.")
|
||
multithreading_layout.addWidget(self.use_multithreading_checkbox)
|
||
self.thread_count_label = QLabel("Threads:")
|
||
multithreading_layout.addWidget(self.thread_count_label)
|
||
self.thread_count_input = QLineEdit()
|
||
self.thread_count_input.setFixedWidth(40)
|
||
self.thread_count_input.setText("4")
|
||
# --- MODIFIED: Updated tooltip to remove recommendation ---
|
||
self.thread_count_input.setToolTip(f"Number of threads (max: {MAX_THREADS}).")
|
||
# --- END MODIFIED ---
|
||
self.thread_count_input.setValidator(QIntValidator(1, MAX_THREADS)) # Use constant
|
||
multithreading_layout.addWidget(self.thread_count_input)
|
||
advanced_row2_layout.addLayout(multithreading_layout)
|
||
|
||
self.external_links_checkbox = QCheckBox("Show External Links in Log")
|
||
self.external_links_checkbox.setChecked(False)
|
||
advanced_row2_layout.addWidget(self.external_links_checkbox)
|
||
|
||
self.manga_mode_checkbox = QCheckBox("Manga/Comic Mode")
|
||
self.manga_mode_checkbox.setToolTip("Process newest posts first, rename files based on post title (for creator feeds only).")
|
||
self.manga_mode_checkbox.setChecked(False)
|
||
advanced_row2_layout.addWidget(self.manga_mode_checkbox)
|
||
advanced_row2_layout.addStretch(1)
|
||
checkboxes_group_layout.addLayout(advanced_row2_layout)
|
||
|
||
left_layout.addLayout(checkboxes_group_layout)
|
||
|
||
# Download and Cancel Buttons
|
||
btn_layout = QHBoxLayout()
|
||
btn_layout.setSpacing(10)
|
||
self.download_btn = QPushButton("⬇️ Start Download")
|
||
self.download_btn.setStyleSheet("padding: 8px 15px; font-weight: bold;") # Make it prominent
|
||
self.download_btn.clicked.connect(self.start_download)
|
||
self.cancel_btn = QPushButton("❌ Cancel")
|
||
self.cancel_btn.setEnabled(False) # Initially disabled
|
||
self.cancel_btn.clicked.connect(self.cancel_download)
|
||
btn_layout.addWidget(self.download_btn)
|
||
btn_layout.addWidget(self.cancel_btn)
|
||
left_layout.addLayout(btn_layout)
|
||
left_layout.addSpacing(10) # Some space before known characters list
|
||
|
||
# Known Characters/Shows List Management
|
||
known_chars_label_layout = QHBoxLayout()
|
||
known_chars_label_layout.setSpacing(10)
|
||
self.known_chars_label = QLabel("🎭 Known Shows/Characters (for Folder Names):")
|
||
self.character_search_input = QLineEdit()
|
||
self.character_search_input.setPlaceholderText("Search characters...")
|
||
known_chars_label_layout.addWidget(self.known_chars_label, 1) # Label takes more space
|
||
known_chars_label_layout.addWidget(self.character_search_input)
|
||
left_layout.addLayout(known_chars_label_layout)
|
||
|
||
self.character_list = QListWidget()
|
||
self.character_list.setSelectionMode(QListWidget.ExtendedSelection) # Allow multi-select for delete
|
||
left_layout.addWidget(self.character_list, 1) # Takes remaining vertical space
|
||
|
||
char_manage_layout = QHBoxLayout() # Add/Delete character buttons
|
||
char_manage_layout.setSpacing(10)
|
||
self.new_char_input = QLineEdit()
|
||
self.new_char_input.setPlaceholderText("Add new show/character name")
|
||
self.add_char_button = QPushButton("➕ Add")
|
||
self.delete_char_button = QPushButton("🗑️ Delete Selected")
|
||
self.add_char_button.clicked.connect(self.add_new_character)
|
||
self.new_char_input.returnPressed.connect(self.add_char_button.click) # Add on Enter
|
||
self.delete_char_button.clicked.connect(self.delete_selected_character)
|
||
char_manage_layout.addWidget(self.new_char_input, 2) # Input field wider
|
||
char_manage_layout.addWidget(self.add_char_button, 1)
|
||
char_manage_layout.addWidget(self.delete_char_button, 1)
|
||
left_layout.addLayout(char_manage_layout)
|
||
left_layout.addStretch(0) # Prevent vertical stretching of controls
|
||
|
||
# --- Populate Right Panel (Logs) ---
|
||
log_title_layout = QHBoxLayout()
|
||
self.progress_log_label = QLabel("📜 Progress Log:") # Store label reference
|
||
log_title_layout.addWidget(self.progress_log_label)
|
||
log_title_layout.addStretch(1)
|
||
|
||
# --- ADDED: Link Search Bar ---
|
||
self.link_search_input = QLineEdit()
|
||
self.link_search_input.setPlaceholderText("Search Links...")
|
||
self.link_search_input.setVisible(False) # Initially hidden
|
||
self.link_search_input.setFixedWidth(150) # Adjust width
|
||
log_title_layout.addWidget(self.link_search_input)
|
||
|
||
self.link_search_button = QPushButton("🔍")
|
||
self.link_search_button.setToolTip("Filter displayed links")
|
||
self.link_search_button.setVisible(False) # Initially hidden
|
||
self.link_search_button.setFixedWidth(30)
|
||
self.link_search_button.setStyleSheet("padding: 4px 4px;")
|
||
log_title_layout.addWidget(self.link_search_button)
|
||
# --- END ADDED ---
|
||
|
||
# --- ADDED: Log Verbosity Button ---
|
||
self.log_verbosity_button = QPushButton("Show Basic Log") # Default text
|
||
self.log_verbosity_button.setToolTip("Toggle between full and basic log details.")
|
||
self.log_verbosity_button.setFixedWidth(110) # Adjust width as needed
|
||
self.log_verbosity_button.setStyleSheet("padding: 4px 8px;")
|
||
log_title_layout.addWidget(self.log_verbosity_button)
|
||
# --- END ADDED ---
|
||
|
||
self.reset_button = QPushButton("🔄 Reset")
|
||
self.reset_button.setToolTip("Reset all inputs and logs to default state (only when idle).")
|
||
self.reset_button.setFixedWidth(80)
|
||
self.reset_button.setStyleSheet("padding: 4px 8px;") # Smaller padding
|
||
log_title_layout.addWidget(self.reset_button)
|
||
right_layout.addLayout(log_title_layout)
|
||
|
||
self.log_splitter = QSplitter(Qt.Vertical) # Keep the vertical splitter for logs
|
||
self.main_log_output = QTextEdit()
|
||
self.main_log_output.setReadOnly(True)
|
||
# self.main_log_output.setMinimumWidth(450) # Remove minimum width
|
||
self.main_log_output.setLineWrapMode(QTextEdit.NoWrap) # Disable line wrapping
|
||
self.main_log_output.setStyleSheet("""
|
||
QTextEdit {
|
||
background-color: #3C3F41; border: 1px solid #5A5A5A; padding: 5px;
|
||
color: #F0F0F0; border-radius: 4px; font-family: Consolas, Courier New, monospace; font-size: 9.5pt;
|
||
}""")
|
||
self.external_log_output = QTextEdit()
|
||
self.external_log_output.setReadOnly(True)
|
||
# self.external_log_output.setMinimumWidth(450) # Remove minimum width
|
||
self.external_log_output.setLineWrapMode(QTextEdit.NoWrap) # Disable line wrapping
|
||
self.external_log_output.setStyleSheet("""
|
||
QTextEdit {
|
||
background-color: #3C3F41; border: 1px solid #5A5A5A; padding: 5px;
|
||
color: #F0F0F0; border-radius: 4px; font-family: Consolas, Courier New, monospace; font-size: 9.5pt;
|
||
}""")
|
||
self.external_log_output.hide() # Initially hidden
|
||
self.log_splitter.addWidget(self.main_log_output)
|
||
self.log_splitter.addWidget(self.external_log_output)
|
||
self.log_splitter.setSizes([self.height(), 0]) # Main log takes all space initially
|
||
right_layout.addWidget(self.log_splitter, 1) # Log splitter takes available vertical space
|
||
|
||
# --- ADDED: Export Links Button ---
|
||
export_button_layout = QHBoxLayout()
|
||
export_button_layout.addStretch(1) # Push button to the right
|
||
self.export_links_button = QPushButton("Export Links")
|
||
self.export_links_button.setToolTip("Export all extracted links to a .txt file.")
|
||
self.export_links_button.setFixedWidth(100)
|
||
self.export_links_button.setStyleSheet("padding: 4px 8px; margin-top: 5px;")
|
||
self.export_links_button.setEnabled(False) # Initially disabled
|
||
self.export_links_button.setVisible(False) # Initially hidden
|
||
export_button_layout.addWidget(self.export_links_button)
|
||
right_layout.addLayout(export_button_layout) # Add to bottom of right panel
|
||
# --- END ADDED ---
|
||
|
||
self.progress_label = QLabel("Progress: Idle")
|
||
self.progress_label.setStyleSheet("padding-top: 5px; font-style: italic;")
|
||
right_layout.addWidget(self.progress_label)
|
||
|
||
self.file_progress_label = QLabel("") # For individual file progress
|
||
self.file_progress_label.setWordWrap(True) # Enable word wrapping for the status label
|
||
self.file_progress_label.setStyleSheet("padding-top: 2px; font-style: italic; color: #A0A0A0;")
|
||
right_layout.addWidget(self.file_progress_label)
|
||
|
||
# --- Add panels to the main horizontal splitter ---
|
||
self.main_splitter.addWidget(left_panel_widget)
|
||
self.main_splitter.addWidget(right_panel_widget)
|
||
|
||
# --- Set initial sizes for the splitter ---
|
||
# Calculate initial sizes (e.g., left 30%, right 70%)
|
||
initial_width = self.width() # Use the initial window width
|
||
left_width = int(initial_width * 0.30)
|
||
right_width = initial_width - left_width
|
||
self.main_splitter.setSizes([left_width, right_width])
|
||
|
||
# --- Set the main splitter as the central layout ---
|
||
# Need a top-level layout to hold the splitter
|
||
top_level_layout = QHBoxLayout(self) # Apply layout directly to the main widget (self)
|
||
top_level_layout.setContentsMargins(0,0,0,0) # No margins for the main layout
|
||
top_level_layout.addWidget(self.main_splitter)
|
||
# self.setLayout(top_level_layout) # Already set above
|
||
|
||
# --- End Layout Modification ---
|
||
|
||
# Initial UI state updates
|
||
self.update_ui_for_subfolders(self.use_subfolders_checkbox.isChecked())
|
||
self.update_custom_folder_visibility()
|
||
self.update_external_links_setting(self.external_links_checkbox.isChecked())
|
||
self.update_multithreading_label(self.thread_count_input.text())
|
||
self.update_page_range_enabled_state()
|
||
if self.manga_mode_checkbox: # Ensure it exists before accessing
|
||
self.update_ui_for_manga_mode(self.manga_mode_checkbox.isChecked())
|
||
self.link_input.textChanged.connect(self.update_page_range_enabled_state) # Connect after init
|
||
self.load_known_names_from_util() # Load names into the list widget
|
||
self._handle_multithreading_toggle(self.use_multithreading_checkbox.isChecked()) # Set initial state
|
||
self._handle_filter_mode_change(self.radio_group.checkedButton(), True) # Set initial filter mode UI state
|
||
|
||
|
||
def get_dark_theme(self):
|
||
return """
|
||
QWidget { background-color: #2E2E2E; color: #E0E0E0; font-family: Segoe UI, Arial, sans-serif; font-size: 10pt; }
|
||
QLineEdit, QListWidget { background-color: #3C3F41; border: 1px solid #5A5A5A; padding: 5px; color: #F0F0F0; border-radius: 4px; }
|
||
QTextEdit { background-color: #3C3F41; border: 1px solid #5A5A5A; padding: 5px; color: #F0F0F0; border-radius: 4px; }
|
||
QPushButton { background-color: #555; color: #F0F0F0; border: 1px solid #6A6A6A; padding: 6px 12px; border-radius: 4px; min-height: 22px; }
|
||
QPushButton:hover { background-color: #656565; border: 1px solid #7A7A7A; }
|
||
QPushButton:pressed { background-color: #4A4A4A; }
|
||
QPushButton:disabled { background-color: #404040; color: #888; border-color: #555; }
|
||
QLabel { font-weight: bold; padding-top: 4px; padding-bottom: 2px; color: #C0C0C0; }
|
||
QRadioButton, QCheckBox { spacing: 5px; color: #E0E0E0; padding-top: 4px; padding-bottom: 4px; }
|
||
QRadioButton::indicator, QCheckBox::indicator { width: 14px; height: 14px; }
|
||
QListWidget { alternate-background-color: #353535; border: 1px solid #5A5A5A; }
|
||
QListWidget::item:selected { background-color: #007ACC; color: #FFFFFF; }
|
||
QToolTip { background-color: #4A4A4A; color: #F0F0F0; border: 1px solid #6A6A6A; padding: 4px; border-radius: 3px; }
|
||
QSplitter::handle { background-color: #5A5A5A; width: 5px; /* Make handle slightly wider */ }
|
||
QSplitter::handle:horizontal { width: 5px; }
|
||
QSplitter::handle:vertical { height: 5px; }
|
||
""" # Added styling for splitter handle
|
||
|
||
def browse_directory(self):
|
||
current_dir = self.dir_input.text() if os.path.isdir(self.dir_input.text()) else ""
|
||
folder = QFileDialog.getExistingDirectory(self, "Select Download Folder", current_dir)
|
||
if folder:
|
||
self.dir_input.setText(folder)
|
||
|
||
def handle_main_log(self, message):
|
||
# --- MODIFIED: Check for HTML_PREFIX ---
|
||
is_html_message = message.startswith(HTML_PREFIX)
|
||
|
||
if is_html_message:
|
||
# If it's HTML, strip the prefix and use insertHtml
|
||
display_message = message[len(HTML_PREFIX):]
|
||
use_html = True
|
||
elif self.basic_log_mode: # Apply basic filtering only if NOT HTML
|
||
# Define keywords/prefixes for messages to ALWAYS show in basic mode
|
||
basic_keywords = [
|
||
'🚀 starting download', '🏁 download finished', '🏁 download cancelled',
|
||
'❌', '⚠️', '✅ all posts processed', '✅ reached end of posts',
|
||
'summary:', 'progress:', '[fetcher]', # Show fetcher logs for context
|
||
'critical error', 'import error', 'error', 'fail', 'timeout',
|
||
'unsupported url', 'invalid url', 'no posts found', 'could not create directory',
|
||
'missing dependency', 'high thread count', 'manga mode filter warning',
|
||
'duplicate name', 'potential name conflict', 'invalid filter name',
|
||
'no valid character filters'
|
||
]
|
||
message_lower = message.lower()
|
||
if not any(keyword in message_lower for keyword in basic_keywords):
|
||
if not message.strip().startswith("✅ Saved:") and \
|
||
not message.strip().startswith("✅ Added") and \
|
||
not message.strip().startswith("✅ Application reset complete"):
|
||
return # Skip appending less important messages in basic mode
|
||
display_message = message # Use original message if it passes basic filter
|
||
use_html = False
|
||
else: # Full log mode and not HTML
|
||
display_message = message
|
||
use_html = False
|
||
# --- END MODIFIED ---
|
||
|
||
try:
|
||
# Ensure message is a string and replace null characters that can crash QTextEdit
|
||
safe_message = str(display_message).replace('\x00', '[NULL]')
|
||
if use_html:
|
||
self.main_log_output.insertHtml(safe_message) # Use insertHtml for formatted titles
|
||
else:
|
||
self.main_log_output.append(safe_message) # Use append for plain text
|
||
# Auto-scroll if near the bottom
|
||
scrollbar = self.main_log_output.verticalScrollBar()
|
||
if scrollbar.value() >= scrollbar.maximum() - 30: # Threshold for auto-scroll
|
||
scrollbar.setValue(scrollbar.maximum())
|
||
except Exception as e:
|
||
# Fallback logging if GUI logging fails
|
||
print(f"GUI Main Log Error: {e}\nOriginal Message: {message}")
|
||
|
||
# --- ADDED: Helper to check download state ---
|
||
def _is_download_active(self):
|
||
"""Checks if a download thread or pool is currently active."""
|
||
single_thread_active = self.download_thread and self.download_thread.isRunning()
|
||
# Check if pool exists AND has any futures that are not done
|
||
pool_active = self.thread_pool is not None and any(not f.done() for f in self.active_futures if f is not None)
|
||
return single_thread_active or pool_active
|
||
# --- END ADDED ---
|
||
|
||
# --- ADDED: New system for handling external links with sequential CONDIITONAL delay ---
|
||
# MODIFIED: Slot now takes link_text as the second argument
|
||
def handle_external_link_signal(self, post_title, link_text, link_url, platform):
|
||
"""Receives link signals, adds them to a queue, and triggers processing."""
|
||
link_data = (post_title, link_text, link_url, platform)
|
||
self.external_link_queue.append(link_data)
|
||
# --- ADDED: Cache link if in "Only Links" mode ---
|
||
if self.radio_only_links and self.radio_only_links.isChecked():
|
||
self.extracted_links_cache.append(link_data)
|
||
# --- END ADDED ---
|
||
self._try_process_next_external_link()
|
||
|
||
def _try_process_next_external_link(self):
|
||
"""Processes the next link from the queue if not already processing."""
|
||
if self._is_processing_external_link_queue or not self.external_link_queue:
|
||
return # Don't process if busy or queue empty
|
||
|
||
# Determine if we should display based on mode and checkbox state
|
||
is_only_links_mode = self.radio_only_links and self.radio_only_links.isChecked()
|
||
should_display_in_external = self.show_external_links and not is_only_links_mode
|
||
|
||
# Only proceed if displaying in *either* log is currently possible/enabled
|
||
if not (is_only_links_mode or should_display_in_external):
|
||
# If neither log is active/visible for this link, still need to allow queue processing
|
||
self._is_processing_external_link_queue = False
|
||
if self.external_link_queue:
|
||
QTimer.singleShot(0, self._try_process_next_external_link)
|
||
return
|
||
|
||
self._is_processing_external_link_queue = True
|
||
|
||
link_data = self.external_link_queue.popleft()
|
||
|
||
# --- MODIFIED: Schedule the display AND the next step based on mode ---
|
||
if is_only_links_mode:
|
||
# Schedule with fixed 0.4s delay for "Only Links" mode
|
||
delay_ms = 80 # 0.08 seconds
|
||
QTimer.singleShot(delay_ms, lambda data=link_data: self._display_and_schedule_next(data))
|
||
elif self._is_download_active():
|
||
# Schedule with random delay for other modes during download
|
||
delay_ms = random.randint(4000, 8000)
|
||
QTimer.singleShot(delay_ms, lambda data=link_data: self._display_and_schedule_next(data))
|
||
else:
|
||
# No download active in other modes, process immediately
|
||
QTimer.singleShot(0, lambda data=link_data: self._display_and_schedule_next(data))
|
||
# --- END MODIFIED ---
|
||
|
||
# --- NEW Method ---
|
||
def _display_and_schedule_next(self, link_data):
|
||
"""Displays the link in the correct log and schedules the check for the next link."""
|
||
post_title, link_text, link_url, platform = link_data # Unpack all data
|
||
is_only_links_mode = self.radio_only_links and self.radio_only_links.isChecked()
|
||
|
||
# Format the link text part
|
||
max_link_text_len = 35
|
||
display_text = link_text[:max_link_text_len].strip() + "..." if len(link_text) > max_link_text_len else link_text
|
||
formatted_link_info = f"{display_text} - {link_url} - {platform}"
|
||
separator = "-" * 45
|
||
|
||
if is_only_links_mode:
|
||
# Check if the post title has changed
|
||
if post_title != self._current_link_post_title:
|
||
# Emit separator and new title (formatted as HTML)
|
||
self.log_signal.emit(HTML_PREFIX + "<br>" + separator + "<br>")
|
||
# Use HTML for bold blue title
|
||
title_html = f'<b style="color: #87CEEB;">{post_title}</b><br>'
|
||
self.log_signal.emit(HTML_PREFIX + title_html)
|
||
self._current_link_post_title = post_title # Update current title
|
||
|
||
# Emit the link info as plain text (handle_main_log will append it)
|
||
self.log_signal.emit(formatted_link_info)
|
||
|
||
elif self.show_external_links:
|
||
# Append directly to external log (plain text)
|
||
self._append_to_external_log(formatted_link_info, separator)
|
||
|
||
# Allow the next link to be processed
|
||
self._is_processing_external_link_queue = False
|
||
self._try_process_next_external_link() # Check queue again
|
||
# --- END NEW Method ---
|
||
|
||
# --- RENAMED and MODIFIED: Appends ONLY to external log ---
|
||
def _append_to_external_log(self, formatted_link_text, separator):
|
||
"""Appends a single formatted link to the external_log_output widget."""
|
||
# Visibility check is done before calling this now
|
||
if not (self.external_log_output and self.external_log_output.isVisible()):
|
||
return
|
||
|
||
try:
|
||
self.external_log_output.append(separator)
|
||
self.external_log_output.append(formatted_link_text)
|
||
self.external_log_output.append("") # Add a blank line for spacing
|
||
|
||
# Auto-scroll
|
||
scrollbar = self.external_log_output.verticalScrollBar()
|
||
if scrollbar.value() >= scrollbar.maximum() - 50: # Adjust threshold if needed
|
||
scrollbar.setValue(scrollbar.maximum())
|
||
except Exception as e:
|
||
# Log errors related to external log to the main log
|
||
self.log_signal.emit(f"GUI External Log Append Error: {e}\nOriginal Message: {formatted_link_text}")
|
||
print(f"GUI External Log Error (Append): {e}\nOriginal Message: {formatted_link_text}")
|
||
# --- END MODIFIED ---
|
||
|
||
|
||
def update_file_progress_display(self, filename, downloaded_bytes, total_bytes):
|
||
if not filename and total_bytes == 0 and downloaded_bytes == 0: # Clear signal
|
||
self.file_progress_label.setText("")
|
||
return
|
||
|
||
# MODIFIED: Truncate filename more aggressively (e.g., max 25 chars)
|
||
max_filename_len = 25
|
||
display_filename = filename[:max_filename_len-3].strip() + "..." if len(filename) > max_filename_len else filename
|
||
|
||
if total_bytes > 0:
|
||
downloaded_mb = downloaded_bytes / (1024 * 1024)
|
||
total_mb = total_bytes / (1024 * 1024)
|
||
progress_text = f"Downloading '{display_filename}' ({downloaded_mb:.1f}MB / {total_mb:.1f}MB)"
|
||
else: # If total size is unknown
|
||
downloaded_mb = downloaded_bytes / (1024 * 1024)
|
||
progress_text = f"Downloading '{display_filename}' ({downloaded_mb:.1f}MB)"
|
||
|
||
# Check if the resulting text might still be too long (heuristic)
|
||
# This is a basic check, might need refinement based on typical log width
|
||
if len(progress_text) > 75: # Example threshold, adjust as needed
|
||
# If still too long, truncate the display_filename even more
|
||
display_filename = filename[:15].strip() + "..." if len(filename) > 18 else display_filename
|
||
if total_bytes > 0:
|
||
progress_text = f"DL '{display_filename}' ({downloaded_mb:.1f}/{total_mb:.1f}MB)"
|
||
else:
|
||
progress_text = f"DL '{display_filename}' ({downloaded_mb:.1f}MB)"
|
||
|
||
self.file_progress_label.setText(progress_text)
|
||
|
||
|
||
def update_external_links_setting(self, checked):
|
||
# This function is now primarily controlled by _handle_filter_mode_change
|
||
# when the "Only Links" mode is NOT selected.
|
||
is_only_links_mode = self.radio_only_links and self.radio_only_links.isChecked()
|
||
if is_only_links_mode:
|
||
# In "Only Links" mode, the external log is always hidden.
|
||
if self.external_log_output: self.external_log_output.hide()
|
||
if self.log_splitter: self.log_splitter.setSizes([self.height(), 0])
|
||
return
|
||
|
||
# Proceed only if NOT in "Only Links" mode
|
||
self.show_external_links = checked
|
||
if checked:
|
||
if self.external_log_output: self.external_log_output.show()
|
||
# Adjust splitter, give both logs some space
|
||
if self.log_splitter: self.log_splitter.setSizes([self.height() // 2, self.height() // 2])
|
||
if self.main_log_output: self.main_log_output.setMinimumHeight(50) # Ensure it doesn't disappear
|
||
if self.external_log_output: self.external_log_output.setMinimumHeight(50)
|
||
self.log_signal.emit("\n" + "="*40 + "\n🔗 External Links Log Enabled\n" + "="*40)
|
||
if self.external_log_output:
|
||
self.external_log_output.clear() # Clear previous content
|
||
self.external_log_output.append("🔗 External Links Found:") # Header
|
||
# Try processing queue if log becomes visible
|
||
self._try_process_next_external_link()
|
||
else:
|
||
if self.external_log_output: self.external_log_output.hide()
|
||
# Adjust splitter
|
||
if self.log_splitter: self.log_splitter.setSizes([self.height(), 0]) # Main log takes all space
|
||
if self.main_log_output: self.main_log_output.setMinimumHeight(0) # Reset min height
|
||
if self.external_log_output: self.external_log_output.setMinimumHeight(0)
|
||
if self.external_log_output: self.external_log_output.clear() # Clear content when hidden
|
||
self.log_signal.emit("\n" + "="*40 + "\n🔗 External Links Log Disabled\n" + "="*40)
|
||
|
||
# --- ADDED: Handler for filter mode radio buttons ---
|
||
def _handle_filter_mode_change(self, button, checked):
|
||
# button can be None during initial setup sometimes
|
||
if not button or not checked:
|
||
return
|
||
|
||
filter_mode_text = button.text()
|
||
is_only_links = (filter_mode_text == "🔗 Only Links")
|
||
|
||
# --- MODIFIED: Enable/disable widgets based on mode ---
|
||
file_options_enabled = not is_only_links
|
||
widgets_to_disable_in_links_mode = [
|
||
self.dir_input, self.dir_button, # Download Location
|
||
self.skip_zip_checkbox, self.skip_rar_checkbox,
|
||
self.download_thumbnails_checkbox, self.compress_images_checkbox,
|
||
self.use_subfolders_checkbox, self.use_subfolder_per_post_checkbox,
|
||
self.character_filter_widget, # Includes label and input
|
||
self.skip_words_input,
|
||
self.custom_folder_widget # Includes label and input
|
||
]
|
||
# --- END MODIFIED ---
|
||
for widget in widgets_to_disable_in_links_mode:
|
||
if widget: widget.setEnabled(file_options_enabled)
|
||
|
||
# --- ADDED: Show/hide link search bar and export button ---
|
||
if self.link_search_input: self.link_search_input.setVisible(is_only_links)
|
||
if self.link_search_button: self.link_search_button.setVisible(is_only_links)
|
||
if self.export_links_button:
|
||
self.export_links_button.setVisible(is_only_links)
|
||
self.export_links_button.setEnabled(is_only_links and bool(self.extracted_links_cache)) # Enable if cache has items
|
||
if not is_only_links and self.link_search_input: self.link_search_input.clear() # Clear search when hiding
|
||
# --- END ADDED ---
|
||
|
||
# Specific handling for "Only Links" mode vs others
|
||
if is_only_links:
|
||
self.progress_log_label.setText("📜 Extracted Links Log:") # Change title
|
||
# Ensure external log is hidden and main log takes full vertical space
|
||
if self.external_log_output: self.external_log_output.hide()
|
||
if self.log_splitter: self.log_splitter.setSizes([self.height(), 0])
|
||
if self.main_log_output: self.main_log_output.setMinimumHeight(0)
|
||
if self.external_log_output: self.external_log_output.setMinimumHeight(0)
|
||
# Clear logs for the new mode
|
||
if self.main_log_output: self.main_log_output.clear()
|
||
if self.external_log_output: self.external_log_output.clear()
|
||
# External links checkbox is irrelevant in this mode, keep it enabled but ignored
|
||
if self.external_links_checkbox: self.external_links_checkbox.setEnabled(True)
|
||
self.log_signal.emit("="*20 + " Mode changed to: Only Links " + "="*20)
|
||
# Start processing links immediately for the main log display
|
||
self._filter_links_log() # Display initially filtered (all) links
|
||
self._try_process_next_external_link() # Start paced display
|
||
|
||
else: # Other modes (All, Images, Videos)
|
||
self.progress_log_label.setText("📜 Progress Log:") # Restore title
|
||
if self.external_links_checkbox:
|
||
self.external_links_checkbox.setEnabled(True) # Ensure checkbox is enabled
|
||
# Restore log visibility based on checkbox state
|
||
self.update_external_links_setting(self.external_links_checkbox.isChecked())
|
||
# Re-enable potentially disabled subfolder options if needed
|
||
self.update_ui_for_subfolders(self.use_subfolders_checkbox.isChecked())
|
||
self.log_signal.emit(f"="*20 + f" Mode changed to: {filter_mode_text} " + "="*20)
|
||
|
||
# --- END ADDED ---
|
||
|
||
# --- ADDED: Method to filter links in "Only Links" mode ---
|
||
def _filter_links_log(self):
|
||
"""Filters and displays links from the cache in the main log."""
|
||
if not (self.radio_only_links and self.radio_only_links.isChecked()):
|
||
return # Only filter when in "Only Links" mode
|
||
|
||
search_term = self.link_search_input.text().lower().strip()
|
||
self.main_log_output.clear() # Clear current display
|
||
|
||
current_title_for_display = None # Track title for grouping in this filtered view
|
||
separator = "-" * 45
|
||
|
||
for post_title, link_text, link_url, platform in self.extracted_links_cache:
|
||
# Check if the search term matches any part of the link info
|
||
matches_search = (
|
||
not search_term or
|
||
search_term in link_text.lower() or
|
||
search_term in link_url.lower() or
|
||
search_term in platform.lower()
|
||
)
|
||
|
||
if matches_search:
|
||
# Check if the post title has changed
|
||
if post_title != current_title_for_display:
|
||
# Append separator and new title (formatted as HTML)
|
||
self.main_log_output.insertHtml("<br>" + separator + "<br>")
|
||
title_html = f'<b style="color: #87CEEB;">{post_title}</b><br>'
|
||
self.main_log_output.insertHtml(title_html)
|
||
current_title_for_display = post_title # Update current title
|
||
|
||
# Format and append the link info as plain text
|
||
max_link_text_len = 35
|
||
display_text = link_text[:max_link_text_len].strip() + "..." if len(link_text) > max_link_text_len else link_text
|
||
formatted_link_info = f"{display_text} - {link_url} - {platform}"
|
||
self.main_log_output.append(formatted_link_info)
|
||
|
||
# Add a final blank line if any links were displayed
|
||
if self.main_log_output.toPlainText().strip():
|
||
self.main_log_output.append("")
|
||
|
||
# Scroll to top after filtering
|
||
self.main_log_output.verticalScrollBar().setValue(0)
|
||
# --- END ADDED ---
|
||
|
||
# --- ADDED: Method to export links ---
|
||
def _export_links_to_file(self):
|
||
if not (self.radio_only_links and self.radio_only_links.isChecked()):
|
||
QMessageBox.information(self, "Export Links", "Link export is only available in 'Only Links' mode.")
|
||
return
|
||
if not self.extracted_links_cache:
|
||
QMessageBox.information(self, "Export Links", "No links have been extracted yet.")
|
||
return
|
||
|
||
default_filename = "extracted_links.txt"
|
||
filepath, _ = QFileDialog.getSaveFileName(self, "Save Links", default_filename, "Text Files (*.txt);;All Files (*)")
|
||
|
||
if filepath:
|
||
try:
|
||
with open(filepath, 'w', encoding='utf-8') as f:
|
||
current_title_for_export = None
|
||
separator = "-" * 60 + "\n" # For file output
|
||
|
||
for post_title, link_text, link_url, platform in self.extracted_links_cache:
|
||
if post_title != current_title_for_export:
|
||
if current_title_for_export is not None: # Add separator before new title, except for the first one
|
||
f.write("\n" + separator + "\n")
|
||
f.write(f"Post Title: {post_title}\n\n")
|
||
current_title_for_export = post_title
|
||
|
||
f.write(f" {link_text} - {link_url} - {platform}\n")
|
||
|
||
self.log_signal.emit(f"✅ Links successfully exported to: {filepath}")
|
||
QMessageBox.information(self, "Export Successful", f"Links exported to:\n{filepath}")
|
||
except Exception as e:
|
||
self.log_signal.emit(f"❌ Error exporting links: {e}")
|
||
QMessageBox.critical(self, "Export Error", f"Could not export links: {e}")
|
||
# --- END ADDED ---
|
||
|
||
|
||
def get_filter_mode(self):
|
||
# This method returns the simplified filter mode string for the backend
|
||
if self.radio_only_links and self.radio_only_links.isChecked():
|
||
# When "Only Links" is checked, the backend doesn't filter by file type,
|
||
# but it does need a 'filter_mode'. 'all' is a safe default.
|
||
# The actual link extraction is controlled by the 'extract_links_only' flag.
|
||
return 'all'
|
||
elif self.radio_images.isChecked(): return 'image'
|
||
elif self.radio_videos.isChecked(): return 'video'
|
||
return 'all' # Default for "All" radio or if somehow no radio is checked.
|
||
|
||
def add_new_character(self):
|
||
global KNOWN_NAMES, clean_folder_name # Ensure clean_folder_name is accessible
|
||
name_to_add = self.new_char_input.text().strip()
|
||
if not name_to_add:
|
||
QMessageBox.warning(self, "Input Error", "Name cannot be empty.")
|
||
return False # Indicate failure
|
||
|
||
name_lower = name_to_add.lower()
|
||
|
||
# 1. Exact Duplicate Check (case-insensitive)
|
||
is_exact_duplicate = any(existing.lower() == name_lower for existing in KNOWN_NAMES)
|
||
if is_exact_duplicate:
|
||
QMessageBox.warning(self, "Duplicate Name", f"The name '{name_to_add}' (case-insensitive) already exists.")
|
||
return False
|
||
|
||
# 2. Similarity Check (substring, case-insensitive)
|
||
similar_names_details = [] # Store tuples of (new_name, existing_name)
|
||
for existing_name in KNOWN_NAMES:
|
||
existing_name_lower = existing_name.lower()
|
||
# Avoid self-comparison if somehow name_lower was already in a different case
|
||
if name_lower != existing_name_lower:
|
||
if name_lower in existing_name_lower or existing_name_lower in name_lower:
|
||
similar_names_details.append((name_to_add, existing_name))
|
||
|
||
if similar_names_details:
|
||
first_similar_new, first_similar_existing = similar_names_details[0]
|
||
|
||
# Determine shorter and longer for the example message
|
||
shorter_name_for_msg, longer_name_for_msg = sorted(
|
||
[first_similar_new, first_similar_existing], key=len
|
||
)
|
||
|
||
msg_box = QMessageBox(self)
|
||
msg_box.setIcon(QMessageBox.Warning)
|
||
msg_box.setWindowTitle("Potential Name Conflict")
|
||
msg_box.setText(
|
||
f"The name '{first_similar_new}' is very similar to an existing name: '{first_similar_existing}'.\n\n"
|
||
f"For example, if a post title primarily matches the shorter name ('{shorter_name_for_msg}'), "
|
||
f"files might be saved under a folder for '{clean_folder_name(shorter_name_for_msg)}', "
|
||
f"even if the longer name ('{longer_name_for_msg}') was also relevant or intended for a more specific folder.\n"
|
||
"This could lead to files being grouped into less specific or overly broad folders than desired.\n\n"
|
||
"Do you want to change the name you are adding, or proceed anyway?"
|
||
)
|
||
change_button = msg_box.addButton("Change Name", QMessageBox.RejectRole)
|
||
proceed_button = msg_box.addButton("Proceed Anyway", QMessageBox.AcceptRole)
|
||
msg_box.setDefaultButton(proceed_button) # Default to proceed
|
||
msg_box.setEscapeButton(change_button) # Escape cancels/rejects
|
||
|
||
msg_box.exec_()
|
||
|
||
if msg_box.clickedButton() == change_button:
|
||
self.log_signal.emit(f"ℹ️ User chose to change the name '{first_similar_new}' due to similarity with '{first_similar_existing}'.")
|
||
return False # Don't add, user will change input and click "Add" again
|
||
# If proceed_button is clicked (or dialog is closed and proceed is default)
|
||
self.log_signal.emit(f"⚠️ User chose to proceed with adding '{first_similar_new}' despite similarity with '{first_similar_existing}'.")
|
||
# Fall through to add the name
|
||
|
||
# If no exact duplicate, and (no similar names OR user chose to proceed with similar name)
|
||
KNOWN_NAMES.append(name_to_add)
|
||
KNOWN_NAMES.sort(key=str.lower) # Keep the list sorted (case-insensitive for sorting)
|
||
self.character_list.clear()
|
||
self.character_list.addItems(KNOWN_NAMES)
|
||
self.filter_character_list(self.character_search_input.text()) # Re-apply filter
|
||
self.log_signal.emit(f"✅ Added '{name_to_add}' to known names list.")
|
||
self.new_char_input.clear()
|
||
self.save_known_names() # Save to file
|
||
return True # Indicate success
|
||
|
||
|
||
def delete_selected_character(self):
|
||
global KNOWN_NAMES
|
||
selected_items = self.character_list.selectedItems()
|
||
if not selected_items:
|
||
QMessageBox.warning(self, "Selection Error", "Please select one or more names to delete.")
|
||
return
|
||
|
||
names_to_remove = {item.text() for item in selected_items}
|
||
confirm = QMessageBox.question(self, "Confirm Deletion",
|
||
f"Are you sure you want to delete {len(names_to_remove)} name(s)?",
|
||
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
|
||
|
||
if confirm == QMessageBox.Yes:
|
||
original_count = len(KNOWN_NAMES)
|
||
# Filter out names to remove
|
||
KNOWN_NAMES = [n for n in KNOWN_NAMES if n not in names_to_remove]
|
||
removed_count = original_count - len(KNOWN_NAMES)
|
||
|
||
if removed_count > 0:
|
||
self.log_signal.emit(f"🗑️ Removed {removed_count} name(s).")
|
||
self.character_list.clear() # Update UI
|
||
self.character_list.addItems(KNOWN_NAMES)
|
||
self.filter_character_list(self.character_search_input.text()) # Re-apply filter
|
||
self.save_known_names() # Save changes
|
||
else:
|
||
self.log_signal.emit("ℹ️ No names were removed (they might not have been in the list or already deleted).")
|
||
|
||
|
||
def update_custom_folder_visibility(self, url_text=None):
|
||
if url_text is None: url_text = self.link_input.text() # Get current text if not passed
|
||
_, _, post_id = extract_post_info(url_text.strip())
|
||
# Show if it's a post URL AND subfolders are generally enabled
|
||
should_show = bool(post_id) and self.use_subfolders_checkbox.isChecked()
|
||
# --- MODIFIED: Also hide if in "Only Links" mode ---
|
||
is_only_links = self.radio_only_links and self.radio_only_links.isChecked()
|
||
self.custom_folder_widget.setVisible(should_show and not is_only_links)
|
||
# --- END MODIFIED ---
|
||
if not self.custom_folder_widget.isVisible(): self.custom_folder_input.clear() # Clear if hidden
|
||
|
||
def update_ui_for_subfolders(self, checked):
|
||
# Character filter input visibility depends on subfolder usage
|
||
is_only_links = self.radio_only_links and self.radio_only_links.isChecked()
|
||
self.character_filter_widget.setVisible(checked and not is_only_links) # Hide if only links
|
||
if not checked: self.character_input.clear() # Clear filter if hiding
|
||
|
||
self.update_custom_folder_visibility() # Custom folder also depends on this
|
||
|
||
# "Subfolder per Post" is only enabled if "Separate Folders" is also checked
|
||
self.use_subfolder_per_post_checkbox.setEnabled(checked and not is_only_links) # Disable if only links
|
||
if not checked or is_only_links: self.use_subfolder_per_post_checkbox.setChecked(False) # Uncheck if parent is disabled or only links
|
||
|
||
def update_page_range_enabled_state(self):
|
||
url_text = self.link_input.text().strip()
|
||
service, user_id, post_id = extract_post_info(url_text)
|
||
# Page range is for creator feeds (no post_id)
|
||
is_creator_feed = service is not None and user_id is not None and post_id is None
|
||
|
||
manga_mode_active = self.manga_mode_checkbox.isChecked() if self.manga_mode_checkbox else False
|
||
# Enable page range if it's a creator feed AND manga mode is NOT active
|
||
enable_page_range = is_creator_feed and not manga_mode_active
|
||
|
||
for widget in [self.page_range_label, self.start_page_input, self.to_label, self.end_page_input]:
|
||
if widget: widget.setEnabled(enable_page_range)
|
||
if not enable_page_range: # Clear inputs if disabled
|
||
self.start_page_input.clear()
|
||
self.end_page_input.clear()
|
||
|
||
def update_ui_for_manga_mode(self, checked):
|
||
url_text = self.link_input.text().strip()
|
||
_, _, post_id = extract_post_info(url_text)
|
||
is_creator_feed = not post_id if url_text else False # Manga mode only for creator feeds
|
||
|
||
if self.manga_mode_checkbox: # Ensure checkbox exists
|
||
self.manga_mode_checkbox.setEnabled(is_creator_feed) # Only enable for creator feeds
|
||
if not is_creator_feed and self.manga_mode_checkbox.isChecked():
|
||
self.manga_mode_checkbox.setChecked(False) # Uncheck if URL changes to non-creator feed
|
||
|
||
# If manga mode is active (checked and enabled), disable page range
|
||
if is_creator_feed and self.manga_mode_checkbox and self.manga_mode_checkbox.isChecked():
|
||
self.page_range_label.setEnabled(False)
|
||
self.start_page_input.setEnabled(False); self.start_page_input.clear()
|
||
self.to_label.setEnabled(False)
|
||
self.end_page_input.setEnabled(False); self.end_page_input.clear()
|
||
else: # Otherwise, let update_page_range_enabled_state handle it
|
||
self.update_page_range_enabled_state()
|
||
|
||
|
||
def filter_character_list(self, search_text):
|
||
search_text_lower = search_text.lower()
|
||
for i in range(self.character_list.count()):
|
||
item = self.character_list.item(i)
|
||
item.setHidden(search_text_lower not in item.text().lower())
|
||
|
||
def update_multithreading_label(self, text):
|
||
# This method only updates the checkbox label text
|
||
# The actual enabling/disabling is handled by _handle_multithreading_toggle
|
||
if self.use_multithreading_checkbox.isChecked():
|
||
try:
|
||
num_threads = int(text)
|
||
if num_threads > 0 :
|
||
self.use_multithreading_checkbox.setText(f"Use Multithreading ({num_threads} Threads)")
|
||
else:
|
||
self.use_multithreading_checkbox.setText("Use Multithreading (Invalid: >0)")
|
||
except ValueError:
|
||
self.use_multithreading_checkbox.setText("Use Multithreading (Invalid Input)")
|
||
else:
|
||
self.use_multithreading_checkbox.setText("Use Multithreading (1 Thread)") # Show 1 thread when disabled
|
||
|
||
# --- ADDED: Handler for multithreading checkbox toggle ---
|
||
def _handle_multithreading_toggle(self, checked):
|
||
"""Handles enabling/disabling the thread count input."""
|
||
if not checked:
|
||
# Unchecked: Set to 1 and disable
|
||
self.thread_count_input.setText("1")
|
||
self.thread_count_input.setEnabled(False)
|
||
self.thread_count_label.setEnabled(False)
|
||
self.use_multithreading_checkbox.setText("Use Multithreading (1 Thread)")
|
||
else:
|
||
# Checked: Enable and update label based on current value
|
||
self.thread_count_input.setEnabled(True)
|
||
self.thread_count_label.setEnabled(True)
|
||
self.update_multithreading_label(self.thread_count_input.text())
|
||
# --- END ADDED ---
|
||
|
||
|
||
def update_progress_display(self, total_posts, processed_posts):
|
||
if total_posts > 0:
|
||
progress_percent = (processed_posts / total_posts) * 100
|
||
self.progress_label.setText(f"Progress: {processed_posts} / {total_posts} posts ({progress_percent:.1f}%)")
|
||
elif processed_posts > 0 : # If total_posts is unknown (e.g., single post)
|
||
self.progress_label.setText(f"Progress: Processing post {processed_posts}...")
|
||
else: # Initial state or no posts
|
||
self.progress_label.setText("Progress: Starting...")
|
||
|
||
if total_posts > 0 or processed_posts > 0 : self.file_progress_label.setText("") # Clear file progress
|
||
|
||
|
||
def start_download(self):
|
||
global KNOWN_NAMES, BackendDownloadThread, PostProcessorWorker, extract_post_info, clean_folder_name
|
||
|
||
if (self.download_thread and self.download_thread.isRunning()) or self.thread_pool:
|
||
QMessageBox.warning(self, "Busy", "A download is already running.")
|
||
return
|
||
|
||
api_url = self.link_input.text().strip()
|
||
output_dir = self.dir_input.text().strip()
|
||
skip_zip = self.skip_zip_checkbox.isChecked()
|
||
skip_rar = self.skip_rar_checkbox.isChecked()
|
||
use_subfolders = self.use_subfolders_checkbox.isChecked()
|
||
use_post_subfolders = self.use_subfolder_per_post_checkbox.isChecked() and use_subfolders
|
||
compress_images = self.compress_images_checkbox.isChecked()
|
||
download_thumbnails = self.download_thumbnails_checkbox.isChecked()
|
||
use_multithreading = self.use_multithreading_checkbox.isChecked()
|
||
raw_skip_words = self.skip_words_input.text().strip()
|
||
skip_words_list = [word.strip().lower() for word in raw_skip_words.split(',') if word.strip()]
|
||
|
||
manga_mode_is_checked = self.manga_mode_checkbox.isChecked() if self.manga_mode_checkbox else False
|
||
|
||
extract_links_only = (self.radio_only_links and self.radio_only_links.isChecked())
|
||
|
||
# --- MODIFICATION FOR FILTER MODE ---
|
||
# Get the simplified filter mode for the backend (e.g., 'image', 'video', 'all')
|
||
backend_filter_mode = self.get_filter_mode()
|
||
# Get the user-facing text of the selected radio button for logging purposes
|
||
user_selected_filter_text = self.radio_group.checkedButton().text() if self.radio_group.checkedButton() else "All"
|
||
# --- END MODIFICATION FOR FILTER MODE ---
|
||
|
||
|
||
if not api_url:
|
||
QMessageBox.critical(self, "Input Error", "URL is required."); return
|
||
if not extract_links_only and not output_dir:
|
||
QMessageBox.critical(self, "Input Error", "Download Directory is required when not in 'Only Links' mode."); return
|
||
|
||
service, user_id, post_id_from_url = extract_post_info(api_url)
|
||
if not service or not user_id:
|
||
QMessageBox.critical(self, "Input Error", "Invalid or unsupported URL format."); return
|
||
|
||
if not extract_links_only and not os.path.isdir(output_dir):
|
||
reply = QMessageBox.question(self, "Create Directory?",
|
||
f"The directory '{output_dir}' does not exist.\nCreate it now?",
|
||
QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
|
||
if reply == QMessageBox.Yes:
|
||
try:
|
||
os.makedirs(output_dir, exist_ok=True)
|
||
self.log_signal.emit(f"ℹ️ Created directory: {output_dir}")
|
||
except Exception as e:
|
||
QMessageBox.critical(self, "Directory Error", f"Could not create directory: {e}"); return
|
||
else:
|
||
self.log_signal.emit("❌ Download cancelled: Output directory does not exist and was not created.")
|
||
return
|
||
|
||
if compress_images and Image is None:
|
||
QMessageBox.warning(self, "Missing Dependency", "Pillow library (for image compression) not found. Compression will be disabled.")
|
||
compress_images = False
|
||
self.compress_images_checkbox.setChecked(False)
|
||
|
||
manga_mode = manga_mode_is_checked and not post_id_from_url
|
||
|
||
num_threads_str = self.thread_count_input.text().strip()
|
||
num_threads = 1
|
||
if use_multithreading:
|
||
try:
|
||
num_threads_requested = int(num_threads_str)
|
||
if num_threads_requested > MAX_THREADS:
|
||
warning_message = (
|
||
f"You have requested {num_threads_requested} threads, which is above the maximum limit of {MAX_THREADS}.\n\n"
|
||
f"High thread counts can lead to instability or rate-limiting.\n\n"
|
||
f"The thread count will be automatically capped at {MAX_THREADS} for this download."
|
||
)
|
||
QMessageBox.warning(self, "High Thread Count Warning", warning_message)
|
||
self.log_signal.emit(f"⚠️ High thread count requested ({num_threads_requested}). Capping at {MAX_THREADS}.")
|
||
num_threads = MAX_THREADS
|
||
self.thread_count_input.setText(str(num_threads))
|
||
elif num_threads_requested > RECOMMENDED_MAX_THREADS:
|
||
QMessageBox.information(self, "High Thread Count Note",
|
||
f"Using {num_threads_requested} threads (above {RECOMMENDED_MAX_THREADS}) may increase resource usage and risk rate-limiting from the site.\n\nProceeding with caution.")
|
||
self.log_signal.emit(f"ℹ️ Using high thread count: {num_threads_requested}.")
|
||
num_threads = num_threads_requested
|
||
elif num_threads_requested < 1:
|
||
self.log_signal.emit(f"⚠️ Invalid thread count ({num_threads_requested}). Using 1 thread.")
|
||
num_threads = 1
|
||
self.thread_count_input.setText(str(num_threads))
|
||
else:
|
||
num_threads = num_threads_requested
|
||
except ValueError:
|
||
QMessageBox.critical(self, "Thread Count Error", "Invalid number of threads. Please enter a numeric value."); return
|
||
else:
|
||
num_threads = 1
|
||
|
||
|
||
start_page_str, end_page_str = self.start_page_input.text().strip(), self.end_page_input.text().strip()
|
||
start_page, end_page = None, None
|
||
is_creator_feed = bool(not post_id_from_url)
|
||
|
||
if is_creator_feed and not manga_mode:
|
||
try:
|
||
if start_page_str: start_page = int(start_page_str)
|
||
if end_page_str: end_page = int(end_page_str)
|
||
if start_page is not None and start_page <= 0: raise ValueError("Start page must be positive.")
|
||
if end_page is not None and end_page <= 0: raise ValueError("End page must be positive.")
|
||
if start_page and end_page and start_page > end_page:
|
||
raise ValueError("Start page cannot be greater than end page.")
|
||
except ValueError as e:
|
||
QMessageBox.critical(self, "Page Range Error", f"Invalid page range: {e}"); return
|
||
elif manga_mode:
|
||
start_page, end_page = None, None
|
||
|
||
self.external_link_queue.clear()
|
||
self.extracted_links_cache = []
|
||
self._is_processing_external_link_queue = False
|
||
self._current_link_post_title = None
|
||
|
||
|
||
raw_character_filters_text = self.character_input.text().strip()
|
||
parsed_character_list = None
|
||
if raw_character_filters_text:
|
||
temp_list = [name.strip() for name in raw_character_filters_text.split(',') if name.strip()]
|
||
if temp_list: parsed_character_list = temp_list
|
||
|
||
filter_character_list_to_pass = None
|
||
if use_subfolders and parsed_character_list and not post_id_from_url and not extract_links_only:
|
||
self.log_signal.emit(f"ℹ️ Validating character filters for subfolder naming: {', '.join(parsed_character_list)}")
|
||
valid_filters_for_backend = []
|
||
user_cancelled_validation = False
|
||
for char_name in parsed_character_list:
|
||
cleaned_name_test = clean_folder_name(char_name)
|
||
if not cleaned_name_test:
|
||
QMessageBox.warning(self, "Invalid Filter Name", f"Filter name '{char_name}' is invalid for a folder and will be skipped.")
|
||
self.log_signal.emit(f"⚠️ Skipping invalid filter for folder: '{char_name}'")
|
||
continue
|
||
|
||
if char_name.lower() not in {kn.lower() for kn in KNOWN_NAMES}:
|
||
reply = QMessageBox.question(self, "Add Filter Name to Known List?",
|
||
f"The character filter '{char_name}' is not in your known names list (used for folder suggestions).\nAdd it now?",
|
||
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel, QMessageBox.Yes)
|
||
if reply == QMessageBox.Yes:
|
||
self.new_char_input.setText(char_name)
|
||
if self.add_new_character():
|
||
self.log_signal.emit(f"✅ Added '{char_name}' to known names via filter prompt.")
|
||
valid_filters_for_backend.append(char_name)
|
||
else:
|
||
self.log_signal.emit(f"⚠️ Failed to add '{char_name}' via filter prompt (or user opted out). It will still be used for filtering this session if valid.")
|
||
if cleaned_name_test: valid_filters_for_backend.append(char_name)
|
||
elif reply == QMessageBox.Cancel:
|
||
self.log_signal.emit(f"❌ Download cancelled by user during filter validation for '{char_name}'.")
|
||
user_cancelled_validation = True; break
|
||
else:
|
||
self.log_signal.emit(f"ℹ️ Proceeding with filter '{char_name}' for matching without adding to known list.")
|
||
if cleaned_name_test: valid_filters_for_backend.append(char_name)
|
||
else:
|
||
if cleaned_name_test: valid_filters_for_backend.append(char_name)
|
||
|
||
if user_cancelled_validation: return
|
||
|
||
if valid_filters_for_backend:
|
||
filter_character_list_to_pass = valid_filters_for_backend
|
||
self.log_signal.emit(f" Using validated character filters for subfolders: {', '.join(filter_character_list_to_pass)}")
|
||
else:
|
||
self.log_signal.emit("⚠️ No valid character filters remaining after validation for subfolder naming.")
|
||
elif parsed_character_list :
|
||
filter_character_list_to_pass = parsed_character_list
|
||
self.log_signal.emit(f"ℹ️ Character filters provided: {', '.join(filter_character_list_to_pass)} (Subfolder creation rules may differ).")
|
||
|
||
if manga_mode and not filter_character_list_to_pass and not extract_links_only:
|
||
msg_box = QMessageBox(self)
|
||
msg_box.setIcon(QMessageBox.Warning)
|
||
msg_box.setWindowTitle("Manga Mode Filter Warning")
|
||
msg_box.setText(
|
||
"Manga Mode is enabled, but the 'Filter by Character(s)' field is empty.\n\n"
|
||
"For best results (correct file naming and grouping), please enter the exact Manga/Series title "
|
||
"(as used by the creator on the site) into the filter field.\n\n"
|
||
"Do you want to proceed without a filter (file names might be generic) or cancel?"
|
||
)
|
||
proceed_button = msg_box.addButton("Proceed Anyway", QMessageBox.AcceptRole)
|
||
cancel_button = msg_box.addButton("Cancel Download", QMessageBox.RejectRole)
|
||
|
||
msg_box.exec_()
|
||
|
||
if msg_box.clickedButton() == cancel_button:
|
||
self.log_signal.emit("❌ Download cancelled by user due to Manga Mode filter warning.")
|
||
return
|
||
else:
|
||
self.log_signal.emit("⚠️ Proceeding with Manga Mode without a specific title filter.")
|
||
|
||
|
||
custom_folder_name_cleaned = None
|
||
if use_subfolders and post_id_from_url and self.custom_folder_widget.isVisible() and not extract_links_only:
|
||
raw_custom_name = self.custom_folder_input.text().strip()
|
||
if raw_custom_name:
|
||
cleaned_custom = clean_folder_name(raw_custom_name)
|
||
if cleaned_custom: custom_folder_name_cleaned = cleaned_custom
|
||
else: self.log_signal.emit(f"⚠️ Invalid custom folder name ignored: '{raw_custom_name}'")
|
||
|
||
self.main_log_output.clear()
|
||
if extract_links_only:
|
||
self.main_log_output.append("🔗 Extracting Links...")
|
||
if self.external_log_output: self.external_log_output.clear()
|
||
elif self.show_external_links:
|
||
self.external_log_output.clear()
|
||
self.external_log_output.append("🔗 External Links Found:")
|
||
self.file_progress_label.setText("")
|
||
self.cancellation_event.clear()
|
||
self.active_futures = []
|
||
self.total_posts_to_process = self.processed_posts_count = self.download_counter = self.skip_counter = 0
|
||
self.progress_label.setText("Progress: Initializing...")
|
||
|
||
log_messages = [
|
||
"="*40, f"🚀 Starting {'Link Extraction' if extract_links_only else 'Download'} @ {time.strftime('%Y-%m-%d %H:%M:%S')}",
|
||
f" URL: {api_url}",
|
||
]
|
||
if not extract_links_only:
|
||
log_messages.append(f" Save Location: {output_dir}")
|
||
|
||
log_messages.append(f" Mode: {'Single Post' if post_id_from_url else 'Creator Feed'}")
|
||
|
||
if is_creator_feed:
|
||
if manga_mode:
|
||
log_messages.append(" Page Range: All (Manga Mode - Oldest Posts Processed First)")
|
||
else:
|
||
pr_log = "All"
|
||
if start_page or end_page:
|
||
pr_log = f"{f'From {start_page} ' if start_page else ''}{'to ' if start_page and end_page else ''}{f'{end_page}' if end_page else (f'Up to {end_page}' if end_page else (f'From {start_page}' if start_page else 'Specific Range'))}".strip()
|
||
log_messages.append(f" Page Range: {pr_log if pr_log else 'All'}")
|
||
|
||
if not extract_links_only:
|
||
log_messages.append(f" Subfolders: {'Enabled' if use_subfolders else 'Disabled'}")
|
||
if use_subfolders:
|
||
if custom_folder_name_cleaned: log_messages.append(f" Custom Folder (Post): '{custom_folder_name_cleaned}'")
|
||
elif filter_character_list_to_pass and not post_id_from_url: log_messages.append(f" Character Filters for Folders: {', '.join(filter_character_list_to_pass)}")
|
||
else: log_messages.append(f" Folder Naming: Automatic (based on title/known names)")
|
||
log_messages.append(f" Subfolder per Post: {'Enabled' if use_post_subfolders else 'Disabled'}")
|
||
|
||
log_messages.extend([
|
||
# --- MODIFIED LOGGING FOR FILTER MODE ---
|
||
f" File Type Filter: {user_selected_filter_text} (Backend processing as: {backend_filter_mode})",
|
||
# --- END MODIFIED LOGGING ---
|
||
f" Skip Archives: {'.zip' if skip_zip else ''}{', ' if skip_zip and skip_rar else ''}{'.rar' if skip_rar else ''}{'None' if not (skip_zip or skip_rar) else ''}",
|
||
f" Skip Words (posts/files): {', '.join(skip_words_list) if skip_words_list else 'None'}",
|
||
f" Compress Images: {'Enabled' if compress_images else 'Disabled'}",
|
||
f" Thumbnails Only: {'Enabled' if download_thumbnails else 'Disabled'}",
|
||
])
|
||
else:
|
||
log_messages.append(f" Mode: Extracting Links Only") # This handles the "Only Links" case
|
||
|
||
log_messages.append(f" Show External Links: {'Enabled' if self.show_external_links else 'Disabled'}")
|
||
if manga_mode: log_messages.append(f" Manga Mode (File Renaming by Post Title): Enabled")
|
||
|
||
should_use_multithreading = use_multithreading and not post_id_from_url
|
||
log_messages.append(f" Threading: {'Multi-threaded (posts)' if should_use_multithreading else 'Single-threaded (posts)'}")
|
||
if should_use_multithreading: log_messages.append(f" Number of Post Worker Threads: {num_threads}")
|
||
log_messages.append("="*40)
|
||
for msg in log_messages: self.log_signal.emit(msg)
|
||
|
||
self.set_ui_enabled(False)
|
||
|
||
unwanted_keywords_for_folders = {'spicy', 'hd', 'nsfw', '4k', 'preview', 'teaser', 'clip'}
|
||
|
||
args_template = {
|
||
'api_url_input': api_url,
|
||
'download_root': output_dir,
|
||
'output_dir': output_dir,
|
||
'known_names': list(KNOWN_NAMES),
|
||
'known_names_copy': list(KNOWN_NAMES),
|
||
'filter_character_list': filter_character_list_to_pass,
|
||
# --- MODIFIED: Pass the correct backend_filter_mode ---
|
||
'filter_mode': backend_filter_mode,
|
||
# --- END MODIFICATION ---
|
||
'skip_zip': skip_zip, 'skip_rar': skip_rar,
|
||
'use_subfolders': use_subfolders, 'use_post_subfolders': use_post_subfolders,
|
||
'compress_images': compress_images, 'download_thumbnails': download_thumbnails,
|
||
'service': service, 'user_id': user_id,
|
||
'downloaded_files': self.downloaded_files,
|
||
'downloaded_files_lock': self.downloaded_files_lock,
|
||
'downloaded_file_hashes': self.downloaded_file_hashes,
|
||
'downloaded_file_hashes_lock': self.downloaded_file_hashes_lock,
|
||
'skip_words_list': skip_words_list,
|
||
'show_external_links': self.show_external_links,
|
||
'extract_links_only': extract_links_only,
|
||
'start_page': start_page,
|
||
'end_page': end_page,
|
||
'target_post_id_from_initial_url': post_id_from_url,
|
||
'custom_folder_name': custom_folder_name_cleaned,
|
||
'manga_mode_active': manga_mode,
|
||
'unwanted_keywords': unwanted_keywords_for_folders,
|
||
'cancellation_event': self.cancellation_event,
|
||
'signals': self.worker_signals,
|
||
}
|
||
|
||
|
||
try:
|
||
if should_use_multithreading:
|
||
self.log_signal.emit(f" Initializing multi-threaded {'link extraction' if extract_links_only else 'download'} with {num_threads} post workers...")
|
||
self.start_multi_threaded_download(num_post_workers=num_threads, **args_template)
|
||
else:
|
||
self.log_signal.emit(f" Initializing single-threaded {'link extraction' if extract_links_only else 'download'}...")
|
||
dt_expected_keys = [
|
||
'api_url_input', 'output_dir', 'known_names_copy', 'cancellation_event',
|
||
'filter_character_list', 'filter_mode', 'skip_zip', 'skip_rar',
|
||
'use_subfolders', 'use_post_subfolders', 'custom_folder_name',
|
||
'compress_images', 'download_thumbnails', 'service', 'user_id',
|
||
'downloaded_files', 'downloaded_file_hashes', 'downloaded_files_lock',
|
||
'downloaded_file_hashes_lock', 'skip_words_list', 'show_external_links',
|
||
'extract_links_only',
|
||
'num_file_threads_for_worker', 'skip_current_file_flag',
|
||
'start_page', 'end_page', 'target_post_id_from_initial_url',
|
||
'manga_mode_active', 'unwanted_keywords'
|
||
]
|
||
args_template['num_file_threads_for_worker'] = 1
|
||
args_template['skip_current_file_flag'] = None
|
||
|
||
single_thread_args = {}
|
||
for key in dt_expected_keys:
|
||
if key in args_template:
|
||
single_thread_args[key] = args_template[key]
|
||
|
||
self.start_single_threaded_download(**single_thread_args)
|
||
|
||
except Exception as e:
|
||
self.log_signal.emit(f"❌ CRITICAL ERROR preparing {'link extraction' if extract_links_only else 'download'}: {e}\n{traceback.format_exc()}")
|
||
QMessageBox.critical(self, "Start Error", f"Failed to start process:\n{e}")
|
||
self.download_finished(0,0,False)
|
||
|
||
|
||
def start_single_threaded_download(self, **kwargs):
|
||
global BackendDownloadThread
|
||
try:
|
||
self.download_thread = BackendDownloadThread(**kwargs)
|
||
|
||
if hasattr(self.download_thread, 'progress_signal'):
|
||
self.download_thread.progress_signal.connect(self.handle_main_log)
|
||
if hasattr(self.download_thread, 'add_character_prompt_signal'):
|
||
self.download_thread.add_character_prompt_signal.connect(self.add_character_prompt_signal)
|
||
if hasattr(self.download_thread, 'finished_signal'):
|
||
self.download_thread.finished_signal.connect(self.finished_signal)
|
||
if hasattr(self.download_thread, 'receive_add_character_result'):
|
||
self.character_prompt_response_signal.connect(self.download_thread.receive_add_character_result)
|
||
if hasattr(self.download_thread, 'external_link_signal'):
|
||
self.download_thread.external_link_signal.connect(self.handle_external_link_signal)
|
||
if hasattr(self.download_thread, 'file_progress_signal'):
|
||
self.download_thread.file_progress_signal.connect(self.update_file_progress_display)
|
||
|
||
self.download_thread.start()
|
||
self.log_signal.emit("✅ Single download thread (for posts) started.")
|
||
except Exception as e:
|
||
self.log_signal.emit(f"❌ CRITICAL ERROR starting single-thread: {e}\n{traceback.format_exc()}")
|
||
QMessageBox.critical(self, "Thread Start Error", f"Failed to start download process: {e}")
|
||
self.download_finished(0,0,False)
|
||
|
||
|
||
def start_multi_threaded_download(self, num_post_workers, **kwargs):
|
||
global PostProcessorWorker
|
||
self.thread_pool = ThreadPoolExecutor(max_workers=num_post_workers, thread_name_prefix='PostWorker_')
|
||
self.active_futures = []
|
||
self.processed_posts_count = 0
|
||
self.total_posts_to_process = 0
|
||
self.download_counter = 0
|
||
self.skip_counter = 0
|
||
|
||
fetcher_thread = threading.Thread(
|
||
target=self._fetch_and_queue_posts,
|
||
args=(kwargs['api_url_input'], kwargs, num_post_workers),
|
||
daemon=True, name="PostFetcher"
|
||
)
|
||
fetcher_thread.start()
|
||
self.log_signal.emit(f"✅ Post fetcher thread started. {num_post_workers} post worker threads initializing...")
|
||
|
||
|
||
def _fetch_and_queue_posts(self, api_url_input_for_fetcher, worker_args_template, num_post_workers):
|
||
global PostProcessorWorker, download_from_api
|
||
all_posts_data = []
|
||
fetch_error_occurred = False
|
||
|
||
manga_mode_active_for_fetch = worker_args_template.get('manga_mode_active', False)
|
||
signals_for_worker = worker_args_template.get('signals')
|
||
if not signals_for_worker:
|
||
self.log_signal.emit("❌ CRITICAL ERROR: Signals object missing for worker in _fetch_and_queue_posts.")
|
||
self.finished_signal.emit(0,0,True)
|
||
return
|
||
|
||
try:
|
||
self.log_signal.emit(" Fetching post data from API...")
|
||
post_generator = download_from_api(
|
||
api_url_input_for_fetcher,
|
||
logger=lambda msg: self.log_signal.emit(f"[Fetcher] {msg}"),
|
||
start_page=worker_args_template.get('start_page'),
|
||
end_page=worker_args_template.get('end_page'),
|
||
manga_mode=manga_mode_active_for_fetch,
|
||
cancellation_event=self.cancellation_event
|
||
)
|
||
for posts_batch in post_generator:
|
||
if self.cancellation_event.is_set():
|
||
fetch_error_occurred = True; self.log_signal.emit(" Post fetching cancelled by user."); break
|
||
if isinstance(posts_batch, list):
|
||
all_posts_data.extend(posts_batch)
|
||
self.total_posts_to_process = len(all_posts_data)
|
||
if self.total_posts_to_process > 0 and self.total_posts_to_process % 100 == 0 :
|
||
self.log_signal.emit(f" Fetched {self.total_posts_to_process} posts so far...")
|
||
else:
|
||
fetch_error_occurred = True
|
||
self.log_signal.emit(f"❌ API fetcher returned non-list type: {type(posts_batch)}"); break
|
||
|
||
if not fetch_error_occurred and not self.cancellation_event.is_set():
|
||
self.log_signal.emit(f"✅ Post fetching complete. Total posts to process: {self.total_posts_to_process}")
|
||
except TypeError as te:
|
||
self.log_signal.emit(f"❌ TypeError calling download_from_api: {te}")
|
||
self.log_signal.emit(" Check if 'downloader_utils.py' has the correct 'download_from_api' signature (including 'manga_mode' and 'cancellation_event').")
|
||
self.log_signal.emit(traceback.format_exc(limit=2))
|
||
fetch_error_occurred = True
|
||
except RuntimeError as re:
|
||
self.log_signal.emit(f"ℹ️ Post fetching runtime error (likely cancellation): {re}")
|
||
fetch_error_occurred = True
|
||
except Exception as e:
|
||
self.log_signal.emit(f"❌ Error during post fetching: {e}\n{traceback.format_exc(limit=2)}")
|
||
fetch_error_occurred = True
|
||
|
||
if self.cancellation_event.is_set() or fetch_error_occurred:
|
||
self.finished_signal.emit(self.download_counter, self.skip_counter, self.cancellation_event.is_set())
|
||
if self.thread_pool:
|
||
self.thread_pool.shutdown(wait=False, cancel_futures=True); self.thread_pool = None
|
||
return
|
||
|
||
if self.total_posts_to_process == 0:
|
||
self.log_signal.emit("😕 No posts found or fetched to process.")
|
||
self.finished_signal.emit(0,0,False); return
|
||
|
||
self.log_signal.emit(f" Submitting {self.total_posts_to_process} post processing tasks to thread pool...")
|
||
self.processed_posts_count = 0
|
||
self.overall_progress_signal.emit(self.total_posts_to_process, 0)
|
||
|
||
num_file_dl_threads = 4
|
||
|
||
ppw_expected_keys = [
|
||
'post_data', 'download_root', 'known_names', 'filter_character_list',
|
||
'unwanted_keywords', 'filter_mode', 'skip_zip', 'skip_rar',
|
||
'use_subfolders', 'use_post_subfolders', 'target_post_id_from_initial_url',
|
||
'custom_folder_name', 'compress_images', 'download_thumbnails', 'service',
|
||
'user_id', 'api_url_input', 'cancellation_event', 'signals',
|
||
'downloaded_files', 'downloaded_file_hashes', 'downloaded_files_lock',
|
||
'downloaded_file_hashes_lock', 'skip_words_list', 'show_external_links',
|
||
'extract_links_only', 'num_file_threads', 'skip_current_file_flag',
|
||
'manga_mode_active'
|
||
]
|
||
ppw_optional_keys_with_defaults = {
|
||
'skip_words_list', 'show_external_links', 'extract_links_only',
|
||
'num_file_threads', 'skip_current_file_flag', 'manga_mode_active'
|
||
}
|
||
|
||
|
||
for post_data_item in all_posts_data:
|
||
if self.cancellation_event.is_set(): break
|
||
if not isinstance(post_data_item, dict):
|
||
self.log_signal.emit(f"⚠️ Skipping invalid post data item (not a dict): {type(post_data_item)}")
|
||
self.processed_posts_count += 1
|
||
continue
|
||
|
||
worker_init_args = {}
|
||
missing_keys = []
|
||
for key in ppw_expected_keys:
|
||
if key == 'post_data': worker_init_args[key] = post_data_item
|
||
elif key == 'num_file_threads': worker_init_args[key] = num_file_dl_threads
|
||
elif key == 'signals': worker_init_args[key] = signals_for_worker
|
||
elif key in worker_args_template: worker_init_args[key] = worker_args_template[key]
|
||
elif key in ppw_optional_keys_with_defaults: pass
|
||
else: missing_keys.append(key)
|
||
|
||
|
||
if missing_keys:
|
||
self.log_signal.emit(f"❌ CRITICAL ERROR: Missing expected keys for PostProcessorWorker: {', '.join(missing_keys)}")
|
||
self.cancellation_event.set()
|
||
break
|
||
|
||
try:
|
||
worker_instance = PostProcessorWorker(**worker_init_args)
|
||
if self.thread_pool:
|
||
future = self.thread_pool.submit(worker_instance.process)
|
||
future.add_done_callback(self._handle_future_result)
|
||
self.active_futures.append(future)
|
||
else:
|
||
self.log_signal.emit("⚠️ Thread pool not available. Cannot submit more tasks.")
|
||
break
|
||
except TypeError as te:
|
||
self.log_signal.emit(f"❌ TypeError creating PostProcessorWorker: {te}")
|
||
passed_keys_str = ", ".join(sorted(worker_init_args.keys()))
|
||
self.log_signal.emit(f" Passed Args: [{passed_keys_str}]")
|
||
self.log_signal.emit(traceback.format_exc(limit=5))
|
||
self.cancellation_event.set(); break
|
||
except RuntimeError:
|
||
self.log_signal.emit("⚠️ Runtime error submitting task (pool likely shutting down)."); break
|
||
except Exception as e:
|
||
self.log_signal.emit(f"❌ Error submitting post {post_data_item.get('id','N/A')} to worker: {e}"); break
|
||
|
||
if not self.cancellation_event.is_set():
|
||
self.log_signal.emit(f" {len(self.active_futures)} post processing tasks submitted to pool.")
|
||
else:
|
||
self.finished_signal.emit(self.download_counter, self.skip_counter, True)
|
||
if self.thread_pool:
|
||
self.thread_pool.shutdown(wait=False, cancel_futures=True); self.thread_pool = None
|
||
|
||
|
||
def _handle_future_result(self, future: Future):
|
||
self.processed_posts_count += 1
|
||
downloaded_files_from_future = 0
|
||
skipped_files_from_future = 0
|
||
try:
|
||
if future.cancelled():
|
||
self.log_signal.emit(" A post processing task was cancelled.")
|
||
elif future.exception():
|
||
worker_exception = future.exception()
|
||
self.log_signal.emit(f"❌ Post processing worker error: {worker_exception}")
|
||
else: # Success
|
||
downloaded_files_from_future, skipped_files_from_future = future.result()
|
||
|
||
with self.downloaded_files_lock:
|
||
self.download_counter += downloaded_files_from_future
|
||
self.skip_counter += skipped_files_from_future
|
||
|
||
self.overall_progress_signal.emit(self.total_posts_to_process, self.processed_posts_count)
|
||
|
||
except Exception as e:
|
||
self.log_signal.emit(f"❌ Error in _handle_future_result callback: {e}\n{traceback.format_exc(limit=2)}")
|
||
|
||
if self.total_posts_to_process > 0 and self.processed_posts_count >= self.total_posts_to_process:
|
||
all_done = all(f.done() for f in self.active_futures)
|
||
if all_done:
|
||
QApplication.processEvents()
|
||
self.log_signal.emit("🏁 All submitted post tasks have completed or failed.")
|
||
self.finished_signal.emit(self.download_counter, self.skip_counter, self.cancellation_event.is_set())
|
||
|
||
|
||
def set_ui_enabled(self, enabled):
|
||
widgets_to_toggle = [
|
||
self.download_btn, self.link_input,
|
||
self.radio_all, self.radio_images, self.radio_videos, self.radio_only_links,
|
||
self.skip_zip_checkbox, self.skip_rar_checkbox,
|
||
self.use_subfolders_checkbox, self.compress_images_checkbox,
|
||
self.download_thumbnails_checkbox, self.use_multithreading_checkbox,
|
||
self.skip_words_input, self.character_search_input, self.new_char_input,
|
||
self.add_char_button, self.delete_char_button,
|
||
self.start_page_input, self.end_page_input, self.page_range_label, self.to_label,
|
||
self.character_input, self.custom_folder_input, self.custom_folder_label,
|
||
self.reset_button,
|
||
self.manga_mode_checkbox
|
||
]
|
||
for widget in widgets_to_toggle:
|
||
if widget:
|
||
widget.setEnabled(enabled)
|
||
|
||
if self.external_links_checkbox:
|
||
is_only_links = self.radio_only_links and self.radio_only_links.isChecked()
|
||
self.external_links_checkbox.setEnabled(not is_only_links)
|
||
if self.log_verbosity_button:
|
||
self.log_verbosity_button.setEnabled(True)
|
||
|
||
|
||
multithreading_currently_on = self.use_multithreading_checkbox.isChecked()
|
||
self.thread_count_input.setEnabled(enabled and multithreading_currently_on)
|
||
self.thread_count_label.setEnabled(enabled and multithreading_currently_on)
|
||
|
||
|
||
subfolders_currently_on = self.use_subfolders_checkbox.isChecked()
|
||
self.use_subfolder_per_post_checkbox.setEnabled(enabled and subfolders_currently_on)
|
||
|
||
self.cancel_btn.setEnabled(not enabled)
|
||
|
||
if enabled:
|
||
self._handle_filter_mode_change(self.radio_group.checkedButton(), True)
|
||
self._handle_multithreading_toggle(multithreading_currently_on)
|
||
|
||
|
||
def cancel_download(self):
|
||
if not self.cancel_btn.isEnabled() and not self.cancellation_event.is_set():
|
||
self.log_signal.emit("ℹ️ No active download to cancel or already cancelling.")
|
||
return
|
||
|
||
self.log_signal.emit("⚠️ Requesting cancellation of download process...")
|
||
self.cancellation_event.set()
|
||
|
||
if self.download_thread and self.download_thread.isRunning():
|
||
self.download_thread.requestInterruption()
|
||
self.log_signal.emit(" Signaled single download thread to interrupt.")
|
||
|
||
if self.thread_pool:
|
||
self.log_signal.emit(" Initiating immediate shutdown and cancellation of worker pool tasks...")
|
||
self.thread_pool.shutdown(wait=False, cancel_futures=True)
|
||
|
||
self.external_link_queue.clear()
|
||
self._is_processing_external_link_queue = False
|
||
self._current_link_post_title = None
|
||
|
||
self.cancel_btn.setEnabled(False)
|
||
self.progress_label.setText("Progress: Cancelling...")
|
||
self.file_progress_label.setText("")
|
||
|
||
|
||
def download_finished(self, total_downloaded, total_skipped, cancelled_by_user):
|
||
status_message = "Cancelled by user" if cancelled_by_user else "Finished"
|
||
self.log_signal.emit("="*40 + f"\n🏁 Download {status_message}!\n Summary: Downloaded Files={total_downloaded}, Skipped Files={total_skipped}\n" + "="*40)
|
||
self.progress_label.setText(f"{status_message}: {total_downloaded} downloaded, {total_skipped} skipped.")
|
||
self.file_progress_label.setText("")
|
||
|
||
if not cancelled_by_user:
|
||
self._try_process_next_external_link()
|
||
|
||
if self.download_thread:
|
||
try:
|
||
if hasattr(self.download_thread, 'progress_signal'): self.download_thread.progress_signal.disconnect(self.handle_main_log)
|
||
if hasattr(self.download_thread, 'add_character_prompt_signal'): self.download_thread.add_character_prompt_signal.disconnect(self.add_character_prompt_signal)
|
||
if hasattr(self.download_thread, 'finished_signal'): self.download_thread.finished_signal.disconnect(self.finished_signal)
|
||
if hasattr(self.download_thread, 'receive_add_character_result'): self.character_prompt_response_signal.disconnect(self.download_thread.receive_add_character_result)
|
||
if hasattr(self.download_thread, 'external_link_signal'): self.download_thread.external_link_signal.disconnect(self.handle_external_link_signal)
|
||
if hasattr(self.download_thread, 'file_progress_signal'): self.download_thread.file_progress_signal.disconnect(self.update_file_progress_display)
|
||
except (TypeError, RuntimeError) as e:
|
||
self.log_signal.emit(f"ℹ️ Note during single-thread signal disconnection: {e}")
|
||
self.download_thread = None
|
||
|
||
if self.thread_pool:
|
||
self.log_signal.emit(" Ensuring worker thread pool is shut down...")
|
||
self.thread_pool.shutdown(wait=True, cancel_futures=True)
|
||
self.thread_pool = None
|
||
self.active_futures = []
|
||
|
||
|
||
self.set_ui_enabled(True)
|
||
self.cancel_btn.setEnabled(False)
|
||
|
||
def toggle_log_verbosity(self):
|
||
self.basic_log_mode = not self.basic_log_mode
|
||
if self.basic_log_mode:
|
||
self.log_verbosity_button.setText("Show Full Log")
|
||
self.log_signal.emit("="*20 + " Basic Log Mode Enabled " + "="*20)
|
||
else:
|
||
self.log_verbosity_button.setText("Show Basic Log")
|
||
self.log_signal.emit("="*20 + " Full Log Mode Enabled " + "="*20)
|
||
|
||
def reset_application_state(self):
|
||
is_running = (self.download_thread and self.download_thread.isRunning()) or \
|
||
(self.thread_pool is not None and any(not f.done() for f in self.active_futures if f is not None))
|
||
if is_running:
|
||
QMessageBox.warning(self, "Reset Error", "Cannot reset while a download is in progress. Please cancel the download first.")
|
||
return
|
||
|
||
self.log_signal.emit("🔄 Resetting application state to defaults...")
|
||
self._reset_ui_to_defaults()
|
||
self.main_log_output.clear()
|
||
self.external_log_output.clear()
|
||
if self.show_external_links:
|
||
self.external_log_output.append("🔗 External Links Found:")
|
||
|
||
self.external_link_queue.clear()
|
||
self.extracted_links_cache = []
|
||
self._is_processing_external_link_queue = False
|
||
self._current_link_post_title = None
|
||
|
||
self.progress_label.setText("Progress: Idle")
|
||
self.file_progress_label.setText("")
|
||
|
||
with self.downloaded_files_lock:
|
||
count = len(self.downloaded_files)
|
||
self.downloaded_files.clear()
|
||
if count > 0: self.log_signal.emit(f" Cleared {count} downloaded filename(s) from session memory.")
|
||
with self.downloaded_file_hashes_lock:
|
||
count = len(self.downloaded_file_hashes)
|
||
self.downloaded_file_hashes.clear()
|
||
if count > 0: self.log_signal.emit(f" Cleared {count} downloaded file hash(es) from session memory.")
|
||
|
||
self.total_posts_to_process = 0
|
||
self.processed_posts_count = 0
|
||
self.download_counter = 0
|
||
self.skip_counter = 0
|
||
|
||
self.cancellation_event.clear()
|
||
|
||
self.basic_log_mode = False
|
||
if self.log_verbosity_button:
|
||
self.log_verbosity_button.setText("Show Basic Log")
|
||
|
||
self.log_signal.emit("✅ Application reset complete.")
|
||
|
||
|
||
def _reset_ui_to_defaults(self):
|
||
self.link_input.clear()
|
||
self.dir_input.clear()
|
||
self.custom_folder_input.clear()
|
||
self.character_input.clear()
|
||
self.skip_words_input.clear()
|
||
self.start_page_input.clear()
|
||
self.end_page_input.clear()
|
||
self.new_char_input.clear()
|
||
self.character_search_input.clear()
|
||
self.thread_count_input.setText("4")
|
||
|
||
self.radio_all.setChecked(True)
|
||
self.skip_zip_checkbox.setChecked(True)
|
||
self.skip_rar_checkbox.setChecked(True)
|
||
self.download_thumbnails_checkbox.setChecked(False)
|
||
self.compress_images_checkbox.setChecked(False)
|
||
self.use_subfolders_checkbox.setChecked(True)
|
||
self.use_subfolder_per_post_checkbox.setChecked(False)
|
||
self.use_multithreading_checkbox.setChecked(True)
|
||
self.external_links_checkbox.setChecked(False)
|
||
if self.manga_mode_checkbox:
|
||
self.manga_mode_checkbox.setChecked(False)
|
||
|
||
self._handle_filter_mode_change(self.radio_all, True)
|
||
self._handle_multithreading_toggle(self.use_multithreading_checkbox.isChecked())
|
||
|
||
self.filter_character_list("")
|
||
|
||
self.download_btn.setEnabled(True)
|
||
self.cancel_btn.setEnabled(False)
|
||
if self.reset_button: self.reset_button.setEnabled(True)
|
||
if self.log_verbosity_button: self.log_verbosity_button.setText("Show Basic Log")
|
||
|
||
|
||
def prompt_add_character(self, character_name):
|
||
global KNOWN_NAMES
|
||
reply = QMessageBox.question(self, "Add Filter Name to Known List?",
|
||
f"The name '{character_name}' was encountered or used as a filter.\nIt's not in your known names list (used for folder suggestions).\nAdd it now?",
|
||
QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
|
||
result = (reply == QMessageBox.Yes)
|
||
if result:
|
||
self.new_char_input.setText(character_name)
|
||
if self.add_new_character():
|
||
self.log_signal.emit(f"✅ Added '{character_name}' to known names via background prompt.")
|
||
else:
|
||
result = False
|
||
self.log_signal.emit(f"ℹ️ Adding '{character_name}' via background prompt was declined or failed (e.g., similarity warning, duplicate).")
|
||
self.character_prompt_response_signal.emit(result)
|
||
|
||
def receive_add_character_result(self, result):
|
||
with QMutexLocker(self.prompt_mutex):
|
||
self._add_character_response = result
|
||
self.log_signal.emit(f" Main thread received character prompt response: {'Action resulted in addition/confirmation' if result else 'Action resulted in no addition/declined'}")
|
||
|
||
|
||
if __name__ == '__main__':
|
||
import traceback
|
||
try:
|
||
qt_app = QApplication(sys.argv)
|
||
if getattr(sys, 'frozen', False):
|
||
base_dir = sys._MEIPASS
|
||
else:
|
||
base_dir = os.path.dirname(os.path.abspath(__file__))
|
||
|
||
icon_path = os.path.join(base_dir, 'Kemono.ico')
|
||
if os.path.exists(icon_path):
|
||
qt_app.setWindowIcon(QIcon(icon_path))
|
||
else:
|
||
print(f"Warning: Application icon 'Kemono.ico' not found at {icon_path}")
|
||
|
||
downloader_app_instance = DownloaderApp()
|
||
downloader_app_instance.show()
|
||
|
||
# --- ADDED: Show Tour Dialog if needed ---
|
||
if TourDialog: # Check if TourDialog was imported successfully
|
||
tour_result = TourDialog.run_tour_if_needed(downloader_app_instance)
|
||
if tour_result == QDialog.Accepted:
|
||
print("Tour completed by user.")
|
||
elif tour_result == QDialog.Rejected:
|
||
# This means tour was skipped OR already shown.
|
||
# You can use TourDialog.settings.value(TourDialog.TOUR_SHOWN_KEY)
|
||
# to differentiate if needed, but run_tour_if_needed handles the "show once" logic.
|
||
print("Tour skipped or was already shown.")
|
||
# --- END ADDED ---
|
||
|
||
exit_code = qt_app.exec_()
|
||
print(f"Application finished with exit code: {exit_code}")
|
||
sys.exit(exit_code)
|
||
except SystemExit:
|
||
pass # Allow clean exit
|
||
except Exception as e:
|
||
print("--- CRITICAL APPLICATION ERROR ---")
|
||
print(f"An unhandled exception occurred: {e}")
|
||
traceback.print_exc()
|
||
print("--- END CRITICAL ERROR ---")
|
||
sys.exit(1) |