Update app.py

app.py

@@ -1,40 +1,39 @@
+# ─── flash_attn Mock ─────────────────────────────────────────────
 import sys
 import types
 import importlib.util
+
+flash_mock = types.ModuleType("flash_attn")
+flash_mock.__version__ = "2.0.0"
+flash_mock.__spec__ = importlib.util.spec_from_loader("flash_attn", loader=None)
+sys.modules["flash_attn"] = flash_mock
+sys.modules["flash_attn.flash_attn_interface"] = types.ModuleType("flash_attn.flash_attn_interface")
+sys.modules["flash_attn.bert_padding"] = types.ModuleType("flash_attn.bert_padding")
+# ─────────────────────────────────────────────────────────────────
+
+import io
 import os
 import time
 import uuid
 import threading
 import subprocess
-from io import BytesIO
-
-import cv2
 import torch
+import cv2
 from PIL import Image
-from contextlib import asynccontextmanager
+from transformers import (
+    BlipProcessor, BlipForQuestionAnswering,
+    AutoProcessor, AutoModelForCausalLM
+)
 from fastapi import FastAPI, HTTPException, UploadFile, File
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, HTMLResponse
-from transformers import (
-    BlipProcessor,
-    BlipForQuestionAnswering,
-    AutoProcessor,
-    AutoModelForCausalLM,
-)
-
-# --- flash_attn mock for CPU environments that don't provide it ---
-flash_mock = types.ModuleType("flash_attn")
-flash_mock.__version__ = "2.0.0"
-flash_mock.__spec__ = importlib.util.spec_from_loader("flash_attn", loader=None)
-sys.modules["flash_attn"] = flash_mock
-sys.modules["flash_attn.flash_attn_interface"] = types.ModuleType("flash_attn.flash_attn_interface")
-sys.modules["flash_attn.bert_padding"] = types.ModuleType("flash_attn.bert_padding")
+from contextlib import asynccontextmanager
 
-# --- Configuration ---
-BLIP_MODEL_ID = os.getenv("BLIP_MODEL_ID", "Salesforce/blip-vqa-base")
-FLORENCE_MODEL_ID = os.getenv("FLORENCE_MODEL_ID", "microsoft/Florence-2-base-ft")
+# ─── إعدادات ─────────────────────────────────────────────────────
+BLIP_MODEL_ID     = "Salesforce/blip-vqa-base"
+FLORENCE_MODEL_ID = "microsoft/Florence-2-large-ft"
 FRAMES_PER_SECOND = 1
-TEMP_DIR = os.getenv("TEMP_DIR", "/tmp/video_filter")
+TEMP_DIR          = "/tmp/video_filter"
 os.makedirs(TEMP_DIR, exist_ok=True)
 
 BLIP_QUESTIONS = [
@@ -52,83 +51,70 @@ FLORENCE_QUESTION = (
     "Answer yes or no only."
 )
 
-MODEL_DATA = {}
+MODEL_DATA   = {}
 MODEL_STATUS = {"status": "loading", "message": "جاري تحميل النماذج..."}
 
-
+# ─── تحميل النماذج في background ─────────────────────────────────
 def load_models():
     try:
-        print("Loading BLIP...", flush=True)
+        print("📥 Loading BLIP...", flush=True)
         MODEL_STATUS.update({"status": "loading", "message": "جاري تحميل BLIP..."})
         start = time.time()
         MODEL_DATA["blip_processor"] = BlipProcessor.from_pretrained(BLIP_MODEL_ID)
-        MODEL_DATA["blip_model"] = BlipForQuestionAnswering.from_pretrained(
-            BLIP_MODEL_ID,
-            torch_dtype=torch.float32,
+        MODEL_DATA["blip_model"]     = BlipForQuestionAnswering.from_pretrained(
+            BLIP_MODEL_ID, torch_dtype=torch.float32
         ).eval()
-        print(f"BLIP ready in {time.time() - start:.1f}s", flush=True)
+        print(f"✅ BLIP ready in {time.time()-start:.1f}s", flush=True)
 
-        print("Loading Florence-2...", flush=True)
+        print("📥 Loading Florence-2...", flush=True)
         MODEL_STATUS.update({"status": "loading", "message": "جاري تحميل Florence-2..."})
         start = time.time()
         MODEL_DATA["florence_processor"] = AutoProcessor.from_pretrained(
-            FLORENCE_MODEL_ID,
-            trust_remote_code=True,
+            FLORENCE_MODEL_ID, trust_remote_code=True
         )
         MODEL_DATA["florence_model"] = AutoModelForCausalLM.from_pretrained(
             FLORENCE_MODEL_ID,
             torch_dtype=torch.float32,
             trust_remote_code=True,
-            attn_implementation="eager",
+            attn_implementation="eager"
         ).eval()
-        print(f"Florence-2 ready in {time.time() - start:.1f}s", flush=True)
+        print(f"✅ Florence-2 ready in {time.time()-start:.1f}s", flush=True)
+        MODEL_STATUS.update({"status": "ready", "message": "النماذج جاهزة ✅"})
+        print("🎉 All models loaded!", flush=True)
 
-        MODEL_STATUS.update({"status": "ready", "message": "النماذج جاهزة"})
-        print("All models loaded", flush=True)
     except Exception as e:
         MODEL_STATUS.update({"status": "error", "message": str(e)})
-        print(f"Error loading models: {e}", flush=True)
-
+        print(f"❌ Error: {e}", flush=True)
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     thread = threading.Thread(target=load_models, daemon=True)
     thread.start()
-    print("Server started, models are loading in background", flush=True)
+    print("🚀 Server started! Models loading in background...", flush=True)
     yield
     MODEL_DATA.clear()
 
-
 app = FastAPI(
     title="Video Female Filter",
-    description="تحليل الفيديو وإزالة المقاطع غير المرغوبة",
+    description="BLIP + Florence-2 | Video Analysis",
     version="1.1.0",
-    lifespan=lifespan,
+    lifespan=lifespan
 )
 
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
-    allow_credentials=False,
+    allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-
-def ensure_models_ready():
-    if MODEL_STATUS["status"] != "ready":
-        raise HTTPException(
-            status_code=503,
-            detail=f"النماذج لم تكتمل بعد: {MODEL_STATUS['message']}",
-        )
-
-
+# ─── دوال النماذج ─────────────────────────────────────────────────
 def run_blip(image: Image.Image) -> dict:
-    processor = MODEL_DATA["blip_processor"]
-    model = MODEL_DATA["blip_model"]
+    processor   = MODEL_DATA["blip_processor"]
+    model       = MODEL_DATA["blip_model"]
     yes_answers = {}
-    no_answers = {}
-
+    no_answers  = {}
     for question in BLIP_QUESTIONS:
         inputs = processor(image, question, return_tensors="pt")
         with torch.no_grad():
@@ -138,232 +124,140 @@ def run_blip(image: Image.Image) -> dict:
             yes_answers[question] = answer
         else:
             no_answers[question] = answer
-
     return {"yes": yes_answers, "no": no_answers}
 
-
 def run_florence(image: Image.Image) -> str:
     processor = MODEL_DATA["florence_processor"]
-    model = MODEL_DATA["florence_model"]
-    task = "<VQA>"
-    prompt = f"{task}{FLORENCE_QUESTION}"
-    inputs = processor(text=prompt, images=image, return_tensors="pt")
-
+    model     = MODEL_DATA["florence_model"]
+    task      = "<VQA>"
+    prompt    = f"{task}{FLORENCE_QUESTION}"
+    inputs    = processor(text=prompt, images=image, return_tensors="pt")
     with torch.no_grad():
         generated_ids = model.generate(
             input_ids=inputs["input_ids"],
             pixel_values=inputs["pixel_values"],
             max_new_tokens=10,
-            do_sample=False,
+            do_sample=False
         )
-
     generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
     parsed = processor.post_process_generation(
-        generated_text,
-        task=task,
-        image_size=(image.width, image.height),
+        generated_text, task=task,
+        image_size=(image.width, image.height)
     )
     return parsed.get(task, "").strip().lower()
 
-
 def is_female_in_frame(image: Image.Image) -> tuple[bool, str]:
     blip_result = run_blip(image)
-    yes_q = blip_result["yes"]
-
+    yes_q       = blip_result["yes"]
     if "is there a woman in this image?" in yes_q:
         return True, "blip_woman"
-
     if not yes_q:
         return False, "blip_clean"
-
     florence_answer = run_florence(image)
     if "yes" in florence_answer:
         return True, "florence_confirmed"
-
     return False, "florence_clean"
 
-
-def run_cmd(command: list[str], fail_message: str):
-    result = subprocess.run(command, capture_output=True, text=True)
-    if result.returncode != 0:
-        stderr = (result.stderr or "").strip()
-        print(f"{fail_message}: {stderr}", flush=True)
-        raise RuntimeError(f"{fail_message}: {stderr or 'unknown ffmpeg error'}")
-
-
-def normalize_segments(segments: list[list[float]], duration_sec: float) -> list[list[float]]:
-    clipped = []
-    for start, end in segments:
-        s = max(0.0, min(start, duration_sec))
-        e = max(0.0, min(end, duration_sec))
-        if e - s >= 0.05:
-            clipped.append([s, e])
-
-    if not clipped:
-        return []
-
-    clipped.sort(key=lambda x: x[0])
-    merged = [clipped[0]]
-
-    for s, e in clipped[1:]:
-        last = merged[-1]
-        if s <= last[1]:
-            last[1] = max(last[1], e)
-        else:
-            merged.append([s, e])
-
-    return merged
-
-
-def build_keep_segments(female_segments: list[list[float]], duration_sec: float) -> list[list[float]]:
-    keep_segments = []
-    prev_end = 0.0
-
-    for s, e in female_segments:
-        if prev_end < s:
-            keep_segments.append([prev_end, s])
-        prev_end = e
-
-    if prev_end < duration_sec:
-        keep_segments.append([prev_end, duration_sec])
-
-    return [seg for seg in keep_segments if seg[1] - seg[0] >= 0.05]
-
-
-def render_clean_video(input_path: str, output_path: str, keep_segments: list[list[float]]):
-    if not keep_segments:
-        raise RuntimeError("No clean segments to keep")
-
-    video_parts = []
-    audio_parts = []
-
-    for i, (start, end) in enumerate(keep_segments):
-        video_parts.append(
-            f"[0:v]trim=start={start:.3f}:end={end:.3f},setpts=PTS-STARTPTS[v{i}]"
-        )
-        audio_parts.append(
-            f"[0:a]atrim=start={start:.3f}:end={end:.3f},asetpts=PTS-STARTPTS[a{i}]"
-        )
-
-    video_concat_inputs = "".join(f"[v{i}]" for i in range(len(keep_segments)))
-    audio_concat_inputs = "".join(f"[a{i}]" for i in range(len(keep_segments)))
-
-    filter_with_audio = (
-        ";".join(video_parts + audio_parts)
-        + f";{video_concat_inputs}concat=n={len(keep_segments)}:v=1:a=0[vout]"
-        + f";{audio_concat_inputs}concat=n={len(keep_segments)}:v=0:a=1[aout]"
-    )
-
-    cmd_with_audio = [
-        "ffmpeg", "-y", "-i", input_path,
-        "-filter_complex", filter_with_audio,
-        "-map", "[vout]",
-        "-map", "[aout]",
-        "-c:v", "mpeg4", "-q:v", "4",
-        "-c:a", "aac", "-b:a", "128k",
-        "-movflags", "+faststart",
-        output_path,
-    ]
-
+def run_ffmpeg(cmd: list) -> bool:
+    """تشغيل ffmpeg مع التحقق من النجاح"""
     try:
-        run_cmd(cmd_with_audio, "ffmpeg failed while building clean video with audio")
-        return
-    except RuntimeError:
-        pass
-
-    filter_video_only = (
-        ";".join(video_parts)
-        + f";{video_concat_inputs}concat=n={len(keep_segments)}:v=1:a=0[vout]"
-    )
-
-    cmd_video_only = [
-        "ffmpeg", "-y", "-i", input_path,
-        "-filter_complex", filter_video_only,
-        "-map", "[vout]",
-        "-c:v", "mpeg4", "-q:v", "4",
-        "-an",
-        "-movflags", "+faststart",
-        output_path,
-    ]
-
-    run_cmd(cmd_video_only, "ffmpeg failed while building clean video without audio")
-
-
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            print(f"⚠️ ffmpeg error: {result.stderr[:200]}", flush=True)
+            return False
+        return True
+    except Exception as e:
+        print(f"❌ ffmpeg exception: {e}", flush=True)
+        return False
+
+def cleanup_temp_files(job_id: str):
+    """حذف الملفات المؤقتة بعد الانتهاء"""
+    patterns = ["_input.mp4", "_list.txt"]
+    for p in patterns:
+        f = f"{TEMP_DIR}/{job_id}{p}"
+        if os.path.exists(f):
+            try: os.remove(f)
+            except: pass
+    # حذف ملفات الـ segments
+    i = 0
+    while True:
+        seg = f"{TEMP_DIR}/{job_id}_seg_{i}.mp4"
+        if not os.path.exists(seg): break
+        try: os.remove(seg)
+        except: pass
+        i += 1
+
+# ─── Endpoints ────────────────────────────────────────────────────
 @app.get("/", response_class=HTMLResponse)
 def root():
-    index_path = os.path.join(os.path.dirname(__file__), "index.html")
-    if not os.path.exists(index_path):
-        return HTMLResponse("<h1>API is running</h1>", status_code=200)
-    return FileResponse(index_path, media_type="text/html; charset=utf-8")
-
+    with open("index.html", "r", encoding="utf-8") as f:
+        return f.read()
 
 @app.get("/health")
 def health():
     return {
-        "status": MODEL_STATUS["status"],
-        "message": MODEL_STATUS["message"],
-        "blip_loaded": "blip_model" in MODEL_DATA,
-        "florence_loaded": "florence_model" in MODEL_DATA,
+        "status":          MODEL_STATUS["status"],
+        "message":         MODEL_STATUS["message"],
+        "blip_loaded":     "blip_model" in MODEL_DATA,
+        "florence_loaded": "florence_model" in MODEL_DATA
     }
 
-
-@app.post("/analyze-file")
-async def analyze_file(file: UploadFile = File(...)):
-    ensure_models_ready()
+# ─── فحص سريع لصورة واحدة (frame) ───────────────────────────────
+@app.post("/analyze-frame")
+async def analyze_frame(file: UploadFile = File(...)):
+    """يستخدمه الفحص السريع في الـ frontend"""
+    if MODEL_STATUS["status"] != "ready":
+        raise HTTPException(status_code=503, detail=MODEL_STATUS["message"])
 
     if not file.content_type or not file.content_type.startswith("image/"):
         raise HTTPException(status_code=400, detail="الملف ليس صورة")
 
     try:
-        image_bytes = await file.read()
-        image = Image.open(BytesIO(image_bytes)).convert("RGB")
-        has_female, reason = is_female_in_frame(image)
-
-        return {
-            "has_female": has_female,
-            "decision": "BLOCK" if has_female else "ALLOW",
-            "reason": reason,
-            "status": "success",
-        }
+        image = Image.open(io.BytesIO(await file.read())).convert("RGB")
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=400, detail=str(e))
 
+    has_female, reason = is_female_in_frame(image)
+    return {
+        "decision":   "BLOCK" if has_female else "ALLOW",
+        "has_female": has_female,
+        "reason":     reason,
+        "status":     "success"
+    }
 
+# ─── تحليل الفيديو الكامل ─────────────────────────────────────────
 @app.post("/analyze-video")
 async def analyze_video(file: UploadFile = File(...)):
-    ensure_models_ready()
+
+    if MODEL_STATUS["status"] != "ready":
+        raise HTTPException(status_code=503, detail=MODEL_STATUS["message"])
 
     if not file.content_type or not file.content_type.startswith("video/"):
         raise HTTPException(status_code=400, detail="الملف ليس فيديو")
 
-    job_id = str(uuid.uuid4())[:8]
-    input_path = f"{TEMP_DIR}/{job_id}_input.mp4"
+    job_id      = str(uuid.uuid4())[:8]
+    input_path  = f"{TEMP_DIR}/{job_id}_input.mp4"
     output_path = f"{TEMP_DIR}/{job_id}_output.mp4"
 
+    # حفظ الفيديو
     with open(input_path, "wb") as f:
         f.write(await file.read())
 
-    cap = None
     try:
-        cap = cv2.VideoCapture(input_path)
-        if not cap.isOpened():
-            raise HTTPException(status_code=400, detail="تعذر قراءة ملف الفيديو")
-
-        fps = cap.get(cv2.CAP_PROP_FPS) or 25
+        cap          = cv2.VideoCapture(input_path)
+        fps          = cap.get(cv2.CAP_PROP_FPS) or 25.0
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        if total_frames <= 0:
-            raise HTTPException(status_code=400, detail="الفيديو فارغ أو غير مدعوم")
+        duration_sec = total_frames / fps if fps > 0 else 0
 
-        duration_sec = total_frames / fps
-        print(f"Video info: frames={total_frames}, fps={fps:.2f}, duration={duration_sec:.2f}s", flush=True)
+        print(f"📹 {total_frames} frames, {fps:.1f}fps, {duration_sec:.1f}s", flush=True)
 
-        frame_interval = max(1, int(fps / FRAMES_PER_SECOND))
+        frame_interval  = max(1, int(fps / FRAMES_PER_SECOND))
         female_segments = []
-        analysis_log = []
-        in_female_seg = False
-        seg_start = 0.0
-        frame_idx = 0
-        start_time = time.time()
+        analysis_log    = []
+        in_female_seg   = False
+        seg_start       = 0.0
+        frame_idx       = 0
+        start_time      = time.time()
 
         while True:
             ret, frame = cap.read()
@@ -372,100 +266,148 @@ async def analyze_video(file: UploadFile = File(...)):
 
             if frame_idx % frame_interval == 0:
                 current_sec = frame_idx / fps
-                pil_image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+                pil_image   = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
                 has_female, reason = is_female_in_frame(pil_image)
 
                 analysis_log.append({
-                    "second": round(current_sec, 2),
+                    "second":     round(current_sec, 2),
                     "has_female": has_female,
-                    "reason": reason,
+                    "reason":     reason
                 })
+                print(f"  ⏱ {current_sec:.1f}s → {'🔴' if has_female else '🟢'} ({reason})", flush=True)
 
                 if has_female and not in_female_seg:
                     in_female_seg = True
-                    seg_start = max(0.0, current_sec - 0.5)
+                    seg_start     = max(0.0, current_sec - 0.5)
                 elif not has_female and in_female_seg:
                     in_female_seg = False
-                    female_segments.append([seg_start, min(duration_sec, current_sec + 0.5)])
+                    female_segments.append([seg_start, min(current_sec + 0.5, duration_sec)])
 
             frame_idx += 1
 
         if in_female_seg:
             female_segments.append([seg_start, duration_sec])
 
+        cap.release()
         elapsed_analysis = round(time.time() - start_time, 2)
-        female_segments = normalize_segments(female_segments, duration_sec)
 
+        # ─── لا يوجد نساء ─────────────────────────────────────────
         if not female_segments:
+            cleanup_temp_files(job_id)
             return {
-                "has_female": False,
-                "female_segments": [],
-                "analysis_log": analysis_log,
-                "message": "الفيديو نظيف ولا يحتوي على ظهور نساء",
-                "analysis_time": elapsed_analysis,
+                "has_female":       False,
+                "female_segments":  [],
+                "kept_segments":    [[0.0, duration_sec]],
+                "total_removed_sec": 0,
+                "duration_sec":     round(duration_sec, 2),
+                "analysis_log":     analysis_log,
+                "message":          "✅ الفيديو نظيف لا يحتوي على نساء",
+                "analysis_time":    elapsed_analysis,
                 "output_available": False,
-                "status": "success",
+                "status":           "success"
             }
 
-        keep_segments = build_keep_segments(female_segments, duration_sec)
+        # ─── بناء المقاطع النظيفة ─────────────────────────────────
+        keep_segments = []
+        prev_end      = 0.0
+        for s, e in female_segments:
+            if prev_end < s - 0.1:  # تجاهل فجوات أقل من 0.1s
+                keep_segments.append([round(prev_end, 3), round(s, 3)])
+            prev_end = e
+        if prev_end < duration_sec - 0.1:
+            keep_segments.append([round(prev_end, 3), round(duration_sec, 3)])
 
         if not keep_segments:
+            cleanup_temp_files(job_id)
             return {
-                "has_female": True,
-                "female_segments": female_segments,
-                "analysis_log": analysis_log,
-                "message": "الفيديو بالكامل يحتوي على ظهور نساء",
-                "analysis_time": elapsed_analysis,
-                "output_available": False,
-                "status": "success",
+                "has_female":        True,
+                "female_segments":   female_segments,
+                "kept_segments":     [],
+                "total_removed_sec": round(duration_sec, 2),
+                "duration_sec":      round(duration_sec, 2),
+                "analysis_log":      analysis_log,
+                "message":           "⚠️ الفيديو كله يحتوي على نساء",
+                "analysis_time":     elapsed_analysis,
+                "output_available":  False,
+                "status":            "success"
             }
 
-        render_clean_video(input_path, output_path, keep_segments)
-
-        if not os.path.exists(output_path):
-            raise RuntimeError("تعذر إنشاء ملف الفيديو النهائي")
-
+        # ─── قطع بـ ffmpeg ────────────────────────────────────────
+        segment_files = []
+        for i, (s, e) in enumerate(keep_segments):
+            seg_file = f"{TEMP_DIR}/{job_id}_seg_{i}.mp4"
+            ok = run_ffmpeg([
+                "ffmpeg", "-y",
+                "-i", input_path,
+                "-ss", str(s),
+                "-to", str(e),
+                "-c", "copy",
+                seg_file
+            ])
+            if ok and os.path.exists(seg_file) and os.path.getsize(seg_file) > 0:
+                segment_files.append(seg_file)
+
+        if not segment_files:
+            raise HTTPException(status_code=500, detail="فشل في إنشاء مقاطع الفيديو النظيفة")
+
+        # ─── دمج الـ segments ─────────────────────────────────────
+        list_file = f"{TEMP_DIR}/{job_id}_list.txt"
+        with open(list_file, "w") as f:
+            for seg in segment_files:
+                f.write(f"file '{seg}'\n")
+
+        ok = run_ffmpeg([
+            "ffmpeg", "-y",
+            "-f", "concat",
+            "-safe", "0",
+            "-i", list_file,
+            "-c", "copy",
+            output_path
+        ])
+
+        output_exists = ok and os.path.exists(output_path) and os.path.getsize(output_path) > 0
         total_removed = sum(e - s for s, e in female_segments)
 
+        # تنظيف الملفات المؤقتة (نبقي الـ output فقط)
+        cleanup_temp_files(job_id)
+
         return {
-            "has_female": True,
-            "female_segments": female_segments,
-            "kept_segments": keep_segments,
+            "has_female":        True,
+            "female_segments":   female_segments,
+            "kept_segments":     keep_segments,
             "total_removed_sec": round(total_removed, 2),
-            "analysis_log": analysis_log,
-            "analysis_time": elapsed_analysis,
-            "output_available": True,
-            "output_job_id": job_id,
-            "download_url": f"/download/{job_id}",
-            "message": f"تم حذف {round(total_removed, 1)} ثانية من الفيديو",
-            "status": "success",
+            "duration_sec":      round(duration_sec, 2),
+            "analysis_log":      analysis_log,
+            "analysis_time":     elapsed_analysis,
+            "output_available":  output_exists,
+            "output_job_id":     job_id if output_exists else None,
+            "download_url":      f"/download/{job_id}" if output_exists else None,
+            "message":           f"✅ تم حذف {round(total_removed, 1)} ثانية من الفيديو",
+            "status":            "success"
         }
 
     except HTTPException:
         raise
     except Exception as e:
+        print(f"❌ Error: {e}", flush=True)
         raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        if cap is not None:
-            cap.release()
-        if os.path.exists(input_path):
-            os.remove(input_path)
-
 
+# ─── تحميل الفيديو النظيف ─────────────────────────────────────────
 @app.get("/download/{job_id}")
 def download_video(job_id: str):
+    # تحقق من صحة الـ job_id
+    if not job_id.replace("-", "").isalnum():
+        raise HTTPException(status_code=400, detail="job_id غير صالح")
     output_path = f"{TEMP_DIR}/{job_id}_output.mp4"
     if not os.path.exists(output_path):
-        raise HTTPException(status_code=404, detail="الفيديو غير موجود")
-
+        raise HTTPException(status_code=404, detail="الفيديو غير موجود أو انتهت صلاحيته")
     return FileResponse(
         output_path,
         media_type="video/mp4",
-        filename="clean_video.mp4",
+        filename="clean_video.mp4"
     )
 
 
 if __name__ == "__main__":
     import uvicorn
-
-    uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PORT", "7860")))
+    uvicorn.run(app, host="0.0.0.0", port=7860)