Update utils.py

utils.py

@@ -130,14 +130,14 @@ def detect_scene_type_from_analysis(analysis_metadata: Dict[str, Any]) -> str:
 
 def apply_flux_rules(prompt: str, analysis_metadata: Optional[Dict[str, Any]] = None) -> str:
     """
-    Apply enhanced prompt optimization rules for multi-engine compatibility
+    Apply enhanced prompt optimization rules for multi-engine compatibility with condensation
     
     Args:
         prompt: Raw prompt text from BAGEL analysis
         analysis_metadata: Enhanced metadata with cinematography suggestions
         
     Returns:
-        Optimized prompt for Flux, Midjourney, and other generative engines
+        Optimized and condensed prompt for Flux, Midjourney, and other generative engines
     """
     if not prompt or not isinstance(prompt, str):
         return ""
@@ -150,6 +150,11 @@ 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)
     
+    # NEW: Condense the description to remove redundancy
+    if PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("prompt_condensation", True):
+        description_part = _condense_description(description_part)
+        logger.info("Applied prompt condensation")
+    
     # Check if BAGEL provided intelligent camera setup with cinematography context
     camera_config = ""
     scene_type = "default"
@@ -172,8 +177,15 @@ def apply_flux_rules(prompt: str, analysis_metadata: Optional[Dict[str, Any]] =
     # 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
+    # NEW: Add mandatory generative keywords
+    mandatory_keywords = _get_mandatory_keywords(scene_type)
+    
+    # Build final prompt: Description + Camera + Lighting + Style + Keywords
+    final_prompt = description_part + camera_config + lighting_enhancement + style_enhancement + mandatory_keywords
+    
+    # NEW: Final length optimization
+    if PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("prompt_optimization", {}).get("max_length"):
+        final_prompt = _optimize_prompt_length(final_prompt)
     
     # Clean up formatting
     final_prompt = _clean_prompt_formatting(final_prompt)
@@ -212,6 +224,116 @@ def _extract_description_only(prompt: str) -> str:
     return description.strip()
 
 
+def _condense_description(description: str) -> str:
+    """Condense BAGEL's verbose description into concise prompt format"""
+    try:
+        condensed = description
+        
+        # Remove redundant phrases
+        redundant_phrases = FLUX_RULES.get("condensation_patterns", {}).get("remove_redundant_phrases", [])
+        for phrase in redundant_phrases:
+            condensed = re.sub(phrase, '', condensed, flags=re.IGNORECASE)
+        
+        # Simplify lighting descriptions
+        lighting_simplifications = FLUX_RULES.get("condensation_patterns", {}).get("simplify_lighting_descriptions", [])
+        for pattern, replacement in lighting_simplifications:
+            condensed = re.sub(pattern, replacement, condensed, flags=re.IGNORECASE)
+        
+        # Condense mood descriptions
+        mood_condensations = FLUX_RULES.get("condensation_patterns", {}).get("condense_mood_descriptions", [])
+        for pattern, replacement in mood_condensations:
+            condensed = re.sub(pattern, replacement, condensed, flags=re.IGNORECASE)
+        
+        # Remove excessive adjectives and verbose explanations
+        condensed = re.sub(r'\s*,\s*which\s+[^,]+,\s*', ', ', condensed)
+        condensed = re.sub(r'\s*\.\s*The\s+', '. ', condensed)
+        condensed = re.sub(r'\s+', ' ', condensed)
+        
+        # Split into sentences and keep only the most essential
+        sentences = [s.strip() for s in condensed.split('.') if s.strip()]
+        
+        # Keep first 2-3 most descriptive sentences
+        if len(sentences) > 3:
+            essential_sentences = sentences[:3]
+            condensed = '. '.join(essential_sentences)
+        
+        logger.info(f"Condensed description from {len(description)} to {len(condensed)} characters")
+        return condensed.strip()
+        
+    except Exception as e:
+        logger.warning(f"Description condensation failed: {e}")
+        return description
+
+
+def _get_mandatory_keywords(scene_type: str) -> str:
+    """Get mandatory generative keywords based on scene type"""
+    try:
+        mandatory = FLUX_RULES.get("mandatory_keywords", {})
+        
+        keywords = []
+        
+        # Add quality keywords
+        quality_keywords = mandatory.get("quality", [])
+        keywords.extend(quality_keywords)
+        
+        # Add technical keywords
+        technical_keywords = mandatory.get("technical", [])
+        keywords.extend(technical_keywords)
+        
+        # Add scene-specific keywords
+        style_by_scene = mandatory.get("style_by_scene", {})
+        if scene_type in style_by_scene:
+            scene_keywords = style_by_scene[scene_type]
+            keywords.extend(scene_keywords)
+        
+        if keywords:
+            return ", " + ", ".join(keywords)
+        else:
+            return ""
+            
+    except Exception as e:
+        logger.warning(f"Failed to get mandatory keywords: {e}")
+        return ""
+
+
+def _optimize_prompt_length(prompt: str) -> str:
+    """Optimize prompt length while preserving essential information"""
+    try:
+        max_words = PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("prompt_optimization", {}).get("max_length", 150)
+        
+        words = prompt.split()
+        if len(words) <= max_words:
+            return prompt
+        
+        # Keep essential parts: subject, camera setup, technical specs
+        essential_parts = []
+        current_part = []
+        
+        for word in words:
+            current_part.append(word)
+            
+            # Keep camera and technical information
+            if any(tech in word.lower() for tech in ["shot", "lens", "f/", "iso", "mm"]):
+                essential_parts.extend(current_part)
+                current_part = []
+            # Keep quality keywords
+            elif any(qual in word.lower() for qual in ["photorealistic", "cinematic", "professional"]):
+                essential_parts.extend(current_part)
+                current_part = []
+        
+        # Add remaining words if under limit
+        remaining_words = max_words - len(essential_parts)
+        if remaining_words > 0 and current_part:
+            essential_parts.extend(current_part[:remaining_words])
+        
+        optimized = " ".join(essential_parts[:max_words])
+        logger.info(f"Optimized prompt length from {len(words)} to {len(essential_parts)} words")
+        
+        return optimized
+        
+    except Exception as e:
+        logger.warning(f"Prompt length optimization failed: {e}")
+        return prompt
 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", {})
@@ -238,7 +360,7 @@ def _detect_scene_from_description(description_lower: str) -> str:
 
 
 def _format_professional_camera_suggestion(bagel_camera: str, scene_type: str) -> str:
-    """Format BAGEL's camera suggestion with enhanced cinematography knowledge"""
+    """Format BAGEL's camera suggestion with enhanced cinematography knowledge and fix formatting errors"""
     try:
         camera_text = bagel_camera.strip()
         camera_text = re.sub(r'^CAMERA_SETUP:\s*', '', camera_text)
@@ -246,26 +368,64 @@ def _format_professional_camera_suggestion(bagel_camera: str, scene_type: str) -
         # 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.]+[^,]*)'
+            'lens': r'(\d+mm[^,]*(?:anamorphic)?[^,]*)',
+            'aperture': r'(f/[\d.]+)'
         }
         
         extracted_parts = []
-        for key, pattern in cinema_patterns.items():
-            match = re.search(pattern, camera_text, re.IGNORECASE)
-            if match:
-                extracted_parts.append(match.group(1).strip())
+        camera_model = None
+        lens_spec = None
+        aperture_spec = None
         
-        if extracted_parts:
-            camera_info = ', '.join(extracted_parts)
+        # Extract camera
+        camera_match = re.search(cinema_patterns['camera'], camera_text, re.IGNORECASE)
+        if camera_match:
+            camera_model = camera_match.group(1).strip()
+        
+        # Extract lens
+        lens_match = re.search(cinema_patterns['lens'], camera_text, re.IGNORECASE)
+        if lens_match:
+            lens_spec = lens_match.group(1).strip()
+        
+        # Extract aperture
+        aperture_match = re.search(cinema_patterns['aperture'], camera_text, re.IGNORECASE)
+        if aperture_match:
+            aperture_spec = aperture_match.group(1).strip()
+        
+        # Build proper camera setup with all technical specs
+        if camera_model and lens_spec:
+            # Fix the "with, 35mm" error by proper formatting
+            camera_setup = f"{camera_model}, {lens_spec}"
+            
+            # Add aperture if found
+            if aperture_spec:
+                if 'f/' not in lens_spec:  # Don't duplicate aperture
+                    camera_setup += f" at {aperture_spec}"
+            
+            # Add ISO and composition based on scene type
+            enhanced_config = _get_enhanced_camera_config(scene_type, "")
+            
+            # Extract ISO and composition from enhanced config
+            iso_match = re.search(r'ISO \d+', enhanced_config)
+            composition_match = re.search(r'(rule of thirds|leading lines|symmetrical|centered|hyperfocal distance)[^,]*', enhanced_config)
+            
+            if iso_match:
+                camera_setup += f", {iso_match.group()}"
+            if composition_match:
+                camera_setup += f", {composition_match.group()}"
+            
             # Add scene-specific enhancement
             if scene_type == "cinematic":
-                return f", Shot on {camera_info}, cinematic photography"
+                result = f", Shot on {camera_setup}, cinematic photography"
             elif scene_type == "portrait":
-                return f", Shot on {camera_info}, professional portrait photography"
+                result = f", Shot on {camera_setup}, professional portrait photography"
             else:
-                return f", Shot on {camera_info}, professional photography"
+                result = f", Shot on {camera_setup}, professional photography"
+                
+            logger.info(f"Formatted camera setup: {result}")
+            return result
         else:
+            # Fallback to enhanced config if parsing fails
             return _get_enhanced_camera_config(scene_type, camera_text.lower())
                 
     except Exception as e: