Update utils.py

utils.py

@@ -142,525 +142,300 @@ def apply_flux_rules(prompt: str, analysis_metadata: Optional[Dict[str, Any]] =
     if not prompt or not isinstance(prompt, str):
         return ""
     
-    # Clean the prompt from unwanted elements
-    cleaned_prompt = prompt
-    for pattern in FLUX_RULES["remove_patterns"]:
-        cleaned_prompt = re.sub(pattern, '', cleaned_prompt, flags=re.IGNORECASE)
-    
-    # Extract description part only (remove CAMERA_SETUP section if present)
-    description_part = _extract_description_only(cleaned_prompt)
-    
-    # NEW: Convert to generative language with cinematography angle detection
-    if PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("prompt_condensation", True):
-        description_part = _convert_to_cinematographic_language(description_part)
-        logger.info("Applied cinematographic language conversion")
-    
-    # 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 - enhanced with cinematography knowledge
-        bagel_camera = analysis_metadata["camera_setup"]
-        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:
-        # 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 enhanced lighting with cinematography principles
-    lighting_enhancement = _get_cinematography_lighting_enhancement(description_part.lower(), camera_config, scene_type)
-    
-    # Add style enhancement for multi-engine compatibility
-    style_enhancement = _get_style_enhancement(scene_type, description_part.lower())
-    
-    # NEW: Smart keyword insertion with token economy
-    smart_keywords = _apply_smart_keyword_insertion(description_part, camera_config, scene_type)
-    
-    # Build final prompt: Description + Camera + Lighting + Style + Smart Keywords
-    final_prompt = description_part + camera_config + lighting_enhancement + style_enhancement + smart_keywords
-    
-    # NEW: Final length optimization with token economy
-    if PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("prompt_optimization", {}).get("max_length"):
-        final_prompt = _optimize_prompt_with_token_economy(final_prompt)
-    
-    # Clean up formatting
-    final_prompt = _clean_prompt_formatting(final_prompt)
-    
-    return final_prompt
-
-
-def _extract_description_only(prompt: str) -> str:
-    """Extract only the description part, removing camera setup sections"""
-    # Remove CAMERA_SETUP section if present
-    if "CAMERA_SETUP:" in prompt:
-        parts = prompt.split("CAMERA_SETUP:")
-        description = parts[0].strip()
-    elif "2. CAMERA_SETUP" in prompt:
-        parts = prompt.split("2. CAMERA_SETUP")
-        description = parts[0].strip()
-    else:
-        description = prompt
-    
-    # Remove "DESCRIPTION:" label if present
-    if description.startswith("DESCRIPTION:"):
-        description = description.replace("DESCRIPTION:", "").strip()
-    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)
-    description = re.sub(r'Professional Context:.*?\.', '', description, flags=re.DOTALL)
-    description = re.sub(r'Cinematography context:.*?\.', '', description, flags=re.DOTALL)
-    
-    # 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 _detect_camera_angles(description: str) -> List[str]:
-    """Detect camera angles and perspectives using professional cinematography knowledge"""
     try:
-        angles_detected = []
-        description_lower = description.lower()
-        
-        # Low angle (contrapicado) detection
-        low_angle_indicators = [
-            "looking up at", "from below", "upward angle", "towering", "looming",
-            "shot from ground level", "worm's eye", "low angle"
-        ]
-        if any(indicator in description_lower for indicator in low_angle_indicators):
-            angles_detected.append("low-angle shot")
-        
-        # High angle (picado) detection  
-        high_angle_indicators = [
-            "looking down", "from above", "overhead", "bird's eye", "aerial view",
-            "downward angle", "top-down", "high angle"
-        ]
-        if any(indicator in description_lower for indicator in high_angle_indicators):
-            angles_detected.append("high-angle shot")
+        # Step 1: Extract and clean the core description
+        core_description = _extract_clean_description(prompt)
+        if not core_description:
+            return "Professional photograph with technical excellence"
         
-        # Eye level detection
-        eye_level_indicators = [
-            "eye level", "straight on", "direct view", "level with"
-        ]
-        if any(indicator in description_lower for indicator in eye_level_indicators):
-            angles_detected.append("eye-level shot")
+        # Step 2: Get camera configuration
+        camera_setup = _get_camera_setup(analysis_metadata, core_description)
         
-        # Dutch angle detection
-        dutch_indicators = [
-            "tilted", "angled", "diagonal", "off-kilter", "dutch angle"
-        ]
-        if any(indicator in description_lower for indicator in dutch_indicators):
-            angles_detected.append("dutch angle")
+        # Step 3: Get essential style keywords
+        style_keywords = _get_essential_keywords(core_description, camera_setup, analysis_metadata)
         
-        # Perspective analysis for mixed angles
-        if ("foreground" in description_lower and "background" in description_lower):
-            if ("close" in description_lower or "prominent" in description_lower) and "blurred" in description_lower:
-                # Suggests foreground element shot from specific angle with background perspective
-                if not angles_detected:  # Only add if no specific angle detected
-                    angles_detected.append("shallow depth perspective")
+        # Step 4: Build final optimized prompt
+        final_prompt = _build_optimized_prompt(core_description, camera_setup, style_keywords)
         
-        logger.info(f"Camera angles detected: {angles_detected}")
-        return angles_detected
+        logger.info(f"Prompt optimized: {len(prompt)} → {len(final_prompt)} chars")
+        return final_prompt
         
     except Exception as e:
-        logger.warning(f"Camera angle detection failed: {e}")
-        return []
+        logger.error(f"Prompt optimization failed: {e}")
+        return _create_fallback_prompt(prompt)
 
 
-def _convert_to_cinematographic_language(description: str) -> str:
-    """Convert descriptive analysis to cinematographic prompt language with angle detection"""
+def _extract_clean_description(prompt: str) -> str:
+    """Extract and clean the core description from BAGEL output"""
     try:
-        # First detect camera angles
-        camera_angles = _detect_camera_angles(description)
-        
-        generative = description
-        
-        # Remove descriptive introduction phrases
-        descriptive_intros = [
-            r'This image (?:features|shows|depicts|presents|displays)',
-            r'The image (?:features|shows|depicts|presents|displays)',
-            r'This (?:photograph|picture|scene|composition) (?:features|shows|depicts)',
-            r'The (?:photograph|picture|scene|composition) (?:features|shows|depicts)',
-            r'This is (?:a|an) (?:image|photograph|picture) (?:of|showing)',
-            r'The setting (?:appears to be|is)',
-            r'The scene (?:appears to be|is|shows)',
+        # Remove CAMERA_SETUP section
+        if "CAMERA_SETUP:" in prompt:
+            description = prompt.split("CAMERA_SETUP:")[0].strip()
+        elif "2. CAMERA_SETUP" in prompt:
+            description = prompt.split("2. CAMERA_SETUP")[0].strip()
+        else:
+            description = prompt
+        
+        # Remove section headers
+        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 descriptive_intros:
-            generative = re.sub(pattern, '', generative, flags=re.IGNORECASE)
-        
-        # Remove uncertainty and verbose connector phrases
-        verbose_phrases = [
-            r'possibly (?:a|an) ',
-            r'appears to be (?:a|an) ',
-            r'seems to be (?:a|an) ',
-            r'might be (?:a|an) ',
-            r'could be (?:a|an) ',
-            r'suggests (?:a|an) ',
-            r'indicating (?:a|an) ',
-            r'(?:possibly|apparently|seemingly|likely)',
-            r'which (?:is|are|creates|adds)',
-            r'(?:In the background|In the foreground), (?:there are|there is)',
-            r'(?:The background|The foreground) (?:features|shows|contains)',
-            r'(?:There are|There is) [^,]+ (?:in the background|in the foreground)',
-            r'The overall (?:setting|atmosphere|mood) (?:suggests|indicates)',
-        ]
+        for pattern in remove_patterns:
+            description = re.sub(pattern, '', description, flags=re.IGNORECASE)
         
-        for pattern in verbose_phrases:
-            generative = re.sub(pattern, '', generative, flags=re.IGNORECASE)
-        
-        # Convert spatial relationships to cinematographic terms
-        spatial_conversions = [
-            # Background/foreground to cinematographic terms
-            (r'prominently displayed in (?:the )?foreground', 'foreground focus'),
-            (r'in (?:the )?foreground', 'foreground'),
-            (r'in (?:the )?background', 'background'),
-            (r'blurred (?:figures|people|objects)', 'bokeh blur'),
-            (r'out of focus', 'soft focus'),
-            # Convert descriptive structure to noun phrases
-            (r'(?:close-up|medium shot|wide shot) of (?:a|an|the) ', r'close-up '),
-            (r'(?:a|an|the) (\w+)', r'\1'),
-            # Remove excessive connecting words
-            (r'(?:, and|, with|, featuring)', ','),
-            # Simplify location descriptions
-            (r'on (?:a|an|the) ', r'on '),
-            (r'in (?:a|an|the) ', r'in '),
-        ]
+        # Convert to concise, direct language
+        description = _convert_to_direct_language(description)
         
-        for pattern, replacement in spatial_conversions:
-            generative = re.sub(pattern, replacement, generative, flags=re.IGNORECASE)
+        # Clean up formatting
+        description = re.sub(r'\s+', ' ', description).strip()
         
-        # Convert action descriptions to present participles
-        action_conversions = [
-            (r'(\w+) (?:are|is) walking', r'\1 walking'),
-            (r'(\w+) (?:are|is) standing', r'\1 standing'),
-            (r'(\w+) (?:are|is) sitting', r'\1 sitting'),
-            (r'people (?:are|is) out of focus', r'blurred people'),
-        ]
+        # Limit length for efficiency
+        if len(description) > 200:
+            sentences = re.split(r'[.!?]', description)
+            description = sentences[0] if sentences else description[:200]
+        
+        return description.strip()
         
-        for pattern, replacement in action_conversions:
-            generative = re.sub(pattern, replacement, generative, flags=re.IGNORECASE)
+    except Exception as e:
+        logger.warning(f"Description extraction failed: {e}")
+        return prompt[:100] if prompt else ""
+
+
+def _convert_to_direct_language(text: str) -> str:
+    """Convert verbose descriptive text to direct, concise language"""
+    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''),
+        ]
         
-        # Add detected camera angles at the beginning
-        if camera_angles:
-            angle_prefix = ", ".join(camera_angles)
-            generative = f"{angle_prefix}, {generative}"
+        result = text
+        for pattern, replacement in conversions:
+            result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
         
         # Clean up extra spaces and punctuation
-        generative = re.sub(r'\s+', ' ', generative)
-        generative = re.sub(r'^\s*,\s*', '', generative)  # Remove leading commas
-        generative = re.sub(r'\s*,\s*,+', ',', generative)  # Remove double commas
-        generative = re.sub(r'\.+', '.', generative)  # Remove multiple periods
-        
-        # Ensure it starts with a capital letter
-        generative = generative.strip()
-        if generative:
-            generative = generative[0].upper() + generative[1:] if len(generative) > 1 else generative.upper()
+        result = re.sub(r'\s+', ' ', result)
+        result = re.sub(r'\s*,\s*,+', ',', result)
+        result = re.sub(r'^\s*,\s*', '', result)
         
-        logger.info(f"Cinematographic conversion: angles={len(camera_angles)}, {len(description)} → {len(generative)} chars")
-        return generative
+        return result.strip()
         
     except Exception as e:
-        logger.warning(f"Cinematographic language conversion failed: {e}")
-        return description
+        logger.warning(f"Language conversion failed: {e}")
+        return text
 
 
-def _apply_smart_keyword_insertion(description: str, camera_config: str, scene_type: str) -> str:
-    """Smart keyword insertion with token economy - avoid redundancy"""
+def _get_camera_setup(analysis_metadata: Optional[Dict[str, Any]], description: str) -> str:
+    """Get camera setup configuration"""
     try:
-        keywords = []
+        # Check if BAGEL provided camera setup
+        if analysis_metadata and analysis_metadata.get("has_camera_suggestion"):
+            camera_setup = analysis_metadata.get("camera_setup", "")
+            if camera_setup and len(camera_setup) > 10:
+                return _format_camera_setup(camera_setup)
         
-        # Token Economy Rule 1: If camera specs exist, skip "photorealistic" keywords
-        has_camera_specs = bool(re.search(r'(?:Canon|Sony|Leica|ARRI|RED|Hasselblad|Phase One)', camera_config))
-        has_lens_specs = bool(re.search(r'\d+mm.*f/[\d.]+', camera_config))
+        # Detect scene type and provide appropriate camera setup
+        scene_type = _detect_scene_from_content(description)
+        return _get_scene_camera_setup(scene_type)
         
-        # Only add quality keywords if NO technical specs present
-        if not (has_camera_specs and has_lens_specs):
-            quality_keywords = FLUX_RULES.get("mandatory_keywords", {}).get("quality", [])
-            keywords.extend(quality_keywords[:2])  # Limit to 2 quality keywords max
-            logger.info("Added fallback quality keywords (no camera specs detected)")
-        else:
-            logger.info("Skipped redundant quality keywords (camera specs present)")
+    except Exception as e:
+        logger.warning(f"Camera setup detection failed: {e}")
+        return "shot on professional camera"
+
+
+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,]+)'
+        ]
         
-        # Token Economy Rule 2: Scene-specific keywords only if they add value
-        style_by_scene = FLUX_RULES.get("mandatory_keywords", {}).get("style_by_scene", {})
-        if scene_type in style_by_scene:
-            scene_keywords = style_by_scene[scene_type]
-            
-            # Check if scene keywords are already implied by camera config or description
-            for keyword in scene_keywords:
-                if keyword.lower() not in camera_config.lower() and keyword.lower() not in description.lower():
-                    keywords.append(keyword)
-        
-        # Token Economy Rule 3: Technical keywords only if not redundant
-        technical_keywords = FLUX_RULES.get("mandatory_keywords", {}).get("technical", [])
-        for tech_keyword in technical_keywords:
-            # Skip "professional photography" if camera specs already indicate professional level
-            if tech_keyword == "professional photography" and has_camera_specs:
-                continue
-            # Skip "high resolution" if camera specs include resolution indicators
-            if tech_keyword == "high resolution" and has_camera_specs:
-                continue
-            keywords.append(tech_keyword)
-        
-        # Remove duplicates while preserving order
-        unique_keywords = []
-        for keyword in keywords:
-            if keyword not in unique_keywords:
-                unique_keywords.append(keyword)
-        
-        if unique_keywords:
-            result = ", " + ", ".join(unique_keywords)
-            logger.info(f"Smart keywords applied: {unique_keywords}")
-            return result
+        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:
-            logger.info("No additional keywords needed (all redundant)")
-            return ""
+            return "professional photography"
             
     except Exception as e:
-        logger.warning(f"Smart keyword insertion failed: {e}")
-        return ""
+        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 _optimize_prompt_with_token_economy(prompt: str) -> str:
-    """Optimize prompt length with intelligent token economy"""
+
+def _get_essential_keywords(description: str, camera_setup: str, analysis_metadata: Optional[Dict[str, Any]]) -> List[str]:
+    """Get essential style keywords without redundancy"""
     try:
-        max_words = PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("prompt_optimization", {}).get("max_length", 150)
-        
-        words = prompt.split()
-        if len(words) <= max_words:
-            return prompt
-        
-        # Priority preservation order for token economy
-        essential_patterns = [
-            # 1. Camera angles (highest priority)
-            r'(?:low-angle|high-angle|eye-level|dutch angle|bird\'s eye|worm\'s eye) shot',
-            # 2. Camera and lens specs
-            r'(?:Canon|Sony|Leica|ARRI|RED|Hasselblad|Phase One) [^,]+',
-            r'\d+mm[^,]*f/[\d.]+[^,]*',
-            r'ISO \d+',
-            # 3. Core subject and composition
-            r'(?:close-up|medium shot|wide shot|shallow depth)',
-            r'(?:foreground|background|bokeh)',
-            # 4. Scene-specific technical terms
-            r'(?:cinematic|anamorphic|telephoto|wide-angle)',
-        ]
+        keywords = []
+        description_lower = description.lower()
         
-        # Extract essential parts first
-        essential_parts = []
-        remaining_text = prompt
+        # Only add depth of field if not already mentioned
+        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")
         
-        for pattern in essential_patterns:
-            matches = re.findall(pattern, remaining_text, re.IGNORECASE)
-            for match in matches:
-                if match not in essential_parts:
-                    essential_parts.append(match)
-                # Remove from remaining text to avoid duplication
-                remaining_text = re.sub(re.escape(match), '', remaining_text, count=1, flags=re.IGNORECASE)
+        # Add professional photography only if no specific camera mentioned
+        if "shot on" not in camera_setup:
+            keywords.append("professional photography")
         
-        # Add essential parts to start
-        optimized_words = []
-        for part in essential_parts:
-            optimized_words.extend(part.split())
+        # Scene-specific keywords
+        if "portrait" in description_lower and "studio lighting" not in description_lower:
+            keywords.append("professional portrait")
         
-        # Fill remaining space with most important remaining words
-        remaining_words = [w for w in remaining_text.split() if w.strip() and w not in optimized_words]
-        remaining_space = max_words - len(optimized_words)
+        # Technical quality (only if needed)
+        if len(keywords) < 2:
+            keywords.append("high quality")
         
-        if remaining_space > 0:
-            optimized_words.extend(remaining_words[:remaining_space])
+        return keywords[:3]  # Limit to 3 essential keywords
         
-        optimized = " ".join(optimized_words[:max_words])
+    except Exception as e:
+        logger.warning(f"Keyword extraction failed: {e}")
+        return ["professional photography"]
+
+
+def _build_optimized_prompt(description: str, camera_setup: str, keywords: List[str]) -> str:
+    """Build final optimized prompt with proper structure"""
+    try:
+        # Structure: Description + Technical + Style
+        parts = []
+        
+        # Core description (clean and concise)
+        if description:
+            parts.append(description)
+        
+        # Technical setup
+        if camera_setup:
+            parts.append(camera_setup)
+        
+        # Essential keywords
+        if keywords:
+            parts.extend(keywords)
+        
+        # Join with consistent separator
+        result = ", ".join(parts)
+        
+        # Final cleanup
+        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
         
-        logger.info(f"Token economy optimization: {len(words)} → {len(optimized_words)} words, preserved {len(essential_parts)} essential elements")
+        # Ensure it starts with capital letter
+        if result:
+            result = result[0].upper() + result[1:] if len(result) > 1 else result.upper()
         
-        return optimized
+        return result
         
     except Exception as e:
-        logger.warning(f"Token economy optimization failed: {e}")
-        return prompt
+        logger.error(f"Prompt building failed: {e}")
+        return "Professional photograph"
 
 
-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 and fix formatting errors"""
+def _create_fallback_prompt(original_prompt: str) -> str:
+    """Create fallback prompt when optimization fails"""
     try:
-        camera_text = bagel_camera.strip()
-        camera_text = re.sub(r'^CAMERA_SETUP:\s*', '', camera_text)
-        
-        # 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)?[^,]*)',
-            'aperture': r'(f/[\d.]+)'
-        }
-        
-        extracted_parts = []
-        camera_model = None
-        lens_spec = None
-        aperture_spec = None
-        
-        # 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)
+        # 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 iso_match:
-                camera_setup += f", {iso_match.group()}"
-            if composition_match:
-                camera_setup += f", {composition_match.group()}"
-            
-            # Scene-specific enhancement with token economy
-            if scene_type == "cinematic":
-                result = f", Shot on {camera_setup}"  # Skip redundant "cinematic photography"
-            elif scene_type == "portrait":
-                result = f", Shot on {camera_setup}"  # Skip redundant "professional portrait photography"  
-            else:
-                result = f", Shot on {camera_setup}"
-                
-            logger.info(f"Formatted camera setup with token economy: {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:
-        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 at f/2.8, ISO 400",
-        "portrait": ", Shot on Canon EOS R5, 85mm f/1.4 lens at f/2.8, ISO 200, rule of thirds",
-        "landscape": ", Shot on Phase One XT, 24-70mm f/4 lens at f/8, ISO 100, hyperfocal distance",
-        "street": ", Shot on Leica M11, 35mm f/1.4 lens at f/2.8, ISO 800",
-        "architectural": ", Shot on Canon EOS R5, 24-70mm f/2.8 lens at f/8, ISO 100, symmetrical composition",
-        "commercial": ", Shot on Hasselblad X2D 100C, 90mm f/2.5 lens at f/4, ISO 100"
-    }
-    
-    # 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_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 ""
-    
-    # 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 lighting"
-        else:
-            return ", cinematic lighting"
-    elif scene_type == "portrait":
-        return ", studio lighting"
-    elif "dramatic" in description_lower or "chaos" in description_lower:
-        return ", dramatic lighting"
-    else:
-        return ""  # Skip redundant lighting terms
-
-
-def _get_style_enhancement(scene_type: str, description_lower: str) -> str:
-    """Get style enhancement for multi-engine compatibility with token economy"""
-    # Token economy: only add style if it adds unique value
-    if scene_type == "cinematic":
-        if "film grain" not in description_lower:
-            return ", film grain"
-    elif scene_type == "architectural":
-        return ", clean lines"
-    
-    return ""  # Skip redundant style terms
-
-
-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()
+            if len(clean_sentence) > 20:
+                return f"{clean_sentence}, professional photography"
+        
+        return "Professional photograph with technical excellence"
+        
+    except Exception:
+        return "Professional photograph"
 
 
 def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]] = None) -> Tuple[int, Dict[str, int]]:
@@ -681,103 +456,75 @@ def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]]
     
     # 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
+    detail_score = min(10, len(prompt.split(',')) * 2)  # Reward structured detail
     breakdown["prompt_quality"] = int(length_score + detail_score)
     
     # Technical Details with Cinematography Focus (0-25 points)
     tech_score = 0
     
     # Cinema equipment (higher scores for professional gear)
-    cinema_equipment = ['ARRI', 'RED', 'Canon EOS R', 'Sony A1', 'Leica', 'Hasselblad', 'Phase One']
+    cinema_equipment = ['Canon EOS R', 'Sony A1', 'Leica', 'Hasselblad', 'Phase One', 'ARRI', 'RED']
     for equipment in cinema_equipment:
         if equipment.lower() in prompt.lower():
-            tech_score += 6
+            tech_score += 8
             break
     
     # Lens specifications
     if re.search(r'\d+mm.*f/[\d.]+', prompt):
-        tech_score += 5
+        tech_score += 6
     
-    # Camera angles (NEW - high value)
-    angle_terms = ['low-angle shot', 'high-angle shot', 'eye-level shot', 'dutch angle', 'bird\'s eye', 'worm\'s eye']
-    tech_score += sum(4 for term in angle_terms if term in prompt.lower())
-    
-    # Anamorphic and specialized lenses
-    if 'anamorphic' in prompt.lower():
+    # ISO settings
+    if re.search(r'ISO \d+', prompt):
         tech_score += 4
     
     # Professional terminology
-    tech_keywords = ['shot on', 'lens', 'cinematography', 'lighting']
-    for keyword in tech_keywords:
-        if keyword in prompt.lower():
-            tech_score += 2
+    tech_keywords = ['shot on', 'lens', 'depth of field', 'bokeh']
+    tech_score += sum(3 for keyword in tech_keywords if keyword in prompt.lower())
     
-    # Bonus for BAGEL cinematography suggestions
-    if analysis_data and analysis_data.get("has_camera_suggestion"):
-        tech_score += 8
-        
     breakdown["technical_details"] = min(25, tech_score)
     
-    # Professional Cinematography (0-25 points) - Enhanced with angle detection
+    # Professional Cinematography (0-25 points)
     cinema_score = 0
     
-    # Camera angles (high value for professional cinematography)
-    angle_terms = ['low-angle', 'high-angle', 'eye-level', 'dutch angle', 'bird\'s eye', 'worm\'s eye']
-    cinema_score += sum(5 for term in angle_terms if term in prompt.lower())
-    
     # 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())
+    lighting_terms = ['professional lighting', 'studio lighting', 'natural lighting']
+    cinema_score += sum(4 for term in lighting_terms if term in prompt.lower())
     
     # Composition techniques
-    composition_terms = ['composition', 'framing', 'depth of field', 'bokeh', 'rule of thirds', 'foreground', 'background']
-    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', 'shallow depth']
-    cinema_score += sum(3 for term in style_terms if term in prompt.lower())
+    composition_terms = ['composition', 'depth of field', 'bokeh', 'shallow depth']
+    cinema_score += sum(3 for term in composition_terms if term in prompt.lower())
     
     # Professional context bonus
-    if analysis_data and analysis_data.get("cinematography_context_applied"):
-        cinema_score += 5
+    if analysis_data and analysis_data.get("has_camera_suggestion"):
+        cinema_score += 6
     
     breakdown["professional_cinematography"] = min(25, cinema_score)
     
-    # Multi-Engine Optimization (0-25 points) - Token economy aware
+    # Multi-Engine Optimization (0-25 points)
     optimization_score = 0
     
-    # Check for technical specifications (more valuable than generic keywords)
-    if re.search(r'(?:Canon|Sony|Leica|ARRI|RED|Hasselblad|Phase One)', prompt):
-        optimization_score += 8  # Higher score for actual camera specs
+    # Check for technical specifications
+    if re.search(r'(?:Canon|Sony|Leica|Phase One)', prompt):
+        optimization_score += 10
     
+    # Complete technical specs
     if re.search(r'\d+mm.*f/[\d.]+.*ISO \d+', prompt):
-        optimization_score += 7  # Complete technical specs
-    
-    # Token economy bonus: penalize redundant keywords
-    redundant_keywords = ['photorealistic', 'ultra-detailed', 'professional photography']
-    has_camera_specs = bool(re.search(r'(?:Canon|Sony|Leica|ARRI|RED)', prompt))
+        optimization_score += 8
     
-    if has_camera_specs:
-        # Bonus for NOT having redundant keywords when camera specs present
-        redundant_count = sum(1 for keyword in redundant_keywords if keyword in prompt.lower())
-        optimization_score += max(0, 5 - redundant_count * 2)  # Penalty for redundancy
-    else:
-        # If no camera specs, quality keywords are valuable
-        quality_keywords = sum(1 for keyword in redundant_keywords if keyword in prompt.lower())
-        optimization_score += min(5, quality_keywords * 2)
+    # Professional terminology
+    pro_terms = ['professional', 'shot on', 'high quality']
+    optimization_score += sum(2 for term in pro_terms if term in prompt.lower())
     
-    # Scene-specific optimization
-    if any(style in prompt for style in FLUX_RULES.get("style_enhancements", {}).values()):
-        optimization_score += 3
-        
-    # Length efficiency bonus
+    # Length efficiency bonus (reward conciseness)
     word_count = len(prompt.split())
-    if word_count <= 120:  # Reward conciseness
-        optimization_score += 2
+    if 30 <= word_count <= 60:  # Optimal range
+        optimization_score += 5
+    elif word_count <= 30:
+        optimization_score += 3
     
     breakdown["multi_engine_optimization"] = min(25, optimization_score)
     
-    # Calculate total with enhanced weighting
+    # Calculate total
     total_score = sum(breakdown.values())
     
     return total_score, breakdown
@@ -794,7 +541,6 @@ def calculate_professional_enhanced_score(prompt: str, analysis_data: Optional[D
     Returns:
         Tuple of (total_score, breakdown_dict)
     """
-    # Use the enhanced scoring system
     return calculate_prompt_score(prompt, analysis_data)
 
 
@@ -842,9 +588,9 @@ def format_analysis_report(analysis_data: Dict[str, Any], processing_time: float
 **Professional Context:** {'✅ Applied' if has_cinema_context else '❌ Not Applied'}
 
 **🎯 OPTIMIZATIONS APPLIED:**
-✅ Camera angle detection
+✅ Clean description extraction
 ✅ Professional camera configuration
-✅ Cinematography lighting setup  
+✅ Essential keyword optimization
 ✅ Token economy optimization
 ✅ Multi-engine compatibility
 ✅ Redundancy elimination