Update backend/main.py

backend/main.py

@@ -11,7 +11,7 @@ import random
 from deepface import DeepFace
 from supabase import create_client, Client
 
-# --- CONFIGURATION SUPABASE ---
+# --- 1. CONFIGURATION SUPABASE ---
 SUPABASE_URL = os.getenv("SUPABASE_URL", "https://gwjrwejdjpctizolfkcz.supabase.co")
 SUPABASE_KEY = os.getenv("SUPABASE_KEY")
 
@@ -20,57 +20,156 @@ try:
         supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
         print("☁️ Connecté à Supabase")
     else:
-        print("⚠️ Pas de clé Supabase")
+        print("⚠️ ATTENTION: SUPABASE_KEY manquante !")
 except:
     pass
 
-# --- CONFIGURATION SOCKET.IO (LE BYPASS) ---
-# Cette fonction force l'acceptation et imprime l'origine
+# --- 2. SERVER SETUP ---
 def force_allow_origins(origin, environ, **kwargs):
-    print(f"🔍 ORIGIN DETECTED: {origin}") # Debug Log
-    return True # Force YES
+    return True
 
 sio = socketio.AsyncServer(
     async_mode='asgi',
-    cors_allowed_origins=force_allow_origins, # On utilise la fonction
-    logger=True,
-    engineio_logger=True,
+    cors_allowed_origins=force_allow_origins,
+    logger=False,        # On réduit les logs pour la performance
+    engineio_logger=False,
     always_connect=True
 )
 
 app = FastAPI()
 app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+    CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
 )
 socket_app = socketio.ASGIApp(sio, app)
 
-# --- ROUTES ---
-@app.get("/")
-def home(): return {"status": "ok"}
+# --- 3. VARIABLES GLOBALES ---
+# On stocke l'état pour chaque client connecté (sid)
+sessions_data = {} 
 
-@app.get("/api/sessions")
-def get_sessions():
+def get_default_kpis():
+    return {
+        "engagement": 0, "satisfaction": 50, "trust": 50, "loyalty": 50, "opinion": 50,
+        "lbl_eng": "En attente...", "lbl_sat": "Analyse..."
+    }
+
+# --- 4. LOGIQUE MÉTIER ---
+def analyze_image_task(frame):
+    # Cette fonction sera exécutée dans un thread séparé pour ne pas bloquer
     try:
-        return supabase.table('sessions').select("*").order('id', desc=True).execute().data
-    except: return []
+        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
+        
+        # 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": emotion, "face_coords": face_coords, "kpis": kpis}
+    except Exception as e:
+        print(f"DeepFace Error: {e}")
+        return None
 
-# --- SOCKET EVENTS ---
+# --- 5. SOCKET EVENTS ---
 @sio.event
 async def connect(sid, environ):
-    print(f"✅ CONNECTED: {sid}")
+    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
+    }
 
 @sio.event
-async def process_frame(sid, data):
-    # (Votre logique DeepFace simplifiée pour le test)
-    pass
+async def disconnect(sid):
+    if sid in sessions_data: del sessions_data[sid]
 
 @sio.event
 async def start_session(sid, data):
-    print(f"▶️ START SESSION: {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
+
+@sio.event
+async def stop_session(sid):
+    if sid in sessions_data: 
+        sessions_data[sid]["is_recording"] = False
+        print(f"⏹️ SESSION STOP pour {sid}")
+
+@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
+
+    try:
+        # 1. Décodage Image
+        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"]
+
+    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 broadcast_loop():
+    while True:
+        await asyncio.sleep(1) # 1 Tick par seconde pour l'horloge
+        
+        for sid, session in list(sessions_data.items()):
+            # Gestion du chrono
+            if session["is_recording"]:
+                session["session_time"] += 1
+            
+            # Préparation du paquet
+            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"]
+            }
+            
+            # Envoi au Frontend
+            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())
     uvicorn.run(socket_app, host="0.0.0.0", port=7860)