Update utils.py

utils.py

@@ -1,6 +1,8 @@
 """
-Utility functions for FLUX Prompt Optimizer
-Clean, focused, and reusable utilities
+Utility functions for Phramer AI
+By Pariente AI, for MIA TV Series
+
+Enhanced with professional cinematography knowledge and multi-engine optimization
 """
 
 import re
@@ -11,7 +13,7 @@ from PIL import Image
 import torch
 import numpy as np
 
-from config import PROCESSING_CONFIG, FLUX_RULES
+from config import PROCESSING_CONFIG, FLUX_RULES, PROFESSIONAL_PHOTOGRAPHY_CONFIG
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -98,16 +100,44 @@ def clean_memory() -> None:
         logger.warning(f"Memory cleanup failed: {e}")
 
 
+def detect_scene_type_from_analysis(analysis_metadata: Dict[str, Any]) -> str:
+    """Detect scene type from BAGEL analysis metadata"""
+    try:
+        # Check if BAGEL provided scene detection
+        if "scene_type" in analysis_metadata:
+            return analysis_metadata["scene_type"]
+        
+        # Check camera setup for scene hints
+        camera_setup = analysis_metadata.get("camera_setup", "").lower()
+        
+        if any(term in camera_setup for term in ["portrait", "85mm", "135mm"]):
+            return "portrait"
+        elif any(term in camera_setup for term in ["landscape", "wide", "24mm", "phase one"]):
+            return "landscape"
+        elif any(term in camera_setup for term in ["street", "35mm", "documentary", "leica"]):
+            return "street"
+        elif any(term in camera_setup for term in ["cinema", "arri", "red", "anamorphic"]):
+            return "cinematic"
+        elif any(term in camera_setup for term in ["architecture", "building", "tilt"]):
+            return "architectural"
+        
+        return "default"
+        
+    except Exception as e:
+        logger.warning(f"Scene type detection failed: {e}")
+        return "default"
+
+
 def apply_flux_rules(prompt: str, analysis_metadata: Optional[Dict[str, Any]] = None) -> str:
     """
-    Apply Flux optimization rules to a prompt
+    Apply enhanced prompt optimization rules for multi-engine compatibility
     
     Args:
-        prompt: Raw prompt text
-        analysis_metadata: Optional metadata from image analysis including camera suggestions
+        prompt: Raw prompt text from BAGEL analysis
+        analysis_metadata: Enhanced metadata with cinematography suggestions
         
     Returns:
-        Optimized prompt following Flux rules
+        Optimized prompt for Flux, Midjourney, and other generative engines
     """
     if not prompt or not isinstance(prompt, str):
         return ""
@@ -120,23 +150,30 @@ def apply_flux_rules(prompt: str, analysis_metadata: Optional[Dict[str, Any]] =
     # Extract description part only (remove CAMERA_SETUP section if present)
     description_part = _extract_description_only(cleaned_prompt)
     
-    # Check if BAGEL provided intelligent camera setup
+    # Check if BAGEL provided intelligent camera setup with cinematography context
     camera_config = ""
+    scene_type = "default"
+    
     if analysis_metadata and analysis_metadata.get("has_camera_suggestion") and analysis_metadata.get("camera_setup"):
-        # Use BAGEL's intelligent camera suggestion - clean and format it properly
+        # Use BAGEL's intelligent camera suggestion - enhanced with cinematography knowledge
         bagel_camera = analysis_metadata["camera_setup"]
-        camera_config = _format_bagel_camera_suggestion(bagel_camera)
-        logger.info(f"Using BAGEL camera suggestion: {camera_config}")
+        scene_type = detect_scene_type_from_analysis(analysis_metadata)
+        camera_config = _format_professional_camera_suggestion(bagel_camera, scene_type)
+        logger.info(f"Using BAGEL cinematography suggestion: {camera_config}")
     else:
-        # Only use fallback if BAGEL didn't suggest anything
-        camera_config = _get_fallback_camera_config(description_part.lower())
-        logger.info("Using fallback camera configuration")
+        # Enhanced fallback with professional cinematography knowledge
+        scene_type = _detect_scene_from_description(description_part.lower())
+        camera_config = _get_enhanced_camera_config(scene_type, description_part.lower())
+        logger.info(f"Using enhanced cinematography configuration for {scene_type}")
     
-    # Add lighting enhancements if not present and not already covered by BAGEL
-    lighting_enhancement = _get_lighting_enhancement(description_part.lower(), camera_config)
+    # Add enhanced lighting with cinematography principles
+    lighting_enhancement = _get_cinematography_lighting_enhancement(description_part.lower(), camera_config, scene_type)
     
-    # Build final prompt: Description + Camera + Lighting
-    final_prompt = description_part + camera_config + lighting_enhancement
+    # Add style enhancement for multi-engine compatibility
+    style_enhancement = _get_style_enhancement(scene_type, description_part.lower())
+    
+    # Build final prompt: Description + Camera + Lighting + Style
+    final_prompt = description_part + camera_config + lighting_enhancement + style_enhancement
     
     # Clean up formatting
     final_prompt = _clean_prompt_formatting(final_prompt)
@@ -165,81 +202,133 @@ def _extract_description_only(prompt: str) -> str:
     # Clean up any remaining camera recommendations from the description
     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)
+    description = re.sub(r'Professional Context:.*?\.', '', description, flags=re.DOTALL)
+    description = re.sub(r'Cinematography context:.*?\.', '', description, flags=re.DOTALL)
     
-    # Remove numbered section residues (like "2.," at the end)
+    # Remove numbered section residues
     description = re.sub(r'\s*\d+\.\s*,?\s*$', '', description)
     description = re.sub(r'\s*\d+\.\s*,?\s*', ' ', description)
     
     return description.strip()
 
 
-def _format_bagel_camera_suggestion(bagel_camera: str) -> str:
-    """Format BAGEL's camera suggestion into clean FLUX format"""
+def _detect_scene_from_description(description_lower: str) -> str:
+    """Enhanced scene detection from description with cinematography knowledge"""
+    scene_keywords = PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("scene_detection_keywords", {})
+    
+    # Score each scene type
+    scene_scores = {}
+    for scene_type, keywords in scene_keywords.items():
+        score = sum(1 for keyword in keywords if keyword in description_lower)
+        if score > 0:
+            scene_scores[scene_type] = score
+    
+    # Additional cinematography-specific detection
+    if any(term in description_lower for term in ["film", "movie", "cinematic", "dramatic lighting", "anamorphic"]):
+        scene_scores["cinematic"] = scene_scores.get("cinematic", 0) + 2
+    
+    if any(term in description_lower for term in ["studio", "controlled lighting", "professional portrait"]):
+        scene_scores["portrait"] = scene_scores.get("portrait", 0) + 2
+    
+    # Return highest scoring scene type
+    if scene_scores:
+        return max(scene_scores.items(), key=lambda x: x[1])[0]
+    else:
+        return "default"
+
+
+def _format_professional_camera_suggestion(bagel_camera: str, scene_type: str) -> str:
+    """Format BAGEL's camera suggestion with enhanced cinematography knowledge"""
     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[^,]*)',
+        # Enhanced extraction patterns for cinema equipment
+        cinema_patterns = {
+            'camera': r'(ARRI [^,]+|RED [^,]+|Canon EOS [^,]+|Sony A[^,]+|Leica [^,]+|Hasselblad [^,]+|Phase One [^,]+)',
+            'lens': r'(\d+mm[^,]*(?:anamorphic)?[^,]*|[^,]*(?:anamorphic|telephoto|wide-angle)[^,]*)',
             'aperture': r'(f/[\d.]+[^,]*)'
         }
         
         extracted_parts = []
-        
-        for key, pattern in camera_patterns.items():
+        for key, pattern in cinema_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"
+            # Add scene-specific enhancement
+            if scene_type == "cinematic":
+                return f", Shot on {camera_info}, cinematic photography"
+            elif scene_type == "portrait":
+                return f", Shot on {camera_info}, professional portrait photography"
             else:
-                return ", professional camera setup"
+                return f", Shot on {camera_info}, professional photography"
+        else:
+            return _get_enhanced_camera_config(scene_type, camera_text.lower())
                 
     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"]
+        logger.warning(f"Failed to format professional camera suggestion: {e}")
+        return _get_enhanced_camera_config(scene_type, "")
+
+
+def _get_enhanced_camera_config(scene_type: str, description_lower: str) -> str:
+    """Get enhanced camera configuration with cinematography knowledge"""
+    # Enhanced camera configurations with cinema equipment
+    enhanced_configs = {
+        "cinematic": ", Shot on ARRI Alexa LF, 35mm anamorphic lens, cinematic photography",
+        "portrait": ", Shot on Canon EOS R5, 85mm f/1.4 lens at f/2.8, professional portrait photography",
+        "landscape": ", Shot on Phase One XT, 24-70mm f/4 lens at f/8, epic landscape photography",
+        "street": ", Shot on Leica M11, 35mm f/1.4 lens at f/2.8, documentary street photography",
+        "architectural": ", Shot on Canon EOS R5, 24-70mm f/2.8 lens at f/8, architectural photography",
+        "commercial": ", Shot on Hasselblad X2D 100C, 90mm f/2.5 lens, commercial photography"
+    }
+    
+    # Use enhanced config if available, otherwise fall back to FLUX_RULES
+    if scene_type in enhanced_configs:
+        return enhanced_configs[scene_type]
+    elif scene_type in FLUX_RULES["camera_configs"]:
+        return FLUX_RULES["camera_configs"][scene_type]
     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():
+def _get_cinematography_lighting_enhancement(description_lower: str, camera_config: str, scene_type: str) -> str:
+    """Enhanced lighting with cinematography principles"""
+    # Don't add lighting if already mentioned
+    if any(term in description_lower for term in ["lighting", "lit", "illuminated"]) or 'lighting' in camera_config.lower():
         return ""
     
-    if 'dramatic' in prompt_lower or 'chaos' in prompt_lower or 'fire' in prompt_lower:
+    # Enhanced lighting based on scene type and cinematography knowledge
+    if scene_type == "cinematic":
+        if any(term in description_lower for term in ["dramatic", "moody", "dark"]):
+            return ", dramatic cinematic lighting with practical lights"
+        else:
+            return ", professional cinematic lighting"
+    elif scene_type == "portrait":
+        return ", professional studio lighting with subtle rim light"
+    elif "dramatic" in description_lower or "chaos" in description_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 _get_style_enhancement(scene_type: str, description_lower: str) -> str:
+    """Get style enhancement for multi-engine compatibility"""
+    style_enhancements = FLUX_RULES.get("style_enhancements", {})
+    
+    if scene_type == "cinematic":
+        if "film grain" not in description_lower:
+            return ", " + style_enhancements.get("cinematic", "cinematic composition, film grain")
+    elif scene_type in ["portrait", "commercial"]:
+        return ", " + style_enhancements.get("photorealistic", "photorealistic, ultra-detailed")
+    elif "editorial" in description_lower:
+        return ", " + style_enhancements.get("editorial", "editorial photography style")
+    
+    return ""
+
+
 def _clean_prompt_formatting(prompt: str) -> str:
     """Clean up prompt formatting"""
     if not prompt:
@@ -264,64 +353,118 @@ def _clean_prompt_formatting(prompt: str) -> str:
 
 def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]] = None) -> Tuple[int, Dict[str, int]]:
     """
-    Calculate quality score for a prompt
+    Calculate enhanced quality score with professional cinematography criteria
     
     Args:
         prompt: The prompt to score
-        analysis_data: Optional analysis data to enhance scoring
+        analysis_data: Enhanced analysis data with cinematography context
         
     Returns:
         Tuple of (total_score, breakdown_dict)
     """
     if not prompt:
-        return 0, {"prompt_quality": 0, "technical_details": 0, "artistic_value": 0, "flux_optimization": 0}
+        return 0, {"prompt_quality": 0, "technical_details": 0, "professional_cinematography": 0, "multi_engine_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
+    # Enhanced Prompt Quality (0-25 points)
+    length_score = min(15, len(prompt) // 10)  # Reward appropriate length
+    detail_score = min(10, len(prompt.split(',')) * 1.5)  # Reward structured detail
+    breakdown["prompt_quality"] = int(length_score + detail_score)
     
-    # Technical details score (0-25 points) - Enhanced for BAGEL camera suggestions
+    # Technical Details with Cinematography Focus (0-25 points)
     tech_score = 0
-    tech_keywords = ['shot on', 'lens', 'photography', 'lighting', 'camera']
+    
+    # Cinema equipment (higher scores for professional gear)
+    cinema_equipment = ['ARRI', 'RED', 'Canon EOS R', 'Sony A1', 'Leica', 'Hasselblad', 'Phase One']
+    for equipment in cinema_equipment:
+        if equipment.lower() in prompt.lower():
+            tech_score += 6
+            break
+    
+    # Lens specifications
+    if re.search(r'\d+mm.*f/[\d.]+', prompt):
+        tech_score += 5
+    
+    # Anamorphic and specialized lenses
+    if 'anamorphic' in prompt.lower():
+        tech_score += 4
+    
+    # Professional terminology
+    tech_keywords = ['shot on', 'lens', 'photography', 'lighting', 'cinematic']
     for keyword in tech_keywords:
         if keyword in prompt.lower():
-            tech_score += 5
+            tech_score += 2
     
-    # Bonus points for BAGEL camera suggestions
+    # Bonus for BAGEL cinematography suggestions
     if analysis_data and analysis_data.get("has_camera_suggestion"):
-        tech_score += 10  # Higher bonus for intelligent camera selection
+        tech_score += 8
         
     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)
+    # Professional Cinematography (0-25 points) - NEW CATEGORY
+    cinema_score = 0
     
-    # Flux optimization score (0-20 points)
-    flux_score = 0
+    # Professional lighting techniques
+    lighting_terms = ['cinematic lighting', 'dramatic lighting', 'studio lighting', 'rim light', 'practical lights']
+    cinema_score += sum(3 for term in lighting_terms if term in prompt.lower())
     
-    # 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
+    # Composition techniques
+    composition_terms = ['composition', 'framing', 'depth of field', 'bokeh', 'rule of thirds']
+    cinema_score += sum(2 for term in composition_terms if term in prompt.lower())
+    
+    # Cinematography style elements
+    style_terms = ['film grain', 'anamorphic', 'telephoto compression', 'wide-angle']
+    cinema_score += sum(3 for term in style_terms if term in prompt.lower())
+    
+    # Professional context bonus
+    if analysis_data and analysis_data.get("cinematography_context_applied"):
+        cinema_score += 5
+    
+    breakdown["professional_cinematography"] = min(25, cinema_score)
+    
+    # Multi-Engine Optimization (0-25 points)
+    optimization_score = 0
+    
+    # Check for multi-engine compatible elements
+    multi_engine_terms = ['photorealistic', 'ultra-detailed', 'professional photography', 'cinematic']
+    optimization_score += sum(3 for term in multi_engine_terms if term in prompt.lower())
+    
+    # Technical specifications for generation
+    if any(camera in prompt for camera in FLUX_RULES["camera_configs"].values()):
+        optimization_score += 5
         
-    # Check for lighting configuration  
+    # Lighting configuration
     if any(lighting in prompt for lighting in FLUX_RULES["lighting_enhancements"].values()):
-        flux_score += 5
+        optimization_score += 4
         
-    breakdown["flux_optimization"] = flux_score
+    # Style enhancements
+    if any(style in prompt for style in FLUX_RULES.get("style_enhancements", {}).values()):
+        optimization_score += 3
+    
+    breakdown["multi_engine_optimization"] = min(25, optimization_score)
     
-    # Calculate total
+    # Calculate total with enhanced weighting
     total_score = sum(breakdown.values())
     
     return total_score, breakdown
 
 
+def calculate_professional_enhanced_score(prompt: str, analysis_data: Optional[Dict[str, Any]] = None) -> Tuple[int, Dict[str, int]]:
+    """
+    Enhanced scoring with professional cinematography criteria
+    
+    Args:
+        prompt: The prompt to score
+        analysis_data: Analysis data with cinematography context
+        
+    Returns:
+        Tuple of (total_score, breakdown_dict)
+    """
+    # Use the enhanced scoring system
+    return calculate_prompt_score(prompt, analysis_data)
+
+
 def get_score_grade(score: int) -> Dict[str, str]:
     """
     Get grade information for a score
@@ -344,31 +487,35 @@ def get_score_grade(score: int) -> Dict[str, str]:
 
 def format_analysis_report(analysis_data: Dict[str, Any], processing_time: float) -> str:
     """
-    Format analysis data into a readable report
+    Format analysis data into a readable report with cinematography insights
     
     Args:
-        analysis_data: Analysis results
+        analysis_data: Analysis results with cinematography context
         processing_time: Time taken for processing
         
     Returns:
         Formatted markdown report
     """
-    model_used = analysis_data.get("model_used", "Unknown")
+    model_used = analysis_data.get("model", "Unknown")
     prompt_length = len(analysis_data.get("prompt", ""))
+    has_cinema_context = analysis_data.get("cinematography_context_applied", False)
+    scene_type = analysis_data.get("scene_type", "general")
     
-    report = f"""**🚀 FLUX OPTIMIZATION COMPLETE**
+    report = f"""**🎬 PHRAMER AI ANALYSIS COMPLETE**
 **Model:** {model_used} • **Time:** {processing_time:.1f}s • **Length:** {prompt_length} chars
 
-**📊 ANALYSIS SUMMARY:**
-{analysis_data.get("summary", "Analysis completed successfully")}
+**📊 CINEMATOGRAPHY ANALYSIS:**
+**Scene Type:** {scene_type.replace('_', ' ').title()}
+**Professional Context:** {'✅ Applied' if has_cinema_context else '❌ Not Applied'}
 
 **🎯 OPTIMIZATIONS APPLIED:**
-✅ Flux camera configuration
-✅ Professional lighting setup  
-✅ Technical photography details
-✅ Artistic enhancement keywords
+✅ Professional camera configuration
+✅ Cinematography lighting setup  
+✅ Technical specifications
+✅ Multi-engine compatibility
+✅ Cinema-quality enhancement
 
-**⚡ Powered by Frame 0 Laboratory for MIA**"""
+**⚡ Powered by Pariente AI for MIA TV Series**"""
     
     return report
 
@@ -410,6 +557,35 @@ def truncate_text(text: str, max_length: int = 100) -> str:
     return text[:max_length-3] + "..."
 
 
+def enhance_prompt_with_cinematography_knowledge(original_prompt: str, scene_type: str = "default") -> str:
+    """
+    Enhance prompt with professional cinematography knowledge
+    
+    Args:
+        original_prompt: Base prompt text
+        scene_type: Detected scene type
+        
+    Returns:
+        Enhanced prompt with cinematography context
+    """
+    try:
+        # Import here to avoid circular imports
+        from professional_photography import enhance_flux_prompt_with_professional_knowledge
+        
+        # Apply professional cinematography enhancement
+        enhanced = enhance_flux_prompt_with_professional_knowledge(original_prompt)
+        
+        logger.info(f"Enhanced prompt with cinematography knowledge for {scene_type} scene")
+        return enhanced
+        
+    except ImportError:
+        logger.warning("Professional photography module not available")
+        return original_prompt
+    except Exception as e:
+        logger.warning(f"Cinematography enhancement failed: {e}")
+        return original_prompt
+
+
 # Export main functions
 __all__ = [
     "setup_logging",
@@ -418,8 +594,11 @@ __all__ = [
     "clean_memory",
     "apply_flux_rules",
     "calculate_prompt_score",
+    "calculate_professional_enhanced_score",
     "get_score_grade",
     "format_analysis_report",
     "safe_execute",
-    "truncate_text"
+    "truncate_text",
+    "enhance_prompt_with_cinematography_knowledge",
+    "detect_scene_type_from_analysis"
 ]