Update app.py

app.py

@@ -1,249 +1,303 @@
-# app.py
-from fastapi import FastAPI, HTTPException
-from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel
-import subprocess
 import os
-import shutil
-import logging
-from datetime import datetime
-import tempfile
-from pathlib import Path
-from typing import List
-from dotenv import load_dotenv
-from urllib.parse import quote
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-def env_to_cookies(env_content: str, output_file: str) -> None:
-    """Convert environment variable content to cookie file"""
-    try:
-        # Extract content from env format
-        if '="' not in env_content:
-            raise ValueError("Invalid env content format")
-        content = env_content.split('="', 1)[1].strip('"')
-        
-        # Replace escaped newlines with actual newlines
-        cookie_content = content.replace('\\n', '\n')
-        
-        # Write to cookie file
-        with open(output_file, 'w') as f:
-            f.write(cookie_content)
-            
-        logger.info(f"Successfully created cookie file at {output_file}")
-    except Exception as e:
-        logger.error(f"Error creating cookie file: {str(e)}")
-        raise ValueError(f"Error converting to cookie file: {str(e)}")
-
-def get_cookies() -> str:
-    """Get cookies from environment variable"""
-    load_dotenv()
-    cookie_content = os.getenv('COOKIES')
-    if not cookie_content:
-        raise ValueError("COOKIES environment variable not set")
-    return cookie_content
-
-def env_to_cookies_from_env(output_file: str) -> None:
-    """Convert environment variable from .env file to cookie file"""
-    try:
-        load_dotenv()
-        env_content = os.getenv('COOKIES')
-        logger.info("Retrieved cookies from environment variable")
-        
-        if not env_content:
-            raise ValueError("COOKIES not found in environment variables")
-            
-        env_to_cookies(f'COOKIES="{env_content}"', output_file)
-    except Exception as e:
-        logger.error(f"Error creating cookie file from env: {str(e)}")
-        raise ValueError(f"Error converting to cookie file: {str(e)}")
+import json
+import time
+import urllib.parse
+from datetime import datetime, timezone
+from starlette.responses import JSONResponse
+from fastapi import FastAPI, HTTPException, status, Request
+from yt_dlp import YoutubeDL
+from yt_dlp.version import __version__ as yt_dlp_version
+from typing import Union, Dict
 
-app = FastAPI(
-    title="GAMDL API",
-    description="API for downloading Google Drive files using gamdl",
-    version="1.0.0"
-)
+app = FastAPI(docs_url=None, redoc_url=None)
 
-# Create downloads directory if it doesn't exist
-DOWNLOADS_DIR = "downloads"
-os.makedirs(DOWNLOADS_DIR, exist_ok=True)
+# Set cache directory to /tmp which is writable in Vercel
+os.environ["XDG_CACHE_HOME"] = "/tmp"
 
-# Mount the downloads directory
-app.mount("/files", StaticFiles(directory=DOWNLOADS_DIR), name="files")
+# Rate limiting configuration
+DAILY_LIMIT = 100  # Maximum requests per IP per day
+RATE_LIMIT_FILE = "/tmp/rate_limits.json"
 
+def load_rate_limits() -> Dict[str, Dict]:
+    """Load rate limit data from file"""
+    try:
+        if os.path.exists(RATE_LIMIT_FILE):
+            with open(RATE_LIMIT_FILE, 'r') as f:
+                return json.load(f)
+    except Exception:
+        pass
+    return {}
 
+def save_rate_limits(rate_limits: Dict[str, Dict]):
+    """Save rate limit data to file"""
+    try:
+        with open(RATE_LIMIT_FILE, 'w') as f:
+            json.dump(rate_limits, f)
+    except Exception:
+        pass
 
+def get_current_date() -> str:
+    """Get current date as string in YYYY-MM-DD format"""
+    return datetime.now(timezone.utc).strftime('%Y-%m-%d')
 
-# [Previous cookie handling code remains the same...]
+def cleanup_old_entries(rate_limits: Dict[str, Dict]) -> Dict[str, Dict]:
+    """Remove entries older than today"""
+    current_date = get_current_date()
+    cleaned = {}
+    
+    for ip, data in rate_limits.items():
+        if data.get('date') == current_date:
+            cleaned[ip] = data
+    
+    return cleaned
 
+def check_rate_limit(ip: str) -> tuple[bool, int]:
+    """
+    Check if IP has exceeded daily limit
+    Returns: (is_allowed, remaining_requests)
+    """
+    rate_limits = load_rate_limits()
+    rate_limits = cleanup_old_entries(rate_limits)
+    
+    current_date = get_current_date()
+    
+    if ip not in rate_limits:
+        rate_limits[ip] = {
+            'date': current_date,
+            'count': 0
+        }
+    
+    ip_data = rate_limits[ip]
+    
+    # Reset count if it's a new day
+    if ip_data.get('date') != current_date:
+        ip_data['date'] = current_date
+        ip_data['count'] = 0
+    
+    current_count = ip_data['count']
+    
+    if current_count >= DAILY_LIMIT:
+        return False, 0
+    
+    # Increment count
+    ip_data['count'] = current_count + 1
+    rate_limits[ip] = ip_data
+    
+    # Save updated limits
+    save_rate_limits(rate_limits)
+    
+    remaining = DAILY_LIMIT - ip_data['count']
+    return True, remaining
 
+def get_client_ip(request: Request) -> str:
+    """Extract client IP from request, handling proxies"""
+    # Check for common proxy headers
+    forwarded_for = request.headers.get("x-forwarded-for")
+    if forwarded_for:
+        # Take the first IP in the chain
+        return forwarded_for.split(",")[0].strip()
+    
+    real_ip = request.headers.get("x-real-ip")
+    if real_ip:
+        return real_ip.strip()
+    
+    # Fallback to direct client IP
+    return request.client.host if request.client else "unknown"
 
+@app.get("/api/version")
+async def version_info():
+    return JSONResponse({"yt_dlp": yt_dlp_version})
 
-# [Previous cookie handling code remains the same...]
+@app.get('/')
+def main():
+    return "Chrunos Downloader API Is Running well."
 
-class DownloadRequest(BaseModel):
-    url: str
+@app.get("/api/info")
+async def get_info(
+    request: Request,
+    url: str, 
+    quality: Union[str, None] = None, 
+    playlist: bool = True
+):
+    # Get client IP
+    client_ip = get_client_ip(request)
+    
+    # Check rate limit
+    is_allowed, remaining = check_rate_limit(client_ip)
     
+    if not is_allowed:
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail=f"Daily limit of {DAILY_LIMIT} requests exceeded. Try again tomorrow.",
+            headers={
+                "X-RateLimit-Limit": str(DAILY_LIMIT),
+                "X-RateLimit-Remaining": "0",
+                "X-RateLimit-Reset": str(int(time.time()) + 86400),
+                "Cache-Control": "no-store, max-age=0"
+            }
+        )
+    
+    ydl_options = {
+        "retries": 3,
+        "encoding": "utf8",
+        "noplaylist": not playlist,
+        "dump_single_json": True,
+        "format": quality if quality else "bestvideo+bestaudio/best",
+        "ignoreerrors": True,
+        "extract_flat": playlist,
+        "cachedir": "/tmp/yt-dlp-cache",
+        "js-runtimes": "node"
+    }
+    
+    with YoutubeDL(ydl_options) as ytdl:
+        try:
+            response = ytdl.extract_info(url, download=False)
+            return JSONResponse(
+                response,
+                headers={
+                    "Cache-Control": "s-maxage=2592000, stale-while-revalidate",
+                    "X-RateLimit-Limit": str(DAILY_LIMIT),
+                    "X-RateLimit-Remaining": str(remaining),
+                    "X-RateLimit-Reset": str(int(time.time()) + 86400)
+                }
+            )
+        except Exception as e:
+            print(e)
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=repr(e),
+                headers={"Cache-Control": "no-store, max-age=0"},
+            )
 
 
-# [Previous cookie handling code remains the same...]
 
-class FileInfo(BaseModel):
-    filename: str
-    download_url: str
-    file_type: str
+@app.get("/api/playlist")
+async def get_playlist_info(
+    request: Request,
+    url: str,
+    start: int = 1,
+    end: int = 50
+):
+    """
+    Fetches paginated items from a playlist or user profile.
+    Strictly enforces a maximum of 50 items per request and provides a next_page URL.
+    """
+    # 1. Validate inputs
+    if start < 1:
+        raise HTTPException(status_code=400, detail="'start' must be 1 or greater.")
+    if end < start:
+        raise HTTPException(status_code=400, detail="'end' must be greater than or equal to 'start'.")
 
-class DownloadResponse(BaseModel):
-    success: bool
-    message: str
-    files: List[FileInfo]
+    # 2. Enforce a hard limit of 50 items per request
+    # If a client requests start=51 & end=1000, we force end=100.
+    requested_count = end - start + 1
+    if requested_count > 50:
+        end = start + 49
+        requested_count = 50
 
-@app.post("/download", response_model=DownloadResponse)
-async def download_file(request: DownloadRequest):
-    try:
-        # Create a unique subdirectory for this download
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        download_subdir = os.path.join(DOWNLOADS_DIR, timestamp)
-        os.makedirs(download_subdir, exist_ok=True)
-        
-        logger.info(f"Current working directory: {os.getcwd()}")
-        logger.info(f"Download directory: {download_subdir}")
-        
-        # Create cookies file from environment variable
-        cookie_path = os.path.join(download_subdir, "cookies.txt")
-        logger.info(f"Creating cookies file at: {cookie_path}")
-        env_to_cookies_from_env(cookie_path)
-        
-        # Change to download directory
-        original_dir = os.getcwd()
-        os.chdir(download_subdir)
-        
-        # Run gamdl command
-        cmd = ["gamdl", "--codec-song", "aac-legacy", request.url]
-        logger.info(f"Executing command: {' '.join(cmd)}")
-        
-        process = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True
+    # Rate Limiting
+    client_ip = get_client_ip(request)
+    is_allowed, remaining = check_rate_limit(client_ip)
+    
+    if not is_allowed:
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail=f"Daily limit of {DAILY_LIMIT} requests exceeded. Try again tomorrow.",
+            headers={
+                "X-RateLimit-Limit": str(DAILY_LIMIT),
+                "X-RateLimit-Remaining": "0",
+                "X-RateLimit-Reset": str(int(time.time()) + 86400), 
+                "Cache-Control": "no-store, max-age=0"
+            }
         )
-        
-        logger.info(f"Command stdout: {process.stdout}")
-        logger.info(f"Command stderr: {process.stderr}")
-        
-        process.check_returncode()
-        
-        # Find all files recursively in the download directory
-        all_files = []
-        for root, dirs, files in os.walk('.'):
-            for file in files:
-                if file != "cookies.txt":
-                    file_path = os.path.join(root, file)
-                    all_files.append(file_path)
-        
-        logger.info(f"All files found: {all_files}")
-        
-        if not all_files:
-            raise Exception("No files found after download attempt")
-        
-        # Process all downloaded files
-        downloaded_files = []
-        space_url = os.getenv("SPACE_URL", "https://tecuts-testing.hf.space")
-        
-        for file_path in all_files:
-            try:
-                # Get just the filename from the path
-                filename = os.path.basename(file_path)
-                
-                # Create new path in current directory
-                new_path = os.path.join(".", filename)
-                
-                logger.info(f"Moving file from {file_path} to {new_path}")
-                
-                # Copy file to current directory
-                shutil.copy2(file_path, new_path)
-                
-                # Get file extension
-                file_type = os.path.splitext(filename)[1].lstrip('.')
-                
-                # Generate download URL
-                encoded_filename = quote(filename)
-                download_url = f"{space_url}/files/{timestamp}/{encoded_filename}"
-                
-                downloaded_files.append(FileInfo(
-                    filename=filename,
-                    download_url=download_url,
-                    file_type=file_type
-                ))
+    
+    ydl_options = {
+        "retries": 3,
+        "encoding": "utf8",
+        "extract_flat": "in_playlist", 
+        "dump_single_json": True,
+        "ignoreerrors": True,
+        "cachedir": "/tmp/yt-dlp-cache",
+        "js-runtimes": "node",
+        # Pass the strictly clamped pagination settings to yt-dlp
+        "playliststart": start,
+        "playlistend": end
+    }
+    
+    with YoutubeDL(ydl_options) as ytdl:
+        try:
+            response = ytdl.extract_info(url, download=False)
+            if not response:
+                raise HTTPException(status_code=404, detail="Playlist or profile not found.")
+            
+            # Extract entries. yt-dlp might omit 'entries' if out of bounds, so default to empty list.
+            raw_entries = response.get("entries") or []
+            
+            # Filter out 'None' entries (yt-dlp sometimes returns None for deleted/private videos in a playlist)
+            valid_entries = [e for e in raw_entries if e is not None]
+
+            # 3. Determine if there is a next page
+            next_page_url = None
+            
+            # If yt-dlp found enough items to fill our requested quota, there is likely a next page.
+            # (Note: we check the length of raw_entries because deleted videos still consume an index slot)
+            if len(raw_entries) >= requested_count:
+                next_start = end + 1
+                next_end = next_start + 49
                 
-                logger.info(f"Processed file: {filename} -> {download_url}")
+                # Safely encode the target URL
+                encoded_url = urllib.parse.quote(url)
+                base_url = str(request.base_url).rstrip('/')
                 
-            except Exception as e:
-                logger.error(f"Error processing file {file_path}: {str(e)}")
-                continue
-        
-        # Clean up original files and directories after successful copy
-        for root, dirs, files in os.walk('.'):
-            for dir_name in dirs:
-                if dir_name == "Apple Music":  # Only remove the music directory
-                    dir_path = os.path.join(root, dir_name)
-                    logger.info(f"Removing directory: {dir_path}")
-                    shutil.rmtree(dir_path, ignore_errors=True)
-        
-        # Move back to original directory
-        os.chdir(original_dir)
-        
-        if not downloaded_files:
-            raise Exception("Failed to process any files")
-        
-        return DownloadResponse(
-            success=True,
-            message=f"Successfully downloaded {len(downloaded_files)} files",
-            files=downloaded_files
-        )
-            
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Download process failed: stdout={e.stdout}, stderr={e.stderr}")
-        raise HTTPException(
-            status_code=400,
-            detail=f"Failed to download: {e.stderr or e.stdout or str(e)}"
-        )
-    except Exception as e:
-        logger.error(f"Unexpected error: {str(e)}", exc_info=True)
-        raise HTTPException(
-            status_code=500,
-            detail=f"Error: {str(e)}"
-        )
-    finally:
-        if 'original_dir' in locals():
-            os.chdir(original_dir)
+                # Construct the ready-to-use next_page URL for the client
+                next_page_url = f"{base_url}/api/playlist?url={encoded_url}&start={next_start}&end={next_end}"
+
+            clean_response = {
+                "id": response.get("id"),
+                "title": response.get("title", "Unknown Playlist"),
+                "uploader": response.get("uploader"),
+                "items_returned": len(valid_entries),
+                "next_page": next_page_url,
+                "entries": valid_entries
+            }
             
-@app.get("/")
-async def root():
-    return {"message": "Welcome to testing API. Visit /docs for API documentation."}
+            return JSONResponse(
+                clean_response,
+                headers={
+                    "Cache-Control": "s-maxage=2592000, stale-while-revalidate",
+                    "X-RateLimit-Limit": str(DAILY_LIMIT),
+                    "X-RateLimit-Remaining": str(remaining),
+                    "X-RateLimit-Reset": str(int(time.time()) + 86400)
+                }
+            )
+        except Exception as e:
+            print(f"Error extracting playlist: {e}")
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=repr(e),
+                headers={"Cache-Control": "no-store, max-age=0"},
+            )
 
-@app.get("/test")
-async def test():
-    """Test endpoint to verify setup"""
-    try:
-        # Test cookie creation
-        temp_cookie = os.path.join(DOWNLOADS_DIR, "test_cookies.txt")
-        env_to_cookies_from_env(temp_cookie)
-        
-        # Test gamdl installation
-        process = subprocess.run(["gamdl", "--version"], capture_output=True, text=True)
-        
-        return {
-            "gamdl_version": process.stdout.strip(),
-            "cookies_created": os.path.exists(temp_cookie),
-            "cookies_size": os.path.getsize(temp_cookie) if os.path.exists(temp_cookie) else 0,
-            "installed": True,
-            "error": process.stderr if process.stderr else None
-        }
-    except Exception as e:
-        return {
-            "installed": False,
-            "error": str(e)
-        }
+
+@app.get("/api/rate-limit-status")
+async def get_rate_limit_status(request: Request):
+    """Endpoint to check current rate limit status for the requesting IP"""
+    client_ip = get_client_ip(request)
+    rate_limits = load_rate_limits()
+    rate_limits = cleanup_old_entries(rate_limits)
+    
+    current_date = get_current_date()
+    
+    if client_ip in rate_limits and rate_limits[client_ip].get('date') == current_date:
+        used = rate_limits[client_ip]['count']
+        remaining = DAILY_LIMIT - used
+    else:
+        used = 0
+        remaining = DAILY_LIMIT
+    
+    return JSONResponse({
+        "daily_limit": DAILY_LIMIT,
+        "used": used,
+        "remaining": remaining,
+        "reset_time": f"{current_date}T00:00:00Z"
+    })