Update app.py

app.py

@@ -16,8 +16,11 @@ 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"[ERROR] {msg}", flush=True)
+
+class EpisodeExceedsAvailableCount(Exception):
+    pass
 
 class StartPayload(BaseModel):
     anime_id: str
@@ -25,33 +28,34 @@ 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 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/"
-}
-try:
-    resp = requests.get(url, headers=headers, timeout=20)
-    resp.raise_for_status()
-    data = resp.json()
-    if data.get("status") != 200:
+        "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/"
+    }
+    try:
+        resp = requests.get(url, headers=headers, timeout=20)
+        resp.raise_for_status()
+        data = resp.json()
+        if data.get("status") == 422:
+            raise EpisodeExceedsAvailableCount()
+        if data.get("status") != 200:
             return None
-    video_url = data["direct_link"]
-except:
-        log(f"Link failed ep {episode} {quality}")
+        video_url = data["direct_link"]
+    except EpisodeExceedsAvailableCount:
+        raise
+    except Exception as e:
+        log_error(f"Link failed ep {episode} {quality}: {e}")
         return None
 
     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:
                 shutil.copyfileobj(r.raw, f)
-        log(f"Downloaded ep {episode} {quality}")
         return tmp_path
-    except:
-        log(f"Download failed ep {episode} {quality}")
+    except Exception as e:
+        log_error(f"Download failed ep {episode} {quality}: {e}")
         if os.path.exists(tmp_path):
             os.remove(tmp_path)
         return None
@@ -61,16 +65,13 @@ 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()
-        url = r.text.strip()
-        log(f"Uploaded: {url}")
-        return url
+        return r.text.strip()
     except Exception as e:
-        log(f"Upload failed: {e}")
+        log_error(f"Upload failed: {e}")
         raise
 
 def notify_render(anime_id: str, episode: int, quality: str, file_url: str, file_name: str, status: int):
@@ -82,11 +83,10 @@ 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(f"Notify failed: {e}")
+        log_error(f"Notify failed: {e}")
 
 def blur_video(input_path: str) -> str:
     output = tempfile.mktemp(suffix="_blurred.mp4")
@@ -101,39 +101,41 @@ def blur_video(input_path: str) -> str:
         "-c:v", "libx264", "-preset", "fast", "-crf", "23",
         "-c:a", "copy", output
     ]
-    subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    return 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}")
+        raise
 
 def process_anime(anime_id: str, anime_name: str):
-    log(f"Started {anime_id} - {anime_name}")
     episode = 1
     while True:
         processed = False
         for quality in QUALITIES:
             try:
-                file = download_video(anime_id, episode, quality)
-                if not file:
+                local_file = download_video(anime_id, episode, quality)
+                if not local_file:
                     continue
-                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)
+                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)
                 processed = True
-            except:
+            except EpisodeExceedsAvailableCount:
+                notify_render(anime_id, 0, "", "", "", 5)
+                return
+            except Exception:
                 notify_render(anime_id, episode, quality, "", "", 3)
         if not processed:
-            log("No more episodes")
             notify_render(anime_id, 0, "", "", "", 5)
             break
         episode += 1
-    log("Complete")
 
 @app.post("/start")
-def start(payload: StartPayload, bg: BackgroundTasks):
-    log(f"Queueing {payload.anime_id} - {payload.anime_name}")
+def start_endpoint(payload: StartPayload, background_tasks: BackgroundTasks):
     with queue_lock:
-        bg.add_task(process_anime, payload.anime_id, payload.anime_name)
-    return {"code": 4, "message": "Queued"}
+        background_tasks.add_task(process_anime, payload.anime_id, payload.anime_name)
+    return {"code": 4, "message": "Job queued and processing in background"}