Upload folder using huggingface_hub

.claude/settings.local.json

@@ -72,7 +72,10 @@
       "Bash(sed -i '' '1540s/.*/            print(\"Close modal button clicked!\")  # Debug/' /Users/deep-diver/Developers/auto-diffusers/gradio_app.py)",
       "Bash(GRADIO_SERVER_PORT=7861 python gradio_app.py)",
       "Bash(lsof -ti:7860)",
-      "Bash(kill 46516 80145)"
+      "Bash(kill 46516 80145)",
+      "Bash(grep -n \"model_name\" gradio_app.py)",
+      "Bash(grep -n -A2 -B2 \"model_name\" gradio_app.py)",
+      "Bash(timeout 20 python gradio_app.py)"
     ],
     "deny": []
   },

gradio_app.py

@@ -1224,37 +1224,38 @@ def create_gradio_interface():
             return f"🤖 Model: {model_short} | {dtype_short} | {width}×{height} | {inference_steps} steps{memory_info}"
         
                 
-        def update_memory_analysis(model_name, vram_gb):
-            """Update memory analysis in real-time based on selections."""
+        # State to track last processed model name
+        last_processed_model = gr.State(value="")
+        
+        def update_memory_analysis(model_name, vram_gb, last_model):
+            """Update memory analysis based on selections."""
             if not model_name or not model_name.strip():
-                return "Select a model to see memory requirements."
+                return "Select a model to see memory requirements.", ""
+            
+            # Check if model name has actually changed
+            if model_name == last_model and last_model != "":
+                # Return current analysis without API call (model hasn't changed)
+                return gr.update(), last_model
             
             if not vram_gb or vram_gb <= 0:
-                return f"**Model:** {model_name}\n\nConfigure your GPU to see memory analysis."
+                return f"**Model:** {model_name}\n\nConfigure your GPU to see memory analysis.", model_name
             
             try:
                 memory_info, recommendations, formatted_info = app.analyze_model_memory(model_name, vram_gb)
-                return formatted_info
-            except Exception as e:
-                # Enhanced error reporting with full traceback
-                import traceback
-                error_details = traceback.format_exc()
-                print(f"Memory analysis error for {model_name}: {error_details}")
                 
-                # More specific error messages
-                error_msg = str(e)
-                if "Too many arguments" in error_msg:
-                    detailed_error = f"❌ **HuggingFace API Error**\n\nModel: `{model_name}`\n\n**Issue:** The model repository might not exist or is private.\n\n**Details:** {error_msg}\n\n**Suggestion:** Check the model name spelling and ensure it's a public model on HuggingFace."
-                elif "404" in error_msg or "not found" in error_msg.lower():
-                    detailed_error = f"❌ **Model Not Found**\n\nModel: `{model_name}`\n\n**Issue:** This model doesn't exist on HuggingFace.\n\n**Suggestion:** Verify the model name is correct (e.g., 'black-forest-labs/FLUX.1-schnell')."
-                elif "403" in error_msg or "private" in error_msg.lower():
-                    detailed_error = f"❌ **Access Denied**\n\nModel: `{model_name}`\n\n**Issue:** This model is private or requires authentication.\n\n**Suggestion:** Use a public model or check access permissions."
-                elif "timeout" in error_msg.lower():
-                    detailed_error = f"❌ **Timeout Error**\n\nModel: `{model_name}`\n\n**Issue:** HuggingFace API is slow or unresponsive.\n\n**Suggestion:** Try again in a moment."
-                else:
-                    detailed_error = f"❌ **Memory Analysis Error**\n\nModel: `{model_name}`\n\n**Error Type:** {type(e).__name__}\n\n**Details:** {error_msg}\n\n**Full Error:**\n```\n{error_details}\n```"
+                # Check if there was an error in the memory analysis
+                if isinstance(memory_info, dict) and 'error' in memory_info:
+                    # Extract just the core error message
+                    error_msg = str(memory_info['error'])
+                    if "Error analyzing model memory:" in error_msg:
+                        error_msg = error_msg.replace("Error analyzing model memory:", "").strip()
+                    return f"**Note:** {error_msg} (API error)", model_name
                 
-                return detailed_error
+                return formatted_info, model_name
+            except Exception as e:
+                # Simple error message for any other exceptions
+                error_msg = str(e)
+                return f"**Note:** {error_msg} (API error)", model_name
                 
         # Connect GPU dropdown change handlers with memory analysis updates
         gpu_vendor.change(
@@ -1263,8 +1264,8 @@ def create_gradio_interface():
             outputs=[gpu_series, gpu_model, gpu_name, vram_gb]
         ).then(
             update_memory_analysis,
-            inputs=[model_name, vram_gb],
-            outputs=memory_analysis_output
+            inputs=[model_name, vram_gb, last_processed_model],
+            outputs=[memory_analysis_output, last_processed_model]
         )
         
         gpu_series.change(
@@ -1279,29 +1280,35 @@ def create_gradio_interface():
             outputs=[gpu_name, vram_gb]
         ).then(
             update_memory_analysis,
-            inputs=[model_name, vram_gb],
-            outputs=memory_analysis_output
+            inputs=[model_name, vram_gb, last_processed_model],
+            outputs=[memory_analysis_output, last_processed_model]
         )
         
         
-        # Update memory analysis when model name or VRAM changes
-        model_name.change(
+        # Update memory analysis when model name is submitted (Enter) or loses focus, or VRAM changes
+        model_name.submit(
+            update_memory_analysis,
+            inputs=[model_name, vram_gb, last_processed_model],
+            outputs=[memory_analysis_output, last_processed_model]
+        )
+        
+        model_name.blur(
             update_memory_analysis,
-            inputs=[model_name, vram_gb],
-            outputs=memory_analysis_output
+            inputs=[model_name, vram_gb, last_processed_model],
+            outputs=[memory_analysis_output, last_processed_model]
         )
         
         vram_gb.change(
             update_memory_analysis,
-            inputs=[model_name, vram_gb],
-            outputs=memory_analysis_output
+            inputs=[model_name, vram_gb, last_processed_model],
+            outputs=[memory_analysis_output, last_processed_model]
         )
         
         # Load initial memory analysis on startup
         interface.load(
             update_memory_analysis,
-            inputs=[model_name, vram_gb],
-            outputs=memory_analysis_output
+            inputs=[model_name, vram_gb, last_processed_model],
+            outputs=[memory_analysis_output, last_processed_model]
         )
         
         # Create wrapper functions that return gr.update for accordion labels
@@ -1337,7 +1344,19 @@ def create_gradio_interface():
             )
         
         # Model accordion title updates (including memory analysis)
-        for component in [model_name, dtype_selection, width, height, inference_steps]:
+        model_name.submit(
+            update_model_accordion,
+            inputs=[model_name, dtype_selection, width, height, inference_steps, memory_analysis_output],
+            outputs=model_accordion
+        )
+        
+        model_name.blur(
+            update_model_accordion,
+            inputs=[model_name, dtype_selection, width, height, inference_steps, memory_analysis_output],
+            outputs=model_accordion
+        )
+        
+        for component in [dtype_selection, width, height, inference_steps]:
             component.change(
                 update_model_accordion,
                 inputs=[model_name, dtype_selection, width, height, inference_steps, memory_analysis_output],