Update utils.py

utils.py

@@ -123,17 +123,17 @@ def apply_flux_rules(prompt: str, analysis_metadata: Optional[Dict[str, Any]] =
     # Check if BAGEL provided intelligent camera setup
     camera_config = ""
     if analysis_metadata and analysis_metadata.get("has_camera_suggestion") and analysis_metadata.get("camera_setup"):
-        # Use BAGEL's intelligent camera suggestion
+        # Use BAGEL's intelligent camera suggestion - clean and format it properly
         bagel_camera = analysis_metadata["camera_setup"]
-        camera_config = f", {bagel_camera}" if not bagel_camera.startswith(",") else bagel_camera
-        logger.info(f"Using BAGEL camera suggestion: {bagel_camera}")
+        camera_config = _format_bagel_camera_suggestion(bagel_camera)
+        logger.info(f"Using BAGEL camera suggestion: {camera_config}")
     else:
-        # Fallback to static rules if BAGEL didn't suggest camera
+        # Only use fallback if BAGEL didn't suggest anything
         camera_config = _get_fallback_camera_config(description_part.lower())
         logger.info("Using fallback camera configuration")
     
-    # Add lighting enhancements if not present
-    lighting_enhancement = _get_lighting_enhancement(description_part.lower())
+    # Add lighting enhancements if not present and not already covered by BAGEL
+    lighting_enhancement = _get_lighting_enhancement(description_part.lower(), camera_config)
     
     # Build final prompt: Description + Camera + Lighting
     final_prompt = description_part + camera_config + lighting_enhancement
@@ -162,31 +162,78 @@ def _extract_description_only(prompt: str) -> str:
     elif description.startswith("1. DESCRIPTION:"):
         description = description.replace("1. DESCRIPTION:", "").strip()
     
+    # 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)
+    
     return description.strip()
 
 
+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"""
-    if any(word in prompt_lower for word in ['portrait', 'person', 'man', 'woman', 'face']):
+    # 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"]
-    elif any(word in prompt_lower for word in ['street', 'urban', 'city']):
-        return FLUX_RULES["camera_configs"]["street"]
     else:
         return FLUX_RULES["camera_configs"]["default"]
 
 
-def _get_lighting_enhancement(prompt_lower: str) -> str:
+def _get_lighting_enhancement(prompt_lower: str, camera_config: str) -> str:
     """Determine appropriate lighting enhancement"""
-    if 'lighting' not in prompt_lower:
-        if 'dramatic' in prompt_lower:
-            return FLUX_RULES["lighting_enhancements"]["dramatic"]
-        elif 'portrait' in prompt_lower:
-            return FLUX_RULES["lighting_enhancements"]["portrait"]
-        else:
-            return FLUX_RULES["lighting_enhancements"]["default"]
-    return ""  # No enhancement needed if lighting already mentioned
+    # 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:
@@ -205,6 +252,9 @@ def _clean_prompt_formatting(prompt: str) -> str:
     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()
 
 
@@ -238,7 +288,7 @@ def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]]
     
     # Bonus points for BAGEL camera suggestions
     if analysis_data and analysis_data.get("has_camera_suggestion"):
-        tech_score += 5  # Bonus for intelligent camera selection
+        tech_score += 10  # Higher bonus for intelligent camera selection
         
     breakdown["technical_details"] = min(25, tech_score)
     
@@ -250,14 +300,15 @@ def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]]
     # Flux optimization score (0-20 points)
     flux_score = 0
     
-    # Check for camera configuration (either BAGEL or fallback)
-    if any(camera in prompt for camera in FLUX_RULES["camera_configs"].values()) or \
-       (analysis_data and analysis_data.get("has_camera_suggestion")):
-        flux_score += 10
+    # 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 += 10
+        flux_score += 5
         
     breakdown["flux_optimization"] = flux_score
     
@@ -313,7 +364,7 @@ def format_analysis_report(analysis_data: Dict[str, Any], processing_time: float
 ✅ Technical photography details
 ✅ Artistic enhancement keywords
 
-**⚡ Powered by Pariente AI Research**"""
+**⚡ Powered by Frame 0 Laboratory for MIA**"""
     
     return report