feat: add YouTube to MP3 downloader with playlist support

Dockerfile

@@ -3,6 +3,8 @@
 
 FROM python:3.9
 
+RUN apt-get update && apt-get install -y ffmpeg && rm -rf /var/lib/apt/lists/*
+
 RUN useradd -m -u 1000 user
 USER user
 ENV PATH="/home/user/.local/bin:$PATH"

app.py

@@ -0,0 +1,142 @@
+import os
+import json
+import uuid
+import zipfile
+import threading
+import time
+from flask import Flask, request, jsonify, send_file
+from yt_dlp import YoutubeDL
+
+app = Flask(__name__)
+
+TASKS_DIR = "tasks"
+if not os.path.exists(TASKS_DIR):
+    os.makedirs(TASKS_DIR)
+
+
+def download_youtube(url, task_id):
+    task_file = os.path.join(TASKS_DIR, f"{task_id}.json")
+
+    def update_status(status, progress=None, total=None, error=None):
+        with open(task_file, "w") as f:
+            json.dump(
+                {
+                    "status": status,
+                    "progress": progress,
+                    "total": total,
+                    "error": error,
+                    "url": url,
+                },
+                f,
+            )
+
+    try:
+        ydl_opts = {
+            "format": "bestaudio/best",
+            "outtmpl": os.path.join(TASKS_DIR, f"{task_id}/%(title)s.%(ext)s"),
+            "postprocessors": [
+                {
+                    "key": "FFmpegExtractAudio",
+                    "preferredcodec": "mp3",
+                    "preferredquality": "192",
+                }
+            ],
+            "quiet": True,
+            "no_warnings": True,
+            "extract_flat": "in_playlist",
+            "max_downloads": 50,
+        }
+
+        update_status("analyzing")
+
+        with YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=False)
+
+            if "entries" in info:
+                total = len(info["entries"][:50])
+                update_status("downloading", progress=0, total=total)
+
+                for idx, entry in enumerate(info["entries"][:50]):
+                    video_url = entry["url"]
+                    video_opts = ydl_opts.copy()
+                    video_opts["outtmpl"] = os.path.join(
+                        TASKS_DIR, f"{task_id}/%(title)s.%(ext)s"
+                    )
+
+                    with YoutubeDL(video_opts) as video_ydl:
+                        video_ydl.download([video_url])
+
+                    update_status("downloading", progress=idx + 1, total=total)
+            else:
+                update_status("downloading", progress=1, total=1)
+                ydl_opts["outtmpl"] = os.path.join(
+                    TASKS_DIR, f"{task_id}/%(title)s.%(ext)s"
+                )
+                with YoutubeDL(ydl_opts) as ydl_single:
+                    ydl_single.download([url])
+
+        zip_path = os.path.join(TASKS_DIR, f"{task_id}.zip")
+        with zipfile.ZipFile(zip_path, "w") as zipf:
+            for root, dirs, files in os.walk(os.path.join(TASKS_DIR, task_id)):
+                for file in files:
+                    if file.endswith(".mp3"):
+                        file_path = os.path.join(root, file)
+                        arcname = file
+                        zipf.write(file_path, arcname)
+
+        update_status("completed")
+
+    except Exception as e:
+        update_status("error", error=str(e))
+
+
+@app.route("/download", methods=["POST"])
+def start_download():
+    data = request.get_json()
+    url = data.get("url")
+
+    if not url:
+        return jsonify({"error": "URL required"}), 400
+
+    task_id = str(uuid.uuid4())
+    os.makedirs(os.path.join(TASKS_DIR, task_id), exist_ok=True)
+
+    thread = threading.Thread(target=download_youtube, args=(url, task_id))
+    thread.start()
+
+    return jsonify({"task_id": task_id})
+
+
+@app.route("/status/<task_id>", methods=["GET"])
+def get_status(task_id):
+    task_file = os.path.join(TASKS_DIR, f"{task_id}.json")
+
+    if not os.path.exists(task_file):
+        return jsonify({"error": "Task not found"}), 404
+
+    with open(task_file, "r") as f:
+        data = json.load(f)
+
+    return jsonify(data)
+
+
+@app.route("/download/<task_id>", methods=["GET"])
+def download_zip(task_id):
+    task_file = os.path.join(TASKS_DIR, f"{task_id}.json")
+
+    if not os.path.exists(task_file):
+        return jsonify({"error": "Task not found"}), 404
+
+    with open(task_file, "r") as f:
+        data = json.load(f)
+
+    if data["status"] != "completed":
+        return jsonify({"error": "Download not completed"}), 400
+
+    zip_path = os.path.join(TASKS_DIR, f"{task_id}.zip")
+
+    return send_file(zip_path, as_attachment=True, download_name="youtube_mp3.zip")
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860)

index.html

@@ -0,0 +1,218 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>YouTube to MP3</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            max-width: 600px;
+            margin: 50px auto;
+            padding: 20px;
+            background: #f5f5f5;
+        }
+        .container {
+            background: white;
+            padding: 30px;
+            border-radius: 10px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+        }
+        h1 {
+            color: #333;
+            margin-bottom: 30px;
+        }
+        input[type="url"] {
+            width: 100%;
+            padding: 12px;
+            border: 1px solid #ddd;
+            border-radius: 5px;
+            margin-bottom: 15px;
+            box-sizing: border-box;
+        }
+        button {
+            background: #ff0000;
+            color: white;
+            padding: 12px 30px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 16px;
+            width: 100%;
+        }
+        button:hover {
+            background: #cc0000;
+        }
+        button:disabled {
+            background: #ccc;
+            cursor: not-allowed;
+        }
+        #status {
+            margin-top: 20px;
+            padding: 15px;
+            border-radius: 5px;
+            display: none;
+        }
+        .analyzing { background: #fff3cd; }
+        .downloading { background: #d1ecf1; }
+        .completed { background: #d4edda; }
+        .error { background: #f8d7da; }
+        #progress {
+            margin-top: 10px;
+            font-weight: bold;
+        }
+        .task-list {
+            margin-top: 30px;
+        }
+        .task-item {
+            background: #f9f9f9;
+            padding: 15px;
+            border-radius: 5px;
+            margin-bottom: 10px;
+            cursor: pointer;
+        }
+        .task-item:hover {
+            background: #eee;
+        }
+        .task-url {
+            font-size: 14px;
+            color: #666;
+            margin-bottom: 5px;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+        .task-status {
+            font-weight: bold;
+            margin-bottom: 5px;
+        }
+        .task-completed { color: #28a745; }
+        .task-downloading { color: #17a2b8; }
+        .task-error { color: #dc3545; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🎵 YouTube to MP3</h1>
+        <p>Entrez une URL YouTube (vidéo ou playlist)</p>
+        
+        <input type="url" id="urlInput" placeholder="https://www.youtube.com/watch?v=..." />
+        <button onclick="startDownload()">Télécharger</button>
+        
+        <div id="status"></div>
+        <div id="progress"></div>
+        
+        <div class="task-list">
+            <h3>Tâches récentes</h3>
+            <div id="tasksList"></div>
+        </div>
+    </div>
+
+    <script>
+        let currentTaskId = null;
+        let tasks = JSON.parse(localStorage.getItem('tasks') || '[]');
+
+        function saveTasks() {
+            localStorage.setItem('tasks', JSON.stringify(tasks));
+        }
+
+        function renderTasks() {
+            const list = document.getElementById('tasksList');
+            list.innerHTML = '';
+            
+            tasks.slice().reverse().forEach(task => {
+                const div = document.createElement('div');
+                div.className = 'task-item';
+                div.onclick = () => checkStatus(task.id);
+                
+                let statusClass = '';
+                let statusText = '';
+                
+                if (task.status === 'completed') {
+                    statusClass = 'task-completed';
+                    statusText = '✓ Terminé';
+                } else if (task.status === 'downloading' || task.status === 'analyzing') {
+                    statusClass = 'task-downloading';
+                    statusText = `⏳ ${task.progress}/${task.total}`;
+                } else if (task.status === 'error') {
+                    statusClass = 'task-error';
+                    statusText = '✗ Erreur';
+                }
+                
+                div.innerHTML = `
+                    <div class="task-status ${statusClass}">${statusText}</div>
+                    <div class="task-url">${task.url}</div>
+                `;
+                list.appendChild(div);
+            });
+        }
+
+        async function startDownload() {
+            const url = document.getElementById('urlInput').value;
+            
+            if (!url) {
+                alert('Veuillez entrer une URL');
+                return;
+            }
+
+            const response = await fetch('/download', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ url })
+            });
+
+            const data = await response.json();
+            
+            if (data.error) {
+                alert(data.error);
+                return;
+            }
+
+            currentTaskId = data.task_id;
+            tasks.push({ id: currentTaskId, url: url, status: 'analyzing', progress: 0, total: 0 });
+            saveTasks();
+            renderTasks();
+            
+            checkStatus(currentTaskId);
+        }
+
+        async function checkStatus(taskId) {
+            currentTaskId = taskId;
+            const response = await fetch(`/status/${taskId}`);
+            const data = await response.json();
+
+            const statusDiv = document.getElementById('status');
+            const progressDiv = document.getElementById('progress');
+
+            statusDiv.style.display = 'block';
+            statusDiv.className = data.status;
+
+            if (data.status === 'analyzing') {
+                statusDiv.textContent = '📊 Analyse de la playlist...';
+            } else if (data.status === 'downloading') {
+                statusDiv.textContent = '📥 Téléchargement en cours...';
+                progressDiv.textContent = `${data.progress}/${data.total} vidéos`;
+            } else if (data.status === 'completed') {
+                statusDiv.textContent = '✅ Téléchargement terminé!';
+                progressDiv.innerHTML = `<a href="/download/${taskId}" style="color: #007bff;">📦 Télécharger le ZIP</a>`;
+            } else if (data.status === 'error') {
+                statusDiv.textContent = '❌ Erreur: ' + data.error;
+                progressDiv.textContent = '';
+            }
+
+            const taskIndex = tasks.findIndex(t => t.id === taskId);
+            if (taskIndex !== -1) {
+                tasks[taskIndex] = { ...tasks[taskIndex], status: data.status, progress: data.progress, total: data.total };
+                saveTasks();
+                renderTasks();
+            }
+
+            if (data.status === 'downloading' || data.status === 'analyzing') {
+                setTimeout(() => checkStatus(taskId), 2000);
+            }
+        }
+
+        renderTasks();
+    </script>
+</body>
+</html>

requirements.txt

@@ -0,0 +1,3 @@
+flask
+yt-dlp
+ffmpeg-python