🚀 Simplified, robust app for HF Spaces compatibility

app.py

@@ -1,82 +1,89 @@
 import gradio as gr
 import numpy as np
-import cv2
 from PIL import Image
 import os
 import json
 from datetime import datetime
-import logging
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Import InsightFace components
+# Try to import InsightFace, fallback gracefully if not available
+INSIGHTFACE_AVAILABLE = False
 try:
     from insightface.app.face_analysis import FaceAnalysis
     import onnxruntime as ort
-except ImportError as e:
-    logger.error(f"Import error: {e}")
-    FaceAnalysis = None
+    INSIGHTFACE_AVAILABLE = True
+    print("✓ InsightFace available")
+except Exception as e:
+    print(f"InsightFace not available: {e}")
+    print("Will use demo mode")
 
 class FaceMatchingSystem:
     def __init__(self):
-        """Initialize the professional face matching system"""
+        """Initialize the face matching system"""
         self.app = None
         self.face_database = {}
+        self.model_status = "Initializing..."
         self.setup_models()
         
     def setup_models(self):
         """Setup the face recognition models"""
         try:
-            logger.info("Initializing face recognition models...")
-            
-            try:
-                if FaceAnalysis is not None:
-                    logger.info("Attempting to load InsightFace models...")
+            if INSIGHTFACE_AVAILABLE:
+                print("Attempting to load InsightFace models...")
+                try:
                     self.app = FaceAnalysis(
                         name='buffalo_l',
                         providers=['CPUExecutionProvider']
                     )
                     self.app.prepare(ctx_id=0, det_thresh=0.5, det_size=(640, 640))
-                    logger.info("✓ Real InsightFace models loaded successfully")
+                    self.model_status = "✓ InsightFace models loaded successfully"
+                    print(self.model_status)
                     return
-            except Exception as e:
-                logger.warning(f"Failed to load real models: {e}")
+                except Exception as e:
+                    print(f"Failed to load InsightFace models: {e}")
             
-            # Fall back to demo mode
-            logger.info("Using demo mode for deployment")
+            # Fallback to demo mode
             self.app = MockFaceApp()
-            logger.info("✓ Demo face recognition system loaded successfully")
+            self.model_status = "Demo mode active (InsightFace not available)"
+            print(self.model_status)
             
         except Exception as e:
-            logger.error(f"Failed to initialize models: {e}")
+            print(f"Error in model setup: {e}")
             self.app = MockFaceApp()
+            self.model_status = f"Demo mode (Error: {str(e)})"
     
     def extract_face_embedding(self, image):
         """Extract face embedding from image"""
         try:
+            if image is None:
+                return None, "No image provided"
+                
+            # Convert PIL to numpy array (RGB format)
             if isinstance(image, Image.Image):
-                image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+                image_array = np.array(image.convert('RGB'))
+            else:
+                image_array = image
             
+            # Use the face analysis app
             if hasattr(self.app, 'get'):
-                faces = self.app.get(image)
+                faces = self.app.get(image_array)
             else:
-                return np.random.rand(512), "Mock face detected (demo mode)"
+                return np.random.rand(512), "Demo mode: mock embedding generated"
             
             if len(faces) == 0:
                 return None, "No face detected in the image"
             
+            # Use the largest face if multiple detected
             if len(faces) > 1:
                 faces = sorted(faces, key=lambda x: (x.bbox[2] - x.bbox[0]) * (x.bbox[3] - x.bbox[1]), reverse=True)
             
             face = faces[0]
             embedding = face.embedding
+            confidence = getattr(face, 'det_score', 0.95)
             
-            return embedding, f"Face detected successfully (confidence: {face.det_score:.3f})"
+            return embedding, f"Face detected (confidence: {confidence:.3f})"
             
         except Exception as e:
-            logger.error(f"Error extracting face embedding: {e}")
+            print(f"Error extracting face embedding: {e}")
             return None, f"Error processing image: {str(e)}"
     
     def add_face_to_database(self, image, person_name):
@@ -145,7 +152,7 @@ class FaceMatchingSystem:
             with open('face_database.json', 'w') as f:
                 json.dump(self.face_database, f, indent=2)
         except Exception as e:
-            logger.error(f"Failed to save database: {e}")
+            print(f"Failed to save database: {e}")
     
     def load_database(self):
         """Load the face database"""
@@ -153,9 +160,9 @@ class FaceMatchingSystem:
             if os.path.exists('face_database.json'):
                 with open('face_database.json', 'r') as f:
                     self.face_database = json.load(f)
-                logger.info(f"Loaded {len(self.face_database)} faces from database")
+                print(f"Loaded {len(self.face_database)} faces from database")
         except Exception as e:
-            logger.error(f"Failed to load database: {e}")
+            print(f"Failed to load database: {e}")
             self.face_database = {}
     
     def get_database_info(self):
@@ -199,166 +206,100 @@ class MockFaceApp:
         return [MockFace(image_hash)]
 
 # Initialize the system
-logger.info("Initializing Face Matching System...")
+print("Initializing Face Matching System...")
 face_system = FaceMatchingSystem()
 face_system.load_database()
 
-def create_interface():
-    """Create the Gradio interface"""
+# Create a simple, robust Gradio interface
+with gr.Blocks(title="FaceMatch Pro") as demo:
     
-    with gr.Blocks(
-        title="FaceMatch Pro - Professional Face Recognition",
-        theme=gr.themes.Soft()
-    ) as demo:
-        
-        # Header
-        gr.HTML("""
-        <div style="text-align: center; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 2rem; border-radius: 15px; margin-bottom: 2rem;">
-            <h1>🎯 FaceMatch Pro</h1>
-            <p style="font-size: 1.2rem;">Advanced AI-Powered Face Recognition & Matching System</p>
-            <div style="display: flex; justify-content: center; gap: 2rem; margin: 1rem 0;">
-                <div style="text-align: center;">
-                    <div style="font-size: 1.5rem; font-weight: bold;">99%+</div>
-                    <div style="font-size: 0.9rem; opacity: 0.9;">Accuracy</div>
-                </div>
-                <div style="text-align: center;">
-                    <div style="font-size: 1.5rem; font-weight: bold;">&lt;50ms</div>
-                    <div style="font-size: 0.9rem; opacity: 0.9;">Response Time</div>
-                </div>
-                <div style="text-align: center;">
-                    <div style="font-size: 1.5rem; font-weight: bold;">512D</div>
-                    <div style="font-size: 0.9rem; opacity: 0.9;">Feature Vector</div>
-                </div>
-            </div>
-            <p style="margin: 1rem 0; opacity: 0.9;">🔒 Privacy-First • ⚡ Real-Time Processing • 🎯 Enterprise-Grade Accuracy</p>
-        </div>
-        """)
-        
-        with gr.Tabs():
-            # Tab 1: Add Face to Database
-            with gr.Tab("📥 Add Face to Database"):
-                gr.HTML("<h3>👤 Register New Face</h3>")
-                
-                with gr.Row():
-                    with gr.Column():
-                        add_image = gr.Image(label="Upload Photo", type="pil", height=300)
-                        person_name = gr.Textbox(label="Person Name", placeholder="Enter name...")
-                        add_btn = gr.Button("Add to Database", variant="primary")
-                    
-                    with gr.Column():
-                        add_result = gr.Textbox(label="Result", lines=3)
-                        database_info = gr.Textbox(
-                            label="Database Info", 
-                            lines=8, 
-                            value=face_system.get_database_info()
-                        )
-                
-                add_btn.click(
-                    face_system.add_face_to_database,
-                    inputs=[add_image, person_name],
-                    outputs=[add_result, database_info]
-                )
+    gr.Markdown("# 🎯 FaceMatch Pro")
+    gr.Markdown("### Professional Face Recognition System")
+    
+    # Status display
+    status_display = gr.Textbox(
+        label="System Status", 
+        value=face_system.model_status,
+        interactive=False
+    )
+    
+    with gr.Tabs():
+        # Tab 1: Add Face
+        with gr.Tab("Add Face"):
+            gr.Markdown("### Add a face to the database")
             
-            # Tab 2: Match Face
-            with gr.Tab("🔍 Face Recognition"):
-                gr.HTML("<h3>🔍 Find Face Matches</h3>")
-                
-                with gr.Row():
-                    with gr.Column():
-                        match_image = gr.Image(label="Upload Photo to Match", type="pil", height=300)
-                        threshold = gr.Slider(
-                            minimum=0.3,
-                            maximum=0.9,
-                            value=0.6,
-                            step=0.05,
-                            label="Matching Threshold"
-                        )
-                        match_btn = gr.Button("Find Matches", variant="primary")
-                    
-                    with gr.Column():
-                        match_result = gr.Textbox(label="Match Result", lines=2)
-                        confidence_text = gr.Textbox(label="Confidence Details", lines=2)
-                        confidence_score = gr.Number(label="Confidence Score (%)", precision=1)
+            with gr.Row():
+                with gr.Column():
+                    add_image = gr.Image(label="Upload Photo", type="pil")
+                    person_name = gr.Textbox(label="Person Name", placeholder="Enter name...")
+                    add_btn = gr.Button("Add to Database", variant="primary")
                 
-                match_btn.click(
-                    face_system.match_face,
-                    inputs=[match_image, threshold],
-                    outputs=[match_result, confidence_text, confidence_score]
-                )
+                with gr.Column():
+                    add_result = gr.Textbox(label="Result", lines=3)
+                    database_info = gr.Textbox(
+                        label="Database Info", 
+                        lines=6, 
+                        value=face_system.get_database_info()
+                    )
             
-            # Tab 3: Database Management
-            with gr.Tab("🗄️ Database Management"):
-                gr.HTML("<h3>🗄️ Database Administration</h3>")
-                
-                with gr.Row():
-                    with gr.Column():
-                        db_stats = gr.Textbox(
-                            label="Database Contents",
-                            lines=10,
-                            value=face_system.get_database_info()
-                        )
-                        
-                        with gr.Row():
-                            refresh_btn = gr.Button("Refresh Info", variant="secondary")
-                            clear_btn = gr.Button("Clear Database", variant="stop")
-                        
-                        clear_result = gr.Textbox(label="Action Result", lines=2)
-                
-                refresh_btn.click(
-                    lambda: face_system.get_database_info(),
-                    outputs=[db_stats]
-                )
+            add_btn.click(
+                face_system.add_face_to_database,
+                inputs=[add_image, person_name],
+                outputs=[add_result, database_info]
+            )
+        
+        # Tab 2: Match Face
+        with gr.Tab("Match Face"):
+            gr.Markdown("### Find face matches")
+            
+            with gr.Row():
+                with gr.Column():
+                    match_image = gr.Image(label="Upload Photo to Match", type="pil")
+                    threshold = gr.Slider(
+                        minimum=0.3,
+                        maximum=0.9,
+                        value=0.6,
+                        step=0.05,
+                        label="Matching Threshold"
+                    )
+                    match_btn = gr.Button("Find Matches", variant="primary")
                 
-                clear_btn.click(
-                    face_system.clear_database,
-                    outputs=[clear_result, db_stats]
-                )
+                with gr.Column():
+                    match_result = gr.Textbox(label="Match Result", lines=2)
+                    confidence_text = gr.Textbox(label="Confidence Details", lines=2)
+                    confidence_score = gr.Number(label="Confidence Score (%)", precision=1)
             
-            # Tab 4: About
-            with gr.Tab("ℹ️ About"):
-                gr.HTML("""
-                <div style="padding: 2rem;">
-                    <h2>🎯 FaceMatch Pro</h2>
-                    <p>Professional-grade face recognition system powered by state-of-the-art AI technology.</p>
-                    
-                    <h3>🚀 Key Features</h3>
-                    <ul>
-                        <li>99%+ accuracy face detection & recognition</li>
-                        <li>Real-time processing with &lt;50ms response</li>
-                        <li>Privacy-first local processing</li>
-                        <li>Confidence scoring & similarity metrics</li>
-                        <li>Persistent database storage</li>
-                        <li>Professional web interface</li>
-                    </ul>
-                    
-                    <h3>⚙️ Technical Specifications</h3>
-                    <ul>
-                        <li>Deep Convolutional Neural Networks</li>
-                        <li>512-dimensional feature vectors</li>
-                        <li>ONNX Runtime CPU optimization</li>
-                        <li>Cosine similarity matching</li>
-                        <li>RetinaFace detection architecture</li>
-                        <li>JSON-based database storage</li>
-                    </ul>
-                    
-                    <h3>🔒 Privacy & Security</h3>
-                    <p><strong>Local Processing:</strong> All face recognition processing happens locally on the server. No data is transmitted to external services.</p>
-                    <p><strong>Secure Storage:</strong> Face embeddings are stored locally in JSON format.</p>
-                    <p><strong>Privacy-First:</strong> Original images are not stored permanently, only mathematical representations.</p>
-                </div>
-                """)
+            match_btn.click(
+                face_system.match_face,
+                inputs=[match_image, threshold],
+                outputs=[match_result, confidence_text, confidence_score]
+            )
         
-        # Footer
-        gr.HTML("""
-        <div style="text-align: center; margin-top: 2rem; padding: 1rem; background: #f8f9fa; border-radius: 10px;">
-            <p>🔒 All processing happens locally. Your images are never stored or transmitted externally.</p>
-            <p>💡 This is a demonstration of professional face recognition capabilities.</p>
-        </div>
-        """)
-    
-    return demo
+        # Tab 3: Database Management
+        with gr.Tab("Database"):
+            gr.Markdown("### Database Management")
+            
+            db_stats = gr.Textbox(
+                label="Database Contents",
+                lines=8,
+                value=face_system.get_database_info()
+            )
+            
+            with gr.Row():
+                refresh_btn = gr.Button("Refresh Info", variant="secondary")
+                clear_btn = gr.Button("Clear Database", variant="stop")
+            
+            clear_result = gr.Textbox(label="Action Result", lines=2)
+            
+            refresh_btn.click(
+                lambda: face_system.get_database_info(),
+                outputs=[db_stats]
+            )
+            
+            clear_btn.click(
+                face_system.clear_database,
+                outputs=[clear_result, db_stats]
+            )
 
-# Create and launch the interface
 if __name__ == "__main__":
-    demo = create_interface()
     demo.launch()