Update app.py

app.py

@@ -1,79 +1,50 @@
+import gradio as gr
 import tempfile
-from io import BytesIO
-from typing import Optional
-
 import cv2
-import numpy as np
-import uvicorn
-from fastapi import FastAPI, File, Form, Query, UploadFile
-from fastapi.responses import JSONResponse, StreamingResponse
-from starlette.middleware.cors import CORSMiddleware
-
 from prediction import Prediction
 
-app = FastAPI(
-    title="Deepfake Detection API",
-    description="Upload a video to check if it's real or a manipulated deepfake (Face2Face, FaceShifter, FaceSwap, or NeuralTextures).",
-)
-
-# CORS (optional if using frontend)
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Initialize model
+# Initialize the predictor
 predictor = Prediction()
 
-
-@app.post("/predict/")
-async def predict_deepfake(
-    video: UploadFile = File(...),
-    sequence_length: Optional[int] = Query(
-        None, description="Number of frames to use for prediction"
-    ),
-):
+# Define your inference function
+def detect_deepfake(video_file, sequence_length=None):
     try:
-        # Save video to a temporary file
+        # Save the uploaded video to a temporary file
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_video:
-            temp_video.write(await video.read())
+            temp_video.write(video_file.read())
             temp_video_path = temp_video.name
 
-        # Get prediction and explanation image
+        # Run prediction
         prediction_str, explanation_image, details = predictor.predict(
             temp_video_path, sequence_length
         )
 
-        response = {"prediction": prediction_str, "details": details}
-
-        # Convert explanation image (np array) to JPEG bytes if available
+        # Return prediction and image
+        explanation_img = None
         if explanation_image is not None:
-            _, img_encoded = cv2.imencode(".jpg", explanation_image)
-            img_bytes = BytesIO(img_encoded.tobytes())
-            return StreamingResponse(
-                content=img_bytes,
-                media_type="image/jpeg",
-                headers={"X-Prediction-Result": prediction_str},
-            )
-        else:
-            return JSONResponse(content=response)
-
-    except Exception as e:
-        import traceback
+            explanation_img = cv2.cvtColor(explanation_image, cv2.COLOR_BGR2RGB)
 
-        error_detail = traceback.format_exc()
-        return JSONResponse(
-            status_code=500, content={"error": str(e), "detail": error_detail}
-        )
+        return prediction_str, explanation_img, str(details)
 
+    except Exception as e:
+        return f"Error: {str(e)}", None, ""
+
+# Gradio UI
+demo = gr.Interface(
+    fn=detect_deepfake,
+    inputs=[
+        gr.File(label="Upload Video (.mp4)", file_types=[".mp4"]),
+        gr.Number(label="Sequence Length (Optional)", value=None),
+    ],
+    outputs=[
+        gr.Textbox(label="Prediction"),
+        gr.Image(label="Explanation Image"),
+        gr.Textbox(label="Details"),
+    ],
+    title="Deepdetect",
+    description="Upload a video to detect deepfakes using Face2Face, FaceSwap, FaceShifter, and NeuralTextures models.",
+    allow_flagging="never",
+)
 
-@app.get("/")
-def root():
-    return {
-        "message": "Deepfake Detection API is running!",
-        "usage": "POST to /predict/ with a video file and optional sequence_length parameter",
-    }
-
+if __name__ == "__main__":
+    demo.launch()