Update app.py

app.py

@@ -1,323 +1,483 @@
+"""
+================================================================================
+  VERIDEX — Master UI / Orchestrator Space  (DeepFake-Detector-UI)
+  ──────────────────────────────────────────────────────────────────
+  Architecture
+  ────────────
+  • FastAPI serves the custom deepfake-detector.html at GET /
+  • POST /predict/  accepts a raw .mp4 upload
+      1. Saves video to a temp file
+      2. MTCNN extracts up to NUM_FRAMES faces (380 × 380, uint8 HWC)
+      3. Batch is saved as a compressed .npy file
+      4. Fires the .npy at all 7 Workers in parallel via gradio_client
+      5. Aggregates per-frame predictions with confident_strategy
+      6. Returns JSON { prediction, score, filename, worker_results }
+
+  ENV VARS (set in HF Space settings)
+  ─────────────────────────────────────
+  WORKER_1_URL  …  WORKER_7_URL   — public Gradio Space URLs for each worker
+                                    e.g. https://your-user-deepfake-worker-1.hf.space
+  NUM_FRAMES        default 32    — frames to sample per video
+  WORKER_TIMEOUT    default 120   — seconds to wait per worker call
+================================================================================
+"""
+
 import os
+import io
+import time
+import uuid
+import logging
+import tempfile
+import traceback
+import traceback as _tb
+from concurrent.futures import ThreadPoolExecutor, as_completed, TimeoutError as FuturesTimeout
+from pathlib import Path
+from typing import Optional
+
 import cv2
-import torch
 import numpy as np
-from PIL import Image
-import gradio as gr
+import torch
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+import uvicorn
 from gradio_client import Client, handle_file
-from facenet_pytorch.models.mtcnn import MTCNN
-import concurrent.futures
-import tempfile
-from fastapi import FastAPI, UploadFile, File
-from fastapi.responses import HTMLResponse
-import shutil
-
-# ==========================================
-# 1. API ROUTER
-# ==========================================
-WORKER_SPACES = [
-    "bithal26/DeepFake-Worker-1",
-    "bithal26/DeepFake-Worker-2",
-    "bithal26/DeepFake-Worker-3",
-    "bithal26/DeepFake-Worker-4",
-    "bithal26/DeepFake-Worker-5",
-    "bithal26/DeepFake-Worker-6",
-    "bithal26/DeepFake-Worker-7"
-]
-
-clients = []
-print("Initializing connections to 7 API Workers...")
-for space in WORKER_SPACES:
-    try:
-        clients.append(Client(space))
-    except Exception as e:
-        print(f"Warning: Could not connect to {space}. Error: {e}")
 
-# ==========================================
-# 2. PREPROCESSING ENGINE
-# ==========================================
-device = torch.device('cpu')
+# ─────────────────────────────────────────────────────────────────────────────
+#  Optional: facenet-pytorch for MTCNN face detection
+# ─────────────────────────────────────────────────────────────────────────────
+try:
+    from facenet_pytorch import MTCNN
+    FACENET_AVAILABLE = True
+except ImportError:
+    FACENET_AVAILABLE = False
+    logging.warning(
+        "facenet-pytorch not installed — falling back to full-frame "
+        "centre-crop for face extraction."
+    )
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [UI] %(levelname)s %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Configuration
+# ══════════════════════════════════════════════════════════════════════════════
+
+NUM_FRAMES     = int(os.environ.get("NUM_FRAMES", "32"))
+WORKER_TIMEOUT = int(os.environ.get("WORKER_TIMEOUT", "120"))
+INPUT_SIZE     = 380   # must match worker expectation
+
+# Worker URLs — read from env vars so no secrets are hard-coded
+WORKER_URLS: list[str] = [
+    url for url in (
+        os.environ.get(f"WORKER_{i}_URL", "").strip()
+        for i in range(1, 8)
+    )
+    if url
+]
 
-def isotropically_resize_image(img, size, interpolation_down=cv2.INTER_AREA, interpolation_up=cv2.INTER_CUBIC):
+if not WORKER_URLS:
+    logger.warning(
+        "No WORKER_*_URL env vars set. "
+        "Set WORKER_1_URL … WORKER_7_URL in Space settings."
+    )
+
+# ── HTML template path ────────────────────────────────────────────────────────
+HTML_FILE = Path(__file__).parent / "deepfake-detector.html"
+
+# ── MTCNN ─────────────────────────────────────────────────────────────────────
+if FACENET_AVAILABLE:
+    # keep_all=True returns every detected face per frame
+    _mtcnn = MTCNN(
+        keep_all=True,
+        device="cuda" if torch.cuda.is_available() else "cpu",
+        select_largest=False,
+        post_process=False,   # return raw uint8 tensors, not normalised
+        image_size=INPUT_SIZE,
+        margin=20,
+    )
+    logger.info("MTCNN initialised.")
+else:
+    _mtcnn = None
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Face extraction helpers
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _isotropic_resize(img: np.ndarray, size: int) -> np.ndarray:
     h, w = img.shape[:2]
-    if max(w, h) == size: return img
-    scale = size / w if w > h else size / h
-    w, h = w * scale, h * scale
-    interpolation = interpolation_up if scale > 1 else interpolation_down
-    return cv2.resize(img, (int(w), int(h)), interpolation=interpolation)
-
-def put_to_center(img, input_size):
-    img = img[:input_size, :input_size]
-    image = np.zeros((input_size, input_size, 3), dtype=np.uint8)
-    start_w = (input_size - img.shape[1]) // 2
-    start_h = (input_size - img.shape[0]) // 2
-    image[start_h:start_h + img.shape[0], start_w: start_w + img.shape[1], :] = img
-    return image
-
-class VideoReader:
-    def read_frames(self, path, num_frames):
-        capture = cv2.VideoCapture(path)
-        frame_count = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
-        if frame_count <= 0: return None
-        frame_idxs = np.linspace(0, frame_count - 1, num_frames, endpoint=True, dtype=np.int32)
-        frames, idxs_read = [], []
-        for frame_idx in range(frame_idxs[0], frame_idxs[-1] + 1):
-            ret = capture.grab()
-            if not ret: break
-            current = len(idxs_read)
-            if frame_idx == frame_idxs[current]:
-                ret, frame = capture.retrieve()
-                if not ret or frame is None: break
-                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                frames.append(frame)
-                idxs_read.append(frame_idx)
-        capture.release()
-        return np.stack(frames), idxs_read if len(frames) > 0 else None
-
-class FaceExtractor:
-    def __init__(self):
-        self.video_reader = VideoReader()
-        self.detector = MTCNN(margin=0, thresholds=[0.7, 0.8, 0.8], device=device)
-
-    def process_video(self, video_path, frames_per_video=32): 
-        result = self.video_reader.read_frames(video_path, num_frames=frames_per_video)
-        if result is None: return []
-        my_frames, my_idxs = result
-        results = []
-        for frame in my_frames:
-            img = Image.fromarray(frame.astype(np.uint8))
-            img = img.resize(size=[s // 2 for s in img.size])
-            batch_boxes, probs = self.detector.detect(img, landmarks=False)
-            faces = []
-            if batch_boxes is not None:
-                for bbox in batch_boxes:
-                    if bbox is not None:
-                        xmin, ymin, xmax, ymax = [int(b * 2) for b in bbox]
-                        w, h = xmax - xmin, ymax - ymin
-                        p_h, p_w = h // 3, w // 3
-                        crop = frame[max(ymin - p_h, 0):ymax + p_h, max(xmin - p_w, 0):xmax + p_w]
-                        faces.append(crop)
-            if faces:
-                results.append({"faces": faces})
-        return results
-
-face_extractor = FaceExtractor()
-
-def confident_strategy(pred, t=0.8):
-    pred = np.array(pred)
-    sz = len(pred)
-    if sz == 0: return 0.5
-    fakes = np.count_nonzero(pred > t)
-    if fakes > sz // 2.5 and fakes > 11:
-        return float(np.mean(pred[pred > t]))
-    elif np.count_nonzero(pred < 0.2) > 0.9 * sz:
-        return float(np.mean(pred[pred < 0.2]))
-    else:
-        return float(np.mean(pred))
-
-def call_worker(client, filepath):
+    if max(h, w) == size:
+        return img
+    scale = size / max(h, w)
+    new_h, new_w = int(h * scale), int(w * scale)
+    interp = cv2.INTER_CUBIC if scale > 1 else cv2.INTER_AREA
+    return cv2.resize(img, (new_w, new_h), interpolation=interp)
+
+
+def _put_to_center(img: np.ndarray, size: int) -> np.ndarray:
+    img = img[:size, :size]
+    canvas = np.zeros((size, size, 3), dtype=np.uint8)
+    sh = (size - img.shape[0]) // 2
+    sw = (size - img.shape[1]) // 2
+    canvas[sh : sh + img.shape[0], sw : sw + img.shape[1]] = img
+    return canvas
+
+
+def _extract_faces_mtcnn(video_path: str, num_frames: int) -> Optional[np.ndarray]:
+    """
+    Use MTCNN to detect and crop faces from evenly-spaced video frames.
+    Returns uint8 numpy array of shape (N, INPUT_SIZE, INPUT_SIZE, 3) or None.
+    """
+    cap = cv2.VideoCapture(video_path)
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    if total <= 0:
+        cap.release()
+        return None
+
+    idxs = np.linspace(0, total - 1, num_frames, dtype=np.int32)
+    faces_collected: list[np.ndarray] = []
+
+    for idx in idxs:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, int(idx))
+        ret, frame_bgr = cap.read()
+        if not ret:
+            continue
+        frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+        from PIL import Image as _PILImage
+        pil_frame = _PILImage.fromarray(frame_rgb)
+
+        try:
+            boxes, _ = _mtcnn.detect(pil_frame)
+            if boxes is None:
+                # No face detected — fall back to centre crop of whole frame
+                face = _isotropic_resize(frame_rgb, INPUT_SIZE)
+                face = _put_to_center(face, INPUT_SIZE)
+                faces_collected.append(face)
+                continue
+
+            for box in boxes:
+                x1, y1, x2, y2 = [int(c) for c in box]
+                x1, y1 = max(0, x1), max(0, y1)
+                x2, y2 = min(frame_rgb.shape[1], x2), min(frame_rgb.shape[0], y2)
+                crop = frame_rgb[y1:y2, x1:x2]
+                if crop.size == 0:
+                    continue
+                face = _isotropic_resize(crop, INPUT_SIZE)
+                face = _put_to_center(face, INPUT_SIZE)
+                faces_collected.append(face)
+
+        except Exception as exc:
+            logger.warning(f"MTCNN failed on frame {idx}: {exc}")
+            face = _isotropic_resize(frame_rgb, INPUT_SIZE)
+            face = _put_to_center(face, INPUT_SIZE)
+            faces_collected.append(face)
+
+    cap.release()
+    if not faces_collected:
+        return None
+    return np.stack(faces_collected[:num_frames * 4], axis=0).astype(np.uint8)
+
+
+def _extract_faces_fallback(video_path: str, num_frames: int) -> Optional[np.ndarray]:
+    """Centre-crop fallback when facenet-pytorch is not available."""
+    cap = cv2.VideoCapture(video_path)
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    if total <= 0:
+        cap.release()
+        return None
+
+    idxs = np.linspace(0, total - 1, num_frames, dtype=np.int32)
+    frames = []
+    for idx in idxs:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, int(idx))
+        ret, frame_bgr = cap.read()
+        if not ret:
+            continue
+        frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+        face = _isotropic_resize(frame_rgb, INPUT_SIZE)
+        face = _put_to_center(face, INPUT_SIZE)
+        frames.append(face)
+    cap.release()
+
+    if not frames:
+        return None
+    return np.stack(frames, axis=0).astype(np.uint8)
+
+
+def extract_faces(video_path: str) -> Optional[np.ndarray]:
+    if FACENET_AVAILABLE and _mtcnn is not None:
+        return _extract_faces_mtcnn(video_path, NUM_FRAMES)
+    return _extract_faces_fallback(video_path, NUM_FRAMES)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Aggregation strategy  (mirrors deepfake_det.py confident_strategy)
+# ══════════════════════════════════════════════════════════════════════════════
+
+def confident_strategy(pred: np.ndarray, t: float = 0.8) -> float:
+    pred = np.array(pred, dtype=np.float32)
+    if len(pred) == 0:
+        return 0.5
+    confident_fake = pred[pred > t]
+    if len(confident_fake) >= 1:
+        return float(np.mean(confident_fake))
+    confident_real = pred[pred < (1 - t)]
+    if len(confident_real) >= 1:
+        return float(np.mean(confident_real))
+    return float(np.mean(pred))
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Worker communication
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _call_worker(worker_url: str, npy_path: str, worker_idx: int) -> dict:
+    """
+    Call one Worker Space via gradio_client.
+    Returns a dict with keys: worker, predictions, n_frames, error, score
+    """
+    result_stub = {"worker": worker_idx, "predictions": None, "n_frames": 0,
+                   "error": None, "score": 0.5}
     try:
-        # Pass positional argument to avoid Gradio 4 keyword parsing issues
-        result = client.predict(handle_file(filepath), api_name="/predict")
-        
-        # Log backend errors if they happen
-        if isinstance(result, dict) and "error" in result:
-            print(f"Worker Error: {result['error']}")
-            return 0.5 
-            
-        preds = result.get("predictions", []) if isinstance(result, dict) else []
-        if not preds: return 0.5 
-        return confident_strategy(preds)
-    except Exception as e:
-        print(f"Network Connection Error: {e}")
-        return 0.5 
-
-# ==========================================
-# 3. FASTAPI SERVER & HTML INJECTION
-# ==========================================
-app = FastAPI()
-
-JS_OVERRIDE = """
-<script>
-  function handleDrop(e) {
-    e.preventDefault();
-    document.getElementById('uploadZone').classList.remove('dragging');
-    const file = e.dataTransfer.files[0];
-    if (file) startAnalysis(file);
-  }
-
-  function startAnalysis(file) {
-    if (!file) return;
-    const overlay = document.getElementById('analyzeOverlay');
-    overlay.classList.add('visible');
-
-    const steps = ['step1','step2','step3','step4','step5','step6'];
-    const labels = [
-      'Decoding video frames...',
-      'Extracting facial landmarks...',
-      'Running 7 parallel neural models...',
-      'Frequency domain analysis...',
-      'Temporal coherence check...',
-      'Generating forensic report...'
-    ];
-
-    let currentStep = 0;
-    const interval = setInterval(() => {
-      if (currentStep > 0) document.getElementById(steps[currentStep - 1]).className = 'a-step done';
-      if (currentStep < steps.length) {
-        document.getElementById(steps[currentStep]).className = 'a-step active';
-        document.getElementById('analyzeText').textContent = labels[currentStep];
-        currentStep++;
-      }
-    }, 450);
-
-    const formData = new FormData();
-    formData.append('file', file);
-    const startTime = performance.now();
-
-    fetch('/api/analyze', { method: 'POST', body: formData })
-      .then(res => res.json())
-      .then(data => {
-        clearInterval(interval);
-        steps.forEach(s => document.getElementById(s).className = 'a-step');
-        overlay.classList.remove('visible');
-
-        if (data.error) {
-            alert("Analysis Error: " + data.error);
-            return;
+        client = Client(worker_url, verbose=False)
+        # handle_file wraps the filepath so gradio_client sends it correctly
+        response = client.predict(
+            npy_file=handle_file(npy_path),
+            api_name="/predict",
+        )
+
+        # response may be the dict directly or a JSON string
+        if isinstance(response, str):
+            import json
+            response = json.loads(response)
+
+        if not isinstance(response, dict):
+            raise TypeError(f"Unexpected worker response type: {type(response)}")
+
+        worker_error = response.get("error")
+        predictions  = response.get("predictions")
+
+        if worker_error:
+            # Worker returned an application-level error — log it fully
+            logger.error(
+                f"[Worker {worker_idx}] Application error:\n{worker_error}"
+            )
+            result_stub["error"] = worker_error
+            return result_stub
+
+        if predictions is None or len(predictions) == 0:
+            msg = f"Worker returned empty predictions list: {response}"
+            logger.error(f"[Worker {worker_idx}] {msg}")
+            result_stub["error"] = msg
+            return result_stub
+
+        score = confident_strategy(predictions)
+        logger.info(
+            f"[Worker {worker_idx}] OK — frames={len(predictions)}, score={score:.4f}"
+        )
+        result_stub.update({
+            "predictions": predictions,
+            "n_frames":    response.get("n_frames", len(predictions)),
+            "score":       score,
+        })
+        return result_stub
+
+    except FuturesTimeout:
+        msg = f"Timed out after {WORKER_TIMEOUT}s"
+        logger.error(f"[Worker {worker_idx}] {msg}")
+        result_stub["error"] = msg
+        return result_stub
+
+    except Exception:
+        full_tb = _tb.format_exc()
+        logger.error(f"[Worker {worker_idx}] Exception:\n{full_tb}")
+        result_stub["error"] = full_tb
+        return result_stub
+
+
+def dispatch_to_workers(npy_path: str) -> list[dict]:
+    """
+    Fire the .npy file at all configured workers in parallel.
+    Each worker gets its own thread; WORKER_TIMEOUT caps each call.
+    Workers that fail contribute a score=0.5 fallback but log the real error.
+    """
+    if not WORKER_URLS:
+        logger.warning("No workers configured — returning neutral score.")
+        return [{"worker": 0, "predictions": None, "n_frames": 0,
+                 "error": "No workers configured.", "score": 0.5}]
+
+    results: list[dict] = []
+    with ThreadPoolExecutor(max_workers=len(WORKER_URLS)) as pool:
+        futures = {
+            pool.submit(_call_worker, url, npy_path, i + 1): i + 1
+            for i, url in enumerate(WORKER_URLS)
         }
+        for fut in as_completed(futures, timeout=WORKER_TIMEOUT + 10):
+            try:
+                results.append(fut.result())
+            except Exception:
+                w = futures[fut]
+                full_tb = _tb.format_exc()
+                logger.error(f"[Worker {w}] Future raised:\n{full_tb}")
+                results.append({"worker": w, "predictions": None,
+                                "n_frames": 0, "error": full_tb, "score": 0.5})
 
-        const duration = ((performance.now() - startTime) / 1000).toFixed(1);
-        updateRealMetrics(data.final_score, data.worker_scores);
-        showRealResult(file.name, data.final_score, data.worker_scores, duration);
-      })
-      .catch(err => {
-        clearInterval(interval);
-        overlay.classList.remove('visible');
-        alert("System Error: " + err);
-      });
-  }
-
-  function updateRealMetrics(finalScore, workerScores) {
-    const isFake = finalScore >= 0.5;
-    const confidence = isFake ? finalScore * 100 : (1 - finalScore) * 100;
-    
-    const scoreEl = document.getElementById('authScore');
-    scoreEl.textContent = confidence.toFixed(1) + '%';
-    scoreEl.className = 'result-score ' + (isFake ? 'fake' : 'authentic');
-
-    for(let i=1; i<=5; i++) {
-        let wScore = workerScores[i-1] ? workerScores[i-1] * 100 : confidence;
-        document.getElementById('m' + i).textContent = wScore.toFixed(1) + '%';
-        document.getElementById('b' + i).style.width = wScore + '%';
-    }
-  }
-
-  function showRealResult(fileName, finalScore, workerScores, duration) {
-    const isFake = finalScore >= 0.5;
-    const confidence = isFake ? (finalScore * 100).toFixed(1) : ((1 - finalScore) * 100).toFixed(1);
-    const overlay = document.getElementById('resultOverlay');
-
-    document.getElementById('modalScore').textContent = confidence + '%';
-    document.getElementById('modalScore').style.color = isFake ? 'var(--red)' : 'var(--green)';
-    document.getElementById('modalVerdict').textContent = isFake ? 'DEEPFAKE DETECTED' : 'AUTHENTIC CONTENT';
-    document.getElementById('modalVerdict').className = 'verdict-title ' + (isFake ? '' : 'authentic');
-    document.getElementById('modalDesc').textContent = isFake
-      ? `High confidence manipulation detected in "${fileName}". Ensemble forensic signals indicate AI-generated modifications.`
-      : `No significant manipulation detected in "${fileName}". All forensic signals within normal parameters.`;
-
-    document.getElementById('mm1').textContent = confidence + '%';
-    document.getElementById('mm2').textContent = workerScores[1] ? (workerScores[1]*100).toFixed(1) + '%' : confidence + '%';
-    document.getElementById('mm3').textContent = duration + 's';
-
-    overlay.classList.add('visible');
-  }
-
-  function closeResult() { document.getElementById('resultOverlay').classList.remove('visible'); }
-  document.getElementById('resultOverlay').addEventListener('click', function(e) { if (e.target === this) closeResult(); });
-
-  setTimeout(() => {
-    const observer = new IntersectionObserver((entries) => {
-      entries.forEach(e => {
-        if (e.isIntersecting) {
-          e.target.style.opacity = '1';
-          e.target.style.transform = 'translateY(0)';
-        }
-      });
-    }, { threshold: 0.1 });
-    document.querySelectorAll('.how-step, .feature-card, .report-card').forEach(el => {
-      el.style.opacity = '0';
-      el.style.transform = 'translateY(24px)';
-      el.style.transition = 'opacity 0.6s ease, transform 0.6s ease, border-color 0.3s';
-      observer.observe(el);
-    });
-  }, 500);
-</script>
-</body>
-</html>
-"""
+    return results
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  FastAPI app
+# ══════════════════════════════════════════════════════════════════════════════
+
+app = FastAPI(title="VERIDEX DeepFake Detector UI")
 
-@app.get("/")
-def read_root():
-    try:
-        with open("deepfake-detector.html", "r", encoding="utf-8") as f:
-            html_content = f.read()
-        html_parts = html_content.split("<script>")
-        live_html = html_parts[0] + JS_OVERRIDE
-        return HTMLResponse(content=live_html)
-    except FileNotFoundError:
-        return HTMLResponse(content="<h1>Error: deepfake-detector.html not found.</h1><p>Please upload the HTML file to this space.</p>")
-
-@app.post("/api/analyze")
-async def analyze_api(file: UploadFile = File(...)):
-    temp_dir = tempfile.mkdtemp()
-    video_path = os.path.join(temp_dir, file.filename)
-    with open(video_path, "wb") as buffer:
-        shutil.copyfileobj(file.file, buffer)
-
-    input_size = 380
-    frames_per_video = 32
-    batch_size = frames_per_video * 4 
-    
-    faces = face_extractor.process_video(video_path, frames_per_video=frames_per_video)
-    
-    x = np.zeros((batch_size, input_size, input_size, 3), dtype=np.uint8)
-    n = 0
-    for frame_data in faces:
-        for face in frame_data["faces"]:
-            resized_face = isotropically_resize_image(face, input_size)
-            resized_face = put_to_center(resized_face, input_size)
-            if n < batch_size:
-                x[n] = resized_face
-                n += 1
-
-    if n == 0:
-        shutil.rmtree(temp_dir, ignore_errors=True)
-        return {"error": "No faces detected."}
-
-    # Save as highly compressed uint8 numpy array instead of float32 tensor
-    x_final = x[:n]
-    np_path = os.path.join(temp_dir, "batch_tensor.npy")
-    np.save(np_path, x_final)
-
-    worker_scores = []
-    with concurrent.futures.ThreadPoolExecutor(max_workers=7) as executor:
-        futures = [executor.submit(call_worker, client, np_path) for client in clients]
-        for future in concurrent.futures.as_completed(futures):
-            worker_scores.append(future.result())
-
-    final_score = np.mean(worker_scores)
-    shutil.rmtree(temp_dir, ignore_errors=True)
 
+@app.get("/", response_class=HTMLResponse)
+async def serve_ui():
+    """Serve the custom VERIDEX HTML interface."""
+    if not HTML_FILE.exists():
+        raise HTTPException(
+            status_code=404,
+            detail=f"deepfake-detector.html not found at {HTML_FILE}. "
+                   "Ensure the file is committed to the Space repository root.",
+        )
+    return HTMLResponse(content=HTML_FILE.read_text(encoding="utf-8"))
+
+
+@app.get("/health")
+async def health():
     return {
-        "final_score": float(final_score),
-        "worker_scores": [float(s) for s in worker_scores]
+        "status":         "ok",
+        "workers":        len(WORKER_URLS),
+        "worker_urls":    WORKER_URLS,
+        "facenet":        FACENET_AVAILABLE,
+        "num_frames":     NUM_FRAMES,
+        "worker_timeout": WORKER_TIMEOUT,
     }
 
-demo = gr.Blocks()
-app = gr.mount_gradio_app(app, demo, path="/gradio") 
 
-# --- KEEP THE SERVER AWAKE ---
+@app.post("/predict/")
+async def predict(file: UploadFile = File(...)):
+    """
+    Main prediction endpoint.
+
+    1. Save uploaded video to a temp file.
+    2. Extract faces via MTCNN → uint8 .npy.
+    3. Dispatch .npy to all workers in parallel.
+    4. Aggregate scores, return result.
+    """
+    start_time = time.time()
+    tmp_dir    = tempfile.mkdtemp(prefix="veridex_")
+
+    try:
+        # ── 1. Save uploaded video ────────────────────────────────────────────
+        video_path = os.path.join(tmp_dir, f"input_{uuid.uuid4().hex}.mp4")
+        contents   = await file.read()
+        with open(video_path, "wb") as f:
+            f.write(contents)
+        logger.info(f"Video saved: {video_path}  ({len(contents)/1024:.1f} KB)")
+
+        # ── 2. Face extraction ────────────────────────────────────────────────
+        faces_array = extract_faces(video_path)
+        if faces_array is None or faces_array.shape[0] == 0:
+            raise HTTPException(
+                status_code=422,
+                detail="No faces detected in the uploaded video. "
+                       "Please upload a video that clearly shows a face.",
+            )
+        logger.info(f"Face extraction complete: {faces_array.shape}")
+
+        # ── 3. Serialise to compressed uint8 .npy ─────────────────────────────
+        npy_path = os.path.join(tmp_dir, "faces.npy")
+        # allow_pickle=False keeps the file safe and small;
+        # uint8 is ~4× smaller than float32 → stays within HF payload limits
+        np.save(npy_path, faces_array.astype(np.uint8))
+        npy_size_kb = os.path.getsize(npy_path) / 1024
+        logger.info(f"NPY payload: {npy_path}  ({npy_size_kb:.1f} KB)")
+
+        # ── 4. Dispatch to workers ─────────────────────────────────────────────
+        worker_results = dispatch_to_workers(npy_path)
+
+        # ── 5. Aggregate ───────────────────────────────────────────────────────
+        # Collect all per-frame predictions from workers that succeeded
+        all_predictions: list[float] = []
+        successful_workers = 0
+        for r in worker_results:
+            if r.get("predictions") and r.get("error") is None:
+                all_predictions.extend(r["predictions"])
+                successful_workers += 1
+
+        if not all_predictions:
+            logger.warning(
+                "All workers failed or returned no predictions. "
+                "Returning neutral score. See per-worker errors above."
+            )
+            final_score = 0.5
+        else:
+            final_score = confident_strategy(all_predictions)
+
+        label      = "FAKE" if final_score >= 0.5 else "REAL"
+        elapsed    = round(time.time() - start_time, 2)
+
+        logger.info(
+            f"Result: {label}  score={final_score:.4f}  "
+            f"workers={successful_workers}/{len(WORKER_URLS)}  "
+            f"elapsed={elapsed}s"
+        )
+
+        return JSONResponse({
+            "prediction":        label,
+            "score":             round(final_score, 4),
+            "score_pct":         f"{final_score * 100:.1f}%",
+            "filename":          file.filename,
+            "faces_extracted":   int(faces_array.shape[0]),
+            "successful_workers": successful_workers,
+            "total_workers":     len(WORKER_URLS),
+            "elapsed_sec":       elapsed,
+            "worker_results": [
+                {
+                    "worker":    r["worker"],
+                    "score":     round(r["score"], 4),
+                    "n_frames":  r["n_frames"],
+                    # Truncate the full traceback in the API response but it
+                    # has already been printed in full to the server console.
+                    "error": (r["error"][:300] + "…") if r.get("error") else None,
+                }
+                for r in sorted(worker_results, key=lambda x: x["worker"])
+            ],
+        })
+
+    except HTTPException:
+        raise
+    except Exception:
+        full_tb = traceback.format_exc()
+        logger.error(f"Unhandled error in /predict/:\n{full_tb}")
+        raise HTTPException(status_code=500, detail=full_tb)
+
+    finally:
+        # Best-effort cleanup; ignore errors if HF locks the temp dir
+        import shutil
+        try:
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+        except Exception:
+            pass
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Entry point
+# ══════════════════════════════════════════════════════════════════════════════
+
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=7860,
+        log_level="info",
+        # HF Spaces injects PORT; honour it if present
+        **({} if not os.environ.get("PORT") else
+           {"port": int(os.environ["PORT"])}),
+    )