Update utils.py

utils.py

@@ -130,45 +130,44 @@ 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 with cinematography knowledge and intelligent token economy
+    Apply enhanced prompt optimization - FORMAT ONLY, do not filter content
+    Let professional_photography.py do ALL the cinematographic work
     
     Args:
-        prompt: Raw prompt text from BAGEL analysis
+        prompt: Raw prompt text from BAGEL analysis (already enriched by professional_photography.py)
         analysis_metadata: Enhanced metadata with cinematography suggestions
         
     Returns:
-        Optimized prompt with professional cinematography terms and efficient token usage
+        Clean formatted prompt preserving ALL professional cinematography content
     """
     if not prompt or not isinstance(prompt, str):
         return ""
     
     try:
-        # Step 1: Extract and clean the core description
-        core_description = _extract_clean_description(prompt)
-        if not core_description:
-            return "Professional photograph with technical excellence"
+        # Step 1: Extract the rich professional description (preserve ALL content)
+        description = _extract_professional_description(prompt)
         
-        # Step 2: Get camera configuration
-        camera_setup = _get_camera_setup(analysis_metadata, core_description)
+        # Step 2: Extract camera setup if provided by BAGEL
+        camera_setup = _extract_camera_setup(prompt, analysis_metadata)
         
-        # Step 3: Get essential style keywords
-        style_keywords = _get_essential_keywords(core_description, camera_setup, analysis_metadata)
+        # Step 3: Format into clean structure (NO filtering)
+        formatted_prompt = _format_professional_prompt(description, camera_setup)
         
-        # Step 4: Build final optimized prompt
-        final_prompt = _build_optimized_prompt(core_description, camera_setup, style_keywords)
-        
-        logger.info(f"Prompt optimized: {len(prompt)} → {len(final_prompt)} chars")
-        return final_prompt
+        logger.info(f"Professional prompt formatted: {len(prompt)} → {len(formatted_prompt)} chars")
+        return formatted_prompt
         
     except Exception as e:
-        logger.error(f"Prompt optimization failed: {e}")
-        return _create_fallback_prompt(prompt)
+        logger.error(f"Professional prompt formatting failed: {e}")
+        return prompt  # Return original if formatting fails
 
 
-def _extract_clean_description(prompt: str) -> str:
-    """Extract and clean the core description from BAGEL output"""
+def _extract_professional_description(prompt: str) -> str:
+    """
+    Extract the professional description - preserve ALL cinematographic content
+    Only clean formatting, DO NOT filter content
+    """
     try:
-        # Remove CAMERA_SETUP section
+        # Split sections if present
         if "CAMERA_SETUP:" in prompt:
             description = prompt.split("CAMERA_SETUP:")[0].strip()
         elif "2. CAMERA_SETUP" in prompt:
@@ -176,342 +175,129 @@ def _extract_clean_description(prompt: str) -> str:
         else:
             description = prompt
         
-        # Remove section headers
+        # Remove only section headers, preserve ALL content
         description = re.sub(r'^(DESCRIPTION:|1\.\s*DESCRIPTION:)\s*', '', description, flags=re.IGNORECASE)
         
-        # Remove verbose introduction phrases
-        remove_patterns = [
-            r'^This image (?:features|shows|depicts|presents|captures)',
-            r'^The image (?:features|shows|depicts|presents|captures)',
-            r'^This (?:photograph|picture|scene) (?:features|shows|depicts)',
-            r'^(?:In this image,?|Looking at this image,?)',
-            r'(?:possibly|apparently|seemingly|appears to be|seems to be)',
-        ]
-        
-        for pattern in remove_patterns:
-            description = re.sub(pattern, '', description, flags=re.IGNORECASE)
-        
-        # Convert to concise, direct language
-        description = _convert_to_direct_language(description)
-        
-        # Clean up formatting
-        description = re.sub(r'\s+', ' ', description).strip()
-        
-        # Limit length for efficiency
-        if len(description) > 200:
-            sentences = re.split(r'[.!?]', description)
-            description = sentences[0] if sentences else description[:200]
-        
-        return description.strip()
+        # Clean up only formatting issues, preserve ALL professional terminology
+        # Remove only redundant whitespace
+        description = re.sub(r'\s+', ' ', description)
+        description = description.strip()
+        
+        # If description is too long, preserve the most important parts
+        # But DO NOT remove cinematographic terms or professional language
+        if len(description) > 300:
+            # Only truncate at sentence boundaries to preserve meaning
+            sentences = re.split(r'[.!?]+', description)
+            truncated = ""
+            for sentence in sentences:
+                if len(truncated + sentence) < 280:
+                    truncated += sentence + ". "
+                else:
+                    break
+            if truncated:
+                description = truncated.strip()
+        
+        return description
         
     except Exception as e:
-        logger.warning(f"Description extraction failed: {e}")
-        return prompt[:100] if prompt else ""
+        logger.warning(f"Professional description extraction failed: {e}")
+        return prompt
 
 
-def _convert_to_direct_language(text: str) -> str:
-    """Convert verbose descriptive text to direct, concise language"""
+def _extract_camera_setup(prompt: str, analysis_metadata: Optional[Dict[str, Any]]) -> str:
+    """
+    Extract camera setup from BAGEL output or metadata
+    """
     try:
-        # Direct conversions for common verbose phrases
-        conversions = [
-            # Subject identification
-            (r'a (?:person|individual|figure|man|woman) (?:who is|that is)', r'person'),
-            (r' (?:who is|that is) (?:wearing|dressed in)', r' wearing'),
-            (r' (?:who appears to be|that appears to be)', r''),
-            
-            # Location simplification  
-            (r'(?:what appears to be|what seems to be) (?:a|an)', r''),
-            (r'in (?:what looks like|what appears to be) (?:a|an)', r'in'),
-            (r'(?:standing|sitting|positioned) in (?:the middle of|the center of)', r'in'),
-            
-            # Action simplification
-            (r'(?:is|are) (?:currently|presently) (?:engaged in|performing)', r''),
-            (r'(?:can be seen|is visible|are visible)', r''),
-            
-            # Background simplification
-            (r'(?:In the background|Behind (?:him|her|them)),? (?:there (?:is|are)|we can see)', r'Background:'),
-            (r'The background (?:features|shows|contains)', r'Background:'),
-            
-            # Remove filler words
-            (r'\b(?:quite|rather|somewhat|fairly|very|extremely)\b', r''),
-            (r'\b(?:overall|generally|typically|usually)\b', r''),
-        ]
-        
-        result = text
-        for pattern, replacement in conversions:
-            result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
-        
-        # Clean up extra spaces and punctuation
-        result = re.sub(r'\s+', ' ', result)
-        result = re.sub(r'\s*,\s*,+', ',', result)
-        result = re.sub(r'^\s*,\s*', '', result)
-        
-        return result.strip()
+        # First check if BAGEL provided camera setup in the prompt
+        camera_setup = ""
         
-    except Exception as e:
-        logger.warning(f"Language conversion failed: {e}")
-        return text
-
-
-def _get_camera_setup(analysis_metadata: Optional[Dict[str, Any]], description: str) -> str:
-    """Get camera setup configuration"""
-    try:
-        # Check if BAGEL provided camera setup
-        if analysis_metadata and analysis_metadata.get("has_camera_suggestion"):
+        if "CAMERA_SETUP:" in prompt:
+            camera_section = prompt.split("CAMERA_SETUP:")[1].strip()
+            # Take first substantial line
+            lines = camera_section.split('\n')
+            for line in lines:
+                if len(line.strip()) > 20:
+                    camera_setup = line.strip()
+                    break
+        
+        elif "2. CAMERA_SETUP" in prompt:
+            camera_section = prompt.split("2. CAMERA_SETUP")[1].strip()
+            lines = camera_section.split('\n')
+            for line in lines:
+                if len(line.strip()) > 20:
+                    camera_setup = line.strip()
+                    break
+        
+        # If no setup in prompt, check metadata
+        if not camera_setup and analysis_metadata:
             camera_setup = analysis_metadata.get("camera_setup", "")
-            if camera_setup and len(camera_setup) > 10:
-                return _format_camera_setup(camera_setup)
         
-        # Detect scene type and provide appropriate camera setup
-        scene_type = _detect_scene_from_content(description)
-        return _get_scene_camera_setup(scene_type)
+        # Format camera setup if found
+        if camera_setup:
+            return _format_camera_setup(camera_setup)
+        
+        # Return empty if no camera setup (let the description speak for itself)
+        return ""
         
     except Exception as e:
-        logger.warning(f"Camera setup detection failed: {e}")
-        return "shot on professional camera"
+        logger.warning(f"Camera setup extraction failed: {e}")
+        return ""
 
 
 def _format_camera_setup(raw_setup: str) -> str:
-    """Format camera setup into clean, concise format"""
-    try:
-        # Extract camera model
-        camera_patterns = [
-            r'(Canon EOS R\d+)',
-            r'(Sony A\d+[^\s,]*)',
-            r'(Leica [^\s,]+)',
-            r'(Phase One [^\s,]+)',
-            r'(Hasselblad [^\s,]+)',
-            r'(ARRI [^\s,]+)',
-            r'(RED [^\s,]+)'
-        ]
-        
-        camera = None
-        for pattern in camera_patterns:
-            match = re.search(pattern, raw_setup, re.IGNORECASE)
-            if match:
-                camera = match.group(1)
-                break
-        
-        # Extract lens info
-        lens_pattern = r'(\d+mm[^,]*f/[\d.]+[^,]*)'
-        lens_match = re.search(lens_pattern, raw_setup, re.IGNORECASE)
-        lens = lens_match.group(1) if lens_match else None
-        
-        # Extract ISO
-        iso_pattern = r'(ISO \d+)'
-        iso_match = re.search(iso_pattern, raw_setup, re.IGNORECASE)
-        iso = iso_match.group(1) if iso_match else None
-        
-        # Build clean setup
-        parts = []
-        if camera:
-            parts.append(camera)
-        if lens:
-            parts.append(lens)
-        if iso:
-            parts.append(iso)
-        
-        if parts:
-            return f"shot on {', '.join(parts)}"
-        else:
-            return "professional photography"
-            
-    except Exception as e:
-        logger.warning(f"Camera setup formatting failed: {e}")
-        return "professional photography"
-
-
-def _detect_scene_from_content(description: str) -> str:
-    """Detect scene type from description content"""
-    description_lower = description.lower()
-    
-    # Scene detection patterns
-    if any(term in description_lower for term in ["portrait", "person", "man", "woman", "face"]):
-        return "portrait"
-    elif any(term in description_lower for term in ["landscape", "mountain", "horizon", "nature", "outdoor"]):
-        return "landscape"
-    elif any(term in description_lower for term in ["street", "urban", "city", "building", "crowd"]):
-        return "street"
-    elif any(term in description_lower for term in ["architecture", "building", "structure", "interior"]):
-        return "architecture"
-    else:
-        return "general"
-
-
-def _get_scene_camera_setup(scene_type: str) -> str:
-    """Get camera setup based on scene type"""
-    setups = {
-        "portrait": "shot on Canon EOS R5, 85mm f/1.4 lens, ISO 200",
-        "landscape": "shot on Phase One XT, 24-70mm f/4 lens, ISO 100", 
-        "street": "shot on Leica M11, 35mm f/1.4 lens, ISO 800",
-        "architecture": "shot on Canon EOS R5, 24-70mm f/2.8 lens, ISO 100",
-        "general": "shot on Canon EOS R6, 50mm f/1.8 lens, ISO 400"
-    }
-    
-    return setups.get(scene_type, setups["general"])
-
-
-def _get_essential_keywords(description: str, camera_setup: str, analysis_metadata: Optional[Dict[str, Any]]) -> List[str]:
-    """Get essential lighting and composition keywords without redundancy"""
+    """
+    Format camera setup preserving ALL technical information
+    """
     try:
-        keywords = []
-        description_lower = description.lower()
-        
-        # Detect and add lighting information
-        lighting = _detect_lighting_from_description(description_lower)
-        if lighting:
-            keywords.append(lighting)
-        
-        # Detect and add composition technique
-        composition = _detect_composition_from_description(description_lower, camera_setup)
-        if composition:
-            keywords.append(composition)
+        # Clean up common prefixes but preserve all technical specs
+        setup = re.sub(r'^(Based on.*?recommend|I would recommend|For this.*?setup)\s*', '', raw_setup, flags=re.IGNORECASE)
+        setup = re.sub(r'^(CAMERA_SETUP:|2\.\s*CAMERA_SETUP:?)\s*', '', setup, flags=re.IGNORECASE)
         
-        # Only add depth of field if not already mentioned and relevant
-        if "depth" not in description_lower and "bokeh" not in description_lower:
-            if any(term in camera_setup for term in ["f/1.4", "f/2.8", "85mm"]):
-                keywords.append("shallow depth of field")
+        # Ensure proper formatting
+        if setup and not setup.lower().startswith('shot on'):
+            setup = f"shot on {setup}"
         
-        # Add professional photography only if no specific camera mentioned (fallback)
-        if "shot on" not in camera_setup and len(keywords) == 0:
-            keywords.append("professional photography")
+        return setup.strip()
         
-        return keywords[:3]  # Limit to 3 essential keywords
-        
-    except Exception as e:
-        logger.warning(f"Keyword extraction failed: {e}")
-        return ["natural lighting"]
-
-
-def _detect_lighting_from_description(description_lower: str) -> Optional[str]:
-    """Detect lighting type from description"""
-    try:
-        # Check for existing lighting mentions
-        if any(term in description_lower for term in ["lighting", "light", "lit", "illuminated"]):
-            return None  # Already has lighting info
-        
-        # Detect lighting conditions from scene context
-        if any(term in description_lower for term in ["sunset", "sunrise", "golden", "warm"]):
-            return "golden hour lighting"
-        elif any(term in description_lower for term in ["twilight", "dusk", "evening", "blue hour"]):
-            return "blue hour lighting"
-        elif any(term in description_lower for term in ["overcast", "cloudy", "soft", "diffused"]):
-            return "soft natural lighting"
-        elif any(term in description_lower for term in ["bright", "sunny", "daylight", "outdoor"]):
-            return "natural daylight"
-        elif any(term in description_lower for term in ["indoor", "interior", "inside"]):
-            return "ambient lighting"
-        elif any(term in description_lower for term in ["studio", "controlled", "professional"]):
-            return "studio lighting"
-        elif any(term in description_lower for term in ["dramatic", "moody", "shadow"]):
-            return "dramatic lighting"
-        else:
-            # Default based on scene type
-            if any(term in description_lower for term in ["portrait", "person", "face"]):
-                return "natural lighting"
-            elif any(term in description_lower for term in ["landscape", "outdoor", "nature"]):
-                return "natural daylight"
-            else:
-                return "natural lighting"
-                
-    except Exception as e:
-        logger.warning(f"Lighting detection failed: {e}")
-        return "natural lighting"
-
-
-def _detect_composition_from_description(description_lower: str, camera_setup: str) -> Optional[str]:
-    """Detect composition technique from description and camera setup"""
-    try:
-        # Check for existing composition mentions
-        if any(term in description_lower for term in ["composition", "framing", "rule of thirds"]):
-            return None  # Already has composition info
-        
-        # Detect composition from perspective/angle
-        if any(term in description_lower for term in ["elevated", "above", "overhead", "aerial"]):
-            return "elevated perspective"
-        elif any(term in description_lower for term in ["low angle", "looking up", "from below"]):
-            return "low angle composition"
-        elif any(term in description_lower for term in ["close-up", "tight", "detailed"]):
-            return "close-up framing"
-        elif any(term in description_lower for term in ["wide", "expansive", "panoramic"]):
-            return "wide composition"
-        
-        # Detect composition from subject arrangement
-        elif any(term in description_lower for term in ["centered", "center", "middle"]):
-            return "centered composition"
-        elif any(term in description_lower for term in ["symmetr", "balanced", "mirror"]):
-            return "symmetrical composition"
-        elif any(term in description_lower for term in ["leading", "lines", "path", "diagonal"]):
-            return "leading lines"
-        
-        # Default composition based on camera setup
-        elif any(term in camera_setup for term in ["85mm", "135mm", "f/1.4", "f/2.8"]):
-            return "rule of thirds"  # Portrait/shallow DOF typically uses rule of thirds
-        elif any(term in camera_setup for term in ["24mm", "35mm", "wide"]):
-            return "dynamic composition"  # Wide angle allows for dynamic compositions
-        else:
-            return "rule of thirds"  # Universal fallback
-            
     except Exception as e:
-        logger.warning(f"Composition detection failed: {e}")
-        return "rule of thirds"
+        logger.warning(f"Camera setup formatting failed: {e}")
+        return raw_setup
 
 
-def _build_optimized_prompt(description: str, camera_setup: str, keywords: List[str]) -> str:
-    """Build final optimized prompt with proper structure"""
+def _format_professional_prompt(description: str, camera_setup: str) -> str:
+    """
+    Format the final prompt preserving ALL professional cinematography content
+    Structure: [Professional Description] + [Camera Setup]
+    """
     try:
-        # Structure: Description + Technical + Style
         parts = []
         
-        # Core description (clean and concise)
+        # Add the rich professional description (preserve ALL content)
         if description:
             parts.append(description)
         
-        # Technical setup
+        # Add camera setup if available
         if camera_setup:
             parts.append(camera_setup)
         
-        # Essential keywords
-        if keywords:
-            parts.extend(keywords)
-        
-        # Join with consistent separator
+        # Join with clean formatting
         result = ", ".join(parts)
         
-        # Final cleanup
+        # Clean up only formatting issues
         result = re.sub(r'\s*,\s*,+', ',', result)  # Remove double commas
-        result = re.sub(r'\s+', ' ', result)  # Clean spaces
-        result = result.strip().rstrip(',')  # Remove trailing comma
+        result = re.sub(r'\s+', ' ', result)  # Clean multiple spaces
+        result = result.strip().rstrip(',')  # Clean edges
         
-        # Ensure it starts with capital letter
+        # Ensure proper capitalization
         if result:
             result = result[0].upper() + result[1:] if len(result) > 1 else result.upper()
         
         return result
         
     except Exception as e:
-        logger.error(f"Prompt building failed: {e}")
-        return "Professional photograph"
-
-
-def _create_fallback_prompt(original_prompt: str) -> str:
-    """Create fallback prompt when optimization fails"""
-    try:
-        # Extract first meaningful sentence
-        sentences = re.split(r'[.!?]', original_prompt)
-        if sentences:
-            clean_sentence = sentences[0].strip()
-            # Remove verbose starters
-            clean_sentence = re.sub(r'^(This image shows|The image depicts|This photograph)', '', clean_sentence, flags=re.IGNORECASE)
-            clean_sentence = clean_sentence.strip()
-            
-            if len(clean_sentence) > 20:
-                return f"{clean_sentence}, professional photography"
-        
-        return "Professional photograph with technical excellence"
-        
-    except Exception:
-        return "Professional photograph"
+        logger.error(f"Professional prompt formatting failed: {e}")
+        return description if description else "Professional cinematographic photograph"
 
 
 def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]] = None) -> Tuple[int, Dict[str, int]]:
@@ -531,8 +317,8 @@ def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]]
     breakdown = {}
     
     # Enhanced Prompt Quality (0-25 points)
-    length_score = min(15, len(prompt) // 10)  # Reward appropriate length
-    detail_score = min(10, len(prompt.split(',')) * 2)  # Reward structured detail
+    length_score = min(15, len(prompt) // 15)  # 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 with Cinematography Focus (0-25 points)
@@ -553,22 +339,30 @@ def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]]
     if re.search(r'ISO \d+', prompt):
         tech_score += 4
     
-    # Professional terminology
-    tech_keywords = ['shot on', 'lens', 'depth of field', 'bokeh']
-    tech_score += sum(3 for keyword in tech_keywords if keyword in prompt.lower())
+    # Professional terminology from professional_photography.py
+    tech_keywords = ['shot on', 'lens', 'depth of field', 'bokeh', 'composition', 'lighting']
+    tech_score += sum(2 for keyword in tech_keywords if keyword in prompt.lower())
     
     breakdown["technical_details"] = min(25, tech_score)
     
-    # Professional Cinematography (0-25 points)
+    # Professional Cinematography (0-25 points) - Check for professional_photography.py terms
     cinema_score = 0
     
-    # Professional lighting techniques
-    lighting_terms = ['professional lighting', 'studio lighting', 'natural lighting']
-    cinema_score += sum(4 for term in lighting_terms if term in prompt.lower())
+    # Photographic planes
+    planes = ['wide shot', 'close-up', 'medium shot', 'extreme wide', 'extreme close-up', 'detail shot']
+    cinema_score += sum(4 for plane in planes if plane in prompt.lower())
+    
+    # Camera angles
+    angles = ['low angle', 'high angle', 'eye level', 'dutch angle', 'elevated perspective']
+    cinema_score += sum(4 for angle in angles if angle in prompt.lower())
+    
+    # Lighting principles
+    lighting = ['golden hour', 'blue hour', 'natural lighting', 'studio lighting', 'dramatic lighting', 'soft lighting']
+    cinema_score += sum(3 for light in lighting if light in prompt.lower())
     
-    # Composition techniques
-    composition_terms = ['composition', 'depth of field', 'bokeh', 'shallow depth']
-    cinema_score += sum(3 for term in composition_terms if term in prompt.lower())
+    # Composition rules
+    composition = ['rule of thirds', 'leading lines', 'symmetrical', 'centered', 'dynamic composition']
+    cinema_score += sum(3 for comp in composition if comp in prompt.lower())
     
     # Professional context bonus
     if analysis_data and analysis_data.get("has_camera_suggestion"):
@@ -579,23 +373,23 @@ def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]]
     # Multi-Engine Optimization (0-25 points)
     optimization_score = 0
     
-    # Check for technical specifications
-    if re.search(r'(?:Canon|Sony|Leica|Phase One)', prompt):
+    # Check for complete technical specifications
+    if re.search(r'(?:Canon|Sony|Leica|Phase One|ARRI|RED)', prompt):
         optimization_score += 10
     
     # Complete technical specs
-    if re.search(r'\d+mm.*f/[\d.]+.*ISO \d+', prompt):
+    if re.search(r'shot on.*\d+mm.*f/[\d.]+', prompt):
         optimization_score += 8
     
-    # Professional terminology
-    pro_terms = ['professional', 'shot on', 'high quality']
-    optimization_score += sum(2 for term in pro_terms if term in prompt.lower())
+    # Professional terminology density
+    pro_terms = ['professional', 'cinematographic', 'shot on', 'composition', 'lighting']
+    optimization_score += sum(1 for term in pro_terms if term in prompt.lower())
     
-    # Length efficiency bonus (reward conciseness)
+    # Length efficiency (reward comprehensive but concise)
     word_count = len(prompt.split())
-    if 30 <= word_count <= 60:  # Optimal range
+    if 40 <= word_count <= 80:  # Optimal range for rich but efficient prompts
         optimization_score += 5
-    elif word_count <= 30:
+    elif 20 <= word_count <= 40:
         optimization_score += 3
     
     breakdown["multi_engine_optimization"] = min(25, optimization_score)
@@ -664,12 +458,12 @@ def format_analysis_report(analysis_data: Dict[str, Any], processing_time: float
 **Professional Context:** {'✅ Applied' if has_cinema_context else '❌ Not Applied'}
 
 **🎯 OPTIMIZATIONS APPLIED:**
-✅ Clean description extraction
-✅ Professional camera configuration
-✅ Essential keyword optimization
-✅ Token economy optimization
-✅ Multi-engine compatibility
-✅ Redundancy elimination
+✅ Complete professional cinematography analysis
+✅ Preserved all technical and artistic content
+✅ Structured professional prompt format
+✅ Multi-engine compatibility maintained
+✅ Professional photography knowledge integrated
+✅ Cinematographic terminology preserved
 
 **⚡ Powered by Pariente AI for MIA TV Series**"""