Update app.py

app.py

@@ -1,240 +1,288 @@
-"""
-Deepfake Detection System - Main Streamlit Application
-"""
-import streamlit as st
-import os
-from pathlib import Path
-from utils.detect import DeepfakeDetector
-from utils.media_io import MediaHandler
-import tempfile
-
-# Page configuration
-st.set_page_config(
-    page_title="Deepfake Detection System",
-    page_icon="🔍",
-    layout="wide"
-)
-
-# Initialize session state
-if 'analysis_complete' not in st.session_state:
-    st.session_state.analysis_complete = False
-if 'results' not in st.session_state:
-    st.session_state.results = None
-
-def main():
-    # Header
-    st.title("🔍 Deepfake Detection System")
-    st.markdown("### Analyze images and videos for AI-generated or manipulated content")
-    
-    # Sidebar for API key
-    with st.sidebar:
-        st.header("⚙️ Configuration")
-        api_key = st.text_input(
-            "Gemini API Key",
-            type="password",
-            help="Enter your Google Gemini API key"
-        )
-        
-        st.markdown("---")
-        st.markdown("### 📖 About")
-        st.info(
-            "This system uses Google's Gemini AI to analyze media files "
-            "for signs of deepfake manipulation or AI generation."
-        )
-        
-        st.markdown("### 🎯 Features")
-        st.markdown("""
-        - Image analysis
-        - Video analysis
-        - Frame-by-frame detection
-        - Confidence scoring
-        - Detailed reports
-        """)
-    
-    # Main content
-    if not api_key:
-        st.warning("⚠️ Please enter your Gemini API key in the sidebar to continue.")
-        st.markdown("""
-        ### How to get your API key:
-        1. Visit [Google AI Studio](https://makersuite.google.com/app/apikey)
-        2. Create or select a project
-        3. Generate an API key
-        4. Paste it in the sidebar
-        """)
-        return
-    
-    # Media type selection
-    st.markdown("---")
-    col1, col2 = st.columns([1, 2])
-    
-    with col1:
-        media_type = st.radio(
-            "📁 Select Media Type",
-            ["Image", "Video"],
-            help="Choose the type of media you want to analyze"
-        )
-    
-    with col2:
-        st.markdown(f"### Upload {media_type}")
-        
-        if media_type == "Image":
-            uploaded_file = st.file_uploader(
-                "Choose an image file",
-                type=["jpg", "jpeg", "png", "webp"],
-                help="Supported formats: JPG, PNG, WEBP"
-            )
-        else:
-            uploaded_file = st.file_uploader(
-                "Choose a video file",
-                type=["mp4", "avi", "mov", "mkv"],
-                help="Supported formats: MP4, AVI, MOV, MKV"
-            )
-    
-    # Analysis section
-    if uploaded_file is not None:
-        st.markdown("---")
-        
-        # Display uploaded media
-        col1, col2 = st.columns([1, 1])
-        
-        with col1:
-            st.markdown("### 📎 Uploaded Media")
-            if media_type == "Image":
-                st.image(uploaded_file, use_container_width=True)
-            else:
-                st.video(uploaded_file)
-        
-        with col2:
-            st.markdown("### 🔬 Analysis")
-            
-            # Analyze button
-            if st.button("🚀 Analyze Media", type="primary", use_container_width=True):
-                with st.spinner("🔍 Analyzing media... This may take a moment."):
-                    try:
-                        # Save uploaded file temporarily
-                        with tempfile.NamedTemporaryFile(delete=False, suffix=Path(uploaded_file.name).suffix) as tmp_file:
-                            tmp_file.write(uploaded_file.getvalue())
-                            tmp_path = tmp_file.name
-                        
-                        # Initialize detector
-                        detector = DeepfakeDetector(api_key)
-                        
-                        # Perform analysis
-                        if media_type == "Image":
-                            results = detector.analyze_image(tmp_path)
-                        else:
-                            results = detector.analyze_video(tmp_path)
-                        
-                        # Store results
-                        st.session_state.results = results
-                        st.session_state.analysis_complete = True
-                        
-                        # Clean up temp file
-                        os.unlink(tmp_path)
-                        
-                        st.success("✅ Analysis complete!")
-                        st.rerun()
-                        
-                    except Exception as e:
-                        st.error(f"❌ Error during analysis: {str(e)}")
-                        if os.path.exists(tmp_path):
-                            os.unlink(tmp_path)
-        
-        # Display results
-        if st.session_state.analysis_complete and st.session_state.results:
-            st.markdown("---")
-            display_results(st.session_state.results, media_type)
-
-def display_results(results, media_type):
-    """Display analysis results in a formatted manner"""
-    st.markdown("## 📊 Analysis Results")
-    
-    # Overall verdict
-    is_fake = results.get('is_deepfake', False)
-    confidence = results.get('confidence_score', 0)
-    
-    # Color-coded verdict
-    if is_fake:
-        verdict_color = "🔴"
-        verdict_text = "LIKELY DEEPFAKE/AI-GENERATED"
-        alert_type = "error"
-    else:
-        verdict_color = "🟢"
-        verdict_text = "LIKELY AUTHENTIC"
-        alert_type = "success"
-    
-    # Display verdict
-    col1, col2, col3 = st.columns([1, 2, 1])
-    
-    with col2:
-        if alert_type == "error":
-            st.error(f"{verdict_color} **{verdict_text}**")
-        else:
-            st.success(f"{verdict_color} **{verdict_text}**")
-    
-    # Metrics
-    st.markdown("### 📈 Detection Metrics")
-    col1, col2, col3 = st.columns(3)
-    
-    with col1:
-        st.metric("Confidence Score", f"{confidence:.1f}%")
-    
-    with col2:
-        st.metric("Authenticity", f"{100 - confidence:.1f}%")
-    
-    with col3:
-        risk_level = "High" if confidence > 70 else "Medium" if confidence > 40 else "Low"
-        st.metric("Risk Level", risk_level)
-    
-    # Detailed analysis
-    st.markdown("### 🔍 Detailed Analysis")
-    
-    with st.expander("📝 Full Analysis Report", expanded=True):
-        st.markdown(results.get('analysis', 'No detailed analysis available.'))
-    
-    # Indicators found
-    if 'indicators' in results and results['indicators']:
-        with st.expander("⚠️ Deepfake Indicators Detected"):
-            for idx, indicator in enumerate(results['indicators'], 1):
-                st.markdown(f"**{idx}.** {indicator}")
-    
-    # Video-specific results
-    if media_type == "Video" and 'frame_analysis' in results:
-        with st.expander("🎬 Frame-by-Frame Analysis"):
-            frame_data = results['frame_analysis']
-            st.markdown(f"**Total Frames Analyzed:** {frame_data.get('total_frames', 0)}")
-            st.markdown(f"**Suspicious Frames:** {frame_data.get('suspicious_frames', 0)}")
-            
-            if frame_data.get('frame_details'):
-                st.markdown("#### Sample Frames:")
-                for frame_info in frame_data['frame_details'][:5]:
-                    st.markdown(f"- Frame {frame_info.get('frame_number', 'N/A')}: {frame_info.get('note', 'N/A')}")
-    
-    # Recommendations
-    st.markdown("### 💡 Recommendations")
-    
-    if is_fake:
-        st.warning("""
-        **This media shows signs of manipulation or AI generation. Consider:**
-        - Verifying the source
-        - Looking for corroborating evidence
-        - Checking metadata
-        - Consulting additional verification tools
-        - Being cautious about sharing
-        """)
-    else:
-        st.info("""
-        **This media appears authentic, but:**
-        - No detection system is 100% accurate
-        - Always verify important content through multiple sources
-        - Check the original source when possible
-        """)
-    
-    # Reset button
-    if st.button("🔄 Analyze Another File", use_container_width=True):
-        st.session_state.analysis_complete = False
-        st.session_state.results = None
-        st.rerun()
-
-if __name__ == "__main__":
-    main()
+"""
+Deepfake Detection System - Gradio Application
+"""
+import gradio as gr
+import os
+from pathlib import Path
+from utils.detect import DeepfakeDetector
+import tempfile
+
+def analyze_media(api_key, media_file, media_type):
+    """
+    Analyze media file for deepfake content
+    
+    Args:
+        api_key: Gemini API key
+        media_file: Uploaded file
+        media_type: "Image" or "Video"
+        
+    Returns:
+        tuple: (result_html, confidence_score, verdict)
+    """
+    # Validate API key
+    if not api_key or api_key.strip() == "":
+        return (
+            "⚠️ **Error**: Please enter your Gemini API key first.",
+            None,
+            None
+        )
+    
+    # Validate file upload
+    if media_file is None:
+        return (
+            "⚠️ **Error**: Please upload a file to analyze.",
+            None,
+            None
+        )
+    
+    try:
+        # Get file path
+        file_path = media_file.name if hasattr(media_file, 'name') else media_file
+        
+        # Initialize detector
+        detector = DeepfakeDetector(api_key.strip())
+        
+        # Perform analysis based on media type
+        if media_type == "Image":
+            results = detector.analyze_image(file_path)
+        else:  # Video
+            results = detector.analyze_video(file_path, max_frames=10)
+        
+        # Check for errors
+        if 'error' in results:
+            return (
+                f"❌ **Error during analysis**: {results['error']}\n\nPlease check your API key and try again.",
+                None,
+                None
+            )
+        
+        # Format results
+        result_html = format_results(results, media_type)
+        confidence = results.get('confidence_score', 0)
+        verdict = "🔴 LIKELY DEEPFAKE" if results.get('is_deepfake', False) else "🟢 LIKELY AUTHENTIC"
+        
+        return result_html, confidence, verdict
+        
+    except Exception as e:
+        return (
+            f"❌ **Error**: {str(e)}\n\nPlease check your file and API key, then try again.",
+            None,
+            None
+        )
+
+def format_results(results, media_type):
+    """Format analysis results as HTML"""
+    is_fake = results.get('is_deepfake', False)
+    confidence = results.get('confidence_score', 0)
+    analysis = results.get('analysis', 'No analysis available.')
+    indicators = results.get('indicators', [])
+    
+    # Build HTML output
+    html = f"""
+    <div style="font-family: Arial, sans-serif;">
+        <h2>📊 Analysis Results</h2>
+        
+        <div style="background: {'#fee'; border-left: 4px solid #f00;' if is_fake else '#efe; border-left: 4px solid #0f0;'} padding: 15px; margin: 10px 0;">
+            <h3>{'🔴 LIKELY DEEPFAKE/AI-GENERATED' if is_fake else '🟢 LIKELY AUTHENTIC'}</h3>
+        </div>
+        
+        <div style="background: #f5f5f5; padding: 15px; margin: 10px 0; border-radius: 5px;">
+            <h3>📈 Detection Metrics</h3>
+            <p><strong>Confidence Score:</strong> {confidence:.1f}%</p>
+            <p><strong>Authenticity:</strong> {100 - confidence:.1f}%</p>
+            <p><strong>Risk Level:</strong> {'High' if confidence > 70 else 'Medium' if confidence > 40 else 'Low'}</p>
+        </div>
+        
+        <div style="background: #f5f5f5; padding: 15px; margin: 10px 0; border-radius: 5px;">
+            <h3>🔍 Detailed Analysis</h3>
+            <p style="white-space: pre-wrap;">{analysis}</p>
+        </div>
+    """
+    
+    # Add indicators if found
+    if indicators:
+        html += """
+        <div style="background: #fff3cd; padding: 15px; margin: 10px 0; border-radius: 5px; border-left: 4px solid #ffc107;">
+            <h3>⚠️ Deepfake Indicators Detected</h3>
+            <ul>
+        """
+        for indicator in indicators[:5]:
+            html += f"<li>{indicator}</li>"
+        html += """
+            </ul>
+        </div>
+        """
+    
+    # Add video-specific results
+    if media_type == "Video" and 'frame_analysis' in results:
+        frame_data = results['frame_analysis']
+        html += f"""
+        <div style="background: #e7f3ff; padding: 15px; margin: 10px 0; border-radius: 5px; border-left: 4px solid #2196F3;">
+            <h3>🎬 Frame-by-Frame Analysis</h3>
+            <p><strong>Total Frames Analyzed:</strong> {frame_data.get('total_frames', 0)}</p>
+            <p><strong>Suspicious Frames:</strong> {frame_data.get('suspicious_frames', 0)}</p>
+        </div>
+        """
+    
+    # Add recommendations
+    html += """
+    <div style="background: #f5f5f5; padding: 15px; margin: 10px 0; border-radius: 5px;">
+        <h3>💡 Recommendations</h3>
+    """
+    
+    if is_fake:
+        html += """
+        <p><strong>This media shows signs of manipulation or AI generation. Consider:</strong></p>
+        <ul>
+            <li>Verifying the source</li>
+            <li>Looking for corroborating evidence</li>
+            <li>Checking metadata</li>
+            <li>Consulting additional verification tools</li>
+            <li>Being cautious about sharing</li>
+        </ul>
+        """
+    else:
+        html += """
+        <p><strong>This media appears authentic, but remember:</strong></p>
+        <ul>
+            <li>No detection system is 100% accurate</li>
+            <li>Always verify important content through multiple sources</li>
+            <li>Check the original source when possible</li>
+        </ul>
+        """
+    
+    html += """
+    </div>
+    </div>
+    """
+    
+    return html
+
+# Create Gradio interface
+def create_interface():
+    """Create and configure Gradio interface"""
+    
+    with gr.Blocks(title="Deepfake Detection System", theme=gr.themes.Soft()) as demo:
+        
+        # Header
+        gr.Markdown("""
+        # 🔍 Deepfake Detection System
+        ### Analyze images and videos for AI-generated or manipulated content
+        
+        This system uses Google's Gemini AI to detect deepfakes and AI-generated content in media files.
+        """)
+        
+        # API Key Section
+        with gr.Row():
+            with gr.Column(scale=3):
+                api_key_input = gr.Textbox(
+                    label="🔑 Gemini API Key",
+                    type="password",
+                    placeholder="Enter your Google Gemini API key here...",
+                    info="Get your free API key from https://makersuite.google.com/app/apikey"
+                )
+            with gr.Column(scale=1):
+                gr.Markdown("""
+                ### 📖 How to get API Key:
+                1. Visit [Google AI Studio](https://makersuite.google.com/app/apikey)
+                2. Sign in with Google
+                3. Create API key
+                4. Paste it here
+                """)
+        
+        gr.Markdown("---")
+        
+        # Main Interface
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Media Type Selection
+                media_type = gr.Radio(
+                    choices=["Image", "Video"],
+                    value="Image",
+                    label="📁 Select Media Type",
+                    info="Choose the type of media you want to analyze"
+                )
+                
+                # File Upload
+                media_file = gr.File(
+                    label="📤 Upload Media File",
+                    file_types=["image", "video"],
+                    type="filepath"
+                )
+                
+                # Analyze Button
+                analyze_btn = gr.Button(
+                    "🚀 Analyze Media",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                # Quick Stats
+                gr.Markdown("""
+                ### 📊 Supported Formats
+                **Images:** JPG, PNG, WEBP  
+                **Videos:** MP4, AVI, MOV, MKV
+                
+                ### ⏱️ Processing Time
+                **Images:** 5-15 seconds  
+                **Videos:** 30-60 seconds
+                """)
+            
+            with gr.Column(scale=2):
+                # Results Display
+                gr.Markdown("### 📊 Analysis Results")
+                
+                with gr.Row():
+                    verdict_output = gr.Textbox(
+                        label="Verdict",
+                        interactive=False,
+                        scale=2
+                    )
+                    confidence_output = gr.Number(
+                        label="Confidence Score (%)",
+                        interactive=False,
+                        scale=1
+                    )
+                
+                result_output = gr.HTML(
+                    label="Detailed Analysis"
+                )
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        ### ⚠️ Important Notes
+        - **Not 100% Accurate**: No detection system is perfect. Always verify through multiple sources.
+        - **Privacy**: Your API key and files are not stored. They're only used for analysis.
+        - **For Educational Use**: This tool is for educational and research purposes.
+        
+        ### 🛠️ Technology Stack
+        Built with: Google Gemini AI • Gradio • OpenCV • Python
+        """)
+        
+        # Connect the analyze button
+        analyze_btn.click(
+            fn=analyze_media,
+            inputs=[api_key_input, media_file, media_type],
+            outputs=[result_output, confidence_output, verdict_output]
+        )
+        
+        # Examples section
+        gr.Markdown("""
+        ### 💡 Tips for Best Results
+        - Use high-quality images and videos
+        - Ensure good lighting in the media
+        - Videos should be at least 5 seconds long
+        - Check multiple suspicious areas if available
+        """)
+    
+    return demo
+
+# Launch the application
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )