Update app.py

app.py

@@ -2,7 +2,6 @@ import requests
 import tempfile
 import os
 import shutil
-#import cv2
 import subprocess
 from fastapi import FastAPI, BackgroundTasks
 from pydantic import BaseModel
@@ -12,103 +11,77 @@ import re
 app = FastAPI(title="Neon Anime Blur & Upload")
 
 # Constants
-CATBOX_UPLOAD_URL = "https://catbox.moe/user/api.php"
+UPLOAD_URL = "https://0x0.st"
 RENDER_UPDATE_ENDPOINT = "https://nt-anime-api.onrender.com/update"
 HF_AYANO_BASE = "https://a-y-a-n-o-k-o-j-i-dnd-api.hf.space"
 
 QUALITIES = ["360p", "720p", "1080p"]
 queue_lock = Lock()
 
-def log(msg: str):
-    print(f"[HF] {msg}", flush=True)
+def log_error(msg: str):
+    print(f"[HF ERROR] {msg}", flush=True)
 
 class EpisodeExceedsAvailableCount(Exception):
     pass
 
 class StartPayload(BaseModel):
     anime_id: str
-    anime_name: str  # New required field for public title/slug
+    anime_name: str
 
 def download_video(anime_id: str, episode: int, quality: str) -> str | None:
     url = f"{HF_AYANO_BASE}/anime/download?id={anime_id}&episode={episode}&quality={quality}"
-    print(f"[HF] Calling Ayano: {url}")
-
-    resp = requests.get(url, timeout=20)
-    if resp.status_code != 200:
-        print("[HF] Ayano non-200")
-        return None
-
-    data = resp.json()
-    print(f"[HF] Ayano JSON: {data}")
-
-    if data.get("status") != 200:
+    try:
+        resp = requests.get(url, timeout=20)
+        resp.raise_for_status()
+        data = resp.json()
+        if data.get("status") != 200:
+            return None
+        video_url = data["direct_link"]
+    except:
         return None
 
-    video_url = data["direct_link"]
-
-    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"
-        ),
-        "Referer": "https://animepahe.si/",
-        "Accept": "*/*",
-        "Connection": "keep-alive",
-    }
-
+    headers = {"User-Agent": "Mozilla/5.0 Chrome/120.0", "Referer": "https://animepahe.si/"}
     tmp_path = tempfile.mktemp(suffix=".mp4")
-    print(f"[HF] Downloading video from: {video_url}")
-
-    with requests.get(video_url, headers=headers, stream=True, timeout=60) as r:
-        r.raise_for_status()
-        with open(tmp_path, "wb") as f:
-            shutil.copyfileobj(r.raw, f)
-
-    print(f"[HF] Download complete → {tmp_path}")
-    return tmp_path
+    try:
+        with requests.get(video_url, headers=headers, stream=True, timeout=120) as r:
+            r.raise_for_status()
+            with open(tmp_path, "wb") as f:
+                for chunk in r.iter_content(chunk_size=8192):
+                    f.write(chunk)
+        return tmp_path
+    except Exception as e:
+        log_error(f"Download failed: {e}")
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+        return None
 
 def get_filename(anime_name: str, ep: int, quality: str) -> str:
     slug = re.sub(r'[^a-z0-9-]+', '-', anime_name.lower()).strip('-')
     return f"nt-animes_{slug}_ep{ep}_{quality}.mp4"
 
-def upload_to_catbox_public(file_path: str, file_name: str) -> str:
-    size_mb = os.path.getsize(file_path) / (1024 * 1024)
-    log(f"Uploading to Catbox: {file_name} (Size: {size_mb:.2f} MB)")
-
-    with open(file_path, "rb") as f:
-        files = {"fileToUpload": (file_name, f)}
-        data = {"reqtype": "fileupload"}
-
-        r = requests.post(CATBOX_UPLOAD_URL, data=data, files=files, timeout=60)
-        log(f"Catbox response status {r.status_code}")
-        log(f"Catbox response text: {r.text}")
-
-        if r.status_code == 412 or "too large" in r.text.lower():
-            log("❌ ERROR: File too large (greater than 200 MB)")
-
-        catbox_url = (f"{r.text}")
-
+def upload_to_0x0(file_path: str, file_name: str) -> str:
+    try:
+        with open(file_path, "rb") as f:
+            r = requests.post(UPLOAD_URL, files={"file": (file_name, f)}, timeout=180)
         r.raise_for_status()
         return r.text.strip()
+    except Exception as e:
+        log_error(f"0x0 upload failed: {e}")
+        raise
 
-def notify_render(anime_id, episode, quality, catbox_url, file_name, status):
+def notify_render(anime_id: str, episode: int, quality: str, file_url: str, file_name: str, status: int):
     payload = {
         "anime_id": anime_id,
         "episode": episode,
         "quality": quality,
-        "file_url": catbox_url,
+        "file_url": file_url,
         "file_name": file_name,
         "status": status
     }
-
-    log(f"Notify render → {payload}")
-
     try:
-        r = requests.post(RENDER_UPDATE_ENDPOINT, json=payload, timeout=10)
-        log(f"Render response {r.status_code}")
+        requests.post(RENDER_UPDATE_ENDPOINT, json=payload, timeout=10)
     except Exception as e:
-        log(f"⚠️ Render notify failed: {repr(e)}")
+        log_error(f"Notify failed: {e}")
 
 BLUR_W = 74
 BLUR_H = 17
@@ -119,104 +92,59 @@ TEXT_X = 8
 TEXT_Y = 8
 
 def blur_video(input_path: str) -> str:
-    tmp_video = tempfile.mktemp(suffix="_video.mp4")
-    final_video = tempfile.mktemp(suffix="_final.mp4")
-
-    # FFmpeg filtergraph: blur + text overlay
+    output = tempfile.mktemp(suffix="_blurred.mp4")
     filter_graph = (
         f"[0:v]crop={BLUR_W}:{BLUR_H}:0:0,boxblur=luma_radius=4:luma_power=1:chroma_radius=0[top];"
         f"[0:v][top]overlay=0:0,"
         f"drawtext=text={TEXT}:x={TEXT_X}:y={TEXT_Y}:fontcolor={FONT_COLOR}:fontsize={FONT_SIZE}[v]"
     )
-
     cmd = [
-        "ffmpeg",
-        "-y",
-        "-i", input_path,
+        "ffmpeg", "-y", "-i", input_path,
         "-filter_complex", filter_graph,
         "-map", "[v]",
         "-map", "0:a?",
         "-c:v", "libx264",
-        "-preset", "veryfast",
+        "-preset", "ultrafast",
         "-crf", "23",
         "-c:a", "copy",
-        tmp_video
+        output
     ]
-
-    subprocess.run(cmd, check=True)
-
-    # Move temp_video to final_video like your OpenCV version
-    os.rename(tmp_video, final_video)
-    return final_video
+    try:
+        subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return output
+    except Exception as e:
+        log_error(f"Blur failed: {e}")
+        raise
 
 def process_anime(anime_id: str, anime_name: str):
-    log(f"PROCESS STARTED for anime_id={anime_id}")
-
     episode = 1
     while True:
-        log(f"--- EPISODE LOOP START ep={episode} ---")
         episode_processed = False
-
         for quality in QUALITIES:
-            log(f"Trying ep={episode}, quality={quality}")
-
             try:
                 local_file = download_video(anime_id, episode, quality)
-
-                if local_file is None:
-                    log(f"No video for ep={episode} quality={quality}")
+                if not local_file:
                     continue
-
-                log(f"Downloaded file: {local_file}")
-
                 blurred_file = blur_video(local_file)
-                log(f"Blurred file created: {blurred_file}")
-
                 os.remove(local_file)
-                log(f"Removed original file")
-
-                new_name = get_filename(anime_name, episode, quality)
-                log(f"Renamed to: {new_name}")
-
-                catbox_url = upload_to_catbox_public(blurred_file, new_name)
-                log(f"Uploaded to Catbox: {catbox_url}")
-
+                file_name = get_filename(anime_name, episode, quality)
+                file_url = upload_to_0x0(blurred_file, file_name)
                 os.remove(blurred_file)
-                log("Removed blurred temp file")
-
-                notify_render(
-                    anime_id, episode, quality,
-                    catbox_url, new_name, status=2
-                )
-                log(f"Notified render SUCCESS ep={episode} quality={quality}")
-
+                notify_render(anime_id, episode, quality, file_url, file_name, 2)
                 episode_processed = True
-
             except EpisodeExceedsAvailableCount:
-                log("🚨 EPISODE LIMIT REACHED (422)")
-                notify_render(anime_id, episode, "", "", "", status=5)
-                log("Sent FINAL status=5 to render, stopping")
+                notify_render(anime_id, episode, "", "", "", 5)
                 return
-
             except Exception as e:
-                log(f"❌ ERROR ep={episode} quality={quality}: {repr(e)}")
-                notify_render(anime_id, episode, quality, "", "", status=3)
-
+                log_error(f"Error ep{episode} {quality}: {e}")
+                notify_render(anime_id, episode, quality, "", "", 3)
         if not episode_processed:
-            log("No qualities processed → stopping episode loop")
+            notify_render(anime_id, 0, "", "", "", 5)  # complete
             break
-
         episode += 1
 
-    log("PROCESS FINISHED NORMALLY")
-
 @app.post("/start")
 def start_endpoint(payload: StartPayload, background_tasks: BackgroundTasks):
-    log(f"/start called with anime_id={payload.anime_id}, anime_name={payload.anime_name}")
-
     with queue_lock:
-        log("Queue lock acquired, scheduling background task")
         background_tasks.add_task(process_anime, payload.anime_id, payload.anime_name)
-
-    log("Background task scheduled, returning code 4")
     return {"code": 4, "message": "Job queued and processing in background"}