app.py

import os
import subprocess
import importlib.util
import gradio as gr
import logging

# 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_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,
                text=True,
                capture_output=True
            )
            print("Repository cloned successfully.")
        except subprocess.CalledProcessError as e:
            print("Output:", e.stdout)
            print("Error:", e.stderr)
            raise RuntimeError(f"Failed to clone repository: {e.stderr}")

def import_backend_script(script_name):
    """Dynamically import the backend script."""
    try:
        script_path = os.path.join("./repository", script_name)
        if not os.path.exists(script_path):
            raise FileNotFoundError(f"Script {script_name} not found in the repository.")
        
        spec = importlib.util.spec_from_file_location("backend_module", script_path)
        backend_module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(backend_module)
        return backend_module
    except Exception as e:
        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
def analyze_video(video_file):
    results = analyzer.analyze_media(video_file)
    combined_probability = results['combined_assessment']
    audio_analysis = results["audio_analysis"]
    video_probability = results['video_analysis']['probability']
    frame_count = len(results['video_analysis']['frame_results'])

    # Format the output for display
    output = {
        "Audio Analysis": audio_analysis,
        "Deepfake Probability (Combined Assessment)": f"{combined_probability:.2f}%",
        "Video Analysis": {
            "Deepfake Probability": f"{video_probability:.4f}",
            "Frames Analyzed": frame_count,
            "Frame Analysis Summary": [
                {
                    "Frame Number": frame_result["frame_number"],
                    "Noise Level": frame_result["noise"],
                    "Edge Density": frame_result["edge_density"],
                    "Color Consistency": frame_result["color_consistency"],
                    "Temporal Difference": frame_result["temporal_difference"],
                    "Probability": frame_result["probability"]
                }
                for frame_result in results['video_analysis']['frame_results']
            ]
        }
    }
    return output

# Define the Gradio interface
interface = gr.Interface(
    fn=analyze_video,
    inputs=gr.Video(label="Upload Video"),
    outputs="json",
    title="Deepfake Analyzer",
    description="Upload a video to analyze for deepfake content."
)

# Launch Gradio app
if __name__ == "__main__":
    interface.launch()