Add: youtube to mp3 feature

.dockerignore

@@ -0,0 +1,44 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Project specific
+app/static/audio/*
+!app/static/audio/.gitkeep
+*.mp3
+*.log
+.env
+.env.* 

.env.example

@@ -0,0 +1,13 @@
+# Server Configuration
+SERVER_HOST=http://localhost
+SERVER_PORT=8000
+
+# API Configuration
+API_V1_STR=/api
+
+# Project Configuration
+PROJECT_NAME="YouTube to MP3 Converter"
+
+# File Configuration
+MAX_AUDIO_FILES=1000
+CLEANUP_THRESHOLD=800 

.gitignore

@@ -0,0 +1,53 @@
+# 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 Environment
+venv/
+env/
+ENV/
+.env
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# FastAPI specific
+.pytest_cache/
+coverage.xml
+htmlcov/
+
+# Logs
+*.log
+
+# Local development
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# System Files
+.DS_Store
+Thumbs.db
+
+*.mp3

Dockerfile

@@ -0,0 +1,33 @@
+# Use Python 3.11 slim image as base
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    DEBIAN_FRONTEND=noninteractive
+
+# Set working directory
+WORKDIR /code
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create directory for static files in Hugging Face's persistent storage
+RUN mkdir -p /data/audio && \
+    chmod -R 755 /data/audio
+
+# Expose port (Hugging Face uses port 7860 by default)
+EXPOSE 7860
+
+# Run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"] 

README.md

@@ -0,0 +1,49 @@
+# YouTube to MP3 Converter API
+
+A FastAPI service that converts YouTube videos to MP3 format, optimized for Hugging Face Spaces deployment.
+
+## Features
+
+- Convert YouTube videos to MP3
+- Persistent storage for audio files
+- RESTful API with automatic documentation
+- Docker-ready deployment
+
+## API Endpoints
+
+- `POST /api/convert`: Convert a YouTube video to MP3
+  - Request body: `{"url": "youtube_url"}`
+  - Response: `{"download_url": "mp3_file_url"}`
+
+## Development
+
+1. Create `.env` file from template:
+```bash
+cp .env.example .env
+```
+
+2. Run locally with Docker:
+```bash
+docker-compose up --build
+```
+
+3. Access API documentation:
+- Local: http://localhost:8000/docs
+- Production: https://huggingface.co/spaces/bivav/video-mp3/docs
+
+## Hugging Face Deployment
+
+This API is deployed on Hugging Face Spaces at: https://huggingface.co/spaces/bivav/video-mp3
+
+The service uses Hugging Face's persistent storage at `/data/audio` for storing MP3 files.
+
+## Environment Variables
+
+- `SERVER_HOST`: API server host
+- `SERVER_PORT`: API server port
+- `HF_SPACE_NAME`: Hugging Face space name
+- `HF_STATIC_DIR`: Directory for static files in Hugging Face
+
+## License
+
+MIT License

app/api/endpoints.py

@@ -0,0 +1,38 @@
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, HttpUrl
+from ..services.youtube_service import youtube_service
+from ..core.config import settings
+
+router = APIRouter()
+
+
+class ConversionRequest(BaseModel):
+    url: HttpUrl
+
+
+class ConversionResponse(BaseModel):
+    download_url: str
+
+
+@router.post("/convert", response_model=ConversionResponse)
+async def convert_video(request: ConversionRequest):
+    try:
+        filename = await youtube_service.convert_to_mp3(str(request.url))
+        download_url = f"{settings.BASE_URL}/static/audio/{filename}"
+        return ConversionResponse(download_url=download_url)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/static/audio/{filename}")
+async def get_audio(filename: str):
+    file_path = settings.AUDIO_DIR / filename
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="Audio file not found")
+    return FileResponse(
+        path=file_path,
+        media_type="audio/mpeg",
+        filename=filename,
+        headers={"Content-Disposition": f"attachment; filename={filename}"},
+    )

app/core/config.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    # API Settings
+    API_V1_STR: str = "/api"
+    PROJECT_NAME: str = "YouTube to MP3 Converter"
+
+    # Server configuration
+    SERVER_HOST: str
+    SERVER_PORT: int
+
+    # Hugging Face configuration
+    HF_SPACE_NAME: str = "bivav/video-mp3"
+    HF_STATIC_DIR: str = "/data/audio"
+
+    @property
+    def BASE_URL(self) -> str:
+        # For HTTPS, we don't include the port
+        return self.SERVER_HOST
+
+    # Static file configurations
+    STATIC_DIR: Path = (
+        Path(HF_STATIC_DIR)
+        if HF_STATIC_DIR.startswith("/data")
+        else Path(__file__).parent.parent / "static"
+    )
+    AUDIO_DIR: Path = STATIC_DIR / "audio"
+
+    # File configurations
+    MAX_AUDIO_FILES: int = 1000
+    CLEANUP_THRESHOLD: int = 800
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        case_sensitive = True
+
+
+settings = Settings()
+
+# Ensure directories exist
+settings.STATIC_DIR.mkdir(exist_ok=True, parents=True)
+settings.AUDIO_DIR.mkdir(exist_ok=True, parents=True)

app/main.py

@@ -0,0 +1,26 @@
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+
+from .core.config import settings
+from .api.endpoints import router
+
+app = FastAPI(
+    title=settings.PROJECT_NAME,
+    openapi_url=f"{settings.API_V1_STR}/openapi.json"
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace with specific origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static files directory
+app.mount("/static", StaticFiles(directory=str(settings.STATIC_DIR)), name="static")
+
+# Include API router
+app.include_router(router, prefix=settings.API_V1_STR)

app/services/youtube_service.py

@@ -0,0 +1,142 @@
+import asyncio
+from urllib.parse import urlparse, parse_qs
+from pathlib import Path
+import yt_dlp
+from ..core.config import settings
+
+
+class YouTubeService:
+    def __init__(self):
+        self.output_dir = settings.AUDIO_DIR
+        # Configure yt-dlp with Docker-compatible defaults
+        self.ydl_opts = {
+            "format": "bestaudio/best",
+            "postprocessors": [
+                {
+                    "key": "FFmpegExtractAudio",
+                    "preferredcodec": "mp3",
+                    "preferredquality": "192",
+                }
+            ],
+            "quiet": True,
+            # Add user agent and other headers to avoid restrictions
+            "http_headers": {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "en-us,en;q=0.5",
+                "Referer": "https://www.youtube.com/",
+            },
+            # Add retries and throttling with better Docker-optimized settings
+            "retries": 3,
+            "fragment_retries": 3,
+            "skip_unavailable_fragments": True,
+            "ignoreerrors": False,  # Changed to False to better handle errors in Docker
+            "no_warnings": False,  # Show warnings for better Docker logs
+            "sleep_interval": 2,  # Increased sleep to avoid rate limiting
+            "max_sleep_interval": 6,
+            # Add geo bypass
+            "geo_bypass": True,
+            "geo_bypass_country": "US",
+            # Add network settings
+            "socket_timeout": 30,  # Timeout for network operations
+            "extractor_retries": 3,  # Retries for extractor errors
+            # Add progress hooks for better logging
+            "progress_hooks": [self._progress_hook],
+            # Force IPv4 to avoid IPv6 issues in some Docker networks
+            "source_address": "0.0.0.0",
+        }
+
+    def _progress_hook(self, d):
+        """
+        Hook to track download progress and log important events
+        """
+        if d["status"] == "downloading":
+            try:
+                progress = (
+                    float(d.get("downloaded_bytes", 0))
+                    / float(d.get("total_bytes", 1))
+                    * 100
+                )
+                print(f"Downloading: {progress:.1f}%")
+            except:
+                pass
+        elif d["status"] == "error":
+            print(f"Error during download: {d.get('error')}")
+        elif d["status"] == "finished":
+            print(f"Download finished, converting to MP3...")
+
+    def _extract_video_id(self, url: str) -> str:
+        """
+        Extract video ID from YouTube URL
+        """
+        query = urlparse(url)
+        if query.hostname == "youtu.be":
+            return query.path[1:]
+        if query.hostname in {"www.youtube.com", "youtube.com", "m.youtube.com"}:
+            if query.path == "/watch":
+                return parse_qs(query.query)["v"][0]
+            if query.path[:7] == "/embed/":
+                return query.path.split("/")[2]
+            if query.path[:3] == "/v/":
+                return query.path.split("/")[2]
+        raise ValueError("Invalid YouTube URL")
+
+    async def convert_to_mp3(self, url: str) -> str:
+        """
+        Convert YouTube video to MP3 and return the filename
+        """
+        video_id = self._extract_video_id(url)
+        filename = f"{video_id}.mp3"
+        output_path = self.output_dir / filename
+
+        # Skip if file already exists
+        if output_path.exists():
+            return filename
+
+        # Update output template for this specific download
+        opts = {**self.ydl_opts, "outtmpl": str(output_path.with_suffix(""))}
+
+        try:
+            # Run youtube-dl in a thread pool to avoid blocking
+            await asyncio.get_event_loop().run_in_executor(
+                None, self._download_and_convert, url, opts
+            )
+
+            if not output_path.exists():
+                raise Exception("Failed to download and convert the video")
+
+            return filename
+        except Exception as e:
+            print(
+                f"Error in convert_to_mp3: {str(e)}"
+            )  # Better error logging for Docker
+            raise Exception(f"Error converting video: {str(e)}")
+
+    def _download_and_convert(self, url: str, opts: dict):
+        """
+        Download and convert the video using yt-dlp
+        """
+        try:
+            with yt_dlp.YoutubeDL(opts) as ydl:
+                error = ydl.download([url])
+                if error:  # yt-dlp returns non-zero on error
+                    raise Exception(f"yt-dlp returned error code: {error}")
+        except Exception as e:
+            print(f"First download attempt failed: {str(e)}")
+            # Try one more time with different format
+            try:
+                opts["format"] = (
+                    "worstaudio/worst"  # Try with lowest quality as fallback
+                )
+                with yt_dlp.YoutubeDL(opts) as ydl_fallback:
+                    error = ydl_fallback.download([url])
+                    if error:
+                        raise Exception(
+                            f"Fallback download failed with error code: {error}"
+                        )
+            except Exception as fallback_error:
+                print(f"Fallback download attempt failed: {str(fallback_error)}")
+                raise  # Re-raise the last error
+
+
+youtube_service = YouTubeService()

docker-compose.yml

@@ -0,0 +1,16 @@
+services:
+  web:
+    build: .
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./app/static/audio:/app/app/static/audio
+    env_file:
+      - .env
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/docs"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s 

requirements.txt

@@ -0,0 +1,7 @@
+fastapi>=0.104.1
+uvicorn[standard]>=0.24.0
+python-multipart>=0.0.6
+pydantic>=2.5.2
+pydantic-settings>=2.1.0
+yt-dlp>=2023.11.16
+python-dotenv>=1.0.0