Upload folder using huggingface_hub

.claude/settings.local.json

@@ -79,7 +79,53 @@
       "Bash(grep -n \"section-header\" /Users/deep-diver/Developers/auto-diffusers/gradio_app.py)",
       "Bash(grep -n \"memory-card\" /Users/deep-diver/Developers/auto-diffusers/gradio_app.py)",
       "Bash(grep -n -A 5 \"Configure your system hardware\" /Users/deep-diver/Developers/auto-diffusers/gradio_app.py)",
-      "Bash(grep -n -A 5 \"Configure the AI model\" /Users/deep-diver/Developers/auto-diffusers/gradio_app.py)"
+      "Bash(grep -n -A 5 \"Configure the AI model\" /Users/deep-diver/Developers/auto-diffusers/gradio_app.py)",
+      "Bash(rm /Users/deep-diver/Developers/auto-diffusers/model_memory_calculator.py)",
+      "Bash(rm /Users/deep-diver/Developers/auto-diffusers/flux_optimized_apple_silicon.py)",
+      "Bash(rm /Users/deep-diver/Developers/auto-diffusers/generated_optimized.py)",
+      "Bash(rm /Users/deep-diver/Developers/auto-diffusers/sample_optimized_apple_silicon.py)",
+      "Bash(rm /Users/deep-diver/Developers/auto-diffusers/test_flux_specific.py)",
+      "Bash(rm /Users/deep-diver/Developers/auto-diffusers/test_generation.py)",
+      "Bash(grep -n \"debug_config\\|setup_debug_logging\" /Users/deep-diver/Developers/auto-diffusers/launch_gradio.py)",
+      "Bash(rm -rf /Users/deep-diver/Developers/auto-diffusers/logs/*)",
+      "Bash(rm /Users/deep-diver/Developers/auto-diffusers/auto_diffusers.log)",
+      "Bash(mkdir -p auto_diffusers/{core,hardware,ui,utils} scripts docs tests/{test_core,test_hardware,test_ui})",
+      "Bash(mv auto_diffusers.py auto_diffusers/core/generator.py)",
+      "Bash(mv optimization_knowledge.py auto_diffusers/core/knowledge_base.py)",
+      "Bash(mv hardware_detector.py auto_diffusers/hardware/detector.py)",
+      "Bash(mv simple_memory_calculator.py auto_diffusers/hardware/memory_calculator.py)",
+      "Bash(mv gradio_app.py auto_diffusers/ui/gradio_interface.py)",
+      "Bash(mv debug_config.py auto_diffusers/utils/logging_config.py)",
+      "Bash(mv launch_gradio.py scripts/launch.py)",
+      "Bash(mv *.md docs/)",
+      "Bash(grep -n \"gradio_app\" /Users/deep-diver/Developers/auto-diffusers/scripts/launch.py)",
+      "Bash(chmod +x /Users/deep-diver/Developers/auto-diffusers/main.py)",
+      "Bash(python -c \"from auto_diffusers import AutoDiffusersGenerator, HardwareDetector, SimpleMemoryCalculator; print('✅ Core imports work!')\")",
+      "Bash(python -c \"from auto_diffusers.ui.gradio_interface import create_gradio_interface; print('✅ UI imports work!')\")",
+      "Bash(ls /Users/deep-diver/Developers/auto-diffusers/docs/)",
+      "Bash(find /Users/deep-diver/Developers/auto-diffusers -name \"*.md\" -not -path \"*/docs/*\")",
+      "Bash(rm /Users/deep-diver/Developers/auto-diffusers/setup.py)",
+      "Bash(ls -la /Users/deep-diver/Developers/auto-diffusers/)",
+      "Bash(grep -n -A 10 -B 2 \"Apple Silicon.*choices\" /Users/deep-diver/Developers/auto-diffusers/auto_diffusers/ui/gradio_interface.py)",
+      "Bash(grep -n -A 20 \"def on_gpu_vendor_change\" /Users/deep-diver/Developers/auto-diffusers/auto_diffusers/ui/gradio_interface.py)",
+      "Bash(grep -n -A 35 \"def on_gpu_vendor_change\" /Users/deep-diver/Developers/auto-diffusers/auto_diffusers/ui/gradio_interface.py)",
+      "Bash(python -c \"from auto_diffusers.ui.gradio_interface import create_gradio_interface; print('✅ Updated interface imports work!')\")",
+      "Bash(python -c \"from auto_diffusers.ui.gradio_interface import create_gradio_interface; print('✅ Fixed interface imports work!')\")",
+      "Bash(python main.py --auto-hardware-detection)",
+      "Bash(GRADIO_SERVER_PORT=7861 python main.py --auto-hardware-detection)",
+      "Bash(python main.py --auto-hardware-detection --port 7861)",
+      "Bash(rg -n \"🔧 GPU Model|gpu_model\" auto_diffusers/ui/gradio_interface.py)",
+      "Bash(grep -n \"🔧 GPU Model\\|gpu_model\" auto_diffusers/ui/gradio_interface.py)",
+      "Bash(grep -n -A 10 \"def on_gpu_model_change\" auto_diffusers/ui/gradio_interface.py)",
+      "Bash(grep -n -A 5 \"def update_hardware_accordion\" auto_diffusers/ui/gradio_interface.py)",
+      "Bash(grep -n -A 5 \"def generate_with_combined_gpu_name\" auto_diffusers/ui/gradio_interface.py)",
+      "Bash(grep -n -A 5 \"def generate_and_store_code\" auto_diffusers/ui/gradio_interface.py)",
+      "Bash(grep -n -A 3 -B 3 \"gpu_series.*change\\|gpu_model.*change\" auto_diffusers/ui/gradio_interface.py)",
+      "Bash(grep -n -A 5 -B 5 \"inputs=\\[.*gpu_model\" auto_diffusers/ui/gradio_interface.py)",
+      "Bash(grep -n -A 10 \"generate_btn.click\" auto_diffusers/ui/gradio_interface.py)",
+      "Bash(ls -la)",
+      "Bash(find . -name \"hardware_detector.py\" -o -name \"auto_diffusers.py\")",
+      "Bash(grep -r \"Interactive Mode\" .)"
     ],
     "deny": []
   },

.env.example

@@ -0,0 +1,15 @@
+# Auto Diffusers Configuration
+# Copy this file to .env and fill in your values
+
+# Google Gemini API Key (required)
+GOOGLE_API_KEY=your_google_gemini_api_key_here
+
+# Debug Configuration (optional)
+DEBUG_LEVEL=INFO
+LOG_TO_FILE=true
+LOG_TO_CONSOLE=true
+
+# Application Configuration (optional)
+# PORT=7860
+# HOST=0.0.0.0
+# SHARE=true

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+auto_diffusers/ui/__pycache__/gradio_interface.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+auto_diffusers/ui/__pycache__/gradio_interface.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

README.md

@@ -37,14 +37,32 @@ export GEMINI_API_KEY="your_api_key_here"
 
 ### Interactive Mode
 ```bash
-python auto_diffusers.py
+python main.py
 ```
 
-### Hardware Detection Only
+**Available Options:**
+- `--auto-hardware-detection` - Enable automatic hardware detection on startup (disabled by default)
+- `--no-auto-hardware-detection` - Explicitly disable automatic hardware detection
+- `--port PORT` - Specify port to run the server on (default: 7860)
+- `--host HOST` - Specify host to run the server on (default: 0.0.0.0)  
+- `--no-share` - Disable public sharing of the interface (local access only)
+
+**Examples:**
 ```bash
-python hardware_detector.py
+# Launch with auto hardware detection enabled
+python main.py --auto-hardware-detection
+
+# Launch on a different port
+python main.py --port 8080
+
+# Launch for local access only
+python main.py --no-share
+
+# Combine options
+python main.py --auto-hardware-detection --port 8080 --no-share
 ```
 
+
 ### Programmatic Usage
 ```python
 from auto_diffusers import AutoDiffusersGenerator

auto_diffusers/__init__.py

@@ -0,0 +1,20 @@
+"""
+Auto Diffusers - Hardware-Optimized Code Generator
+
+A tool for generating hardware-optimized diffusion model code using AI.
+"""
+
+__version__ = "1.0.0"
+__author__ = "Auto-Diffusers Team"
+__description__ = "Hardware-Optimized Diffusion Model Code Generator"
+
+# Main exports
+from .core.generator import AutoDiffusersGenerator
+from .hardware.detector import HardwareDetector
+from .hardware.memory_calculator import SimpleMemoryCalculator
+
+__all__ = [
+    "AutoDiffusersGenerator",
+    "HardwareDetector", 
+    "SimpleMemoryCalculator"
+]

auto_diffusers/core/__init__.py

@@ -0,0 +1,14 @@
+"""
+Core application logic and AI integration.
+
+This module contains the main generator class and knowledge base
+for the Auto Diffusers application.
+"""
+
+from .generator import AutoDiffusersGenerator
+from .knowledge_base import get_optimization_guide
+
+__all__ = [
+    "AutoDiffusersGenerator",
+    "get_optimization_guide"
+]

auto_diffusers/core/generator.py

@@ -0,0 +1,564 @@
+import os
+import logging
+from dotenv import load_dotenv
+import google.generativeai as genai
+from ..hardware.detector import HardwareDetector
+from .knowledge_base import get_optimization_guide
+from typing import Dict, List
+import json
+
+# Optional imports for tool calling
+try:
+    import requests
+    from urllib.parse import urljoin, urlparse
+    from bs4 import BeautifulSoup
+    TOOLS_AVAILABLE = True
+except ImportError:
+    TOOLS_AVAILABLE = False
+    requests = None
+    urlparse = None
+    BeautifulSoup = None
+
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('auto_diffusers.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+
+class AutoDiffusersGenerator:
+    def __init__(self, api_key: str):
+        logger.info("Initializing AutoDiffusersGenerator")
+        logger.debug(f"API key length: {len(api_key) if api_key else 'None'}")
+        
+        try:
+            genai.configure(api_key=api_key)
+            
+            # Define tools for Gemini to use (if available)
+            if TOOLS_AVAILABLE:
+                self.tools = self._create_tools()
+                # Initialize model with tools
+                self.model = genai.GenerativeModel(
+                    'gemini-2.5-flash-preview-05-20',
+                    tools=self.tools
+                )
+                logger.info("Successfully configured Gemini AI model with tools")
+            else:
+                self.tools = None
+                # Initialize model without tools
+                self.model = genai.GenerativeModel('gemini-2.5-flash-preview-05-20')
+                logger.warning("Tool calling dependencies not available, running without tools")
+        except Exception as e:
+            logger.error(f"Failed to configure Gemini AI: {e}")
+            raise
+        
+        try:
+            self.hardware_detector = HardwareDetector()
+            logger.info("Hardware detector initialized successfully")
+        except Exception as e:
+            logger.error(f"Failed to initialize hardware detector: {e}")
+            raise
+    
+    def _create_tools(self):
+        """Create function tools for Gemini to use."""
+        logger.debug("Creating tools for Gemini")
+        
+        if not TOOLS_AVAILABLE:
+            logger.warning("Tools dependencies not available, returning empty tools")
+            return []
+        
+        def fetch_huggingface_docs(url: str) -> str:
+            """Fetch documentation from HuggingFace URLs."""
+            logger.info("🌐 TOOL CALL: fetch_huggingface_docs")
+            logger.info(f"📋 Requested URL: {url}")
+            
+            try:
+                # Validate URL is from HuggingFace
+                parsed = urlparse(url)
+                logger.debug(f"URL validation - Domain: {parsed.netloc}, Path: {parsed.path}")
+                
+                if not any(domain in parsed.netloc for domain in ['huggingface.co', 'hf.co']):
+                    error_msg = "Error: URL must be from huggingface.co domain"
+                    logger.warning(f"❌ URL validation failed: {error_msg}")
+                    return error_msg
+                
+                logger.info(f"✅ URL validation passed for domain: {parsed.netloc}")
+                
+                headers = {
+                    'User-Agent': 'Auto-Diffusers-Config/1.0 (Educational Tool)'
+                }
+                
+                logger.info(f"🔄 Fetching content from: {url}")
+                response = requests.get(url, headers=headers, timeout=10)
+                response.raise_for_status()
+                logger.info(f"✅ HTTP {response.status_code} - Successfully fetched {len(response.text)} characters")
+                
+                # Parse HTML content
+                logger.info("🔍 Parsing HTML content...")
+                soup = BeautifulSoup(response.text, 'html.parser')
+                
+                # Extract main content (remove navigation, footers, etc.)
+                content = ""
+                element_count = 0
+                for element in soup.find_all(['p', 'pre', 'code', 'h1', 'h2', 'h3', 'h4', 'li']):
+                    text = element.get_text().strip()
+                    if text:
+                        content += text + "\\n"
+                        element_count += 1
+                
+                logger.info(f"📄 Extracted content from {element_count} HTML elements")
+                
+                # Limit content length
+                original_length = len(content)
+                if len(content) > 5000:
+                    content = content[:5000] + "...[truncated]"
+                    logger.info(f"✂️ Content truncated from {original_length} to 5000 characters")
+                
+                logger.info(f"📊 Final processed content: {len(content)} characters")
+                
+                # Log a preview of the fetched content
+                preview = content[:200].replace('\\n', ' ')
+                logger.info(f"📋 Content preview: {preview}...")
+                
+                # Log content sections found
+                sections = []
+                for header in soup.find_all(['h1', 'h2', 'h3']):
+                    header_text = header.get_text().strip()
+                    if header_text:
+                        sections.append(header_text)
+                
+                if sections:
+                    logger.info(f"📑 Found sections: {', '.join(sections[:5])}{'...' if len(sections) > 5 else ''}")
+                
+                logger.info("✅ Content extraction completed successfully")
+                return content
+                
+            except Exception as e:
+                logger.error(f"❌ Error fetching {url}: {type(e).__name__}: {e}")
+                return f"Error fetching documentation: {str(e)}"
+        
+        def fetch_model_info(model_id: str) -> str:
+            """Fetch model information from HuggingFace API."""
+            logger.info("🤖 TOOL CALL: fetch_model_info")
+            logger.info(f"📋 Requested model: {model_id}")
+            try:
+                # Use HuggingFace API to get model info
+                api_url = f"https://huggingface.co/api/models/{model_id}"
+                logger.info(f"🔄 Fetching model info from: {api_url}")
+                headers = {
+                    'User-Agent': 'Auto-Diffusers-Config/1.0 (Educational Tool)'
+                }
+                
+                response = requests.get(api_url, headers=headers, timeout=10)
+                response.raise_for_status()
+                logger.info(f"✅ HTTP {response.status_code} - Model API response received")
+                
+                model_data = response.json()
+                logger.info(f"📊 Raw API response contains {len(model_data)} fields")
+                
+                # Extract relevant information
+                info = {
+                    'model_id': model_data.get('id', model_id),
+                    'pipeline_tag': model_data.get('pipeline_tag', 'unknown'),
+                    'tags': model_data.get('tags', []),
+                    'library_name': model_data.get('library_name', 'unknown'),
+                    'downloads': model_data.get('downloads', 0),
+                    'likes': model_data.get('likes', 0)
+                }
+                
+                logger.info(f"📋 Extracted model info:")
+                logger.info(f"   - Pipeline: {info['pipeline_tag']}")
+                logger.info(f"   - Library: {info['library_name']}")
+                logger.info(f"   - Downloads: {info['downloads']:,}")
+                logger.info(f"   - Likes: {info['likes']:,}")
+                logger.info(f"   - Tags: {len(info['tags'])} tags")
+                
+                result = json.dumps(info, indent=2)
+                logger.info(f"✅ Model info formatting completed ({len(result)} characters)")
+                return result
+                
+            except Exception as e:
+                logger.error(f"Error fetching model info for {model_id}: {e}")
+                return f"Error fetching model information: {str(e)}"
+        
+        def search_optimization_guides(query: str) -> str:
+            """Search for optimization guides and best practices."""
+            logger.info("🔍 TOOL CALL: search_optimization_guides")
+            logger.info(f"📋 Search query: '{query}'")
+            try:
+                # Search common optimization documentation URLs
+                docs_urls = [
+                    "https://huggingface.co/docs/diffusers/optimization/fp16",
+                    "https://huggingface.co/docs/diffusers/optimization/memory",
+                    "https://huggingface.co/docs/diffusers/optimization/torch2",
+                    "https://huggingface.co/docs/diffusers/optimization/mps",
+                    "https://huggingface.co/docs/diffusers/optimization/xformers"
+                ]
+                
+                logger.info(f"🔎 Searching through {len(docs_urls)} optimization guide URLs...")
+                
+                results = []
+                matched_urls = []
+                for url in docs_urls:
+                    if any(keyword in url for keyword in query.lower().split()):
+                        logger.info(f"✅ URL matched query: {url}")
+                        matched_urls.append(url)
+                        content = fetch_huggingface_docs(url)
+                        if not content.startswith("Error"):
+                            results.append(f"From {url}:\\n{content[:1000]}...\\n")
+                            logger.info(f"📄 Successfully processed content from {url}")
+                        else:
+                            logger.warning(f"❌ Failed to fetch content from {url}")
+                    else:
+                        logger.debug(f"⏭️ URL skipped (no match): {url}")
+                
+                logger.info(f"📊 Search completed: {len(matched_urls)} URLs matched, {len(results)} successful fetches")
+                
+                if results:
+                    final_result = "\\n".join(results)
+                    logger.info(f"✅ Returning combined content ({len(final_result)} characters)")
+                    return final_result
+                else:
+                    logger.warning("❌ No specific optimization guides found for the query")
+                    return "No specific optimization guides found for the query"
+                
+            except Exception as e:
+                logger.error(f"Error searching optimization guides: {e}")
+                return f"Error searching guides: {str(e)}"
+        
+        # Define tools schema for Gemini (simplified for now)
+        tools = [
+            {
+                "function_declarations": [
+                    {
+                        "name": "fetch_huggingface_docs",
+                        "description": "Fetch current documentation from HuggingFace URLs for diffusers library, models, or optimization guides",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "url": {
+                                    "type": "string",
+                                    "description": "The HuggingFace documentation URL to fetch"
+                                }
+                            },
+                            "required": ["url"]
+                        }
+                    },
+                    {
+                        "name": "fetch_model_info",
+                        "description": "Fetch current model information and metadata from HuggingFace API",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "model_id": {
+                                    "type": "string",
+                                    "description": "The HuggingFace model ID (e.g., 'black-forest-labs/FLUX.1-schnell')"
+                                }
+                            },
+                            "required": ["model_id"]
+                        }
+                    },
+                    {
+                        "name": "search_optimization_guides",
+                        "description": "Search for optimization guides and best practices for diffusers models",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "Search query for optimization topics (e.g., 'memory', 'fp16', 'torch compile')"
+                                }
+                            },
+                            "required": ["query"]
+                        }
+                    }
+                ]
+            }
+        ]
+        
+        # Store function implementations for execution
+        self.tool_functions = {
+            'fetch_huggingface_docs': fetch_huggingface_docs,
+            'fetch_model_info': fetch_model_info,
+            'search_optimization_guides': search_optimization_guides
+        }
+        
+        logger.info(f"Created {len(tools[0]['function_declarations'])} tools for Gemini")
+        return tools
+        
+    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."""
+        
+        logger.info(f"Starting code generation for model: {model_name}")
+        logger.debug(f"Parameters: prompt='{prompt_text[:50]}...', size={image_size}, steps={num_inference_steps}")
+        logger.debug(f"Manual specs: {use_manual_specs}, Memory analysis provided: {memory_analysis is not None}")
+        
+        # Get hardware specifications
+        if use_manual_specs and manual_specs:
+            logger.info("Using manual hardware specifications")
+            hardware_specs = manual_specs
+            logger.debug(f"Manual specs: {hardware_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
+                logger.debug(f"GPU detected with {vram_gb:.1f} GB VRAM")
+                
+                if vram_gb >= 16:
+                    optimization_profile = 'performance'
+                elif vram_gb >= 8:
+                    optimization_profile = 'balanced'
+                else:
+                    optimization_profile = 'memory_efficient'
+            else:
+                optimization_profile = 'cpu_only'
+                logger.info("No GPU detected, using CPU-only profile")
+                
+            logger.info(f"Selected optimization profile: {optimization_profile}")
+        else:
+            logger.info("Using automatic hardware detection")
+            hardware_specs = self.hardware_detector.specs
+            optimization_profile = self.hardware_detector.get_optimization_profile()
+            logger.debug(f"Detected specs: {hardware_specs}")
+            logger.info(f"Auto-detected optimization profile: {optimization_profile}")
+        
+        # Create the prompt for Gemini API
+        logger.debug("Creating generation 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
+        )
+        logger.debug(f"Prompt length: {len(system_prompt)} characters")
+        
+        # Log the actual prompt being sent to Gemini API
+        logger.info("=" * 80)
+        logger.info("PROMPT SENT TO GEMINI API:")
+        logger.info("=" * 80)
+        logger.info(system_prompt)
+        logger.info("=" * 80)
+        
+        try:
+            logger.info("Sending request to Gemini API")
+            response = self.model.generate_content(system_prompt)
+            
+            # Handle tool calling if present and tools are available
+            if self.tools and response.candidates[0].content.parts:
+                for part in response.candidates[0].content.parts:
+                    if hasattr(part, 'function_call') and part.function_call:
+                        function_name = part.function_call.name
+                        function_args = dict(part.function_call.args)
+                        
+                        logger.info("🛠️ " + "=" * 60)
+                        logger.info(f"🛠️ GEMINI REQUESTED TOOL CALL: {function_name}")
+                        logger.info("🛠️ " + "=" * 60)
+                        logger.info(f"📋 Tool arguments: {function_args}")
+                        
+                        if function_name in self.tool_functions:
+                            logger.info(f"✅ Tool function found, executing...")
+                            tool_result = self.tool_functions[function_name](**function_args)
+                            logger.info("🛠️ " + "=" * 60)
+                            logger.info(f"🛠️ TOOL EXECUTION COMPLETED: {function_name}")
+                            logger.info("🛠️ " + "=" * 60)
+                            logger.info(f"📊 Tool result length: {len(str(tool_result))} characters")
+                            
+                            # Log a preview of the tool result
+                            preview = str(tool_result)[:300].replace('\\n', ' ')
+                            logger.info(f"📋 Tool result preview: {preview}...")
+                            logger.info("🛠️ " + "=" * 60)
+                            
+                            # Create a follow-up conversation with the tool result
+                            follow_up_prompt = f"""
+                            {system_prompt}
+                            
+                            ADDITIONAL CONTEXT FROM TOOLS:
+                            Tool: {function_name}
+                            Result: {tool_result}
+                            
+                            Please use this current information to generate the most up-to-date and optimized code.
+                            """
+                            
+                            # Log the follow-up prompt
+                            logger.info("=" * 80)
+                            logger.info("FOLLOW-UP PROMPT SENT TO GEMINI API (WITH TOOL RESULTS):")
+                            logger.info("=" * 80)
+                            logger.info(follow_up_prompt)
+                            logger.info("=" * 80)                            
+                            # Generate final response with tool context
+                            logger.info("Generating final response with tool context")
+                            final_response = self.model.generate_content(follow_up_prompt)
+                            logger.info("Successfully received final response from Gemini API")
+                            logger.debug(f"Final response length: {len(final_response.text)} characters")
+                            return final_response.text
+            
+            # No tool calling, return direct response
+            logger.info("Successfully received response from Gemini API (no tools used)")
+            logger.debug(f"Response length: {len(response.text)} characters")
+            return response.text
+            
+        except Exception as e:
+            logger.error(f"Error generating code: {str(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.
+
+NOTE: This system includes curated optimization knowledge from HuggingFace documentation.
+
+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 KNOWLEDGE BASE:
+{get_optimization_guide()}
+
+IMPORTANT: For FLUX.1-schnell models, do NOT include guidance_scale parameter as it's not needed.
+
+Using the OPTIMIZATION KNOWLEDGE BASE above, generate Python code that:
+
+1. **Selects the best optimization techniques** for the specific hardware profile
+2. **Applies appropriate memory optimizations** based on available VRAM
+3. **Uses optimal data types** for the target hardware:
+   - User specified dtype (if provided): Use exactly as specified
+   - Apple Silicon (MPS): prefer torch.bfloat16
+   - NVIDIA GPUs: prefer torch.float16 or torch.bfloat16 
+   - CPU only: use torch.float32
+4. **Implements hardware-specific optimizations** (CUDA, MPS, CPU)
+5. **Follows model-specific guidelines** (e.g., FLUX guidance_scale handling)
+
+IMPORTANT GUIDELINES:
+- Reference the OPTIMIZATION KNOWLEDGE BASE to select appropriate techniques
+- Include all necessary imports
+- Add brief comments explaining optimization choices
+- Generate compact, production-ready code
+- Inline values where possible for concise code
+- 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()

auto_diffusers/core/knowledge_base.py

@@ -0,0 +1,206 @@
+"""
+Curated HuggingFace Diffusers optimization knowledge base
+Manually extracted and organized for reliable prompt injection
+"""
+
+OPTIMIZATION_GUIDE = """
+# DIFFUSERS OPTIMIZATION TECHNIQUES
+
+## Memory Optimization Techniques
+
+### 1. Model CPU Offloading
+Use `enable_model_cpu_offload()` to move models between GPU and CPU automatically:
+```python
+pipe.enable_model_cpu_offload()
+```
+- Saves significant VRAM by keeping only active models on GPU
+- Automatic management, no manual intervention needed
+- Compatible with all pipelines
+
+### 2. Sequential CPU Offloading  
+Use `enable_sequential_cpu_offload()` for more aggressive memory saving:
+```python
+pipe.enable_sequential_cpu_offload()
+```
+- More memory efficient than model offloading
+- Moves models to CPU after each forward pass
+- Best for very limited VRAM scenarios
+
+### 3. Attention Slicing
+Use `enable_attention_slicing()` to reduce memory during attention computation:
+```python
+pipe.enable_attention_slicing()
+# or specify slice size
+pipe.enable_attention_slicing("max")  # maximum slicing
+pipe.enable_attention_slicing(1)      # slice_size = 1
+```
+- Trades compute time for memory
+- Most effective for high-resolution images
+- Can be combined with other techniques
+
+### 4. VAE Slicing
+Use `enable_vae_slicing()` for large batch processing:
+```python
+pipe.enable_vae_slicing()
+```
+- Decodes images one at a time instead of all at once
+- Essential for batch sizes > 4
+- Minimal performance impact on single images
+
+### 5. VAE Tiling
+Use `enable_vae_tiling()` for high-resolution image generation:
+```python
+pipe.enable_vae_tiling()
+```
+- Enables 4K+ image generation on 8GB VRAM
+- Splits images into overlapping tiles
+- Automatically disabled for 512x512 or smaller images
+
+### 6. Memory Efficient Attention (xFormers)
+Use `enable_xformers_memory_efficient_attention()` if xFormers is installed:
+```python
+pipe.enable_xformers_memory_efficient_attention()
+```
+- Significantly reduces memory usage and improves speed
+- Requires xformers library installation
+- Compatible with most models
+
+## Performance Optimization Techniques
+
+### 1. Half Precision (FP16/BF16)
+Use lower precision for better memory and speed:
+```python
+# FP16 (widely supported)
+pipe = DiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
+
+# BF16 (better numerical stability, newer hardware)
+pipe = DiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
+```
+- FP16: Halves memory usage, widely supported
+- BF16: Better numerical stability, requires newer GPUs
+- Essential for most optimization scenarios
+
+### 2. Torch Compile (PyTorch 2.0+)
+Use `torch.compile()` for significant speed improvements:
+```python
+pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
+# For some models, compile VAE too:
+pipe.vae.decode = torch.compile(pipe.vae.decode, mode="reduce-overhead", fullgraph=True)
+```
+- 5-50% speed improvement
+- Requires PyTorch 2.0+
+- First run is slower due to compilation
+
+### 3. Fast Schedulers
+Use faster schedulers for fewer steps:
+```python
+from diffusers import LMSDiscreteScheduler, UniPCMultistepScheduler
+
+# LMS Scheduler (good quality, fast)
+pipe.scheduler = LMSDiscreteScheduler.from_config(pipe.scheduler.config)
+
+# UniPC Scheduler (fastest)
+pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+```
+
+## Hardware-Specific Optimizations
+
+### NVIDIA GPU Optimizations
+```python
+# Enable Tensor Cores
+torch.backends.cudnn.benchmark = True
+
+# Optimal data type for NVIDIA
+torch_dtype = torch.float16  # or torch.bfloat16 for RTX 30/40 series
+```
+
+### Apple Silicon (MPS) Optimizations
+```python
+# Use MPS device
+device = "mps" if torch.backends.mps.is_available() else "cpu"
+pipe = pipe.to(device)
+
+# Recommended dtype for Apple Silicon
+torch_dtype = torch.bfloat16  # Better than float16 on Apple Silicon
+
+# Attention slicing often helps on MPS
+pipe.enable_attention_slicing()
+```
+
+### CPU Optimizations
+```python
+# Use float32 for CPU
+torch_dtype = torch.float32
+
+# Enable optimized attention
+pipe.enable_attention_slicing()
+```
+
+## Model-Specific Guidelines
+
+### FLUX Models
+- Do NOT use guidance_scale parameter (not needed for FLUX)
+- Use 4-8 inference steps maximum
+- BF16 dtype recommended
+- Enable attention slicing for memory optimization
+
+### Stable Diffusion XL
+- Enable attention slicing for high resolutions
+- Use refiner model sparingly to save memory
+- Consider VAE tiling for >1024px images
+
+### Stable Diffusion 1.5/2.1
+- Very memory efficient base models
+- Can often run without optimizations on 8GB+ VRAM
+- Enable VAE slicing for batch processing
+
+## Memory Usage Estimation
+- FLUX.1: ~24GB for full precision, ~12GB for FP16
+- SDXL: ~7GB for FP16, ~14GB for FP32
+- SD 1.5: ~2GB for FP16, ~4GB for FP32
+
+## Optimization Combinations by VRAM
+
+### 24GB+ VRAM (High-end)
+```python
+pipe = DiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
+pipe = pipe.to("cuda")
+pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
+```
+
+### 12-24GB VRAM (Mid-range)
+```python
+pipe = DiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
+pipe = pipe.to("cuda")
+pipe.enable_model_cpu_offload()
+pipe.enable_xformers_memory_efficient_attention()
+```
+
+### 8-12GB VRAM (Entry-level)
+```python
+pipe = DiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
+pipe.enable_sequential_cpu_offload()
+pipe.enable_attention_slicing()
+pipe.enable_vae_slicing()
+pipe.enable_xformers_memory_efficient_attention()
+```
+
+### <8GB VRAM (Low-end)
+```python
+pipe = DiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
+pipe.enable_sequential_cpu_offload()
+pipe.enable_attention_slicing("max")
+pipe.enable_vae_slicing()
+pipe.enable_vae_tiling()
+```
+"""
+
+
+def get_optimization_guide():
+    """Return the curated optimization guide."""
+    return OPTIMIZATION_GUIDE
+
+
+if __name__ == "__main__":
+    print("Optimization guide loaded successfully!")
+    print(f"Guide length: {len(OPTIMIZATION_GUIDE)} characters")

auto_diffusers/hardware/__init__.py

@@ -0,0 +1,14 @@
+"""
+Hardware detection and analysis components.
+
+This module provides hardware detection capabilities and memory
+requirement analysis for diffusion models.
+"""
+
+from .detector import HardwareDetector
+from .memory_calculator import SimpleMemoryCalculator
+
+__all__ = [
+    "HardwareDetector",
+    "SimpleMemoryCalculator"
+]

auto_diffusers/hardware/detector.py

@@ -0,0 +1,196 @@
+import platform
+import subprocess
+import os
+import logging
+from typing import Dict, Optional
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class HardwareDetector:
+    def __init__(self):
+        logger.info("Initializing HardwareDetector")
+        try:
+            self.specs = self._detect_system_specs()
+            logger.info("Hardware detection completed successfully")
+            logger.debug(f"Detected specs: {self.specs}")
+        except Exception as e:
+            logger.error(f"Failed to detect hardware specs: {e}")
+            raise
+    
+    def _detect_system_specs(self) -> Dict:
+        """Detect system hardware specifications automatically."""
+        logger.debug("Starting system hardware detection")
+        
+        platform_info = platform.system()
+        architecture = platform.machine()
+        cpu_count = os.cpu_count()
+        python_version = platform.python_version()
+        
+        logger.debug(f"Platform: {platform_info}, Architecture: {architecture}")
+        logger.debug(f"CPU cores: {cpu_count}, Python: {python_version}")
+        
+        gpu_info = self._detect_gpu()
+        
+        specs = {
+            'platform': platform_info,
+            'architecture': architecture,
+            'cpu_count': cpu_count,
+            'python_version': python_version,
+            'gpu_info': gpu_info,
+            'cuda_available': False,
+            'mps_available': False
+        }
+        
+        # Check for PyTorch and device availability
+        logger.debug("Checking PyTorch availability")
+        try:
+            import torch
+            torch_version = torch.__version__
+            cuda_available = torch.cuda.is_available()
+            mps_available = torch.backends.mps.is_available()
+            
+            logger.info(f"PyTorch {torch_version} detected")
+            logger.debug(f"CUDA available: {cuda_available}, MPS available: {mps_available}")
+            
+            specs['torch_version'] = torch_version
+            specs['cuda_available'] = cuda_available
+            specs['mps_available'] = mps_available
+            
+            if cuda_available:
+                device_count = torch.cuda.device_count()
+                device_name = torch.cuda.get_device_name(0)
+                device_memory = torch.cuda.get_device_properties(0).total_memory // (1024**3)
+                
+                logger.info(f"CUDA devices: {device_count}, Primary: {device_name} ({device_memory}GB)")
+                
+                specs['cuda_device_count'] = device_count
+                specs['cuda_device_name'] = device_name
+                specs['cuda_memory'] = device_memory
+                
+        except ImportError as e:
+            logger.warning(f"PyTorch not installed: {e}")
+            specs['torch_version'] = 'Not installed'
+            
+        return specs
+    
+    def _detect_gpu(self) -> Optional[Dict]:
+        """Attempt to detect GPU information using nvidia-smi."""
+        logger.debug("Attempting GPU detection via nvidia-smi")
+        try:
+            result = subprocess.run([
+                'nvidia-smi', 
+                '--query-gpu=name,memory.total', 
+                '--format=csv,noheader,nounits'
+            ], capture_output=True, text=True, check=True)
+            
+            logger.debug(f"nvidia-smi output: {result.stdout}")
+            
+            lines = result.stdout.strip().split('\n')
+            gpus = []
+            logger.debug(f"Found {len(lines)} GPU entries")
+            for line in lines:
+                if line.strip():
+                    try:
+                        name, memory = line.split(', ')
+                        gpu_entry = {'name': name.strip(), 'memory_mb': int(memory)}
+                        gpus.append(gpu_entry)
+                        logger.debug(f"Parsed GPU: {gpu_entry}")
+                    except ValueError as e:
+                        logger.warning(f"Failed to parse GPU line '{line}': {e}")
+            
+            logger.info(f"Successfully detected {len(gpus)} GPUs")
+            return gpus
+            
+        except subprocess.CalledProcessError as e:
+            logger.warning(f"nvidia-smi command failed: {e}")
+            return None
+        except FileNotFoundError:
+            logger.debug("nvidia-smi not found, no NVIDIA GPU detected")
+            return None
+        except Exception as e:
+            logger.error(f"Unexpected error during GPU detection: {e}")
+            return None
+    
+    def get_manual_input(self) -> Dict:
+        """Get hardware specifications via manual user input."""
+        logger.info("Starting manual hardware input")
+        print("Enter your hardware specifications manually:")
+        
+        gpu_name = input("GPU Name (e.g., RTX 4090, A100, leave empty if none): ").strip()
+        logger.debug(f"User input GPU name: '{gpu_name}'")
+        
+        if gpu_name:
+            try:
+                vram_gb = int(input("VRAM in GB (e.g., 24): "))
+                gpu_info = [{'name': gpu_name, 'memory_mb': vram_gb * 1024}]
+                logger.info(f"Manual GPU configured: {gpu_name} with {vram_gb}GB VRAM")
+            except ValueError as e:
+                logger.warning(f"Invalid VRAM input: {e}")
+                gpu_info = None
+        else:
+            gpu_info = None
+            logger.info("No GPU specified in manual input")
+            
+        try:
+            ram_gb = int(input("System RAM in GB (e.g., 32): "))
+            logger.debug(f"User input RAM: {ram_gb}GB")
+        except ValueError as e:
+            logger.warning(f"Invalid RAM input: {e}, using default 16GB")
+            ram_gb = 16  # Default
+            
+        specs = self.specs.copy()
+        specs['gpu_info'] = gpu_info
+        specs['ram_gb'] = ram_gb
+        specs['manual_input'] = True
+        
+        logger.info(f"Manual hardware specs configured: {specs}")
+        return specs
+    
+    def get_optimization_profile(self) -> str:
+        """Determine the best optimization profile based on hardware."""
+        logger.debug("Determining optimization profile")
+        
+        if self.specs['cuda_available']:
+            cuda_memory = self.specs.get('cuda_memory', 0)
+            logger.debug(f"CUDA available with {cuda_memory}GB memory")
+            
+            if cuda_memory >= 20:
+                profile = 'high_end_gpu'
+            elif cuda_memory >= 8:
+                profile = 'mid_range_gpu'
+            else:
+                profile = 'low_vram_gpu'
+                
+        elif self.specs['mps_available']:
+            logger.debug("MPS available, using Apple Silicon profile")
+            profile = 'apple_silicon'
+        else:
+            logger.debug("No GPU acceleration available, using CPU-only profile")
+            profile = 'cpu_only'
+            
+        logger.info(f"Selected optimization profile: {profile}")
+        return profile
+    
+    def print_specs(self):
+        """Print detected hardware specifications."""
+        logger.info("Printing 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']}")
+        
+        logger.debug("Hardware specs display completed")
+        
+        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")
+

auto_diffusers/hardware/memory_calculator.py

@@ -0,0 +1,276 @@
+from huggingface_hub import HfApi, hf_hub_download
+from typing import Dict, Optional
+import json
+import os
+import logging
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class SimpleMemoryCalculator:
+    def __init__(self):
+        logger.info("Initializing SimpleMemoryCalculator")
+        try:
+            self.hf_api = HfApi()
+            logger.debug("HuggingFace API initialized")
+        except Exception as e:
+            logger.error(f"Failed to initialize HuggingFace API: {e}")
+            raise
+            
+        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
+            }
+        }
+        
+        logger.debug(f"Known models in database: {len(self.known_models)}")
+    
+    def get_model_memory_requirements(self, model_id: str) -> Dict:
+        """
+        Get memory requirements for a model, using known values or estimating from file sizes.
+        """
+        logger.info(f"Getting memory requirements for model: {model_id}")
+        
+        if model_id in self.cache:
+            logger.debug(f"Using cached memory data for {model_id}")
+            return self.cache[model_id]
+        
+        # Check if we have known values
+        if model_id in self.known_models:
+            logger.info(f"Using known memory data for {model_id}")
+            known = self.known_models[model_id]
+            logger.debug(f"Known data: {known}")
+            
+            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
+            logger.info(f"Successfully estimated memory for {model_id} via API")
+            logger.debug(f"API estimation result: {result}")
+            return result
+            
+        except Exception as api_error:
+            logger.error(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."""
+        logger.warning(f"Using generic estimation for {model_id} due to: {error_msg}")
+        
+        # Default to medium-sized model estimates
+        default_params_billions = 3.0
+        default_fp16_gb = 6.0
+        
+        logger.debug(f"Generic estimation parameters: {default_params_billions}B params, {default_fp16_gb}GB FP16")
+        
+        result = {
+            '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
+        }
+        
+        logger.info(f"Generic estimation completed for {model_id}")
+        return result
+    
+    def get_memory_recommendation(self, model_id: str, available_vram_gb: float) -> Dict:
+        """Get memory recommendations based on available VRAM."""
+        logger.info(f"Generating memory recommendations for {model_id} with {available_vram_gb}GB 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']
+        
+        logger.debug(f"Model memory: {model_memory_fp16}GB, Inference memory: {inference_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()
+
+

auto_diffusers/ui/__init__.py

@@ -0,0 +1,12 @@
+"""
+User interface components.
+
+This module contains the web interface and UI components
+for the Auto Diffusers application.
+"""
+
+from .gradio_interface import create_gradio_interface
+
+__all__ = [
+    "create_gradio_interface"
+]

auto_diffusers/ui/__pycache__/gradio_interface.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:817b8406277df29c7ea8920085efcaca842422c6228346dbcacd5ce39853bf4e
+size 106270

auto_diffusers/ui/__pycache__/gradio_interface.cpython-312.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb50d6060e996af9fc7a103042a23da0a351042bf02882f8d3dd3eae4dd37a67
+size 100434

auto_diffusers/utils/__init__.py

@@ -0,0 +1,14 @@
+"""
+Utilities and configuration.
+
+This module contains shared utilities, configuration management,
+and logging setup for the Auto Diffusers application.
+"""
+
+from .logging_config import setup_debug_logging, log_system_info, log_session_end
+
+__all__ = [
+    "setup_debug_logging",
+    "log_system_info", 
+    "log_session_end"
+]

auto_diffusers/utils/logging_config.py

@@ -0,0 +1,162 @@
+"""
+Debug configuration for Auto Diffusers Config
+Provides centralized logging setup for the entire application
+"""
+
+import logging
+import os
+from datetime import datetime
+
+def setup_debug_logging(log_level='DEBUG', log_to_file=True, log_to_console=True):
+    """
+    Set up comprehensive debug logging for the entire application
+    
+    Args:
+        log_level (str): Logging level ('DEBUG', 'INFO', 'WARNING', 'ERROR')
+        log_to_file (bool): Whether to log to files
+        log_to_console (bool): Whether to log to console
+    """
+    
+    # Create logs directory if it doesn't exist
+    if log_to_file:
+        os.makedirs('logs', exist_ok=True)
+    
+    # Clear any existing handlers
+    root_logger = logging.getLogger()
+    root_logger.handlers.clear()
+    
+    # Set root logging level
+    numeric_level = getattr(logging, log_level.upper(), logging.DEBUG)
+    root_logger.setLevel(numeric_level)
+    
+    # Create formatter
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    
+    handlers = []
+    
+    # Console handler
+    if log_to_console:
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(numeric_level)
+        console_handler.setFormatter(formatter)
+        handlers.append(console_handler)
+    
+    # File handlers
+    if log_to_file:
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        
+        # Main application log
+        main_log_file = f'logs/auto_diffusers_{timestamp}.log'
+        file_handler = logging.FileHandler(main_log_file)
+        file_handler.setLevel(numeric_level)
+        file_handler.setFormatter(formatter)
+        handlers.append(file_handler)
+        
+        # Error-only log
+        error_log_file = f'logs/errors_{timestamp}.log'
+        error_handler = logging.FileHandler(error_log_file)
+        error_handler.setLevel(logging.ERROR)
+        error_handler.setFormatter(formatter)
+        handlers.append(error_handler)
+    
+    # Add all handlers to root logger
+    for handler in handlers:
+        root_logger.addHandler(handler)
+    
+    # Set up specific logger configurations
+    configure_component_loggers(numeric_level)
+    
+    logging.info("=" * 80)
+    logging.info("AUTO DIFFUSERS CONFIG - DEBUG SESSION STARTED")
+    logging.info("=" * 80)
+    logging.info(f"Log level: {log_level}")
+    logging.info(f"Logging to console: {log_to_console}")
+    logging.info(f"Logging to file: {log_to_file}")
+    if log_to_file:
+        logging.info(f"Main log file: {main_log_file}")
+        logging.info(f"Error log file: {error_log_file}")
+    logging.info("=" * 80)
+
+
+def configure_component_loggers(level):
+    """Configure logging for individual components"""
+    
+    # Main application components
+    components = [
+        'auto_diffusers',
+        'hardware_detector', 
+        'simple_memory_calculator',
+        'gradio_app',
+        '__main__'
+    ]
+    
+    for component in components:
+        logger = logging.getLogger(component)
+        logger.setLevel(level)
+        # Don't propagate to avoid duplicate messages
+        logger.propagate = True
+    
+    # Third-party library logging (reduce verbosity)
+    third_party_loggers = {
+        'urllib3': logging.WARNING,
+        'requests': logging.WARNING,
+        'httpx': logging.WARNING,
+        'gradio': logging.INFO,
+        'google': logging.INFO,
+        'huggingface_hub': logging.INFO
+    }
+    
+    for lib_name, lib_level in third_party_loggers.items():
+        lib_logger = logging.getLogger(lib_name)
+        lib_logger.setLevel(lib_level)
+
+
+def log_system_info():
+    """Log comprehensive system information at startup"""
+    import platform
+    import sys
+    import os
+    
+    logger = logging.getLogger(__name__)
+    
+    logger.info("SYSTEM INFORMATION:")
+    logger.info(f"  Platform: {platform.system()} {platform.release()}")
+    logger.info(f"  Architecture: {platform.machine()}")
+    logger.info(f"  Python: {sys.version}")
+    logger.info(f"  Working directory: {os.getcwd()}")
+    logger.info(f"  Process ID: {os.getpid()}")
+    
+    # Environment variables (non-sensitive)
+    env_vars = ['GOOGLE_API_KEY', 'CUDA_VISIBLE_DEVICES', 'PYTORCH_CUDA_ALLOC_CONF']
+    logger.info("ENVIRONMENT VARIABLES:")
+    for var in env_vars:
+        value = os.getenv(var, 'Not set')
+        if var == 'GOOGLE_API_KEY' and value != 'Not set':
+            value = f"Set (length: {len(value)})"
+        logger.info(f"  {var}: {value}")
+
+
+def log_session_end():
+    """Log session end information"""
+    logger = logging.getLogger(__name__)
+    logger.info("=" * 80)
+    logger.info("AUTO DIFFUSERS CONFIG - DEBUG SESSION ENDED")
+    logger.info("=" * 80)
+
+
+if __name__ == "__main__":
+    # Example usage
+    setup_debug_logging(log_level='DEBUG')
+    log_system_info()
+    
+    # Test logging from different components
+    logger = logging.getLogger(__name__)
+    logger.debug("This is a debug message")
+    logger.info("This is an info message")
+    logger.warning("This is a warning message")
+    logger.error("This is an error message")
+    
+    log_session_end()

main.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""
+Main entry point for the Auto Diffusers application.
+Simple launcher that starts the Gradio web interface.
+"""
+
+from auto_diffusers.ui.gradio_interface import main
+
+if __name__ == "__main__":
+    main()

scripts/__init__.py

@@ -0,0 +1,3 @@
+"""
+Entry point scripts for the Auto Diffusers application.
+"""

scripts/launch.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+Simple launcher script for the Gradio app with better error handling and debug logging.
+"""
+
+import os
+import sys
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Import and setup debug configuration
+try:
+    from auto_diffusers.utils.logging_config import setup_debug_logging, log_system_info, log_session_end
+    import logging
+    
+    # Setup debug logging (can be controlled via environment variable)
+    debug_level = os.getenv('DEBUG_LEVEL', 'INFO')
+    log_to_file = os.getenv('LOG_TO_FILE', 'true').lower() == 'true'
+    log_to_console = os.getenv('LOG_TO_CONSOLE', 'true').lower() == 'true'
+    
+    setup_debug_logging(log_level=debug_level, log_to_file=log_to_file, log_to_console=log_to_console)
+    logger = logging.getLogger(__name__)
+    
+except ImportError:
+    # Fallback if logging_config is not available
+    import logging
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)
+
+def check_requirements():
+    """Check if all required packages are installed."""
+    logger.info("Checking package requirements...")
+    
+    required_packages = [
+        'gradio', 'google.generativeai', 'torch', 'psutil'
+    ]
+    
+    missing = []
+    for package in required_packages:
+        try:
+            __import__(package.replace('-', '_'))
+            logger.debug(f"✓ Package {package} found")
+        except ImportError:
+            missing.append(package)
+            logger.warning(f"✗ Package {package} missing")
+    
+    if missing:
+        logger.error(f"Missing packages: {', '.join(missing)}")
+        print(f"Missing packages: {', '.join(missing)}")
+        print("Please run: pip install -r requirements.txt")
+        return False
+    
+    logger.info("All required packages are available")
+    return True
+
+def check_api_key():
+    """Check if API key is configured."""
+    logger.info("Checking API key configuration...")
+    
+    api_key = os.getenv('GOOGLE_API_KEY')
+    if not api_key:
+        logger.error("GOOGLE_API_KEY not found in environment variables")
+        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
+    
+    logger.info(f"API key found (length: {len(api_key)})")
+    return True
+
+def main():
+    logger.info("Starting Auto Diffusers Config application")
+    print("🚀 Starting Auto Diffusers Config Gradio App...")
+    
+    # Log system information
+    try:
+        log_system_info()
+    except:
+        logger.warning("Could not log system info")
+    
+    # Check requirements
+    if not check_requirements():
+        logger.error("Requirements check failed, exiting")
+        sys.exit(1)
+    
+    if not check_api_key():
+        logger.error("API key check failed, exiting")
+        sys.exit(1)
+    
+    try:
+        logger.info("Importing Gradio interface module")
+        from auto_diffusers.ui.gradio_interface import create_gradio_interface
+        
+        logger.info("All requirements satisfied, launching interface")
+        print("✅ All requirements satisfied")
+        print("🌐 Launching Gradio interface...")
+        
+        interface = create_gradio_interface()
+        logger.info("Gradio interface created successfully")
+        
+        logger.info("Starting Gradio server on 0.0.0.0:7860")
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True,
+            show_error=True,
+            inbrowser=True
+        )
+        
+    except ImportError as e:
+        logger.error(f"Import error: {e}")
+        print(f"Import error: {e}")
+        print("Make sure all dependencies are installed: pip install -r requirements.txt")
+    except Exception as e:
+        logger.error(f"Error launching app: {e}", exc_info=True)
+        print(f"Error launching app: {e}")
+    finally:
+        try:
+            log_session_end()
+        except:
+            logger.warning("Could not log session end")
+
+if __name__ == "__main__":
+    main()

tests/__init__.py

@@ -0,0 +1,3 @@
+"""
+Test suite for the Auto Diffusers application.
+"""