more fixes

app.py

@@ -7,8 +7,10 @@ import gradio as gr
 import numpy as np
 import requests
 import torch
-from fastapi import FastAPI, Header, HTTPException
+from fastapi import FastAPI, Header, HTTPException, UploadFile, File, Form
+from fastapi.responses import JSONResponse
 from pydantic import BaseModel
+from typing import List as TypingList
 from PIL import Image
 from starlette.staticfiles import StaticFiles
 import threading
@@ -226,6 +228,7 @@ class Item(BaseModel):
     embedding: Optional[List[float]] = None
     category: Optional[str] = None
     image_url: Optional[str] = None
+    image_base64: Optional[str] = None  # Base64 encoded image
 
 
 class ComposeRequest(BaseModel):
@@ -356,6 +359,138 @@ def get_image_formats() -> dict:
         "note": "Images are automatically converted to RGB mode for model processing"
     }
 
+@app.post("/compose/upload")
+async def compose_with_upload(
+    files: TypingList[UploadFile] = File(...),
+    occasion: str = Form("casual"),
+    weather: str = Form("any"),
+    style: str = Form("casual"),
+    num_outfits: int = Form(5),
+    color_preference: Optional[str] = Form(None),
+    fit_preference: Optional[str] = Form(None),
+    material_preference: Optional[str] = Form(None),
+    season: Optional[str] = Form(None),
+    time_of_day: Optional[str] = Form(None),
+    budget: Optional[str] = Form(None),
+    personal_style: Optional[str] = Form(None),
+    x_api_key: Optional[str] = Header(None)
+) -> dict:
+    """
+    Generate outfit recommendations from uploaded image files.
+    
+    This endpoint accepts multipart/form-data with:
+    - files: Image files (JPG, PNG, WEBP, GIF, BMP, TIFF, etc.)
+    - All tag parameters as form fields
+    
+    Returns personalized outfit recommendations.
+    """
+    require_api_key(x_api_key)
+    
+    if not files or len(files) < 2:
+        raise HTTPException(status_code=400, detail="At least 2 images required for outfit recommendations")
+    
+    # Load images from uploaded files
+    items = []
+    errors = []
+    
+    for i, file in enumerate(files):
+        try:
+            # Read file content
+            contents = await file.read()
+            
+            # Load image from bytes
+            img = load_image_from_bytes(contents, convert_to_rgb=True, raise_on_error=False)
+            if img is None:
+                errors.append(f"Failed to load image from file {file.filename}")
+                continue
+            
+            items.append({
+                "id": f"item_{i}",
+                "image": img,
+                "category": None  # Will be auto-detected
+            })
+        except Exception as e:
+            errors.append(f"Error processing file {file.filename}: {str(e)}")
+    
+    if len(items) < 2:
+        error_msg = f"Not enough valid images. Need at least 2, got {len(items)}."
+        if errors:
+            error_msg += f" Errors: {', '.join(errors[:3])}"
+        raise HTTPException(status_code=400, detail=error_msg)
+    
+    # Build context
+    context = {
+        "occasion": occasion,
+        "weather": weather,
+        "style": style,
+        "outfit_style": style,
+        "num_outfits": num_outfits
+    }
+    
+    # Add optional tags
+    if color_preference and color_preference != "None":
+        context["color_preference"] = color_preference
+    if fit_preference and fit_preference != "None":
+        context["fit_preference"] = fit_preference
+    if material_preference and material_preference != "None":
+        context["material_preference"] = material_preference
+    if season and season != "None":
+        context["season"] = season
+    if time_of_day and time_of_day != "None":
+        context["time_of_day"] = time_of_day
+    if budget and budget != "None":
+        context["budget"] = budget
+    if personal_style and personal_style != "None":
+        context["personal_style"] = personal_style
+    
+    # Validate tags
+    is_valid, tag_errors = validate_tags(context)
+    if not is_valid:
+        return JSONResponse(
+            status_code=400,
+            content={
+                "error": "Invalid tags provided",
+                "errors": tag_errors,
+                "valid_tag_options": get_all_tag_options()
+            }
+        )
+    
+    # Generate recommendations
+    try:
+        outfits = service.compose_outfits(items, context=context)
+        
+        # Check for errors
+        if outfits and isinstance(outfits, list) and len(outfits) > 0:
+            if isinstance(outfits[0], dict) and "error" in outfits[0]:
+                return JSONResponse(
+                    status_code=500,
+                    content={
+                        "error": "Recommendation generation failed",
+                        "details": outfits[0].get("details", []),
+                        "message": outfits[0].get("message", "Unknown error")
+                    }
+                )
+        
+        return {
+            "outfits": outfits,
+            "version": service.vit_version,
+            "tags_processed": True,
+            "context_used": context,
+            "items_processed": len(items),
+            "warnings": errors if errors else None
+        }
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return JSONResponse(
+            status_code=500,
+            content={
+                "error": "Internal server error",
+                "message": str(e),
+                "model_status": service.get_model_status()
+            }
+        )
+
 @app.post("/tags/validate")
 def validate_request_tags(tags: Dict[str, Any], x_api_key: Optional[str] = Header(None)) -> dict:
     """
@@ -465,19 +600,58 @@ def compose(req: ComposeRequest, x_api_key: Optional[str] = Header(None)) -> dic
     
     Supports both legacy context dict format and new tag-based format.
     Tags are processed and prioritized automatically.
+    
+    Items can provide:
+    - image_url: URL to image (will be downloaded)
+    - image_base64: Base64 encoded image
+    - embedding: Pre-computed embedding (skips ResNet)
+    - category: Item category (optional, auto-detected if not provided)
     """
     require_api_key(x_api_key)
     
-    # Build items
-    items = [
-        {
+    # Build items with image loading
+    items = []
+    errors = []
+    
+    for it in req.items:
+        item_dict = {
             "id": it.id,
             "embedding": np.array(it.embedding, dtype=np.float32) if it.embedding is not None else None,
             "category": it.category,
-            "image_url": it.image_url,
         }
-        for it in req.items
-    ]
+        
+        # Load image from URL if provided
+        if it.image_url:
+            img = load_image_from_url(it.image_url, timeout=20, convert_to_rgb=True, raise_on_error=False)
+            if img is not None:
+                item_dict["image"] = img
+            else:
+                errors.append(f"Failed to load image from URL for item {it.id}: {it.image_url}")
+        
+        # Load image from base64 if provided
+        elif it.image_base64:
+            try:
+                image_bytes = base64.b64decode(it.image_base64)
+                img = load_image_from_bytes(image_bytes, convert_to_rgb=True, raise_on_error=False)
+                if img is not None:
+                    item_dict["image"] = img
+                else:
+                    errors.append(f"Failed to load image from base64 for item {it.id}")
+            except Exception as e:
+                errors.append(f"Error decoding base64 image for item {it.id}: {str(e)}")
+        
+        # If no image and no embedding, skip this item
+        if item_dict.get("image") is None and item_dict.get("embedding") is None:
+            errors.append(f"Item {it.id} has no image or embedding - skipping")
+            continue
+        
+        items.append(item_dict)
+    
+    if not items:
+        error_msg = "No valid items provided. All items failed to load or have no images/embeddings."
+        if errors:
+            error_msg += f" Errors: {', '.join(errors[:5])}"
+        raise HTTPException(status_code=400, detail=error_msg)
     
     # Build context from request
     context = req.context or {}
@@ -513,23 +687,52 @@ def compose(req: ComposeRequest, x_api_key: Optional[str] = Header(None)) -> dic
             context[tag_name] = tag_value
     
     # Validate tags
-    is_valid, errors = validate_tags(context)
+    is_valid, tag_errors = validate_tags(context)
     if not is_valid:
-        return {
-            "error": "Invalid tags provided",
-            "errors": errors,
-            "valid_tag_options": get_all_tag_options()
-        }
+        return JSONResponse(
+            status_code=400,
+            content={
+                "error": "Invalid tags provided",
+                "errors": tag_errors,
+                "valid_tag_options": get_all_tag_options()
+            }
+        )
     
     # Generate recommendations
-    outfits = service.compose_outfits(items, context=context)
-    
-    return {
-        "outfits": outfits,
-        "version": service.vit_version,
-        "tags_processed": True,
-        "context_used": context
-    }
+    try:
+        outfits = service.compose_outfits(items, context=context)
+        
+        # Check if compose_outfits returned an error
+        if outfits and isinstance(outfits, list) and len(outfits) > 0:
+            if isinstance(outfits[0], dict) and "error" in outfits[0]:
+                return JSONResponse(
+                    status_code=500,
+                    content={
+                        "error": "Recommendation generation failed",
+                        "details": outfits[0].get("details", []),
+                        "message": outfits[0].get("message", "Unknown error")
+                    }
+                )
+        
+        return {
+            "outfits": outfits,
+            "version": service.vit_version,
+            "tags_processed": True,
+            "context_used": context,
+            "items_processed": len(items),
+            "warnings": errors if errors else None
+        }
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return JSONResponse(
+            status_code=500,
+            content={
+                "error": "Internal server error during recommendation generation",
+                "message": str(e),
+                "model_status": service.get_model_status()
+            }
+        )
 
 
 @app.get("/artifacts")