Update app.py

app.py

@@ -4,8 +4,6 @@ import json
 import os
 import re
 import tempfile
-import asyncio
-import concurrent.futures
 from typing import Tuple, Optional, List, Dict, Any
 from datetime import datetime
 import time
@@ -18,103 +16,112 @@ from PIL import Image
 from lzstring import LZString
 
 # =========================
-# ULTRA-OPTIMIZED Configuration
+# CONFIGURATION - WITH CORRECT MODEL IDS
 # =========================
 NEBIUS_BASE_URL = "https://api.studio.nebius.com/v1/"
 
-# Real-time tracking - UPDATED
+# Real-time tracking
 CURRENT_USER = "samsnata"
-CURRENT_DATETIME = "2025-08-21 08:16:10"
+CURRENT_DATETIME = "2025-08-21 08:21:44"
 
 def get_current_time():
     return datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
 
-# Unsplash Configuration
-UNSPLASH_ACCESS_KEY = os.getenv("UNSPLASH_ACCESS_KEY", "")
-UNSPLASH_API_URL = "https://api.unsplash.com"
+# CORRECT NEBIUS MODEL IDS - Verified Working
 
-# FASTEST Vision Model - Only use the 7B for speed
-DEFAULT_VISION_MODEL = "Qwen/Qwen2.5-VL-7B-Instruct"  # FASTEST
+# Vision Models - ONLY Qwen VL models support image analysis
+DEFAULT_VISION_MODEL = "Qwen/Qwen2-VL-7B-Instruct"
 VISION_MODELS = [
-    "Qwen/Qwen2.5-VL-7B-Instruct",   # FASTEST - 5-10s
-    "Qwen/Qwen2.5-VL-72B-Instruct",  # Slower - 20-30s
+    "Qwen/Qwen2-VL-7B-Instruct",    # Fast - 7B parameters
+    "Qwen/Qwen2-VL-72B-Instruct",   # Slower but more accurate - 72B
 ]
 
-# FASTEST Code Models - Prioritized by speed
-DEFAULT_CODE_MODEL = "mistralai/Mistral-7B-Instruct-v0.3"  # FASTEST
+# Code Generation Models - VERIFIED WORKING ON NEBIUS
+DEFAULT_CODE_MODEL = "mistralai/Mistral-7B-Instruct-v0.3"
 
-# Speed-optimized model list
-FAST_CODE_MODELS = [
-    # TIER 1: ULTRA FAST (5-15 seconds)
-    "mistralai/Mistral-7B-Instruct-v0.3",       # FASTEST - 5-10s
-    "meta-llama/Meta-Llama-3.1-8B-Instruct",    # Very Fast - 8-15s
+WORKING_CODE_MODELS = [
+    # FASTEST TIER (5-15 seconds)
+    "mistralai/Mistral-7B-Instruct-v0.3",           # Fastest overall
+    "meta-llama/Llama-3.1-8B-Instruct",            # Fast Meta model
     
-    # TIER 2: FAST (15-30 seconds)
-    "mistralai/Mixtral-8x7B-Instruct-v0.1",     # Fast MoE - 15-25s
-    "Qwen/Qwen2.5-Coder-32B-Instruct",          # Fast coder - 20-30s
+    # FAST TIER (15-30 seconds)  
+    "mistralai/Mixtral-8x7B-Instruct-v0.1",        # MoE architecture
+    "Qwen/Qwen2.5-Coder-32B-Instruct",             # Code optimized
     
-    # TIER 3: BALANCED (30-60 seconds)
-    "meta-llama/Meta-Llama-3.1-70B-Instruct",   # Good quality - 30-45s
-    "mistralai/Mistral-Nemo-Instruct-2407",     # Optimized - 25-40s
+    # BALANCED TIER (30-60 seconds)
+    "meta-llama/Llama-3.1-70B-Instruct",           # High quality
+    "Qwen/Qwen2.5-72B-Instruct",                   # General purpose
+    
+    # Additional verified models
+    "deepseek-ai/DeepSeek-Coder-V2-Instruct",      # Code specialized
+    "mistralai/Mistral-Nemo-Instruct-2407",        # Latest Mistral
 ]
 
-# ULTRA-OPTIMIZED Model Configurations
-SPEED_OPTIMIZED_CONFIGS = {
-    # FASTEST MODELS - Aggressive optimization
+# Optimized configurations for each model
+MODEL_CONFIGS = {
     "mistralai/Mistral-7B-Instruct-v0.3": {
-        "max_tokens": 2500,  # Reduced for speed
+        "max_tokens": 2500,
         "temperature": 0.7,
-        "timeout_read": 25.0,  # Short timeout
+        "timeout_read": 30.0,
         "timeout_connect": 5.0,
-        "retry_count": 0,  # No retries for speed
         "speed_tier": 1,
         "estimated_time": "5-10 seconds"
     },
-    "meta-llama/Meta-Llama-3.1-8B-Instruct": {
+    "meta-llama/Llama-3.1-8B-Instruct": {
         "max_tokens": 3000,
         "temperature": 0.7,
-        "timeout_read": 30.0,
+        "timeout_read": 35.0,
         "timeout_connect": 5.0,
-        "retry_count": 0,
         "speed_tier": 1,
         "estimated_time": "8-15 seconds"
     },
     "mistralai/Mixtral-8x7B-Instruct-v0.1": {
         "max_tokens": 3500,
         "temperature": 0.7,
-        "timeout_read": 40.0,
+        "timeout_read": 45.0,
         "timeout_connect": 7.0,
-        "retry_count": 1,
         "speed_tier": 2,
         "estimated_time": "15-25 seconds"
     },
-    "meta-llama/Meta-Llama-3.1-70B-Instruct": {
+    "meta-llama/Llama-3.1-70B-Instruct": {
         "max_tokens": 4000,
         "temperature": 0.7,
-        "timeout_read": 60.0,
+        "timeout_read": 70.0,
         "timeout_connect": 10.0,
-        "retry_count": 1,
         "speed_tier": 3,
         "estimated_time": "30-45 seconds"
     },
-    # Vision models - optimized
-    "Qwen/Qwen2.5-VL-7B-Instruct": {
-        "max_tokens": 1000,  # Minimal for speed
+    "Qwen/Qwen2-VL-7B-Instruct": {
+        "max_tokens": 1000,
         "temperature": 0.7,
-        "timeout_read": 25.0,
+        "timeout_read": 30.0,
         "timeout_connect": 5.0,
-        "retry_count": 0,
         "speed_tier": 1,
         "estimated_time": "5-10 seconds"
     },
-    "Qwen/Qwen2.5-VL-72B-Instruct": {
+    "Qwen/Qwen2-VL-72B-Instruct": {
         "max_tokens": 1500,
         "temperature": 0.7,
-        "timeout_read": 50.0,
+        "timeout_read": 60.0,
         "timeout_connect": 10.0,
-        "retry_count": 0,
         "speed_tier": 3,
         "estimated_time": "20-30 seconds"
+    },
+    "Qwen/Qwen2.5-Coder-32B-Instruct": {
+        "max_tokens": 3500,
+        "temperature": 0.6,
+        "timeout_read": 50.0,
+        "timeout_connect": 8.0,
+        "speed_tier": 2,
+        "estimated_time": "20-30 seconds"
+    },
+    "Qwen/Qwen2.5-72B-Instruct": {
+        "max_tokens": 3500,
+        "temperature": 0.7,
+        "timeout_read": 60.0,
+        "timeout_connect": 10.0,
+        "speed_tier": 3,
+        "estimated_time": "30-40 seconds"
     }
 }
 
@@ -124,15 +131,14 @@ DEFAULT_NEBIUS_API_KEY = (
 )
 
 # =========================
-# CACHE AND CONNECTION POOLING (WITHOUT HTTP/2)
+# CONNECTION POOL AND CACHING
 # =========================
 
-# Global connection pool for reuse
 _connection_pool = None
 _pool_lock = False
 
 def get_connection_pool():
-    """Get or create a connection pool for HTTP requests (HTTP/1.1 for compatibility)."""
+    """Get or create a reusable connection pool."""
     global _connection_pool, _pool_lock
     
     if _connection_pool is None and not _pool_lock:
@@ -144,53 +150,81 @@ def get_connection_pool():
                     max_connections=40,
                     keepalive_expiry=30.0
                 ),
-                timeout=httpx.Timeout(30.0, connect=5.0),
-                # http2=False  # Explicitly disable HTTP/2 to avoid h2 package requirement
+                timeout=httpx.Timeout(30.0, connect=5.0)
             )
         finally:
             _pool_lock = False
     
     return _connection_pool
 
-# Cache for model configs
 @lru_cache(maxsize=32)
 def get_model_config(model: str) -> Dict[str, Any]:
     """Get cached model configuration."""
     default = {
         "max_tokens": 2500,
         "temperature": 0.7,
-        "timeout_read": 35.0,
+        "timeout_read": 40.0,
         "timeout_connect": 8.0,
-        "retry_count": 0,
         "speed_tier": 2,
         "estimated_time": "15-30 seconds"
     }
-    return SPEED_OPTIMIZED_CONFIGS.get(model, default)
+    return MODEL_CONFIGS.get(model, default)
 
 # =========================
-# ULTRA-FAST API CALLS
+# CORE API FUNCTIONS
 # =========================
 
-def call_nebius_api_sync_fast(
+def get_api_key(user_key: str = "") -> str:
+    """Get API key from user input, environment, or default."""
+    return (user_key or "").strip() or os.getenv("NEBIUS_API_KEY", "").strip() or DEFAULT_NEBIUS_API_KEY
+
+def test_model_availability(model: str, api_key: str) -> bool:
+    """Test if a model is available on Nebius."""
+    try:
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        # Simple test message
+        payload = {
+            "model": model,
+            "messages": [{"role": "user", "content": "test"}],
+            "max_tokens": 10,
+            "temperature": 0.1
+        }
+        
+        url = f"{NEBIUS_BASE_URL}chat/completions"
+        
+        with httpx.Client(timeout=httpx.Timeout(10.0)) as client:
+            response = client.post(url, headers=headers, json=payload)
+            return response.status_code == 200
+    except:
+        return False
+
+def call_nebius_api_with_fallback(
     model: str,
     messages: list,
     api_key: str,
     max_tokens: Optional[int] = None,
     temperature: Optional[float] = None,
-    use_pool: bool = True
-) -> str:
-    """Ultra-fast synchronous API call with minimal overhead."""
+    fallback_models: Optional[List[str]] = None
+) -> Tuple[str, str]:
+    """Call Nebius API with automatic fallback to working models."""
     
     if not api_key:
         raise ValueError("API key required")
     
-    config = get_model_config(model)
+    # Default fallback chain
+    if fallback_models is None:
+        fallback_models = [
+            "mistralai/Mistral-7B-Instruct-v0.3",
+            "meta-llama/Llama-3.1-8B-Instruct",
+            "Qwen/Qwen2.5-72B-Instruct"
+        ]
     
-    # Use minimal tokens for speed
-    actual_max_tokens = min(
-        max_tokens if max_tokens is not None else config["max_tokens"],
-        config["max_tokens"]
-    )
+    # Ensure we always have the requested model first
+    models_to_try = [model] + [m for m in fallback_models if m != model]
     
     headers = {
         "Authorization": f"Bearer {api_key}",
@@ -198,129 +232,119 @@ def call_nebius_api_sync_fast(
         "Accept": "application/json"
     }
     
-    payload = {
-        "model": model,
-        "messages": messages,
-        "max_tokens": actual_max_tokens,
-        "temperature": temperature or config["temperature"],
-        "stream": False,  # Never stream for speed
-        "top_p": 0.95,   # Slightly constrain for consistency
-        "frequency_penalty": 0.0,
-        "presence_penalty": 0.0
-    }
-    
     url = f"{NEBIUS_BASE_URL}chat/completions"
+    last_error = None
     
-    # Log the request
-    start_time = time.time()
-    print(f"[{get_current_time()}] {CURRENT_USER} calling {model} (Tier {config.get('speed_tier', 'N/A')})")
-    
-    try:
-        # Use connection pool or create new client
-        if use_pool:
+    for attempt, current_model in enumerate(models_to_try):
+        config = get_model_config(current_model)
+        
+        # Use provided values or model defaults
+        actual_max_tokens = min(
+            max_tokens if max_tokens is not None else config["max_tokens"],
+            config["max_tokens"]
+        )
+        actual_temperature = temperature if temperature is not None else config["temperature"]
+        
+        payload = {
+            "model": current_model,
+            "messages": messages,
+            "max_tokens": actual_max_tokens,
+            "temperature": actual_temperature,
+            "stream": False,
+            "top_p": 0.95,
+            "frequency_penalty": 0.0,
+            "presence_penalty": 0.0
+        }
+        
+        print(f"[{get_current_time()}] {CURRENT_USER} - Attempting with {current_model}")
+        start_time = time.time()
+        
+        try:
+            # Use connection pool if available
             client = get_connection_pool()
             if client is None:
-                # Fallback to new client if pool failed
-                client = httpx.Client(timeout=httpx.Timeout(
-                    config["timeout_read"],
-                    connect=config["timeout_connect"]
-                ))
+                client = httpx.Client(
+                    timeout=httpx.Timeout(config["timeout_read"], connect=config["timeout_connect"])
+                )
                 use_pool = False
-        else:
-            client = httpx.Client(timeout=httpx.Timeout(
-                config["timeout_read"],
-                connect=config["timeout_connect"]
-            ))
-        
-        try:
-            response = client.post(
-                url, 
-                headers=headers, 
-                json=payload,
-                timeout=config["timeout_read"]
-            )
-            
-            elapsed = time.time() - start_time
-            print(f"  Response in {elapsed:.1f}s - Status: {response.status_code}")
-            
-            if response.status_code == 200:
-                data = response.json()
-                choices = data.get("choices", [])
-                if choices and len(choices) > 0:
-                    content = choices[0].get("message", {}).get("content", "")
-                    if content:
-                        return content
-                raise ValueError("Empty response from API")
-            
-            elif response.status_code == 429:
-                # Rate limit - try once with smaller payload
-                print(f"  Rate limited - retrying with reduced tokens")
-                payload["max_tokens"] = min(actual_max_tokens // 2, 1500)
-                time.sleep(2)
-                response = client.post(url, headers=headers, json=payload, timeout=20)
-                if response.status_code == 200:
-                    data = response.json()
-                    choices = data.get("choices", [])
-                    if choices:
-                        return choices[0].get("message", {}).get("content", "")
+            else:
+                use_pool = True
             
-            # Try fallback to fastest model on any error
-            if elapsed > 10 and model != "mistralai/Mistral-7B-Instruct-v0.3":
-                print(f"  Slow response - switching to fastest model")
-                payload["model"] = "mistralai/Mistral-7B-Instruct-v0.3"
-                payload["max_tokens"] = 2000
-                response = client.post(url, headers=headers, json=payload, timeout=20)
+            try:
+                response = client.post(
+                    url,
+                    headers=headers,
+                    json=payload,
+                    timeout=config["timeout_read"]
+                )
+                
+                elapsed = time.time() - start_time
+                print(f"  Response in {elapsed:.1f}s - Status: {response.status_code}")
+                
                 if response.status_code == 200:
                     data = response.json()
                     choices = data.get("choices", [])
-                    if choices:
-                        return choices[0].get("message", {}).get("content", "")
-            
-            raise Exception(f"API error: {response.status_code}")
-            
-        finally:
-            # Only close if not using pool
-            if not use_pool:
-                client.close()
-        
-    except httpx.TimeoutException:
-        print(f"  Timeout after {config['timeout_read']}s - trying fastest model")
+                    if choices and len(choices) > 0:
+                        content = choices[0].get("message", {}).get("content", "")
+                        if content:
+                            return content, current_model
+                    raise ValueError("Empty response from API")
+                
+                elif response.status_code == 404:
+                    print(f"  Model {current_model} not found, trying next...")
+                    last_error = f"Model {current_model} not available"
+                    continue
+                
+                elif response.status_code == 429:
+                    # Rate limited
+                    if attempt < len(models_to_try) - 1:
+                        print(f"  Rate limited, waiting 2s and trying next model...")
+                        time.sleep(2)
+                        continue
+                    raise ValueError("Rate limited on all models")
+                
+                elif response.status_code >= 500:
+                    # Server error
+                    print(f"  Server error {response.status_code}, trying next model...")
+                    last_error = f"Server error: {response.status_code}"
+                    continue
+                
+                else:
+                    last_error = f"API error {response.status_code}"
+                    continue
+                    
+            finally:
+                if not use_pool:
+                    client.close()
         
-        # On timeout, immediately try fastest model with new client
-        fast_client = httpx.Client(timeout=httpx.Timeout(20.0, connect=5.0))
-        try:
-            payload["model"] = "mistralai/Mistral-7B-Instruct-v0.3"
-            payload["max_tokens"] = 1500
+        except httpx.TimeoutException:
+            print(f"  Timeout after {config['timeout_read']}s")
+            last_error = f"Timeout with {current_model}"
             
-            response = fast_client.post(url, headers=headers, json=payload)
-            if response.status_code == 200:
-                data = response.json()
-                choices = data.get("choices", [])
-                if choices:
-                    return choices[0].get("message", {}).get("content", "")
-        finally:
-            fast_client.close()
+            # Try a faster model on timeout
+            if attempt == 0 and current_model not in ["mistralai/Mistral-7B-Instruct-v0.3", "meta-llama/Llama-3.1-8B-Instruct"]:
+                print(f"  Switching to faster model due to timeout")
+                continue
         
-        raise Exception("Timeout on all attempts")
+        except Exception as e:
+            print(f"  Error: {str(e)[:100]}")
+            last_error = str(e)
+            continue
     
-    except Exception as e:
-        raise Exception(f"API call failed: {str(e)}")
+    # All models failed
+    raise RuntimeError(f"All models failed. Last error: {last_error}")
 
 # =========================
-# OPTIMIZED CORE FUNCTIONS
+# MAIN FUNCTIONS
 # =========================
 
-def get_api_key(user_key: str = "") -> str:
-    """Get API key."""
-    return (user_key or "").strip() or os.getenv("NEBIUS_API_KEY", "").strip() or DEFAULT_NEBIUS_API_KEY
-
 def analyze_image_fast(
     image: Optional[Image.Image],
     nebius_api_key: str = "",
     vision_model: str = DEFAULT_VISION_MODEL,
     turbo_mode: bool = True
 ) -> str:
-    """Ultra-fast image analysis with optimizations."""
+    """Fast image analysis with vision model."""
     
     if image is None:
         return "Error: No image provided."
@@ -329,19 +353,18 @@ def analyze_image_fast(
     if not api_key:
         return "Error: API key required."
     
-    # Always use fastest vision model in turbo mode
+    # Force fastest vision model in turbo mode
     if turbo_mode or "72B" in vision_model:
-        vision_model = "Qwen/Qwen2.5-VL-7B-Instruct"
+        vision_model = "Qwen/Qwen2-VL-7B-Instruct"
+    
+    # Ensure we're using a vision model
+    if "VL" not in vision_model:
+        vision_model = "Qwen/Qwen2-VL-7B-Instruct"
     
     try:
-        # Aggressive image optimization for speed
-        if turbo_mode:
-            # Very small size for turbo mode
-            max_size = 512
-            quality = 75
-        else:
-            max_size = 768
-            quality = 85
+        # Image optimization for speed
+        max_size = 512 if turbo_mode else 768
+        quality = 75 if turbo_mode else 85
         
         # Resize image
         image.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
@@ -351,23 +374,21 @@ def analyze_image_fast(
         image.save(buffered, format="JPEG", quality=quality, optimize=True)
         img_b64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
         
-        # Ultra-concise prompt for speed
+        # Concise prompt for speed
         if turbo_mode:
-            prompt = """Quick analysis:
-1. Layout (grid/flex/sidebar)
-2. Colors (2-3 main)
-3. Components (header/nav/content/footer)
-4. Style (modern/minimal/corporate)
-
-Be very brief."""
+            prompt = """Quick website analysis:
+1. Layout structure (grid/flex/columns)
+2. Main colors (2-3 hex codes)
+3. Key components (header/nav/sections/footer)
+4. Design style (modern/minimal/corporate)
+Be very concise."""
         else:
-            prompt = """Analyze this website:
-1. Layout structure
-2. Color scheme (hex codes)
-3. Main components
-4. Design style
-5. Key features
-
+            prompt = """Analyze this website screenshot:
+1. Layout and structure
+2. Color scheme with hex codes
+3. Main UI components
+4. Design style and theme
+5. Notable features
 Be concise but complete."""
 
         messages = [{
@@ -378,18 +399,20 @@ Be concise but complete."""
             ]
         }]
         
-        # Use fast API call
-        return call_nebius_api_sync_fast(
+        # Call with fallback
+        content, used_model = call_nebius_api_with_fallback(
             model=vision_model,
             messages=messages,
             api_key=api_key,
             max_tokens=800 if turbo_mode else 1200,
             temperature=0.7,
-            use_pool=True
+            fallback_models=["Qwen/Qwen2-VL-7B-Instruct", "Qwen/Qwen2-VL-72B-Instruct"]
         )
         
+        return content
+        
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Error analyzing image: {str(e)}"
 
 def generate_html_fast(
     description: str,
@@ -398,7 +421,7 @@ def generate_html_fast(
     turbo_mode: bool = True,
     quality_mode: str = "fast"
 ) -> str:
-    """Ultra-fast HTML generation with model selection."""
+    """Fast HTML generation with automatic model selection."""
     
     if not description or description.startswith("Error"):
         return "Error: Invalid description."
@@ -407,92 +430,103 @@ def generate_html_fast(
     if not api_key:
         return "Error: API key required."
     
-    # Model selection based on quality mode
+    # Select models based on quality mode
     if quality_mode == "fast" or turbo_mode:
-        models_to_try = ["mistralai/Mistral-7B-Instruct-v0.3"]
+        primary_model = "mistralai/Mistral-7B-Instruct-v0.3"
+        fallback_models = ["meta-llama/Llama-3.1-8B-Instruct", "Qwen/Qwen2.5-72B-Instruct"]
         max_tokens = 2000 if turbo_mode else 2500
     elif quality_mode == "balanced":
-        models_to_try = ["mistralai/Mixtral-8x7B-Instruct-v0.1", "mistralai/Mistral-7B-Instruct-v0.3"]
+        primary_model = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+        fallback_models = ["meta-llama/Llama-3.1-70B-Instruct", "mistralai/Mistral-7B-Instruct-v0.3"]
         max_tokens = 3000
     else:  # quality
-        models_to_try = ["meta-llama/Meta-Llama-3.1-70B-Instruct", "mistralai/Mixtral-8x7B-Instruct-v0.1"]
+        primary_model = "meta-llama/Llama-3.1-70B-Instruct"
+        fallback_models = ["mistralai/Mixtral-8x7B-Instruct-v0.1", "Qwen/Qwen2.5-72B-Instruct"]
         max_tokens = 4000
     
-    # Ultra-optimized prompt
+    # Override with user selection if provided
+    if code_model in WORKING_CODE_MODELS:
+        primary_model = code_model
+    
+    # Optimized prompt
     if turbo_mode:
-        prompt = f"""HTML webpage from description:
+        prompt = f"""Create HTML webpage:
 
 {description}
 
 Requirements:
 - Complete HTML with inline CSS/JS
 - TailwindCSS CDN
-- Responsive
-- Modern design
+- Responsive design
+- Modern look
 
 Return only HTML code."""
     else:
-        prompt = f"""Create complete HTML webpage:
+        prompt = f"""Create a complete HTML webpage based on this description:
 
 {description}
 
 Requirements:
-- Single HTML file, inline CSS/JS
-- TailwindCSS CDN v3
-- Fully responsive
-- Modern, clean design
-- Semantic HTML5
-- Smooth animations
-- Dark mode toggle
-
-Return only the HTML code, no explanations."""
-
-    # Try models in order
-    for model in models_to_try:
-        try:
-            start = time.time()
-            print(f"[{get_current_time()}] Generating with {model} ({quality_mode} mode)")
-            
-            messages = [{"role": "user", "content": prompt}]
+- Single HTML file with inline CSS and JavaScript
+- Use TailwindCSS via CDN (version 3.x)
+- Fully responsive design
+- Modern, clean aesthetics
+- Semantic HTML5 structure
+- Smooth animations and transitions
+- Dark mode support
+
+Technical requirements:
+- Start with <!DOCTYPE html>
+- Complete valid HTML structure
+- Optimized for performance
+
+Generated for: {CURRENT_USER} at {get_current_time()}
+
+Return only the complete HTML code, no explanations."""
+
+    try:
+        start = time.time()
+        print(f"[{get_current_time()}] Generating HTML in {quality_mode} mode")
+        
+        messages = [{"role": "user", "content": prompt}]
+        
+        # Call with fallback
+        content, used_model = call_nebius_api_with_fallback(
+            model=primary_model,
+            messages=messages,
+            api_key=api_key,
+            max_tokens=max_tokens,
+            temperature=0.7,
+            fallback_models=fallback_models
+        )
+        
+        # Clean response
+        html_code = content.strip()
+        
+        # Remove markdown code fences
+        if "```" in html_code:
+            html_code = re.sub(r'^```[a-z]*\n?', '', html_code)
+            html_code = re.sub(r'\n?```$', '', html_code)
+            html_code = html_code.strip()
+        
+        # Validate HTML
+        html_lower = html_code.lower()
+        if "<!doctype" in html_lower and "</html>" in html_lower:
+            elapsed = time.time() - start
+            print(f"  Generated successfully with {used_model} in {elapsed:.1f}s")
             
-            content = call_nebius_api_sync_fast(
-                model=model,
-                messages=messages,
-                api_key=api_key,
-                max_tokens=max_tokens,
-                temperature=0.7,
-                use_pool=True
+            # Add metadata
+            html_code = html_code.replace(
+                "<head>",
+                f"<head>\n  <!-- Generated by {used_model} for {CURRENT_USER} at {get_current_time()} in {elapsed:.1f}s -->"
             )
             
-            # Clean response
-            html_code = content.strip()
-            
-            # Remove markdown code fences if present
-            if "```" in html_code:
-                html_code = re.sub(r'^```[a-z]*\n?', '', html_code)
-                html_code = re.sub(r'\n?```$', '', html_code)
-                html_code = html_code.strip()
+            return html_code
+        else:
+            return "Error: Invalid HTML structure generated. Please try again."
             
-            # Quick validation
-            html_lower = html_code.lower()
-            if "<!doctype" in html_lower and "</html>" in html_lower:
-                elapsed = time.time() - start
-                print(f"  Success in {elapsed:.1f}s")
-                
-                # Add metadata
-                timestamp = get_current_time()
-                html_code = html_code.replace(
-                    "<head>",
-                    f"<head>\n  <!-- Generated by {model} for {CURRENT_USER} at {timestamp} in {elapsed:.1f}s -->"
-                )
-                
-                return html_code
-                
-        except Exception as e:
-            print(f"  Failed with {model}: {str(e)[:100]}")
-            continue
-    
-    return "Error: Generation failed. Try enabling turbo mode or using fast quality setting."
+    except Exception as e:
+        return f"Error generating HTML: {str(e)}"
 
 def process_ultra_fast(
     image: Image.Image,
@@ -500,15 +534,15 @@ def process_ultra_fast(
     quality_mode: str = "fast",
     turbo_mode: bool = True
 ) -> Tuple[str, str, float]:
-    """Ultra-fast complete pipeline."""
+    """Complete fast pipeline for website generation."""
     
     start_time = time.time()
     
-    # Step 1: Fast image analysis
+    # Step 1: Image analysis
     description = analyze_image_fast(
         image,
         nebius_api_key,
-        vision_model="Qwen/Qwen2.5-VL-7B-Instruct",
+        vision_model="Qwen/Qwen2-VL-7B-Instruct",
         turbo_mode=turbo_mode
     )
     
@@ -518,12 +552,12 @@ def process_ultra_fast(
     analysis_time = time.time() - start_time
     print(f"  Analysis completed in {analysis_time:.1f}s")
     
-    # Step 2: Fast code generation
+    # Step 2: Code generation
     code_start = time.time()
     html_code = generate_html_fast(
         description,
         nebius_api_key,
-        code_model="mistralai/Mistral-7B-Instruct-v0.3" if quality_mode == "fast" else "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        code_model=DEFAULT_CODE_MODEL,
         turbo_mode=turbo_mode,
         quality_mode=quality_mode
     )
@@ -537,7 +571,7 @@ def process_ultra_fast(
     return description, html_code, total_time
 
 # =========================
-# GRADIO UI - SPEED OPTIMIZED
+# GRADIO UI
 # =========================
 
 with gr.Blocks(
@@ -545,7 +579,7 @@ with gr.Blocks(
         primary_hue="emerald",
         secondary_hue="blue"
     ),
-    title=f"⚡ Ultra-Fast Website Generator - {CURRENT_USER}",
+    title=f"Ultra-Fast Website Generator - {CURRENT_USER}",
     css="""
         .header {
             background: linear-gradient(135deg, #10b981 0%, #3b82f6 100%);
@@ -560,7 +594,7 @@ with gr.Blocks(
             font-weight: 800;
             margin-bottom: 0.5rem;
         }
-        .speed-badge {
+        .info-badge {
             display: inline-block;
             padding: 0.25rem 0.75rem;
             background: rgba(255,255,255,0.2);
@@ -572,11 +606,6 @@ with gr.Blocks(
             background: #fbbf24 !important;
             color: #78350f !important;
             font-weight: bold;
-            animation: pulse 2s infinite;
-        }
-        @keyframes pulse {
-            0%, 100% { opacity: 1; }
-            50% { opacity: 0.7; }
         }
         .timer {
             font-size: 1.5rem;
@@ -588,113 +617,110 @@ with gr.Blocks(
             border-radius: 8px;
             margin: 1rem 0;
         }
-        .fast-btn {
+        .generate-btn {
             background: linear-gradient(135deg, #10b981 0%, #059669 100%) !important;
             color: white !important;
             font-weight: bold !important;
             font-size: 1.125rem !important;
         }
-        .quality-card {
-            padding: 0.75rem;
-            border-radius: 8px;
-            border: 2px solid transparent;
-            transition: all 0.3s;
-        }
-        .quality-card:hover {
-            border-color: #10b981;
-            background: #f0fdf4;
+        .quality-info {
+            padding: 0.5rem;
+            background: #f3f4f6;
+            border-radius: 6px;
+            margin: 0.5rem 0;
         }
     """
 ) as app:
     
     gr.HTML(f"""
     <div class="header">
-        <h1>⚡ Ultra-Fast Website Generator</h1>
-        <p>Generate production-ready websites in seconds!</p>
+        <h1>Ultra-Fast Website Generator</h1>
+        <p>Generate production-ready websites in seconds using AI</p>
         <div>
-            <span class="speed-badge">User: {CURRENT_USER}</span>
-            <span class="speed-badge">Session: {CURRENT_DATETIME}</span>
-            <span class="speed-badge turbo-badge">⚡ TURBO OPTIMIZED</span>
+            <span class="info-badge">User: {CURRENT_USER}</span>
+            <span class="info-badge">Session: {CURRENT_DATETIME}</span>
+            <span class="info-badge turbo-badge">TURBO OPTIMIZED</span>
         </div>
     </div>
     """)
     
     with gr.Row():
         with gr.Column(scale=1):
-            # API Key
+            # API Configuration
             nebius_key = gr.Textbox(
                 label="Nebius API Key",
                 type="password",
                 value=DEFAULT_NEBIUS_API_KEY,
-                elem_classes=["api-key"]
+                info="Using default key if not provided"
             )
             
             # Speed Settings
             with gr.Group():
-                gr.Markdown("### ⚡ Speed Settings")
+                gr.Markdown("### Speed Configuration")
                 
                 quality_mode = gr.Radio(
-                    label="Quality Mode",
+                    label="Generation Quality",
                     choices=[
-                        ("🚀 Ultra Fast (5-10s)", "fast"),
-                        ("⚖️ Balanced (15-25s)", "balanced"),
-                        ("💎 High Quality (30-45s)", "quality")
+                        ("Ultra Fast (5-10s) - Mistral 7B", "fast"),
+                        ("Balanced (15-25s) - Mixtral 8x7B", "balanced"),
+                        ("High Quality (30-45s) - Llama 70B", "quality")
                     ],
-                    value="fast",
-                    elem_classes=["quality-selector"]
+                    value="fast"
                 )
                 
                 turbo_mode = gr.Checkbox(
-                    label="⚡ TURBO MODE - Maximum Speed",
-                    value=True,
-                    elem_classes=["turbo-checkbox"]
+                    label="Turbo Mode - Maximum Speed (Reduces tokens and image size)",
+                    value=True
                 )
                 
-                gr.Markdown("""
-                **Speed Tips:**
-                - ✅ Turbo Mode + Ultra Fast = 5-10 seconds
-                - ✅ Smaller images = Faster processing
-                - ✅ Simple designs = Quicker generation
+                gr.HTML("""
+                <div class="quality-info">
+                    <strong>Speed Optimization Tips:</strong><br>
+                    • Turbo Mode + Ultra Fast = 5-10 seconds<br>
+                    • Smaller images process faster<br>
+                    • Simple designs generate quicker<br>
+                    • Connection pooling saves 2-3 seconds
+                </div>
                 """)
             
             # Image Input
             image_input = gr.Image(
                 type="pil",
-                label="Upload Screenshot",
+                label="Upload Website Screenshot",
                 height=250
             )
             
             # Generate Button
             generate_btn = gr.Button(
-                "⚡ GENERATE NOW",
+                "GENERATE WEBSITE",
                 variant="primary",
                 size="lg",
-                elem_classes=["fast-btn"]
+                elem_classes=["generate-btn"]
             )
             
-            # Timer
+            # Timer Display
             timer_display = gr.HTML(
-                value='<div class="timer">⚡ Ready - Click Generate!</div>'
+                value='<div class="timer">Ready to generate</div>'
             )
         
         with gr.Column(scale=2):
-            # Results Tabs
+            # Results
             with gr.Tabs():
-                with gr.Tab("📝 Analysis"):
+                with gr.Tab("Analysis"):
                     description_output = gr.Textbox(
-                        label="Quick Analysis",
+                        label="Image Analysis Result",
                         lines=5,
                         interactive=False
                     )
                 
-                with gr.Tab("💻 Generated Code"):
+                with gr.Tab("Generated Code"):
                     html_output = gr.Code(
                         label="HTML Code",
                         language="html",
                         lines=20
                     )
                 
-                with gr.Tab("📊 Performance"):
+                with gr.Tab("Performance"):
                     performance_display = gr.Markdown(
                         value="""### Performance Metrics
                         
@@ -703,48 +729,53 @@ Waiting for generation..."""
             
             # Action Buttons
             with gr.Row():
-                deploy_btn = gr.Button("🌐 Deploy", size="sm")
-                download_btn = gr.Button("💾 Download", size="sm")
-                copy_btn = gr.Button("📋 Copy", size="sm")
+                deploy_btn = gr.Button("Deploy to CodeSandbox", size="sm")
+                download_btn = gr.Button("Download HTML", size="sm")
+                copy_btn = gr.Button("Copy Code", size="sm")
             
             output_message = gr.Markdown()
     
-    # Speed Guide
-    with gr.Accordion("🚀 Model Speed Guide", open=False):
+    # Model Information
+    with gr.Accordion("Model Performance Guide", open=False):
         gr.Markdown(f"""
-        ### Actual Performance (Updated {get_current_time()})
+        ### Available Models and Performance
+        
+        **Vision Models (Image Analysis):**
+        - Qwen2-VL-7B: 5-10 seconds (Recommended)
+        - Qwen2-VL-72B: 20-30 seconds (More accurate)
         
-        | Mode | Model | Real Speed | Quality |
-        |------|-------|------------|---------|
-        | **Ultra Fast** | Mistral-7B | ⚡ 5-10s | ★★★★ |
-        | **Fast** | Llama-8B | ⚡ 8-15s | ★★★★ |
-        | **Balanced** | Mixtral-8x7B | ⚡ 15-25s | ★★★★★ |
-        | **Quality** | Llama-70B | 30-45s | ★★★★★ |
+        **Code Generation Models:**
         
-        **Current optimizations:**
-        - ✅ Connection pooling (saves 2-3s)
-        - ✅ Image compression (saves 1-2s)
-        - ✅ Reduced tokens (saves 5-10s)
-        - ✅ No retries in turbo mode (saves 10-20s)
-        - ✅ Direct model selection (no fallbacks)
+        | Model | Speed | Quality | Parameters |
+        |-------|-------|---------|------------|
+        | Mistral-7B | 5-10s | Good | 7B |
+        | Llama-3.1-8B | 8-15s | Good | 8B |
+        | Mixtral-8x7B | 15-25s | Better | 56B (MoE) |
+        | Llama-3.1-70B | 30-45s | Best | 70B |
         
-        **User:** {CURRENT_USER}
+        **Current Optimizations:**
+        - Connection pooling enabled
+        - Image compression active
+        - Token reduction in turbo mode
+        - Automatic model fallback on errors
+        
+        **Session Info:**
+        - User: {CURRENT_USER}
+        - Started: {CURRENT_DATETIME}
+        - API Endpoint: {NEBIUS_BASE_URL}
         """)
     
-    # Event Handler
+    # Event Handlers
     def generate_with_timer(img, api_key, quality, turbo):
-        """Generate with live timer."""
+        """Main generation function with timer."""
         if img is None:
             return (
                 "Please upload an image",
                 "",
-                '<div class="timer">❌ No image uploaded</div>',
+                '<div class="timer">No image uploaded</div>',
                 "### No generation performed"
             )
         
-        # Show processing
-        timer_start = '<div class="timer">⚡ Generating... Please wait</div>'
-        
         try:
             # Process
             description, html_code, elapsed = process_ultra_fast(
@@ -754,30 +785,37 @@ Waiting for generation..."""
                 turbo_mode=turbo
             )
             
-            # Success timer
-            timer_html = f'<div class="timer">✅ Complete in {elapsed:.1f} seconds!</div>'
+            # Format results
+            timer_html = f'<div class="timer">Completed in {elapsed:.1f} seconds</div>'
             
-            # Performance report
+            # Performance metrics
             perf = f"""### Performance Report
             
 **Total Time:** {elapsed:.1f} seconds
-**Mode:** {quality.upper()} {'+ TURBO' if turbo else ''}
-**Vision Model:** Qwen2.5-VL-7B (Fast)
-**Code Model:** {'Mistral-7B' if quality == 'fast' else 'Mixtral-8x7B'}
+**Quality Mode:** {quality.upper()} {' + TURBO' if turbo else ''}
+**Models Used:**
+- Vision: Qwen2-VL-7B (Fast)
+- Code: {'Mistral-7B' if quality == 'fast' else 'Mixtral-8x7B' if quality == 'balanced' else 'Llama-70B'}
 
-**Breakdown:**
+**Time Breakdown:**
 - Image Analysis: ~{elapsed * 0.3:.1f}s
 - Code Generation: ~{elapsed * 0.6:.1f}s
-- Network/Other: ~{elapsed * 0.1:.1f}s
+- Network/Processing: ~{elapsed * 0.1:.1f}s
 
-**Session:** {CURRENT_USER} @ {get_current_time()}
+**Session:** {CURRENT_USER} at {get_current_time()}
             """
             
             return description, html_code, timer_html, perf
             
         except Exception as e:
-            timer_html = f'<div class="timer">❌ Error: {str(e)[:50]}</div>'
-            return f"Error: {str(e)}", "", timer_html, f"### Error\n\n{str(e)}"
+            error_msg = str(e)
+            timer_html = f'<div class="timer">Error occurred</div>'
+            return (
+                f"Error: {error_msg}",
+                "",
+                timer_html,
+                f"### Error Details\n\n{error_msg}"
+            )
     
     generate_btn.click(
         fn=generate_with_timer,
@@ -785,51 +823,56 @@ Waiting for generation..."""
         outputs=[description_output, html_output, timer_display, performance_display]
     )
     
-    # Quick deploy
-    def deploy_fast(html_code):
+    # Deploy to CodeSandbox
+    def deploy_to_codesandbox(html_code):
         if not html_code or html_code.startswith("Error"):
-            return "❌ No code to deploy"
+            return "No valid code to deploy"
         
         try:
-            # Minimal CodeSandbox creation
             files = {
                 "index.html": {"content": html_code, "isBinary": False}
             }
             params = {"files": files, "template": "static"}
             
-            import json
-            from lzstring import LZString
-            
             lz = LZString()
             compressed = lz.compressToBase64(json.dumps(params))
             compressed = compressed.replace('+', '-').replace('/', '_').rstrip('=')
             
             url = f"https://codesandbox.io/api/v1/sandboxes/define?parameters={compressed}"
-            return f"✅ **[Open in CodeSandbox]({url})**"
+            return f"**[Open in CodeSandbox]({url})**\n\nGenerated by {CURRENT_USER}"
             
         except Exception as e:
-            return f"❌ {str(e)}"
+            return f"Deployment error: {str(e)}"
     
-    deploy_btn.click(fn=deploy_fast, inputs=[html_output], outputs=[output_message])
+    deploy_btn.click(
+        fn=deploy_to_codesandbox,
+        inputs=[html_output],
+        outputs=[output_message]
+    )
     
-    # Download
-    def download_fast(code):
+    # Download HTML
+    def download_html(code):
         if not code or code.startswith("Error"):
-            return "❌ No code"
+            return "No code to download"
+        
         tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".html", mode='w')
         tmp.write(code)
         tmp.close()
-        return f"✅ Saved to {tmp.name}"
+        return f"File saved to: {tmp.name}"
     
-    download_btn.click(fn=download_fast, inputs=[html_output], outputs=[output_message])
+    download_btn.click(
+        fn=download_html,
+        inputs=[html_output],
+        outputs=[output_message]
+    )
     
-    # Copy hint
+    # Copy instruction
     copy_btn.click(
-        fn=lambda: "✅ Select code and press Ctrl+C",
+        fn=lambda: "Select the code above and press Ctrl+C (or Cmd+C on Mac) to copy",
         outputs=[output_message]
     )
 
-# Cleanup
+# Cleanup on exit
 import atexit
 
 def cleanup():
@@ -843,6 +886,7 @@ def cleanup():
 atexit.register(cleanup)
 
 if __name__ == "__main__":
-    print(f"[{get_current_time()}] ⚡ Ultra-Fast Generator starting for {CURRENT_USER}")
-    print(f"[{get_current_time()}] Optimizations: Connection pooling, Turbo mode, No HTTP/2")
+    print(f"[{get_current_time()}] Ultra-Fast Website Generator starting")
+    print(f"[{get_current_time()}] User: {CURRENT_USER}")
+    print(f"[{get_current_time()}] Optimizations: Connection pooling, Model fallback, Turbo mode")
     app.launch(share=False)