Update detector.py

detector.py

@@ -1,21 +1,17 @@
 """
 Deepfake Detector — Hugging Face ZeroGPU Space
 V-JEPA 2.1 ViT-Giant + AttentiveClassifier probe
-
-ZEROGPU RULES (strictly followed here):
-  - No torch.cuda.is_available() in main process
-  - No map_location="cuda" in main process
-  - No .to("cuda") that actually executes in main process
-    (ZeroGPU *intercepts* .to("cuda") calls and postpones them —
-     models stay on CPU until @spaces.GPU runs)
-  - Only @spaces.GPU functions touch real GPU operations
 """
-
 import glob
 import os
 import subprocess
 import tempfile
 import warnings
+import time
+import uuid
+import json
+import requests
+from datetime import datetime
 
 warnings.filterwarnings("ignore", category=FutureWarning)
 warnings.filterwarnings("ignore", category=UserWarning)
@@ -23,12 +19,11 @@ warnings.filterwarnings("ignore", category=UserWarning)
 import gradio as gr
 import spaces
 import torch
-from huggingface_hub import hf_hub_download
-
+from huggingface_hub import hf_hub_download, HfApi
 from inference_core import AttentiveClassifier, get_video_windows
 
 # ─────────────────────────────────────────────
-# CONFIG
+# CONFIG & SECRETS
 # ─────────────────────────────────────────────
 DEVICE = "cuda"
 FEATURE_DIM = 1408
@@ -38,12 +33,15 @@ HF_TOKEN = os.environ.get("HF_TOKEN")
 ENCODER_REPO = os.environ.get("ENCODER_REPO", "")
 PROBE_REPO = os.environ.get("PROBE_REPO", ENCODER_REPO)
 
+DATASET_REPO_ID = os.environ.get("DATASET_REPO_ID", "")
+TELEGRAM_BOT_TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN", "")
+TELEGRAM_CHAT_ID = os.environ.get("TELEGRAM_CHAT_ID", "")
+
 # ─────────────────────────────────────────────
-# MODEL LOADING  (CPU — ZeroGPU intercepts CUDA calls)
+# MODEL LOADING (CPU)
 # ─────────────────────────────────────────────
 print("=" * 50)
 print("Loading V-JEPA 2.1 encoder architecture via torch.hub...")
-
 encoder, _ = torch.hub.load(
     "facebookresearch/vjepa2",
     "vjepa2_1_vit_giant_384",
@@ -67,7 +65,7 @@ del ckpt
 
 encoder = encoder.to(DEVICE).to(torch.bfloat16)
 encoder.eval()
-print("Encoder ready (on CPU, ZeroGPU will move to GPU at inference time).")
+print("Encoder ready.")
 
 print("Loading AttentiveClassifier probe...")
 probe_path = hf_hub_download(
@@ -75,6 +73,7 @@ probe_path = hf_hub_download(
     filename="attentive_probe_optimized.pt",
     token=HF_TOKEN,
 )
+
 probe_state = torch.load(probe_path, map_location="cpu")
 if "probe_state_dict" in probe_state:
     probe_state = probe_state["probe_state_dict"]
@@ -86,182 +85,257 @@ probe.eval()
 print("Probe ready.")
 print("=" * 50)
 
+# ─────────────────────────────────────────────
+# HELPER UTILS
+# ─────────────────────────────────────────────
+def extract_platform(url: str) -> str:
+    url_lower = url.lower()
+    if "instagram.com" in url_lower or "instagr.am" in url_lower:
+        return "Instagram"
+    elif "tiktok.com" in url_lower:
+        return "TikTok"
+    elif "youtube.com" in url_lower or "youtu.be" in url_lower:
+        return "YouTube"
+    else:
+        return "Direct Link / Other"
 
 # ─────────────────────────────────────────────
-# VIDEO DOWNLOAD  (pure CPU — no GPU quota used)
+# VIDEO DOWNLOAD 
 # ─────────────────────────────────────────────
 def download_video(url: str) -> tuple[bool, str]:
-    """Download via yt-dlp to a temp file. Returns (success, path_or_error)."""
     tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
     tmp.close()
 
     cmd = [
         "yt-dlp",
-        "-f",
-        "best[height<=720]/best",
-        "--max-filesize",
-        "100M",
+        "-f", "best[height<=720]/best",
+        "--max-filesize", "100M",
+        "--match-filter", "duration <= 120", 
         "--no-playlist",
         "--no-warnings",
         "--force-overwrites",
-        "-o",
-        tmp.name,
+        "-o", tmp.name,
         url,
     ]
+
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, timeout=90)
-
-        # Always print yt-dlp output so it appears in the Space Logs tab
-        print(f"[yt-dlp] returncode : {result.returncode}")
-        print(f"[yt-dlp] stdout     : {result.stdout[:800]}")
-        print(f"[yt-dlp] stderr     : {result.stderr[:800]}")
-
-        if result.returncode != 0:
-            return False, (
-                f"yt-dlp exited {result.returncode}\nstderr: {result.stderr[:600]}"
-            )
-
-        # yt-dlp sometimes writes to a different extension than the template
-        # (e.g. tmp.mp4 → tmp.mp4.webm when remux isn't needed).
-        # Search for any file that starts with tmp.name and has content.
         candidates = sorted(glob.glob(tmp.name + "*") + [tmp.name])
-        actual_file = next(
-            (f for f in candidates if os.path.exists(f) and os.path.getsize(f) > 0),
-            None,
-        )
+        actual_file = next((f for f in candidates if os.path.exists(f) and os.path.getsize(f) > 0), None)
 
         if actual_file is None:
-            return False, (
-                f"yt-dlp wrote no output (empty or missing file).\n"
-                f"stdout: {result.stdout[:400]}\n"
-                f"stderr: {result.stderr[:400]}"
-            )
+            if "does not pass filter" in result.stdout or "does not pass filter" in result.stderr:
+                return False, "Video length exceeds the maximum 2-minute limit."
+            return False, f"yt-dlp wrote no output. stderr: {result.stderr[:400]}"
 
-        print(
-            f"[yt-dlp] actual file: {actual_file} ({os.path.getsize(actual_file)} bytes)"
-        )
         return True, actual_file
-
     except subprocess.TimeoutExpired:
         return False, "Download timed out (90s limit)."
     except FileNotFoundError:
-        return False, "yt-dlp not installed. Check requirements.txt."
-
+        return False, "yt-dlp not installed."
 
 # ─────────────────────────────────────────────
-# GPU INFERENCE  (inside ZeroGPU allocation)
+# GPU INFERENCE
 # ─────────────────────────────────────────────
 @spaces.GPU(duration=120)
 def encode_and_classify(windows: list) -> list:
     scores = []
-
     for window in windows:
         clips = window["clips"]
         batch = torch.stack(clips).to(DEVICE)
-
         with torch.no_grad():
             with torch.amp.autocast("cuda", dtype=torch.bfloat16):
                 chunks = []
                 for i in range(0, batch.shape[0], ENCODER_BATCH):
                     chunks.append(encoder(batch[i : i + ENCODER_BATCH]))
                 all_feats = torch.cat(chunks, dim=0)
-
                 video_feats = all_feats.view(1, -1, FEATURE_DIM)
-
                 logit, _ = probe(video_feats)
                 prob = torch.sigmoid(logit).item()
+        scores.append({
+            "prob": prob,
+            "start_sec": window["start_sec"],
+            "end_sec": window["end_sec"],
+        })
+    return scores
 
-        scores.append(
-            {
-                "prob": prob,
-                "start_sec": window["start_sec"],
-                "end_sec": window["end_sec"],
-            }
-        )
+# ─────────────────────────────────────────────
+# DATA UPLOAD & ALERTS (CPU Network Task)
+# ─────────────────────────────────────────────
+def upload_and_notify(video_path: str, meta: dict):
+    if not DATASET_REPO_ID or not HF_TOKEN:
+        print("Upload skipped: Credentials missing.")
+        return
 
-    return scores
+    try:
+        api = HfApi(token=HF_TOKEN)
+        unique_id = str(uuid.uuid4())[:8]
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        base_filename = f"{timestamp}_{unique_id}"
+        
+        repo_video_path = f"data/video_{base_filename}.mp4"
+        repo_json_path = f"data/meta_{base_filename}.json"
+
+        # Generate the direct download/view asset URL for the video
+        direct_video_url = f"https://huggingface.co/datasets/{DATASET_REPO_ID}/resolve/main/{repo_video_path}"
+        
+        # Store the video direct link inside the metadata dictionary itself
+        meta["stored_video_url"] = direct_video_url
+
+        # 1. Upload Video File
+        api.upload_file(
+            path_or_fileobj=video_path,
+            path_in_repo=repo_video_path,
+            repo_id=DATASET_REPO_ID,
+            repo_type="dataset"
+        )
+        
+        # 2. Upload Updated Metadata JSON File
+        api.upload_file(
+            path_or_fileobj=json.dumps(meta, indent=2).encode("utf-8"),
+            path_in_repo=repo_json_path,
+            repo_id=DATASET_REPO_ID,
+            repo_type="dataset"
+        )
 
+        # 3. Send Telegram alert containing the direct video asset link
+        if TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID:
+            tele_msg = (
+                f"🚀 *New FYP Data Collected*\n\n"
+                f"• *Platform:* {meta['platform']}\n"
+                f"• *Prediction:* {meta['label']}\n"
+                f"• *Confidence:* {meta['confidence']}\n"
+                f"• *Proc Time:* {meta['processing_time_sec']}s\n"
+                f"• *Video Len:* {meta['video_duration_sec']}s\n\n"
+                f"🔗 [Original Link]({meta['url']})\n"
+                f"🎬 [Direct Video Link]({direct_video_url})"
+            )
+            requests.post(
+                f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage",
+                json={"chat_id": TELEGRAM_CHAT_ID, "text": tele_msg, "parse_mode": "Markdown", "disable_web_page_preview": True},
+                timeout=10
+            )
+    except Exception as e:
+        print(f"Data upload/notification failed: {e}")
 
 # ─────────────────────────────────────────────
 # GRADIO PREDICT
 # ─────────────────────────────────────────────
-def predict(url: str) -> tuple[str, str, str]:
+def predict(url: str, consent: bool, current_state: dict) -> tuple[str, str, str, dict]:
+    # Check mandatory consent gate
+    if not consent:
+        return "❌ Required: You must check the data collection consent box to process videos.", "", "", current_state
+
+    start_time = time.time()
     url = (url or "").strip()
+    
+    if current_state and "video_path" in current_state:
+        old_path = current_state["video_path"]
+        for f in glob.glob(old_path + "*") + [old_path]:
+            if os.path.exists(f):
+                os.remove(f)
+
     if not url:
-        return "Please enter a URL.", "", ""
+        return "Please enter a URL.", "", "", {}
 
     ok, path_or_err = download_video(url)
     if not ok:
-        return f"Download failed: {path_or_err}", "", ""
+        return f"Download failed: {path_or_err}", "", "", {}
 
     video_path = path_or_err
-    try:
-        try:
-            windows, total_frames, fps, duration_sec = get_video_windows(video_path)
-        except Exception as e:
-            return f"Video decode failed: {e}", "", ""
-
-        scores = encode_and_classify(windows)
 
-    finally:
-        # Clean up all files that share the temp base name
-        for f in glob.glob(video_path + "*") + [video_path]:
-            if os.path.exists(f):
-                os.remove(f)
+    try:
+        windows, total_frames, fps, duration_sec = get_video_windows(video_path)
+    except Exception as e:
+        if os.path.exists(video_path):
+            os.remove(video_path)
+        return f"Video decode failed: {e}", "", "", {}
+    
+    scores = encode_and_classify(windows)
 
     if not scores:
-        return "No windows processed.", "", ""
+        if os.path.exists(video_path):
+            os.remove(video_path)
+        return "No windows processed.", "", "", {}
 
     final_prob = max(s["prob"] for s in scores)
     label = "⚠️  AI-GENERATED (FAKE)" if final_prob > 0.5 else "✅  REAL"
+    elapsed_time = time.time() - start_time
     confidence = f"{final_prob * 100:.1f}%"
-
+    
     lines = [
+        f"Processing Time: {elapsed_time:.1f}s",
         f"Duration: {duration_sec:.1f}s  |  Frames: {total_frames}  |  Windows: {len(scores)}\n"
     ]
     for s in scores:
         flag = "  ← peak" if (s["prob"] == final_prob and final_prob > 0.5) else ""
-        lines.append(
-            f"  [{s['start_sec']:.1f}s – {s['end_sec']:.1f}s]  →  {s['prob'] * 100:.1f}% fake{flag}"
-        )
+        lines.append(f"  [{s['start_sec']:.1f}s – {s['end_sec']:.1f}s]  →  {s['prob'] * 100:.1f}% fake{flag}")
+
+    # Build base metadata dict
+    meta = {
+        "url": url,
+        "platform": extract_platform(url),
+        "label": label,
+        "confidence": confidence,
+        "processing_time_sec": round(elapsed_time, 2),
+        "video_duration_sec": round(duration_sec, 2),
+        "total_frames": total_frames
+    }
 
-    return label, confidence, "\n".join(lines)
+    # Execute backend background syncing task
+    upload_and_notify(video_path, meta)
 
+    # Clean up local system file tracking loop paths
+    for f in glob.glob(video_path + "*") + [video_path]:
+        if os.path.exists(f):
+            os.remove(f)
+
+    return label, confidence, "\n".join(lines), {}
 
 # ─────────────────────────────────────────────
 # GRADIO UI
 # ─────────────────────────────────────────────
 with gr.Blocks(title="Deepfake Detector") as demo:
+    session_state = gr.State(value={})
+
     gr.Markdown(
         """
         ## 🎬 Deepfake Video Detector
-        Paste a public Instagram, TikTok, or direct `.mp4` URL.
+        Paste a public Instagram, TikTok, or direct `.mp4` URL. (Maximum duration: 2 minutes).
         Uses **V-JEPA 2.1 ViT-Giant** + **AttentiveClassifier** probe.
         """
     )
-
+    
     url_box = gr.Textbox(
         label="Video URL",
         placeholder="https://www.instagram.com/reels/...",
         autofocus=True,
     )
+    
+    # Mandatory Consent Checkbox
+    consent_box = gr.Checkbox(
+        label="I allow the developer to securely save this video and its results for an academic Final Year Project.",
+        value=False,
+        interactive=True
+    )
+    
     run_btn = gr.Button("Analyze", variant="primary")
-
+    
     with gr.Row():
         label_out = gr.Textbox(label="Prediction", scale=2)
         conf_out = gr.Textbox(label="Confidence", scale=1)
-
-    breakdown_out = gr.Textbox(label="Window Breakdown", lines=6, interactive=False)
+        
+    breakdown_out = gr.Textbox(label="Window Breakdown & Processing Time", lines=6, interactive=False)
 
     run_btn.click(
         fn=predict,
-        inputs=url_box,
-        outputs=[label_out, conf_out, breakdown_out],
+        inputs=[url_box, consent_box, session_state],
+        outputs=[label_out, conf_out, breakdown_out, session_state],
     )
     url_box.submit(
         fn=predict,
-        inputs=url_box,
-        outputs=[label_out, conf_out, breakdown_out],
+        inputs=[url_box, consent_box, session_state],
+        outputs=[label_out, conf_out, breakdown_out, session_state],
     )
 
-demo.launch(share=True)
+demo.launch()