more fixes

app.py

@@ -823,28 +823,40 @@ def gradio_recommend(
     if not files:
         return [], {"error": "No files uploaded"}
     
-    # Debug: Log file information for API troubleshooting
+    # Enhanced debug: Log detailed file information for API troubleshooting
+    print(f"🔍 DEBUG: gradio_recommend called with {len(files)} files")
     file_info = []
-    for f in files:
+    for i, f in enumerate(files):
         if isinstance(f, str):
-            file_info.append(f"Path: {f}")
+            from pathlib import Path
+            path = Path(f)
+            file_size = path.stat().st_size if path.exists() else 0
+            file_info.append(f"File {i+1}: {path.name} ({file_size} bytes)")
+            print(f"🔍 DEBUG: File {i+1}: path={f}, exists={path.exists()}, size={file_size}, name={path.name}")
         else:
             file_info.append(f"Type: {type(f).__name__}, Value: {str(f)[:100]}")
+            print(f"🔍 DEBUG: File {i+1}: type={type(f).__name__}, value={str(f)[:100]}")
     
     try:
+        print(f"🔍 DEBUG: Attempting to load {len(files)} images...")
         images = _load_images_from_files(files)
+        print(f"🔍 DEBUG: Successfully loaded {len(images)} images from {len(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.)"
+            print(f"🔍 DEBUG: ERROR - No images loaded. Files: {len(files)}, Images: {len(images)}")
             return [], {"error": error_msg, "files_received": len(files), "file_info": file_info[:5]}
     except Exception as e:
+        import traceback
         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."
+        print(f"🔍 DEBUG: EXCEPTION during image loading: {e}")
+        traceback.print_exc()
         return [], {"error": error_msg, "exception": str(e), "files_received": len(files)}
     
     # Tag normalization: Map frontend values to backend values

utils/image_utils.py

@@ -98,8 +98,13 @@ def load_image_from_file(
     """
     Load an image from a file path, supporting all major formats.
     
-    This function attempts to load images even without file extensions (e.g., Gradio blob files).
-    It first checks the extension, but if that fails, it tries to detect the format from file content.
+    Enhanced to handle files without extensions (e.g., Gradio blob files)
+    by detecting format from file content (magic bytes).
+    
+    Detection priority:
+    1. File extension (if present)
+    2. Magic byte detection (file content)
+    3. PIL format detection (fallback)
     
     Args:
         filepath: Path to the image file
@@ -118,46 +123,101 @@ def load_image_from_file(
                 raise FileNotFoundError(f"Image file not found: {filepath}")
             return None
         
-        # Try to open the image - PIL can detect format from content even without extension
-        # This handles Gradio's "blob" files and other files without extensions
+        # Step 1: Check file extension first
+        detected_format = None
+        if is_image_file(path):
+            detected_format = get_image_format(path)
+            if detected_format:
+                print(f"🔍 Detected format from extension: {detected_format} (file: {path.name})")
+        
+        # Step 2: If no extension, detect from magic bytes (file content)
+        # This is critical for Gradio blob files which have no extension
+        if not detected_format:
+            try:
+                with open(path, 'rb') as f:
+                    header = f.read(12)  # Read first 12 bytes for format detection
+                    
+                    # JPEG: FF D8 (JPEG files start with these bytes, third byte can vary)
+                    if len(header) >= 2 and header[:2] == b'\xff\xd8':
+                        detected_format = 'JPEG'
+                    # PNG: 89 50 4E 47 0D 0A 1A 0A (PNG signature)
+                    elif len(header) >= 8 and header[:8] == b'\x89PNG\r\n\x1a\n':
+                        detected_format = 'PNG'
+                    # GIF: 47 49 46 38 (GIF8 or GIF9)
+                    elif len(header) >= 4 and header[:4] in [b'GIF8', b'GIF9']:
+                        detected_format = 'GIF'
+                    # WEBP: RIFF ... WEBP (RIFF container with WEBP format)
+                    elif len(header) >= 12 and header[:4] == b'RIFF' and header[8:12] == b'WEBP':
+                        detected_format = 'WEBP'
+                    # BMP: 42 4D (BM - Windows bitmap)
+                    elif len(header) >= 2 and header[:2] == b'BM':
+                        detected_format = 'BMP'
+                    # TIFF: 49 49 2A 00 (little-endian) or 4D 4D 00 2A (big-endian)
+                    elif len(header) >= 4 and header[:4] in [b'II*\x00', b'MM\x00*']:
+                        detected_format = 'TIFF'
+                    
+                    if detected_format:
+                        print(f"🔍 Detected format from magic bytes: {detected_format} (file: {path.name})")
+            except Exception as e:
+                print(f"⚠️ Error reading file header for format detection: {e}")
+        
+        # Step 3: Try PIL format detection as fallback
         try:
-            # Open image to detect format (don't verify yet, just check format)
+            # Open image - PIL can also detect format from content
             test_img = Image.open(path)
-            detected_format = test_img.format
+            pil_format = test_img.format
             test_img.close()
             
-            # If format detected, check if it's supported
-            if detected_format:
-                if detected_format.upper() not in SUPPORTED_FORMATS:
-                    # Format detected but not in our supported list
-                    if raise_on_error:
-                        raise ValueError(f"Unsupported image format: {detected_format} (file: {filepath})")
-                    print(f"⚠️ Skipping unsupported format: {detected_format} (file: {filepath})")
-                    return None
-            else:
-                # No format detected - check extension as fallback
-                if not is_image_file(path):
-                    if raise_on_error:
-                        raise ValueError(f"Cannot identify image format and no valid extension: {filepath}")
-                    print(f"⚠️ Cannot identify image format: {filepath}")
-                    return None
+            # Use PIL format if we didn't detect from extension/magic bytes, or verify consistency
+            if pil_format:
+                if detected_format:
+                    # Both methods detected format - verify they match
+                    if pil_format.upper() != detected_format.upper():
+                        print(f"⚠️ Format mismatch: extension/magic bytes={detected_format}, PIL={pil_format}, using PIL format")
+                    detected_format = pil_format  # Prefer PIL format as it's more reliable
+                else:
+                    # Only PIL detected format
+                    detected_format = pil_format
+                    print(f"🔍 Detected format from PIL: {detected_format} (file: {path.name})")
+            elif not detected_format:
+                # Neither method detected format
+                if raise_on_error:
+                    raise ValueError(f"Cannot identify image format and no valid extension: {filepath}")
+                print(f"⚠️ Cannot identify image format: {filepath}")
+                return None
+            
+            # Check if format is supported
+            if detected_format and detected_format.upper() not in SUPPORTED_FORMATS:
+                if raise_on_error:
+                    raise ValueError(f"Unsupported image format: {detected_format} (file: {filepath})")
+                print(f"⚠️ Skipping unsupported format: {detected_format} (file: {filepath})")
+                return None
             
             # Verify it's actually a valid image
             with Image.open(path) as img:
                 img.verify()
                 
         except UnidentifiedImageError:
-            # If PIL can't identify it, check extension as fallback
-            if not is_image_file(path):
+            # PIL can't identify it - but we might have detected from magic bytes
+            if detected_format:
+                # We detected format from magic bytes, try to open anyway
+                print(f"⚠️ PIL couldn't identify format, but magic bytes suggest {detected_format}, attempting to open...")
+                try:
+                    # Try opening with PIL (it might still work)
+                    test_img = Image.open(path)
+                    test_img.verify()
+                    test_img.close()
+                except Exception as e:
+                    if raise_on_error:
+                        raise ValueError(f"File detected as {detected_format} but cannot be read: {filepath} ({str(e)})")
+                    print(f"⚠️ File detected as {detected_format} but cannot be read: {filepath} ({str(e)})")
+                    return None
+            else:
+                # No format detected from any method
                 if raise_on_error:
                     raise ValueError(f"Cannot identify image format and no valid extension: {filepath}")
                 print(f"⚠️ Cannot identify image format: {filepath}")
                 return None
-            # Extension suggests it's an image, but PIL can't read it - might be corrupted
-            if raise_on_error:
-                raise ValueError(f"File has image extension but cannot be read: {filepath}")
-            print(f"⚠️ File has image extension but cannot be read: {filepath}")
-            return None
         
         # Re-open for actual use (verify() closes the file)
         img = Image.open(path)