some fixes

GRADIO_API_CLIENT_GUIDE.md

@@ -0,0 +1,355 @@
+# Gradio API Client Usage Guide
+
+## Problem: File Type Validation Error
+
+When using the Gradio Client API, you may encounter:
+```
+gradio.exceptions.Error: "Invalid file type. Please upload a file that is one of these formats: ['.jpg', '.jpeg', '.png', ...]"
+```
+
+## Solution
+
+The file type restriction has been removed from the Gradio interface to allow API client flexibility. File validation is now handled by our internal image loading utilities.
+
+## Using Gradio Client API
+
+### Method 1: Using File Paths (Recommended)
+
+```python
+import gradio_client as grc
+
+# Connect to your Gradio server
+client = grc.Client("http://your-server:7860")
+
+# Prepare file paths (must be accessible from the server)
+file_paths = [
+    "/path/to/image1.jpg",
+    "/path/to/image2.png",
+    "/path/to/image3.webp"
+]
+
+# Call the API
+result = client.predict(
+    files=file_paths,
+    occasion="casual",
+    weather="warm",
+    num_outfits=3,
+    outfit_style="casual",
+    color_preference=None,
+    fit_preference=None,
+    material_preference=None,
+    season=None,
+    time_of_day=None,
+    budget=None,
+    personal_style=None,
+    api_name="/gradio_recommend"
+)
+
+# Result contains:
+# - result[0]: List of stitched outfit images (PIL Images)
+# - result[1]: JSON dict with outfit details
+images, json_data = result
+```
+
+### Method 2: Using Temporary Files
+
+If you have image data in memory, save to temporary files first:
+
+```python
+import gradio_client as grc
+import tempfile
+from PIL import Image
+import os
+
+# Connect to server
+client = grc.Client("http://your-server:7860")
+
+# Your image data (e.g., from requests, base64, etc.)
+image_data_list = [...]  # Your image bytes or PIL Images
+
+# Save to temporary files
+temp_files = []
+for i, img_data in enumerate(image_data_list):
+    if isinstance(img_data, bytes):
+        # If bytes, save directly
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.jpg')
+        temp_file.write(img_data)
+        temp_file.close()
+        temp_files.append(temp_file.name)
+    elif isinstance(img_data, Image.Image):
+        # If PIL Image, save to temp file
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
+        img_data.save(temp_file.name)
+        temp_file.close()
+        temp_files.append(temp_file.name)
+    else:
+        # Assume it's a file path
+        temp_files.append(img_data)
+
+# Call API
+result = client.predict(
+    files=temp_files,
+    occasion="formal",
+    weather="cool",
+    num_outfits=5,
+    outfit_style="formal",
+    api_name="/gradio_recommend"
+)
+
+# Clean up temp files
+for temp_file in temp_files:
+    if os.path.exists(temp_file):
+        os.unlink(temp_file)
+```
+
+### Method 3: Using Base64 (Convert to Files)
+
+```python
+import gradio_client as grc
+import base64
+import tempfile
+from io import BytesIO
+from PIL import Image
+
+def base64_to_temp_file(base64_string, suffix='.jpg'):
+    """Convert base64 string to temporary file"""
+    image_data = base64.b64decode(base64_string)
+    img = Image.open(BytesIO(image_data))
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
+    img.save(temp_file.name)
+    temp_file.close()
+    return temp_file.name
+
+# Your base64 image strings
+base64_images = [
+    "iVBORw0KGgoAAAANSUhEUgAA...",  # Base64 encoded image 1
+    "iVBORw0KGgoAAAANSUhEUgAA...",  # Base64 encoded image 2
+]
+
+# Convert to temp files
+file_paths = [base64_to_temp_file(img) for img in base64_images]
+
+# Use with Gradio client
+client = grc.Client("http://your-server:7860")
+result = client.predict(
+    files=file_paths,
+    occasion="casual",
+    weather="warm",
+    num_outfits=3,
+    api_name="/gradio_recommend"
+)
+```
+
+## Alternative: Use FastAPI Endpoints Instead
+
+For better API integration, consider using the FastAPI endpoints directly:
+
+### Option 1: `/compose/upload` (Multipart Form-Data)
+
+```python
+import requests
+
+url = "http://your-server:8000/compose/upload"
+
+# Prepare files
+files = [
+    ('files', ('image1.jpg', open('image1.jpg', 'rb'), 'image/jpeg')),
+    ('files', ('image2.png', open('image2.png', 'rb'), 'image/png')),
+]
+
+# Prepare form data
+data = {
+    'occasion': 'casual',
+    'weather': 'warm',
+    'style': 'casual',
+    'num_outfits': 3,
+    'color_preference': None,
+    # ... other optional tags
+}
+
+# Make request
+response = requests.post(url, files=files, data=data)
+result = response.json()
+```
+
+### Option 2: `/compose` (JSON with Base64)
+
+```python
+import requests
+import base64
+
+def image_to_base64(image_path):
+    with open(image_path, 'rb') as f:
+        return base64.b64encode(f.read()).decode('utf-8')
+
+url = "http://your-server:8000/compose"
+
+# Prepare items with base64 images
+items = [
+    {
+        "id": "item_0",
+        "image_base64": image_to_base64("image1.jpg"),
+        "category": None  # Auto-detected
+    },
+    {
+        "id": "item_1",
+        "image_base64": image_to_base64("image2.png"),
+        "category": None
+    }
+]
+
+# Prepare request
+payload = {
+    "items": items,
+    "occasion": "casual",
+    "weather": "warm",
+    "style": "casual",
+    "num_outfits": 3,
+    "color_preference": None,
+    # ... other optional tags
+}
+
+# Make request
+response = requests.post(url, json=payload)
+result = response.json()
+```
+
+## Supported Image Formats
+
+The system supports all major image formats:
+- **JPEG/JPG** (`.jpg`, `.jpeg`)
+- **PNG** (`.png`)
+- **WEBP** (`.webp`)
+- **GIF** (`.gif`)
+- **BMP** (`.bmp`)
+- **TIFF** (`.tiff`, `.tif`)
+
+Images are automatically:
+- Validated for format
+- Converted to RGB mode
+- Handled for transparency (PNG/GIF)
+- Processed for model compatibility
+
+## Troubleshooting
+
+### Error: "Could not load images"
+
+**Possible causes:**
+1. Files don't exist at the specified paths
+2. Files are not valid image formats
+3. Files are corrupted
+4. Permission issues accessing files
+
+**Solutions:**
+1. Verify file paths are correct and accessible
+2. Check file extensions match actual format
+3. Try opening files with PIL/Pillow to verify they're valid
+4. Ensure server has read permissions for files
+
+### Error: "No files uploaded"
+
+**Possible causes:**
+1. Empty file list passed
+2. Files parameter not provided correctly
+
+**Solutions:**
+1. Ensure at least 2 files are provided
+2. Check file paths are in a list format: `["file1.jpg", "file2.png"]`
+
+### Error: File type validation (if still occurring)
+
+**Solution:**
+- The file type restriction has been removed. If you still see this error:
+  1. Update to the latest version of the code
+  2. Restart the Gradio server
+  3. Ensure you're not using an old cached version
+
+## Best Practices
+
+1. **Use FastAPI endpoints for production**: More reliable and flexible than Gradio Client API
+2. **Validate images before sending**: Check that files are valid images
+3. **Handle errors gracefully**: Check response for error messages
+4. **Use appropriate image formats**: JPG for photos, PNG for transparency, WEBP for web
+5. **Clean up temp files**: If using temporary files, delete them after use
+
+## Example: Complete Client Script
+
+```python
+import gradio_client as grc
+import os
+
+def recommend_outfits(
+    image_paths: list,
+    occasion: str = "casual",
+    weather: str = "warm",
+    num_outfits: int = 3,
+    outfit_style: str = "casual",
+    **optional_tags
+):
+    """Complete example of using Gradio API for recommendations"""
+    
+    # Validate inputs
+    if not image_paths or len(image_paths) < 2:
+        raise ValueError("At least 2 images required")
+    
+    for path in image_paths:
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Image not found: {path}")
+    
+    # Connect to server
+    client = grc.Client("http://localhost:7860")
+    
+    # Prepare parameters
+    params = {
+        "files": image_paths,
+        "occasion": occasion,
+        "weather": weather,
+        "num_outfits": num_outfits,
+        "outfit_style": outfit_style,
+        **{k: v for k, v in optional_tags.items() if v is not None}
+    }
+    
+    # Make request
+    try:
+        result = client.predict(api_name="/gradio_recommend", **params)
+        images, json_data = result
+        
+        # Check for errors
+        if "error" in json_data:
+            raise RuntimeError(f"API Error: {json_data['error']}")
+        
+        return images, json_data["outfits"]
+    
+    except Exception as e:
+        raise RuntimeError(f"Failed to get recommendations: {str(e)}")
+
+# Usage
+if __name__ == "__main__":
+    images, outfits = recommend_outfits(
+        image_paths=["shirt.jpg", "pants.jpg", "shoes.jpg"],
+        occasion="formal",
+        weather="cool",
+        num_outfits=5,
+        outfit_style="formal",
+        color_preference="neutral",
+        fit_preference="tailored"
+    )
+    
+    print(f"Generated {len(outfits)} outfits")
+    for i, outfit in enumerate(outfits):
+        print(f"Outfit {i+1}: {outfit['item_ids']}")
+```
+
+## API Endpoints Summary
+
+| Endpoint | Method | Use Case |
+|----------|--------|----------|
+| `/compose` | POST | JSON API with base64 images |
+| `/compose/upload` | POST | Multipart form-data with files |
+| `/tags` | GET | Get all available tag options |
+| `/image-formats` | GET | Get supported image formats |
+| `/health` | GET | Check model status |
+| Gradio `/gradio_recommend` | POST | Gradio Client API (file paths) |
+
+For production use, prefer FastAPI endpoints (`/compose` or `/compose/upload`) over Gradio Client API for better reliability and error handling.
+

app.py

@@ -822,9 +822,30 @@ def gradio_recommend(
     # Return stitched outfit images and a JSON with details
     if not files:
         return [], {"error": "No files uploaded"}
-    images = _load_images_from_files(files)
-    if not images:
-        return [], {"error": "Could not load images"}
+    
+    # Debug: Log file information for API troubleshooting
+    file_info = []
+    for f in files:
+        if isinstance(f, str):
+            file_info.append(f"Path: {f}")
+        else:
+            file_info.append(f"Type: {type(f).__name__}, Value: {str(f)[:100]}")
+    
+    try:
+        images = _load_images_from_files(files)
+        if not images:
+            error_msg = "Could not load images from uploaded files.\n\n"
+            error_msg += f"Files received: {len(files)}\n"
+            error_msg += f"File details: {', '.join(file_info[:3])}\n\n"
+            error_msg += f"Supported formats: {', '.join(get_supported_extensions())}\n"
+            error_msg += "Please ensure files are valid image files (JPG, PNG, WEBP, GIF, BMP, TIFF, etc.)"
+            return [], {"error": error_msg, "files_received": len(files), "file_info": file_info[:5]}
+    except Exception as e:
+        error_msg = f"Error processing files: {str(e)}\n\n"
+        error_msg += f"Files received: {len(files)}\n"
+        error_msg += f"File details: {', '.join(file_info[:3])}\n\n"
+        error_msg += "Please check that files are valid image files."
+        return [], {"error": error_msg, "exception": str(e), "files_received": len(files)}
     
     # Build comprehensive context with all tags
     context = {
@@ -1213,8 +1234,9 @@ with gr.Blocks(fill_height=True, title="Dressify - Advanced Outfit Recommendatio
         
         inp2 = gr.Files(
             label="Upload wardrobe images", 
-            file_types=[".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tiff", ".tif"],
             file_count="multiple"
+            # Note: file_types removed to allow API client flexibility
+            # Validation is handled by our image_utils.load_images_from_files()
         )
         
         with gr.Accordion("🎯 Primary Tags (Required)", open=True):
@@ -1601,8 +1623,9 @@ with gr.Blocks(fill_height=True, title="Dressify - Advanced Outfit Recommendatio
     with gr.Tab("📊 Embed (Debug)"):
         inp = gr.Files(
             label="Upload Items (multiple images)",
-            file_types=[".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tiff", ".tif"],
             file_count="multiple"
+            # Note: file_types removed to allow API client flexibility
+            # Validation is handled by our image_utils.load_images_from_files()
         )
         out = gr.Textbox(label="Embeddings (JSON)")
         btn = gr.Button("Compute Embeddings")