Upload 3 files

Dockerfile

@@ -10,11 +10,12 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
 # Set work directory
 WORKDIR /app
 
-# Install system dependencies
+# Install system dependencies including additional tools for anti-detection
 RUN apt-get update && apt-get install -y \
     ffmpeg \
     curl \
     wget \
+    ca-certificates \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements first for better caching
@@ -27,7 +28,7 @@ RUN pip install --no-cache-dir --upgrade pip && \
 # Copy application code
 COPY . .
 
-# Create downloads directory
+# Create downloads directory with proper permissions
 RUN mkdir -p /tmp/downloads && \
     chmod 755 /tmp/downloads
 
@@ -42,8 +43,8 @@ USER app
 # Expose port
 EXPOSE 7860
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+# Health check with longer timeout for anti-detection measures
+HEALTHCHECK --interval=60s --timeout=60s --start-period=10s --retries=3 \
     CMD curl -f http://localhost:7860/health || exit 1
 
 # Run the application

main.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-FastAPI YouTube Video Downloader for Hugging Face Spaces
-A modern API service for downloading YouTube videos without cookies
+Enhanced FastAPI YouTube Video Downloader with Anti-Bot Measures
+Implements strategies to bypass YouTube's rate limiting and bot detection
 """
 
 import os
@@ -9,17 +9,17 @@ import sys
 import subprocess
 import json
 import tempfile
-import shutil
+import random
+import time
+import asyncio
 import logging
 from pathlib import Path
 from typing import Optional, Dict, Any, List
 from datetime import datetime
-import asyncio
 from concurrent.futures import ThreadPoolExecutor
 
-from fastapi import FastAPI, HTTPException, BackgroundTasks, UploadFile, File
+from fastapi import FastAPI, HTTPException, BackgroundTasks, Request
 from fastapi.responses import FileResponse, HTMLResponse
-from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, HttpUrl
 import uvicorn
@@ -28,7 +28,7 @@ import uvicorn
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Pydantic models for request/response
+# Pydantic models
 class VideoInfoRequest(BaseModel):
     url: HttpUrl
     
@@ -61,12 +61,13 @@ class HealthResponse(BaseModel):
     status: str
     yt_dlp_available: bool
     timestamp: str
+    strategies_enabled: List[str]
 
 # Initialize FastAPI app
 app = FastAPI(
-    title="YouTube Video Downloader",
-    description="Download YouTube videos without cookies using yt-dlp",
-    version="1.0.0",
+    title="Enhanced YouTube Video Downloader",
+    description="Download YouTube videos with anti-bot measures and rate limiting bypass",
+    version="2.0.0",
     docs_url="/docs",
     redoc_url="/redoc"
 )
@@ -81,22 +82,91 @@ app.add_middleware(
 )
 
 # Thread pool for background tasks
-executor = ThreadPoolExecutor(max_workers=3)
+executor = ThreadPoolExecutor(max_workers=2)  # Reduced to avoid overwhelming YouTube
 
-class YouTubeDownloader:
-    """
-    A class to download YouTube videos without cookies using yt-dlp
-    """
+class AntiDetectionManager:
+    """Manages anti-detection strategies for YouTube downloading"""
     
-    def __init__(self, download_dir: str = None):
-        """
-        Initialize the YouTube downloader
+    def __init__(self):
+        self.user_agents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0',
+            'Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edge/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15'
+        ]
+        
+        self.sleep_intervals = [1, 2, 3, 5]  # Random sleep intervals
+        self.last_request_time = 0
+        self.request_count = 0
+        self.max_requests_per_minute = 10
+        
+    def get_random_user_agent(self) -> str:
+        """Get a random user agent"""
+        return random.choice(self.user_agents)
+    
+    def get_sleep_interval(self) -> int:
+        """Get a random sleep interval"""
+        return random.choice(self.sleep_intervals)
+    
+    def should_rate_limit(self) -> bool:
+        """Check if we should rate limit requests"""
+        current_time = time.time()
+        
+        # Reset counter every minute
+        if current_time - self.last_request_time > 60:
+            self.request_count = 0
+            self.last_request_time = current_time
+        
+        self.request_count += 1
+        
+        # Rate limit if too many requests
+        if self.request_count > self.max_requests_per_minute:
+            return True
+        
+        return False
+    
+    def get_enhanced_command(self, base_cmd: List[str]) -> List[str]:
+        """Enhance yt-dlp command with anti-detection measures"""
+        enhanced_cmd = base_cmd.copy()
+        
+        # Add user agent
+        enhanced_cmd.extend(['--user-agent', self.get_random_user_agent()])
+        
+        # Add sleep interval
+        enhanced_cmd.extend(['--sleep-interval', str(self.get_sleep_interval())])
+        
+        # Add retry options
+        enhanced_cmd.extend(['--retries', '3'])
+        enhanced_cmd.extend(['--fragment-retries', '3'])
+        
+        # Add socket timeout
+        enhanced_cmd.extend(['--socket-timeout', '30'])
         
-        Args:
-            download_dir: Directory to save downloaded videos
-        """
+        # Disable certificate checking (sometimes helps)
+        enhanced_cmd.extend(['--no-check-certificates'])
+        
+        # Add geo bypass
+        enhanced_cmd.extend(['--geo-bypass'])
+        
+        # Add additional headers to look more like a browser
+        enhanced_cmd.extend(['--add-header', 'Accept:text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'])
+        enhanced_cmd.extend(['--add-header', 'Accept-Language:en-US,en;q=0.5'])
+        enhanced_cmd.extend(['--add-header', 'Accept-Encoding:gzip, deflate'])
+        enhanced_cmd.extend(['--add-header', 'DNT:1'])
+        enhanced_cmd.extend(['--add-header', 'Connection:keep-alive'])
+        enhanced_cmd.extend(['--add-header', 'Upgrade-Insecure-Requests:1'])
+        
+        return enhanced_cmd
+
+class EnhancedYouTubeDownloader:
+    """Enhanced YouTube downloader with anti-detection measures"""
+    
+    def __init__(self, download_dir: str = None):
         if download_dir is None:
-            # Use persistent storage if available, otherwise temp
             if os.path.exists('/data'):
                 download_dir = '/data/downloads'
             else:
@@ -104,6 +174,7 @@ class YouTubeDownloader:
         
         self.download_dir = Path(download_dir)
         self.download_dir.mkdir(parents=True, exist_ok=True)
+        self.anti_detection = AntiDetectionManager()
         
         # Ensure yt-dlp is available
         self._ensure_ytdlp_available()
@@ -124,18 +195,17 @@ class YouTubeDownloader:
                 logger.error(f"Failed to install yt-dlp: {e}")
                 raise RuntimeError("Could not install yt-dlp")
     
-    def get_video_info(self, url: str) -> Optional[Dict[str, Any]]:
-        """
-        Get video information without downloading
+    def get_video_info(self, url: str, retry_count: int = 0) -> Optional[Dict[str, Any]]:
+        """Get video information with anti-detection measures"""
+        max_retries = 3
+        
+        # Check rate limiting
+        if self.anti_detection.should_rate_limit():
+            logger.warning("Rate limiting applied - waiting before request")
+            time.sleep(30)  # Wait 30 seconds if rate limited
         
-        Args:
-            url: YouTube video URL
-            
-        Returns:
-            Dictionary containing video information or None if failed
-        """
         try:
-            cmd = [
+            base_cmd = [
                 'yt-dlp',
                 '--dump-json',
                 '--no-download',
@@ -143,7 +213,12 @@ class YouTubeDownloader:
                 str(url)
             ]
             
-            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            # Enhance command with anti-detection measures
+            cmd = self.anti_detection.get_enhanced_command(base_cmd)
+            
+            logger.info(f"Executing command (attempt {retry_count + 1}): {' '.join(cmd[:5])}...")
+            
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=60)
             video_info = json.loads(result.stdout)
             
             return {
@@ -160,74 +235,108 @@ class YouTubeDownloader:
             }
             
         except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.lower() if e.stderr else ""
+            
+            # Handle specific error cases
+            if "429" in error_msg or "too many requests" in error_msg:
+                if retry_count < max_retries:
+                    wait_time = (retry_count + 1) * 30  # Exponential backoff
+                    logger.warning(f"Rate limited (429), waiting {wait_time}s before retry {retry_count + 1}")
+                    time.sleep(wait_time)
+                    return self.get_video_info(url, retry_count + 1)
+                else:
+                    logger.error("Max retries exceeded for rate limiting")
+                    return None
+            
+            elif "sign in" in error_msg or "bot" in error_msg:
+                if retry_count < max_retries:
+                    wait_time = (retry_count + 1) * 60  # Longer wait for bot detection
+                    logger.warning(f"Bot detection triggered, waiting {wait_time}s before retry {retry_count + 1}")
+                    time.sleep(wait_time)
+                    return self.get_video_info(url, retry_count + 1)
+                else:
+                    logger.error("Max retries exceeded for bot detection")
+                    return None
+            
             logger.error(f"Failed to get video info: {e.stderr}")
             return None
-        except json.JSONDecodeError as e:
-            logger.error(f"Failed to parse video info JSON: {e}")
+            
+        except (json.JSONDecodeError, subprocess.TimeoutExpired) as e:
+            logger.error(f"Error processing video info: {e}")
+            if retry_count < max_retries:
+                time.sleep(10)
+                return self.get_video_info(url, retry_count + 1)
             return None
     
     def download_video(self, url: str, quality: str = "best", 
-                      audio_only: bool = False) -> Optional[str]:
-        """
-        Download a YouTube video without cookies
+                      audio_only: bool = False, retry_count: int = 0) -> Optional[str]:
+        """Download video with anti-detection measures"""
+        max_retries = 2
+        
+        # Check rate limiting
+        if self.anti_detection.should_rate_limit():
+            logger.warning("Rate limiting applied - waiting before download")
+            time.sleep(30)
         
-        Args:
-            url: YouTube video URL
-            quality: Video quality (best, worst, or specific format)
-            audio_only: If True, download only audio
-            
-        Returns:
-            Path to downloaded file or None if failed
-        """
         try:
-            # Base command
-            cmd = ['yt-dlp']
+            base_cmd = ['yt-dlp']
             
             # Set output directory and filename template
             output_template = str(self.download_dir / "%(title)s.%(ext)s")
-            cmd.extend(['-o', output_template])
+            base_cmd.extend(['-o', output_template])
             
             # Set format/quality
             if audio_only:
-                cmd.extend(['-f', 'bestaudio/best'])
+                base_cmd.extend(['-f', 'bestaudio/best'])
             else:
                 if quality == "best":
-                    cmd.extend(['-f', 'best[height<=720]'])  # Limit to 720p for server efficiency
+                    base_cmd.extend(['-f', 'best[height<=720]'])
                 elif quality == "worst":
-                    cmd.extend(['-f', 'worst'])
+                    base_cmd.extend(['-f', 'worst'])
                 else:
-                    cmd.extend(['-f', quality])
+                    base_cmd.extend(['-f', quality])
             
-            # Add other useful options
-            cmd.extend([
-                '--no-cookies',  # Explicitly no cookies
-                '--no-check-certificates',  # Skip SSL certificate verification if needed
-                '--extract-flat', 'false',  # Extract full metadata
-                str(url)
-            ])
+            base_cmd.extend(['--no-cookies', str(url)])
+            
+            # Enhance command with anti-detection measures
+            cmd = self.anti_detection.get_enhanced_command(base_cmd)
             
-            logger.info(f"Downloading video from: {url}")
+            logger.info(f"Downloading video (attempt {retry_count + 1}): {url}")
             
-            # Execute download
-            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=300)
             
             logger.info("Download completed successfully")
             
             # Find the downloaded file
             downloaded_files = [f for f in self.download_dir.glob("*") if f.is_file()]
             if downloaded_files:
-                # Return the most recently created file
                 latest_file = max(downloaded_files, key=os.path.getctime)
                 return str(latest_file)
             
             return None
             
         except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.lower() if e.stderr else ""
+            
+            if ("429" in error_msg or "too many requests" in error_msg or 
+                "sign in" in error_msg or "bot" in error_msg):
+                if retry_count < max_retries:
+                    wait_time = (retry_count + 1) * 60
+                    logger.warning(f"Download blocked, waiting {wait_time}s before retry {retry_count + 1}")
+                    time.sleep(wait_time)
+                    return self.download_video(url, quality, audio_only, retry_count + 1)
+            
             logger.error(f"Download failed: {e.stderr}")
             return None
+            
+        except subprocess.TimeoutExpired:
+            logger.error("Download timeout")
+            if retry_count < max_retries:
+                return self.download_video(url, quality, audio_only, retry_count + 1)
+            return None
 
 # Global downloader instance
-downloader = YouTubeDownloader()
+downloader = EnhancedYouTubeDownloader()
 
 @app.get("/", response_class=HTMLResponse)
 async def read_root():
@@ -238,7 +347,7 @@ async def read_root():
     <head>
         <meta charset="UTF-8">
         <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>YouTube Video Downloader API</title>
+        <title>Enhanced YouTube Video Downloader</title>
         <style>
             body {
                 font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
@@ -271,29 +380,19 @@ async def read_root():
                 color: #666;
                 font-size: 1.1em;
             }
-            .api-info {
+            .features {
                 background: #f8f9fa;
                 border-radius: 8px;
                 padding: 20px;
                 margin: 20px 0;
             }
-            .endpoint {
+            .feature {
                 background: white;
                 border: 1px solid #dee2e6;
                 border-radius: 5px;
                 padding: 15px;
                 margin: 10px 0;
             }
-            .method {
-                display: inline-block;
-                padding: 4px 8px;
-                border-radius: 4px;
-                font-weight: bold;
-                font-size: 0.8em;
-                margin-right: 10px;
-            }
-            .get { background: #d4edda; color: #155724; }
-            .post { background: #d1ecf1; color: #0c5460; }
             .btn {
                 background: linear-gradient(135deg, #667eea, #764ba2);
                 color: white;
@@ -308,56 +407,55 @@ async def read_root():
             .btn:hover {
                 transform: translateY(-2px);
             }
-            code {
-                background: #f8f9fa;
-                padding: 2px 6px;
-                border-radius: 3px;
-                font-family: 'Courier New', monospace;
+            .warning {
+                background: #fff3cd;
+                border: 1px solid #ffeaa7;
+                border-radius: 5px;
+                padding: 15px;
+                margin: 20px 0;
+                color: #856404;
             }
         </style>
     </head>
     <body>
         <div class="container">
             <div class="header">
-                <h1>🎥 YouTube Downloader API</h1>
-                <p>FastAPI service for downloading YouTube videos without cookies</p>
+                <h1>🛡️ Enhanced YouTube Downloader</h1>
+                <p>Advanced anti-detection measures for reliable video downloading</p>
             </div>
             
-            <div class="api-info">
-                <h3>📋 Available Endpoints</h3>
+            <div class="warning">
+                <strong>⚠️ Important:</strong> This enhanced version includes anti-bot measures to handle YouTube's restrictions. 
+                Downloads may take longer due to rate limiting and retry mechanisms.
+            </div>
+            
+            <div class="features">
+                <h3>🚀 Enhanced Features</h3>
+                
+                <div class="feature">
+                    <strong>🔄 Smart Retry Logic:</strong> Automatically retries failed requests with exponential backoff
+                </div>
                 
-                <div class="endpoint">
-                    <span class="method get">GET</span>
-                    <code>/health</code> - Check service health and yt-dlp availability
+                <div class="feature">
+                    <strong>🎭 User-Agent Rotation:</strong> Randomizes browser signatures to avoid detection
                 </div>
                 
-                <div class="endpoint">
-                    <span class="method post">POST</span>
-                    <code>/video/info</code> - Get video information without downloading
+                <div class="feature">
+                    <strong>⏱️ Rate Limiting:</strong> Intelligent request spacing to prevent 429 errors
                 </div>
                 
-                <div class="endpoint">
-                    <span class="method post">POST</span>
-                    <code>/video/download</code> - Download a YouTube video
+                <div class="feature">
+                    <strong>🌐 Enhanced Headers:</strong> Mimics real browser behavior with proper headers
                 </div>
                 
-                <div class="endpoint">
-                    <span class="method get">GET</span>
-                    <code>/video/file/{filename}</code> - Download a previously processed file
+                <div class="feature">
+                    <strong>🔧 Timeout Handling:</strong> Robust timeout and error recovery mechanisms
                 </div>
             </div>
             
             <div style="text-align: center;">
-                <a href="/docs" class="btn">📖 Interactive API Documentation</a>
-                <a href="/redoc" class="btn">📚 ReDoc Documentation</a>
-            </div>
-            
-            <div class="api-info">
-                <h3>🚀 Quick Start Example</h3>
-                <p>Get video information:</p>
-                <pre><code>curl -X POST "http://localhost:8000/video/info" \\
-     -H "Content-Type: application/json" \\
-     -d '{"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"}'</code></pre>
+                <a href="/docs" class="btn">📖 API Documentation</a>
+                <a href="/health" class="btn">🏥 Health Check</a>
             </div>
         </div>
     </body>
@@ -367,37 +465,48 @@ async def read_root():
 
 @app.get("/health", response_model=HealthResponse)
 async def health_check():
-    """Health check endpoint"""
+    """Enhanced health check with strategy information"""
     try:
-        # Check if yt-dlp is available
         subprocess.run(['yt-dlp', '--version'], capture_output=True, check=True)
         yt_dlp_available = True
     except:
         yt_dlp_available = False
     
+    strategies = [
+        "User-Agent Rotation",
+        "Rate Limiting",
+        "Smart Retry Logic",
+        "Enhanced Headers",
+        "Timeout Handling",
+        "Exponential Backoff"
+    ]
+    
     return HealthResponse(
         status="healthy" if yt_dlp_available else "unhealthy",
         yt_dlp_available=yt_dlp_available,
-        timestamp=datetime.now().isoformat()
+        timestamp=datetime.now().isoformat(),
+        strategies_enabled=strategies
     )
 
 @app.post("/video/info", response_model=Dict[str, Any])
 async def get_video_info(request: VideoInfoRequest):
-    """Get video information without downloading"""
+    """Get video information with enhanced anti-detection"""
     try:
-        # Validate URL
         url_str = str(request.url)
         if not any(domain in url_str for domain in ['youtube.com', 'youtu.be']):
             raise HTTPException(status_code=400, detail="Invalid YouTube URL")
         
-        # Get video info in thread pool to avoid blocking
+        # Get video info in thread pool with enhanced measures
         loop = asyncio.get_event_loop()
         info = await loop.run_in_executor(executor, downloader.get_video_info, url_str)
         
         if info:
             return {"success": True, "info": info}
         else:
-            raise HTTPException(status_code=500, detail="Failed to get video information")
+            raise HTTPException(
+                status_code=503, 
+                detail="Failed to get video information. YouTube may be blocking requests. Please try again later."
+            )
             
     except HTTPException:
         raise
@@ -407,9 +516,8 @@ async def get_video_info(request: VideoInfoRequest):
 
 @app.post("/video/download", response_model=DownloadResponse)
 async def download_video(request: DownloadRequest, background_tasks: BackgroundTasks):
-    """Download a YouTube video"""
+    """Download video with enhanced anti-detection"""
     try:
-        # Validate URL
         url_str = str(request.url)
         if not any(domain in url_str for domain in ['youtube.com', 'youtu.be']):
             raise HTTPException(status_code=400, detail="Invalid YouTube URL")
@@ -418,7 +526,10 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
         loop = asyncio.get_event_loop()
         info = await loop.run_in_executor(executor, downloader.get_video_info, url_str)
         if not info:
-            raise HTTPException(status_code=500, detail="Failed to get video information")
+            raise HTTPException(
+                status_code=503, 
+                detail="Failed to get video information. YouTube may be blocking requests."
+            )
         
         # Download the video
         downloaded_file = await loop.run_in_executor(
@@ -433,19 +544,22 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
             file_size = os.path.getsize(downloaded_file)
             filename = os.path.basename(downloaded_file)
             
-            # Schedule cleanup after 1 hour
-            background_tasks.add_task(cleanup_file, downloaded_file, delay=3600)
+            # Schedule cleanup after 2 hours (longer due to potential delays)
+            background_tasks.add_task(cleanup_file, downloaded_file, delay=7200)
             
             return DownloadResponse(
                 success=True,
-                message="Video downloaded successfully",
+                message="Video downloaded successfully with anti-detection measures",
                 filename=filename,
                 file_size=file_size,
                 video_info=VideoInfo(**info),
                 download_path=downloaded_file
             )
         else:
-            raise HTTPException(status_code=500, detail="Failed to download video")
+            raise HTTPException(
+                status_code=503, 
+                detail="Failed to download video. YouTube may be blocking requests. Please try again later."
+            )
             
     except HTTPException:
         raise
@@ -457,10 +571,8 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
 async def download_file(filename: str):
     """Serve downloaded files"""
     try:
-        # Security: only allow files from download directory
         file_path = downloader.download_dir / filename
         
-        # Check if file exists and is within download directory
         if not file_path.exists() or not str(file_path.resolve()).startswith(str(downloader.download_dir.resolve())):
             raise HTTPException(status_code=404, detail="File not found")
         
@@ -476,33 +588,7 @@ async def download_file(filename: str):
         logger.error(f"Error serving file: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/video/formats")
-async def list_formats(url: HttpUrl):
-    """List available formats for a video"""
-    try:
-        url_str = str(url)
-        if not any(domain in url_str for domain in ['youtube.com', 'youtu.be']):
-            raise HTTPException(status_code=400, detail="Invalid YouTube URL")
-        
-        cmd = ['yt-dlp', '--list-formats', '--no-cookies', url_str]
-        
-        loop = asyncio.get_event_loop()
-        result = await loop.run_in_executor(
-            executor,
-            lambda: subprocess.run(cmd, capture_output=True, text=True, check=True)
-        )
-        
-        formats = result.stdout.split('\n')
-        return {"success": True, "formats": formats}
-        
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Failed to list formats: {e.stderr}")
-        raise HTTPException(status_code=500, detail="Failed to list formats")
-    except Exception as e:
-        logger.error(f"Error listing formats: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-async def cleanup_file(file_path: str, delay: int = 3600):
+async def cleanup_file(file_path: str, delay: int = 7200):
     """Clean up downloaded file after delay"""
     await asyncio.sleep(delay)
     try:
@@ -513,7 +599,6 @@ async def cleanup_file(file_path: str, delay: int = 3600):
         logger.error(f"Failed to cleanup file {file_path}: {e}")
 
 if __name__ == "__main__":
-    # Get port from environment variable (Hugging Face Spaces uses port 7860)
     port = int(os.environ.get("PORT", 7860))
     
     uvicorn.run(