🚀 Deploy from GitHub Actions - 2026-02-03 10:48:14

README.md

@@ -5,7 +5,7 @@ colorFrom: blue
 colorTo: green
 sdk: docker
 pinned: false
-license: apache-2.0
+license: mit
 ---
 
 # 🧠 Wakee Emotion Detection API
@@ -102,7 +102,7 @@ L'API nécessite les secrets suivants (configurés dans les Settings du Space) :
 
 ## 📄 License
 
-MIT
+mit
 
 ---
 

app.py

@@ -278,7 +278,259 @@ async def predict_emotion(file: UploadFile = File(...)):
         print(f"❌ Erreur prédiction : {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-# (reste des endpoints /insert et /load identiques)
+@app.post("/predict", response_model=PredictionResponse)
+async def predict_emotion(file: UploadFile = File(...)):
+    """
+    Prédiction des 4 émotions depuis une image
+    
+    ⚠️ RIEN N'EST SAUVEGARDÉ à cette étape
+    
+    L'utilisateur doit ensuite appeler /insert pour sauvegarder
+    """
+    
+    if not onnx_session:
+        raise HTTPException(
+            status_code=503, 
+            detail="Model not loaded"
+        )
+    
+    if not file.content_type.startswith('image/'):
+        raise HTTPException(status_code=400, detail="File must be an image")
+    
+    try:
+        # 1. Load image
+        image_bytes = await file.read()
+        image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+        
+        # 2. Preprocessing
+        input_tensor = preprocess_image(image)
+        
+        # 3. Inference ONNX
+        outputs = onnx_session.run(['output'], {'input': input_tensor})
+        scores_array = outputs[0][0]
+        
+        # 4. Format résultats
+        return PredictionResponse(
+            boredom=round(float(scores_array[0]), 2),
+            confusion=round(float(scores_array[1]), 2),
+            engagement=round(float(scores_array[2]), 2),
+            frustration=round(float(scores_array[3]), 2),
+            timestamp=datetime.now().isoformat()
+        )
+        
+        # ⚠️ PAS de sauvegarde R2
+        # ⚠️ PAS de sauvegarde NeonDB
+        # → L'utilisateur décide s'il valide via /insert
+    
+    except Exception as e:
+        print(f"❌ Erreur prédiction : {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/insert", response_model=InsertResponse)
+async def insert_annotation(annotation: AnnotationInsert):
+    """
+    Insert annotation utilisateur
+    
+    Ce endpoint fait 2 choses :
+    1. Upload image vers Cloudflare R2
+    2. Insert labels (predicted + user) dans NeonDB
+    
+    ✅ Appelé uniquement quand l'utilisateur clique "Valider"
+    """
+    
+    # Vérifications
+    if not db_engine:
+        raise HTTPException(status_code=503, detail="Database not available")
+    
+    if not s3_client:
+        raise HTTPException(status_code=503, detail="Storage not available")
+    
+    try:
+        # 1. Decode image base64
+        try:
+            image_bytes = base64.b64decode(annotation.image_base64)
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Invalid base64 image: {e}")
+        
+        # 2. Generate unique filename
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        img_name = f"{timestamp}_{hash(annotation.image_base64) % 10000:04d}.jpg"
+        s3_key = f"collected/{img_name}"
+        
+        # 3. Upload image to Cloudflare R2
+        print(f"📤 Upload vers R2 : {s3_key}")
+        try:
+            s3_client.put_object(
+                Bucket=R2_BUCKET_NAME,
+                Key=s3_key,
+                Body=image_bytes,
+                ContentType='image/jpeg'
+            )
+            print(f"✅ Upload R2 réussi : {img_name}")
+        except ClientError as e:
+            print(f"❌ Erreur upload R2 : {e}")
+            raise HTTPException(status_code=500, detail=f"R2 upload failed: {e}")
+        
+        # 4. Insert labels in NeonDB
+        query = text("""
+            INSERT INTO emotion_labels 
+            (img_name, s3_path, 
+             predicted_boredom, predicted_confusion, predicted_engagement, predicted_frustration,
+             user_boredom, user_confusion, user_engagement, user_frustration,
+             source, is_validated, timestamp)
+            VALUES 
+            (:img_name, :s3_path,
+             :pred_boredom, :pred_confusion, :pred_engagement, :pred_frustration,
+             :user_boredom, :user_confusion, :user_engagement, :user_frustration,
+             'app_sourcing', TRUE, :timestamp)
+        """)
+        
+        with db_engine.connect() as conn:
+            conn.execute(query, {
+                'img_name': img_name,
+                's3_path': s3_key,
+                'pred_boredom': annotation.predicted_boredom,
+                'pred_confusion': annotation.predicted_confusion,
+                'pred_engagement': annotation.predicted_engagement,
+                'pred_frustration': annotation.predicted_frustration,
+                'user_boredom': annotation.user_boredom,
+                'user_confusion': annotation.user_confusion,
+                'user_engagement': annotation.user_engagement,
+                'user_frustration': annotation.user_frustration,
+                'timestamp': datetime.now()
+            })
+            conn.commit()
+        
+        print(f"✅ Insert NeonDB réussi : {img_name}")
+        
+        # 5. Generate public URL (si tu as activé l'accès public)
+        # public_url = f"https://pub-{R2_ACCOUNT_ID}.r2.dev/{s3_key}"
+        # Ou None si pas d'accès public
+        public_url = None
+        
+        return InsertResponse(
+            status="success",
+            message="Image uploaded to R2 and labels saved to NeonDB",
+            img_name=img_name,
+            s3_url=public_url
+        )
+    
+    except SQLAlchemyError as e:
+        print(f"❌ Erreur NeonDB : {e}")
+        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+    
+    except Exception as e:
+        print(f"❌ Erreur insert : {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/load", response_model=LoadResponse)
+async def load_data(limit: int = 10):
+    """
+    Charge les données depuis NeonDB
+    
+    Retourne :
+    - Nombre total d'échantillons
+    - Nombre d'échantillons validés
+    - Dernières prédictions (avec corrections utilisateur)
+    - Statistiques globales
+    """
+    
+    if not db_engine:
+        raise HTTPException(status_code=503, detail="Database not available")
+    
+    try:
+        with db_engine.connect() as conn:
+            # Total samples
+            total = conn.execute(text(
+                "SELECT COUNT(*) FROM emotion_labels"
+            )).scalar()
+            
+            # Validated samples (ceux insérés via /insert)
+            validated = conn.execute(text(
+                "SELECT COUNT(*) FROM emotion_labels WHERE is_validated = TRUE"
+            )).scalar()
+            
+            # Recent predictions
+            recent = conn.execute(text(f"""
+                SELECT 
+                    img_name,
+                    s3_path,
+                    predicted_boredom,
+                    predicted_confusion,
+                    predicted_engagement,
+                    predicted_frustration,
+                    user_boredom,
+                    user_confusion,
+                    user_engagement,
+                    user_frustration,
+                    timestamp
+                FROM emotion_labels
+                WHERE is_validated = TRUE
+                ORDER BY timestamp DESC
+                LIMIT :limit
+            """), {'limit': limit}).fetchall()
+            
+            recent_list = [
+                {
+                    'img_name': row[0],
+                    's3_path': row[1],
+                    'predicted': {
+                        'boredom': float(row[2]),
+                        'confusion': float(row[3]),
+                        'engagement': float(row[4]),
+                        'frustration': float(row[5])
+                    },
+                    'user_corrected': {
+                        'boredom': float(row[6]),
+                        'confusion': float(row[7]),
+                        'engagement': float(row[8]),
+                        'frustration': float(row[9])
+                    },
+                    'timestamp': row[10].isoformat() if row[10] else None
+                }
+                for row in recent
+            ]
+            
+            # Statistics (moyennes)
+            stats = conn.execute(text("""
+                SELECT 
+                    AVG(predicted_boredom) as avg_pred_boredom,
+                    AVG(predicted_confusion) as avg_pred_confusion,
+                    AVG(predicted_engagement) as avg_pred_engagement,
+                    AVG(predicted_frustration) as avg_pred_frustration,
+                    AVG(user_boredom) as avg_user_boredom,
+                    AVG(user_confusion) as avg_user_confusion,
+                    AVG(user_engagement) as avg_user_engagement,
+                    AVG(user_frustration) as avg_user_frustration
+                FROM emotion_labels
+                WHERE is_validated = TRUE
+            """)).fetchone()
+            
+            statistics = {
+                'predictions': {
+                    'boredom': round(float(stats[0] or 0), 2),
+                    'confusion': round(float(stats[1] or 0), 2),
+                    'engagement': round(float(stats[2] or 0), 2),
+                    'frustration': round(float(stats[3] or 0), 2)
+                },
+                'user_corrections': {
+                    'boredom': round(float(stats[4] or 0), 2),
+                    'confusion': round(float(stats[5] or 0), 2),
+                    'engagement': round(float(stats[6] or 0), 2),
+                    'frustration': round(float(stats[7] or 0), 2)
+                }
+            }
+        
+        return LoadResponse(
+            total_samples=total or 0,
+            validated_samples=validated or 0,
+            recent_predictions=recent_list,
+            statistics=statistics
+        )
+    
+    except SQLAlchemyError as e:
+        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+
 
 if __name__ == "__main__":
     import uvicorn