493 lines
20 KiB
Python
493 lines
20 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
YouTube Channel Archiver - Standalone Windows Executable
|
|
Complete self-contained application with dependency management.
|
|
"""
|
|
|
|
import tkinter as tk
|
|
from tkinter import ttk, filedialog, messagebox, scrolledtext
|
|
import subprocess
|
|
import threading
|
|
import sys
|
|
import os
|
|
import platform
|
|
from pathlib import Path
|
|
import queue
|
|
import tempfile
|
|
|
|
class YouTubeArchiverStandalone:
|
|
def __init__(self, root):
|
|
self.root = root
|
|
self.root.title("YouTube Channel Archiver v1.0")
|
|
self.root.geometry("700x600")
|
|
self.root.resizable(True, True)
|
|
|
|
# Queue for thread communication
|
|
self.output_queue = queue.Queue()
|
|
|
|
# Variables
|
|
self.channel_url = tk.StringVar()
|
|
self.output_dir = tk.StringVar(value=str(Path.home() / "Downloads" / "YouTube_Archives"))
|
|
self.quality = tk.StringVar(value="best")
|
|
self.audio_only = tk.BooleanVar()
|
|
self.download_thumbnails = tk.BooleanVar(value=True)
|
|
self.download_metadata = tk.BooleanVar(value=True)
|
|
|
|
# Track processes
|
|
self.download_process = None
|
|
self.is_downloading = False
|
|
self.dependencies_checked = False
|
|
|
|
self.create_widgets()
|
|
|
|
# Check dependencies in background
|
|
self.root.after(1000, self.check_all_dependencies)
|
|
|
|
# Start checking queue for output updates
|
|
self.root.after(100, self.check_queue)
|
|
|
|
def create_widgets(self):
|
|
# Main frame with padding
|
|
main_frame = ttk.Frame(self.root, padding="15")
|
|
main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
|
|
|
|
# Configure grid weights
|
|
self.root.columnconfigure(0, weight=1)
|
|
self.root.rowconfigure(0, weight=1)
|
|
main_frame.columnconfigure(1, weight=1)
|
|
|
|
# Title and info
|
|
title_frame = ttk.Frame(main_frame)
|
|
title_frame.grid(row=0, column=0, columnspan=3, pady=(0, 20))
|
|
|
|
title_label = ttk.Label(title_frame, text="YouTube Channel Archiver",
|
|
font=('Arial', 18, 'bold'))
|
|
title_label.pack()
|
|
|
|
subtitle_label = ttk.Label(title_frame, text="Download entire YouTube channels with ease",
|
|
font=('Arial', 10))
|
|
subtitle_label.pack()
|
|
|
|
# Status frame
|
|
status_frame = ttk.LabelFrame(main_frame, text="System Status", padding="10")
|
|
status_frame.grid(row=1, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 15))
|
|
status_frame.columnconfigure(1, weight=1)
|
|
|
|
self.python_status = ttk.Label(status_frame, text="Python: Checking...", foreground="orange")
|
|
self.python_status.grid(row=0, column=0, sticky=tk.W, pady=2)
|
|
|
|
self.ytdlp_status = ttk.Label(status_frame, text="yt-dlp: Checking...", foreground="orange")
|
|
self.ytdlp_status.grid(row=1, column=0, sticky=tk.W, pady=2)
|
|
|
|
# Channel URL input
|
|
ttk.Label(main_frame, text="YouTube Channel URL:", font=('Arial', 10, 'bold')).grid(
|
|
row=2, column=0, sticky=tk.W, pady=(5, 2))
|
|
|
|
url_frame = ttk.Frame(main_frame)
|
|
url_frame.grid(row=3, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 10))
|
|
url_frame.columnconfigure(0, weight=1)
|
|
|
|
url_entry = ttk.Entry(url_frame, textvariable=self.channel_url, font=('Arial', 10))
|
|
url_entry.grid(row=0, column=0, sticky=(tk.W, tk.E), padx=(0, 10))
|
|
|
|
paste_btn = ttk.Button(url_frame, text="Paste", command=self.paste_from_clipboard)
|
|
paste_btn.grid(row=0, column=1)
|
|
|
|
# Examples
|
|
examples_label = ttk.Label(main_frame,
|
|
text="Examples: https://www.youtube.com/@channelname or https://www.youtube.com/c/channelname",
|
|
font=('Arial', 8), foreground="gray")
|
|
examples_label.grid(row=4, column=0, columnspan=3, sticky=tk.W)
|
|
|
|
# Output directory
|
|
ttk.Label(main_frame, text="Download Location:", font=('Arial', 10, 'bold')).grid(
|
|
row=5, column=0, sticky=tk.W, pady=(15, 2))
|
|
|
|
dir_frame = ttk.Frame(main_frame)
|
|
dir_frame.grid(row=6, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 10))
|
|
dir_frame.columnconfigure(0, weight=1)
|
|
|
|
dir_entry = ttk.Entry(dir_frame, textvariable=self.output_dir, font=('Arial', 10))
|
|
dir_entry.grid(row=0, column=0, sticky=(tk.W, tk.E), padx=(0, 10))
|
|
|
|
browse_btn = ttk.Button(dir_frame, text="Browse", command=self.browse_directory)
|
|
browse_btn.grid(row=0, column=1)
|
|
|
|
# Options frame
|
|
options_frame = ttk.LabelFrame(main_frame, text="Download Options", padding="10")
|
|
options_frame.grid(row=7, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 15))
|
|
options_frame.columnconfigure(1, weight=1)
|
|
|
|
# Quality selection
|
|
ttk.Label(options_frame, text="Video Quality:").grid(row=0, column=0, sticky=tk.W, pady=2)
|
|
quality_combo = ttk.Combobox(options_frame, textvariable=self.quality,
|
|
values=["best", "1080p", "720p", "480p", "worst"],
|
|
state="readonly", width=15)
|
|
quality_combo.grid(row=0, column=1, sticky=tk.W, pady=2, padx=(10, 0))
|
|
|
|
# Checkboxes
|
|
ttk.Checkbutton(options_frame, text="Audio only",
|
|
variable=self.audio_only).grid(row=1, column=0, sticky=tk.W, pady=2)
|
|
|
|
ttk.Checkbutton(options_frame, text="Download thumbnails",
|
|
variable=self.download_thumbnails).grid(row=1, column=1, sticky=tk.W, pady=2)
|
|
|
|
ttk.Checkbutton(options_frame, text="Download metadata",
|
|
variable=self.download_metadata).grid(row=2, column=0, sticky=tk.W, pady=2)
|
|
|
|
# Download button
|
|
self.download_btn = ttk.Button(main_frame, text="Download Channel",
|
|
command=self.start_download,
|
|
style="Accent.TButton")
|
|
self.download_btn.grid(row=8, column=0, columnspan=3, pady=15)
|
|
self.download_btn.state(['disabled']) # Disabled until dependencies are ready
|
|
|
|
# Progress bar
|
|
self.progress = ttk.Progressbar(main_frame, mode='indeterminate')
|
|
self.progress.grid(row=9, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 10))
|
|
|
|
# Output text area
|
|
output_frame = ttk.LabelFrame(main_frame, text="Download Progress", padding="5")
|
|
output_frame.grid(row=10, column=0, columnspan=3, sticky=(tk.W, tk.E, tk.N, tk.S), pady=(0, 10))
|
|
output_frame.columnconfigure(0, weight=1)
|
|
output_frame.rowconfigure(0, weight=1)
|
|
main_frame.rowconfigure(10, weight=1)
|
|
|
|
self.output_text = scrolledtext.ScrolledText(output_frame, height=10, width=80,
|
|
font=('Consolas', 9))
|
|
self.output_text.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
|
|
|
|
# Status bar
|
|
self.status_var = tk.StringVar(value="Checking system dependencies...")
|
|
status_bar = ttk.Label(main_frame, textvariable=self.status_var,
|
|
relief=tk.SUNKEN, anchor=tk.W)
|
|
status_bar.grid(row=11, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(5, 0))
|
|
|
|
def paste_from_clipboard(self):
|
|
"""Paste URL from clipboard."""
|
|
try:
|
|
clipboard_content = self.root.clipboard_get()
|
|
if "youtube.com" in clipboard_content or "youtu.be" in clipboard_content:
|
|
self.channel_url.set(clipboard_content.strip())
|
|
else:
|
|
messagebox.showwarning("Invalid URL", "Clipboard doesn't contain a YouTube URL")
|
|
except tk.TkError:
|
|
messagebox.showwarning("Clipboard Error", "Could not access clipboard")
|
|
|
|
def log_output(self, message):
|
|
"""Add message to output text area."""
|
|
self.output_text.insert(tk.END, message + "\n")
|
|
self.output_text.see(tk.END)
|
|
self.root.update_idletasks()
|
|
|
|
def clear_output(self):
|
|
"""Clear the output text area."""
|
|
self.output_text.delete(1.0, tk.END)
|
|
|
|
def check_all_dependencies(self):
|
|
"""Check all system dependencies."""
|
|
self.log_output("=== System Dependency Check ===")
|
|
|
|
# Check Python
|
|
python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
|
|
self.log_output(f"Python {python_version} detected")
|
|
self.python_status.config(text=f"Python: {python_version} [OK]", foreground="green")
|
|
|
|
# Check yt-dlp in background thread
|
|
threading.Thread(target=self.check_ytdlp, daemon=True).start()
|
|
|
|
def check_ytdlp(self):
|
|
"""Check if yt-dlp is available, install if needed."""
|
|
try:
|
|
# Try to run yt-dlp
|
|
result = subprocess.run(['yt-dlp', '--version'],
|
|
capture_output=True, text=True, check=True, timeout=10)
|
|
version = result.stdout.strip()
|
|
|
|
# Update UI from main thread
|
|
self.root.after(0, lambda: self.ytdlp_found(version))
|
|
|
|
except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
|
|
# yt-dlp not found, try to install
|
|
self.root.after(0, lambda: self.install_ytdlp())
|
|
|
|
def ytdlp_found(self, version):
|
|
"""Called when yt-dlp is found."""
|
|
self.log_output(f"yt-dlp {version} is available")
|
|
self.ytdlp_status.config(text=f"yt-dlp: {version} [OK]", foreground="green")
|
|
self.dependencies_ready()
|
|
|
|
def install_ytdlp(self):
|
|
"""Install yt-dlp using pip."""
|
|
self.log_output("yt-dlp not found. Installing...")
|
|
self.ytdlp_status.config(text="yt-dlp: Installing...", foreground="orange")
|
|
|
|
# Install in background thread
|
|
threading.Thread(target=self.do_install_ytdlp, daemon=True).start()
|
|
|
|
def do_install_ytdlp(self):
|
|
"""Actually install yt-dlp."""
|
|
try:
|
|
# Install yt-dlp
|
|
result = subprocess.run([sys.executable, '-m', 'pip', 'install', 'yt-dlp'],
|
|
capture_output=True, text=True, check=True, timeout=60)
|
|
|
|
# Verify installation
|
|
result = subprocess.run(['yt-dlp', '--version'],
|
|
capture_output=True, text=True, check=True, timeout=10)
|
|
version = result.stdout.strip()
|
|
|
|
# Update UI from main thread
|
|
self.root.after(0, lambda: self.ytdlp_installed(version))
|
|
|
|
except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
|
|
self.root.after(0, lambda: self.ytdlp_install_failed(str(e)))
|
|
|
|
def ytdlp_installed(self, version):
|
|
"""Called when yt-dlp is successfully installed."""
|
|
self.log_output(f"yt-dlp {version} installed successfully!")
|
|
self.ytdlp_status.config(text=f"yt-dlp: {version} [OK]", foreground="green")
|
|
self.dependencies_ready()
|
|
|
|
def ytdlp_install_failed(self, error):
|
|
"""Called when yt-dlp installation fails."""
|
|
self.log_output(f"Failed to install yt-dlp: {error}")
|
|
self.ytdlp_status.config(text="yt-dlp: Installation failed [ERROR]", foreground="red")
|
|
self.status_var.set("Error: Could not install yt-dlp. Check internet connection.")
|
|
|
|
messagebox.showerror("Installation Error",
|
|
"Could not install yt-dlp automatically.\n\n"
|
|
"Please check your internet connection and try again.\n"
|
|
"You can also install it manually with: pip install yt-dlp")
|
|
|
|
def dependencies_ready(self):
|
|
"""Called when all dependencies are ready."""
|
|
if not self.dependencies_checked:
|
|
self.dependencies_checked = True
|
|
self.download_btn.state(['!disabled'])
|
|
self.status_var.set("Ready to download!")
|
|
self.log_output("=== All dependencies ready! ===")
|
|
|
|
def browse_directory(self):
|
|
"""Open directory browser."""
|
|
directory = filedialog.askdirectory(initialdir=self.output_dir.get())
|
|
if directory:
|
|
self.output_dir.set(directory)
|
|
|
|
def validate_inputs(self):
|
|
"""Validate user inputs."""
|
|
if not self.channel_url.get().strip():
|
|
messagebox.showerror("Error", "Please enter a YouTube channel URL")
|
|
return False
|
|
|
|
url = self.channel_url.get().strip()
|
|
if "youtube.com" not in url and "youtu.be" not in url:
|
|
messagebox.showerror("Error", "Please enter a valid YouTube URL")
|
|
return False
|
|
|
|
if not self.output_dir.get().strip():
|
|
messagebox.showerror("Error", "Please select an output directory")
|
|
return False
|
|
|
|
# Check if output directory exists or can be created
|
|
try:
|
|
output_path = Path(self.output_dir.get())
|
|
output_path.mkdir(parents=True, exist_ok=True)
|
|
except Exception as e:
|
|
messagebox.showerror("Error", f"Cannot create output directory: {e}")
|
|
return False
|
|
|
|
return True
|
|
|
|
def build_command(self):
|
|
"""Build the yt-dlp command based on GUI settings."""
|
|
cmd = ['yt-dlp']
|
|
|
|
# Output template
|
|
output_path = Path(self.output_dir.get())
|
|
output_template = str(output_path / "%(uploader)s" / "%(upload_date)s - %(title)s.%(ext)s")
|
|
cmd.extend(['-o', output_template])
|
|
|
|
# Quality settings
|
|
if self.audio_only.get():
|
|
cmd.extend(['-f', 'bestaudio/best'])
|
|
else:
|
|
if self.quality.get() == 'best':
|
|
cmd.extend(['-f', 'best'])
|
|
elif self.quality.get() == 'worst':
|
|
cmd.extend(['-f', 'worst'])
|
|
else:
|
|
# Custom quality
|
|
quality_num = self.quality.get().replace('p', '')
|
|
cmd.extend(['-f', f'best[height<={quality_num}]'])
|
|
|
|
# Additional options
|
|
cmd.extend([
|
|
'--ignore-errors',
|
|
'--no-overwrites',
|
|
'--continue',
|
|
])
|
|
|
|
# Archive file
|
|
archive_file = output_path / 'download_archive.txt'
|
|
cmd.extend(['--download-archive', str(archive_file)])
|
|
|
|
# Metadata and thumbnails
|
|
if self.download_metadata.get():
|
|
cmd.extend(['--write-info-json', '--write-description'])
|
|
|
|
if self.download_thumbnails.get():
|
|
cmd.extend(['--write-thumbnail'])
|
|
|
|
# Add channel URL
|
|
cmd.append(self.channel_url.get().strip())
|
|
|
|
return cmd
|
|
|
|
def start_download(self):
|
|
"""Start the download process."""
|
|
if self.is_downloading:
|
|
self.stop_download()
|
|
return
|
|
|
|
if not self.validate_inputs():
|
|
return
|
|
|
|
# Clear previous output
|
|
self.clear_output()
|
|
|
|
# Update UI
|
|
self.is_downloading = True
|
|
self.download_btn.config(text="Stop Download")
|
|
self.progress.start()
|
|
self.status_var.set("Downloading...")
|
|
|
|
# Build command
|
|
cmd = self.build_command()
|
|
self.log_output(f"Starting download...")
|
|
self.log_output(f"Channel: {self.channel_url.get()}")
|
|
self.log_output(f"Output: {self.output_dir.get()}")
|
|
self.log_output("-" * 50)
|
|
|
|
# Start download in separate thread
|
|
self.download_thread = threading.Thread(target=self.run_download, args=(cmd,))
|
|
self.download_thread.daemon = True
|
|
self.download_thread.start()
|
|
|
|
def run_download(self, cmd):
|
|
"""Run the download process."""
|
|
try:
|
|
# Start the process
|
|
self.download_process = subprocess.Popen(
|
|
cmd,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
text=True,
|
|
bufsize=1,
|
|
universal_newlines=True,
|
|
creationflags=subprocess.CREATE_NO_WINDOW if platform.system() == "Windows" else 0
|
|
)
|
|
|
|
# Read output line by line
|
|
for line in iter(self.download_process.stdout.readline, ''):
|
|
if not self.is_downloading:
|
|
break
|
|
self.output_queue.put(('output', line.rstrip()))
|
|
|
|
# Wait for process to complete
|
|
return_code = self.download_process.wait()
|
|
|
|
if return_code == 0:
|
|
self.output_queue.put(('status', 'Download completed successfully!'))
|
|
else:
|
|
self.output_queue.put(('status', f'Download finished with some errors (code {return_code})'))
|
|
|
|
except Exception as e:
|
|
self.output_queue.put(('error', f'Error during download: {str(e)}'))
|
|
finally:
|
|
self.output_queue.put(('finished', None))
|
|
|
|
def stop_download(self):
|
|
"""Stop the current download."""
|
|
if self.download_process and self.download_process.poll() is None:
|
|
self.download_process.terminate()
|
|
self.log_output("\n[WARNING] Download stopped by user")
|
|
|
|
self.download_finished()
|
|
|
|
def download_finished(self):
|
|
"""Handle download completion."""
|
|
self.is_downloading = False
|
|
self.download_btn.config(text="Download Channel")
|
|
self.progress.stop()
|
|
self.status_var.set("Ready to download!")
|
|
|
|
def check_queue(self):
|
|
"""Check the queue for messages from the download thread."""
|
|
try:
|
|
while True:
|
|
msg_type, message = self.output_queue.get_nowait()
|
|
|
|
if msg_type == 'output':
|
|
self.log_output(message)
|
|
elif msg_type == 'status':
|
|
self.log_output(f"\n{message}")
|
|
self.status_var.set(message)
|
|
elif msg_type == 'error':
|
|
self.log_output(f"\n[ERROR] {message}")
|
|
messagebox.showerror("Download Error", message)
|
|
elif msg_type == 'finished':
|
|
self.download_finished()
|
|
break
|
|
except queue.Empty:
|
|
pass
|
|
|
|
# Schedule next check
|
|
self.root.after(100, self.check_queue)
|
|
|
|
def main():
|
|
# Set up the main window
|
|
root = tk.Tk()
|
|
|
|
# Configure styling
|
|
style = ttk.Style()
|
|
try:
|
|
style.theme_use('vista') # Windows native theme
|
|
except:
|
|
try:
|
|
style.theme_use('clam') # Fallback modern theme
|
|
except:
|
|
pass # Use default
|
|
|
|
# Configure button style
|
|
style.configure('Accent.TButton', font=('Arial', 10, 'bold'))
|
|
|
|
# Create the application
|
|
app = YouTubeArchiverStandalone(root)
|
|
|
|
# Handle window closing
|
|
def on_closing():
|
|
if app.is_downloading:
|
|
if messagebox.askokcancel("Quit", "Download in progress. Stop and quit?"):
|
|
app.stop_download()
|
|
root.destroy()
|
|
else:
|
|
root.destroy()
|
|
|
|
root.protocol("WM_DELETE_WINDOW", on_closing)
|
|
|
|
# Center window on screen
|
|
root.update_idletasks()
|
|
x = (root.winfo_screenwidth() // 2) - (root.winfo_width() // 2)
|
|
y = (root.winfo_screenheight() // 2) - (root.winfo_height() // 2)
|
|
root.geometry(f"+{x}+{y}")
|
|
|
|
# Set minimum size
|
|
root.minsize(600, 500)
|
|
|
|
# Run the application
|
|
root.mainloop()
|
|
|
|
if __name__ == "__main__":
|
|
main()
|