Add image_name field support for JSON import - match images by filename

app.py

@@ -1197,8 +1197,10 @@ with gr.Blocks(
                     with gr.Tab("Bulk Import (JSON)"):
                         gr.Markdown(
                             "Paste a JSON array like: `[{\"input\": \"...\", \"output\": \"...\"}]`<br>"
-                            "**Images**: Upload images below and reference them by index (0-based) in JSON using `\"image_index\": 0`, "
-                            "or include base64 directly using `\"image\": \"data:image/...\"`",
+                            "**Images**: Upload images below and reference them in JSON using:<br>"
+                            "• `\"image_name\": \"filename.png\"` - Match by filename (recommended)<br>"
+                            "• `\"image_index\": 0` - Reference by upload order (0-based)<br>"
+                            "• `\"image\": \"data:image/...\"` - Include base64 directly",
                             elem_classes=["small-note"]
                         )
                         bulk_json = gr.Textbox(
@@ -1450,29 +1452,57 @@ with gr.Blocks(
                 raise gr.Error("JSON array is empty. Add at least one example object.")
             
             # Process uploaded images into base64 format
+            # Create both a list (for index-based access) and a dict (for filename-based access)
             image_list = []
+            image_dict = {}  # Maps filename -> base64
+            original_filenames = []  # Track original filenames for error messages
+            
             if uploaded_images:
                 for img_file in uploaded_images:
                     try:
                         if img_file is None:
                             continue
+                        
+                        # Extract filename and process image
+                        filename = None
+                        img_b64 = None
+                        
                         # Handle different file input formats
                         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)
-                                if img_b64:
-                                    image_list.append(img_b64)
                         elif hasattr(img_file, 'name'):
-                            # File object with name attribute
+                            # 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)
-                            if img_b64:
-                                image_list.append(img_b64)
+                        elif isinstance(img_file, dict):
+                            # Gradio file dict format: {"name": "...", "path": "...", ...}
+                            file_path = img_file.get("path") or img_file.get("name")
+                            if file_path:
+                                filename = os.path.basename(file_path)
+                                img_b64 = gradio_image_to_base64(file_path)
                         else:
                             # Try to process as image directly
                             img_b64 = gradio_image_to_base64(img_file)
-                            if img_b64:
-                                image_list.append(img_b64)
+                            # If we can't get filename, use index as fallback
+                            filename = f"image_{len(image_list)}.png"
+                        
+                        if img_b64:
+                            image_list.append(img_b64)
+                            # Store by filename (case-insensitive matching)
+                            if filename:
+                                original_filenames.append(filename)
+                                # Store with original filename
+                                image_dict[filename] = img_b64
+                                # Also store with lowercase for case-insensitive lookup
+                                image_dict[filename.lower()] = img_b64
+                                # Also store without extension for more flexible matching
+                                base_name = os.path.splitext(filename)[0]
+                                if base_name and base_name != filename:
+                                    image_dict[base_name] = img_b64
+                                    image_dict[base_name.lower()] = img_b64
                     except Exception as e:
                         logger.warning(f"Failed to process uploaded image: {str(e)}")
                         continue
@@ -1502,9 +1532,43 @@ with gr.Blocks(
                         errors.append(f"Item {i+1}: 'input' and 'output' cannot be empty")
                         continue
                     
-                    # Handle image - check for image_index first, then direct image field
+                    # Handle image - check for image_name first, then image_index, then direct image field
                     img_b64 = None
-                    if "image_index" in item:
+                    if "image_name" in item:
+                        # Match uploaded image by filename
+                        image_name = item["image_name"]
+                        if not isinstance(image_name, str):
+                            errors.append(f"Item {i+1}: 'image_name' must be a string")
+                            continue
+                        if not image_name.strip():
+                            errors.append(f"Item {i+1}: 'image_name' cannot be empty")
+                            continue
+                        
+                        # 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())
+                        
+                        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 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 not img_b64:
+                            # Show available filenames for debugging
+                            available_str = ', '.join(original_filenames[:5])
+                            if len(original_filenames) > 5:
+                                available_str += f" (and {len(original_filenames) - 5} more)"
+                            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}")
+                    elif "image_index" in item:
                         # Reference uploaded image by index
                         img_idx = item["image_index"]
                         if not isinstance(img_idx, int):