＜Project-20 YT-DLP＞ 视频下载工具 yt-dlp/yt-dlp 加个页面 可下载视频、视频字幕、自动粘贴URL 自动更新 yt-dlp on 12Apr25

介绍 yt-dlp

Github 项目：https://github.com/yt-dlp/yt-dlp

A feature-rich command-line audio/video downloader

一个功能丰富的视频与音频命令行下载器

原因与功能

之前我用的 cobalt 因为它不再提供Client Web功能，只能去它的官网使用。 翻 reddit 找到这个 YT-DLP，但它是个命令行工具，考虑参数大多很少用到，给它加个web 壳子，又可以放到docker里面运行。

在网页填入url，只列出含有视频+音频的文件。点下载后，文件可以保存在本地。命令的运行输出也在页面上显示。占用端口: 9012

YT-DLP 程序

代码在 Claude AI 帮助下完成，前端全靠它，Nice~ 

界面

目录结构

20.YT-DLP/
├── Dockerfile
├── app.py
├── static/
│   ├── css/
│   │   └── style.css
│   └── js/
│       └── script.js
├── templates/
│   └── index.html
└── temp_downloads/
 

完整代码

1. app.py

# app.py
from flask import Flask, render_template, request, jsonify, send_file
import yt_dlp
import os
import shutil
from werkzeug.utils import secure_filename
import time
import logging
import queue
from datetime import datetime
import sys
import socket

app = Flask(__name__)

# Configure maximum content length (1GB)
app.config['MAX_CONTENT_LENGTH'] = 1024 * 1024 * 1024

# Create fixed temp directory
TEMP_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'temp_downloads')
if not os.path.exists(TEMP_DIR):
    os.makedirs(TEMP_DIR)

# Store download information
DOWNLOADS = {}

# Create log queue
log_queue = queue.Queue(maxsize=1000)

class QueueHandler(logging.Handler):
    def __init__(self, log_queue):
        super().__init__()
        self.log_queue = log_queue

    def emit(self, record):
        try:
            # Filter out Werkzeug's regular access logs
            if record.name == 'werkzeug' and any(x in record.getMessage() for x in [
                '127.0.0.1',
                'GET /api/logs',
                'GET /static/',
                '"GET / HTTP/1.1"'
            ]):
                return

            # Clean message format
            msg = self.format(record)
            if record.name == 'app':
                # Remove "INFO:app:" etc. prefix
                msg = msg.split(' - ')[-1]
            
            log_entry = {
                'timestamp': datetime.fromtimestamp(record.created).isoformat(),
                'message': msg,
                'level': record.levelname.lower(),
                'logger': record.name
            }
            
            # Remove oldest log if queue is full
            if self.log_queue.full():
                try:
                    self.log_queue.get_nowait()
                except queue.Empty:
                    pass
                    
            self.log_queue.put(log_entry)
        except Exception as e:
            print(f"Error in QueueHandler: {e}")

# Configure log format
log_formatter = logging.Formatter('%(message)s')

# Configure queue handler
queue_handler = QueueHandler(log_queue)
queue_handler.setFormatter(log_formatter)

# Configure console handler
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setFormatter(log_formatter)

# Configure Flask logger
app.logger.handlers = []
app.logger.addHandler(queue_handler)
app.logger.addHandler(console_handler)
app.logger.setLevel(logging.INFO)

# Werkzeug logger only outputs errors
werkzeug_logger = logging.getLogger('werkzeug')
werkzeug_logger.handlers = []
werkzeug_logger.addHandler(console_handler)
werkzeug_logger.setLevel(logging.WARNING)

# Language code mappings
LANGUAGE_CODES = {
    'English': 'en',
    'English (Auto-generated)': 'en',
    'Simplified Chinese': 'zh-Hans',
    'Simplified Chinese (Auto-generated)': 'zh-Hans',
    'Traditional Chinese': 'zh-Hant',
    'Traditional Chinese (Auto-generated)': 'zh-Hant'
}

def get_language_display(lang):
    lang_map = {
        'en': 'English',
        'zh': 'Chinese',
        'zh-Hans': 'Simplified Chinese',
        'zh-Hant': 'Traditional Chinese',
        'zh-CN': 'Simplified Chinese',
        'zh-TW': 'Traditional Chinese'
    }
    return lang_map.get(lang, lang)

def get_video_info(url):
    """Get video information including available formats and subtitles"""
    ydl_opts = {
        'quiet': True,
        'no_warnings': True,
        'format': None,
        'youtube_include_dash_manifest': True,
        'writesubtitles': True,
        'allsubtitles': True,
        'writeautomaticsub': True,
        'format_sort': [
            'res:2160',
            'res:1440',
            'res:1080',
            'res:720',
            'res:480',
            'fps:60',
            'fps',
            'vcodec:h264',
            'vcodec:vp9',
            'acodec'
        ]
    }
    
    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
        try:
            info = ydl.extract_info(url, download=False)
            formats = []
            
            def safe_number(value, default=0):
                try:
                    return float(value or default)
                except (TypeError, ValueError):
                    return default

            # Process video formats
            for f in info.get('formats', []):
                vcodec = f.get('vcodec', 'none')
                acodec = f.get('acodec', 'none')
                has_video = vcodec != 'none'
                has_audio = acodec != 'none'
                
                height = safe_number(f.get('height', 0))
                width = safe_number(f.get('width', 0))
                fps = safe_number(f.get('fps', 0))
                tbr = safe_number(f.get('tbr', 0))
                
                if has_video:
                    format_notes = []
                    
                    if height >= 2160:
                        format_notes.append("4K")
                    elif height >= 1440:
                        format_notes.append("2K")
                    
                    if height and width:
                        format_notes.append(f"{width:.0f}x{height:.0f}p")
                    
                    if fps > 0:
                        format_notes.append(f"{fps:.0f}fps")
                    
                    if vcodec != 'none':
                        codec_name = {
                            'avc1': 'H.264',
                            'vp9': 'VP9',
                            'av01': 'AV1'
                        }.get(vcodec.split('.')[0], vcodec)
                        format_notes.append(f"Video: {codec_name}")
                    
                    if tbr > 0:
                        format_notes.append(f"{tbr:.0f}kbps")
                    
                    if has_audio and acodec != 'none':
                        format_notes.append(f"Audio: {acodec}")
                    
                    format_data = {
                        'format_id': f.get('format_id', ''),
                        'ext': f.get('ext', ''),
                        'filesize': f.get('filesize', 0),
                        'format_note': ' - '.join(format_notes),
                        'vcodec': vcodec,
                        'acodec': acodec,
                        'height': height,
                        'width': width,
                        'fps': fps,
                        'resolution_sort': height * 1000 + fps
                    }
                    
                    if format_data['format_id']:
                        formats.append(format_data)
            
            formats.sort(key=lambda x: x['resolution_sort'], reverse=True)
            
            seen_resolutions = set()
            unique_formats = []
            for fmt in formats:
                res_key = f"{fmt['height']:.0f}p-{fmt['fps']:.0f}fps"
                if res_key not in seen_resolutions:
                    seen_resolutions.add(res_key)
                    unique_formats.append(fmt)

            # Process subtitles
            subtitles = []
            seen_languages = set()
            allowed_languages = {'en', 'zh', 'zh-Hans', 'zh-Hant', 'zh-CN', 'zh-TW'}
            
            # Process regular subtitles
            for lang, subs in info.get('subtitles', {}).items():
                if lang in allowed_languages:
                    display_lang = get_language_display(lang)
                    if display_lang not in seen_languages:
                        seen_languages.add(display_lang)
                        if subs:
                            subtitles.append({
                                'language': display_lang,
                                'language_code': lang,
                                'format': subs[0].get('ext', ''),
                                'url': subs[0].get('url', ''),
                                'auto_generated': False
                            })
            
            # Process auto-generated subtitles
            f