🔧 FIXED: Minimal bulletproof app avoiding Gradio schema bug

app.py

@@ -3,303 +3,183 @@ import numpy as np
 from PIL import Image
 import os
 import json
-from datetime import datetime
 
-# Try to import InsightFace, fallback gracefully if not available
-INSIGHTFACE_AVAILABLE = False
+# Try to import InsightFace
 try:
     from insightface.app.face_analysis import FaceAnalysis
-    import onnxruntime as ort
     INSIGHTFACE_AVAILABLE = True
     print("✓ InsightFace available")
 except Exception as e:
+    INSIGHTFACE_AVAILABLE = False
     print(f"InsightFace not available: {e}")
-    print("Will use demo mode")
 
-class FaceMatchingSystem:
+class SimpleFaceSystem:
     def __init__(self):
-        """Initialize the face matching system"""
         self.app = None
-        self.face_database = {}
-        self.model_status = "Initializing..."
-        self.setup_models()
+        self.database = {}
+        self.status = "Initializing..."
+        self.setup()
+        
+    def setup(self):
+        if INSIGHTFACE_AVAILABLE:
+            try:
+                print("Loading InsightFace models...")
+                self.app = FaceAnalysis(name='buffalo_l', providers=['CPUExecutionProvider'])
+                self.app.prepare(ctx_id=0, det_thresh=0.5, det_size=(640, 640))
+                self.status = "✓ InsightFace loaded"
+                print(self.status)
+            except Exception as e:
+                print(f"Failed to load InsightFace: {e}")
+                self.status = f"Demo mode (InsightFace failed: {str(e)[:50]})"
+        else:
+            self.status = "Demo mode (InsightFace not available)"
         
-    def setup_models(self):
-        """Setup the face recognition models"""
+        # Load existing database
         try:
-            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))
-                    self.model_status = "✓ InsightFace models loaded successfully"
-                    print(self.model_status)
-                    return
-                except Exception as e:
-                    print(f"Failed to load InsightFace models: {e}")
-            
-            # Fallback to demo mode
-            self.app = MockFaceApp()
-            self.model_status = "Demo mode active (InsightFace not available)"
-            print(self.model_status)
-            
-        except Exception as 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"""
+            if os.path.exists('faces.json'):
+                with open('faces.json', 'r') as f:
+                    self.database = json.load(f)
+                print(f"Loaded {len(self.database)} faces from database")
+        except:
+            self.database = {}
+
+    def get_embedding(self, image):
+        if not self.app or not image:
+            # Demo mode - return random but consistent embedding
+            if image:
+                seed = int(np.array(image).mean() * 1000) % 1000
+                np.random.seed(seed)
+                emb = np.random.rand(512)
+                return emb / np.linalg.norm(emb), "Demo embedding"
+            return None, "No image"
+        
         try:
-            if image is None:
-                return None, "No image provided"
-                
-            # Convert PIL to numpy array (RGB format)
-            if isinstance(image, Image.Image):
-                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_array)
-            else:
-                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)
-            
+            img_array = np.array(image.convert('RGB'))
+            faces = self.app.get(img_array)
+            if not faces:
+                return None, "No face detected"
             face = faces[0]
-            embedding = face.embedding
-            confidence = getattr(face, 'det_score', 0.95)
-            
-            return embedding, f"Face detected (confidence: {confidence:.3f})"
-            
+            return face.embedding, f"Face detected (confidence: {face.det_score:.2f})"
         except Exception as 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):
-        """Add a face to the database"""
-        if not person_name or not person_name.strip():
-            return "Please provide a valid person name", ""
+            return None, f"Error: {str(e)}"
+
+    def add_face(self, image, name):
+        if not name or not name.strip():
+            return "Please enter a name", self.get_db_info()
         
-        person_name = person_name.strip()
+        name = name.strip()
+        embedding, msg = self.get_embedding(image)
         
-        embedding, message = self.extract_face_embedding(image)
         if embedding is None:
-            return f"Failed to add {person_name}: {message}", ""
+            return f"Failed: {msg}", self.get_db_info()
         
-        # Store embedding in database
-        self.face_database[person_name] = {
-            'embedding': embedding.tolist() if hasattr(embedding, 'tolist') else embedding,
-            'added_at': datetime.now().isoformat()
-        }
+        self.database[name] = embedding.tolist()
         
         # Save database
-        self.save_database()
+        try:
+            with open('faces.json', 'w') as f:
+                json.dump(self.database, f)
+        except:
+            pass
         
-        return f"✓ Successfully added {person_name} to database ({message})", self.get_database_info()
-    
-    def match_face(self, image, threshold=0.6):
-        """Match a face against the database"""
-        if not self.face_database:
-            return "Database is empty. Please add faces first.", "", 0.0
+        return f"✓ Added {name} ({msg})", self.get_db_info()
+
+    def match_face(self, image):
+        if not self.database:
+            return "Database is empty", ""
+        
+        if not image:
+            return "Please upload an image", ""
         
-        embedding, message = self.extract_face_embedding(image)
+        embedding, msg = self.get_embedding(image)
         if embedding is None:
-            return f"Face matching failed: {message}", "", 0.0
+            return f"Failed: {msg}", ""
         
         best_match = None
-        best_similarity = 0.0
+        best_score = -1
         
-        for person_name, data in self.face_database.items():
-            stored_embedding = np.array(data['embedding'])
-            
-            # Calculate cosine similarity
-            similarity = np.dot(embedding, stored_embedding) / (
-                np.linalg.norm(embedding) * np.linalg.norm(stored_embedding)
-            )
-            
-            if similarity > best_similarity:
-                best_similarity = similarity
-                best_match = person_name
+        for name, stored_emb in self.database.items():
+            stored_emb = np.array(stored_emb)
+            score = np.dot(embedding, stored_emb) / (np.linalg.norm(embedding) * np.linalg.norm(stored_emb))
+            if score > best_score:
+                best_score = score
+                best_match = name
         
-        if best_similarity >= threshold:
-            confidence_percentage = best_similarity * 100
-            return (
-                f"✓ Match Found: {best_match}",
-                f"Confidence: {confidence_percentage:.1f}%",
-                confidence_percentage
-            )
+        if best_score > 0.6:
+            return f"✓ Match: {best_match} ({best_score:.2f})", f"Confidence: {best_score*100:.1f}%"
         else:
-            return (
-                "❌ No match found",
-                f"Best similarity: {best_similarity*100:.1f}% (below threshold {threshold*100:.1f}%)",
-                best_similarity * 100
-            )
-    
-    def save_database(self):
-        """Save the face database"""
-        try:
-            with open('face_database.json', 'w') as f:
-                json.dump(self.face_database, f, indent=2)
-        except Exception as e:
-            print(f"Failed to save database: {e}")
-    
-    def load_database(self):
-        """Load the face database"""
-        try:
-            if os.path.exists('face_database.json'):
-                with open('face_database.json', 'r') as f:
-                    self.face_database = json.load(f)
-                print(f"Loaded {len(self.face_database)} faces from database")
-        except Exception as e:
-            print(f"Failed to load database: {e}")
-            self.face_database = {}
-    
-    def get_database_info(self):
-        """Get information about the current database"""
-        if not self.face_database:
+            return "❌ No match found", f"Best score: {best_score:.2f} (threshold: 0.6)"
+
+    def get_db_info(self):
+        if not self.database:
             return "Database is empty"
-        
-        info = f"Database contains {len(self.face_database)} faces:\\n"
-        for name, data in self.face_database.items():
-            added_date = data.get('added_at', 'Unknown')[:10]
-            info += f"• {name} (added: {added_date})\\n"
-        
-        return info
-    
-    def clear_database(self):
-        """Clear the entire database"""
-        self.face_database = {}
-        self.save_database()
-        return "Database cleared successfully", ""
+        return f"Database has {len(self.database)} faces: {', '.join(list(self.database.keys())[:5])}"
 
-class MockFaceApp:
-    """Mock face app for demo purposes when InsightFace is not available"""
-    def __init__(self):
-        self.face_counter = 0
-        
-    def get(self, image):
-        if image is None:
-            return []
-            
-        # Create deterministic embedding based on image hash
-        image_hash = hash(str(np.array(image).mean())) % 1000
-        
-        class MockFace:
-            def __init__(self, image_hash):
-                np.random.seed(image_hash)
-                self.embedding = np.random.rand(512)
-                self.embedding = self.embedding / np.linalg.norm(self.embedding)
-                self.det_score = 0.85 + (image_hash % 15) / 100
-                self.bbox = [50, 50, 200, 200]
-        
-        return [MockFace(image_hash)]
+    def clear_db(self):
+        self.database = {}
+        try:
+            with open('faces.json', 'w') as f:
+                json.dump({}, f)
+        except:
+            pass
+        return "Database cleared", ""
 
-# Initialize the system
-print("Initializing Face Matching System...")
-face_system = FaceMatchingSystem()
-face_system.load_database()
+# Initialize system
+print("Starting FaceMatch system...")
+face_system = SimpleFaceSystem()
 
-# Create a simple, robust Gradio interface
-with gr.Blocks(title="FaceMatch Pro") as demo:
-    
-    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
+# Create interface
+def create_app():
+    with gr.Blocks(title="FaceMatch Pro") as app:
+        gr.Markdown("# 🎯 FaceMatch Pro")
+        gr.Markdown("### Professional Face Recognition System")
+        
+        # Status
+        gr.Textbox(value=face_system.status, label="System Status", interactive=False)
+        
         with gr.Tab("Add Face"):
-            gr.Markdown("### Add a face to the database")
-            
             with gr.Row():
+                add_img = gr.Image(type="pil", label="Upload Photo")
                 with gr.Column():
-                    add_image = gr.Image(label="Upload Photo", type="pil")
-                    person_name = gr.Textbox(label="Person Name", placeholder="Enter name...")
+                    add_name = gr.Textbox(label="Name", placeholder="Enter person's 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=6, 
-                        value=face_system.get_database_info()
-                    )
+                    add_result = gr.Textbox(label="Result", lines=2)
+                    add_info = gr.Textbox(label="Database Info", lines=3, value=face_system.get_db_info())
             
             add_btn.click(
-                face_system.add_face_to_database,
-                inputs=[add_image, person_name],
-                outputs=[add_result, database_info]
+                face_system.add_face,
+                inputs=[add_img, add_name],
+                outputs=[add_result, add_info]
             )
         
-        # Tab 2: Match Face
         with gr.Tab("Match Face"):
-            gr.Markdown("### Find face matches")
-            
             with gr.Row():
+                match_img = gr.Image(type="pil", label="Upload Photo to Match")
                 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")
-                
-                with gr.Column():
+                    match_btn = gr.Button("Find Match", variant="primary")
                     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)
+                    match_conf = gr.Textbox(label="Confidence", lines=2)
             
             match_btn.click(
                 face_system.match_face,
-                inputs=[match_image, threshold],
-                outputs=[match_result, confidence_text, confidence_score]
+                inputs=[match_img],
+                outputs=[match_result, match_conf]
             )
         
-        # 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()
-            )
-            
+            db_info = gr.Textbox(label="Database Contents", lines=5, value=face_system.get_db_info())
             with gr.Row():
-                refresh_btn = gr.Button("Refresh Info", variant="secondary")
+                refresh_btn = gr.Button("Refresh")
                 clear_btn = gr.Button("Clear Database", variant="stop")
+            clear_result = gr.Textbox(label="Result", lines=2)
             
-            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]
-            )
+            refresh_btn.click(lambda: face_system.get_db_info(), outputs=[db_info])
+            clear_btn.click(face_system.clear_db, outputs=[clear_result, db_info])
+    
+    return app
+
+# Create and launch
+demo = create_app()
 
 if __name__ == "__main__":
     demo.launch()