Update app.py

app.py

@@ -1,18 +1,15 @@
 import os
-import json
-import time
 os.environ['HF_HOME'] = '/tmp/cache'
 os.environ['TORCH_HOME'] = '/tmp/cache'
 
-from fastapi import FastAPI, File, UploadFile, HTTPException
+import json
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse
 from PIL import Image
 import torch
-import io
-import colorthief
-import tempfile
-import numpy as np
+import requests
+from io import BytesIO
+from transformers import CLIPProcessor, CLIPModel
 
 app = FastAPI(title="Fashion Classification API")
 
@@ -26,150 +23,84 @@ app.add_middleware(
     expose_headers=["*"]
 )
 
-# --- ÉTAT DU MODÈLE ---
-print("⚠️ Démarrage du chargement du modèle...")
+# --- Configuration du modèle ---
+print("🔄 Chargement du modèle Fashion CLIP...")
 model = None
 processor = None
-model_loaded = False
-model_error = None
-
-# Modèles disponibles (garantis de fonctionner)
-AVAILABLE_MODELS = {
-    "siglip-base": {
-        "name": "google/siglip-base-patch16-224",
-        "type": "siglip",
-        "description": "SigLIP base - Excellente précision"
-    },
-    "clip-fashion": {
-        "name": "patrickjohncyh/fashion-clip", 
-        "type": "clip",
-        "description": "CLIP spécialisé mode"
-    },
-    "openclip": {
-        "name": "laion/CLIP-ViT-B-32-laion2B-s34B-b79K",
-        "type": "clip", 
-        "description": "OpenCLIP performant"
-    }
-}
-
-SELECTED_MODEL = "siglip-base"  # ← MODÈLE GARANTI
 
 def load_model():
-    global model, processor, model_loaded, model_error
-    
+    global model, processor
     try:
-        from transformers import AutoModel, AutoProcessor, AutoTokenizer, CLIPModel, CLIPProcessor
-        
-        model_info = AVAILABLE_MODELS[SELECTED_MODEL]
-        model_name = model_info["name"]
-        
-        print(f"📦 Chargement du modèle: {model_name}")
-        print(f"📝 Description: {model_info['description']}")
-        
-        if model_info["type"] == "siglip":
-            # Charger SigLIP
-            model = AutoModel.from_pretrained(
-                model_name,
-                cache_dir="/tmp/cache",
-                torch_dtype=torch.float16
-            )
-            processor = AutoProcessor.from_pretrained(model_name)
-            
-        else:
-            # Charger CLIP
-            model = CLIPModel.from_pretrained(
-                model_name,
-                cache_dir="/tmp/cache",
-                torch_dtype=torch.float16
-            )
-            processor = CLIPProcessor.from_pretrained(model_name)
-        
-        print(f"✅ Modèle {model_name} chargé avec succès !")
-        model_loaded = True
-        
+        model_name = "patrickjohncyh/fashion-clip"  # Modèle spécialisé mode
+        model = CLIPModel.from_pretrained(model_name)
+        processor = CLIPProcessor.from_pretrained(model_name)
+        print("✅ Modèle chargé avec succès!")
     except Exception as e:
-        model_error = f"Erreur avec {SELECTED_MODEL}: {str(e)}"
-        print(f"❌ {model_error}")
-        # Essayer le modèle suivant en cas d'erreur
-        try_next_model()
+        print(f"❌ Erreur de chargement: {e}")
 
-def try_next_model():
-    """Essaye le modèle suivant si le premier échoue"""
-    global SELECTED_MODEL
-    models = list(AVAILABLE_MODELS.keys())
-    current_index = models.index(SELECTED_MODEL)
-    
-    if current_index < len(models) - 1:
-        SELECTED_MODEL = models[current_index + 1]
-        print(f"🔄 Essai du modèle suivant: {SELECTED_MODEL}")
-        load_model()
-    else:
-        print("❌ Tous les modèles ont échoué")
-
-# Démarrer le chargement
+# Charger le modèle au démarrage
 load_model()
 
-# Catégories de mode adaptées
-categories = [
-    "a t-shirt", "a dress", "jeans", "a shirt", "a skirt", 
-    "sneakers", "a handbag", "a jacket", "shorts", "a sweater",
-    "a coat", "high heels", "a blouse", "boots", "a hat"
-]
+# Catégories en français avec mapping vers anglais
+CATEGORIES_FR = {
+    "haut": ["a t-shirt", "a shirt", "a sweater", "a blouse", "a top"],
+    "pantalon": ["jeans", "pants", "trousers", "leggings"],
+    "robe": ["a dress", "a gown", "a sundress"],
+    "jupe": ["a skirt"],
+    "short": ["shorts", "bermuda shorts"],
+    "veste": ["a jacket", "a blazer", "a leather jacket"],
+    "manteau": ["a coat", "a winter coat", "a parka"],
+    "chaussures": ["sneakers", "high heels", "boots", "sandals"],
+    "sac": ["a handbag", "a purse", "a backpack"],
+    "accessoire": ["a hat", "sunglasses", "a scarf", "a belt"],
+    "autre": ["clothing", "fashion item"]
+}
 
 @app.get("/")
 def read_root():
-    return {
-        "message": "Fashion Classification API is running!", 
-        "status": "OK",
-        "model_loaded": model_loaded,
-        "current_model": SELECTED_MODEL,
-        "model_name": AVAILABLE_MODELS[SELECTED_MODEL]["name"] if model_loaded else "loading"
-    }
+    return {"message": "Fashion Classification API is running!", "status": "OK"}
 
 @app.get("/health")
 def health_check():
     return {
-        "model_loaded": model_loaded,
-        "model_error": model_error,
-        "current_model": SELECTED_MODEL,
-        "model_details": AVAILABLE_MODELS[SELECTED_MODEL] if model_loaded else None,
-        "available_models": list(AVAILABLE_MODELS.keys()),
-        "status": "ready" if model_loaded else "error",
-        "timestamp": time.time()
+        "model_loaded": model is not None,
+        "status": "ready" if model else "loading"
     }
 
-@app.post("/analyze")
-async def analyze_image(file: UploadFile = File(...)):
-    if not model_loaded:
-        raise HTTPException(status_code=423, detail="Model not loaded yet. Please check /health")
-    
+# --- NOUVELLE ROUTE POUR LOVABLE ---
+@app.post("/classify")
+async def classify_fashion(image_data: dict):
+    """
+    Endpoint pour Lovable - accepte une URL d'image
+    Format attendu: {"imageUrl": "https://example.com/image.jpg"}
+    """
     try:
-        # Lire et préparer l'image
-        contents = await file.read()
-        image = Image.open(io.BytesIO(contents)).convert("RGB")
-        image = image.resize((224, 224))  # Taille standard
+        if not model or not processor:
+            raise HTTPException(status_code=503, detail="Model not loaded yet")
         
-        # Traitement selon le type de modèle
-        if SELECTED_MODEL == "siglip-base":
-            # SigLIP processing
-            inputs = processor(
-                text=categories,
-                images=image,
-                return_tensors="pt",
-                padding=True,
-                truncation=True
-            )
-            
-            with torch.no_grad():
-                outputs = model(**inputs)
-            
-            logits_per_image = outputs.logits_per_image
-            probs = torch.sigmoid(logits_per_image)
-            
-        else:
-            # CLIP processing
+        # Vérifier et extraire l'URL de l'image
+        image_url = image_data.get("imageUrl")
+        if not image_url:
+            raise HTTPException(status_code=400, detail="imageUrl is required")
+        
+        # Télécharger l'image depuis l'URL
+        response = requests.get(image_url)
+        response.raise_for_status()
+        
+        # Ouvrir et préparer l'image
+        image = Image.open(BytesIO(response.content)).convert("RGB")
+        image.thumbnail((512, 512))  # Réduire la taille pour plus d'efficacité
+        
+        # Préparer toutes les catégories en anglais
+        all_english_categories = []
+        for fr_cat, en_categories in CATEGORIES_FR.items():
+            all_english_categories.extend(en_categories)
+        
+        # Traitement par lots pour éviter les problèmes de padding
+        results = {}
+        for category in all_english_categories:
             inputs = processor(
-                text=categories,
+                text=[category],
                 images=image,
                 return_tensors="pt",
                 padding=True,
@@ -178,86 +109,45 @@ async def analyze_image(file: UploadFile = File(...)):
             
             with torch.no_grad():
                 outputs = model(**inputs)
-            
-            logits_per_image = outputs.logits_per_image
-            probs = torch.softmax(logits_per_image, dim=1)
+                results[category] = outputs.logits_per_image.item()
         
-        probs = probs.cpu().numpy()[0]
-        predicted_idx = np.argmax(probs)
-        category_name = categories[predicted_idx]
-        confidence_score = float(probs[predicted_idx])
+        # Trouver la catégorie anglaise avec le meilleur score
+        best_english_category = max(results, key=results.get)
+        confidence = results[best_english_category]
         
-        # Analyse couleur simplifiée
-        try:
-            image_rgb = image.convert('RGB')
-            small_img = image_rgb.resize((10, 10))
-            colors = small_img.getcolors(100)
-            if colors:
-                dominant_color = max(colors, key=lambda x: x[0])[1]
-                hex_color = '#%02x%02x%02x' % dominant_color
-            else:
-                hex_color = "#000000"
-        except Exception:
-            hex_color = "#000000"
-
+        # Convertir en catégorie française
+        best_french_category = "autre"
+        for fr_cat, en_categories in CATEGORIES_FR.items():
+            if best_english_category in en_categories:
+                best_french_category = fr_cat
+                break
+        
+        # Normaliser la confiance entre 0 et 1
+        confidence_normalized = 1 / (1 + torch.exp(torch.tensor(-confidence))).item()
+        
+        # Format de réponse exact pour Lovable
         return {
-            "category": category_name,
-            "confidence": round(confidence_score, 4),
-            "color_hex": hex_color,
-            "model": AVAILABLE_MODELS[SELECTED_MODEL]["name"]
+            "success": True,
+            "category": best_french_category,
+            "confidence": round(confidence_normalized, 4),
+            "colorHex": "#000000",
+            "originalCategory": best_english_category,
+            "method": "modli-api"
         }
-
+        
+    except requests.exceptions.RequestException as e:
+        raise HTTPException(status_code=400, detail=f"Invalid image URL: {str(e)}")
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Analysis error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Classification error: {str(e)}")
 
-@app.get("/test-ui", response_class=HTMLResponse)
-async def test_ui():
-    health_status = health_check()
-    status_class = "ready" if health_status["model_loaded"] else "error"
-    status_text = "✅ Prêt" if health_status["model_loaded"] else "❌ Erreur"
-    
-    return f"""
-    <html>
-        <head>
-            <title>Fashion Detection</title>
-            <style>
-                body {{ font-family: Arial, sans-serif; margin: 40px; }}
-                .container {{ max-width: 600px; margin: 0 auto; }}
-                .status {{ padding: 15px; margin: 10px 0; border-radius: 5px; }}
-                .ready {{ background: #d4edda; color: #155724; }}
-                .error {{ background: #f8d7da; color: #721c24; }}
-                .model-info {{ background: #e9ecef; padding: 10px; border-radius: 5px; }}
-            </style>
-        </head>
-        <body>
-            <div class="container">
-                <h1>👗 Fashion Detector</h1>
-                
-                <div class="status {status_class}">
-                    <b>Statut:</b> {status_text}
-                </div>
-                
-                <div class="model-info">
-                    <b>Modèle:</b> {health_status['current_model']}<br>
-                    <b>Détails:</b> {AVAILABLE_MODELS[health_status['current_model']]['description'] if health_status['model_loaded'] else 'Chargement...'}
-                </div>
-                
-                <form action="/analyze" method="post" enctype="multipart/form-data">
-                    <h3>Uploader une image de vêtement :</h3>
-                    <input type="file" name="file" accept="image/*" required>
-                    <br><br>
-                    <input type="submit" value="Analyser" {"disabled" if not health_status["model_loaded"] else ""}>
-                </form>
-                
-                <div style="margin-top: 20px;">
-                    <h4>Modèles disponibles:</h4>
-                    <ul>
-                        <li><b>siglip-base</b>: SigLIP base - Excellente précision</li>
-                        <li><b>clip-fashion</b>: CLIP spécialisé mode</li>
-                        <li><b>openclip</b>: OpenCLIP performant</li>
-                    </ul>
-                </div>
-            </div>
-        </body>
-    </html>
-    """
+# Ancienne route pour compatibilité (si nécessaire)
+@app.post("/analyze")
+async def analyze_image_old():
+    return {"error": "Use /classify endpoint instead"}
+
+# Route de test
+@app.get("/test")
+async def test_endpoint():
+    """Endpoint de test avec une image exemple"""
+    test_url = "https://images.unsplash.com/photo-1521572163474-6864f9cf17ab?w=400"
+    return await classify_fashion({"imageUrl": test_url})