Upload 4 files

.dockerignore

@@ -0,0 +1,49 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Logs
+*.log
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+

Dockerfile

@@ -0,0 +1,51 @@
+# Use Python 3.11 slim image as base
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    DEBIAN_FRONTEND=noninteractive \
+    PORT=7860
+
+# Set work directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    curl \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create downloads directory
+RUN mkdir -p /tmp/downloads && \
+    chmod 755 /tmp/downloads
+
+# Create non-root user for security
+RUN useradd --create-home --shell /bin/bash app && \
+    chown -R app:app /app && \
+    chown -R app:app /tmp/downloads
+
+# Switch to non-root user
+USER app
+
+# Expose port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Run the application
+CMD ["python", "main.py"]
+

main.py

@@ -0,0 +1,526 @@
+#!/usr/bin/env python3
+"""
+FastAPI YouTube Video Downloader for Hugging Face Spaces
+A modern API service for downloading YouTube videos without cookies
+"""
+
+import os
+import sys
+import subprocess
+import json
+import tempfile
+import shutil
+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.responses import FileResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, HttpUrl
+import uvicorn
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Pydantic models for request/response
+class VideoInfoRequest(BaseModel):
+    url: HttpUrl
+    
+class DownloadRequest(BaseModel):
+    url: HttpUrl
+    quality: str = "best"
+    audio_only: bool = False
+
+class VideoInfo(BaseModel):
+    title: str
+    duration: int
+    uploader: str
+    view_count: int
+    upload_date: str
+    description: str
+    formats: int
+    id: str
+    thumbnail: str
+    webpage_url: str
+
+class DownloadResponse(BaseModel):
+    success: bool
+    message: str
+    filename: Optional[str] = None
+    file_size: Optional[int] = None
+    video_info: Optional[VideoInfo] = None
+    download_path: Optional[str] = None
+
+class HealthResponse(BaseModel):
+    status: str
+    yt_dlp_available: bool
+    timestamp: str
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="YouTube Video Downloader",
+    description="Download YouTube videos without cookies using yt-dlp",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Thread pool for background tasks
+executor = ThreadPoolExecutor(max_workers=3)
+
+class YouTubeDownloader:
+    """
+    A class to download YouTube videos without cookies using yt-dlp
+    """
+    
+    def __init__(self, download_dir: str = None):
+        """
+        Initialize the YouTube downloader
+        
+        Args:
+            download_dir: Directory to save downloaded videos
+        """
+        if download_dir is None:
+            # Use persistent storage if available, otherwise temp
+            if os.path.exists('/data'):
+                download_dir = '/data/downloads'
+            else:
+                download_dir = '/tmp/downloads'
+        
+        self.download_dir = Path(download_dir)
+        self.download_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Ensure yt-dlp is available
+        self._ensure_ytdlp_available()
+    
+    def _ensure_ytdlp_available(self):
+        """Ensure yt-dlp is available, install if necessary"""
+        try:
+            subprocess.run(['yt-dlp', '--version'], 
+                         capture_output=True, check=True)
+            logger.info("yt-dlp is available")
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            logger.info("Installing yt-dlp...")
+            try:
+                subprocess.run([sys.executable, '-m', 'pip', 'install', 'yt-dlp'], 
+                              check=True, capture_output=True)
+                logger.info("yt-dlp installed successfully")
+            except subprocess.CalledProcessError as e:
+                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
+        
+        Args:
+            url: YouTube video URL
+            
+        Returns:
+            Dictionary containing video information or None if failed
+        """
+        try:
+            cmd = [
+                'yt-dlp',
+                '--dump-json',
+                '--no-download',
+                '--no-cookies',
+                str(url)
+            ]
+            
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            video_info = json.loads(result.stdout)
+            
+            return {
+                'title': video_info.get('title', 'Unknown'),
+                'duration': video_info.get('duration', 0),
+                'uploader': video_info.get('uploader', 'Unknown'),
+                'view_count': video_info.get('view_count', 0),
+                'upload_date': video_info.get('upload_date', 'Unknown'),
+                'description': video_info.get('description', ''),
+                'formats': len(video_info.get('formats', [])),
+                'id': video_info.get('id', 'Unknown'),
+                'thumbnail': video_info.get('thumbnail', ''),
+                'webpage_url': video_info.get('webpage_url', str(url))
+            }
+            
+        except subprocess.CalledProcessError as e:
+            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}")
+            return None
+    
+    def download_video(self, url: str, quality: str = "best", 
+                      audio_only: bool = False) -> Optional[str]:
+        """
+        Download a YouTube video without cookies
+        
+        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']
+            
+            # Set output directory and filename template
+            output_template = str(self.download_dir / "%(title)s.%(ext)s")
+            cmd.extend(['-o', output_template])
+            
+            # Set format/quality
+            if audio_only:
+                cmd.extend(['-f', 'bestaudio/best'])
+            else:
+                if quality == "best":
+                    cmd.extend(['-f', 'best[height<=720]'])  # Limit to 720p for server efficiency
+                elif quality == "worst":
+                    cmd.extend(['-f', 'worst'])
+                else:
+                    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)
+            ])
+            
+            logger.info(f"Downloading video from: {url}")
+            
+            # Execute download
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            
+            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:
+            logger.error(f"Download failed: {e.stderr}")
+            return None
+
+# Global downloader instance
+downloader = YouTubeDownloader()
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root():
+    """Serve the main HTML interface"""
+    html_content = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>YouTube Video Downloader API</title>
+        <style>
+            body {
+                font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                min-height: 100vh;
+                margin: 0;
+                padding: 20px;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+            }
+            .container {
+                background: white;
+                border-radius: 15px;
+                box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+                padding: 40px;
+                max-width: 800px;
+                width: 100%;
+            }
+            .header {
+                text-align: center;
+                margin-bottom: 30px;
+            }
+            .header h1 {
+                color: #333;
+                margin-bottom: 10px;
+                font-size: 2.5em;
+            }
+            .header p {
+                color: #666;
+                font-size: 1.1em;
+            }
+            .api-info {
+                background: #f8f9fa;
+                border-radius: 8px;
+                padding: 20px;
+                margin: 20px 0;
+            }
+            .endpoint {
+                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;
+                border: none;
+                padding: 12px 24px;
+                border-radius: 8px;
+                text-decoration: none;
+                display: inline-block;
+                margin: 10px 5px;
+                transition: transform 0.2s ease;
+            }
+            .btn:hover {
+                transform: translateY(-2px);
+            }
+            code {
+                background: #f8f9fa;
+                padding: 2px 6px;
+                border-radius: 3px;
+                font-family: 'Courier New', monospace;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="header">
+                <h1>🎥 YouTube Downloader API</h1>
+                <p>FastAPI service for downloading YouTube videos without cookies</p>
+            </div>
+            
+            <div class="api-info">
+                <h3>📋 Available Endpoints</h3>
+                
+                <div class="endpoint">
+                    <span class="method get">GET</span>
+                    <code>/health</code> - Check service health and yt-dlp availability
+                </div>
+                
+                <div class="endpoint">
+                    <span class="method post">POST</span>
+                    <code>/video/info</code> - Get video information without downloading
+                </div>
+                
+                <div class="endpoint">
+                    <span class="method post">POST</span>
+                    <code>/video/download</code> - Download a YouTube video
+                </div>
+                
+                <div class="endpoint">
+                    <span class="method get">GET</span>
+                    <code>/video/file/{filename}</code> - Download a previously processed file
+                </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>
+            </div>
+        </div>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    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
+    
+    return HealthResponse(
+        status="healthy" if yt_dlp_available else "unhealthy",
+        yt_dlp_available=yt_dlp_available,
+        timestamp=datetime.now().isoformat()
+    )
+
+@app.post("/video/info", response_model=Dict[str, Any])
+async def get_video_info(request: VideoInfoRequest):
+    """Get video information without downloading"""
+    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
+        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")
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting video info: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/video/download", response_model=DownloadResponse)
+async def download_video(request: DownloadRequest, background_tasks: BackgroundTasks):
+    """Download a YouTube video"""
+    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 first
+        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")
+        
+        # Download the video
+        downloaded_file = await loop.run_in_executor(
+            executor, 
+            downloader.download_video, 
+            url_str, 
+            request.quality, 
+            request.audio_only
+        )
+        
+        if downloaded_file:
+            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)
+            
+            return DownloadResponse(
+                success=True,
+                message="Video downloaded successfully",
+                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")
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error downloading video: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/video/file/{filename}")
+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")
+        
+        return FileResponse(
+            path=str(file_path),
+            filename=filename,
+            media_type='application/octet-stream'
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        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):
+    """Clean up downloaded file after delay"""
+    await asyncio.sleep(delay)
+    try:
+        if os.path.exists(file_path):
+            os.remove(file_path)
+            logger.info(f"Cleaned up file: {file_path}")
+    except Exception as e:
+        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(
+        "main:app",
+        host="0.0.0.0",
+        port=port,
+        reload=False,
+        log_level="info"
+    )
+

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+yt-dlp==2025.6.30
+python-multipart==0.0.6
+