Update app.py

app.py

@@ -4,8 +4,9 @@ import importlib.util
 import gradio as gr
 import logging
 from moviepy.editor import VideoFileClip
+import json
+
 
-# Function to truncate video to 15 seconds
 def truncate_video(video_file):
     """Truncates video to 15 seconds and saves it as a temporary file."""
     clip = VideoFileClip(video_file)
@@ -14,25 +15,20 @@ def truncate_video(video_file):
     truncated_clip.write_videofile(truncated_video_file, codec="libx264", audio_codec="aac")
     return truncated_video_file
 
-# Clone the GitHub repository containing the backend
 def clone_repo():
     """Clone the GitHub repository containing the backend."""
-    repo_url = "https://github.com/NeeravSood/AllMark-MVP.git"  # Update if necessary
+    repo_url = "https://github.com/NeeravSood/AllMark-MVP.git"  # Update when changing
     repo_path = "./repository"
 
-    # Retrieve the GitHub Personal Access Token (GITHUB_PAT) from environment variables
     github_pat = os.getenv("GITHUB_PAT")
     if not github_pat:
         raise RuntimeError("GitHub Personal Access Token (GITHUB_PAT) not found in environment variables.")
-
-    # Modify the repository URL to include the token for authentication
     authenticated_repo_url = f"https://{github_pat}@github.com/NeeravSood/AllMark-MVP.git"
 
     if os.path.exists(repo_path):
         print("Repository already cloned.")
     else:
         try:
-            # Clone the repository using the authenticated URL
             subprocess.run(
                 ["git", "clone", authenticated_repo_url, repo_path],
                 check=True,
@@ -60,29 +56,21 @@ def import_backend_script(script_name):
         logging.error(f"Error importing backend script: {str(e)}")
         raise RuntimeError(f"Failed to import backend script: {str(e)}")
 
-# Clone the repository and import the backend module
 clone_repo()
-backend = import_backend_script("app.py")  # Import app.py from the cloned repository
-
-# Initialize the analyzer instance from the imported module
-analyzer = backend.DeepfakeAnalyzer()  # Use the imported module's class or function
-
-# Define the Gradio function to analyze the video
-import json  # Ensure imports include json for dictionary-to-JSON string handling
+backend = import_backend_script("app.py") 
+analyzer = backend.DeepfakeAnalyzer()
 
 def analyze_video(video_file):
     try:
-        # Truncate the video to 15 seconds
         truncated_video = truncate_video(video_file)
-        
-        # Pass the truncated video to the analyzer
         results = analyzer.analyze_media(truncated_video)
-        
-        # Get the combined probability and interpret the result
-        combined_probability = float(results.get('combined_assessment', 0))
+        combined_assessment = results.get('combined_assessment', 0)
+        if isinstance(combined_assessment, (int, float)):
+            combined_probability = combined_assessment
+        else:
+            combined_probability = 100 if combined_assessment == "Deepfake" else 0
+
         analysis_result = "genuine/original" if combined_probability < 50 else "a deepfake"
-        
-        # Prepare JSON output
         output = {
             "message": f"According to our analysis, the video you uploaded appears to be {analysis_result} "
                        f"with a {combined_probability:.2f}% probability. "
@@ -92,12 +80,8 @@ def analyze_video(video_file):
         return output
 
     except Exception as e:
-        # Log the error and return a JSON-compatible error message
         logging.error(f"Error during analysis: {e}")
         return {"error": "An error occurred during video analysis. Please check your input and try again."}
-
-
-# Define the Gradio interface with json output to handle dictionaries
 interface = gr.Interface(
     fn=analyze_video,
     inputs=gr.Video(label="Upload Video"),
@@ -106,6 +90,5 @@ interface = gr.Interface(
     description="Upload a video to analyze for deepfake content. N.B. - Only mp4 files supported for now. Analysis usually takes between 1 to 5 minutes."
 )
 
-# Launch Gradio app
 if __name__ == "__main__":
     interface.launch()