Update app.py

app.py

@@ -8,22 +8,57 @@ import base64
 import io
 import logging
 import time
-from typing import Optional, Tuple
+from typing import Optional, Tuple, Dict, List
 import warnings
 import requests
 import json
+import random
+from functools import wraps
 warnings.filterwarnings("ignore")
 
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('nano_banana.log')
+    ]
+)
 logger = logging.getLogger(__name__)
 
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
-FREEPIK_API_KEY = os.getenv("FREEPIK_API_KEY")
+def validate_api_key(api_key, api_name):
+    if not api_key:
+        return False, f"{api_name} API key not provided"
+    
+    if len(api_key.strip()) < 10:
+        return False, f"{api_name} API key appears to be too short"
+    
+    if api_key.startswith(' ') or api_key.endswith(' '):
+        return False, f"{api_name} API key has leading/trailing whitespace"
+    
+    return True, f"{api_name} API key format validated"
+
+def get_secure_api_key(env_var_name, api_name):
+    api_key = os.getenv(env_var_name)
+    if api_key:
+        is_valid, message = validate_api_key(api_key, api_name)
+        if is_valid:
+            logger.info(f"{api_name} API key loaded and validated")
+            return api_key.strip()
+        else:
+            logger.warning(f"{api_name} API key validation failed: {message}")
+            return None
+    return None
+
+GEMINI_API_KEY = get_secure_api_key("GEMINI_API_KEY", "Gemini")
+ELEVENLABS_API_KEY = get_secure_api_key("ELEVENLABS_API_KEY", "ElevenLabs")
+FREEPIK_API_KEY = get_secure_api_key("FREEPIK_API_KEY", "Freepik")
 
 MAX_IMAGE_SIZE = 1024
 RATE_LIMIT_DELAY = 3
-API_RETRY_COUNT = 3
+API_RETRY_COUNT = 5
+MAX_BACKOFF_TIME = 60
+BASE_BACKOFF = 1
 
 IMAGE_MODELS = {
     "Freepik Gemini 2.5 Flash": {
@@ -60,11 +95,90 @@ except ImportError:
     yolo_available = False
     logger.info("YOLO not available - optional feature")
 
+def retry_with_backoff(max_retries=API_RETRY_COUNT, base_delay=BASE_BACKOFF):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            last_exception = None
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except requests.exceptions.RequestException as e:
+                    last_exception = e
+                    if hasattr(e, 'response') and e.response is not None:
+                        status_code = e.response.status_code
+                        if status_code == 429:
+                            wait_time = min(base_delay * (2 ** attempt) + random.uniform(0, 1), MAX_BACKOFF_TIME)
+                            logger.warning(f"Rate limit hit, retrying in {wait_time:.2f}s (attempt {attempt + 1}/{max_retries})")
+                            time.sleep(wait_time)
+                            continue
+                        elif status_code in [500, 502, 503, 504]:
+                            wait_time = min(base_delay * (2 ** attempt), MAX_BACKOFF_TIME)
+                            logger.warning(f"Server error {status_code}, retrying in {wait_time:.2f}s (attempt {attempt + 1}/{max_retries})")
+                            time.sleep(wait_time)
+                            continue
+                        else:
+                            logger.error(f"Non-retryable error: {status_code}")
+                            break
+                    else:
+                        wait_time = min(base_delay * (2 ** attempt), MAX_BACKOFF_TIME)
+                        logger.warning(f"Network error, retrying in {wait_time:.2f}s (attempt {attempt + 1}/{max_retries})")
+                        time.sleep(wait_time)
+                except Exception as e:
+                    last_exception = e
+                    logger.error(f"Unexpected error on attempt {attempt + 1}: {e}")
+                    break
+            
+            if last_exception:
+                raise last_exception
+            return None
+        return wrapper
+    return decorator
+
 class NanoBananaApp:
     def __init__(self):
         self.gemini_model = None
         self.yolo_model = None
+        self.session = self._create_session()
         self._initialize_gemini()
+    
+    def _create_session(self):
+        session = requests.Session()
+        session.headers.update({
+            'User-Agent': 'NanoBanana/1.0',
+            'Accept': 'application/json',
+            'Content-Type': 'application/json'
+        })
+        
+        adapter = requests.adapters.HTTPAdapter(
+            max_retries=requests.adapters.Retry(
+                total=3,
+                backoff_factor=0.3,
+                status_forcelist=[500, 502, 503, 504]
+            )
+        )
+        session.mount('http://', adapter)
+        session.mount('https://', adapter)
+        
+        return session
+        
+    def _log_api_response(self, response, api_name="API"):
+        logger.info(f"{api_name} Response: {response.status_code}")
+        if response.status_code != 200:
+            logger.error(f"{api_name} Error: {response.status_code} - {response.text[:500]}")
+        else:
+            logger.info(f"{api_name} Success: Request completed")
+            
+    def _validate_api_response(self, response, expected_keys=None):
+        if not response:
+            return False, "Empty response"
+        
+        if expected_keys:
+            missing_keys = [key for key in expected_keys if key not in response]
+            if missing_keys:
+                return False, f"Missing keys: {missing_keys}"
+        
+        return True, "Valid response"
         
     def _initialize_gemini(self):
         if not GEMINI_API_KEY:
@@ -103,40 +217,45 @@ class NanoBananaApp:
         else:
             return None, f"Unsupported API type: {api_type}"
     
+    @retry_with_backoff(max_retries=API_RETRY_COUNT)
     def _generate_with_freepik(self, image, prompt, style, editing_mode, api_key):
         if not api_key:
             return None, "Freepik API key not provided"
             
         try:
             buffered = io.BytesIO()
-            image.save(buffered, format='PNG')
+            image.save(buffered, format='PNG', optimize=True, quality=95)
             image_b64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
             
             full_prompt = self._build_enhanced_prompt(prompt, style, editing_mode)
+            logger.info(f"Enhanced prompt (first 200 chars): {full_prompt[:200]}...")
             
-            # Note: This URL may need to be updated based on actual Freepik API documentation
             url = "https://api.freepik.com/v1/ai/text-to-image"
             payload = {
                 "prompt": full_prompt,
                 "num_images": 1,
                 "image": {
                     "size": "1024x1024"
-                }
-            }
-            headers = {
-                "x-freepik-api-key": api_key,
-                "Content-Type": "application/json"
+                },
+                "style": style,
+                "mode": editing_mode
             }
             
-            response = requests.post(url, json=payload, headers=headers, timeout=60)
+            self.session.headers.update({
+                "x-freepik-api-key": api_key
+            })
             
-            logger.info(f"Freepik API response: {response.status_code}")
+            response = self.session.post(url, json=payload, timeout=60)
+            self._log_api_response(response, "Freepik")
             
             if response.status_code == 200:
                 result = response.json()
                 logger.info(f"Freepik response data keys: {list(result.keys())}")
                 
-                # Handle different possible response formats
+                is_valid, validation_msg = self._validate_api_response(result, ['data'])
+                if not is_valid:
+                    logger.warning(f"Response validation failed: {validation_msg}")
+                
                 if 'data' in result and len(result['data']) > 0:
                     data_item = result['data'][0]
                     
@@ -183,17 +302,29 @@ class NanoBananaApp:
                     return None, f"Freepik API: Unexpected response format - available keys: {list(result.keys())}"
                     
             elif response.status_code == 401:
-                return None, "Invalid or expired Freepik API key"
+                logger.error("Freepik API authentication failed")
+                return None, "🔑 Invalid or expired Freepik API key. Please check your API key."
             elif response.status_code == 403:
-                return None, "Freepik API access forbidden - check subscription plan"
+                logger.error("Freepik API access forbidden")
+                return None, "🚫 Freepik API access forbidden. Please check your subscription plan and permissions."
             elif response.status_code == 429:
-                return None, "Freepik API rate limit exceeded"
+                logger.warning("Freepik API rate limit exceeded")
+                return None, "⏱️ Freepik API rate limit exceeded. Please wait before making another request."
+            elif response.status_code == 400:
+                logger.error("Freepik API bad request")
+                return None, "📝 Invalid request parameters. Please check your prompt and settings."
+            elif response.status_code >= 500:
+                logger.error(f"Freepik API server error: {response.status_code}")
+                return None, f"🛠️ Freepik API server error ({response.status_code}). Please try again later."
             else:
                 try:
                     error_data = response.json()
-                    return None, f"Freepik API error: {response.status_code} - {error_data}"
+                    error_message = error_data.get('message', 'Unknown error')
+                    logger.error(f"Freepik API error {response.status_code}: {error_message}")
+                    return None, f"❌ Freepik API error ({response.status_code}): {error_message}"
                 except:
-                    return None, f"Freepik API error: {response.status_code} - {response.text[:200]}"
+                    logger.error(f"Freepik API error {response.status_code}: {response.text[:200]}")
+                    return None, f"❌ Freepik API error ({response.status_code}): {response.text[:200]}"
             
         except Exception as e:
             logger.error(f"Freepik generation failed: {e}")
@@ -202,21 +333,63 @@ class NanoBananaApp:
     
     def _build_enhanced_prompt(self, prompt, style, editing_mode):
         style_modifiers = {
-            "realistic": "photorealistic, high-quality construction, professional architecture",
-            "futuristic": "futuristic, high-tech, modern glass and steel, sci-fi architecture",
-            "artistic": "artistic, creative design, unique architecture, colorful and innovative"
+            "realistic": {
+                "base": "photorealistic, high-quality construction, professional architecture",
+                "materials": "concrete, steel, glass, brick, modern building materials",
+                "lighting": "natural lighting, architectural photography, professional composition",
+                "details": "precise construction details, realistic textures, accurate proportions"
+            },
+            "futuristic": {
+                "base": "futuristic, high-tech, modern glass and steel, sci-fi architecture",
+                "materials": "smart glass, carbon fiber, LED lighting, metallic surfaces",
+                "lighting": "neon accents, ambient lighting, dynamic color schemes",
+                "details": "sleek lines, geometric patterns, technological integration"
+            },
+            "artistic": {
+                "base": "artistic, creative design, unique architecture, colorful and innovative",
+                "materials": "mixed media, colorful facades, creative textures, artistic elements",
+                "lighting": "dramatic lighting, vibrant colors, artistic composition",
+                "details": "creative patterns, artistic flourishes, unique design elements"
+            }
         }
         
         mode_descriptions = {
-            "complete": "Complete this unfinished construction",
-            "edit": "Edit and transform this construction image",
-            "blend": "Blend and reimagine this construction"
+            "complete": {
+                "action": "Complete and finish this unfinished construction project",
+                "focus": "seamless integration, structural completion, architectural consistency",
+                "outcome": "fully realized building with complete structure and details"
+            },
+            "edit": {
+                "action": "Edit and transform specific elements of this construction image",
+                "focus": "targeted modifications, enhanced features, improved design",
+                "outcome": "enhanced version with specific improvements and modifications"
+            },
+            "blend": {
+                "action": "Blend and reimagine this construction with new architectural elements",
+                "focus": "creative fusion, architectural harmony, innovative design integration",
+                "outcome": "seamlessly blended design combining existing and new elements"
+            }
         }
         
-        base_desc = mode_descriptions.get(editing_mode, 'Transform')
-        style_desc = style_modifiers.get(style, '')
+        style_info = style_modifiers.get(style, style_modifiers["realistic"])
+        mode_info = mode_descriptions.get(editing_mode, mode_descriptions["edit"])
+        
+        enhanced_prompt = f"""
+        {mode_info['action']}: {prompt}
+        
+        Style Requirements: {style_info['base']}
+        Materials: {style_info['materials']}
+        Lighting: {style_info['lighting']}
+        Details: {style_info['details']}
         
-        return f"{base_desc} {prompt}. Style: {style_desc}. Make it look professional and realistic. Architecture, construction, building."
+        Focus: {mode_info['focus']}
+        Desired Outcome: {mode_info['outcome']}
+        
+        Quality: High-resolution, professional architecture rendering, detailed construction imagery
+        Context: Modern construction, building architecture, structural engineering
+        """
+        
+        return enhanced_prompt.strip()
             
     def load_yolo_optional(self):
         if not yolo_available:
@@ -422,8 +595,15 @@ def process_nano_banana_with_freepik(image, prompt, style, editing_mode, freepik
     if not prompt or not prompt.strip():
         return image, image, image, None, "💭 Please provide a transformation prompt", None
     
+    final_freepik_key = freepik_key or FREEPIK_API_KEY
+    if final_freepik_key:
+        is_valid, validation_msg = validate_api_key(final_freepik_key, "Freepik")
+        if not is_valid:
+            return image, image, image, None, f"🔑 API Key Error: {validation_msg}", None
+        logger.info("User-provided Freepik API key validated")
+    
     user_api_keys = {
-        "freepik": freepik_key or FREEPIK_API_KEY
+        "freepik": final_freepik_key
     }
     
     try: