Update app.py

app.py

@@ -9,40 +9,11 @@ from PIL import Image
 import torch
 import requests
 from io import BytesIO
-import requests
-
-@app.post("/classify")
-async def classify_fashion(image_data: dict):
-    try:
-        image_url = image_data.get("imageUrl")
-        if not image_url:
-            raise HTTPException(status_code=400, detail="imageUrl is required")
-        
-        # Télécharger l'image
-        response = requests.get(image_url, timeout=30)
-        response.raise_for_status()
-        
-        # Envoyer directement à l'API Marqo
-        files = {'file': ('image.jpg', response.content, 'image/jpeg')}
-        marqo_response = requests.post(
-            "https://marqo-marqo-fashionsiglip-classification.hf.space/predict",
-            files=files,
-            data={'url': ''}
-        )
-        
-        if marqo_response.status_code == 200:
-            result = marqo_response.json()
-            return format_marqo_response(result)
-        else:
-            raise HTTPException(status_code=500, detail="Marqo API error")
-            
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Classification error: {str(e)}")
-import tempfile
 
-app = FastAPI(title="Fashion Classification API - Marqo")
+# ==================== CRÉATION DE L'APP EN PREMIER ====================
+app = FastAPI(title="Fashion Classification API")
 
-# Middleware CORS
+# ==================== MIDDLEWARE EN SECOND ====================
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -52,190 +23,91 @@ app.add_middleware(
     expose_headers=["*"]
 )
 
-# Client Gradio pour Marqo
-marqo_client = None
+# ==================== CONFIGURATION DU MODÈLE ====================
+print("🔄 Chargement du modèle Fashion CLIP...")
+model = None
+processor = None
 
-@app.on_event("startup")
-async def startup_event():
-    global marqo_client
+def load_model():
+    global model, processor
     try:
-        print("🔄 Connexion à Marqo FashionSigLIP...")
-        marqo_client = Client("Marqo/Marqo-FashionSigLIP-Classification")
-        print("✅ Connecté à Marqo FashionSigLIP avec succès!")
+        model_name = "patrickjohncyh/fashion-clip"
+        model = CLIPModel.from_pretrained(model_name)
+        processor = CLIPProcessor.from_pretrained(model_name)
+        print("✅ Modèle chargé avec succès!")
     except Exception as e:
-        print(f"❌ Erreur de connexion à Marqo: {e}")
-        marqo_client = None
+        print(f"❌ Erreur de chargement: {e}")
 
+# ==================== CATÉGORIES ====================
+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"]
+}
+
+# ==================== ROUTES ====================
 @app.get("/")
 def read_root():
-    return {"message": "Marqo Fashion Classification API is running!", "status": "OK"}
+    return {"message": "Fashion Classification API is running!", "status": "OK"}
 
 @app.get("/health")
 def health_check():
     return {
-        "marqo_connected": marqo_client is not None,
-        "status": "ready" if marqo_client else "disconnected"
+        "model_loaded": model is not None,
+        "status": "ready" if model else "loading"
     }
 
 @app.post("/classify")
 async def classify_fashion(image_data: dict):
     """
-    Endpoint pour Lovable - utilise Marqo FashionSigLIP
+    Endpoint pour Lovable - accepte une URL d'image
     Format attendu: {"imageUrl": "https://example.com/image.jpg"}
     """
     try:
-        if not marqo_client:
-            raise HTTPException(status_code=503, detail="Marqo client not connected")
+        if not model or not processor:
+            raise HTTPException(status_code=503, detail="Model not loaded yet")
         
-        # 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
+        # Télécharger l'image
         response = requests.get(image_url, timeout=30)
         response.raise_for_status()
         
-        # Sauvegarder temporairement l'image
-        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp_file:
-            tmp_file.write(response.content)
-            tmp_file_path = tmp_file.name
+        # Ouvrir et préparer l'image
+        image = Image.open(BytesIO(response.content)).convert("RGB")
+        image.thumbnail((512, 512))
         
-        try:
-            # Appeler l'API Marqo
-            result = marqo_client.predict(
-                image=handle_file(tmp_file_path),
-                url="",  # Vide car on utilise l'image uploadée
-                api_name="/predict"
-            )
-            
-            # Traiter les résultats de Marqo
-            if result and len(result) >= 2:
-                # result[1] contient les données de classification
-                classification_data = result[1]
-                
-                # Formater la réponse pour Lovable
-                return format_marqo_response(classification_data)
-            else:
-                raise HTTPException(status_code=500, detail="Format de réponse Marqo inattendu")
-                
-        finally:
-            # Nettoyer le fichier temporaire
-            os.unlink(tmp_file_path)
+        # SIMULATION - En attendant de régler les problèmes de modèle
+        # Retournez des données factices pour tester
+        return {
+            "success": True,
+            "category": "haut",
+            "confidence": 0.92,
+            "colorHex": "#FF0000",
+            "originalCategory": "a t-shirt",
+            "method": "modli-api-test"
+        }
         
     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"Classification error: {str(e)}")
 
-def format_marqo_response(marqo_data):
-    """
-    Formate la réponse de Marqo pour Lovable
-    """
-    if not marqo_data or 'label' not in marqo_data:
-        return {
-            "success": False,
-            "category": "autre",
-            "confidence": 0.0,
-            "colorHex": "#000000",
-            "originalCategory": "unknown",
-            "method": "marqo-api"
-        }
-    
-    # Extraire la catégorie principale
-    main_category = marqo_data['label']
-    confidence = 0.0
-    
-    # Extraire la confiance si disponible
-    if 'confidences' in marqo_data and marqo_data['confidences']:
-        for conf in marqo_data['confidences']:
-            if conf['label'] == main_category:
-                confidence = conf['confidence']
-                break
-    
-    # Mapping des catégories Marqo -> Français
-    category_mapping = {
-        "t-shirt": "haut",
-        "shirt": "haut", 
-        "sweater": "haut",
-        "blouse": "haut",
-        "top": "haut",
-        "jeans": "pantalon",
-        "pants": "pantalon",
-        "trousers": "pantalon",
-        "leggings": "pantalon",
-        "dress": "robe",
-        "gown": "robe",
-        "sundress": "robe",
-        "skirt": "jupe",
-        "shorts": "short",
-        "bermuda shorts": "short",
-        "jacket": "veste",
-        "blazer": "veste",
-        "leather jacket": "veste",
-        "coat": "manteau",
-        "winter coat": "manteau",
-        "parka": "manteau",
-        "sneakers": "chaussures",
-        "high heels": "chaussures",
-        "boots": "chaussures",
-        "sandals": "chaussures",
-        "handbag": "sac",
-        "purse": "sac",
-        "backpack": "sac",
-        "hat": "accessoire",
-        "sunglasses": "accessoire",
-        "scarf": "accessoire",
-        "belt": "accessoire"
-    }
-    
-    # Convertir la catégorie
-    french_category = category_mapping.get(main_category.lower(), "autre")
-    
-    return {
-        "success": True,
-        "category": french_category,
-        "confidence": round(confidence, 4),
-        "colorHex": "#000000",
-        "originalCategory": main_category,
-        "method": "marqo-fashion-siglip"
-    }
-
-@app.post("/classify_direct")
-async def classify_direct_file(file: UploadFile = File(...)):
-    """
-    Endpoint alternatif pour upload direct de fichier
-    """
-    try:
-        if not marqo_client:
-            raise HTTPException(status_code=503, detail="Marqo client not connected")
-        
-        # Sauvegarder le fichier temporairement
-        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp_file:
-            content = await file.read()
-            tmp_file.write(content)
-            tmp_file_path = tmp_file.name
-        
-        try:
-            # Appeler Marqo
-            result = marqo_client.predict(
-                image=handle_file(tmp_file_path),
-                url="",
-                api_name="/predict"
-            )
-            
-            if result and len(result) >= 2:
-                classification_data = result[1]
-                return format_marqo_response(classification_data)
-            else:
-                raise HTTPException(status_code=500, detail="Format de réponse inattendu")
-                
-        finally:
-            os.unlink(tmp_file_path)
-            
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Classification error: {str(e)}")
+# ==================== CHARGEMENT AU DÉMARRAGE ====================
+# Charger le modèle au démarrage (commenté pour l'instant)
+# load_model()
 
+# ==================== POINT D'ENTRÉE ====================
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)