Update app.py

app.py

@@ -4,52 +4,68 @@ from huggingface_hub import hf_hub_download
 from safetensors.torch import load_file
 import gradio as gr
 
-from model import ImprovedEfficientViT  # custom model architecture
-from inference import predict_vedio  # custom video inference function
+# import your custom model/inference (ensure model.py and inference.py are present)
+from model import ImprovedEfficientViT
+from inference import predict_vedio
 
-# --- Force CPU-only to prevent CUDA/TensorFlow GPU errors ---
+# Force CPU-only (avoid CUDA/tensorflow GPU init errors on Spaces)
 os.environ["CUDA_VISIBLE_DEVICES"] = ""
 device = "cpu"
 
-# --- Download checkpoint ---
+# Download + load checkpoint (this will cache on the Spaces runner)
 CHECKPOINT_PATH = hf_hub_download(
     repo_id="faisalishfaq2005/deepfake-detection-efficientnet-vit",
     filename="model.safetensors"
 )
 
-# --- Load model weights safely ---
 state_dict = load_file(CHECKPOINT_PATH, device="cpu")
 model = ImprovedEfficientViT()
 model.load_state_dict(state_dict)
 model.eval()
 model.to(device)
 
-# --- Inference function ---
-def run_inference(video_path):
-    if not os.path.exists(video_path):
-        return "Error: uploaded video not found.", None
+def run_inference(uploaded_file):
+    """
+    uploaded_file: this will be a filesystem path (string) returned by gr.File
+    (This avoids file-like objects and tempfile issues across Gradio versions.)
+    """
+    # uploaded_file can be None or a path string
+    if not uploaded_file:
+        return "Error: no file uploaded.", None
+
+    # On some Gradio versions uploaded_file is a dict with 'name' or 'tempfile' keys,
+    # but typically it's a string path. Handle common cases defensively:
+    video_path = None
+    if isinstance(uploaded_file, str):
+        video_path = uploaded_file
+    elif isinstance(uploaded_file, dict):
+        # Examples of possible dict shapes; try common keys:
+        video_path = uploaded_file.get("name") or uploaded_file.get("filename") or uploaded_file.get("tempfile")
+    else:
+        # fallback: try str()
+        video_path = str(uploaded_file)
+
+    if not video_path or not os.path.exists(video_path):
+        return f"Error: uploaded video not found at path: {video_path}", None
 
     try:
         result = predict_vedio(video_path, model)
-        verdict = "Deepfake" if result['class'] == 1 else "Real"
-        output_video = video_path
+        verdict = "Deepfake" if int(result.get("class", 0)) == 1 else "Real"
+        # Return the verdict string and the path so gr.Video output can preview it
+        return f"Verdict: {verdict}", video_path
     except Exception as e:
-        verdict = f"Error during prediction: {str(e)}"
-        output_video = None
+        return f"Error during prediction: {e}", None
 
-    return verdict, output_video
-
-# --- Gradio interface ---
+# Build UI (gr.File for upload; gr.Video for preview)
 with gr.Blocks() as app:
     gr.Markdown("# 🔍 Deepfake Detector (EfficientViT, CPU-only)")
-
     with gr.Row():
-        video_input = gr.Video(label="Upload Video", source="upload")  # updated
-        output_text = gr.Textbox(label="Prediction")
-        output_video = gr.Video(label="Uploaded Video Preview")
+        upload = gr.File(label="Upload Video (mp4, mov, avi)", file_types=["video"])
+        out_text = gr.Textbox(label="Prediction")
+        out_video = gr.Video(label="Uploaded Video Preview")
 
-    analyze_btn = gr.Button("Analyze")
-    analyze_btn.click(run_inference, inputs=[video_input], outputs=[output_text, output_video])
+    analyze = gr.Button("Analyze")
+    analyze.click(fn=run_inference, inputs=[upload], outputs=[out_text, out_video])
 
 if __name__ == "__main__":
-    app.launch()
+    app.launch()