360 lines
11 KiB
Python
360 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
YouTube CLI - A command-line interface for browsing and downloading YouTube videos
|
|
"""
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
from rich.console import Console
|
|
from rich.progress import Progress, SpinnerColumn, TextColumn
|
|
from rich.table import Table
|
|
|
|
console = Console()
|
|
|
|
|
|
def main():
|
|
"""Main entry point for the YouTube CLI application."""
|
|
parser = argparse.ArgumentParser(
|
|
description="YouTube CLI - Browse and download YouTube videos"
|
|
)
|
|
parser.add_argument("query", nargs="?", help="Search query for YouTube")
|
|
parser.add_argument(
|
|
"--download", action="store_true", help="Download a specific video"
|
|
)
|
|
parser.add_argument("--config", help="Configuration file path")
|
|
parser.add_argument(
|
|
"--list", action="store_true", help="List videos (default behavior)"
|
|
)
|
|
parser.add_argument("--page", type=int, default=1, help="Page number for results")
|
|
|
|
args = parser.parse_args()
|
|
|
|
# Initialize configuration
|
|
config = load_config(args.config)
|
|
|
|
if args.download:
|
|
# Handle download functionality
|
|
if not args.query:
|
|
print("Error: You must provide a video URL for downloading")
|
|
return
|
|
download_video(args.query, config)
|
|
return
|
|
|
|
# Default behavior - show search results
|
|
if args.query:
|
|
search_videos(args.query, config, page=args.page)
|
|
else:
|
|
# Show help if no arguments given
|
|
parser.print_help()
|
|
|
|
|
|
def load_config(config_path=None):
|
|
"""Load configuration from file or use defaults."""
|
|
default_config = {
|
|
"download_dir": str(Path.home() / "Downloads" / "youtube"),
|
|
"default_locations": [
|
|
str(Path.home() / "Downloads" / "youtube"),
|
|
str(Path.home() / "Movies" / "youtube"),
|
|
"/tmp/youtube",
|
|
],
|
|
"max_videos_per_page": 15,
|
|
"yt_dlp_args": {
|
|
"format": "bestvideo[height=1080]+bestaudio/bestvideo[height<=1080]+bestaudio",
|
|
"write_thumbnail": True,
|
|
"extractor_args": "youtube:player-client=default,-tv_simply",
|
|
},
|
|
}
|
|
|
|
if config_path and os.path.exists(config_path):
|
|
try:
|
|
with open(config_path, "r") as f:
|
|
config = json.load(f)
|
|
# Merge with defaults
|
|
for key, value in default_config.items():
|
|
if key not in config:
|
|
config[key] = value
|
|
return config
|
|
except Exception as e:
|
|
print(f"Error loading config: {e}")
|
|
|
|
return default_config
|
|
|
|
|
|
def search_videos(query, config, page=1):
|
|
"""Search YouTube videos based on the query using yt-dlp."""
|
|
console.print(f"[blue]Searching YouTube for:[/blue] {query}")
|
|
|
|
# Construct yt-dlp command for search
|
|
cmd = [
|
|
"yt-dlp",
|
|
"--flat-playlist", # Get video info without downloading
|
|
"--dump-single-json", # Output as JSON for single video
|
|
f"--playlist-start={15 * (page - 1) + 1}",
|
|
f"--playlist-end={15 * page}",
|
|
"--no-warnings",
|
|
"--no-progress",
|
|
"--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
|
|
f"ytsearch{15 * page}:{query}",
|
|
]
|
|
|
|
try:
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode != 0:
|
|
console.print(f"[red]Error searching videos: {result.stderr}[/red]")
|
|
return
|
|
|
|
# Parse JSON output
|
|
import json
|
|
|
|
try:
|
|
data = json.loads(result.stdout.strip())
|
|
except json.JSONDecodeError:
|
|
console.print(
|
|
"[red]Error parsing search results. Try another search.[/red]"
|
|
)
|
|
return
|
|
|
|
# Process videos into our format
|
|
videos = []
|
|
|
|
if isinstance(data, list):
|
|
videos_data = data
|
|
elif "entries" in data:
|
|
videos_data = data["entries"]
|
|
else:
|
|
videos_data = [data]
|
|
|
|
for entry in videos_data:
|
|
if not entry:
|
|
continue
|
|
|
|
title = entry.get("title", "Unknown Title")
|
|
author = entry.get("uploader", "Unknown Author")
|
|
duration = entry.get("duration", 0)
|
|
url = entry.get("url", "") or entry.get("webpage_url", "")
|
|
|
|
# Format duration
|
|
length = format_duration(duration)
|
|
|
|
# Check if this is a short video
|
|
is_short = "/shorts/" in url
|
|
|
|
# Create video object
|
|
videos.append(
|
|
{
|
|
"title": title,
|
|
"author": author,
|
|
"length": length,
|
|
"url": url,
|
|
"is_short": is_short,
|
|
"id": entry.get("id", ""),
|
|
"thumbnail": entry.get("thumbnail", ""),
|
|
}
|
|
)
|
|
|
|
if not videos:
|
|
console.print("[yellow]No videos found for your search.[/yellow]")
|
|
return
|
|
|
|
display_videos(videos, config, page=page)
|
|
|
|
except subprocess.TimeoutExpired:
|
|
console.print("[red]Search timed out. Please try again.[/red]")
|
|
except Exception as e:
|
|
console.print(f"[red]Error during search: {str(e)}[/red]")
|
|
|
|
|
|
def format_duration(seconds):
|
|
"""Convert seconds to MM:SS or HH:MM:SS format."""
|
|
if not seconds:
|
|
return "0:00"
|
|
|
|
hours = int(seconds // 3600)
|
|
minutes = int((seconds % 3600) // 60)
|
|
secs = int(seconds % 60)
|
|
|
|
if hours > 0:
|
|
return f"{hours}:{minutes:02d}:{secs:02d}"
|
|
else:
|
|
return f"{minutes}:{secs:02d}"
|
|
|
|
|
|
def display_videos(videos, config, page=1):
|
|
"""Display videos in a formatted table."""
|
|
console.print("\n" + "=" * 80)
|
|
console.print(f"[bold]YouTube Search Results - Page {page}[/bold]")
|
|
console.print("=" * 80)
|
|
|
|
table = Table(
|
|
title=f"Page {page} of search results",
|
|
show_header=True,
|
|
header_style="bold magenta",
|
|
)
|
|
table.add_column("No.", style="dim", width=3)
|
|
table.add_column("Title", width=35)
|
|
table.add_column("Author", width=20)
|
|
table.add_column("Duration", width=10)
|
|
table.add_column("Type", width=8)
|
|
|
|
for i, video in enumerate(videos, 1):
|
|
title = video["title"]
|
|
author = video["author"]
|
|
length = video["length"]
|
|
|
|
# Mark short videos
|
|
if video["is_short"]:
|
|
title = f"(short) {title}"
|
|
|
|
table.add_row(
|
|
str(i),
|
|
title,
|
|
author[:18] + "..." if len(author) > 18 else author,
|
|
length,
|
|
"Short" if video["is_short"] else "Video",
|
|
)
|
|
|
|
console.print(table)
|
|
|
|
# Show pagination options
|
|
console.print("=" * 80)
|
|
console.print("[blue]Options:[/blue]")
|
|
console.print(" [green]n[/green] - Next page")
|
|
console.print(" [red]q[/red] - Quit")
|
|
console.print(" [yellow]Number[/yellow] - Select and download video (e.g., 1)")
|
|
|
|
# Get user input
|
|
user_input = input("\nChoose an option: ").strip().lower()
|
|
|
|
if user_input == "q":
|
|
console.print("[green]Goodbye![/green]")
|
|
return
|
|
|
|
elif user_input == "n":
|
|
console.print(f"[blue]Loading page {page + 1}...[/blue]")
|
|
search_videos(
|
|
videos[0]["title"].split(" ")[0], config, page=page + 1
|
|
) # Simple approach
|
|
return
|
|
|
|
else:
|
|
try:
|
|
choice = int(user_input)
|
|
if 1 <= choice <= len(videos):
|
|
selected_video = videos[choice - 1]
|
|
console.print(
|
|
f"\n[blue]Selected video:[/blue] {selected_video['title']}"
|
|
)
|
|
|
|
# Download the video
|
|
download_video(selected_video["url"], config)
|
|
else:
|
|
console.print("[red]Invalid selection. Please try again.[/red]")
|
|
except ValueError:
|
|
console.print("[red]Invalid input. Please enter a number or 'q'/'n'.[/red]")
|
|
|
|
|
|
def download_video(url, config):
|
|
"""Download a video using yt-dlp with progress bar."""
|
|
console.print(f"[blue]Preparing to download:[/blue] {url}")
|
|
|
|
# Check if yt-dlp is available
|
|
try:
|
|
subprocess.run(["yt-dlp", "--version"], capture_output=True, check=True)
|
|
except (subprocess.CalledProcessError, FileNotFoundError):
|
|
console.print(
|
|
"[red]Error: yt-dlp not found. Please install it with 'pip install yt-dlp'[/red]"
|
|
)
|
|
return
|
|
|
|
# Set download directory
|
|
download_dir = Path(config["download_dir"])
|
|
download_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Prepare yt-dlp command
|
|
cmd = [
|
|
"yt-dlp",
|
|
"--no-warnings",
|
|
"-o",
|
|
str(download_dir / "%(title)s.%(ext)s"),
|
|
"--write-thumbnail",
|
|
]
|
|
|
|
# Add custom args from config if they exist
|
|
ytdlp_args = config.get("yt_dlp_args", {})
|
|
if "format" in ytdlp_args:
|
|
cmd.extend(["--format", ytdlp_args["format"]])
|
|
if ytdlp_args.get("write_thumbnail", False):
|
|
cmd.append("--write-thumbnail")
|
|
|
|
# Add extractor args
|
|
if "extractor_args" in ytdlp_args:
|
|
cmd.extend(["--extractor-args", ytdlp_args["extractor_args"]])
|
|
|
|
# Add URL
|
|
cmd.append(url)
|
|
|
|
try:
|
|
console.print("[blue]Starting download...[/blue]")
|
|
|
|
# Run command with progress tracking
|
|
process = subprocess.Popen(
|
|
cmd,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
universal_newlines=True,
|
|
bufsize=1,
|
|
)
|
|
|
|
# Create a simple status indicator
|
|
progress_console = Console()
|
|
with Progress(
|
|
SpinnerColumn(),
|
|
TextColumn("[progress.description]{task.description}"),
|
|
console=progress_console,
|
|
) as progress:
|
|
task = progress.add_task("[blue]Downloading...", total=100)
|
|
|
|
while True:
|
|
output = process.stdout.readline()
|
|
if output == "" and process.poll() is not None:
|
|
break
|
|
if output:
|
|
# Simple progress tracking (yt-dlp doesn't support progress events directly)
|
|
progress.update(task, advance=1)
|
|
|
|
# Check if download completed successfully
|
|
return_code = process.poll()
|
|
if return_code == 0:
|
|
console.print("[green]Download completed successfully![/green]")
|
|
else:
|
|
console.print("[red]Download failed.[/red]")
|
|
|
|
except Exception as e:
|
|
console.print(f"[red]Error during download: {str(e)}[/red]")
|
|
|
|
# Optionally, ask to select a different download location
|
|
locations = config.get("default_locations", [config["download_dir"]])
|
|
if len(locations) > 1:
|
|
console.print("\n[blue]Select download location:[/blue]")
|
|
for i, loc in enumerate(locations, 1):
|
|
console.print(f" {i}. {loc}")
|
|
|
|
try:
|
|
choice = int(input("Enter selection (or press Enter to use default): "))
|
|
if 1 <= choice <= len(locations):
|
|
new_dir = Path(locations[choice - 1])
|
|
config["download_dir"] = str(new_dir)
|
|
console.print(f"[green]Download location set to: {new_dir}[/green]")
|
|
except ValueError:
|
|
pass
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|