Update app.py

app.py

@@ -2,41 +2,42 @@ import requests
 import tempfile
 import os
 import shutil
+import cv2
+import subprocess
 from fastapi import FastAPI, BackgroundTasks
 from pydantic import BaseModel
 from threading import Lock
+import re
 
 app = FastAPI(title="Neon Anime Blur & Upload")
 
 # Constants
-CATBOX_UPLOAD_URL = "https://catbox.moe/user/api.php"  # Public endpoint works with 'reqtype=fileupload'
+CATBOX_UPLOAD_URL = "https://catbox.moe/user/api.php"
 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 to prevent HF space from overloading
 queue_lock = Lock()
 
-# Payload model
+class EpisodeExceedsAvailableCount(Exception):
+    pass
+
 class StartPayload(BaseModel):
     anime_id: str
+    anime_name: str  # New required field for public title/slug
 
 def download_video(anime_id: str, episode: int, quality: str) -> str | None:
-    """Downloads video from Ayano API. Returns local path or None if episode/quality unavailable."""
     url = f"{HF_AYANO_BASE}/anime/download?id={anime_id}&episode={episode}&quality={quality}"
     resp = requests.get(url)
     if resp.status_code != 200:
         return None
     data = resp.json()
 
-    # Stop entirely if episode number exceeds available count
     if data.get("status") == 422:
         raise EpisodeExceedsAvailableCount(f"Episode {episode} exceeds available count")
 
-    # Skip if quality is missing
     if data.get("status") != 200:
-        return None  
+        return None
 
     video_url = data["direct_link"]
     tmp_path = tempfile.mktemp(suffix=".mp4")
@@ -46,21 +47,19 @@ def download_video(anime_id: str, episode: int, quality: str) -> str | None:
             shutil.copyfileobj(r.raw, f)
     return tmp_path
 
-def rename_file(original_path: str, anime_id: str, ep: int, quality: str) -> str:
-    """Renames file according to nt-animes convention."""
-    return f"nt-animes_{anime_id}_ep{ep}_{quality}.mp4"
+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:
-    """Uploads video to public Catbox API, returns URL."""
     with open(file_path, "rb") as f:
         files = {"fileToUpload": (file_name, f)}
-        data = {"reqtype": "fileupload"}  # Public API requires no key
+        data = {"reqtype": "fileupload"}
         r = requests.post(CATBOX_UPLOAD_URL, data=data, files=files)
         r.raise_for_status()
         return r.text.strip()
 
 def notify_render(anime_id: str, episode: int, quality: str, url: str, filename: str, code: int):
-    """Send per-file update to Render."""
     payload = {
         "anime_id": anime_id,
         "episode": episode,
@@ -74,25 +73,69 @@ def notify_render(anime_id: str, episode: int, quality: str, url: str, filename:
     except Exception as e:
         print("Failed to notify Render:", e)
 
+def blur_video(input_path: str) -> str:
+    tmp_video = tempfile.mktemp(suffix="_video.mp4")
+    final_video = tempfile.mktemp(suffix="_final.mp4")
+
+    cap = cv2.VideoCapture(input_path)
+    if not cap.isOpened():
+        raise RuntimeError("Cannot open video")
+
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = cap.get(cv2.CAP_PROP_FPS)
+
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    out = cv2.VideoWriter(tmp_video, fourcc, fps, (width, height))
+
+    BLUR_W = 291
+    BLUR_H = 84
+    BLUR_KERNEL = (15, 15)
+    TEXT = "nt-animes"
+    FONT = cv2.FONT_HERSHEY_SIMPLEX
+    FONT_SCALE = 0.4
+    FONT_COLOR = (255, 255, 255)
+    FONT_THICKNESS = 1
+    TEXT_X = 8
+    TEXT_Y = 10
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        roi = frame[0:BLUR_H, 0:BLUR_W]
+        roi = cv2.GaussianBlur(roi, BLUR_KERNEL, 0)
+        frame[0:BLUR_H, 0:BLUR_W] = roi
+        cv2.putText(frame, TEXT, (TEXT_X, TEXT_Y), FONT, FONT_SCALE, FONT_COLOR, FONT_THICKNESS, cv2.LINE_AA)
+        out.write(frame)
+
+    cap.release()
+    out.release()
+
+    subprocess.run([
+        "ffmpeg", "-y", "-i", tmp_video, "-i", input_path,
+        "-c:v", "copy", "-c:a", "copy",
+        "-map", "0:v:0", "-map", "1:a:0", final_video
+    ], check=True)
+
+    os.remove(tmp_video)
+    return final_video
+
 def process_anime(anime_id: str, anime_name: str):
     episode = 1
     while True:
         episode_processed = False
         for quality in QUALITIES:
             try:
-                # Download returns None if episode/quality unavailable
                 result = download_video(anime_id, episode, quality)
                 if result is None:
-                    # If the API explicitly says episode exceeds count
                     continue
 
                 local_file = result
-
-                # Blur + watermark
                 blurred_file = blur_video(local_file)
                 os.remove(local_file)
 
-                new_name = rename_file(blurred_file, anime_name, episode, quality)
+                new_name = get_filename(anime_name, episode, quality)
                 catbox_url = upload_to_catbox_public(blurred_file, new_name)
                 os.remove(blurred_file)
 
@@ -100,22 +143,17 @@ def process_anime(anime_id: str, anime_name: str):
                 episode_processed = True
 
             except EpisodeExceedsAvailableCount:
-                # Stop the outer loop entirely if the episode doesn't exist
                 return
             except Exception as e:
                 print(f"Error ep {episode} quality {quality}: {e}")
                 notify_render(anime_id, episode, quality, "", "", code=5)
 
         if not episode_processed:
-            # No qualities were processed → stop
             break
         episode += 1
 
 @app.post("/start")
 def start_endpoint(payload: StartPayload, background_tasks: BackgroundTasks):
-    anime_id = payload.anime_id
-    # Queue lock ensures HF space doesn't get overloaded
     with queue_lock:
-        background_tasks.add_task(process_anime, anime_id)
-    # Immediately return status 4 (queued) to Render
+        background_tasks.add_task(process_anime, payload.anime_id, payload.anime_name)
     return {"code": 4, "message": "Job queued and processing in background"}