🚨 EMERGENCY FIX: Ultra-simple app to avoid Gradio schema bug

app.py

@@ -5,181 +5,181 @@ import os
 import json
 
 # Try to import InsightFace
+INSIGHTFACE_AVAILABLE = False
 try:
     from insightface.app.face_analysis import FaceAnalysis
     INSIGHTFACE_AVAILABLE = True
     print("✓ InsightFace available")
-except Exception as e:
-    INSIGHTFACE_AVAILABLE = False
-    print(f"InsightFace not available: {e}")
+except:
+    print("InsightFace not available, using demo mode")
 
-class SimpleFaceSystem:
-    def __init__(self):
-        self.app = None
-        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)"
-        
-        # Load existing database
-        try:
-            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 = {}
+# Global variables
+face_app = None
+face_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"
-        
+def setup_models():
+    global face_app
+    if INSIGHTFACE_AVAILABLE:
         try:
-            img_array = np.array(image.convert('RGB'))
-            faces = self.app.get(img_array)
-            if not faces:
-                return None, "No face detected"
-            face = faces[0]
-            return face.embedding, f"Face detected (confidence: {face.det_score:.2f})"
+            print("Loading InsightFace models...")
+            face_app = FaceAnalysis(name='buffalo_l', providers=['CPUExecutionProvider'])
+            face_app.prepare(ctx_id=0, det_thresh=0.5, det_size=(640, 640))
+            print("✓ InsightFace models loaded")
+            return "✓ InsightFace models loaded successfully"
         except Exception as e:
-            return None, f"Error: {str(e)}"
+            print(f"Failed to load InsightFace: {e}")
+            return f"Demo mode (InsightFace failed: {str(e)[:50]})"
+    return "Demo mode (InsightFace not available)"
 
-    def add_face(self, image, name):
-        if not name or not name.strip():
-            return "Please enter a name", self.get_db_info()
-        
-        name = name.strip()
-        embedding, msg = self.get_embedding(image)
-        
-        if embedding is None:
-            return f"Failed: {msg}", self.get_db_info()
-        
-        self.database[name] = embedding.tolist()
-        
-        # Save database
-        try:
-            with open('faces.json', 'w') as f:
-                json.dump(self.database, f)
-        except:
-            pass
-        
-        return f"✓ Added {name} ({msg})", self.get_db_info()
+def load_database():
+    global face_database
+    try:
+        if os.path.exists('faces.json'):
+            with open('faces.json', 'r') as f:
+                face_database = json.load(f)
+            print(f"Loaded {len(face_database)} faces from database")
+    except:
+        face_database = {}
 
-    def match_face(self, image):
-        if not self.database:
-            return "Database is empty", ""
-        
-        if not image:
-            return "Please upload an image", ""
-        
-        embedding, msg = self.get_embedding(image)
-        if embedding is None:
-            return f"Failed: {msg}", ""
-        
-        best_match = None
-        best_score = -1
-        
-        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_score > 0.6:
-            return f"✓ Match: {best_match} ({best_score:.2f})", f"Confidence: {best_score*100:.1f}%"
-        else:
-            return "❌ No match found", f"Best score: {best_score:.2f} (threshold: 0.6)"
+def save_database():
+    try:
+        with open('faces.json', 'w') as f:
+            json.dump(face_database, f)
+    except:
+        pass
 
-    def get_db_info(self):
-        if not self.database:
-            return "Database is empty"
-        return f"Database has {len(self.database)} faces: {', '.join(list(self.database.keys())[:5])}"
+def get_embedding(image):
+    global face_app
+    if not face_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:
+        img_array = np.array(image.convert('RGB'))
+        faces = face_app.get(img_array)
+        if not faces:
+            return None, "No face detected"
+        face = faces[0]
+        return face.embedding, f"Face detected (confidence: {face.det_score:.2f})"
+    except Exception as e:
+        return None, f"Error: {str(e)}"
 
-    def clear_db(self):
-        self.database = {}
-        try:
-            with open('faces.json', 'w') as f:
-                json.dump({}, f)
-        except:
-            pass
-        return "Database cleared", ""
+def add_face_to_database(image, name):
+    if not name or not name.strip():
+        return "Please enter a name"
+    
+    name = name.strip()
+    embedding, msg = get_embedding(image)
+    
+    if embedding is None:
+        return f"Failed: {msg}"
+    
+    face_database[name] = embedding.tolist()
+    save_database()
+    
+    return f"✓ Added {name} ({msg}). Database now has {len(face_database)} faces."
 
-# Initialize system
-print("Starting FaceMatch system...")
-face_system = SimpleFaceSystem()
+def match_face_in_database(image):
+    if not face_database:
+        return "Database is empty. Please add faces first."
+    
+    if not image:
+        return "Please upload an image"
+    
+    embedding, msg = get_embedding(image)
+    if embedding is None:
+        return f"Failed: {msg}"
+    
+    best_match = None
+    best_score = -1
+    
+    for name, stored_emb in face_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_score > 0.6:
+        return f"✓ Match Found: {best_match} (confidence: {best_score*100:.1f}%)"
+    else:
+        return f"❌ No match found. Best score: {best_score*100:.1f}% (threshold: 60%)"
+
+def get_database_status():
+    if not face_database:
+        return "Database is empty"
+    names = list(face_database.keys())[:5]
+    if len(face_database) > 5:
+        names.append(f"... and {len(face_database)-5} more")
+    return f"Database has {len(face_database)} faces: {', '.join(names)}"
 
-# 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"):
-            with gr.Row():
-                add_img = gr.Image(type="pil", label="Upload Photo")
-                with gr.Column():
-                    add_name = gr.Textbox(label="Name", placeholder="Enter person's name")
-                    add_btn = gr.Button("Add to Database", variant="primary")
-                    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,
-                inputs=[add_img, add_name],
-                outputs=[add_result, add_info]
-            )
-        
-        with gr.Tab("Match Face"):
-            with gr.Row():
-                match_img = gr.Image(type="pil", label="Upload Photo to Match")
-                with gr.Column():
-                    match_btn = gr.Button("Find Match", variant="primary")
-                    match_result = gr.Textbox(label="Match Result", lines=2)
-                    match_conf = gr.Textbox(label="Confidence", lines=2)
-            
-            match_btn.click(
-                face_system.match_face,
-                inputs=[match_img],
-                outputs=[match_result, match_conf]
-            )
-        
-        with gr.Tab("Database"):
-            db_info = gr.Textbox(label="Database Contents", lines=5, value=face_system.get_db_info())
-            with gr.Row():
-                refresh_btn = gr.Button("Refresh")
-                clear_btn = gr.Button("Clear Database", variant="stop")
-            clear_result = gr.Textbox(label="Result", lines=2)
-            
-            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
+def clear_database():
+    global face_database
+    face_database = {}
+    save_database()
+    return "Database cleared successfully"
+
+# Initialize
+print("Starting FaceMatch system...")
+status_msg = setup_models()
+load_database()
 
-# Create and launch
-demo = create_app()
+# Create interface using legacy Interface (more stable than Blocks)
+with gr.Blocks(title="FaceMatch Pro") as demo:
+    gr.Markdown("# 🎯 FaceMatch Pro")
+    gr.Markdown("### Professional Face Recognition System")
+    
+    # Status
+    gr.Markdown(f"**System Status:** {status_msg}")
+    gr.Markdown(f"**Database Status:** {get_database_status()}")
+    
+    # Add Face Interface
+    gr.Markdown("## Add Face to Database")
+    with gr.Row():
+        add_image_input = gr.Image(type="pil", label="Upload Photo")
+        add_name_input = gr.Textbox(label="Person Name", placeholder="Enter name...")
+    
+    add_button = gr.Button("Add to Database", variant="primary")
+    add_output = gr.Textbox(label="Result", lines=2)
+    
+    add_button.click(
+        fn=add_face_to_database,
+        inputs=[add_image_input, add_name_input],
+        outputs=add_output
+    )
+    
+    # Match Face Interface
+    gr.Markdown("## Find Face Match")
+    match_image_input = gr.Image(type="pil", label="Upload Photo to Match")
+    match_button = gr.Button("Find Match", variant="primary")
+    match_output = gr.Textbox(label="Match Result", lines=3)
+    
+    match_button.click(
+        fn=match_face_in_database,
+        inputs=match_image_input,
+        outputs=match_output
+    )
+    
+    # Database Management
+    gr.Markdown("## Database Management")
+    status_button = gr.Button("Check Database Status")
+    clear_button = gr.Button("Clear Database", variant="stop")
+    db_output = gr.Textbox(label="Database Status", lines=2)
+    
+    status_button.click(
+        fn=get_database_status,
+        outputs=db_output
+    )
+    
+    clear_button.click(
+        fn=clear_database,
+        outputs=db_output
+    )
 
 if __name__ == "__main__":
     demo.launch()