Update backend/main.py

backend/main.py

@@ -1,7 +1,7 @@
 import os
 import socketio
 import uvicorn
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 import asyncio
 import base64
@@ -10,166 +10,156 @@ import numpy as np
 import random
 from deepface import DeepFace
 from supabase import create_client, Client
+import time
 
-# --- 1. CONFIGURATION SUPABASE ---
+# --- 1. CONFIGURATION ---
 SUPABASE_URL = os.getenv("SUPABASE_URL", "https://gwjrwejdjpctizolfkcz.supabase.co")
 SUPABASE_KEY = os.getenv("SUPABASE_KEY")
 
 try:
     if SUPABASE_KEY:
         supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
-        print("☁️ Connecté à Supabase")
-    else:
-        print("⚠️ ATTENTION: SUPABASE_KEY manquante !")
-except:
-    pass
-
-# --- 2. SERVER SETUP ---
-def force_allow_origins(origin, environ, **kwargs):
-    return True
-
-sio = socketio.AsyncServer(
-    async_mode='asgi',
-    cors_allowed_origins=force_allow_origins,
-    logger=False,        # On réduit les logs pour la performance
-    engineio_logger=False,
-    always_connect=True
-)
+        print("☁️ Supabase Connecté")
+except: pass
 
+# --- 2. SOCKET IO (Optimisé) ---
+sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*', logger=False, engineio_logger=False, always_connect=True)
 app = FastAPI()
-app.add_middleware(
-    CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
-)
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
 socket_app = socketio.ASGIApp(sio, app)
 
-# --- 3. VARIABLES GLOBALES ---
-# On stocke l'état pour chaque client connecté (sid)
-sessions_data = {} 
+# --- 3. MOTEUR LÉGER (Pour le Carré Vert) ---
+# On charge le détecteur de visage ultra-rapide d'OpenCV
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+
+# --- 4. ETAT GLOBAL ---
+sessions = {}
 
 def get_default_kpis():
     return {
         "engagement": 0, "satisfaction": 50, "trust": 50, "loyalty": 50, "opinion": 50,
-        "lbl_eng": "En attente...", "lbl_sat": "Analyse..."
+        "lbl_eng": "En attente...", "lbl_sat": "Calibration..."
     }
 
-# --- 4. LOGIQUE MÉTIER ---
-def analyze_image_task(frame):
-    # Cette fonction sera exécutée dans un thread séparé pour ne pas bloquer
+# --- 5. TÂCHE DE FOND (LOURDE) ---
+def deepface_task(frame):
+    # C'est ici que l'IA réfléchit (ça peut prendre 1 à 2 secondes)
     try:
-        result = DeepFace.analyze(frame, actions=['emotion'], enforce_detection=False, silent=True)
-        data = result[0] if isinstance(result, list) else result
-        emotion = data['dominant_emotion']
-        region = data['region']
-        face_coords = {'x': region['x'], 'y': region['y'], 'w': region['w'], 'h': region['h']} if region['w'] > 0 else None
+        objs = DeepFace.analyze(frame, actions=['emotion'], enforce_detection=False, silent=True)
+        data = objs[0] if isinstance(objs, list) else objs
+        
+        # Calculs KPIs simulés basés sur l'émotion réelle
+        emo = data['dominant_emotion']
+        val = 0.8 if emo == "happy" else (-0.6 if emo in ["sad", "angry", "fear"] else 0.0)
+        aro = 0.8 if emo in ["angry", "fear", "surprise"] else 0.3
         
-        # Calcul KPI (Algorithme)
-        valence = 0.0; arousal = 0.0
-        if emotion == "happy": valence = 0.8; arousal = 0.6
-        elif emotion == "sad": valence = -0.6; arousal = 0.2
-        elif emotion == "angry": valence = -0.7; arousal = 0.8
-        elif emotion == "fear": valence = -0.7; arousal = 0.8
-        elif emotion == "surprise": valence = 0.2; arousal = 0.9
-        else: valence = 0.0; arousal = 0.3 # neutral
-
         def clamp(n): return max(0, min(100, int(n)))
-        kpis = {
-            "engagement": clamp((arousal * 100) + random.uniform(0, 10)),
-            "satisfaction": clamp(((valence + 1) / 2) * 100),
-            "trust": clamp(50 + (valence * 20)),
-            "loyalty": clamp(50 + (valence * 10)),
-            "opinion": clamp(((valence + 1) / 2) * 100),
-            "lbl_eng": "Fort 🔥" if arousal > 0.6 else "Moyen",
-            "lbl_sat": "Positif 😃" if valence > 0.2 else ("Négatif 😡" if valence < -0.2 else "Neutre 😐")
+        return {
+            "emotion": emo,
+            "metrics": {
+                "engagement": clamp((aro * 100) + random.uniform(0, 10)),
+                "satisfaction": clamp(((val + 1) / 2) * 100),
+                "trust": clamp(50 + (val * 20)),
+                "loyalty": clamp(50 + (val * 10)),
+                "opinion": clamp(((val + 1) / 2) * 100),
+                "lbl_eng": "Fort 🔥" if aro > 0.6 else "Moyen",
+                "lbl_sat": "Positif 😃" if val > 0.2 else "Neutre 😐"
+            }
         }
-        return {"emotion": emotion, "face_coords": face_coords, "kpis": kpis}
-    except Exception as e:
-        print(f"DeepFace Error: {e}")
-        return None
+    except: return None
 
-# --- 5. SOCKET EVENTS ---
+# --- 6. ÉVÉNEMENTS ---
 @sio.event
 async def connect(sid, environ):
-    print(f"✅ Client CONNECTÉ: {sid}")
-    sessions_data[sid] = {
-        "is_recording": False, "session_time": 0, "db_id": None, 
-        "last_data": {"emotion": "neutral", "face_coords": None, "kpis": get_default_kpis()},
-        "is_processing": False # Verrou pour éviter la surcharge
+    print(f"✅ CONNECTÉ: {sid}")
+    sessions[sid] = {
+        "is_recording": False, "session_time": 0, "db_id": None,
+        "face_coords": None, "emotion": "neutral", "metrics": get_default_kpis(),
+        "last_deepface_time": 0
     }
 
 @sio.event
 async def disconnect(sid):
-    if sid in sessions_data: del sessions_data[sid]
+    if sid in sessions: del sessions[sid]
 
 @sio.event
 async def start_session(sid, data):
-    if sid in sessions_data:
-        sessions_data[sid]["is_recording"] = True
-        sessions_data[sid]["session_time"] = 0
-        print(f"▶️ SESSION START pour {sid}")
-        # Optionnel: Création DB ici
+    if sid in sessions:
+        sessions[sid]["is_recording"] = True
+        sessions[sid]["session_time"] = 0
+        try:
+            res = supabase.table('sessions').insert({"first_name": data.get('firstName', ''), "last_name": data.get('lastName', ''), "client_id": data.get('clientId', '')}).execute()
+            sessions[sid]["db_id"] = res.data[0]['id']
+        except: pass
 
 @sio.event
 async def stop_session(sid):
-    if sid in sessions_data: 
-        sessions_data[sid]["is_recording"] = False
-        print(f"⏹️ SESSION STOP pour {sid}")
+    if sid in sessions: sessions[sid]["is_recording"] = False
 
 @sio.event
 async def process_frame(sid, data_uri):
-    # Si le client n'existe pas ou si le serveur est déjà occupé à traiter une image pour ce client : ON IGNORE
-    if sid not in sessions_data: return
-    if sessions_data[sid]["is_processing"]: return 
-
-    sessions_data[sid]["is_processing"] = True # On verrouille
-
+    if sid not in sessions: return
+    
     try:
-        # 1. Décodage Image
+        # 1. Décodage Rapide
         encoded_data = data_uri.split(',')[1]
         nparr = np.frombuffer(base64.b64decode(encoded_data), np.uint8)
         frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-
-        # 2. Analyse dans un THREAD SÉPARÉ (Magie Asyncio)
-        # Cela empêche le serveur de se figer
-        result = await asyncio.to_thread(analyze_image_task, frame)
-
-        # 3. Mise à jour des données si succès
-        if result:
-            sessions_data[sid]["last_data"]["emotion"] = result["emotion"]
-            sessions_data[sid]["last_data"]["face_coords"] = result["face_coords"]
-            sessions_data[sid]["last_data"]["kpis"] = result["kpis"]
+        
+        # 2. DÉTECTION RAPIDE (CARRÉ VERT) - Ça prend 0.01s
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+        
+        if len(faces) > 0:
+            (x, y, w, h) = faces[0] # On prend le premier visage
+            sessions[sid]["face_coords"] = {'x': int(x), 'y': int(y), 'w': int(w), 'h': int(h)}
+        else:
+            sessions[sid]["face_coords"] = None # Pas de visage = Pas de carré
+
+        # 3. ANALYSE LENTE (ÉMOTIONS) - Seulement toutes les 1.5 secondes
+        now = time.time()
+        if now - sessions[sid]["last_deepface_time"] > 1.5: 
+            sessions[sid]["last_deepface_time"] = now
+            # On lance l'IA en arrière-plan sans bloquer
+            asyncio.create_task(run_deepface_background(sid, frame))
 
     except Exception as e:
         print(f"Erreur Frame: {e}")
-    finally:
-        sessions_data[sid]["is_processing"] = False # On déverrouille
 
-# --- 6. BOUCLE D'ENVOI (Le Coeur) ---
+async def run_deepface_background(sid, frame):
+    # Wrapper pour exécuter DeepFace sans bloquer le serveur
+    try:
+        result = await asyncio.to_thread(deepface_task, frame)
+        if result and sid in sessions:
+            sessions[sid]["emotion"] = result["emotion"]
+            sessions[sid]["metrics"] = result["metrics"]
+    except: pass
+
+# --- 7. BOUCLE DE D'ENVOI (BROADCAST) ---
 async def broadcast_loop():
     while True:
-        await asyncio.sleep(1) # 1 Tick par seconde pour l'horloge
+        await asyncio.sleep(0.5) # Mise à jour fluide (2 fois par seconde)
         
-        for sid, session in list(sessions_data.items()):
-            # Gestion du chrono
-            if session["is_recording"]:
-                session["session_time"] += 1
+        for sid in list(sessions.keys()):
+            if sid not in sessions: continue
+            sess = sessions[sid]
+            
+            if sess["is_recording"]:
+                sess["session_time"] += 0.5 # On ajoute 0.5s au chrono
+                # Sauvegarde DB allégée ici si besoin
             
-            # Préparation du paquet
+            # On envoie TOUT ce qu'on a (le carré vert est à jour, l'émotion peut dater d'il y a 1s)
             payload = {
-                "emotion": session["last_data"]["emotion"],
-                "face_coords": session["last_data"]["face_coords"],
-                "metrics": session["last_data"]["kpis"],
-                "session_time": session["session_time"],
-                "is_recording": session["is_recording"]
+                "emotion": sess["emotion"],
+                "face_coords": sess["face_coords"], # C'est ça qui affiche le carré vert !
+                "metrics": sess["metrics"],
+                "session_time": int(sess["session_time"]),
+                "is_recording": sess["is_recording"]
             }
-            
-            # Envoi au Frontend
-            try:
-                await sio.emit('metrics_update', payload, room=sid)
-            except:
-                pass
+            try: await sio.emit('metrics_update', payload, room=sid)
+            except: pass
 
 if __name__ == "__main__":
     @app.on_event("startup")
-    async def startup():
-        asyncio.create_task(broadcast_loop())
+    async def startup(): asyncio.create_task(broadcast_loop())
     uvicorn.run(socket_app, host="0.0.0.0", port=7860)