Refactor image loading and tag processing logic; enhance validation for color and fit preferences. Remove deprecated Gradio API client guide. Improve code readability and maintainability.

GRADIO_API_CLIENT_GUIDE.md

@@ -1,355 +0,0 @@
-# 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

@@ -840,9 +840,9 @@ def gradio_recommend(
     
     try:
         print(f"🔍 DEBUG: Attempting to load {len(files)} images...")
-        images = _load_images_from_files(files)
+    images = _load_images_from_files(files)
         print(f"🔍 DEBUG: Successfully loaded {len(images)} images from {len(files)} files")
-        if not images:
+    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"
@@ -869,7 +869,7 @@ def gradio_recommend(
         
         value_lower = value.lower().strip()
         
-        # Color preference mappings
+        # Color preference mappings - normalize variations to standard values
         if tag_name == "color_preference":
             color_mappings = {
                 "monochrome": "monochromatic",  # Frontend uses "monochrome", backend uses "monochromatic"
@@ -877,7 +877,14 @@ def gradio_recommend(
                 "single_color": "monochromatic",
                 "one_color": "monochromatic",
             }
-            return color_mappings.get(value_lower, value)  # Return mapped value or original
+            normalized = color_mappings.get(value_lower, value)
+            # Validate against allowed values
+            allowed_colors = ["neutral", "monochromatic", "complementary", "bold", "subtle", 
+                            "bright", "muted", "pastel", "dark", "light", "earth_tones", 
+                            "jewel_tones", "black_white", "navy_white", "colorful", "minimal_color"]
+            if normalized in allowed_colors:
+                return normalized
+            return value  # Return original if not in allowed list
         
         # Fit preference mappings
         if tag_name == "fit_preference":
@@ -887,14 +894,18 @@ def gradio_recommend(
                 "baggy": "loose",
                 "wide": "loose",
             }
-            return fit_mappings.get(value_lower, value)
+            normalized = fit_mappings.get(value_lower, value)
+            # Validate against allowed values
+            allowed_fits = ["fitted", "loose", "oversized", "relaxed", "comfortable", 
+                          "structured", "flowy", "tailored", "athletic_fit", "regular_fit"]
+            if normalized in allowed_fits:
+                return normalized
+            return value
         
-        # Season mappings
+        # Season mappings - both "fall" and "autumn" are valid, keep as-is
         if tag_name == "season":
-            season_mappings = {
-                "autumn": "fall",  # Both are valid, but normalize to "fall"
-            }
-            return season_mappings.get(value_lower, value)
+            # Both "fall" and "autumn" are in the Literal type, so no normalization needed
+            return value
         
         # Return original value if no mapping found
         return value
@@ -1017,7 +1028,7 @@ def start_training_advanced(
         return "❌ Dataset not ready. Please wait for bootstrap to complete."
     
     log_message = "🚀 Advanced training started with custom parameters! Check the log below for progress."
-    def _runner():
+            def _runner():
         nonlocal log_message
         try:
             import subprocess
@@ -1219,13 +1230,13 @@ def start_training_simple(dataset_size: str, res_epochs: int, vit_epochs: int):
     log_message = f"Starting training on {dataset_size} samples..."
     def _runner():
         nonlocal log_message
-        try:
-            import subprocess
-            if not DATASET_ROOT:
+                try:
+                    import subprocess
+                    if not DATASET_ROOT:
                 log_message = "Dataset not ready."
-                return
-            export_dir = os.getenv("EXPORT_DIR", "models/exports")
-            os.makedirs(export_dir, exist_ok=True)
+                        return
+                    export_dir = os.getenv("EXPORT_DIR", "models/exports")
+                    os.makedirs(export_dir, exist_ok=True)
             log_message = f"Training ResNet on {dataset_size} samples...\n"
             # Add dataset size limit if not full
             dataset_args = []
@@ -1274,7 +1285,7 @@ def start_training_simple(dataset_size: str, res_epochs: int, vit_epochs: int):
             else:
                 log_message += f"❌ ViT training failed: {vit_result.stderr}\n"
                 return log_message
-            service.reload_models()
+                    service.reload_models()
             
             # Check if models loaded successfully
             model_status = service.get_model_status()

inference.py

@@ -59,8 +59,8 @@ class InferenceService:
         # Disable gradients
         for m in [self.resnet, self.vit]:
             if m is not None:
-                for p in m.parameters():
-                    p.requires_grad_(False)
+            for p in m.parameters():
+                p.requires_grad_(False)
 
         # Update overall status
         self.models_loaded = self.resnet_loaded and self.vit_loaded
@@ -299,8 +299,8 @@ class InferenceService:
         # Disable gradients
         for m in [self.resnet, self.vit]:
             if m is not None:
-                for p in m.parameters():
-                    p.requires_grad_(False)
+            for p in m.parameters():
+                p.requires_grad_(False)
         
         # Update overall status
         self.models_loaded = self.resnet_loaded and self.vit_loaded
@@ -347,11 +347,11 @@ class InferenceService:
             
         try:
             batch = torch.stack([self.transform(img) for img in processed_images])
-            batch = batch.to(self.device, memory_format=torch.channels_last)
-            use_amp = (self.device == "cuda")
-            with torch.autocast(device_type=("cuda" if use_amp else "cpu"), enabled=use_amp):
-                emb = self.resnet(batch)
-            emb = nn.functional.normalize(emb, dim=-1)
+        batch = batch.to(self.device, memory_format=torch.channels_last)
+        use_amp = (self.device == "cuda")
+        with torch.autocast(device_type=("cuda" if use_amp else "cpu"), enabled=use_amp):
+            emb = self.resnet(batch)
+        emb = nn.functional.normalize(emb, dim=-1)
             result = [e.detach().cpu().numpy().astype(np.float32) for e in emb]
             print(f"🔍 DEBUG: Successfully generated {len(result)} embeddings")
             return result
@@ -518,7 +518,8 @@ class InferenceService:
         # Extract primary tags (backward compatible)
         occasion = context.get("occasion", processed_tags["primary_tags"].get("occasion", "casual"))
         weather = context.get("weather", processed_tags["primary_tags"].get("weather", "any"))
-        outfit_style = context.get("outfit_style", context.get("style", processed_tags["primary_tags"].get("style", "casual")))
+        # Support both "outfit_style" and "style" for backward compatibility
+        outfit_style = context.get("outfit_style") or context.get("style") or processed_tags["primary_tags"].get("outfit_style") or processed_tags["primary_tags"].get("style", "casual")
         
         # Select base template
         template_name = outfit_style

utils/tag_system.py

@@ -10,7 +10,7 @@ from enum import Enum
 
 
 class OccasionTag(str, Enum):
-    """Expanded occasion tags for different events and contexts"""
+    """Occasion tags matching API Literal types"""
     CASUAL = "casual"
     BUSINESS = "business"
     FORMAL = "formal"
@@ -25,29 +25,17 @@ class OccasionTag(str, Enum):
     TRAVEL = "travel"
     BEACH = "beach"
     OUTDOOR = "outdoor"
-    INDOOR = "indoor"
     NIGHT_OUT = "night_out"
     BRUNCH = "brunch"
-    SHOPPING = "shopping"
-    CULTURAL = "cultural"
-    RELIGIOUS = "religious"
-    FESTIVAL = "festival"
-    CONCERT = "concert"
-    THEATER = "theater"
-    MUSEUM = "museum"
     DINNER = "dinner"
-    LUNCH = "lunch"
     MEETING = "meeting"
-    PRESENTATION = "presentation"
     INTERVIEW = "interview"
-    GRADUATION = "graduation"
-    PROM = "prom"
-    GALA = "gala"
-    AWARD_CEREMONY = "award_ceremony"
+    CULTURAL = "cultural"
+    TRADITIONAL = "traditional"
 
 
 class WeatherTag(str, Enum):
-    """Expanded weather tags for climate-appropriate recommendations"""
+    """Weather tags matching API Literal types"""
     ANY = "any"
     HOT = "hot"
     WARM = "warm"
@@ -59,16 +47,12 @@ class WeatherTag(str, Enum):
     SNOW = "snow"
     WINDY = "windy"
     HUMID = "humid"
-    DRY = "dry"
     SUNNY = "sunny"
     CLOUDY = "cloudy"
-    OVERCAST = "overcast"
-    STORMY = "stormy"
-    FOGGY = "foggy"
 
 
 class StyleTag(str, Enum):
-    """Expanded style tags for different fashion aesthetics"""
+    """Style tags matching API Literal types (outfit_style)"""
     CASUAL = "casual"
     SMART_CASUAL = "smart_casual"
     FORMAL = "formal"
@@ -76,39 +60,19 @@ class StyleTag(str, Enum):
     ATHLETIC = "athletic"
     STREETWEAR = "streetwear"
     MINIMALIST = "minimalist"
-    BOHEMIAN = "bohemian"
-    VINTAGE = "vintage"
     CLASSIC = "classic"
     MODERN = "modern"
-    EDGY = "edgy"
     ELEGANT = "elegant"
     SOPHISTICATED = "sophisticated"
-    CHIC = "chic"
-    GLAMOROUS = "glamorous"
-    ROMANTIC = "romantic"
-    PREPPY = "preppy"
-    GRUNGE = "grunge"
-    PUNK = "punk"
-    GOTH = "goth"
     TRADITIONAL = "traditional"
     ETHNIC = "ethnic"
-    CULTURAL = "cultural"
-    WESTERN = "western"
-    EASTERN = "eastern"
-    CONTEMPORARY = "contemporary"
-    AVANT_GARDE = "avant_garde"
-    ARTSY = "artsy"
-    COMFORTABLE = "comfortable"
-    PRACTICAL = "practical"
 
 
 class ColorPreferenceTag(str, Enum):
-    """Color preference tags for personalized color schemes"""
+    """Color preference tags matching API Literal types"""
     NEUTRAL = "neutral"
     MONOCHROMATIC = "monochromatic"
     COMPLEMENTARY = "complementary"
-    ANALOGOUS = "analogous"
-    TRIADIC = "triadic"
     BOLD = "bold"
     SUBTLE = "subtle"
     BRIGHT = "bright"
@@ -118,33 +82,28 @@ class ColorPreferenceTag(str, Enum):
     LIGHT = "light"
     EARTH_TONES = "earth_tones"
     JEWEL_TONES = "jewel_tones"
-    PRIMARY_COLORS = "primary_colors"
     BLACK_WHITE = "black_white"
     NAVY_WHITE = "navy_white"
-    BROWN_BEIGE = "brown_beige"
     COLORFUL = "colorful"
     MINIMAL_COLOR = "minimal_color"
 
 
 class FitPreferenceTag(str, Enum):
-    """Fit preference tags for body type and comfort"""
+    """Fit preference tags matching API Literal types"""
     FITTED = "fitted"
     LOOSE = "loose"
     OVERSIZED = "oversized"
-    SKINNY = "skinny"
     RELAXED = "relaxed"
-    TIGHT = "tight"
     COMFORTABLE = "comfortable"
     STRUCTURED = "structured"
     FLOWY = "flowy"
     TAILORED = "tailored"
-    BAGGY = "baggy"
     ATHLETIC_FIT = "athletic_fit"
     REGULAR_FIT = "regular_fit"
 
 
 class MaterialPreferenceTag(str, Enum):
-    """Material preference tags for fabric choices"""
+    """Material preference tags matching API Literal types"""
     COTTON = "cotton"
     LINEN = "linen"
     SILK = "silk"
@@ -152,30 +111,20 @@ class MaterialPreferenceTag(str, Enum):
     CASHMERE = "cashmere"
     DENIM = "denim"
     LEATHER = "leather"
-    SUEDE = "suede"
-    SYNTHETIC = "synthetic"
-    POLYESTER = "polyester"
-    RAYON = "rayon"
-    BAMBOO = "bamboo"
-    ORGANIC = "organic"
-    SUSTAINABLE = "sustainable"
     BREATHABLE = "breathable"
     WATERPROOF = "waterproof"
     MOISTURE_WICKING = "moisture_wicking"
-    STRETCH = "stretch"
-    NON_STRETCH = "non_stretch"
+    SUSTAINABLE = "sustainable"
 
 
 class BudgetTag(str, Enum):
-    """Budget preference tags for price-conscious recommendations"""
+    """Budget preference tags matching API Literal types"""
     LUXURY = "luxury"
     PREMIUM = "premium"
     MID_RANGE = "mid_range"
     AFFORDABLE = "affordable"
     BUDGET = "budget"
     VALUE = "value"
-    INVESTMENT = "investment"
-    DISPOSABLE = "disposable"
 
 
 class AgeGroupTag(str, Enum):
@@ -303,10 +252,10 @@ class TagProcessor:
             "constraints": {}
         }
         
-        # Extract and validate tags
+        # Extract and validate tags (support both "style" and "outfit_style" for backward compatibility)
         occasion = tags.get("occasion", "casual")
         weather = tags.get("weather", "any")
-        style = tags.get("style", "casual")
+        outfit_style = tags.get("outfit_style") or tags.get("style", "casual")  # Support both keys
         color_preference = tags.get("color_preference", None)
         fit_preference = tags.get("fit_preference", None)
         material_preference = tags.get("material_preference", None)
@@ -321,7 +270,7 @@ class TagProcessor:
         processed["primary_tags"] = {
             "occasion": occasion,
             "weather": weather,
-            "style": style
+            "outfit_style": outfit_style  # Use outfit_style consistently
         }
         
         # Secondary tags (medium influence)
@@ -431,17 +380,27 @@ class TagProcessor:
             "style_keywords": []
         }
         
-        # Map tags to preferences
+        # Map tags to preferences (support both "style" and "outfit_style")
+        style_value = tags.get("outfit_style") or tags.get("style", "casual")
         style_mapping = {
             "formal": ["blazer", "jacket", "dress shirt", "dress pant", "oxford"],
             "casual": ["tshirt", "jean", "sneaker", "hoodie"],
             "sporty": ["athletic shirt", "jogger", "running shoe", "tank"],
+            "athletic": ["athletic shirt", "jogger", "running shoe", "tank"],
             "business": ["shirt", "pants", "loafer", "blazer"],
-            "traditional": ["kameez", "kurta", "shalwar", "peshawari"]
+            "smart_casual": ["shirt", "chino", "loafer", "blazer"],
+            "traditional": ["kameez", "kurta", "shalwar", "peshawari"],
+            "ethnic": ["kameez", "kurta", "shalwar", "peshawari"],
+            "elegant": ["blazer", "dress shirt", "dress pant", "oxford"],
+            "sophisticated": ["blazer", "dress shirt", "dress pant", "oxford"],
+            "minimalist": ["tshirt", "jean", "sneaker", "hoodie"],
+            "classic": ["shirt", "pants", "loafer", "blazer"],
+            "modern": ["tshirt", "jean", "sneaker", "hoodie"],
+            "streetwear": ["tshirt", "jean", "sneaker", "hoodie"]
         }
         
-        if tags.get("style") in style_mapping:
-            preferences["preferred_categories"].extend(style_mapping[tags["style"]])
+        if style_value in style_mapping:
+            preferences["preferred_categories"].extend(style_mapping[style_value])
         
         # Add synergies as style keywords
         preferences["style_keywords"].extend(synergies)
@@ -488,7 +447,8 @@ def get_all_tag_options() -> Dict[str, List[str]]:
     return {
         "occasion": [tag.value for tag in OccasionTag],
         "weather": [tag.value for tag in WeatherTag],
-        "style": [tag.value for tag in StyleTag],
+        "outfit_style": [tag.value for tag in StyleTag],  # Use outfit_style to match API
+        "style": [tag.value for tag in StyleTag],  # Keep for backward compatibility
         "color_preference": [tag.value for tag in ColorPreferenceTag],
         "fit_preference": [tag.value for tag in FitPreferenceTag],
         "material_preference": [tag.value for tag in MaterialPreferenceTag],