Update app.py

app.py

@@ -1,21 +1,23 @@
 import os
+import cv2
 import torch
 import numpy as np
 from PIL import Image
-import cv2
 import gradio as gr
 from gradio_client import Client, handle_file
 from torchvision.transforms import Normalize
 from facenet_pytorch.models.mtcnn import MTCNN
 import concurrent.futures
 import tempfile
-from huggingface_hub import get_token
 from fastapi import FastAPI, UploadFile, File
 from fastapi.responses import HTMLResponse
 import shutil
 
 # ==========================================
-# 1. API ROUTER CONFIGURATION
+# 1. API ROUTER
+# ==========================================
+# ==========================================
+# 1. API ROUTER
 # ==========================================
 WORKER_SPACES = [
     "bithal26/DeepFake-Worker-1",
@@ -28,20 +30,16 @@ WORKER_SPACES = [
 ]
 
 clients = []
-print("Initializing connections to 7 API Workers...")
-hf_token = get_token()
-
-if not hf_token:
-    print("CRITICAL WARNING: No HF_TOKEN found! Private workers will fail to connect.")
-
+print("Initializing connections to 7 Public API Workers...")
 for space in WORKER_SPACES:
     try:
-        clients.append(Client(space, token=hf_token))
+        # No token needed anymore!
+        clients.append(Client(space))
     except Exception as e:
         print(f"Warning: Could not connect to {space}. Error: {e}")
 
 # ==========================================
-# 2. MTCNN PREPROCESSING ENGINE
+# 2. NOTEBOOK-EXACT PREPROCESSING
 # ==========================================
 mean = [0.485, 0.456, 0.406]
 std = [0.229, 0.224, 0.225]
@@ -70,7 +68,6 @@ class VideoReader:
         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()
@@ -90,7 +87,7 @@ class FaceExtractor:
         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=16): 
+    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
@@ -117,14 +114,14 @@ face_extractor = FaceExtractor()
 def confident_strategy(pred, t=0.8):
     pred = np.array(pred)
     sz = len(pred)
-    if sz == 0: return 0.0
+    if sz == 0: return 0.5
     fakes = np.count_nonzero(pred > t)
     if fakes > sz // 2.5 and fakes > 11:
-        return np.mean(pred[pred > t])
+        return float(np.mean(pred[pred > t]))
     elif np.count_nonzero(pred < 0.2) > 0.9 * sz:
-        return np.mean(pred[pred < 0.2])
+        return float(np.mean(pred[pred < 0.2]))
     else:
-        return np.mean(pred)
+        return float(np.mean(pred))
 
 def call_worker(client, tensor_filepath):
     try:
@@ -133,74 +130,195 @@ def call_worker(client, tensor_filepath):
         if not preds: return 0.5 
         return confident_strategy(preds)
     except Exception as e:
-        print(f"API Call Failed: {e}")
+        print(f"Worker Error: {e}")
         return 0.5 
 
 # ==========================================
-# 3. FASTAPI SERVER & DIRECT HTML INJECTION
+# 3. FASTAPI SERVER
 # ==========================================
 app = FastAPI()
 
-# 1. Serve your custom HTML file as the main page
+# Override the JS in the HTML dynamically to make real API calls
+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;
+        }
+
+        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>
+"""
+
 @app.get("/")
 def read_root():
+    # Read the raw HTML file and replace the static <script> with our live API logic
     with open("deepfake-detector.html", "r", encoding="utf-8") as f:
         html_content = f.read()
-    return HTMLResponse(content=html_content)
+    
+    # Split off the bottom script tag and replace it with the live JS
+    html_parts = html_content.split("<script>")
+    live_html = html_parts[0] + JS_OVERRIDE
+    return HTMLResponse(content=live_html)
 
-# 2. Create the hidden API endpoint your HTML will call
 @app.post("/api/analyze")
 async def analyze_api(file: UploadFile = File(...)):
-    # Save uploaded video temporarily
     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)
 
-    # Extract Faces
     input_size = 380
-    faces = face_extractor.process_video(video_path, frames_per_video=16)
+    frames_per_video = 32
+    batch_size = frames_per_video * 4 
     
-    if len(faces) == 0:
-        return {"error": "No faces detected."}
-
-    x = []
+    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)
-            x.append(resized_face)
-            if len(x) >= 16 * 4: break
+            if n < batch_size:
+                x[n] = resized_face
+                n += 1
 
-    x = np.array(x, dtype=np.uint8)
-    x = torch.tensor(x, device=device).float()
-    x = x.permute((0, 3, 1, 2))
-    for i in range(len(x)):
-        x[i] = normalize_transform(x[i] / 255.)
+    if n == 0:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+        return {"error": "No faces detected."}
+
+    # Pass exactly 'n' tensors to avoid blank arrays
+    x_tensor = torch.tensor(x[:n]).float()
+    x_tensor = x_tensor.permute((0, 3, 1, 2))
+    for i in range(n):
+        x_tensor[i] = normalize_transform(x_tensor[i] / 255.)
 
-    # Save Tensor
     tensor_path = os.path.join(temp_dir, "batch_tensor.pt")
-    torch.save(x, tensor_path)
+    torch.save(x_tensor, tensor_path)
 
-    # Ping Workers
     worker_scores = []
     with concurrent.futures.ThreadPoolExecutor(max_workers=7) as executor:
         futures = [executor.submit(call_worker, client, tensor_path) for client in clients]
         for future in concurrent.futures.as_completed(futures):
             worker_scores.append(future.result())
 
-    # Aggregate
     final_score = np.mean(worker_scores)
-    
-    # Clean up temp files
     shutil.rmtree(temp_dir, ignore_errors=True)
 
-    # Return pure JSON data to the HTML frontend
     return {
         "final_score": float(final_score),
         "worker_scores": [float(s) for s in worker_scores]
     }
 
-# Gradio wrapper just to keep Hugging Face happy, but we mount our custom FastAPI app
 demo = gr.Blocks()
 app = gr.mount_gradio_app(app, demo, path="/gradio")