Improve image file handling and add debug logging for image_name matching

app.py

@@ -1457,37 +1457,58 @@ with gr.Blocks(
             image_dict = {}  # Maps filename -> base64
             original_filenames = []  # Track original filenames for error messages
             
+            # Handle case where uploaded_images might be None, empty list, or single file
             if uploaded_images:
-                for img_file in uploaded_images:
+                # Ensure it's a list
+                if not isinstance(uploaded_images, list):
+                    uploaded_images = [uploaded_images]
+                logger.info(f"Processing {len(uploaded_images)} uploaded image(s)")
+                for idx, img_file in enumerate(uploaded_images):
                     try:
                         if img_file is None:
+                            logger.warning(f"Image {idx} is None, skipping")
                             continue
                         
                         # Extract filename and process image
                         filename = None
                         img_b64 = None
+                        file_path = None
                         
-                        # Handle different file input formats
+                        # Handle different file input formats (Gradio 6.1.0 returns file paths as strings)
                         if isinstance(img_file, str):
-                            # File path
-                            if os.path.exists(img_file):
-                                filename = os.path.basename(img_file)
-                                img_b64 = gradio_image_to_base64(img_file)
-                        elif hasattr(img_file, 'name'):
-                            # File object with name attribute (Gradio File object)
-                            filename = os.path.basename(img_file.name) if img_file.name else None
-                            img_b64 = gradio_image_to_base64(img_file.name)
+                            # File path (most common in Gradio 6.x)
+                            file_path = img_file
+                            if os.path.exists(file_path):
+                                filename = os.path.basename(file_path)
+                                img_b64 = gradio_image_to_base64(file_path)
+                                logger.info(f"Processed image from path: {filename}")
+                            else:
+                                logger.warning(f"File path does not exist: {file_path}")
                         elif isinstance(img_file, dict):
-                            # Gradio file dict format: {"name": "...", "path": "...", ...}
+                            # Gradio file dict format: {"name": "...", "path": "...", "orig_name": "...", ...}
                             file_path = img_file.get("path") or img_file.get("name")
+                            # Try to get original filename first, then fall back to path basename
+                            orig_name = img_file.get("orig_name") or img_file.get("name")
                             if file_path:
-                                filename = os.path.basename(file_path)
+                                if orig_name:
+                                    filename = os.path.basename(orig_name)
+                                else:
+                                    filename = os.path.basename(file_path)
                                 img_b64 = gradio_image_to_base64(file_path)
+                                logger.info(f"Processed image from dict: {filename} (path: {file_path})")
+                        elif hasattr(img_file, 'name'):
+                            # File object with name attribute
+                            file_path = img_file.name if hasattr(img_file, 'name') else str(img_file)
+                            filename = os.path.basename(file_path) if file_path else None
+                            if file_path and os.path.exists(file_path):
+                                img_b64 = gradio_image_to_base64(file_path)
+                                logger.info(f"Processed image from file object: {filename}")
                         else:
-                            # Try to process as image directly
+                            # Try to process as image directly (numpy array, PIL Image, etc.)
                             img_b64 = gradio_image_to_base64(img_file)
-                            # If we can't get filename, use index as fallback
-                            filename = f"image_{len(image_list)}.png"
+                            if img_b64:
+                                filename = f"image_{len(image_list)}.png"
+                                logger.info(f"Processed image as direct input: {filename}")
                         
                         if img_b64:
                             image_list.append(img_b64)
@@ -1503,9 +1524,17 @@ with gr.Blocks(
                                 if base_name and base_name != filename:
                                     image_dict[base_name] = img_b64
                                     image_dict[base_name.lower()] = img_b64
+                                logger.info(f"Stored image: {filename} (keys: {filename}, {filename.lower()})")
+                            else:
+                                logger.warning(f"Image processed but no filename extracted, using index")
+                                image_dict[f"image_{len(image_list)-1}"] = img_b64
+                        else:
+                            logger.warning(f"Failed to convert image {idx} to base64 (type: {type(img_file)})")
                     except Exception as e:
-                        logger.warning(f"Failed to process uploaded image: {str(e)}")
+                        logger.error(f"Failed to process uploaded image {idx}: {str(e)}\n{traceback.format_exc()}")
                         continue
+                
+                logger.info(f"Successfully processed {len(image_list)} images. Available filenames: {original_filenames}")
             
             # Validate and import items
             imported_count = 0
@@ -1546,20 +1575,32 @@ with gr.Blocks(
                         
                         # Try to find matching image (case-insensitive)
                         image_name_clean = image_name.strip()
-                        img_b64 = image_dict.get(image_name_clean) or image_dict.get(image_name_clean.lower())
+                        logger.info(f"Item {i+1}: Looking for image '{image_name_clean}' in {len(image_dict)} stored images")
+                        
+                        # Try exact match first
+                        img_b64 = image_dict.get(image_name_clean)
+                        if not img_b64:
+                            # Try case-insensitive match
+                            img_b64 = image_dict.get(image_name_clean.lower())
                         
                         if not img_b64:
                             # Try matching just the filename without path
                             basename = os.path.basename(image_name_clean)
                             img_b64 = image_dict.get(basename) or image_dict.get(basename.lower())
+                            if img_b64:
+                                logger.info(f"Item {i+1}: Matched image by basename '{basename}'")
                         
                         if not img_b64:
                             # Try matching without extension
                             base_name = os.path.splitext(image_name_clean)[0]
                             if base_name:
                                 img_b64 = image_dict.get(base_name) or image_dict.get(base_name.lower())
+                                if img_b64:
+                                    logger.info(f"Item {i+1}: Matched image by base name '{base_name}'")
                         
-                        if not img_b64:
+                        if img_b64:
+                            logger.info(f"Item {i+1}: Successfully matched image '{image_name_clean}'")
+                        else:
                             # Show available filenames for debugging
                             available_str = ', '.join(original_filenames[:5])
                             if len(original_filenames) > 5:
@@ -1567,7 +1608,7 @@ with gr.Blocks(
                             if not original_filenames:
                                 available_str = "none uploaded"
                             # Log warning but continue - don't fail the entire import
-                            logger.warning(f"Item {i+1}: Image '{image_name}' not found. Available images: {available_str}")
+                            logger.warning(f"Item {i+1}: Image '{image_name_clean}' not found. Available images: {available_str}. Image dict keys: {list(image_dict.keys())[:10]}")
                     elif "image_index" in item:
                         # Reference uploaded image by index
                         img_idx = item["image_index"]