Update app.py

app.py

@@ -1,4 +1,4 @@
-"""
+    """
 Marketing Image Generator with Gradio MCP Server
 Professional AI image generation using Google Imagen3 with marketing review
 Deployed on HuggingFace Spaces with built-in MCP server support
@@ -10,7 +10,7 @@ import logging
 import json
 import base64
 import asyncio
-from typing import Dict, Any, Tuple
+from typing import Dict, Any, Tuple, List
 from PIL import Image
 import io
 
@@ -23,8 +23,13 @@ def setup_google_credentials():
             import tempfile
             from google.oauth2 import service_account
             
-            # Parse the JSON credentials
-            credentials_dict = json.loads(service_account_json)
+            # Clean and parse the JSON credentials
+            # Remove common problematic characters
+            cleaned_json = service_account_json.strip()
+            # Replace common escape sequences
+            cleaned_json = cleaned_json.replace('\\n', '\n').replace('\\t', '\t').replace('\\r', '\r')
+            
+            credentials_dict = json.loads(cleaned_json)
             
             # Create credentials from service account info
             credentials = service_account.Credentials.from_service_account_info(credentials_dict)
@@ -236,140 +241,223 @@ def generate_marketing_image(prompt: str, style: str = "realistic") -> str:
             "style": style
         })
 
-def analyze_marketing_prompt(prompt: str, review_guidelines: str = "") -> str:
+def analyze_marketing_image_with_gemini(image_url: str, prompt: str, review_guidelines: str = "") -> str:
     """
-    Analyze a marketing prompt for quality, relevance, and compliance.
+    Analyze a generated marketing image using Gemini Vision for quality, relevance, and compliance.
     
     Args:
-        prompt (str): The marketing prompt to analyze
+        image_url (str): URL or base64 data of the generated image
+        prompt (str): The original marketing prompt used to generate the image
         review_guidelines (str): Specific guidelines to check against
         
     Returns:
         str: JSON string containing detailed analysis and recommendations
     """
-    logger.info(f"🔍 Analyzing marketing prompt: {prompt[:50]}...")
+    logger.info(f"🔍 Analyzing marketing image with Gemini Vision: {prompt[:50]}...")
+    
+    if not GEMINI_AVAILABLE or not GOOGLE_API_KEY:
+        logger.warning("Gemini Vision not available, using fallback analysis")
+        return _fallback_image_analysis(prompt, review_guidelines)
     
     try:
-        word_count = len(prompt.split())
-        
-        # Check for marketing-specific elements
-        marketing_keywords = [
-            "professional", "corporate", "business", "marketing", "brand", "commercial",
-            "office", "team", "collaboration", "presentation", "meeting", "workplace",
-            "customer", "service", "product", "showcase", "display", "advertising"
-        ]
-        
-        style_keywords = [
-            "realistic", "photographic", "artistic", "creative", "modern", "clean",
-            "minimalist", "professional", "high-quality", "detailed", "sharp"
-        ]
-        
-        composition_keywords = [
-            "lighting", "composition", "background", "foreground", "perspective",
-            "angle", "framing", "focus", "depth", "contrast", "colors"
-        ]
-        
-        # Count keyword categories
-        marketing_score = sum(1 for word in marketing_keywords if word.lower() in prompt.lower()) / len(marketing_keywords)
-        style_score = sum(1 for word in style_keywords if word.lower() in prompt.lower()) / len(style_keywords)
-        composition_score = sum(1 for word in composition_keywords if word.lower() in prompt.lower()) / len(composition_keywords)
-        
-        # Base quality assessment
-        if word_count < 5:
-            base_quality = 0.3
-            quality_issues = ["Prompt is too short and lacks detail"]
-        elif word_count < 10:
-            base_quality = 0.5
-            quality_issues = ["Prompt could benefit from more descriptive details"]
-        elif word_count < 20:
-            base_quality = 0.7
-            quality_issues = []
-        elif word_count < 40:
-            base_quality = 0.8
-            quality_issues = []
+        # Create a detailed prompt for marketing image analysis
+        analysis_prompt = f"""
+        You are a Marketing Image Reviewer analyzing this image generated from: "{prompt}"
+        
+        CUSTOM REVIEW GUIDELINES (HIGHEST PRIORITY):
+        {review_guidelines if review_guidelines.strip() else 'No specific guidelines provided - use standard marketing criteria'}
+        
+        CRITICAL MARKETING CHECKS:
+        1. **Language/Text Requirements**: If guidelines mention "English" or specific language requirements, verify ALL visible text matches
+        2. **Brand Compliance**: Check professional appearance, color consistency, readability
+        3. **Marketing Effectiveness**: Assess visual appeal and message clarity
+        4. **Target Audience**: Evaluate cultural appropriateness and accessibility
+        
+        Evaluate on these marketing criteria:
+        1. **Marketing Quality**: Visual appeal, composition, professional appearance (0.0 to 1.0)
+        2. **Brand/Prompt Compliance**: How well it matches requirements and guidelines (0.0 to 1.0)
+        3. **Marketing Effectiveness**: Message clarity, target audience appeal (0.0 to 1.0)
+        
+        RESPONSE FORMAT:
+        Marketing Quality Score: [0.0-1.0]
+        Brand Compliance Score: [0.0-1.0]
+        Marketing Effectiveness Score: [0.0-1.0]
+        
+        Guideline Violations: [List specific violations of user guidelines, especially language/text requirements]
+        Missing Elements: [List prompt elements missing from image]
+        Present Elements: [List prompt elements correctly represented]
+        
+        Marketing Issues: [Brand compliance, readability, professional appearance problems]
+        Language/Text Issues: [Specific text/signage language violations if any]
+        Effectiveness Issues: [Marketing message clarity and appeal problems]
+        
+        Marketing Recommendations: [Specific marketing-focused improvement suggestions]
+        
+        CRITICAL: If guidelines specify English text/signage, explicitly check and report on ALL visible text language compliance.
+        """
+        
+        # Load the image
+        image = None
+        if image_url.startswith('data:image'):
+            # Handle base64 data URLs
+            base64_data = image_url.split(',')[1]
+            image_bytes = base64.b64decode(base64_data)
+            image = Image.open(io.BytesIO(image_bytes))
+        elif image_url.startswith('http'):
+            # Handle regular URLs
+            import requests
+            response = requests.get(image_url, timeout=10)
+            if response.status_code == 200:
+                image = Image.open(io.BytesIO(response.content))
+            else:
+                logger.error(f"Failed to fetch image from URL: {response.status_code}")
+                return _fallback_image_analysis(prompt, review_guidelines)
         else:
-            base_quality = 0.6
-            quality_issues = ["Prompt might be too complex - consider simplifying"]
-        
-        # Adjust based on keyword presence
-        quality_adjustment = (marketing_score * 0.2 + style_score * 0.15 + composition_score * 0.15)
-        final_quality = min(1.0, base_quality + quality_adjustment)
-        
-        # Generate specific feedback
-        missing_elements = []
-        if marketing_score < 0.1:
-            missing_elements.append("marketing context or business relevance")
-        if style_score < 0.1:
-            missing_elements.append("artistic style or visual quality descriptors")
-        if "english" in review_guidelines.lower() and "english" not in prompt.lower():
-            missing_elements.append("English language specification for text/signage")
-        
-        present_elements = []
-        if marketing_score > 0.1:
-            present_elements.append("marketing/business context")
-        if style_score > 0.1:
-            present_elements.append("style descriptors")
-        if composition_score > 0.1:
-            present_elements.append("composition guidance")
-        
-        # Calculate overall scores
-        relevance_score = min(1.0, final_quality + (marketing_score * 0.2))
-        safety_score = 0.95  # Generally high for marketing prompts
-        
-        # Check for potentially problematic content
-        problematic_terms = ["violence", "inappropriate", "offensive", "controversial"]
-        for term in problematic_terms:
-            if term in prompt.lower():
-                safety_score = 0.7
-                break
-        
-        overall_score = (final_quality * 0.4 + relevance_score * 0.4 + safety_score * 0.2)
-        
-        # Generate recommendations
-        recommendations = []
-        
-        if final_quality < 0.6:
-            recommendations.append("Consider adding more descriptive details about the desired image")
-        
-        if marketing_score < 0.1:
-            recommendations.append("Add marketing context (e.g., professional, business, corporate)")
-        
-        if "english" in review_guidelines.lower() and "english" not in prompt.lower():
-            recommendations.append("Add 'English signage' or 'English text' to meet language requirements")
-        
-        if word_count < 10:
-            recommendations.append("Expand prompt with lighting, composition, or environmental details")
-        elif word_count > 50:
-            recommendations.append("Consider simplifying prompt while keeping key elements")
+            logger.error("Invalid image URL format")
+            return _fallback_image_analysis(prompt, review_guidelines)
+        
+        if not image:
+            logger.error("Could not load image for analysis")
+            return _fallback_image_analysis(prompt, review_guidelines)
+        
+        # Generate analysis using Gemini Vision
+        model = genai.GenerativeModel('gemini-1.5-flash')
+        response = model.generate_content([analysis_prompt, image])
+        analysis_text = response.text
+        
+        # Parse the analysis response
+        parsed_result = _parse_gemini_analysis(analysis_text, prompt)
         
+        logger.info(f"✅ Gemini Vision analysis completed with score: {parsed_result.get('overall_score', 0)}")
+        return json.dumps(parsed_result)
+        
+    except Exception as e:
+        logger.error(f"Error in Gemini Vision analysis: {str(e)}")
+        return _fallback_image_analysis(prompt, review_guidelines)
+
+def _parse_gemini_analysis(analysis_text: str, original_prompt: str) -> Dict[str, Any]:
+    """Parse Gemini Vision analysis response"""
+    try:
+        # Extract scores using regex patterns
+        import re
+        
+        def extract_score(text: str, score_type: str) -> float:
+            pattern = rf"{score_type}.*?Score:\s*([0-9]*\.?[0-9]+)"
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                return float(match.group(1))
+            return 0.7  # Default score
+        
+        def extract_list_items(text: str, section: str) -> List[str]:
+            pattern = rf"{section}:\s*\[(.*?)\]"
+            match = re.search(pattern, text, re.IGNORECASE | re.DOTALL)
+            if match:
+                items_text = match.group(1).strip()
+                if items_text:
+                    return [item.strip() for item in items_text.split(',') if item.strip()]
+            return []
+        
+        # Extract scores
+        marketing_quality = extract_score(analysis_text, "Marketing Quality")
+        brand_compliance = extract_score(analysis_text, "Brand Compliance")
+        marketing_effectiveness = extract_score(analysis_text, "Marketing Effectiveness")
+        
+        # Calculate overall score
+        overall_score = (marketing_quality * 0.4 + brand_compliance * 0.4 + marketing_effectiveness * 0.2)
+        
+        # Extract lists
+        violations = extract_list_items(analysis_text, "Guideline Violations")
+        missing_elements = extract_list_items(analysis_text, "Missing Elements")
+        present_elements = extract_list_items(analysis_text, "Present Elements")
+        marketing_issues = extract_list_items(analysis_text, "Marketing Issues")
+        language_issues = extract_list_items(analysis_text, "Language/Text Issues")
+        effectiveness_issues = extract_list_items(analysis_text, "Effectiveness Issues")
+        recommendations = extract_list_items(analysis_text, "Marketing Recommendations")
+        
+        # Generate recommendations if none found
         if not recommendations:
             if overall_score > 0.8:
-                recommendations.append("Excellent prompt! Should generate high-quality marketing image")
+                recommendations = ["Excellent marketing image! Meets all quality standards"]
+            elif overall_score > 0.6:
+                recommendations = ["Good marketing image with minor improvements needed"]
             else:
-                recommendations.append("Good prompt foundation - image should meet basic requirements")
+                recommendations = ["Image needs significant improvements for marketing use"]
         
-        analysis_result = {
+        return {
             "success": True,
-            "quality_score": round(final_quality, 2),
-            "relevance_score": round(relevance_score, 2),
-            "safety_score": round(safety_score, 2),
             "overall_score": round(overall_score, 2),
-            "word_count": word_count,
+            "marketing_quality": round(marketing_quality, 2),
+            "brand_compliance": round(brand_compliance, 2),
+            "marketing_effectiveness": round(marketing_effectiveness, 2),
+            "violations": violations,
             "missing_elements": missing_elements,
             "present_elements": present_elements,
-            "recommendations": recommendations[:5],
-            "analysis_method": "prompt_analysis"
+            "marketing_issues": marketing_issues,
+            "language_issues": language_issues,
+            "effectiveness_issues": effectiveness_issues,
+            "recommendations": recommendations[:5],  # Limit to top 5
+            "analysis_method": "gemini_vision",
+            "original_prompt": original_prompt
         }
         
-        return json.dumps(analysis_result)
-        
     except Exception as e:
-        logger.error(f"Prompt analysis failed: {e}")
-        return json.dumps({
-            "success": False,
-            "error": f"Analysis failed: {str(e)}",
-            "prompt": prompt
-        })
+        logger.error(f"Error parsing Gemini analysis: {str(e)}")
+        return _fallback_image_analysis(original_prompt, "")
+
+def _fallback_image_analysis(prompt: str, review_guidelines: str) -> str:
+    """Fallback analysis when Gemini Vision is not available"""
+    logger.info("Using fallback text-based analysis")
+    
+    # Basic analysis based on prompt and guidelines
+    word_count = len(prompt.split())
+    
+    # Simple scoring based on prompt quality
+    if word_count < 10:
+        quality_score = 0.5
+    elif word_count < 20:
+        quality_score = 0.7
+    else:
+        quality_score = 0.8
+    
+    # Check for marketing keywords
+    marketing_keywords = ["professional", "corporate", "business", "marketing", "brand"]
+    marketing_score = sum(1 for word in marketing_keywords if word.lower() in prompt.lower()) / len(marketing_keywords)
+    
+    # Check for language requirements
+    language_issues = []
+    if "english" in review_guidelines.lower() and "english" not in prompt.lower():
+        language_issues.append("English language requirement not specified in prompt")
+    
+    # Generate recommendations
+    recommendations = []
+    if marketing_score < 0.2:
+        recommendations.append("Add marketing context (e.g., professional, business, corporate)")
+    if language_issues:
+        recommendations.extend(language_issues)
+    if word_count < 10:
+        recommendations.append("Expand prompt with more descriptive details")
+    
+    if not recommendations:
+        recommendations = ["Image should meet basic marketing requirements"]
+    
+    overall_score = (quality_score * 0.6 + marketing_score * 0.4)
+    
+    return json.dumps({
+        "success": True,
+        "overall_score": round(overall_score, 2),
+        "marketing_quality": round(quality_score, 2),
+        "brand_compliance": round(marketing_score, 2),
+        "marketing_effectiveness": round(overall_score, 2),
+        "violations": language_issues,
+        "missing_elements": [],
+        "present_elements": [],
+        "marketing_issues": [],
+        "language_issues": language_issues,
+        "effectiveness_issues": [],
+        "recommendations": recommendations,
+        "analysis_method": "fallback_text",
+        "original_prompt": prompt
+    })
 
 def generate_and_review_marketing_image(prompt: str, style: str = "realistic", review_guidelines: str = "") -> str:
     """
@@ -393,8 +481,9 @@ def generate_and_review_marketing_image(prompt: str, style: str = "realistic", r
         if not generation_data.get("success", False):
             return generation_response  # Return error
         
-        # Step 2: Analyze the prompt (marketing review)
-        analysis_response = analyze_marketing_prompt(prompt, review_guidelines)
+        # Step 2: Analyze the generated image with Gemini Vision
+        image_url = generation_data.get("image_url", "")
+        analysis_response = analyze_marketing_image_with_gemini(image_url, prompt, review_guidelines)
         analysis_data = json.loads(analysis_response)
         
         # Combine results
@@ -417,6 +506,7 @@ def generate_and_review_marketing_image(prompt: str, style: str = "realistic", r
             "metadata": {
                 "generation_method": generation_data.get("generation_method", "unknown"),
                 "real_ai_generation": generation_data.get("real_ai_generation", False),
+                "review_method": analysis_data.get("analysis_method", "unknown"),
                 "workflow_type": "gradio_mcp_server"
             }
         }
@@ -467,6 +557,7 @@ def process_generated_image_and_results(api_response_str: str) -> Tuple[Image.Im
         
         # Extract review data
         review_data = response_data.get('review', {})
+        analysis_details = review_data.get('analysis_details', {})
         
         if review_data:
             quality_score = review_data.get('quality_score', 0)
@@ -476,9 +567,10 @@ def process_generated_image_and_results(api_response_str: str) -> Tuple[Image.Im
             
             status_emoji = "🟢" if passed else "🔴"
             
-            # Extract metadata about generation method
+            # Extract metadata about generation and review methods
             metadata = response_data.get('metadata', {})
             generation_method = metadata.get('generation_method', 'unknown')
+            review_method = metadata.get('review_method', 'unknown')
             
             generation_info = ""
             if generation_method == "google-genai-sdk":
@@ -486,13 +578,29 @@ def process_generated_image_and_results(api_response_str: str) -> Tuple[Image.Im
             elif generation_method == "placeholder":
                 generation_info = "🎨 **Generated with**: Placeholder (Fallback)\n"
             
+            review_method_info = ""
+            if review_method == "gemini_vision":
+                review_method_info = "🔍 **Reviewed with**: Gemini Vision (AI Analysis)\n"
+            elif review_method == "fallback_text":
+                review_method_info = "🔍 **Reviewed with**: Text Analysis (Fallback)\n"
+            
+            # Get detailed scores from analysis
+            marketing_quality = analysis_details.get('marketing_quality', quality_score)
+            brand_compliance = analysis_details.get('brand_compliance', quality_score)
+            marketing_effectiveness = analysis_details.get('marketing_effectiveness', quality_score)
+            
             review_text = f"""**🔍 Marketing Review Results**
 
-{generation_info}
+{generation_info}{review_method_info}
 **Quality Score:** {quality_score:.2f}/1.0
 **Status:** {status_emoji} {final_status.upper()}
 **Architecture:** Gradio MCP Server
 
+**📊 Detailed Scores:**
+• Marketing Quality: {marketing_quality:.2f}/1.0
+• Brand Compliance: {brand_compliance:.2f}/1.0  
+• Marketing Effectiveness: {marketing_effectiveness:.2f}/1.0
+
 **💡 Recommendations:**
 """