Update utils.py

utils.py

@@ -166,6 +166,262 @@ def _extract_description_only(prompt: str) -> str:
     description = re.sub(r'For this type of scene.*?shooting style would be.*?\.', '', description, flags=re.DOTALL)
     description = re.sub(r'I would recommend.*?aperture.*?\.', '', description, flags=re.DOTALL)
     
+    # Remove numbered section residues (like "2.," at the end)
+    description = re.sub(r'\s*\d+\.\s*,?\s*
+
+
+def _format_bagel_camera_suggestion(bagel_camera: str) -> str:
+    """Format BAGEL's camera suggestion into clean FLUX format"""
+    try:
+        # Clean up the BAGEL suggestion
+        camera_text = bagel_camera.strip()
+        
+        # Remove "CAMERA_SETUP:" if it's still there
+        camera_text = re.sub(r'^CAMERA_SETUP:\s*', '', camera_text)
+        
+        # Extract key camera info using regex patterns
+        camera_patterns = {
+            'camera': r'(Canon EOS [^,]+|Sony A[^,]+|Leica [^,]+|Hasselblad [^,]+|Phase One [^,]+|Fujifilm [^,]+)',
+            'lens': r'(\d+mm[^,]*|[^,]*lens[^,]*)',
+            'aperture': r'(f/[\d.]+[^,]*)'
+        }
+        
+        extracted_parts = []
+        
+        for key, pattern in camera_patterns.items():
+            match = re.search(pattern, camera_text, re.IGNORECASE)
+            if match:
+                extracted_parts.append(match.group(1).strip())
+        
+        if extracted_parts:
+            # Build clean camera config
+            camera_info = ', '.join(extracted_parts)
+            return f", Shot on {camera_info}, professional photography"
+        else:
+            # Fallback: use the first part of BAGEL's suggestion
+            first_sentence = camera_text.split('.')[0].strip()
+            if len(first_sentence) > 10:
+                return f", {first_sentence}, professional photography"
+            else:
+                return ", professional camera setup"
+                
+    except Exception as e:
+        logger.warning(f"Failed to format BAGEL camera suggestion: {e}")
+        return ", professional camera setup"
+
+
+def _get_fallback_camera_config(prompt_lower: str) -> str:
+    """Get fallback camera configuration when BAGEL doesn't suggest one"""
+    # Improved detection logic
+    if any(word in prompt_lower for word in ['street', 'urban', 'city', 'documentary', 'crowd', 'protest']):
+        return FLUX_RULES["camera_configs"]["street"]
+    elif any(word in prompt_lower for word in ['portrait', 'person', 'man', 'woman', 'face']) and not any(word in prompt_lower for word in ['street', 'crowd', 'scene']):
+        return FLUX_RULES["camera_configs"]["portrait"]
+    elif any(word in prompt_lower for word in ['landscape', 'mountain', 'nature', 'outdoor']):
+        return FLUX_RULES["camera_configs"]["landscape"]
+    else:
+        return FLUX_RULES["camera_configs"]["default"]
+
+
+def _get_lighting_enhancement(prompt_lower: str, camera_config: str) -> str:
+    """Determine appropriate lighting enhancement"""
+    # Don't add lighting if already mentioned in prompt or camera config
+    if 'lighting' in prompt_lower or 'lighting' in camera_config.lower():
+        return ""
+    
+    if 'dramatic' in prompt_lower or 'chaos' in prompt_lower or 'fire' in prompt_lower:
+        return FLUX_RULES["lighting_enhancements"]["dramatic"]
+    elif 'portrait' in camera_config.lower():
+        return FLUX_RULES["lighting_enhancements"]["portrait"]
+    else:
+        return FLUX_RULES["lighting_enhancements"]["default"]
+
+
+def _clean_prompt_formatting(prompt: str) -> str:
+    """Clean up prompt formatting"""
+    if not prompt:
+        return ""
+    
+    # Ensure it starts with capital letter
+    prompt = prompt.strip()
+    if prompt:
+        prompt = prompt[0].upper() + prompt[1:] if len(prompt) > 1 else prompt.upper()
+    
+    # Clean up spaces and commas
+    prompt = re.sub(r'\s+', ' ', prompt)
+    prompt = re.sub(r',\s*,+', ',', prompt)
+    prompt = re.sub(r'^\s*,\s*', '', prompt)  # Remove leading commas
+    prompt = re.sub(r'\s*,\s*$', '', prompt)  # Remove trailing commas
+    
+    # Remove redundant periods
+    prompt = re.sub(r'\.+', '.', prompt)
+    
+    return prompt.strip()
+
+
+def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]] = None) -> Tuple[int, Dict[str, int]]:
+    """
+    Calculate quality score for a prompt
+    
+    Args:
+        prompt: The prompt to score
+        analysis_data: Optional analysis data to enhance scoring
+        
+    Returns:
+        Tuple of (total_score, breakdown_dict)
+    """
+    if not prompt:
+        return 0, {"prompt_quality": 0, "technical_details": 0, "artistic_value": 0, "flux_optimization": 0}
+    
+    breakdown = {}
+    
+    # Prompt quality score (0-30 points)
+    length_score = min(20, len(prompt) // 8)  # Reward decent length
+    detail_score = min(10, len(prompt.split(',')) * 2)  # Reward detail
+    breakdown["prompt_quality"] = length_score + detail_score
+    
+    # Technical details score (0-25 points) - Enhanced for BAGEL camera suggestions
+    tech_score = 0
+    tech_keywords = ['shot on', 'lens', 'photography', 'lighting', 'camera']
+    for keyword in tech_keywords:
+        if keyword in prompt.lower():
+            tech_score += 5
+    
+    # Bonus points for BAGEL camera suggestions
+    if analysis_data and analysis_data.get("has_camera_suggestion"):
+        tech_score += 10  # Higher bonus for intelligent camera selection
+        
+    breakdown["technical_details"] = min(25, tech_score)
+    
+    # Artistic value score (0-25 points)
+    art_keywords = ['masterful', 'professional', 'cinematic', 'dramatic', 'beautiful']
+    art_score = sum(5 for keyword in art_keywords if keyword in prompt.lower())
+    breakdown["artistic_value"] = min(25, art_score)
+    
+    # Flux optimization score (0-20 points)
+    flux_score = 0
+    
+    # Check for camera configuration (prefer BAGEL over fallback)
+    if analysis_data and analysis_data.get("has_camera_suggestion"):
+        flux_score += 15  # Higher score for BAGEL suggestions
+    elif any(camera in prompt for camera in FLUX_RULES["camera_configs"].values()):
+        flux_score += 10  # Lower score for fallback
+        
+    # Check for lighting configuration  
+    if any(lighting in prompt for lighting in FLUX_RULES["lighting_enhancements"].values()):
+        flux_score += 5
+        
+    breakdown["flux_optimization"] = flux_score
+    
+    # Calculate total
+    total_score = sum(breakdown.values())
+    
+    return total_score, breakdown
+
+
+def get_score_grade(score: int) -> Dict[str, str]:
+    """
+    Get grade information for a score
+    
+    Args:
+        score: Numeric score
+        
+    Returns:
+        Dictionary with grade and color information
+    """
+    from config import SCORING_CONFIG
+    
+    for threshold, grade_info in sorted(SCORING_CONFIG["grade_thresholds"].items(), reverse=True):
+        if score >= threshold:
+            return grade_info
+    
+    # Default to lowest grade
+    return SCORING_CONFIG["grade_thresholds"][0]
+
+
+def format_analysis_report(analysis_data: Dict[str, Any], processing_time: float) -> str:
+    """
+    Format analysis data into a readable report
+    
+    Args:
+        analysis_data: Analysis results
+        processing_time: Time taken for processing
+        
+    Returns:
+        Formatted markdown report
+    """
+    model_used = analysis_data.get("model_used", "Unknown")
+    prompt_length = len(analysis_data.get("prompt", ""))
+    
+    report = f"""**🚀 FLUX OPTIMIZATION COMPLETE**
+**Model:** {model_used} • **Time:** {processing_time:.1f}s • **Length:** {prompt_length} chars
+
+**📊 ANALYSIS SUMMARY:**
+{analysis_data.get("summary", "Analysis completed successfully")}
+
+**🎯 OPTIMIZATIONS APPLIED:**
+✅ Flux camera configuration
+✅ Professional lighting setup  
+✅ Technical photography details
+✅ Artistic enhancement keywords
+
+**⚡ Powered by Frame 0 Laboratory for MIA**"""
+    
+    return report
+
+
+def safe_execute(func, *args, **kwargs) -> Tuple[bool, Any]:
+    """
+    Safely execute a function with error handling
+    
+    Args:
+        func: Function to execute
+        *args: Function arguments
+        **kwargs: Function keyword arguments
+        
+    Returns:
+        Tuple of (success: bool, result: Any)
+    """
+    try:
+        result = func(*args, **kwargs)
+        return True, result
+    except Exception as e:
+        logger.error(f"Safe execution failed for {func.__name__}: {e}")
+        return False, str(e)
+
+
+def truncate_text(text: str, max_length: int = 100) -> str:
+    """
+    Truncate text to specified length with ellipsis
+    
+    Args:
+        text: Text to truncate
+        max_length: Maximum length
+        
+    Returns:
+        Truncated text
+    """
+    if not text or len(text) <= max_length:
+        return text
+    
+    return text[:max_length-3] + "..."
+
+
+# Export main functions
+__all__ = [
+    "setup_logging",
+    "optimize_image", 
+    "validate_image",
+    "clean_memory",
+    "apply_flux_rules",
+    "calculate_prompt_score",
+    "get_score_grade",
+    "format_analysis_report",
+    "safe_execute",
+    "truncate_text"
+], '', description)
+    description = re.sub(r'\s*\d+\.\s*,?\s*', ' ', description)
+    
     return description.strip()