Update backend/main.py

backend/main.py

@@ -8,158 +8,168 @@ import base64
 import cv2
 import numpy as np
 import random
+from datetime import datetime
 from deepface import DeepFace
 from supabase import create_client, Client
-import time
 
-# --- 1. CONFIGURATION ---
+# --- CONFIGURATION SUPABASE (COMPATIBLE CLOUD & LOCAL) ---
 SUPABASE_URL = os.getenv("SUPABASE_URL", "https://gwjrwejdjpctizolfkcz.supabase.co")
-SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imd3anJ3ZWpkanBjdGl6b2xma2N6Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc2OTA5ODEyNCwiZXhwIjoyMDg0Njc0MTI0fQ.EjU1DGTN-jrdkaC6nJWilFtYZgtu-NKjnfiMVMnHal0")
 
 try:
-    if SUPABASE_KEY:
-        supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
-        print("☁️ Supabase Connecté")
-except: pass
+    supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    print("☁️ Connecté à Supabase")
+except Exception as e:
+    print(f"❌ Erreur Supabase : {e}")
+
+# --- CONFIGURATION SERVEUR (CORS FIXED) ---
+# C'est ici que la magie opère : cors_allowed_origins='*' autorise tout le monde
+sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
 
-# --- 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=["*"])
+# Middleware pour autoriser les requêtes API REST
+app.add_middleware(
+    CORSMiddleware, 
+    allow_origins=["*"], 
+    allow_credentials=True, 
+    allow_methods=["*"], 
+    allow_headers=["*"],
+)
 socket_app = socketio.ASGIApp(sio, app)
 
-# --- 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": "Calibration..."
-    }
-
-# --- 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)
+# --- API REST ---
+@app.get("/api/sessions")
+def get_sessions():
+    response = supabase.table('sessions').select("*").order('id', desc=True).execute()
+    return response.data
+
+@app.get("/api/sessions/{session_id}")
+def get_session_details(session_id: int):
+    sess = supabase.table('sessions').select("*").eq('id', session_id).execute()
+    if not sess.data: raise HTTPException(status_code=404, detail="Session introuvable")
+    meas = supabase.table('measurements').select("*").eq('session_id', session_id).order('session_time', desc=False).execute()
+    return {"info": sess.data[0], "data": meas.data}
+
+@app.delete("/api/sessions/{session_id}")
+def delete_session(session_id: int):
     try:
-        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
-        
-        def clamp(n): return max(0, min(100, int(n)))
-        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 😐"
-            }
-        }
-    except: return None
-
-# --- 6. ÉVÉNEMENTS ---
-@sio.event
-async def connect(sid, environ):
-    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
+        supabase.table('sessions').delete().eq('id', session_id).execute()
+        return {"message": "Supprimé"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# --- LOGIQUE MÉTIER ---
+def calculate_kpis(emotion):
+    valence = 0.0; arousal = 0.0; noise = random.uniform(-0.05, 0.05)
+    if emotion == "happy": valence = 0.8 + noise; arousal = 0.6 + noise
+    elif emotion == "surprise": valence = 0.2 + noise; arousal = 0.9 + noise
+    elif emotion in ["fear", "angry"]: valence = -0.7 + noise; arousal = 0.8 + noise
+    elif emotion == "disgust": valence = -0.8 + noise; arousal = 0.5 + noise
+    elif emotion == "sad": valence = -0.6 + noise; arousal = 0.2 + noise
+    else: valence = 0.0 + noise; arousal = 0.3 + noise
+
+    def clamp(n): return max(0, min(100, int(n)))
+    val_eng = clamp((arousal * 100) + random.uniform(0, 5))
+    val_sat = clamp(((valence + 1) / 2) * 100)
+    val_tru = clamp(50 + (valence * 40) + random.uniform(0, 5)) if valence > 0 else clamp(50 - (abs(valence) * 40) + random.uniform(0, 5))
+    val_loy = clamp((val_sat * 0.7) + (val_tru * 0.3))
+    val_opi = val_sat
+
+    # Labels
+    if val_eng >= 75: lbl_eng = "Engagement Fort 🔥"
+    elif val_eng >= 40: lbl_eng = "Engagement Moyen"
+    else: lbl_eng = "Désengagement 💤"
+
+    if val_sat >= 70: lbl_sat = "Très Satisfait 😃"
+    elif val_sat >= 45: lbl_sat = "Neutre 😐"
+    else: lbl_sat = "Insatisfait 😡"
+    
+    return {
+        "engagement": val_eng, "satisfaction": val_sat, "trust": val_tru, "loyalty": val_loy, "opinion": val_opi,
+        "lbl_eng": lbl_eng, "lbl_sat": lbl_sat
     }
 
-@sio.event
-async def disconnect(sid):
-    if sid in sessions: del sessions[sid]
-
-@sio.event
-async def start_session(sid, data):
-    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: sessions[sid]["is_recording"] = False
+# --- GESTION WEBSOCKET ---
+camera_state = { "emotion": "neutral", "emotion_score": 0, "face_coords": None }
+active_sessions = {}
 
 @sio.event
 async def process_frame(sid, data_uri):
-    if sid not in sessions: return
-    
     try:
-        # 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. DÉTECTION RAPIDE (CARRÉ VERT) - Ça prend 0.01s
-        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+        result = DeepFace.analyze(frame, actions=['emotion'], enforce_detection=False, silent=True)
+        data = result[0] if isinstance(result, list) else result
+        
+        camera_state["emotion"] = data['dominant_emotion']
+        camera_state["emotion_score"] = data['emotion'][data['dominant_emotion']]
         
-        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)}
+        region = data['region']
+        if region['w'] > 0:
+            camera_state["face_coords"] = {'x': region['x'], 'y': region['y'], 'w': region['w'], 'h': region['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}")
+            camera_state["face_coords"] = None
+    except:
+        camera_state["face_coords"] = None
 
-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():
+async def session_manager_loop():
     while True:
-        await asyncio.sleep(0.5) # Mise à jour fluide (2 fois par seconde)
-        
-        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
+        for sid, user_data in list(active_sessions.items()):
+            kpis = calculate_kpis(camera_state["emotion"])
             
-            # On envoie TOUT ce qu'on a (le carré vert est à jour, l'émotion peut dater d'il y a 1s)
-            payload = {
-                "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"]
-            }
-            try: await sio.emit('metrics_update', payload, room=sid)
-            except: pass
+            if user_data["is_recording"]:
+                user_data["session_time"] += 1
+                if user_data["db_id"]:
+                    try:
+                        data_to_insert = {
+                            "session_id": user_data["db_id"],
+                            "session_time": user_data["session_time"],
+                            "emotion": camera_state["emotion"],
+                            "emotion_score": camera_state["emotion_score"],
+                            "engagement_val": kpis["engagement"], "engagement_lbl": kpis["lbl_eng"],
+                            "satisfaction_val": kpis["satisfaction"], "satisfaction_lbl": kpis["lbl_sat"],
+                            "trust_val": kpis["trust"], "loyalty_val": kpis["loyalty"], "opinion_val": kpis["opinion"]
+                        }
+                        supabase.table('measurements').insert(data_to_insert).execute()
+                    except Exception as e: print(f"DB Error: {e}")
+
+            await sio.emit('metrics_update', {
+                "emotion": camera_state["emotion"], "metrics": kpis, 
+                "face_coords": camera_state["face_coords"], 
+                "session_time": user_data["session_time"], 
+                "is_recording": user_data["is_recording"]
+            }, room=sid)
+        await asyncio.sleep(1)
+
+@sio.event
+async def connect(sid, environ): 
+    print(f"Client connecté: {sid}")
+    active_sessions[sid] = { "is_recording": False, "session_time": 0, "db_id": None }
+
+@sio.event
+async def disconnect(sid): 
+    if sid in active_sessions: del active_sessions[sid]
+
+@sio.event
+async def start_session(sid, data):
+    user_session = active_sessions.get(sid)
+    if user_session:
+        user_session["is_recording"] = True
+        user_session["session_time"] = 0
+        try:
+            new_session = { "first_name": data.get('firstName'), "last_name": data.get('lastName'), "client_id": data.get('clientId') }
+            res = supabase.table('sessions').insert(new_session).execute()
+            user_session["db_id"] = res.data[0]['id']
+        except Exception as e: print(f"Start Session Error: {e}")
+
+@sio.event
+async def stop_session(sid):
+    if sid in active_sessions: active_sessions[sid]["is_recording"] = False
 
 if __name__ == "__main__":
     @app.on_event("startup")
-    async def startup(): asyncio.create_task(broadcast_loop())
+    async def startup_event():
+        asyncio.create_task(session_manager_loop())
     uvicorn.run(socket_app, host="0.0.0.0", port=7860)