Upload folder using huggingface_hub

.claude/settings.local.json

@@ -0,0 +1,35 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python3 -c \"import platform; import psutil; import torch; print(f'Python: {platform.python_version()}'); print(f'Platform: {platform.system()} {platform.release()}'); print(f'CPU: {platform.processor()}'); print(f'CPU Cores: {psutil.cpu_count()}'); print(f'RAM: {psutil.virtual_memory().total // (1024**3)} GB'); print(f'PyTorch: {torch.__version__}' if 'torch' in globals() else 'PyTorch: Not installed'); print(f'CUDA Available: {torch.cuda.is_available()}' if 'torch' in globals() else 'CUDA: Check needed'); print(f'CUDA Devices: {torch.cuda.device_count()}' if 'torch' in globals() and torch.cuda.is_available() else '')\")",
+      "Bash(python3 -c \"import platform; import os; print(f'Python: {platform.python_version()}'); print(f'Platform: {platform.system()} {platform.release()}'); print(f'Machine: {platform.machine()}'); print(f'Processor: {platform.processor()}'); print(f'CPU Count: {os.cpu_count()}'); print('Checking for GPU...'); import subprocess; result = subprocess.run(['nvidia-smi', '--query-gpu=name,memory.total', '--format=csv,noheader,nounits'], capture_output=True, text=True); print(f'NVIDIA GPUs: {result.stdout.strip()}' if result.returncode == 0 else 'No NVIDIA GPU detected')\")",
+      "Bash(conda create -n auto-diffusers python=3.11 -y)",
+      "Bash(source /opt/miniconda3/etc/profile.d/conda.sh)",
+      "Bash(conda activate auto-diffusers)",
+      "Bash(python hardware_detector.py)",
+      "Bash(pip install psutil torch)",
+      "Bash(python -c \"from hardware_detector import HardwareDetector; h = HardwareDetector(); h.print_specs(); print(f''Profile: {h.get_optimization_profile()}'')\")",
+      "Bash(pip install google-generativeai)",
+      "Bash(pip install python-dotenv)",
+      "Bash(python test_generation.py)",
+      "Bash(python test_flux_specific.py)",
+      "Bash(python -c \"from hardware_detector import HardwareDetector; h = HardwareDetector(); print(''Hardware detection: OK''); print(f''Profile: {h.get_optimization_profile()}'')\")",
+      "Bash(python -c \"import os; from dotenv import load_dotenv; load_dotenv(); print(''API key loaded:'', ''Yes'' if os.getenv(''GOOGLE_API_KEY'') else ''No'')\")",
+      "Bash(ls -la *.py)",
+      "Bash(pip install gradio)",
+      "Bash(python -c \"from gradio_app import create_gradio_interface; print(''✅ Gradio app imports successfully'')\")",
+      "Bash(python -c \"from model_memory_calculator import ModelMemoryCalculator; calc = ModelMemoryCalculator(); print(''Testing memory calculator...''); result = calc.get_model_memory_requirements(''black-forest-labs/FLUX.1-schnell''); print(f''Model has {result.get(\"\"total_params_billions\"\", 0):.1f}B parameters'')\")",
+      "Bash(python -c \"from model_memory_calculator import ModelMemoryCalculator; calc = ModelMemoryCalculator(); result = calc.get_model_memory_requirements(''black-forest-labs/FLUX.1-schnell'')\")",
+      "Bash(python simple_memory_calculator.py)",
+      "Bash(python gradio_app.py)",
+      "Bash(python -c \"\nfrom simple_memory_calculator import SimpleMemoryCalculator\ncalc = SimpleMemoryCalculator()\nprint(calc.format_memory_info('stabilityai/stable-diffusion-2'))\n\")",
+      "Bash(python -m py_compile gradio_app.py)",
+      "Bash(python -c \"\nimport gradio_app\nprint('✅ Gradio app syntax is valid!')\n\")",
+      "Bash(python -c \"print('App is ready!')\")",
+      "Bash(grep -n \"copy_btn.click\\|collapse_btn.click\" /Users/deep-diver/Developers/auto-diffusers/gradio_app.py)",
+      "Bash(grep -n \"📋\\|🔽\\|🔼\" /Users/deep-diver/Developers/auto-diffusers/gradio_app.py)",
+      "Bash(grep -n \"💡 Tip:\" /Users/deep-diver/Developers/auto-diffusers/gradio_app.py)"
+    ],
+    "deny": []
+  }
+}

.env

@@ -0,0 +1 @@
+GOOGLE_API_KEY=AIzaSyA-rA_Gnw_jMx4QeaRQ639f1d8PQkvA6hA

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,103 @@
 ---
-title: Auto Diffuser Config
-emoji: 📈
-colorFrom: green
-colorTo: yellow
+title: auto-diffuser-config
+app_file: gradio_app.py
 sdk: gradio
 sdk_version: 5.31.0
-app_file: app.py
-pinned: false
 ---
+# Auto-Diffusers
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+An intelligent code generator that creates optimized diffusers library snippets based on your hardware specifications using Google's Gemini API.
+
+## Features
+
+- **Hardware Detection**: Automatically detects your system specs (CPU, GPU, VRAM) or allows manual input
+- **Real-time Optimization**: Fetches latest optimization techniques from HuggingFace documentation
+- **Smart Code Generation**: Uses Gemini API to generate hardware-optimized diffusers code
+- **Multiple Profiles**: Supports high-end GPU, mid-range GPU, low VRAM, Apple Silicon, and CPU-only configurations
+
+## Setup
+
+1. Create and activate conda environment:
+```bash
+conda create -n auto-diffusers python=3.11 -y
+conda activate auto-diffusers
+```
+
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Set up Gemini API key:
+```bash
+export GEMINI_API_KEY="your_api_key_here"
+```
+
+## Usage
+
+### Interactive Mode
+```bash
+python auto_diffusers.py
+```
+
+### Hardware Detection Only
+```bash
+python hardware_detector.py
+```
+
+### Programmatic Usage
+```python
+from auto_diffusers import AutoDiffusersGenerator
+
+generator = AutoDiffusersGenerator(api_key="your_key")
+code = generator.generate_optimized_code(
+    model_name="black-forest-labs/FLUX.1-schnell",
+    prompt_text="A cat holding a sign that says hello world",
+    image_size=(768, 1360),
+    num_inference_steps=4
+)
+print(code)
+```
+
+## Hardware Profiles
+
+- **high_end_gpu**: 20+ GB VRAM (RTX 4090, A100, etc.)
+- **mid_range_gpu**: 8-20 GB VRAM (RTX 3080, RTX 4070, etc.)  
+- **low_vram_gpu**: <8 GB VRAM (GTX 1660, RTX 3060, etc.)
+- **apple_silicon**: M1/M2/M3 Macs with MPS support
+- **cpu_only**: No GPU acceleration
+
+## Optimization Techniques Applied
+
+The generator automatically applies appropriate optimizations based on your hardware:
+
+- Memory optimizations (model offloading, attention slicing, VAE slicing)
+- Speed optimizations (torch.compile, optimal dtypes)
+- Hardware-specific optimizations (CUDA, MPS, CPU fallbacks)
+- Model-specific configurations (schedulers, inference parameters)
+
+## Example Output
+
+```python
+import torch
+from diffusers import FluxPipeline
+
+# Optimized for Apple Silicon (MPS)
+pipe = FluxPipeline.from_pretrained(
+    "black-forest-labs/FLUX.1-schnell", 
+    torch_dtype=torch.bfloat16
+)
+pipe.to("mps")
+pipe.enable_attention_slicing()
+
+prompt = "A cat holding a sign that says hello world"
+out = pipe(
+    prompt=prompt,
+    guidance_scale=0.,
+    height=768,
+    width=1360,
+    num_inference_steps=4,
+    max_sequence_length=256,
+).images[0]
+out.save("image.png")
+```

auto_diffusers.py

@@ -0,0 +1,235 @@
+import os
+from dotenv import load_dotenv
+import google.generativeai as genai
+from hardware_detector import HardwareDetector
+from typing import Dict, List
+
+load_dotenv()
+
+
+class AutoDiffusersGenerator:
+    def __init__(self, api_key: str):
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel('gemini-2.5-flash-preview-05-20')
+        self.hardware_detector = HardwareDetector()
+        
+    def generate_optimized_code(self, 
+                              model_name: str, 
+                              prompt_text: str,
+                              image_size: tuple = (768, 1360),
+                              num_inference_steps: int = 4,
+                              use_manual_specs: bool = False,
+                              manual_specs: Dict = None,
+                              memory_analysis: Dict = None) -> str:
+        """Generate optimized diffusers code based on hardware specs and memory analysis."""
+        
+        # Get hardware specifications
+        if use_manual_specs and manual_specs:
+            hardware_specs = manual_specs
+            # Determine optimization profile based on manual specs
+            if hardware_specs.get('gpu_info') and hardware_specs['gpu_info']:
+                vram_gb = hardware_specs['gpu_info'][0]['memory_mb'] / 1024
+                if vram_gb >= 16:
+                    optimization_profile = 'performance'
+                elif vram_gb >= 8:
+                    optimization_profile = 'balanced'
+                else:
+                    optimization_profile = 'memory_efficient'
+            else:
+                optimization_profile = 'cpu_only'
+        else:
+            hardware_specs = self.hardware_detector.specs
+            optimization_profile = self.hardware_detector.get_optimization_profile()
+        
+        # Create the prompt for Gemini API
+        system_prompt = self._create_generation_prompt(
+            model_name, prompt_text, image_size, num_inference_steps, 
+            hardware_specs, optimization_profile, memory_analysis
+        )
+        
+        try:
+            response = self.model.generate_content(system_prompt)
+            return response.text
+        except Exception as e:
+            return f"Error generating code: {str(e)}"
+    
+    def _create_generation_prompt(self, 
+                                model_name: str, 
+                                prompt_text: str,
+                                image_size: tuple,
+                                num_inference_steps: int,
+                                hardware_specs: Dict,
+                                optimization_profile: str,
+                                memory_analysis: Dict = None) -> str:
+        """Create the prompt for Gemini API to generate optimized code."""
+        
+        base_prompt = f"""
+You are an expert in optimizing diffusers library code for different hardware configurations.
+
+TASK: Generate optimized Python code for running a diffusion model with the following specifications:
+- Model: {model_name}
+- Prompt: "{prompt_text}"
+- Image size: {image_size[0]}x{image_size[1]}
+- Inference steps: {num_inference_steps}
+
+HARDWARE SPECIFICATIONS:
+- Platform: {hardware_specs['platform']} ({hardware_specs['architecture']})
+- CPU Cores: {hardware_specs['cpu_count']}
+- CUDA Available: {hardware_specs['cuda_available']}
+- MPS Available: {hardware_specs['mps_available']}
+- Optimization Profile: {optimization_profile}
+"""
+
+        if hardware_specs.get('gpu_info'):
+            base_prompt += f"- GPU: {hardware_specs['gpu_info'][0]['name']} ({hardware_specs['gpu_info'][0]['memory_mb']/1024:.1f} GB VRAM)\n"
+
+        # Add user dtype preference if specified
+        if hardware_specs.get('user_dtype'):
+            base_prompt += f"- User specified dtype: {hardware_specs['user_dtype']}\n"
+
+        # Add memory analysis information
+        if memory_analysis:
+            memory_info = memory_analysis.get('memory_info', {})
+            recommendations = memory_analysis.get('recommendations', {})
+            
+            base_prompt += f"\nMEMORY ANALYSIS:\n"
+            if memory_info.get('estimated_inference_memory_fp16_gb'):
+                base_prompt += f"- Model Memory Requirements: {memory_info['estimated_inference_memory_fp16_gb']} GB (FP16 inference)\n"
+            if memory_info.get('memory_fp16_gb'):
+                base_prompt += f"- Model Weights Size: {memory_info['memory_fp16_gb']} GB (FP16)\n"
+            if recommendations.get('recommendations'):
+                base_prompt += f"- Memory Recommendation: {', '.join(recommendations['recommendations'])}\n"
+            if recommendations.get('recommended_precision'):
+                base_prompt += f"- Recommended Precision: {recommendations['recommended_precision']}\n"
+            if recommendations.get('cpu_offload'):
+                base_prompt += f"- CPU Offloading Required: {recommendations['cpu_offload']}\n"
+            if recommendations.get('attention_slicing'):
+                base_prompt += f"- Attention Slicing Recommended: {recommendations['attention_slicing']}\n"
+            if recommendations.get('vae_slicing'):
+                base_prompt += f"- VAE Slicing Recommended: {recommendations['vae_slicing']}\n"
+
+        base_prompt += f"""
+OPTIMIZATION REQUIREMENTS:
+Please scrape and analyze the latest optimization techniques from this URL: https://huggingface.co/docs/diffusers/main/en/optimization
+
+IMPORTANT: For FLUX.1-schnell models, do NOT include guidance_scale parameter as it's not needed.
+
+Based on the hardware specs and optimization profile, generate Python code that includes:
+
+1. **Memory Optimizations** (if low VRAM):
+   - Model offloading (enable_model_cpu_offload, enable_sequential_cpu_offload)
+   - Attention slicing (enable_attention_slicing)
+   - VAE slicing (enable_vae_slicing)
+   - Memory efficient attention
+
+2. **Speed Optimizations**:
+   - Appropriate torch.compile() usage
+   - Optimal dtype selection (torch.float16, torch.bfloat16)
+   - Device placement optimization
+
+3. **Hardware-Specific Optimizations**:
+   - CUDA optimizations for NVIDIA GPUs
+   - MPS optimizations for Apple Silicon
+   - CPU fallbacks when needed
+
+4. **Model-Specific Optimizations**:
+   - Appropriate scheduler selection
+   - Optimal inference parameters
+   - Pipeline configuration
+
+5. **Data Type (dtype) Selection**:
+   - If user specified a dtype, use that exact dtype in the code
+   - If no dtype specified, automatically select the optimal dtype based on hardware:
+     * Apple Silicon (MPS): prefer torch.bfloat16
+     * NVIDIA GPUs: prefer torch.float16 or torch.bfloat16 based on capability
+     * CPU only: use torch.float32
+   - Add a comment explaining why that dtype was chosen
+
+IMPORTANT GUIDELINES:
+- Include all necessary imports
+- Add brief comments explaining optimization choices
+- Use the most current and effective optimization techniques
+- Ensure code is production-ready
+
+CODE STYLE REQUIREMENTS - GENERATE COMPACT CODE:
+- Assign static values directly to function arguments instead of using variables when possible
+- Minimize variable declarations - inline values where it improves readability
+- Reduce exception handling to essential cases only - assume normal operation
+- Use concise, direct code patterns
+- Combine operations where logical and readable
+- Avoid unnecessary intermediate variables
+- Keep code clean and minimal while maintaining functionality
+
+Examples of preferred compact style:
+- pipe = Pipeline.from_pretrained("model", torch_dtype=torch.float16) instead of storing dtype in variable
+- image = pipe("prompt", num_inference_steps=4, height=768, width=1360) instead of separate variables
+- Direct assignment: device = "cuda" if torch.cuda.is_available() else "cpu"
+
+Generate ONLY the Python code, no explanations before or after the code block.
+"""
+        
+        return base_prompt
+    
+    def run_interactive_mode(self):
+        """Run the generator in interactive mode."""
+        print("=== Auto-Diffusers Code Generator ===")
+        print("This tool generates optimized diffusers code based on your hardware.\n")
+        
+        # Check hardware
+        print("=== Hardware Detection ===")
+        self.hardware_detector.print_specs()
+        
+        use_manual = input("\nUse manual hardware input? (y/n): ").lower() == 'y'
+        
+        # Get user inputs
+        print("\n=== Model Configuration ===")
+        model_name = input("Model name (default: black-forest-labs/FLUX.1-schnell): ").strip()
+        if not model_name:
+            model_name = "black-forest-labs/FLUX.1-schnell"
+            
+        prompt_text = input("Prompt text (default: A cat holding a sign that says hello world): ").strip()
+        if not prompt_text:
+            prompt_text = "A cat holding a sign that says hello world"
+            
+        try:
+            width = int(input("Image width (default: 1360): ") or "1360")
+            height = int(input("Image height (default: 768): ") or "768")
+            steps = int(input("Inference steps (default: 4): ") or "4")
+        except ValueError:
+            width, height, steps = 1360, 768, 4
+            
+        print("\n=== Generating Optimized Code ===")
+        
+        # Generate code
+        optimized_code = self.generate_optimized_code(
+            model_name=model_name,
+            prompt_text=prompt_text,
+            image_size=(height, width),
+            num_inference_steps=steps,
+            use_manual_specs=use_manual
+        )
+        
+        print("\n" + "="*60)
+        print("OPTIMIZED DIFFUSERS CODE:")
+        print("="*60)
+        print(optimized_code)
+        print("="*60)
+
+
+def main():
+    # Get API key from .env file
+    api_key = os.getenv('GOOGLE_API_KEY')
+    if not api_key:
+        api_key = os.getenv('GEMINI_API_KEY')  # fallback
+    if not api_key:
+        api_key = input("Enter your Gemini API key: ").strip()
+        if not api_key:
+            print("API key is required!")
+            return
+    
+    generator = AutoDiffusersGenerator(api_key)
+    generator.run_interactive_mode()
+
+
+if __name__ == "__main__":
+    main()

flux_optimized_apple_silicon.py

@@ -0,0 +1,35 @@
+import torch
+from diffusers import FluxPipeline
+
+try:
+    model_id = "black-forest-labs/FLUX.1-schnell"
+    pipe = FluxPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
+    pipe = pipe.to("mps")
+
+    prompt = "A cat holding a sign that says hello world"
+    image_size = (768, 1360)
+    num_inference_steps = 4
+    guidance_scale = 0.0
+    max_sequence_length = 256
+
+
+    with torch.inference_mode():
+        image = pipe(prompt, 
+                     image_size=image_size, 
+                     num_inference_steps=num_inference_steps, 
+                     guidance_scale=guidance_scale,
+                     max_sequence_length=max_sequence_length,
+                     attention_slicing=True,
+                     vae_slicing=True).images[0]
+        image.save("output.png")
+
+except Exception as e:
+    print(f"An error occurred: {e}")
+except ImportError as e:
+    print(f"An import error occurred: {e}. Please make sure you have the required libraries installed.")
+
+except RuntimeError as e:
+    if "CUDA out of memory" in str(e):
+        print("Out of MPS memory. Try reducing image size or batch size.")
+    else:
+        print(f"A runtime error occurred: {e}")

generated_optimized.py

@@ -0,0 +1,37 @@
+```python
+import torch
+from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
+
+# Model selection and device placement
+model_id = "black-forest-labs/FLUX.1-schnell"
+device = "mps" if torch.backends.mps.is_available() else "cpu"  # Prioritize MPS
+
+# Optimization parameters
+torch.backends.mps.graph_mode = False  # Disable graph mode for MPS for better debugging and potential performance in some cases
+pipe = StableDiffusionPipeline.from_pretrained(
+    model_id,
+    torch_dtype=torch.float16,  # Use float16 for better performance on MPS
+    scheduler=DPMSolverMultistepScheduler.from_config(model_id, algorithm_type="dpmsolver"), # Optimized scheduler for speed
+)
+pipe.to(device)
+
+# Memory optimization
+pipe.enable_attention_slicing()  # Enable attention slicing for memory efficiency
+pipe.enable_vae_slicing() # Enable VAE slicing for memory efficiency
+
+# Speed optimization with torch.compile
+pipe = torch.compile(pipe)  # Compile the pipeline for better performance
+
+# Inference parameters
+prompt = "A cat holding a sign that says hello world"
+height = 768
+width = 1360
+num_inference_steps = 4
+
+# Inference
+image = pipe(prompt, height=height, width=width, num_inference_steps=num_inference_steps).images[0]
+
+# Save the image (optional)
+image.save("cat_with_sign.png")
+
+```

gradio_app.py

@@ -0,0 +1,1336 @@
+import os
+import gradio as gr
+from dotenv import load_dotenv
+import google.generativeai as genai
+from auto_diffusers import AutoDiffusersGenerator
+from simple_memory_calculator import SimpleMemoryCalculator
+
+load_dotenv()
+
+class GradioAutodiffusers:
+    def __init__(self):
+        self.api_key = os.getenv('GOOGLE_API_KEY')
+        if not self.api_key:
+            raise ValueError("GOOGLE_API_KEY not found in .env file")
+        
+        self.generator = AutoDiffusersGenerator(self.api_key)
+        self.memory_calculator = SimpleMemoryCalculator()
+        
+        # Default settings
+        self.current_model = 'gemini-2.5-flash-preview-05-20'
+        self.temperature = 0.7
+        self.max_output_tokens = 8192
+        self.top_p = 0.9
+        self.top_k = 40
+    
+    def update_model_settings(self, model_name, temperature, max_output_tokens, top_p, top_k):
+        """Update Gemini model settings."""
+        self.current_model = model_name
+        self.temperature = temperature
+        self.max_output_tokens = max_output_tokens
+        self.top_p = top_p
+        self.top_k = top_k
+        
+        # Update the generator's model with new settings
+        genai.configure(api_key=self.api_key)
+        generation_config = genai.types.GenerationConfig(
+            temperature=temperature,
+            max_output_tokens=max_output_tokens,
+            top_p=top_p,
+            top_k=top_k
+        )
+        self.generator.model = genai.GenerativeModel(model_name, generation_config=generation_config)
+        
+        return f"✅ Model updated to {model_name} with new settings"
+    
+    def get_generation_prompt(self, model_name, prompt_text, image_size, num_inference_steps, hardware_specs, optimization_profile):
+        """Get the actual prompt that will be sent to Gemini API."""
+        return self.generator._create_generation_prompt(
+            model_name, prompt_text, image_size, num_inference_steps, 
+            hardware_specs, optimization_profile
+        )
+    
+    def analyze_model_memory(self, model_name, vram_gb):
+        """Analyze model memory requirements and provide recommendations."""
+        try:
+            if not vram_gb:
+                vram_gb = 8  # Default
+            
+            memory_info = self.memory_calculator.get_model_memory_requirements(model_name)
+            recommendations = self.memory_calculator.get_memory_recommendation(model_name, float(vram_gb))
+            formatted_info = self.memory_calculator.format_memory_info(model_name)
+            
+            return memory_info, recommendations, formatted_info
+            
+        except Exception as e:
+            error_msg = f"Error analyzing model memory: {str(e)}"
+            return {'error': error_msg}, {'error': error_msg}, error_msg
+    
+    def generate_code_with_manual_specs(self,
+                                      gpu_name, 
+                                      vram_gb, 
+                                      ram_gb, 
+                                      platform,
+                                      model_name,
+                                      prompt_text,
+                                      dtype_selection,
+                                      width,
+                                      height,
+                                      inference_steps,
+                                      memory_analysis=None):
+        """Generate optimized code with manual hardware specifications."""
+        
+        try:
+            # Create manual hardware specs
+            # Parse dtype selection
+            if dtype_selection == "Auto (Let AI decide)":
+                user_dtype = None
+            else:
+                user_dtype = dtype_selection
+            
+            manual_specs = {
+                'platform': platform,
+                'architecture': 'manual_input',
+                'cpu_count': 8,  # Default
+                'python_version': '3.11',
+                'cuda_available': 'nvidia' in gpu_name.lower() if gpu_name else False,
+                'mps_available': platform == 'Darwin' and 'apple' in gpu_name.lower() if gpu_name else False,
+                'torch_version': '2.0+',
+                'manual_input': True,
+                'ram_gb': int(ram_gb) if ram_gb else 16,
+                'user_dtype': user_dtype
+            }
+            
+            # Add GPU info if provided
+            if gpu_name and vram_gb:
+                manual_specs['gpu_info'] = [{
+                    'name': gpu_name,
+                    'memory_mb': int(vram_gb) * 1024
+                }]
+                
+                if 'nvidia' in gpu_name.lower():
+                    manual_specs['cuda_available'] = True
+                    manual_specs['cuda_device_count'] = 1
+                    manual_specs['cuda_device_name'] = gpu_name
+                    manual_specs['cuda_memory'] = int(vram_gb)
+            else:
+                manual_specs['gpu_info'] = None
+            
+            # Generate optimized code with manual specs and memory analysis
+            optimized_code = self.generator.generate_optimized_code(
+                model_name=model_name,
+                prompt_text=prompt_text,
+                image_size=(int(height), int(width)),
+                num_inference_steps=int(inference_steps),
+                use_manual_specs=True,
+                manual_specs=manual_specs,
+                memory_analysis=memory_analysis
+            )
+            
+            # Clean up any markdown formatting
+            if optimized_code.startswith('```python'):
+                optimized_code = optimized_code[9:]
+            if optimized_code.endswith('```'):
+                optimized_code = optimized_code[:-3]
+            
+            return optimized_code.strip()
+            
+        except Exception as e:
+            return f"Error generating code: {str(e)}"
+    
+
+def create_gradio_interface():
+    """Create and configure the Gradio interface."""
+    
+    app = GradioAutodiffusers()
+    
+    with gr.Blocks(
+        title="Auto-Diffusers Code Generator", 
+        theme=gr.themes.Soft(
+            primary_hue="violet",
+            secondary_hue="blue",
+            neutral_hue="slate",
+            radius_size=gr.themes.sizes.radius_lg,
+            font=[gr.themes.GoogleFont("Poppins"), gr.themes.GoogleFont("Inter"), "system-ui", "sans-serif"]
+        ).set(
+            background_fill_primary="*neutral_25",
+            background_fill_secondary="*neutral_50",
+            block_background_fill="rgba(255, 255, 255, 0.95)",
+            block_border_width="0px",
+            block_shadow="0 8px 32px rgba(0, 0, 0, 0.08)",
+            panel_background_fill="rgba(255, 255, 255, 0.9)",
+            button_primary_background_fill="*primary_500",
+            button_primary_background_fill_hover="*primary_600",
+            button_secondary_background_fill="rgba(255, 255, 255, 0.8)",
+            button_secondary_background_fill_hover="rgba(255, 255, 255, 0.95)"
+        ),
+        css="""
+        /* Global Styles */
+        .gradio-container {
+            background: linear-gradient(135deg, 
+                #667eea 0%, 
+                #764ba2 25%, 
+                #f093fb 50%, 
+                #f5576c 75%, 
+                #4facfe 100%) !important;
+            min-height: 100vh;
+        }
+        
+        .main-container {
+            max-width: 1400px;
+            margin: 0 auto;
+            padding: 2rem;
+            /* Removed position: relative that can interfere with dropdown positioning */
+        }
+        
+        /* Floating Background Elements */
+        .main-container::before {
+            content: '';
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: 
+                radial-gradient(circle at 20% 20%, rgba(255, 255, 255, 0.1) 0%, transparent 50%),
+                radial-gradient(circle at 80% 80%, rgba(255, 255, 255, 0.1) 0%, transparent 50%),
+                radial-gradient(circle at 40% 70%, rgba(124, 58, 237, 0.1) 0%, transparent 50%);
+            pointer-events: none;
+            z-index: -1;
+        }
+        
+        /* Glass Morphism Effects - Fixed for Dropdown Compatibility */
+        .glass-card {
+            background: rgba(255, 255, 255, 0.25) !important;
+            border: 1px solid rgba(255, 255, 255, 0.2) !important;
+            border-radius: 20px !important;
+            box-shadow: 
+                0 8px 32px rgba(0, 0, 0, 0.1),
+                inset 0 1px 0 rgba(255, 255, 255, 0.2) !important;
+            /* Removed backdrop-filter and transforms that break dropdown positioning */
+        }
+        
+        .ultra-glass {
+            background: rgba(255, 255, 255, 0.15) !important;
+            border: 1px solid rgba(255, 255, 255, 0.3) !important;
+            border-radius: 24px !important;
+            box-shadow: 
+                0 12px 40px rgba(0, 0, 0, 0.15),
+                inset 0 1px 0 rgba(255, 255, 255, 0.3) !important;
+            /* Removed backdrop-filter that interferes with dropdown positioning */
+        }
+        
+        /* Premium Header */
+        .hero-header {
+            background: linear-gradient(135deg, 
+                rgba(124, 58, 237, 0.9) 0%, 
+                rgba(236, 72, 153, 0.9) 50%, 
+                rgba(59, 130, 246, 0.9) 100%) !important;
+            backdrop-filter: blur(20px) !important;
+            border: 1px solid rgba(255, 255, 255, 0.2) !important;
+            border-radius: 24px !important;
+            box-shadow: 
+                0 20px 60px rgba(124, 58, 237, 0.3),
+                inset 0 1px 0 rgba(255, 255, 255, 0.2) !important;
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .hero-header::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: -100%;
+            width: 100%;
+            height: 100%;
+            background: linear-gradient(90deg, 
+                transparent, 
+                rgba(255, 255, 255, 0.2), 
+                transparent);
+            animation: shimmer 3s infinite;
+        }
+        
+        @keyframes shimmer {
+            0% { left: -100%; }
+            50% { left: 100%; }
+            100% { left: 100%; }
+        }
+        
+        /* Premium Buttons */
+        .generate-btn {
+            background: linear-gradient(135deg, 
+                #667eea 0%, 
+                #764ba2 50%, 
+                #f093fb 100%) !important;
+            border: none !important;
+            color: white !important;
+            font-weight: 700 !important;
+            font-size: 1.1rem !important;
+            padding: 1rem 3rem !important;
+            border-radius: 16px !important;
+            box-shadow: 
+                0 8px 32px rgba(102, 126, 234, 0.4),
+                inset 0 1px 0 rgba(255, 255, 255, 0.2) !important;
+            transition: all 0.4s cubic-bezier(0.175, 0.885, 0.32, 1.275) !important;
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .generate-btn::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: -100%;
+            width: 100%;
+            height: 100%;
+            background: linear-gradient(90deg, 
+                transparent, 
+                rgba(255, 255, 255, 0.3), 
+                transparent);
+            transition: left 0.5s;
+        }
+        
+        .generate-btn:hover::before {
+            left: 100%;
+        }
+        
+        .generate-btn:hover {
+            transform: translateY(-4px) scale(1.02) !important;
+            box-shadow: 
+                0 16px 48px rgba(102, 126, 234, 0.6),
+                inset 0 1px 0 rgba(255, 255, 255, 0.3) !important;
+        }
+        
+        .generate-btn:active {
+            transform: translateY(-2px) scale(1.01) !important;
+        }
+        
+        /* Section Headers */
+        .section-header {
+            background: linear-gradient(135deg, 
+                rgba(255, 255, 255, 0.9) 0%, 
+                rgba(248, 250, 252, 0.9) 100%) !important;
+            backdrop-filter: blur(10px) !important;
+            border: 1px solid rgba(255, 255, 255, 0.4) !important;
+            border-radius: 16px !important;
+            padding: 1.5rem !important;
+            margin-bottom: 1.5rem !important;
+            box-shadow: 
+                0 4px 20px rgba(0, 0, 0, 0.08),
+                inset 0 1px 0 rgba(255, 255, 255, 0.4) !important;
+        }
+        
+        /* Premium Inputs - Simplified for Dropdown Compatibility */
+        input[type="text"], 
+        input[type="number"], 
+        textarea {
+            background: rgba(255, 255, 255, 0.9) !important;
+            border: 1px solid rgba(255, 255, 255, 0.3) !important;
+            border-radius: 12px !important;
+            padding: 0.75rem 1rem !important;
+            font-weight: 500 !important;
+            transition: all 0.3s ease !important;
+        }
+        
+        input[type="text"]:focus, 
+        input[type="number"]:focus, 
+        textarea:focus {
+            background: rgba(255, 255, 255, 0.95) !important;
+            border-color: rgba(124, 58, 237, 0.5) !important;
+            box-shadow: 
+                0 0 0 4px rgba(124, 58, 237, 0.1),
+                0 4px 20px rgba(124, 58, 237, 0.2) !important;
+        }
+        
+        /* CRITICAL: Reset all problematic CSS for dropdowns */
+        label:has(+ [data-testid="dropdown"]),
+        div:has([data-testid="dropdown"]),
+        [data-testid="dropdown"],
+        [data-testid="dropdown"] *,
+        .gradio-dropdown,
+        .gradio-dropdown * {
+            position: static !important;
+            transform: none !important;
+            backdrop-filter: none !important;
+            filter: none !important;
+        }
+        
+        /* AGGRESSIVE FIX: Override ALL possible transparency sources */
+        * {
+            --dropdown-bg: #ffffff !important;
+            --dropdown-opacity: 1 !important;
+        }
+        
+        /* Target every possible dropdown element with maximum specificity */
+        .gradio-container [data-testid="dropdown"] div[role="listbox"],
+        .gradio-container .gradio-dropdown .dropdown-content,
+        .gradio-container .dropdown-menu,
+        .gradio-container div[role="listbox"],
+        .gradio-container .svelte-1gfkn6j,
+        body [data-testid="dropdown"] div[role="listbox"],
+        body .dropdown-menu,
+        body div[role="listbox"],
+        html [data-testid="dropdown"] div[role="listbox"] {
+            background: #ffffff !important;
+            background-color: #ffffff !important;
+            opacity: 1 !important;
+            position: absolute !important;
+            z-index: 99999 !important;
+            border: 2px solid #d1d5db !important;
+            border-radius: 8px !important;
+            box-shadow: 0 8px 24px rgba(0, 0, 0, 0.25) !important;
+            max-height: 200px !important;
+            overflow-y: auto !important;
+            backdrop-filter: none !important;
+            filter: none !important;
+            background-image: none !important;
+            background-blend-mode: normal !important;
+            /* Force solid with CSS variables */
+            background: var(--dropdown-bg, #ffffff) !important;
+            opacity: var(--dropdown-opacity, 1) !important;
+        }
+        
+        /* Aggressive option styling */
+        .gradio-container [data-testid="dropdown"] div[role="listbox"] > *,
+        .gradio-container .dropdown-menu > *,
+        .gradio-container div[role="listbox"] > *,
+        body [data-testid="dropdown"] div[role="listbox"] > *,
+        body .dropdown-menu > *,
+        body div[role="listbox"] > * {
+            background: #ffffff !important;
+            background-color: #ffffff !important;
+            padding: 0.75rem 1rem !important;
+            color: #1f2937 !important;
+            cursor: pointer !important;
+            opacity: 1 !important;
+            border: none !important;
+            margin: 0 !important;
+            display: block !important;
+            width: 100% !important;
+            text-align: left !important;
+        }
+        
+        /* Ensure dropdown menus appear correctly with SOLID background */
+        [data-testid="dropdown"] div[role="listbox"],
+        .gradio-dropdown .dropdown-content,
+        .dropdown-menu,
+        div[role="listbox"],
+        .svelte-1gfkn6j,
+        .gradio-container div[role="listbox"] {
+            position: absolute !important;
+            z-index: 9999 !important;
+            background: #ffffff !important;
+            background-color: #ffffff !important;
+            opacity: 1 !important;
+            border: 1px solid #d1d5db !important;
+            border-radius: 8px !important;
+            box-shadow: 0 4px 16px rgba(0, 0, 0, 0.15) !important;
+            max-height: 200px !important;
+            overflow-y: auto !important;
+            backdrop-filter: none !important;
+            /* Force solid background */
+            background-image: none !important;
+            background-blend-mode: normal !important;
+        }
+        
+        /* Dropdown option styling - SOLID background for each option */
+        [data-testid="dropdown"] div[role="listbox"] > *,
+        .dropdown-menu > *,
+        div[role="listbox"] > *,
+        .svelte-1gfkn6j > * {
+            background: #ffffff !important;
+            background-color: #ffffff !important;
+            padding: 0.5rem 0.75rem !important;
+            color: #374151 !important;
+            cursor: pointer !important;
+            transition: background-color 0.2s ease !important;
+            opacity: 1 !important;
+        }
+        
+        /* Dropdown option hover effect */
+        [data-testid="dropdown"] div[role="listbox"] > *:hover,
+        .dropdown-menu > *:hover,
+        div[role="listbox"] > *:hover {
+            background: #f3f4f6 !important;
+            color: #1f2937 !important;
+        }
+        
+        /* Dropdown option selected state */
+        [data-testid="dropdown"] div[role="listbox"] > *[aria-selected="true"],
+        .dropdown-menu > *.selected,
+        div[role="listbox"] > *[aria-selected="true"] {
+            background: #e0e7ff !important;
+            color: #3730a3 !important;
+        }
+        
+        
+        /* Code Areas - Ultra Premium Styling */
+        .code-container {
+            background: linear-gradient(145deg, 
+                rgba(15, 23, 42, 0.98) 0%,
+                rgba(30, 41, 59, 0.95) 50%,
+                rgba(15, 23, 42, 0.98) 100%) !important;
+            backdrop-filter: blur(30px) !important;
+            border: 2px solid transparent !important;
+            background-clip: padding-box !important;
+            border-radius: 20px !important;
+            position: relative !important;
+            overflow: hidden !important;
+            box-shadow: 
+                0 20px 60px rgba(0, 0, 0, 0.4),
+                0 8px 32px rgba(15, 23, 42, 0.3),
+                inset 0 1px 0 rgba(255, 255, 255, 0.1),
+                inset 0 -1px 0 rgba(71, 85, 105, 0.2) !important;
+        }
+        
+        .code-container::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: linear-gradient(45deg, 
+                rgba(99, 102, 241, 0.1) 0%,
+                rgba(139, 92, 246, 0.1) 25%,
+                rgba(59, 130, 246, 0.1) 50%,
+                rgba(139, 92, 246, 0.1) 75%,
+                rgba(99, 102, 241, 0.1) 100%) !important;
+            border-radius: 20px !important;
+            z-index: -1 !important;
+            animation: code-shimmer 3s ease-in-out infinite !important;
+        }
+        
+        @keyframes code-shimmer {
+            0%, 100% { opacity: 0.3; }
+            50% { opacity: 0.6; }
+        }
+        
+        /* Code editor styling */
+        .code-container .cm-editor {
+            background: transparent !important;
+            border-radius: 16px !important;
+            font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', 'Fira Code', monospace !important;
+            font-size: 13px !important;
+            line-height: 1.6 !important;
+        }
+        
+        .code-container .cm-focused {
+            outline: none !important;
+            box-shadow: 0 0 0 2px rgba(99, 102, 241, 0.4) !important;
+        }
+        
+        .code-container .cm-content {
+            padding: 1.5rem !important;
+            color: #e2e8f0 !important;
+        }
+        
+        .code-container .cm-line {
+            padding-left: 0.5rem !important;
+        }
+        
+        /* Syntax highlighting for Python */
+        .code-container .cm-keyword { color: #f472b6 !important; }
+        .code-container .cm-string { color: #34d399 !important; }
+        .code-container .cm-comment { color: #94a3b8 !important; font-style: italic !important; }
+        .code-container .cm-number { color: #fbbf24 !important; }
+        .code-container .cm-variable { color: #60a5fa !important; }
+        .code-container .cm-function { color: #a78bfa !important; }
+        .code-container .cm-operator { color: #fb7185 !important; }
+        
+        /* Code header styling */
+        .code-container label {
+            background: linear-gradient(90deg, 
+                rgba(99, 102, 241, 0.9) 0%,
+                rgba(139, 92, 246, 0.9) 50%,
+                rgba(59, 130, 246, 0.9) 100%) !important;
+            color: white !important;
+            padding: 1rem 1.5rem !important;
+            border-radius: 16px 16px 0 0 !important;
+            font-weight: 600 !important;
+            font-size: 1rem !important;
+            letter-spacing: 0.025em !important;
+            text-shadow: 0 2px 4px rgba(0, 0, 0, 0.3) !important;
+            margin: 0 !important;
+            border: none !important;
+            box-shadow: 0 4px 12px rgba(99, 102, 241, 0.2) !important;
+        }
+        
+        
+        /* Custom scrollbar for code area */
+        .code-container .cm-scroller::-webkit-scrollbar {
+            width: 8px !important;
+            height: 8px !important;
+        }
+        
+        .code-container .cm-scroller::-webkit-scrollbar-track {
+            background: rgba(15, 23, 42, 0.3) !important;
+            border-radius: 4px !important;
+        }
+        
+        .code-container .cm-scroller::-webkit-scrollbar-thumb {
+            background: linear-gradient(135deg, 
+                rgba(99, 102, 241, 0.6) 0%,
+                rgba(139, 92, 246, 0.6) 100%) !important;
+            border-radius: 4px !important;
+            border: 1px solid rgba(255, 255, 255, 0.1) !important;
+        }
+        
+        .code-container .cm-scroller::-webkit-scrollbar-thumb:hover {
+            background: linear-gradient(135deg, 
+                rgba(99, 102, 241, 0.8) 0%,
+                rgba(139, 92, 246, 0.8) 100%) !important;
+        }
+        
+        /* Line numbers styling */
+        .code-container .cm-lineNumbers {
+            background: rgba(15, 23, 42, 0.3) !important;
+            color: rgba(148, 163, 184, 0.6) !important;
+            border-right: 1px solid rgba(71, 85, 105, 0.3) !important;
+            padding-right: 0.5rem !important;
+        }
+        
+        .code-container .cm-lineNumbers .cm-gutterElement {
+            color: rgba(148, 163, 184, 0.5) !important;
+            font-weight: 500 !important;
+        }
+        
+        /* Memory Analysis Cards */
+        .memory-card {
+            background: linear-gradient(135deg, 
+                rgba(251, 191, 36, 0.1) 0%, 
+                rgba(245, 158, 11, 0.1) 100%) !important;
+            backdrop-filter: blur(15px) !important;
+            border: 1px solid rgba(251, 191, 36, 0.2) !important;
+            border-radius: 16px !important;
+            padding: 1.5rem !important;
+            box-shadow: 
+                0 8px 32px rgba(245, 158, 11, 0.1),
+                inset 0 1px 0 rgba(255, 255, 255, 0.2) !important;
+        }
+        
+        /* Labels with icons */
+        label {
+            font-weight: 600 !important;
+            color: rgba(30, 41, 59, 0.9) !important;
+            font-size: 0.95rem !important;
+        }
+        
+        /* Floating Animation */
+        @keyframes float {
+            0%, 100% { transform: translateY(0px); }
+            50% { transform: translateY(-10px); }
+        }
+        
+        .floating {
+            animation: float 6s ease-in-out infinite;
+        }
+        
+        /* Pulse Effect */
+        @keyframes pulse-glow {
+            0%, 100% { 
+                box-shadow: 
+                    0 8px 32px rgba(102, 126, 234, 0.4),
+                    inset 0 1px 0 rgba(255, 255, 255, 0.2);
+            }
+            50% { 
+                box-shadow: 
+                    0 12px 48px rgba(102, 126, 234, 0.6),
+                    inset 0 1px 0 rgba(255, 255, 255, 0.3);
+            }
+        }
+        
+        .pulse-glow {
+            animation: pulse-glow 3s ease-in-out infinite;
+        }
+        
+        /* FINAL OVERRIDE: Nuclear option for dropdown transparency */
+        [role="listbox"] {
+            background: white !important;
+            opacity: 1 !important;
+        }
+        
+        [role="listbox"] > * {
+            background: white !important;
+            opacity: 1 !important;
+        }
+        
+        /* Gradio-specific nuclear option */
+        .gradio-app [role="listbox"],
+        .gradio-app [role="listbox"] > * {
+            background: #ffffff !important;
+            background-color: #ffffff !important;
+            opacity: 1 !important;
+        }
+        
+        /* Last resort: override all possible transparent backgrounds */
+        div[style*="background"] {
+            background: unset !important;
+        }
+        
+        [role="listbox"][style*="background"] {
+            background: #ffffff !important;
+        }
+        """
+    ) as interface:
+        
+        with gr.Column(elem_classes="main-container"):
+            # Ultra Premium Header
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.HTML("""
+                    <div class="hero-header floating" style="text-align: center; padding: 3rem 2rem; margin-bottom: 3rem; position: relative;">
+                        <div style="position: relative; z-index: 2;">
+                            <h1 style="color: white; font-size: 3.5rem; margin: 0; font-weight: 800; text-shadow: 0 4px 8px rgba(0,0,0,0.3); letter-spacing: -0.02em; background: linear-gradient(135deg, #ffffff 0%, #f8fafc 50%, #e2e8f0 100%); -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;">
+                                ✨ Auto-Diffusers
+                            </h1>
+                            <h2 style="color: rgba(255,255,255,0.95); font-size: 1.8rem; margin: 0.5rem 0 1rem 0; font-weight: 600; text-shadow: 0 2px 4px rgba(0,0,0,0.2);">
+                                Code Generator
+                            </h2>
+                            <p style="color: rgba(255,255,255,0.9); font-size: 1.2rem; margin: 0; font-weight: 400; text-shadow: 0 2px 4px rgba(0,0,0,0.2); max-width: 600px; margin: 0 auto; line-height: 1.6;">
+                                Generate stunning, optimized diffusers code tailored perfectly for your hardware using advanced AI
+                            </p>
+                            <div style="margin-top: 2rem;">
+                                <span style="display: inline-block; background: rgba(255,255,255,0.2); padding: 0.5rem 1rem; border-radius: 20px; color: white; font-size: 0.9rem; backdrop-filter: blur(10px); border: 1px solid rgba(255,255,255,0.3);">
+                                    🤖 Powered by Google Gemini 2.5
+                                </span>
+                            </div>
+                        </div>
+                    </div>
+                    """)
+        
+        # Main Content Area
+        
+        # Hardware Selection Section
+        with gr.Group(elem_classes="glass-card"):
+            gr.HTML("""
+            <div class="section-header" style="text-align: center;">
+                <h3 style="margin: 0 0 0.5rem 0; color: #1e293b; font-size: 1.5rem; font-weight: 700;">
+                    ⚙️ Hardware Specifications
+                </h3>
+                <p style="margin: 0; color: #64748b; font-size: 1rem; font-weight: 500;">
+                    Configure your system hardware for optimal code generation
+                </p>
+            </div>
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    platform = gr.Dropdown(
+                        choices=["Linux", "Darwin", "Windows"],
+                        label="🖥️ Platform",
+                        value="Linux",
+                        info="Your operating system"
+                    )
+                    
+                    gpu_vendor = gr.Dropdown(
+                        choices=[
+                            "Custom (Manual Input)",
+                            "NVIDIA Consumer (GeForce RTX)",
+                            "NVIDIA Professional (RTX A-Series)", 
+                            "NVIDIA Data Center",
+                            "Apple Silicon",
+                            "AMD",
+                            "Intel",
+                            "CPU Only"
+                        ],
+                        label="🎮 GPU Vendor/Category",
+                        value="Custom (Manual Input)",
+                        info="Select your GPU category"
+                    )
+                    
+                    gpu_series = gr.Dropdown(
+                        choices=[],
+                        label="📊 GPU Series",
+                        visible=False,
+                        interactive=True,
+                        info="Choose your GPU series"
+                    )
+                    
+                    gpu_model = gr.Dropdown(
+                        choices=[],
+                        label="🔧 GPU Model",
+                        visible=False,
+                        interactive=True,
+                        info="Select your specific GPU model"
+                    )
+                    
+                    gpu_name_custom = gr.Textbox(
+                        label="💾 Custom GPU Name",
+                        placeholder="e.g., RTX 4090, GTX 1080 Ti",
+                        visible=True,
+                        info="Enter your GPU name manually"
+                    )
+                    
+                    gpu_name = gr.Textbox(
+                        label="Selected GPU",
+                        visible=False
+                    )
+                
+                with gr.Column(scale=1):
+                    vram_gb = gr.Number(
+                        label="🎯 VRAM/Memory (GB)",
+                        value=8,
+                        minimum=0,
+                        maximum=200,
+                        info="GPU memory available"
+                    )
+                    ram_gb = gr.Number(
+                        label="💻 System RAM (GB)",
+                        value=16,
+                        minimum=4,
+                        maximum=256,
+                        info="Total system memory"
+                    )
+                
+        # Model Configuration Section
+        with gr.Group(elem_classes="glass-card"):
+            gr.HTML("""
+            <div class="section-header" style="text-align: center;">
+                <h3 style="margin: 0 0 0.5rem 0; color: #1e293b; font-size: 1.5rem; font-weight: 700;">
+                    🤖 Model Configuration
+                </h3>
+                <p style="margin: 0; color: #64748b; font-size: 1rem; font-weight: 500;">
+                    Configure the AI model and generation parameters
+                </p>
+            </div>
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    model_name = gr.Textbox(
+                        label="🏷️ Model Name",
+                        value="black-forest-labs/FLUX.1-schnell",
+                        placeholder="e.g., black-forest-labs/FLUX.1-schnell",
+                        info="HuggingFace model identifier"
+                    )
+                    
+                    dtype_selection = gr.Dropdown(
+                        choices=["Auto (Let AI decide)", "torch.float32", "torch.float16", "torch.bfloat16"],
+                        label="⚡ Data Type (dtype)",
+                        value="Auto (Let AI decide)",
+                        info="Precision mode - Auto is recommended"
+                    )
+                
+                with gr.Column(scale=1):
+                    with gr.Row():
+                        width = gr.Number(
+                            label="📏 Width (px)",
+                            value=1360,
+                            minimum=256,
+                            maximum=2048,
+                            step=64,
+                            info="Image width"
+                        )
+                        height = gr.Number(
+                            label="📐 Height (px)", 
+                            value=768,
+                            minimum=256,
+                            maximum=2048,
+                            step=64,
+                            info="Image height"
+                        )
+                    
+                    inference_steps = gr.Number(
+                        label="🔄 Inference Steps",
+                        value=4,
+                        minimum=1,
+                        maximum=50,
+                        info="Number of denoising steps (higher = better quality, slower)"
+                    )
+                
+        # Memory Analysis Section
+        with gr.Group(elem_classes="ultra-glass"):
+            gr.HTML("""
+            <div class="section-header" style="text-align: center;">
+                <h3 style="margin: 0 0 0.5rem 0; color: #1e293b; font-size: 1.5rem; font-weight: 700;">
+                    🧠 Memory Analysis
+                </h3>
+                <p style="margin: 0; color: #64748b; font-size: 1rem; font-weight: 500;">
+                    Real-time analysis of model memory requirements and optimization strategies
+                </p>
+            </div>
+            """)
+            
+            memory_analysis_output = gr.Markdown(
+                value="✨ Select a model and configure your hardware to see memory requirements and optimization recommendations.",
+                elem_classes="memory-card"
+            )
+                
+        # Generate Button
+        with gr.Row():
+            with gr.Column():
+                gr.HTML("""
+                <div style="text-align: center; margin: 2rem 0;">
+                </div>
+                """)
+                generate_btn = gr.Button(
+                    "✨ Generate Optimized Code", 
+                    variant="primary", 
+                    size="lg",
+                    elem_classes="generate-btn pulse-glow"
+                )
+                
+        # Generated Code Section
+        with gr.Group(elem_classes="ultra-glass"):
+            gr.HTML("""
+            <div class="section-header" style="text-align: center; position: relative; overflow: hidden;">
+                <div style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; background: linear-gradient(45deg, rgba(99, 102, 241, 0.1), rgba(139, 92, 246, 0.1)); border-radius: 16px; z-index: -1;"></div>
+                <h3 style="margin: 0 0 0.5rem 0; color: #1e293b; font-size: 1.5rem; font-weight: 700; text-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+                    💻 Generated Code
+                </h3>
+                <p style="margin: 0; color: #64748b; font-size: 1rem; font-weight: 500;">
+                    ✨ Ultra-optimized Python code with hardware-specific acceleration
+                </p>
+                <div style="margin-top: 1rem; padding: 0.75rem 1.5rem; background: linear-gradient(90deg, rgba(34, 197, 94, 0.1), rgba(59, 130, 246, 0.1)); border-radius: 12px; border: 1px solid rgba(34, 197, 94, 0.2);">
+                    <span style="color: #059669; font-weight: 600; font-size: 0.9rem;">
+                        🚀 Ready-to-run • Memory optimized • Performance tuned
+                    </span>
+                </div>
+            </div>
+            """)
+            
+            # Code Summary
+            code_summary = gr.Markdown(
+                value="🎯 Generated code summary will appear here after generation.",
+                elem_classes="memory-card"
+            )
+            
+            # Code Output
+            code_output = gr.Code(
+                label="🚀 Hardware-Optimized Diffusion Pipeline",
+                language="python",
+                lines=20,
+                interactive=True,
+                show_label=True,
+                elem_classes="code-container",
+                value="# 🎨 Your optimized diffusion code will appear here after generation\n# Click 'Generate Optimized Code' to create hardware-specific Python code\n\nprint('✨ Ready to generate amazing AI art with optimized performance!')"
+            )
+                
+        def on_gpu_vendor_change(vendor):
+            """Handle GPU vendor selection and update series dropdown."""
+            if vendor == "Custom (Manual Input)":
+                return (gr.update(visible=True), 
+                        gr.update(visible=False, choices=[]), 
+                        gr.update(visible=False, choices=[]),
+                        "", gr.update())
+            elif vendor == "CPU Only":
+                return (gr.update(visible=False), 
+                        gr.update(visible=False, choices=[]), 
+                        gr.update(visible=False, choices=[]),
+                        "", 0)
+            elif vendor == "NVIDIA Consumer (GeForce RTX)":
+                return (gr.update(visible=False), 
+                        gr.update(visible=True, choices=["RTX 50 Series", "RTX 40 Series", "RTX 30 Series"]), 
+                        gr.update(visible=False, choices=[]),
+                        "", gr.update())
+            elif vendor == "NVIDIA Professional (RTX A-Series)":
+                return (gr.update(visible=False), 
+                        gr.update(visible=True, choices=["RTX A6000 Series", "RTX A5000 Series", "RTX A4000 Series"]), 
+                        gr.update(visible=False, choices=[]),
+                        "", gr.update())
+            elif vendor == "NVIDIA Data Center":
+                return (gr.update(visible=False), 
+                        gr.update(visible=True, choices=["Blackwell (B-Series)", "Hopper (H-Series)", "Ada Lovelace (L-Series)", "Ampere (A-Series)", "Volta/Tesla"]), 
+                        gr.update(visible=False, choices=[]),
+                        "", gr.update())
+            elif vendor == "Apple Silicon":
+                return (gr.update(visible=False), 
+                        gr.update(visible=True, choices=["M4 Series", "M3 Series", "M2 Series", "M1 Series"]), 
+                        gr.update(visible=False, choices=[]),
+                        "", gr.update())
+            elif vendor == "AMD":
+                return (gr.update(visible=False), 
+                        gr.update(visible=True, choices=["Radeon RX 7000", "Radeon RX 6000", "Instinct MI Series"]), 
+                        gr.update(visible=False, choices=[]),
+                        "", gr.update())
+            elif vendor == "Intel":
+                return (gr.update(visible=False), 
+                        gr.update(visible=True, choices=["Arc A-Series"]), 
+                        gr.update(visible=False, choices=[]),
+                        "", gr.update())
+            else:
+                return (gr.update(visible=True), 
+                        gr.update(visible=False, choices=[]), 
+                        gr.update(visible=False, choices=[]),
+                        "", gr.update())
+
+        def on_gpu_series_change(vendor, series):
+            """Handle GPU series selection and update model dropdown."""
+            models = []
+            
+            if vendor == "NVIDIA Consumer (GeForce RTX)":
+                if series == "RTX 50 Series":
+                    models = ["RTX 5090 (32GB)", "RTX 5080 (16GB)", "RTX 5070 Ti (16GB)", "RTX 5070 (12GB)", "RTX 5060 Ti (16GB)", "RTX 5060 (12GB)"]
+                elif series == "RTX 40 Series":
+                    models = ["RTX 4090 (24GB)", "RTX 4080 Super (16GB)", "RTX 4070 Ti Super (16GB)", "RTX 4070 Super (12GB)", "RTX 4070 (12GB)", "RTX 4060 Ti (16GB)", "RTX 4060 Ti (8GB)", "RTX 4060 (8GB)"]
+                elif series == "RTX 30 Series":
+                    models = ["RTX 3090 Ti (24GB)", "RTX 3090 (24GB)", "RTX 3080 Ti (12GB)", "RTX 3080 (12GB)", "RTX 3080 (10GB)", "RTX 3070 Ti (8GB)", "RTX 3070 (8GB)", "RTX 3060 Ti (8GB)", "RTX 3060 (12GB)"]
+            
+            elif vendor == "NVIDIA Professional (RTX A-Series)":
+                if series == "RTX A6000 Series":
+                    models = ["RTX A6000 (48GB)", "RTX A6000 Ada (48GB)", "RTX 6000 Ada (48GB)"]
+                elif series == "RTX A5000 Series":
+                    models = ["RTX A5000 (24GB)", "RTX A5500 (24GB)", "RTX 5000 Ada (32GB)"]
+                elif series == "RTX A4000 Series":
+                    models = ["RTX A4000 (16GB)", "RTX A4500 (20GB)", "RTX 4000 Ada (20GB)", "RTX 4000 SFF Ada (20GB)"]
+            
+            elif vendor == "NVIDIA Data Center":
+                if series == "Blackwell (B-Series)":
+                    models = ["B200 (192GB)", "B100 (192GB)", "GB200 NVL72 (192GB per GPU)"]
+                elif series == "Hopper (H-Series)":
+                    models = ["H200 (141GB)", "H100 SXM (80GB)", "H100 PCIe (80GB)"]
+                elif series == "Ada Lovelace (L-Series)":
+                    models = ["L40S (48GB)", "L40 (48GB)", "L4 (24GB)"]
+                elif series == "Ampere (A-Series)":
+                    models = ["A100 SXM (80GB)", "A100 PCIe (80GB)", "A100 PCIe (40GB)", "A40 (48GB)", "A30 (24GB)", "A16 (16GB)", "A10 (24GB)"]
+                elif series == "Volta/Tesla":
+                    models = ["V100 SXM2 (32GB)", "V100 PCIe (16GB)", "P100 (16GB)"]
+            
+            elif vendor == "Apple Silicon":
+                if series == "M4 Series":
+                    models = ["M4 Max (128GB Unified)", "M4 Pro (64GB Unified)", "M4 (32GB Unified)"]
+                elif series == "M3 Series":
+                    models = ["M3 Ultra (192GB Unified)", "M3 Max (128GB Unified)", "M3 Pro (36GB Unified)", "M3 (24GB Unified)"]
+                elif series == "M2 Series":
+                    models = ["M2 Ultra (192GB Unified)", "M2 Max (96GB Unified)", "M2 Pro (32GB Unified)", "M2 (24GB Unified)"]
+                elif series == "M1 Series":
+                    models = ["M1 Ultra (128GB Unified)", "M1 Max (64GB Unified)", "M1 Pro (32GB Unified)", "M1 (16GB Unified)"]
+            
+            elif vendor == "AMD":
+                if series == "Radeon RX 7000":
+                    models = ["RX 7900 XTX (24GB)", "RX 7900 XT (20GB)"]
+                elif series == "Radeon RX 6000":
+                    models = ["RX 6900 XT (16GB)"]
+                elif series == "Instinct MI Series":
+                    models = ["Instinct MI300X (192GB)", "Instinct MI250X (128GB)", "Instinct MI100 (32GB)"]
+            
+            elif vendor == "Intel":
+                if series == "Arc A-Series":
+                    models = ["Arc A770 (16GB)", "Arc A750 (8GB)"]
+            
+            return gr.update(visible=True, choices=models)
+
+        def on_gpu_model_change(model):
+            """Handle GPU model selection and auto-fill values."""
+            if not model or model == "":
+                return "", gr.update()
+            
+            # Extract GPU name and VRAM from model
+            if "(" in model and "GB" in model:
+                gpu_name_part = model.split(" (")[0]
+                vram_part = model.split("(")[1].split("GB")[0]
+                try:
+                    vram_value = int(vram_part)
+                except:
+                    vram_value = 8
+                return gpu_name_part, vram_value
+            else:
+                return model, gr.update()
+
+        def get_final_gpu_name(vendor, series, model, custom_name):
+            """Get the final GPU name based on vendor selection or custom input."""
+            if vendor == "Custom (Manual Input)":
+                return custom_name
+            elif vendor == "CPU Only":
+                return ""
+            elif model and "(" in model and "GB" in model:
+                return model.split(" (")[0]
+            elif model:
+                return model
+            else:
+                return custom_name
+                
+        def update_memory_analysis(model_name, vram_gb):
+            """Update memory analysis in real-time based on selections."""
+            if not model_name or not model_name.strip():
+                return "Select a model to see memory requirements."
+            
+            if not vram_gb or vram_gb <= 0:
+                return f"**Model:** {model_name}\n\nConfigure your GPU to see memory analysis."
+            
+            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```"
+                
+                return detailed_error
+                
+        # Connect GPU dropdown change handlers with memory analysis updates
+        gpu_vendor.change(
+            on_gpu_vendor_change,
+            inputs=[gpu_vendor],
+            outputs=[gpu_name_custom, gpu_series, gpu_model, gpu_name, vram_gb]
+        ).then(
+            update_memory_analysis,
+            inputs=[model_name, vram_gb],
+            outputs=memory_analysis_output
+        )
+        
+        gpu_series.change(
+            on_gpu_series_change,
+            inputs=[gpu_vendor, gpu_series],
+            outputs=[gpu_model]
+        )
+        
+        gpu_model.change(
+            on_gpu_model_change,
+            inputs=[gpu_model],
+            outputs=[gpu_name, vram_gb]
+        ).then(
+            update_memory_analysis,
+            inputs=[model_name, vram_gb],
+            outputs=memory_analysis_output
+        )
+        
+        # Update memory analysis when custom GPU name changes
+        gpu_name_custom.change(
+            update_memory_analysis,
+            inputs=[model_name, vram_gb],
+            outputs=memory_analysis_output
+        )
+        
+        # Update memory analysis when model name or VRAM changes
+        model_name.change(
+            update_memory_analysis,
+            inputs=[model_name, vram_gb],
+            outputs=memory_analysis_output
+        )
+        
+        vram_gb.change(
+            update_memory_analysis,
+            inputs=[model_name, vram_gb],
+            outputs=memory_analysis_output
+        )
+        
+        # Load initial memory analysis on startup
+        interface.load(
+            update_memory_analysis,
+            inputs=[model_name, vram_gb],
+            outputs=memory_analysis_output
+        )
+                
+        def create_code_summary(generated_code, model_name, final_gpu_name, vram_gb):
+            """Create a concise summary of the generated code."""
+            if generated_code.startswith("Error"):
+                return "❌ **Code Generation Failed** - See error details in the code output below."
+            
+            # Analyze the generated code to extract key optimizations
+            optimizations = []
+            if "torch.float16" in generated_code or "fp16" in generated_code.lower():
+                optimizations.append("FP16 precision")
+            if "torch.bfloat16" in generated_code or "bf16" in generated_code.lower():
+                optimizations.append("BF16 precision")
+            if "enable_model_cpu_offload" in generated_code:
+                optimizations.append("CPU offloading")
+            if "enable_sequential_cpu_offload" in generated_code:
+                optimizations.append("Sequential CPU offload")
+            if "low_cpu_mem_usage=True" in generated_code:
+                optimizations.append("Low CPU memory usage")
+            if "torch.compile" in generated_code:
+                optimizations.append("Torch compile")
+            if "attention_slicing" in generated_code:
+                optimizations.append("Attention slicing")
+            if "vae_slicing" in generated_code:
+                optimizations.append("VAE slicing")
+            
+            device = "CUDA" if "cuda" in generated_code else "MPS" if "mps" in generated_code else "CPU"
+            
+            summary = f"""
+### ✅ Code Generated Successfully
+
+**Model:** `{model_name}`  
+**Hardware:** {final_gpu_name} ({vram_gb}GB) - {device}  
+**Optimizations:** {', '.join(optimizations) if optimizations else 'Standard configuration'}
+
+**Key Features:**
+- Memory-optimized pipeline loading
+- Hardware-specific device configuration  
+- Performance tuning for your GPU
+- Ready-to-run diffusion code
+"""
+            return summary
+
+        def strip_comments(code):
+            """Remove all comments from the code for collapsed view."""
+            if not code:
+                return code
+            
+            lines = code.split('\n')
+            filtered_lines = []
+            
+            for line in lines:
+                stripped = line.strip()
+                # Skip comment-only lines and empty lines
+                if stripped.startswith('#') or stripped == '':
+                    continue
+                # For lines with inline comments, keep only the code part
+                if '#' in line and not stripped.startswith('#'):
+                    code_part = line.split('#')[0].rstrip()
+                    if code_part.strip():  # Only add if there's actual code
+                        filtered_lines.append(code_part)
+                else:
+                    filtered_lines.append(line)
+            
+            return '\n'.join(filtered_lines)
+
+        def generate_with_combined_gpu_name(gpu_vendor, gpu_series, gpu_model, gpu_name_custom, vram_gb, ram_gb, platform, model_name, dtype_selection, width, height, inference_steps):
+            """Generate code with the correct GPU name from multi-level selection or custom input, including memory analysis."""
+            final_gpu_name = get_final_gpu_name(gpu_vendor, gpu_series, gpu_model, gpu_name_custom)
+            
+            # Constant prompt text
+            prompt_text = "A cat holding a sign that says hello world"
+            
+            # STEP 1: Perform memory analysis BEFORE code generation
+            memory_analysis_data = None
+            memory_header = ""
+            
+            try:
+                if model_name and vram_gb and vram_gb > 0:
+                    memory_info, recommendations, _ = app.analyze_model_memory(model_name, vram_gb)
+                    
+                    # Package memory analysis for Gemini API
+                    memory_analysis_data = {
+                        'memory_info': memory_info,
+                        'recommendations': recommendations
+                    }
+                    
+                    # Create header for the generated code
+                    def get_optimization_strategy(recommendations):
+                        """Generate optimization strategy text based on recommendations."""
+                        strategies = []
+                        
+                        if recommendations.get('cpu_offload'):
+                            strategies.append("CPU offloading")
+                        if recommendations.get('sequential_offload'):
+                            strategies.append("Sequential CPU offload")
+                        if recommendations.get('attention_slicing'):
+                            strategies.append("Attention slicing")
+                        if recommendations.get('vae_slicing'):
+                            strategies.append("VAE slicing")
+                        
+                        precision = recommendations.get('recommended_precision', 'float16')
+                        if precision:
+                            strategies.append(f"{precision} precision")
+                        
+                        if not strategies:
+                            # No special optimizations needed
+                            if recommendations.get('recommendations') and any('Full model can fit' in rec for rec in recommendations.get('recommendations', [])):
+                                return "Full VRAM utilization with optimal performance"
+                            else:
+                                return "Standard optimization"
+                        
+                        return ", ".join(strategies)
+                    
+                    optimization_strategy = get_optimization_strategy(recommendations)
+                    
+                    memory_header = f"""# Memory Analysis for {model_name}:
+# GPU: {final_gpu_name if final_gpu_name else 'Not specified'} ({vram_gb}GB VRAM)
+# Model Memory Requirements: {memory_info.get('estimated_inference_memory_fp16_gb', 'Unknown')} GB
+# Recommendation: {', '.join(recommendations.get('recommendations', ['N/A']))}
+# Optimization Strategy: {optimization_strategy}
+
+"""
+            except Exception as e:
+                memory_header = f"""# Memory Analysis for {model_name}:
+# GPU: {final_gpu_name if final_gpu_name else 'Not specified'} ({vram_gb}GB VRAM)
+# Note: Memory analysis failed - {str(e)}
+
+"""
+            
+            # STEP 2: Generate the optimized code WITH memory analysis information
+            generated_code = app.generate_code_with_manual_specs(
+                final_gpu_name, vram_gb, ram_gb, platform,
+                model_name, prompt_text, dtype_selection, width, height, inference_steps,
+                memory_analysis_data
+            )
+            
+            # STEP 3: Prepend memory analysis header to the generated code
+            final_code = memory_header + generated_code if memory_header and not generated_code.startswith("Error") else generated_code
+            
+            # STEP 4: Create code summary
+            summary = create_code_summary(generated_code, model_name, final_gpu_name, vram_gb)
+            
+            return summary, final_code
+                
+        # Add states for tracking code view and storing full code
+        code_collapsed = gr.State(value=False)
+        full_code_storage = gr.State(value="")
+        
+        def generate_and_store_code(gpu_vendor, gpu_series, gpu_model, gpu_name_custom, vram_gb, ram_gb, platform, model_name, dtype_selection, width, height, inference_steps):
+            """Generate code and return summary, code for display, and full code for storage."""
+            summary, full_code = generate_with_combined_gpu_name(
+                gpu_vendor, gpu_series, gpu_model, gpu_name_custom, vram_gb, ram_gb, platform,
+                model_name, dtype_selection, width, height, inference_steps
+            )
+            return summary, full_code, full_code, False  # summary, display_code, stored_code, reset_collapsed_state
+        
+        generate_btn.click(
+            generate_and_store_code,
+            inputs=[
+                gpu_vendor, gpu_series, gpu_model, gpu_name_custom, vram_gb, ram_gb, platform,
+                model_name, dtype_selection, width, height, inference_steps
+            ],
+            outputs=[code_summary, code_output, full_code_storage, code_collapsed]
+        )
+                
+                
+        
+        # Ultra Premium Footer
+        gr.HTML("""
+        <div class="ultra-glass" style="text-align: center; padding: 3rem 2rem; margin-top: 4rem; position: relative; overflow: hidden;">
+            <div style="position: relative; z-index: 2;">
+                <h4 style="color: #1e293b; font-size: 1.3rem; margin: 0 0 1rem 0; font-weight: 700;">
+                    ✨ Pro Tips & Insights
+                </h4>
+                <p style="color: #475569; font-size: 1rem; margin: 0 0 1.5rem 0; font-weight: 500; line-height: 1.6; max-width: 600px; margin: 0 auto;">
+                    🚀 The generated code includes hardware-specific optimizations for memory efficiency and peak performance<br>
+                    🎯 Fine-tuned for your exact GPU configuration and model requirements
+                </p>
+                <div style="margin-top: 2rem;">
+                    <span style="display: inline-block; background: rgba(124, 58, 237, 0.1); padding: 0.75rem 1.5rem; border-radius: 20px; color: #7c3aed; font-size: 0.9rem; backdrop-filter: blur(10px); border: 1px solid rgba(124, 58, 237, 0.2); margin: 0 0.5rem;">
+                        🤖 Powered by Google Gemini 2.5
+                    </span>
+                    <span style="display: inline-block; background: rgba(236, 72, 153, 0.1); padding: 0.75rem 1.5rem; border-radius: 20px; color: #ec4899; font-size: 0.9rem; backdrop-filter: blur(10px); border: 1px solid rgba(236, 72, 153, 0.2); margin: 0 0.5rem;">
+                        ❤️ Built for the Community
+                    </span>
+                </div>
+            </div>
+        </div>
+        """)
+    
+    return interface
+
+def main():
+    """Launch the Gradio application."""
+    try:
+        interface = create_gradio_interface()
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True,
+            show_error=True
+        )
+    except Exception as e:
+        print(f"Error launching Gradio app: {e}")
+        print("Make sure you have set GOOGLE_API_KEY in your .env file")
+
+if __name__ == "__main__":
+    main()

hardware_detector.py

@@ -0,0 +1,131 @@
+import platform
+import subprocess
+import os
+from typing import Dict, Optional
+
+
+class HardwareDetector:
+    def __init__(self):
+        self.specs = self._detect_system_specs()
+    
+    def _detect_system_specs(self) -> Dict:
+        """Detect system hardware specifications automatically."""
+        specs = {
+            'platform': platform.system(),
+            'architecture': platform.machine(),
+            'cpu_count': os.cpu_count(),
+            'python_version': platform.python_version(),
+            'gpu_info': self._detect_gpu(),
+            'cuda_available': False,
+            'mps_available': False
+        }
+        
+        # Check for PyTorch and device availability
+        try:
+            import torch
+            specs['torch_version'] = torch.__version__
+            specs['cuda_available'] = torch.cuda.is_available()
+            specs['mps_available'] = torch.backends.mps.is_available()
+            
+            if specs['cuda_available']:
+                specs['cuda_device_count'] = torch.cuda.device_count()
+                specs['cuda_device_name'] = torch.cuda.get_device_name(0)
+                specs['cuda_memory'] = torch.cuda.get_device_properties(0).total_memory // (1024**3)
+                
+        except ImportError:
+            specs['torch_version'] = 'Not installed'
+            
+        return specs
+    
+    def _detect_gpu(self) -> Optional[Dict]:
+        """Attempt to detect GPU information using nvidia-smi."""
+        try:
+            result = subprocess.run([
+                'nvidia-smi', 
+                '--query-gpu=name,memory.total', 
+                '--format=csv,noheader,nounits'
+            ], capture_output=True, text=True, check=True)
+            
+            lines = result.stdout.strip().split('\n')
+            gpus = []
+            for line in lines:
+                if line.strip():
+                    name, memory = line.split(', ')
+                    gpus.append({'name': name.strip(), 'memory_mb': int(memory)})
+            return gpus
+            
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return None
+    
+    def get_manual_input(self) -> Dict:
+        """Get hardware specifications via manual user input."""
+        print("Enter your hardware specifications manually:")
+        
+        gpu_name = input("GPU Name (e.g., RTX 4090, A100, leave empty if none): ").strip()
+        if gpu_name:
+            try:
+                vram_gb = int(input("VRAM in GB (e.g., 24): "))
+                gpu_info = [{'name': gpu_name, 'memory_mb': vram_gb * 1024}]
+            except ValueError:
+                gpu_info = None
+        else:
+            gpu_info = None
+            
+        try:
+            ram_gb = int(input("System RAM in GB (e.g., 32): "))
+        except ValueError:
+            ram_gb = 16  # Default
+            
+        specs = self.specs.copy()
+        specs['gpu_info'] = gpu_info
+        specs['ram_gb'] = ram_gb
+        specs['manual_input'] = True
+        
+        return specs
+    
+    def get_optimization_profile(self) -> str:
+        """Determine the best optimization profile based on hardware."""
+        if self.specs['cuda_available']:
+            if self.specs.get('cuda_memory', 0) >= 20:
+                return 'high_end_gpu'
+            elif self.specs.get('cuda_memory', 0) >= 8:
+                return 'mid_range_gpu'
+            else:
+                return 'low_vram_gpu'
+        elif self.specs['mps_available']:
+            return 'apple_silicon'
+        else:
+            return 'cpu_only'
+    
+    def print_specs(self):
+        """Print detected hardware specifications."""
+        print(f"Platform: {self.specs['platform']} ({self.specs['architecture']})")
+        print(f"CPU Cores: {self.specs['cpu_count']}")
+        print(f"Python: {self.specs['python_version']}")
+        print(f"PyTorch: {self.specs.get('torch_version', 'Not detected')}")
+        print(f"CUDA Available: {self.specs['cuda_available']}")
+        print(f"MPS Available: {self.specs['mps_available']}")
+        
+        if self.specs['gpu_info']:
+            print("GPU Information:")
+            for i, gpu in enumerate(self.specs['gpu_info']):
+                vram_gb = gpu['memory_mb'] / 1024
+                print(f"  GPU {i}: {gpu['name']} ({vram_gb:.1f} GB VRAM)")
+        else:
+            print("No GPU detected")
+
+
+if __name__ == "__main__":
+    detector = HardwareDetector()
+    
+    print("=== Auto-detected Hardware ===")
+    detector.print_specs()
+    
+    choice = input("\nUse auto-detected specs? (y/n): ").lower()
+    if choice != 'y':
+        specs = detector.get_manual_input()
+        detector.specs = specs
+        print("\n=== Final Hardware Specs ===")
+        detector.print_specs()
+    
+    print(f"\nRecommended optimization profile: {detector.get_optimization_profile()}")

launch_gradio.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+Simple launcher script for the Gradio app with better error handling.
+"""
+
+import os
+import sys
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+def check_requirements():
+    """Check if all required packages are installed."""
+    required_packages = [
+        'gradio', 'google.generativeai', 'torch', 'psutil'
+    ]
+    
+    missing = []
+    for package in required_packages:
+        try:
+            __import__(package.replace('-', '_'))
+        except ImportError:
+            missing.append(package)
+    
+    if missing:
+        print(f"Missing packages: {', '.join(missing)}")
+        print("Please run: pip install -r requirements.txt")
+        return False
+    return True
+
+def check_api_key():
+    """Check if API key is configured."""
+    api_key = os.getenv('GOOGLE_API_KEY')
+    if not api_key:
+        print("ERROR: GOOGLE_API_KEY not found in .env file")
+        print("Please add your Gemini API key to the .env file:")
+        print("GOOGLE_API_KEY=your_api_key_here")
+        return False
+    return True
+
+def main():
+    print("🚀 Starting Auto-Diffusers Gradio App...")
+    
+    # Check requirements
+    if not check_requirements():
+        sys.exit(1)
+    
+    if not check_api_key():
+        sys.exit(1)
+    
+    try:
+        from gradio_app import create_gradio_interface
+        
+        print("✅ All requirements satisfied")
+        print("🌐 Launching Gradio interface...")
+        
+        interface = create_gradio_interface()
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True,
+            show_error=True,
+            inbrowser=True
+        )
+        
+    except ImportError as e:
+        print(f"Import error: {e}")
+        print("Make sure all dependencies are installed: pip install -r requirements.txt")
+    except Exception as e:
+        print(f"Error launching app: {e}")
+
+if __name__ == "__main__":
+    main()

model_memory_calculator.py

@@ -0,0 +1,244 @@
+import requests
+from huggingface_hub import HfApi
+from typing import Dict, Optional, Tuple
+import json
+
+
+class ModelMemoryCalculator:
+    def __init__(self):
+        self.hf_api = HfApi()
+        self.cache = {}  # Cache results to avoid repeated API calls
+        
+    def get_model_memory_requirements(self, model_id: str) -> Dict:
+        """
+        Calculate memory requirements for a given HuggingFace model.
+        
+        Args:
+            model_id: HuggingFace model identifier (e.g., "black-forest-labs/FLUX.1-schnell")
+            
+        Returns:
+            Dict with memory information including:
+            - total_params: Total parameter count
+            - memory_fp32: Memory in GB at FP32 precision
+            - memory_fp16: Memory in GB at FP16 precision
+            - memory_bf16: Memory in GB at BF16 precision
+            - safetensors_files: List of safetensor files and their sizes
+        """
+        
+        if model_id in self.cache:
+            return self.cache[model_id]
+            
+        try:
+            print(f"Fetching model info for {model_id}...")
+            
+            # Get model info
+            model_info = self.hf_api.model_info(model_id)
+            print(f"Model info retrieved successfully")
+            
+            # Get safetensors metadata
+            print(f"Fetching safetensors metadata...")
+            safetensors_metadata = self.hf_api.get_safetensors_metadata(model_id)
+            print(f"Found {len(safetensors_metadata)} safetensor files")
+            
+            total_params = 0
+            safetensors_files = []
+            
+            # Iterate through all safetensor files
+            for filename, metadata in safetensors_metadata.items():
+                file_params = 0
+                file_size_bytes = 0
+                
+                # Calculate parameters from tensor metadata
+                if 'metadata' in metadata and metadata['metadata']:
+                    for tensor_name, tensor_info in metadata['metadata'].items():
+                        if 'shape' in tensor_info and 'dtype' in tensor_info:
+                            # Calculate tensor size
+                            shape = tensor_info['shape']
+                            tensor_params = 1
+                            for dim in shape:
+                                tensor_params *= dim
+                            file_params += tensor_params
+                            
+                            # Calculate byte size based on dtype
+                            dtype = tensor_info['dtype']
+                            bytes_per_param = self._get_bytes_per_param(dtype)
+                            file_size_bytes += tensor_params * bytes_per_param
+                
+                total_params += file_params
+                safetensors_files.append({
+                    'filename': filename,
+                    'parameters': file_params,
+                    'size_bytes': file_size_bytes,
+                    'size_mb': file_size_bytes / (1024 * 1024)
+                })
+            
+            # Calculate memory requirements for different precisions
+            memory_requirements = {
+                'model_id': model_id,
+                'total_params': total_params,
+                'total_params_billions': total_params / 1e9,
+                'memory_fp32_gb': (total_params * 4) / (1024**3),  # 4 bytes per param
+                'memory_fp16_gb': (total_params * 2) / (1024**3),  # 2 bytes per param
+                'memory_bf16_gb': (total_params * 2) / (1024**3),  # 2 bytes per param
+                'memory_int8_gb': (total_params * 1) / (1024**3),  # 1 byte per param
+                'safetensors_files': safetensors_files,
+                'estimated_inference_memory_fp16_gb': self._estimate_inference_memory(total_params, 'fp16'),
+                'estimated_inference_memory_bf16_gb': self._estimate_inference_memory(total_params, 'bf16'),
+            }
+            
+            # Cache the result
+            self.cache[model_id] = memory_requirements
+            
+            return memory_requirements
+            
+        except Exception as e:
+            return {
+                'error': str(e),
+                'model_id': model_id,
+                'total_params': 0,
+                'memory_fp32_gb': 0,
+                'memory_fp16_gb': 0,
+                'memory_bf16_gb': 0,
+            }
+    
+    def _get_bytes_per_param(self, dtype: str) -> int:
+        """Get bytes per parameter for different data types."""
+        dtype_map = {
+            'F32': 4, 'float32': 4,
+            'F16': 2, 'float16': 2,
+            'BF16': 2, 'bfloat16': 2,
+            'I8': 1, 'int8': 1,
+            'I32': 4, 'int32': 4,
+            'I64': 8, 'int64': 8,
+        }
+        return dtype_map.get(dtype, 4)  # Default to 4 bytes (FP32)
+    
+    def _estimate_inference_memory(self, total_params: int, precision: str) -> float:
+        """
+        Estimate memory requirements during inference.
+        This includes model weights + activations + intermediate tensors.
+        """
+        bytes_per_param = 2 if precision in ['fp16', 'bf16'] else 4
+        
+        # Model weights
+        model_memory = (total_params * bytes_per_param) / (1024**3)
+        
+        # Estimate activation memory (rough approximation)
+        # For diffusion models, activations can be 1.5-3x model size during inference
+        activation_multiplier = 2.0
+        
+        total_inference_memory = model_memory * (1 + activation_multiplier)
+        
+        return total_inference_memory
+    
+    def get_memory_recommendation(self, model_id: str, available_vram_gb: float) -> Dict:
+        """
+        Get memory recommendations based on available VRAM.
+        
+        Args:
+            model_id: HuggingFace model identifier
+            available_vram_gb: Available VRAM in GB
+            
+        Returns:
+            Dict with recommendations for precision, offloading, etc.
+        """
+        memory_info = self.get_model_memory_requirements(model_id)
+        
+        if 'error' in memory_info:
+            return {'error': memory_info['error']}
+        
+        recommendations = {
+            'model_id': model_id,
+            'available_vram_gb': available_vram_gb,
+            'model_memory_fp16_gb': memory_info['memory_fp16_gb'],
+            'estimated_inference_memory_fp16_gb': memory_info['estimated_inference_memory_fp16_gb'],
+            'recommendations': []
+        }
+        
+        inference_memory_fp16 = memory_info['estimated_inference_memory_fp16_gb']
+        inference_memory_bf16 = memory_info['estimated_inference_memory_bf16_gb']
+        
+        # Determine recommendations
+        if available_vram_gb >= inference_memory_bf16:
+            recommendations['recommendations'].append("✅ Full model can fit in VRAM with BF16 precision")
+            recommendations['recommended_precision'] = 'bfloat16'
+            recommendations['cpu_offload'] = False
+            recommendations['attention_slicing'] = False
+            
+        elif available_vram_gb >= inference_memory_fp16:
+            recommendations['recommendations'].append("✅ Full model can fit in VRAM with FP16 precision")
+            recommendations['recommended_precision'] = 'float16'
+            recommendations['cpu_offload'] = False
+            recommendations['attention_slicing'] = False
+            
+        elif available_vram_gb >= memory_info['memory_fp16_gb']:
+            recommendations['recommendations'].append("⚠️ Model weights fit, but may need memory optimizations")
+            recommendations['recommended_precision'] = 'float16'
+            recommendations['cpu_offload'] = False
+            recommendations['attention_slicing'] = True
+            recommendations['vae_slicing'] = True
+            
+        else:
+            recommendations['recommendations'].append("🔄 Requires CPU offloading and memory optimizations")
+            recommendations['recommended_precision'] = 'float16'
+            recommendations['cpu_offload'] = True
+            recommendations['sequential_offload'] = True
+            recommendations['attention_slicing'] = True
+            recommendations['vae_slicing'] = True
+        
+        return recommendations
+    
+    def format_memory_info(self, model_id: str) -> str:
+        """Format memory information for display."""
+        info = self.get_model_memory_requirements(model_id)
+        
+        if 'error' in info:
+            return f"❌ Error calculating memory for {model_id}: {info['error']}"
+        
+        output = f"""
+📊 **Memory Requirements for {model_id}**
+
+🔢 **Parameters**: {info['total_params_billions']:.2f}B parameters
+💾 **Model Memory**:
+   • FP32: {info['memory_fp32_gb']:.2f} GB
+   • FP16/BF16: {info['memory_fp16_gb']:.2f} GB
+   • INT8: {info['memory_int8_gb']:.2f} GB
+
+🚀 **Estimated Inference Memory**:
+   • FP16: {info['estimated_inference_memory_fp16_gb']:.2f} GB
+   • BF16: {info['estimated_inference_memory_bf16_gb']:.2f} GB
+
+📁 **SafeTensor Files**: {len(info['safetensors_files'])} files
+"""
+        return output.strip()
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    calculator = ModelMemoryCalculator()
+    
+    # Test with FLUX.1-schnell
+    model_id = "black-forest-labs/FLUX.1-schnell"
+    print(f"Testing memory calculation for {model_id}...")
+    
+    memory_info = calculator.get_model_memory_requirements(model_id)
+    print(json.dumps(memory_info, indent=2))
+    
+    # Test recommendations
+    print("\n" + "="*50)
+    print("MEMORY RECOMMENDATIONS")
+    print("="*50)
+    
+    vram_options = [8, 16, 24, 40]
+    for vram in vram_options:
+        rec = calculator.get_memory_recommendation(model_id, vram)
+        print(f"\n🎯 For {vram}GB VRAM:")
+        if 'recommendations' in rec:
+            for r in rec['recommendations']:
+                print(f"   {r}")
+    
+    # Format for display
+    print("\n" + "="*50)
+    print("FORMATTED OUTPUT")
+    print("="*50)
+    print(calculator.format_memory_info(model_id))

requirements.txt

@@ -0,0 +1,9 @@
+google-generativeai>=0.8.0
+diffusers>=0.30.0
+torch>=2.0.0
+transformers>=4.30.0
+accelerate>=0.20.0
+psutil>=5.9.0
+gradio>=4.0.0
+python-dotenv>=1.0.0
+huggingface-hub>=0.20.0

sample_optimized_apple_silicon.py

@@ -0,0 +1,48 @@
+import torch
+from diffusers import FluxPipeline
+
+# Optimized for Apple Silicon (MPS) - 16 CPU cores, MPS available
+# Memory-efficient configuration for Apple Silicon
+
+# Load pipeline with bfloat16 for better MPS performance
+pipe = FluxPipeline.from_pretrained(
+    "black-forest-labs/FLUX.1-schnell", 
+    torch_dtype=torch.bfloat16,
+    use_safetensors=True
+)
+
+# Move to MPS device for GPU acceleration on Apple Silicon
+pipe.to("mps")
+
+# Apple Silicon optimizations
+pipe.enable_attention_slicing()  # Reduce memory usage
+pipe.enable_vae_slicing()        # VAE memory optimization
+
+# Optional: Enable model CPU offload if memory is tight
+# pipe.enable_model_cpu_offload()
+
+# For Apple Silicon, compile the UNet for speed (if supported)
+try:
+    pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
+except Exception:
+    print("Torch compile not supported, proceeding without compilation")
+
+prompt = "A cat holding a sign that says hello world"
+
+# Generate image with optimized settings for Apple Silicon
+with torch.inference_mode():
+    out = pipe(
+        prompt=prompt,
+        guidance_scale=0.0,           # FLUX.1-schnell works best with guidance_scale=0
+        height=768,
+        width=1360,
+        num_inference_steps=4,        # FLUX.1-schnell is optimized for 4 steps
+        max_sequence_length=256,      # Reduced for memory efficiency
+        generator=torch.Generator(device="mps").manual_seed(42)  # Reproducible results
+    ).images[0]
+
+# Save the generated image
+out.save("image.png")
+
+print("Image generated and saved as 'image.png'")
+print("Optimizations applied: MPS device, bfloat16 precision, attention slicing, VAE slicing")

simple_memory_calculator.py

@@ -0,0 +1,262 @@
+from huggingface_hub import HfApi, hf_hub_download
+from typing import Dict, Optional
+import json
+import os
+
+
+class SimpleMemoryCalculator:
+    def __init__(self):
+        self.hf_api = HfApi()
+        self.cache = {}
+        
+        # Known model memory requirements (in GB for FP16)
+        self.known_models = {
+            "black-forest-labs/FLUX.1-schnell": {
+                "params_billions": 12.0,
+                "fp16_gb": 24.0,
+                "inference_fp16_gb": 36.0
+            },
+            "black-forest-labs/FLUX.1-dev": {
+                "params_billions": 12.0,
+                "fp16_gb": 24.0,
+                "inference_fp16_gb": 36.0
+            },
+            "stabilityai/stable-diffusion-xl-base-1.0": {
+                "params_billions": 3.5,
+                "fp16_gb": 7.0,
+                "inference_fp16_gb": 12.0
+            },
+            "runwayml/stable-diffusion-v1-5": {
+                "params_billions": 0.86,
+                "fp16_gb": 1.7,
+                "inference_fp16_gb": 4.0
+            }
+        }
+    
+    def get_model_memory_requirements(self, model_id: str) -> Dict:
+        """
+        Get memory requirements for a model, using known values or estimating from file sizes.
+        """
+        if model_id in self.cache:
+            return self.cache[model_id]
+        
+        # Check if we have known values
+        if model_id in self.known_models:
+            known = self.known_models[model_id]
+            result = {
+                'model_id': model_id,
+                'total_params': int(known['params_billions'] * 1e9),
+                'total_params_billions': known['params_billions'],
+                'memory_fp32_gb': known['fp16_gb'] * 2,
+                'memory_fp16_gb': known['fp16_gb'],
+                'memory_bf16_gb': known['fp16_gb'],
+                'memory_int8_gb': known['fp16_gb'] / 2,
+                'estimated_inference_memory_fp16_gb': known['inference_fp16_gb'],
+                'estimated_inference_memory_bf16_gb': known['inference_fp16_gb'],
+                'source': 'known_values'
+            }
+            self.cache[model_id] = result
+            return result
+        
+        # Try to estimate from HuggingFace API
+        try:
+            return self._estimate_from_api(model_id)
+        except Exception as e:
+            # Fallback to generic estimation
+            return self._generic_estimation(model_id, str(e))
+    
+    def _estimate_from_api(self, model_id: str) -> Dict:
+        """Estimate memory from HuggingFace model info."""
+        try:
+            print(f"Fetching model info for: {model_id}")
+            model_info = self.hf_api.model_info(model_id)
+            print(f"Successfully fetched model info for: {model_id}")
+            
+            # Get file sizes from model repo
+            total_size_bytes = 0
+            safetensor_files = []
+            files_without_size = 0
+            
+            for sibling in model_info.siblings:
+                if sibling.rfilename.endswith('.safetensors'):
+                    file_size_bytes = sibling.size
+                    if file_size_bytes is None or file_size_bytes == 0:
+                        files_without_size += 1
+                        print(f"Warning: No size info for {sibling.rfilename}")
+                        # Try to estimate based on typical safetensor file sizes
+                        if 'unet' in sibling.rfilename.lower():
+                            file_size_bytes = 3_400_000_000  # ~3.4GB typical for UNet
+                        elif 'text_encoder' in sibling.rfilename.lower():
+                            file_size_bytes = 500_000_000   # ~500MB typical for text encoder
+                        elif 'vae' in sibling.rfilename.lower():
+                            file_size_bytes = 160_000_000   # ~160MB typical for VAE
+                        else:
+                            file_size_bytes = 500_000_000   # Default fallback
+                        print(f"  → Using estimated size: {file_size_bytes / (1024**3):.2f} GB")
+                    else:
+                        print(f"File {sibling.rfilename}: {file_size_bytes / (1024**3):.2f} GB")
+                    
+                    size_mb = file_size_bytes / (1024 * 1024)
+                    safetensor_files.append({
+                        'filename': sibling.rfilename,
+                        'size_mb': size_mb,
+                        'estimated': file_size_bytes != sibling.size
+                    })
+                    total_size_bytes += file_size_bytes
+            
+            print(f"Found {len(safetensor_files)} safetensor files, total size: {total_size_bytes / (1024**3):.2f} GB")
+            if files_without_size > 0:
+                print(f"Warning: {files_without_size} files had no size info, used estimates")
+            
+            # Estimate parameters from file size (assuming FP16)
+            total_size_gb = total_size_bytes / (1024**3)
+            estimated_params = int((total_size_bytes / 2))  # 2 bytes per param for FP16
+            estimated_params_billions = estimated_params / 1e9
+            
+            # Estimate inference memory (model + activations)
+            inference_multiplier = 1.5  # Conservative estimate
+            estimated_inference_memory = total_size_gb * inference_multiplier
+            
+            result = {
+                'model_id': model_id,
+                'total_params': estimated_params,
+                'total_params_billions': estimated_params_billions,
+                'memory_fp32_gb': total_size_gb * 2,
+                'memory_fp16_gb': total_size_gb,
+                'memory_bf16_gb': total_size_gb,
+                'memory_int8_gb': total_size_gb / 2,
+                'estimated_inference_memory_fp16_gb': estimated_inference_memory,
+                'estimated_inference_memory_bf16_gb': estimated_inference_memory,
+                'safetensors_files': safetensor_files,
+                'files_without_size': files_without_size,
+                'source': 'api_estimation'
+            }
+            
+            self.cache[model_id] = result
+            return result
+            
+        except Exception as api_error:
+            print(f"API Error for model {model_id}: {type(api_error).__name__}: {str(api_error)}")
+            # Re-raise with more context
+            raise Exception(f"HuggingFace API Error: {type(api_error).__name__}: {str(api_error)}")                
+    
+    def _generic_estimation(self, model_id: str, error_msg: str) -> Dict:
+        """Generic fallback estimation."""
+        # Default to medium-sized model estimates
+        default_params_billions = 3.0
+        default_fp16_gb = 6.0
+        
+        return {
+            'model_id': model_id,
+            'total_params': int(default_params_billions * 1e9),
+            'total_params_billions': default_params_billions,
+            'memory_fp32_gb': default_fp16_gb * 2,
+            'memory_fp16_gb': default_fp16_gb,
+            'memory_bf16_gb': default_fp16_gb,
+            'memory_int8_gb': default_fp16_gb / 2,
+            'estimated_inference_memory_fp16_gb': default_fp16_gb * 1.5,
+            'estimated_inference_memory_bf16_gb': default_fp16_gb * 1.5,
+            'source': 'generic_fallback',
+            'error': error_msg
+        }
+    
+    def get_memory_recommendation(self, model_id: str, available_vram_gb: float) -> Dict:
+        """Get memory recommendations based on available VRAM."""
+        memory_info = self.get_model_memory_requirements(model_id)
+        
+        recommendations = {
+            'model_id': model_id,
+            'available_vram_gb': available_vram_gb,
+            'model_memory_fp16_gb': memory_info['memory_fp16_gb'],
+            'estimated_inference_memory_fp16_gb': memory_info['estimated_inference_memory_fp16_gb'],
+            'recommendations': []
+        }
+        
+        inference_memory_fp16 = memory_info['estimated_inference_memory_fp16_gb']
+        model_memory_fp16 = memory_info['memory_fp16_gb']
+        
+        # Determine recommendations
+        if available_vram_gb >= inference_memory_fp16:
+            recommendations['recommendations'].append("✅ Full model can fit in VRAM")
+            recommendations['recommended_precision'] = 'float16'
+            recommendations['cpu_offload'] = False
+            recommendations['attention_slicing'] = False
+            
+        elif available_vram_gb >= model_memory_fp16:
+            recommendations['recommendations'].append("⚠️ Model weights fit, enable memory optimizations")
+            recommendations['recommended_precision'] = 'float16'
+            recommendations['cpu_offload'] = False
+            recommendations['attention_slicing'] = True
+            recommendations['vae_slicing'] = True
+            
+        elif available_vram_gb >= model_memory_fp16 * 0.7:
+            recommendations['recommendations'].append("🔄 Use CPU offloading for some components")
+            recommendations['recommended_precision'] = 'float16'
+            recommendations['cpu_offload'] = True
+            recommendations['attention_slicing'] = True
+            recommendations['vae_slicing'] = True
+            
+        else:
+            recommendations['recommendations'].append("🔄 Requires sequential CPU offloading")
+            recommendations['recommended_precision'] = 'float16'
+            recommendations['sequential_offload'] = True
+            recommendations['attention_slicing'] = True
+            recommendations['vae_slicing'] = True
+        
+        return recommendations
+    
+    def format_memory_info(self, model_id: str) -> str:
+        """Format memory information for display."""
+        info = self.get_model_memory_requirements(model_id)
+        
+        source_text = {
+            'known_values': '📊 Known model specifications',
+            'api_estimation': '🔍 Estimated from model files',
+            'generic_fallback': '⚠️ Generic estimation (API error)'
+        }.get(info.get('source', 'unknown'), '❓ Unknown source')
+        
+        # Add warning if file sizes were estimated
+        if info.get('files_without_size', 0) > 0:
+            source_text += f" (⚠️ {info['files_without_size']} files used size estimates)"
+        
+        output = f"""
+🤖 **Memory Analysis for {model_id}**
+
+{source_text}
+
+🔢 **Parameters**: {info['total_params_billions']:.1f}B parameters
+
+💾 **Model Memory Requirements**:
+   • FP32: {info['memory_fp32_gb']:.1f} GB
+   • FP16/BF16: {info['memory_fp16_gb']:.1f} GB
+   • INT8: {info['memory_int8_gb']:.1f} GB
+
+🚀 **Estimated Inference Memory**:
+   • FP16: {info['estimated_inference_memory_fp16_gb']:.1f} GB
+   • BF16: {info['estimated_inference_memory_bf16_gb']:.1f} GB
+"""
+        
+        if 'error' in info:
+            output += f"\n⚠️ **Note**: {info['error']}"
+        
+        return output.strip()
+
+
+# Quick test
+if __name__ == "__main__":
+    calc = SimpleMemoryCalculator()
+    
+    models = [
+        "black-forest-labs/FLUX.1-schnell",
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        "runwayml/stable-diffusion-v1-5"
+    ]
+    
+    for model in models:
+        print(f"\n{'='*60}")
+        print(calc.format_memory_info(model))
+        
+        # Test recommendations
+        for vram in [8, 16, 24]:
+            rec = calc.get_memory_recommendation(model, vram)
+            print(f"\n💡 {vram}GB VRAM: {rec['recommendations'][0]}")

test_flux_specific.py

@@ -0,0 +1,53 @@
+import os
+from dotenv import load_dotenv
+import google.generativeai as genai
+
+load_dotenv()
+
+def generate_flux_optimized():
+    api_key = os.getenv('GOOGLE_API_KEY')
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel('gemini-2.5-flash-preview-05-20')
+    
+    prompt = """
+Generate optimized Python code for running FLUX.1-schnell diffusion model on Apple Silicon (MPS) hardware.
+
+Requirements:
+- Use FluxPipeline from diffusers library
+- Model: "black-forest-labs/FLUX.1-schnell"
+- Target device: MPS (Apple Silicon)
+- Image size: 768x1360
+- Inference steps: 4
+- Prompt: "A cat holding a sign that says hello world"
+
+Apply these Apple Silicon optimizations:
+1. Use torch.bfloat16 (better than float16 for MPS)
+2. Enable attention slicing and VAE slicing for memory efficiency
+3. Use guidance_scale=0.0 for FLUX.1-schnell
+4. Add max_sequence_length=256 for memory optimization
+5. Include proper error handling
+6. Add torch.inference_mode() for speed
+
+Generate ONLY Python code without markdown formatting.
+"""
+    
+    try:
+        response = model.generate_content(prompt)
+        code = response.text.strip()
+        
+        # Clean up any markdown formatting
+        if code.startswith('```python'):
+            code = code[9:]
+        if code.endswith('```'):
+            code = code[:-3]
+        
+        print("FLUX-Optimized Code for Apple Silicon:")
+        print("=" * 50)
+        print(code)
+        print("=" * 50)
+        
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    generate_flux_optimized()

test_generation.py

@@ -0,0 +1,40 @@
+import os
+from dotenv import load_dotenv
+from auto_diffusers import AutoDiffusersGenerator
+
+load_dotenv()
+
+def test_generation():
+    api_key = os.getenv('GOOGLE_API_KEY')
+    if not api_key:
+        print("No API key found in .env file")
+        return
+    
+    print("Testing auto-diffusers code generation...")
+    print("API key loaded successfully")
+    
+    generator = AutoDiffusersGenerator(api_key)
+    
+    # Test with default FLUX model
+    print("\nGenerating optimized code for FLUX.1-schnell...")
+    
+    try:
+        optimized_code = generator.generate_optimized_code(
+            model_name="black-forest-labs/FLUX.1-schnell",
+            prompt_text="A cat holding a sign that says hello world",
+            image_size=(768, 1360),
+            num_inference_steps=4,
+            use_manual_specs=False
+        )
+        
+        print("\n" + "="*60)
+        print("GENERATED OPTIMIZED CODE:")
+        print("="*60)
+        print(optimized_code)
+        print("="*60)
+        
+    except Exception as e:
+        print(f"Error generating code: {e}")
+
+if __name__ == "__main__":
+    test_generation()