Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,218 +1,454 @@
 """
-src/streamlit_hf_optimized.py
+src/streamlit_with_api.py
 
-Hugging Face Spaces Optimized Version
-Memory-efficient, error-handling, and robust
-Run with: streamlit run src/streamlit_hf_optimized.py
+Professional Streamlit UI for DeepGuard AI - DeepFake Detection System
+Integrated FastAPI Backend - Starts API in background thread
+Run with: streamlit run src/streamlit_with_api.py
 """
 import streamlit as st
-import numpy as np
-from PIL import Image
+import requests
+from io import BytesIO
 import tempfile
 import os
 import sys
-import gc
-import warnings
+import threading
+import time
+import uvicorn
 
-# Suppress warnings
-warnings.filterwarnings("ignore")
-os.environ.setdefault("TF_USE_LEGACY_KERAS", "1")
-os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "3")
-
-# Page configuration - MUST be first
+# Page configuration - MUST be first Streamlit command
 st.set_page_config(
-    page_title="DeepGuard AI - Hugging Face",
+    page_title="DeepGuard AI - DeepFake Detection",
     page_icon="🛡️",
     layout="wide",
     initial_sidebar_state="expanded"
 )
 
-# Add project root to path
+# Add project root to path for imports
 ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 if ROOT_DIR not in sys.path:
     sys.path.insert(0, ROOT_DIR)
 
-# Import optimized model loading
+# Import FastAPI app
 try:
-    from src.model_optimized import load_model_optimized, predict_memory_efficient
-    TENSORFLOW_AVAILABLE = True
+    # Add app directory to path
+    app_dir = os.path.join(ROOT_DIR, "app")
+    if app_dir not in sys.path:
+        sys.path.insert(0, app_dir)
+    
+    # Import the FastAPI app
+    import main
+    fastapi_app = main.app
+    FASTAPI_AVAILABLE = True
 except ImportError as e:
-    st.error(f"Model optimization failed: {e}")
-    TENSORFLOW_AVAILABLE = False
+    st.error(f"FastAPI not available: {e}")
+    FASTAPI_AVAILABLE = False
+
+# 🔥 HF-Compatible Flow: Start FastAPI in background thread
+def start_api():
+    """Start FastAPI server in background thread"""
+    if FASTAPI_AVAILABLE:
+        try:
+            uvicorn.run(
+                fastapi_app,
+                host="127.0.0.1",
+                port=8000,
+                log_level="warning"
+            )
+        except Exception as e:
+            print(f"Error starting FastAPI: {e}")
+
+# Start FastAPI only once per session
+if FASTAPI_AVAILABLE and "api_started" not in st.session_state:
+    api_thread = threading.Thread(target=start_api, daemon=True)
+    api_thread.start()
+    st.session_state.api_started = True
+    time.sleep(2)  # Give API time to start
 
-# Custom CSS
+# Custom CSS for professional look
 st.markdown("""
     <style>
-        .main { padding-top: 0rem; background-color: #f3f4f6; }
-        .header { background: linear-gradient(135deg, #1f2937 0%, #4f46e5 100%); 
-                  padding: 2rem 0; margin: -1rem -1rem 2rem -1rem; }
-        .header-title { color: #f9fafb; font-size: 3rem; font-weight: bold; 
-                       text-align: center; text-shadow: 2px 2px 6px rgba(15, 23, 42, 0.6); }
-        .header-subtitle { color: rgba(249, 250, 251, 0.9); text-align: center; margin-top: 0.5rem; }
-        .status-indicator { display: inline-block; width: 12px; height: 12px; 
-                           border-radius: 50%; margin-right: 8px; }
-        .status-ready { background-color: #10b981; }
-        .status-error { background-color: #ef4444; }
-        .stButton > button { background: linear-gradient(135deg, #4f46e5 0%, #6366f1 100%); 
-                             color: white; border: none; border-radius: 6px; 
-                             padding: 0.6rem 2.2rem; font-weight: 600; }
-        #MainMenu {visibility: hidden;} footer {visibility: hidden;} header {visibility: hidden;}
+        /* Main container styling */
+        .main {
+            padding-top: 0rem;
+            background-color: #f3f4f6; /* light gray for better contrast */
+        }
+        
+        /* Header styling */
+        .header {
+            background: linear-gradient(135deg, #1f2937 0%, #4f46e5 100%);
+            padding: 2rem 0;
+            margin: -1rem -1rem 2rem -1rem;
+            box-shadow: 0 4px 6px rgba(15, 23, 42, 0.35);
+        }
+        
+        .header-content {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 0 2rem;
+        }
+        
+        .header-title {
+            color: #f9fafb;
+            font-size: 3rem;
+            font-weight: bold;
+            margin: 0;
+            text-align: center;
+            text-shadow: 2px 2px 6px rgba(15, 23, 42, 0.6);
+        }
+        
+        .header-subtitle {
+            color: rgba(249, 250, 251, 0.9);
+            font-size: 1.2rem;
+            text-align: center;
+            margin-top: 0.5rem;
+        }
+        
+        /* Footer styling */
+        .footer {
+            background: linear-gradient(135deg, #111827 0%, #1f2937 100%);
+            color: #e5e7eb;
+            padding: 2rem 0;
+            margin: 3rem -1rem -1rem -1rem;
+            text-align: center;
+            box-shadow: 0 -4px 6px rgba(15, 23, 42, 0.4);
+        }
+        
+        .footer-content {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 0 2rem;
+        }
+        
+        .footer-text {
+            color: rgba(229, 231, 235, 0.9);
+            font-size: 1rem;
+            margin: 0;
+        }
+        
+        /* Card styling */
+        .card {
+            background: #ffffff;
+            border-radius: 10px;
+            padding: 2rem;
+            box-shadow: 0 2px 10px rgba(15, 23, 42, 0.12);
+            margin-bottom: 2rem;
+        }
+        
+        /* Button styling */
+        .stButton > button {
+            background: linear-gradient(135deg, #4f46e5 0%, #6366f1 100%);
+            color: #f9fafb;
+            border: none;
+            border-radius: 6px;
+            padding: 0.6rem 2.2rem;
+            font-weight: 600;
+            letter-spacing: 0.02em;
+            transition: all 0.2s ease-in-out;
+        }
+        
+        .stButton > button:hover {
+            transform: translateY(-1px);
+            box-shadow: 0 6px 14px rgba(79, 70, 229, 0.35);
+        }
+        
+        /* File uploader styling */
+        .uploadedFile {
+            border: 2px dashed #4f46e5;
+            border-radius: 10px;
+            padding: 1rem;
+            background-color: #eef2ff;
+        }
+        
+        /* Success/Error message styling */
+        .stSuccess, .stError {
+            border-radius: 6px;
+        }
+        
+        /* Hide Streamlit default elements */
+        #MainMenu {visibility: hidden;}
+        footer {visibility: hidden;}
+        header {visibility: hidden;}
+        
+        /* Info boxes */
+        .info-box {
+            background: linear-gradient(135deg, #e5edff 0%, #d1fae5 100%);
+            padding: 1.6rem;
+            border-radius: 12px;
+            margin: 1rem 0;
+            border-left: 5px solid #4f46e5;
+            color: #111827;
+        }
+        .info-box h3,
+        .info-box p {
+            color: #111827;
+        }
+        
+        .feature-box {
+            background: #ffffff;
+            padding: 1.6rem;
+            border-radius: 12px;
+            margin: 1rem 0;
+            box-shadow: 0 2px 8px rgba(15, 23, 42, 0.08);
+            border: 1px solid #e5e7eb;
+            color: #111827;
+        }
+        .feature-box h4,
+        .feature-box li {
+            color: #111827;
+        }
+        
+        /* Status indicator */
+        .status-indicator {
+            display: inline-block;
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            margin-right: 8px;
+        }
+        .status-ready {
+            background-color: #10b981;
+        }
+        .status-loading {
+            background-color: #f59e0b;
+            animation: pulse 2s infinite;
+        }
+        .status-error {
+            background-color: #ef4444;
+        }
+        @keyframes pulse {
+            0% { opacity: 1; }
+            50% { opacity: 0.5; }
+            100% { opacity: 1; }
+        }
     </style>
 """, unsafe_allow_html=True)
 
 # Header
 st.markdown("""
     <div class="header">
-        <div style="text-align: center;">
+        <div class="header-content">
             <h1 class="header-title">🛡️ DeepGuard AI</h1>
-            <p class="header-subtitle">Hugging Face Spaces Optimized | Memory Efficient DeepFake Detection</p>
+            <p class="header-subtitle">Advanced DeepFake Detection System | Integrated FastAPI Backend</p>
         </div>
     </div>
 """, unsafe_allow_html=True)
 
-# Model loading with caching and error handling
-@st.cache_resource
-def load_model_safe():
-    """Safe model loading with multiple fallbacks"""
-    if not TENSORFLOW_AVAILABLE:
-        return None, "TensorFlow not available"
-    
-    models_to_try = [
-        "hybrid_deepfake_model.h5",
-        "xception_deepfake_model.h5"
-    ]
-    
-    for model_name in models_to_try:
-        model_path = os.path.join(ROOT_DIR, model_name)
-        if os.path.exists(model_path):
-            try:
-                st.info(f"🔄 Loading {model_name}...")
-                model = load_model_optimized(model_path)
-                if model is not None:
-                    st.success(f"✅ {model_name} loaded successfully!")
-                    return model, None
-                else:
-                    st.warning(f"⚠️ {model_name} failed to load")
-            except Exception as e:
-                st.error(f"❌ Error loading {model_name}: {str(e)}")
-                continue
-    
-    return None, "No model could be loaded"
-
-# Load model
-model, model_error = load_model_safe()
-
-# Sidebar
+# Sidebar for configuration
 with st.sidebar:
-    st.markdown("### 📊 System Status")
+    st.markdown("### ⚙️ Configuration")
     
-    # Model status
-    if model is not None:
-        st.markdown('<span class="status-indicator status-ready"></span>Model: Ready', unsafe_allow_html=True)
-        st.success("�� Memory Optimized")
+    # API Status
+    st.markdown("### 📊 Model Status")
+    if FASTAPI_AVAILABLE and "api_started" in st.session_state:
+        st.markdown('<span class="status-indicator status-ready"></span>FastAPI: Running (127.0.0.1:8000)', unsafe_allow_html=True)
+        st.markdown('<span class="status-indicator status-ready"></span>Video Model: Optimized', unsafe_allow_html=True)
+        st.markdown('<span class="status-indicator status-error"></span>Image Model: Disabled', unsafe_allow_html=True)
     else:
-        st.markdown('<span class="status-indicator status-error"></span>Model: Not Loaded', unsafe_allow_html=True)
-        if model_error:
-            st.error(model_error)
+        st.markdown('<span class="status-indicator status-error"></span>FastAPI: Not Available', unsafe_allow_html=True)
+    
+    st.markdown("---")
+    
+    # ✅ API URL - Same as requested
+    API_URL = "http://127.0.0.1:8000/predict"
+    st.text_input(
+        "API Endpoint",
+        value=API_URL,
+        disabled=True,
+        help="FastAPI running internally on port 8000"
+    )
     
     st.markdown("---")
-    st.markdown("### 🎯 Features")
+    st.markdown("### 📋 Supported Formats")
     st.markdown("""
-    - ✅ Memory Optimized
-    - ✅ Hugging Face Ready
-    - ✅ Error Handling
-    - ✅ GPU/CPU Compatible
+    **Images:**
+    - JPG, JPEG, PNG
+    
+    **Videos:**
+    - MP4, AVI, MOV, MKV
     """)
     
     st.markdown("---")
-    st.markdown("### 📋 Supported")
+    st.markdown("### ℹ️ About")
     st.markdown("""
-    **Images:** JPG, PNG, JPEG  
-    **Size:** < 10MB recommended
+    DeepGuard AI uses advanced deep learning 
+    models to detect deepfake content in 
+    videos with high accuracy.
+    
+    **Memory Optimized Version:**
+    - ❌ Image processing disabled
+    - ✅ Video processing only
+    - 🚀 50-70% less memory usage
     """)
 
-# Main content
-if model is None:
-    st.error("❌ Model not available. Please check model files.")
-    st.stop()
+# Main content area
+st.markdown("""
+    <div class="info-box">
+        <h3>🔍 How It Works</h3>
+        <p>Upload a video file to analyze. Our AI-powered system will detect if the content is real or a deepfake using state-of-the-art neural networks. This version is optimized for memory efficiency with video-only processing.</p>
+    </div>
+""", unsafe_allow_html=True)
 
-st.markdown("### 📤 Upload Image for Analysis")
-uploaded_file = st.file_uploader(
-    "Choose an image file",
-    type=["jpg", "jpeg", "png"],
-    help="Upload an image to detect deepfake content"
-)
+# File upload section
+st.markdown("### 📤 Upload Video for Analysis")
 
+col1, col2 = st.columns([1, 1])
+
+with col1:
+    uploaded_file = st.file_uploader(
+        "Choose a video file",
+        type=["mp4", "avi", "mov", "mkv", "flv", "wmv", "webm"],
+        help="Upload a video file to detect deepfakes (Image processing disabled)",
+        label_visibility="collapsed"
+    )
+
+with col2:
+    st.markdown("""
+    <div class="feature-box">
+        <h4>✨ Features</h4>
+        <ul>
+            <li>Video DeepFake Detection</li>
+            <li>Memory Optimized</li>
+            <li>Real-time Analysis</li>
+            <li>50-70% Less Memory Usage</li>
+            <li>Fast Processing</li>
+        </ul>
+    </div>
+    """, unsafe_allow_html=True)
+
+# Display uploaded file and process
 if uploaded_file is not None:
-    # File size check
-    if uploaded_file.size > 10 * 1024 * 1024:  # 10MB limit
-        st.error("❌ File too large. Please upload < 10MB")
-        st.stop()
+    st.markdown("---")
+    
+    # Always video (since only videos are allowed)
+    file_extension = uploaded_file.name.split('.')[-1].lower()
     
     col1, col2 = st.columns([2, 1])
     
     with col1:
-        st.image(uploaded_file, caption="Uploaded Image", use_column_width=True)
+        st.markdown("### 📹 Uploaded Video")
+        st.info(f"Video file: {uploaded_file.name} ({uploaded_file.size / (1024*1024):.2f} MB)")
+        st.markdown("**Note:** Video processing optimized for memory efficiency.")
     
     with col2:
-        st.markdown("### 📊 File Info")
-        st.metric("Size", f"{uploaded_file.size / (1024*1024):.2f} MB")
-        st.metric("Type", uploaded_file.type)
+        st.markdown("### 📊 File Information")
+        st.metric("File Name", uploaded_file.name)
+        st.metric("File Size", f"{uploaded_file.size / (1024*1024):.2f} MB")
+        st.metric("File Type", "Video")
+        st.metric("Processing", "Optimized")
     
     # Analyze button
-    if st.button("🔍 Analyze for DeepFake", use_container_width=True, type="primary"):
+    st.markdown("---")
+    col1, col2, col3 = st.columns([1, 2, 1])
+    
+    with col2:
+        analyze_button = st.button(
+            "🔍 Analyze Video for DeepFake",
+            use_container_width=True,
+            type="primary"
+        )
+    
+    if analyze_button:
+        # Save uploaded file temporarily
+        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{file_extension}") as tmp_file:
+            tmp_file.write(uploaded_file.getvalue())
+            tmp_path = tmp_file.name
+        
         try:
-            with st.spinner("🔄 Analyzing..."):
-                # Process image
-                img = Image.open(uploaded_file).convert("RGB")
-                img = img.resize((224, 224))
-                arr = np.asarray(img)
+            # Prepare file for upload
+            files = {
+                "file": (
+                    uploaded_file.name,
+                    open(tmp_path, "rb"),
+                    uploaded_file.type if hasattr(uploaded_file, 'type') else f"video/{file_extension}"
+                )
+            }
+            
+            # Show progress
+            with st.spinner("🔄 Analyzing video... Memory optimized processing..."):
+                response = requests.post(API_URL, files=files, timeout=180)  # Longer timeout for videos
+            
+            # Close file
+            files["file"][1].close()
+            
+            if response.status_code == 200:
+                result = response.json()
                 
-                # Predict
-                prediction = predict_memory_efficient(model, arr)
+                # Display results in a nice format
+                st.markdown("---")
+                st.markdown("### 📊 Analysis Results")
                 
-                if prediction is not None:
-                    # Process result
-                    if prediction.shape[-1] == 1:
-                        prob = float(prediction[0][0])
-                        pred_label = "FAKE" if prob >= 0.5 else "REAL"
-                        confidence = max(prob, 1-prob) * 100
-                    else:
-                        pred_idx = np.argmax(prediction[0])
-                        pred_label = "FAKE" if pred_idx == 1 else "REAL"
-                        confidence = float(np.max(prediction[0])) * 100
-                    
-                    # Display result
-                    col1, col2 = st.columns([1, 1])
-                    
-                    with col1:
-                        if pred_label == "FAKE":
-                            st.error(f"🔴 {pred_label}")
-                        else:
-                            st.success(f"🟢 {pred_label}")
-                    
-                    with col2:
-                        st.metric("Confidence", f"{confidence:.2f}%")
-                    
-                    st.success("✅ Analysis completed!")
+                # Prediction result
+                prediction = result.get("prediction", "unknown")
+                probabilities = result.get("probabilities", [[0, 0]])
+                
+                # Color coding
+                if prediction.lower() == "fake":
+                    prediction_color = "🔴"
+                    prediction_bg = "#ffebee"
                 else:
-                    st.error("❌ Prediction failed")
+                    prediction_color = "🟢"
+                    prediction_bg = "#e8f5e9"
+                
+                col1, col2 = st.columns([1, 1])
+                
+                with col1:
+                    st.markdown(f"""
+                    <div style="background: {prediction_bg}; padding: 2rem; border-radius: 10px; text-align: center; box-shadow: 0 2px 10px rgba(0,0,0,0.1);">
+                        <h2 style="margin: 0; color: #333;">{prediction_color} Prediction</h2>
+                        <h1 style="margin: 0.5rem 0; color: #333; text-transform: uppercase;">{prediction}</h1>
+                    </div>
+                    """, unsafe_allow_html=True)
+                
+                with col2:
+                    # Probability display
+                    if len(probabilities) > 0 and len(probabilities[0]) >= 2:
+                        real_prob = probabilities[0][0] * 100
+                        fake_prob = probabilities[0][1] * 100
+                        
+                        st.markdown("### 📈 Confidence Scores")
+                        st.progress(real_prob / 100, text=f"Real: {real_prob:.2f}%")
+                        st.progress(fake_prob / 100, text=f"Fake: {fake_prob:.2f}%")
+                
+                # Detailed results
+                with st.expander("📋 View Detailed Results"):
+                    st.json(result)
+                
+                # Success message
+                st.success("✅ Analysis completed successfully!")
                 
-                # Clear memory
-                gc.collect()
+            else:
+                st.error(f"❌ API Error {response.status_code}: {response.text}")
                 
+        except requests.exceptions.Timeout:
+            st.error("⏱️ Request timed out. The file might be too large or the server is busy.")
+        except requests.exceptions.ConnectionError:
+            st.error("🔌 Connection error. Please make sure the API server is running.")
         except Exception as e:
-            st.error(f"❌ Analysis error: {str(e)}")
-            gc.collect()
+            st.error(f"❌ Error: {str(e)}")
+        finally:
+            # Clean up temp file
+            try:
+                os.unlink(tmp_path)
+            except:
+                pass
 
 else:
-    st.info("👆 Upload an image to start analysis")
+    # Show placeholder when no file is uploaded
+    st.markdown("""
+    <div style="text-align: center; padding: 4rem 2rem; background: #f8f9fa; border-radius: 10px; margin: 2rem 0;">
+        <h3 style="color: #667eea;">👆 Upload a file to get started</h3>
+        <p style="color: #666;">Select an image or video file from your device to analyze for deepfake content</p>
+    </div>
+    """, unsafe_allow_html=True)
 
 # Footer
-st.markdown("---")
 st.markdown("""
-<div style='text-align: center; color: #666; padding: 2rem;'>
-    <p>🛡️ DeepGuard AI | Optimized for Hugging Face Spaces</p>
-    <p style='font-size: 0.9rem;'>Memory Efficient • Production Ready</p>
-</div>
+    <div class="footer">
+        <div class="footer-content">
+            <p class="footer-text">This project made by <strong>ABESH MEENA</strong></p>
+            <p class="footer-text" style="margin-top: 0.5rem; font-size: 0.9rem; opacity: 0.8;">
+                DeepGuard AI - Advanced DeepFake Detection System | Powered by Deep Learning
+            </p>
+        </div>
+    </div>
 """, unsafe_allow_html=True)