Update app.py

app.py

@@ -1,7 +1,6 @@
 import requests
 import tempfile
 import os
-import shutil
 import subprocess
 from fastapi import FastAPI, BackgroundTasks
 from pydantic import BaseModel
@@ -10,7 +9,6 @@ import re
 
 app = FastAPI(title="Neon Anime Blur & Upload")
 
-# Constants
 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"
@@ -18,11 +16,8 @@ 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_error(msg: str):
-    print(f"[HF ERROR] {msg}", flush=True)
-
-class EpisodeExceedsAvailableCount(Exception):
-    pass
+def log(msg: str):
+    print(f"[HF] {msg}", flush=True)
 
 class StartPayload(BaseModel):
     anime_id: str
@@ -30,6 +25,7 @@ class StartPayload(BaseModel):
 
 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}"
+    log(f"Fetching link for ep {episode} {quality}")
     try:
         resp = requests.get(url, timeout=20)
         resp.raise_for_status()
@@ -38,19 +34,21 @@ def download_video(anime_id: str, episode: int, quality: str) -> str | None:
             return None
         video_url = data["direct_link"]
     except:
+        log(f"Failed to get link ep {episode} {quality}")
         return None
 
-    headers = {"User-Agent": "Mozilla/5.0 Chrome/120.0", "Referer": "https://animepahe.si/"}
+    headers = {"User-Agent": "Mozilla/5.0", "Referer": "https://animepahe.si/"}
     tmp_path = tempfile.mktemp(suffix=".mp4")
+    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:
-                for chunk in r.iter_content(chunk_size=8192):
-                    f.write(chunk)
+                shutil.copyfileobj(r.raw, f)
+        log(f"Downloaded ep {episode} {quality}")
         return tmp_path
-    except Exception as e:
-        log_error(f"Download failed: {e}")
+    except:
+        log(f"Download failed ep {episode} {quality}")
         if os.path.exists(tmp_path):
             os.remove(tmp_path)
         return None
@@ -60,13 +58,16 @@ def get_filename(anime_name: str, ep: int, quality: str) -> str:
     return f"nt-animes_{slug}_ep{ep}_{quality}.mp4"
 
 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 {file_name}: {url}")
+        return url
     except Exception as e:
-        log_error(f"0x0 upload failed: {e}")
+        log(f"Upload failed: {e}")
         raise
 
 def notify_render(anime_id: str, episode: int, quality: str, file_url: str, file_name: str, status: int):
@@ -78,45 +79,34 @@ def notify_render(anime_id: str, episode: int, quality: str, file_url: str, file
         "file_name": file_name,
         "status": status
     }
+    log(f"Notifying Render status={status} ep={episode} {quality}")
     try:
         requests.post(RENDER_UPDATE_ENDPOINT, json=payload, timeout=10)
     except Exception as e:
-        log_error(f"Notify failed: {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:
     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,
         "-filter_complex", filter_graph,
-        "-map", "[v]",
-        "-map", "0:a?",
-        "-c:v", "libx264",
-        "-preset", "ultrafast",
-        "-crf", "23",
-        "-c:a", "copy",
-        output
+        "-c:v", "libx264", "-preset", "veryfast", "-crf", "23",
+        "-c:a", "copy", output
     ]
     try:
         subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
         return output
     except Exception as e:
-        log_error(f"Blur failed: {e}")
+        log(f"Blur failed: {e}")
         raise
 
 def process_anime(anime_id: str, anime_name: str):
+    log(f"Started processing {anime_id} - {anime_name}")
     episode = 1
     while True:
         episode_processed = False
@@ -125,26 +115,31 @@ def process_anime(anime_id: str, anime_name: str):
                 local_file = download_video(anime_id, episode, quality)
                 if not local_file:
                     continue
+
+                log(f"Blurring ep {episode} {quality}")
                 blurred_file = blur_video(local_file)
                 os.remove(local_file)
+
                 file_name = get_filename(anime_name, episode, quality)
                 file_url = upload_to_0x0(blurred_file, file_name)
                 os.remove(blurred_file)
+
                 notify_render(anime_id, episode, quality, file_url, file_name, 2)
                 episode_processed = True
-            except EpisodeExceedsAvailableCount:
-                notify_render(anime_id, episode, "", "", "", 5)
-                return
-            except Exception as e:
-                log_error(f"Error ep{episode} {quality}: {e}")
+
+            except Exception:
                 notify_render(anime_id, episode, quality, "", "", 3)
+
         if not episode_processed:
-            notify_render(anime_id, 0, "", "", "", 5)  # complete
+            log("No more episodes")
+            notify_render(anime_id, 0, "", "", "", 5)
             break
         episode += 1
+    log("Processing complete")
 
 @app.post("/start")
-def start_endpoint(payload: StartPayload, background_tasks: BackgroundTasks):
+def start(payload: StartPayload, bg: BackgroundTasks):
+    log(f"Queueing {payload.anime_id} - {payload.anime_name}")
     with queue_lock:
-        background_tasks.add_task(process_anime, payload.anime_id, payload.anime_name)
-    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"}