Update app.py

app.py

@@ -1,8 +1,6 @@
 import requests
 import tempfile
 import os
-import shutil
-#import cv2
 import subprocess
 from fastapi import FastAPI, BackgroundTasks
 from pydantic import BaseModel
@@ -11,8 +9,7 @@ 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"
 
@@ -22,201 +19,121 @@ queue_lock = Lock()
 def log(msg: str):
     print(f"[HF] {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:
-        return None
-
-    video_url = data["direct_link"]
-
+    log(f"Fetching link ep {episode} {quality}")
     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",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0 Safari/537.36",
+        "Referer": "https://animepahe.si/"
     }
+    try:
+        resp = requests.get(url, headers=headers, timeout=20)
+        resp.raise_for_status()
+        data = resp.json()
+        if data.get("status") != 200:
+            return None
+        video_url = data["direct_link"]
+    except:
+        log(f"Link failed ep {episode} {quality}")
+        return None
 
     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
+    log(f"Downloading ep {episode} {quality}")
+    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:
+                shutil.copyfileobj(r.raw, f)
+        log(f"Downloaded ep {episode} {quality}")
+        return tmp_path
+    except:
+        log(f"Download failed ep {episode} {quality}")
+        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:
+    log(f"Uploading {file_name}")
+    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()
+        url = r.text.strip()
+        log(f"Uploaded: {url}")
+        return url
+    except Exception as e:
+        log(f"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}")
-
+    log(f"Notifying Render status={status} ep={episode} {quality}")
     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)}")
-
-BLUR_W = 74
-BLUR_H = 17
-TEXT = "nt-animes"
-FONT_COLOR = "white"
-FONT_SIZE = 12
-TEXT_X = 8
-TEXT_Y = 8
+        log(f"Notify failed: {e}")
 
 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]"
+        "[0:v]crop=74:17:0:0,boxblur=luma_radius=4:luma_power=1:chroma_radius=0[top];"
+        "[0:v][top]overlay=0:0,"
+        "drawtext=text='nt-animes':x=8:y=8:fontcolor=white:fontsize=12"
     )
-
     cmd = [
-        "ffmpeg",
-        "-y",
-        "-i", input_path,
+        "ffmpeg", "-y", "-i", input_path,
         "-filter_complex", filter_graph,
-        "-map", "[v]",
-        "-map", "0:a?",
-        "-c:v", "libx264",
-        "-preset", "fast",
-        "-crf", "23",
-        "-c:a", "copy",
-        tmp_video
+        "-c:v", "libx264", "-preset", "fast", "-crf", "23",
+        "-c:a", "copy", 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
+    subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    return output
 
 def process_anime(anime_id: str, anime_name: str):
-    log(f"PROCESS STARTED for anime_id={anime_id}")
-
+    log(f"Started {anime_id} - {anime_name}")
     episode = 1
     while True:
-        log(f"--- EPISODE LOOP START ep={episode} ---")
-        episode_processed = False
-
+        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}")
+                file = download_video(anime_id, episode, quality)
+                if not 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}")
-
-                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}")
-
-                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")
-                return
-
-            except Exception as e:
-                log(f"❌ ERROR ep={episode} quality={quality}: {repr(e)}")
-                notify_render(anime_id, episode, quality, "", "", status=3)
-
-        if not episode_processed:
-            log("No qualities processed → stopping episode loop")
+                log(f"Blurring ep {episode} {quality}")
+                blurred = blur_video(file)
+                os.remove(file)
+                name = get_filename(anime_name, episode, quality)
+                url = upload_to_0x0(blurred, name)
+                os.remove(blurred)
+                notify_render(anime_id, episode, quality, url, name, 2)
+                processed = True
+            except:
+                notify_render(anime_id, episode, quality, "", "", 3)
+        if not processed:
+            log("No more episodes")
+            notify_render(anime_id, 0, "", "", "", 5)
             break
-
         episode += 1
-
-    log("PROCESS FINISHED NORMALLY")
+    log("Complete")
 
 @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}")
-
+def start(payload: StartPayload, bg: BackgroundTasks):
+    log(f"Queueing {payload.anime_id} - {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"}
+        bg.add_task(process_anime, payload.anime_id, payload.anime_name)
+    return {"code": 4, "message": "Queued"}