Upload app.py

app.py

@@ -0,0 +1,288 @@
+import sys
+import time
+from fastapi import FastAPI, BackgroundTasks, Request, HTTPException, Security
+from fastapi.security import APIKeyHeader
+from fastapi.responses import FileResponse
+from fastapi.concurrency import run_in_threadpool
+import yt_dlp
+import ffmpeg
+import urllib.parse
+from urllib.parse import urlparse
+import os
+from datetime import datetime, timedelta
+import schedule
+import requests
+import uvicorn
+import subprocess
+import json
+from dotenv import load_dotenv
+import mimetypes
+import tempfile
+from PIL import Image
+from io import BytesIO
+from pathlib import Path
+from fastapi.staticfiles import StaticFiles
+from collections import defaultdict
+from starlette.responses import JSONResponse
+import logging
+import gc
+from typing import Dict, Any
+import re
+import asyncio
+import cloudscraper
+
+
+tmp_dir = tempfile.gettempdir()
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+app = FastAPI()
+
+# Define a global temporary download directory
+global_download_dir = tempfile.mkdtemp()
+
+# Rate limiting dictionary
+class RateLimiter:
+    def __init__(self, max_requests: int, time_window: timedelta):
+        self.max_requests = max_requests
+        self.time_window = time_window
+        self.requests: Dict[str, list] = defaultdict(list)
+    
+    def _cleanup_old_requests(self, user_ip: str) -> None:
+        """Remove requests that are outside the time window."""
+        current_time = time.time()
+        self.requests[user_ip] = [
+            timestamp for timestamp in self.requests[user_ip]
+            if current_time - timestamp < self.time_window.total_seconds()
+        ]
+    
+    def is_rate_limited(self, user_ip: str) -> bool:
+        """Check if the user has exceeded their rate limit."""
+        self._cleanup_old_requests(user_ip)
+        
+        # Get current count after cleanup
+        current_count = len(self.requests[user_ip])
+        
+        # Add current request timestamp (incrementing the count)
+        current_time = time.time()
+        self.requests[user_ip].append(current_time)
+        
+        # Check if user has exceeded the maximum requests
+        return (current_count + 1) > self.max_requests
+    
+    def get_current_count(self, user_ip: str) -> int:
+        """Get the current request count for an IP."""
+        self._cleanup_old_requests(user_ip)
+        return len(self.requests[user_ip])
+
+
+# Initialize rate limiter with 100 requests per day
+rate_limiter = RateLimiter(
+    max_requests=12,
+    time_window=timedelta(days=1)
+)
+
+def get_user_ip(request: Request) -> str:
+    """Helper function to get user's IP address."""
+    forwarded = request.headers.get("X-Forwarded-For")
+    if forwarded:
+        return forwarded.split(",")[0]
+    return request.client.host
+
+ALT_API = os.getenv("ALT_API")
+
+def extract_video_info(video_url: str) -> str:
+    EXTRACT_API = ALT_API
+    api_url = f'{EXTRACT_API}?url={video_url}'
+    logger.info(api_url)
+    session = cloudscraper.create_scraper()
+    try:
+        response = session.get(api_url, timeout=20)
+        
+        if response.status_code == 200:
+            json_response = response.json()
+            result = []
+            # 检查 formats 列表是否存在且不为空
+            if 'formats' in json_response:
+                for format_item in json_response['formats']:
+                    format_url = format_item.get('url')
+                    format_id = format_item.get('format_id')
+                    p_cookies = format_item.get('cookies')
+                    if format_id and format_url:
+                        result.append({
+                            "url": format_url,
+                            "format_id": format_id,
+                            "cookies": p_cookies
+                        })
+
+                title = json_response.get('title')
+                logger.info(title)
+                if "ornhub.com" in video_url:
+                    p_result = [item for item in result if 'hls' in item['format_id']]
+                    last_item = p_result[-1]
+                    second_last_item = p_result[-2]
+                    last_item["format_id"] = f'{last_item["format_id"]} - Chrunos Shortcuts Premium Only'
+                    last_item["url"] = 'https://chrunos.com/premium-shortcuts/'
+                    second_last_item["format_id"] = f'{second_last_item["format_id"]} - Chrunos Shortcuts Premium Only'
+                    second_last_item["url"] = 'https://chrunos.com/premium-shortcuts/'
+                    return p_result
+                else:
+                    new_result = result
+                    # Check if new_result has more than one item
+                    if len(new_result) > 3:
+                        for i in range(3, len(new_result)):
+                            item = new_result[i]
+                            item["format_id"] = f'{item["format_id"]} - Chrunos Shortcuts Premium Only'
+                            item["url"] = 'https://chrunos.com/premium-shortcuts/'
+                    elif 2 <= len(new_result) <= 3:
+                        last_item = new_result[-1]
+                        last_item["format_id"] = f'{last_item["format_id"]} - Chrunos Shortcuts Premium Only'
+                        last_item["url"] = 'https://chrunos.com/premium-shortcuts/'
+                    elif len(new_result) == 1:
+                        new_item = {"url": "https://chrunos.com/premium-shortcuts/",
+                                    "format_id": "Best Qaulity Video - Chrunos Shortcuts Premium Only"
+                                    }
+                        new_result.append(new_item)
+
+                    return new_result
+            else:
+                if 'url' in json_response:
+                    download_url = json_response.get('url')
+                    thumbnail_url = json_response.get('thumbnail')
+                    return [
+                        {"url": download_url,
+                         "format_id": "Normal Quality Video"
+                        },
+                        {"url": thumbnail_url,
+                         "format_id": "thumbnail"},
+                        {"url": "https://chrunos.com/premium-shortcuts/",
+                         "format_id": "Best Qaulity Video - Chrunos Shortcuts Premium Only"}
+                    ]
+                return {"error": "No formats available. Report Error on Telegram"}
+        else:
+            return {"error": f"Request failed with status code {response.status_code}, API: {api_url}"}
+    except Exception as e:
+        logger.error(f"An error occurred: {e}")
+        return {"error": str(e)}
+
+
+@app.post("/test")
+async def test_download(request: Request):
+    user_ip = get_user_ip(request)
+    if rate_limiter.is_rate_limited(user_ip):
+        current_count = rate_limiter.get_current_count(user_ip)
+        raise HTTPException(
+            status_code=429,
+            detail={
+                "error": "You have exceeded the maximum number of requests per day. Please try again tomorrow.",
+                "url": "https://t.me/chrunoss"
+            }
+        )
+    data = await request.json()
+    video_url = data.get('url')
+    response = extract_video_info(video_url)
+    return response
+
+
+@app.post("/ripper")
+async def ripper_download(request: Request):
+    user_ip = get_user_ip(request)
+    if rate_limiter.is_rate_limited(user_ip):
+        raise HTTPException(
+            status_code=429,
+            detail={
+                "error": "You have exceeded the maximum number of requests per day. Please try again tomorrow.",
+                "url": "https://t.me/chrunoss"
+            }
+        )
+    
+    data = await request.json()
+    video_url = data.get('url')
+    quality = data.get('quality', '720')  # Default to 720p
+    
+    timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+    
+    # Define format options based on quality
+    if quality == 'MP3':
+        ydl_opts = {
+            'format': 'bestaudio/best',
+            'outtmpl': str(Path(global_download_dir) / f'%(title)s_{timestamp}.%(ext)s'),
+            'postprocessors': [{
+                'key': 'FFmpegExtractAudio',
+                'preferredcodec': 'mp3',
+                'preferredquality': '192',
+            }],
+            'quiet': True,
+            'no_warnings': True,
+            'noprogress': True,
+        }
+    else:
+        # For video qualities
+        format_mapping = {
+            '360': 'best[height<=360]',
+            '480': 'best[height<=480]',
+            '720': 'best[height<=720]',
+        }
+        video_format = format_mapping.get(str(quality), 'best')
+        
+        ydl_opts = {
+            'format': video_format,
+            'outtmpl': str(Path(global_download_dir) / f'%(title)s_{timestamp}.%(ext)s'),
+            'quiet': True,
+            'no_warnings': True,
+            'noprogress': True,
+            'merge_output_format': 'mp4'
+        }
+
+    try:
+        await run_in_threadpool(lambda: yt_dlp.YoutubeDL(ydl_opts).download([video_url]))
+    except Exception as e:
+        return {"error": f"Download failed: {str(e)}"}
+
+    # Find the downloaded file
+    downloaded_files = list(Path(global_download_dir).glob(f"*_{timestamp}.*"))
+    if not downloaded_files:
+        return {"error": "Download failed"}
+    
+    downloaded_file = downloaded_files[0]
+    encoded_filename = urllib.parse.quote(downloaded_file.name)
+    download_url = f"{request.base_url}file/{encoded_filename}"
+    
+    gc.collect()
+    return {"url": download_url}
+
+
+@app.post("/hls")
+async def download_hls_video(request: Request):
+    data = await request.json()
+    hls_url = data.get('url')
+
+    timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+    output_template = str(Path(global_download_dir) / f'%(title)s_{timestamp}.%(ext)s')
+
+    ydl_opts = {
+        'format': 'best',
+        'outtmpl': output_template,
+        'quiet': True,
+        'no_warnings': True,
+        'noprogress': True,
+        'merge_output_format': 'mp4'
+    }
+
+    try:
+        await run_in_threadpool(lambda: yt_dlp.YoutubeDL(ydl_opts).download([hls_url]))
+    except Exception as e:
+        return {"error": f"Download failed: {str(e)}"}
+
+    downloaded_files = list(Path(global_download_dir).glob(f"*_{timestamp}.mp4"))
+    if not downloaded_files:
+        return {"error": "Download failed"}
+
+    downloaded_file = downloaded_files[0]
+    encoded_filename = urllib.parse.quote(downloaded_file.name)
+    # Auto-detect the base URL from the request instead of using a fixed BASE_URL
+    download_url = f"{request.base_url}file/{encoded_filename}"
+    gc.collect()
+    return {"url": download_url}