ready for deployment

Dockerfile

@@ -0,0 +1,27 @@
+# Use a lightweight Python image
+FROM python:3.11-slim
+
+# Install ffmpeg (needed by yt-dlp)
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install dependencies
+# Ensure gunicorn and gevent are included in your requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY . .
+
+# Expose the port Gunicorn will run on. Render's default is 10000.
+EXPOSE 10000
+
+# Start the Flask app using Gunicorn with the gevent worker and a longer timeout
+# This prevents the worker from timing out during long downloads.
+CMD ["gunicorn", "--worker-class", "gevent", "--timeout", "3600", "--bind", "0.0.0.0:10000", "app:app"]

app.py

@@ -0,0 +1,348 @@
+import os
+import json
+import time
+import logging
+import tempfile
+import yt_dlp
+from flask import Flask, Response, render_template, request
+from werkzeug.utils import secure_filename
+from threading import Thread, Lock
+import uuid
+
+app = Flask(__name__)
+
+# --- Configuration ---
+
+def get_temp_download_path():
+    render_disk_path = os.environ.get('RENDER_DISK_PATH')
+    if render_disk_path:
+        base_path = render_disk_path
+    else:
+        base_path = tempfile.gettempdir()
+    
+    temp_folder = os.path.join(base_path, 'yt_temp_downloads')
+    return temp_folder
+
+DOWNLOAD_FOLDER = get_temp_download_path()
+COOKIE_FILE = "cookies.txt"
+
+logging.basicConfig(level=logging.INFO)
+os.makedirs(DOWNLOAD_FOLDER, exist_ok=True)
+
+# Progress storage with thread safety
+progress_data = {}
+progress_lock = Lock()
+
+def update_progress(task_id, status, progress=0, **kwargs):
+    """Update progress data thread-safely"""
+    with progress_lock:
+        progress_data[task_id] = {
+            'status': status,
+            'progress': float(progress),
+            'timestamp': time.time(),
+            **kwargs
+        }
+        app.logger.info(f"PROGRESS: {task_id} -> {status} ({progress}%)")
+
+# Global variable to hold current task_id for progress hook
+current_download_task = None
+
+def create_progress_hook(task_id):
+    """Create a progress hook that captures the task_id in closure"""
+    def progress_hook(d):
+        try:
+            if d['status'] == 'downloading':
+                total_bytes = d.get('total_bytes') or d.get('total_bytes_est', 0)
+                downloaded_bytes = d.get('downloaded_bytes', 0)
+                speed = d.get('speed', 0)
+                eta = d.get('eta', 0)
+                
+                if total_bytes > 0:
+                    percent = (downloaded_bytes / total_bytes) * 100
+                    # Don't let it reach 100% until actually finished
+                    percent = min(99.9, percent)
+                else:
+                    # If we don't have total size, estimate based on downloaded amount
+                    # This is a fallback for cases where total size is unknown
+                    percent = min(50, downloaded_bytes / (1024 * 1024))  # Rough estimate
+                
+                speed_mbps = (speed / (1024 * 1024)) if speed else 0
+                
+                update_progress(
+                    task_id,
+                    'downloading',
+                    percent,
+                    eta=int(eta) if eta else 0,
+                    speed=f"{speed_mbps:.2f} MB/s",
+                    downloaded_mb=downloaded_bytes / (1024 * 1024),
+                    total_mb=total_bytes / (1024 * 1024) if total_bytes else 0
+                )
+                
+            elif d['status'] == 'finished':
+                update_progress(task_id, 'processing', 100)
+                
+        except Exception as e:
+            app.logger.error(f"Progress hook error for {task_id}: {e}")
+    
+    return progress_hook
+
+def download_worker(url, format_choice, task_id):
+    """Download worker function"""
+    global current_download_task
+    current_download_task = task_id
+    
+    try:
+        # Step 1: Initialize
+        update_progress(task_id, 'initializing', 5)
+        time.sleep(0.5)
+        
+        # Step 2: Get video info
+        update_progress(task_id, 'fetching_info', 10)
+        info_opts = {
+            'quiet': True,
+            'no_warnings': True,
+            'cookiefile': COOKIE_FILE if os.path.exists(COOKIE_FILE) else None
+        }
+        
+        with yt_dlp.YoutubeDL(info_opts) as ydl:
+            info = ydl.extract_info(url, download=False)
+            clean_title = secure_filename(info.get('title', 'video'))
+            app.logger.info(f"Video title: {clean_title}")
+        
+        # Step 3: Prepare download
+        update_progress(task_id, 'preparing', 15)
+        time.sleep(0.5)
+        
+        # Configure download options
+        timestamp = int(time.time())
+        audio_formats = {"mp3", "m4a", "webm", "aac", "flac", "opus", "ogg", "wav"}
+        
+        if format_choice in audio_formats:
+            unique_name = f"{clean_title}_{timestamp}"
+            final_filename = f"{unique_name}.{format_choice}"
+            ydl_opts = {
+                'format': 'bestaudio/best',
+                'postprocessors': [{
+                    'key': 'FFmpegExtractAudio',
+                    'preferredcodec': format_choice,
+                    'preferredquality': '192',
+                }]
+            }
+        elif format_choice in ["1080", "720", "480", "360", "1440"]:
+            res = int(format_choice)
+            unique_name = f"{clean_title}_{res}p_{timestamp}"
+            final_filename = f"{unique_name}.mp4"
+            ydl_opts = {
+                'format': f'bestvideo[height<={res}]+bestaudio/best[height<={res}]',
+                'merge_output_format': 'mp4'
+            }
+        else:
+            raise ValueError(f"Invalid format: {format_choice}")
+        
+        # Create progress hook with task_id captured in closure
+        progress_hook = create_progress_hook(task_id)
+        
+        # Set common options
+        ydl_opts.update({
+            'outtmpl': os.path.join(DOWNLOAD_FOLDER, f"{unique_name}.%(ext)s"),
+            'progress_hooks': [progress_hook],
+            'quiet': True,
+            'no_warnings': True,
+            'cookiefile': COOKIE_FILE if os.path.exists(COOKIE_FILE) else None
+        })
+        
+        expected_path = os.path.join(DOWNLOAD_FOLDER, final_filename)
+        
+        # Step 4: Start download
+        update_progress(task_id, 'starting_download', 20)
+        time.sleep(0.5)
+        
+        app.logger.info(f"Starting yt-dlp download for {task_id}")
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([url])
+        
+        app.logger.info(f"yt-dlp download completed for {task_id}")
+        
+        # Step 5: Find the downloaded file
+        actual_filename = final_filename
+        if not os.path.exists(expected_path):
+            # Look for any file with the base name
+            base_name = unique_name
+            found_files = []
+            
+            for filename in os.listdir(DOWNLOAD_FOLDER):
+                if filename.startswith(base_name) and not filename.endswith('.part'):
+                    found_files.append(filename)
+            
+            if found_files:
+                # Use the most recent file
+                found_files.sort(key=lambda x: os.path.getctime(os.path.join(DOWNLOAD_FOLDER, x)), reverse=True)
+                actual_filename = found_files[0]
+                expected_path = os.path.join(DOWNLOAD_FOLDER, actual_filename)
+                app.logger.info(f"Found downloaded file: {actual_filename}")
+        
+        # Verify file exists and isn't empty
+        if not os.path.exists(expected_path):
+            raise FileNotFoundError(f"Download completed but file not found: {actual_filename}")
+        
+        file_size = os.path.getsize(expected_path)
+        if file_size == 0:
+            raise ValueError("Downloaded file is empty")
+            
+        app.logger.info(f"File verified: {actual_filename} ({file_size} bytes)")
+        
+        # Step 6: Complete
+        update_progress(task_id, 'complete', 100, filename=actual_filename)
+        
+    except Exception as e:
+        error_msg = str(e)
+        app.logger.error(f"Download error for {task_id}: {error_msg}")
+        update_progress(task_id, 'error', 0, message=error_msg)
+        
+        # Cleanup on error
+        try:
+            if 'expected_path' in locals() and os.path.exists(expected_path):
+                os.remove(expected_path)
+                app.logger.info(f"Cleaned up failed download: {expected_path}")
+        except Exception as cleanup_error:
+            app.logger.error(f"Cleanup error: {cleanup_error}")
+    
+    finally:
+        # Clear global task reference
+        if current_download_task == task_id:
+            current_download_task = None
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/stream-download', methods=['GET'])
+def stream_download():
+    url = request.args.get('url')
+    format_choice = request.args.get('format')
+    
+    if not url or not format_choice:
+        return Response(
+            json.dumps({"error": "Missing parameters"}),
+            status=400,
+            mimetype='application/json'
+        )
+    
+    task_id = str(uuid.uuid4())
+    app.logger.info(f"New download request: {task_id} - {url} - {format_choice}")
+    
+    # Initialize progress
+    update_progress(task_id, 'waiting', 0)
+    
+    # Start download thread
+    thread = Thread(target=download_worker, args=(url, format_choice, task_id))
+    thread.daemon = True
+    thread.start()
+    
+    def generate():
+        try:
+            start_time = time.time()
+            timeout = 1800  # 30 minutes
+            
+            while True:
+                # Check timeout
+                if time.time() - start_time > timeout:
+                    update_progress(task_id, 'error', 0, message='Download timeout')
+                    break
+                
+                # Get current progress
+                with progress_lock:
+                    data = progress_data.get(task_id, {
+                        'status': 'waiting',
+                        'progress': 0,
+                        'timestamp': time.time()
+                    })
+                
+                # Send data
+                json_data = json.dumps(data)
+                yield f"data: {json_data}\n\n"
+                
+                # Check if finished
+                if data.get('status') in ['complete', 'error']:
+                    break
+                
+                time.sleep(0.5)
+                
+        except GeneratorExit:
+            app.logger.info(f"Client disconnected: {task_id}")
+        except Exception as e:
+            app.logger.error(f"Stream error for {task_id}: {e}")
+        finally:
+            # Cleanup after delay
+            def cleanup():
+                time.sleep(30)
+                with progress_lock:
+                    if task_id in progress_data:
+                        del progress_data[task_id]
+                        app.logger.info(f"Cleaned up progress data for {task_id}")
+            
+            Thread(target=cleanup, daemon=True).start()
+    
+    response = Response(generate(), mimetype='text/event-stream')
+    response.headers.update({
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+        'X-Accel-Buffering': 'no'
+    })
+    
+    return response
+
+@app.route('/download-file/<filename>')
+def download_file(filename):
+    safe_folder = os.path.abspath(DOWNLOAD_FOLDER)
+    filepath = os.path.join(safe_folder, filename)
+    
+    # Security check
+    if not os.path.abspath(filepath).startswith(safe_folder):
+        return "Forbidden", 403
+    
+    if not os.path.exists(filepath):
+        return "File not found", 404
+    
+    def generate_and_cleanup():
+        try:
+            app.logger.info(f"Serving file: {filename}")
+            with open(filepath, 'rb') as f:
+                while True:
+                    chunk = f.read(8192)
+                    if not chunk:
+                        break
+                    yield chunk
+        finally:
+            # Remove file after download
+            def remove_file():
+                time.sleep(2)
+                try:
+                    if os.path.exists(filepath):
+                        os.remove(filepath)
+                        app.logger.info(f"Cleaned up file: {filename}")
+                except Exception as e:
+                    app.logger.error(f"Error removing file {filename}: {e}")
+            
+            Thread(target=remove_file, daemon=True).start()
+    
+    return Response(
+        generate_and_cleanup(),
+        headers={
+            'Content-Disposition': f'attachment; filename="{filename}"',
+            'Content-Type': 'application/octet-stream'
+        }
+    )
+
+@app.route('/health')
+def health_check():
+    return {
+        "status": "healthy", 
+        "active_downloads": len(progress_data),
+        "current_task": current_download_task
+    }
+
+if __name__ == "__main__":
+    app.run(debug=True, threaded=True, host='0.0.0.0', port=5000)

cookies.txt

@@ -0,0 +1,15 @@
+# Netscape HTTP Cookie File
+# This file is generated by yt-dlp.  Do not edit.
+
+.vimeo.com	TRUE	/	TRUE	2073814202	has_uploaded	1
+.vimeo.com	TRUE	/	TRUE	2073814202	language	en
+.vimeo.com	TRUE	/	TRUE	1793014133	_ga	GA1.2.1668146364.1758217509
+.vimeo.com	TRUE	/	TRUE	1758540533	_gid	GA1.2.1612255520.1758454116
+.vimeo.com	TRUE	/	TRUE	1761046202	vimeo	OHDdZDLXZ4eMVHLZetdedLLPMNVHLZetdedD4LMxH3cdXcSDc%2CDZDZLNeNLtPPXdNDXX%2CdN%2CBDXZdcXPdM%2Cu9Y_%2CBHLMIHX3XZNt%2CtBtPed%2CLea%2C%2CtBSSPN3Ne%2C3D34Za4ZXeXc4tLdece43D3SBN4dDLeDctL
+.vimeo.com	TRUE	/	TRUE	1758456002	__cf_bm	AiUWyZ8xP90NXJIWLGw3uMotSc1YBk3pt40v1Tfz_wk-1758454202-1.0.1.1-Z1X7MnPMKmDwNbqjqwLVQcbQ9um8lSG051Kn8g5ardtNa5PTJCg8Q7IJrdCwaVqA
+.vimeo.com	TRUE	/	TRUE	1793014120	joined_with_existing_account	1
+.vimeo.com	TRUE	/	TRUE	1759058920	vimeo_cart	%7B%22stock%22%3A%7B%22store%22%3A%22stock%22%2C%22version%22%3A1%2C%22quantities%22%3A%5B%5D%2C%22items%22%3A%5B%5D%2C%22attributes%22%3A%5B%5D%2C%22currency%22%3A%22USD%22%2C%22items_sorted_by_index%22%3A%5B%5D%2C%22items_count%22%3A0%7D%7D
+.vimeo.com	TRUE	/	TRUE	2073814202	vuid	pl1830665756.1005461139
+.vimeo.com	TRUE	/	TRUE	0	_cfuvid	oIXli2u39Hrkua_Kvsi6nW8D6zi6XxCs_Ur5_S6hFWw-1758454202238-0.0.1.1-604800000
+.vimeo.com	TRUE	/	TRUE	1758457720	auth_xsrft	825d15e45c76dc9ab63cfdb1a9930938ec4d7fc0
+vimeo.com	FALSE	/	TRUE	1758455909	builderSessionId	8ba56e98cc724a928dc442bf9beeee26

requirements.txt

@@ -0,0 +1,6 @@
+yt-dlp
+flask
+brotli 
+certifi
+gunicorn
+gevent

templates/index.html

@@ -0,0 +1,310 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vimeo Downloader</title>
+    <style>
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,
+          Helvetica, Arial, sans-serif;
+        background-color: #f0f2f5;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        min-height: 100vh;
+        margin: 0;
+        padding: 1rem;
+        box-sizing: border-box;
+      }
+      .container {
+        background: white;
+        padding: 2rem 2.5rem;
+        border-radius: 8px;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        width: 100%;
+        max-width: 500px;
+      }
+      h1 {
+        font-size: 1.75rem;
+        color: #1c1e21;
+        margin: 0 0 1.5rem 0;
+        text-align: center;
+      }
+      .form-group {
+        margin-bottom: 1rem;
+      }
+      label {
+        display: block;
+        margin-bottom: 0.5rem;
+        font-weight: 600;
+        color: #606770;
+      }
+      input,
+      select,
+      button {
+        width: 100%;
+        padding: 0.75rem;
+        font-size: 1rem;
+        border-radius: 6px;
+        border: 1px solid #dddfe2;
+        box-sizing: border-box;
+      }
+      button {
+        background-color: #007bff;
+        color: white;
+        border: none;
+        cursor: pointer;
+        font-weight: bold;
+        transition: background-color 0.2s;
+      }
+      button:disabled {
+        background-color: #a0c9f8;
+        cursor: not-allowed;
+      }
+
+      #progress-container {
+        display: none;
+        margin-top: 1.5rem;
+      }
+      #progress-bar-wrapper {
+        width: 100%;
+        background-color: #e9ecef;
+        border-radius: 0.25rem;
+        overflow: hidden;
+        height: 30px;
+        border: 1px solid #ddd;
+      }
+      #progress-bar {
+        height: 100%;
+        background-color: #007bff;
+        color: white;
+        text-align: center;
+        line-height: 30px;
+        font-weight: bold;
+        transition: width 0.3s ease;
+        width: 0%;
+        min-width: 60px;
+      }
+      #status-text {
+        text-align: center;
+        margin-top: 0.75rem;
+        font-weight: 500;
+        color: #495057;
+        min-height: 20px;
+      }
+      #download-link-container {
+        text-align: center;
+        margin-top: 1rem;
+      }
+      #download-link-container a {
+        display: inline-block;
+        padding: 0.75rem 1.5rem;
+        background-color: #28a745;
+        color: white;
+        text-decoration: none;
+        border-radius: 6px;
+        font-weight: bold;
+      }
+      .debug {
+        font-size: 12px;
+        color: #666;
+        margin-top: 5px;
+        text-align: center;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>Vimeo Downloader</h1>
+      <form id="download-form">
+        <div class="form-group">
+          <label for="url">URL</label>
+          <input
+            type="text"
+            id="url"
+            name="url"
+            placeholder="Paste Vimeo URL here"
+            required
+          />
+        </div>
+        <div class="form-group">
+          <label for="format">Format</label>
+          <select id="format" name="format">
+            <optgroup label="Audio">
+              <option value="mp3" selected>MP3</option>
+              <option value="m4a">M4A</option>
+              <option value="flac">FLAC</option>
+              <option value="opus">OPUS</option>
+              <option value="wav">WAV</option>
+            </optgroup>
+            <optgroup label="Video">
+              <option value="1080">MP4 (1080p)</option>
+              <option value="720">MP4 (720p)</option>
+              <option value="480">MP4 (480p)</option>
+              <option value="360">MP4 (360p)</option>
+              <option value="1440">MP4 (1440p)</option>
+            </optgroup>
+          </select>
+        </div>
+        <button type="submit" id="download-button">Download</button>
+      </form>
+
+      <div id="progress-container">
+        <div id="progress-bar-wrapper">
+          <div id="progress-bar">0%</div>
+        </div>
+        <div id="status-text">Starting...</div>
+        <div id="debug-info" class="debug"></div>
+        <div id="download-link-container"></div>
+      </div>
+    </div>
+
+    <script>
+      const form = document.getElementById("download-form");
+      const button = document.getElementById("download-button");
+      const progressContainer = document.getElementById("progress-container");
+      const progressBar = document.getElementById("progress-bar");
+      const statusText = document.getElementById("status-text");
+      const debugInfo = document.getElementById("debug-info");
+      const downloadContainer = document.getElementById(
+        "download-link-container"
+      );
+
+      let eventSource;
+
+      form.addEventListener("submit", function (e) {
+        e.preventDefault();
+
+        // Reset UI
+        button.disabled = true;
+        button.textContent = "Downloading...";
+        progressContainer.style.display = "block";
+        downloadContainer.innerHTML = "";
+
+        // Reset progress bar
+        progressBar.style.width = "0%";
+        progressBar.textContent = "0%";
+        progressBar.style.backgroundColor = "#007bff";
+        statusText.textContent = "Connecting...";
+        debugInfo.textContent = "";
+
+        // Close existing connection
+        if (eventSource) {
+          eventSource.close();
+        }
+
+        // Build URL
+        const formData = new FormData(form);
+        const params = new URLSearchParams(formData);
+        const streamUrl = `/stream-download?${params}`;
+
+        console.log("Starting EventSource:", streamUrl);
+        eventSource = new EventSource(streamUrl);
+
+        eventSource.onopen = function (event) {
+          console.log("EventSource opened");
+          statusText.textContent = "Connected to server...";
+        };
+
+        eventSource.onmessage = function (event) {
+          try {
+            const data = JSON.parse(event.data);
+            console.log("Received:", data);
+
+            const progress = parseFloat(data.progress || 0);
+            const status = data.status || "unknown";
+
+            // Update debug info
+            debugInfo.textContent = `Status: ${status} | Progress: ${progress.toFixed(
+              1
+            )}%`;
+
+            // Update progress bar
+            progressBar.style.width = `${progress}%`;
+            progressBar.textContent = `${progress.toFixed(1)}%`;
+
+            // Update status and colors
+            switch (status) {
+              case "waiting":
+                statusText.textContent = "Waiting for server...";
+                progressBar.style.backgroundColor = "#6c757d";
+                break;
+              case "initializing":
+                statusText.textContent = "Initializing download...";
+                progressBar.style.backgroundColor = "#007bff";
+                break;
+              case "fetching_info":
+                statusText.textContent = "Fetching video information...";
+                progressBar.style.backgroundColor = "#007bff";
+                break;
+              case "preparing":
+                statusText.textContent = "Preparing download...";
+                progressBar.style.backgroundColor = "#007bff";
+                break;
+              case "starting_download":
+                statusText.textContent = "Starting download...";
+                progressBar.style.backgroundColor = "#007bff";
+                break;
+              case "downloading":
+                const eta = data.eta || 0;
+                const speed = data.speed || "0 MB/s";
+                statusText.textContent = `Downloading... ETA: ${eta}s at ${speed}`;
+                progressBar.style.backgroundColor = "#007bff";
+                break;
+              case "processing":
+                statusText.textContent = "Processing file...";
+                progressBar.style.backgroundColor = "#ffc107";
+                progressBar.textContent = "Processing...";
+                break;
+              case "complete":
+                statusText.textContent = "Download Complete!";
+                progressBar.style.backgroundColor = "#28a745";
+                progressBar.textContent = "Done!";
+
+                if (data.filename) {
+                  downloadContainer.innerHTML = `<a href="/download-file/${data.filename}" download>Click to Save File</a>`;
+                }
+
+                eventSource.close();
+                resetButton();
+                break;
+              case "error":
+                const errorMsg = data.message || "Download failed";
+                statusText.textContent = `Error: ${errorMsg}`;
+                progressBar.style.backgroundColor = "#dc3545";
+                progressBar.textContent = "Error!";
+
+                eventSource.close();
+                resetButton();
+                break;
+            }
+          } catch (err) {
+            console.error("Error parsing message:", err, event.data);
+            statusText.textContent = "Error processing server response";
+            resetButton();
+          }
+        };
+
+        eventSource.onerror = function (event) {
+          console.error("EventSource error:", event);
+          statusText.textContent = "Connection error. Please try again.";
+          eventSource.close();
+          resetButton();
+        };
+      });
+
+      function resetButton() {
+        button.disabled = false;
+        button.textContent = "Download";
+      }
+
+      // Cleanup on page unload
+      window.addEventListener("beforeunload", function () {
+        if (eventSource) {
+          eventSource.close();
+        }
+      });
+    </script>
+  </body>
+</html>