Update models.py

models.py

@@ -19,7 +19,8 @@ from utils import clean_memory, safe_execute
 from professional_photography import (
     ProfessionalPhotoAnalyzer, 
     enhance_flux_prompt_with_professional_knowledge,
-    professional_analyzer
+    professional_analyzer,
+    export_professional_prompt_enhancement
 )
 
 logger = logging.getLogger(__name__)
@@ -89,183 +90,43 @@ class BagelAPIAnalyzer(BaseImageAnalyzer):
                     logger.error(f"Fallback initialization failed: {e2}")
             return False
 
-    def _create_professional_enhanced_prompt(self, analysis_type: str = "multimodal") -> str:
-        """Create professionally enhanced prompt that makes BAGEL see with cinematographic eyes"""
-        
-        if analysis_type == "cinematic":
-            return """You are a master cinematographer with 30+ years of experience. Analyze this image with complete professional cinematography knowledge and provide exactly two sections:
-
-1. DESCRIPTION: Analyze what you see using professional cinematography terminology:
-
-First, identify the PHOTOGRAPHIC PLANE:
-- EXTREME WIDE SHOT: Subject very small in environment (establishes location)
-- WIDE SHOT: Full body visible with environment (subject in context) 
-- MEDIUM SHOT: From waist up (balance subject/environment)
-- CLOSE-UP: Head and shoulders (emotion and expression)
-- EXTREME CLOSE-UP: Part of face or detail (intense emotion)
-- DETAIL SHOT: Specific small element (highlight aspect)
-
-Second, identify the CAMERA ANGLE:
-- EYE LEVEL: Camera at subject's eye level (neutral, natural perspective)
-- LOW ANGLE: Camera below looking up (subject appears powerful, heroic)
-- HIGH ANGLE: Camera above looking down (subject appears vulnerable, shows context)
-- DUTCH ANGLE: Camera tilted (dynamic tension, instability)
-
-Third, analyze the LIGHTING:
-- GOLDEN HOUR: Warm, soft, directional light (first/last hour of sun)
-- BLUE HOUR: Even blue light, dramatic mood (20-30 min after sunset)
-- NATURAL DAYLIGHT: Bright sunny conditions
-- SOFT NATURAL: Overcast, diffused, even light
-- DRAMATIC: High contrast, moody shadows
-- STUDIO: Controlled professional lighting
-
-Fourth, identify COMPOSITION:
-- RULE OF THIRDS: Key elements on intersection points
-- LEADING LINES: Lines guide viewer's eye to subject
-- SYMMETRICAL: Mirror-like balance
-- CENTERED: Subject in middle for impact
-- DEPTH LAYERS: Foreground, middle ground, background separation
-
-Now describe the scene combining all these professional elements in flowing descriptive language.
-
-2. CAMERA_SETUP: Recommend specific professional equipment based on your analysis:
-
-For PORTRAIT scenes: Canon EOS R5, 85mm f/1.4 lens, f/2.8, ISO 200, single point AF on eyes
-For LANDSCAPE scenes: Phase One XT, 24-70mm f/4 lens, f/8-f/11, ISO 100, hyperfocal distance
-For STREET scenes: Leica M11, 35mm f/1.4 lens, f/5.6-f/8, ISO 400-1600, zone focusing
-For ARCHITECTURE: Canon EOS R5, 24-70mm f/2.8 lens, f/8-f/11, ISO 100, tilt-shift correction
-For ACTION: Sony A1, 70-200mm f/2.8 lens, f/2.8-f/4, ISO 800-3200, continuous AF tracking
-
-Apply your complete professional cinematography knowledge to see this image as a master would."""
-
-        elif analysis_type == "flux_optimized":
-            return """You are a professional cinematographer analyzing this image for photorealistic prompt generation. Use complete technical knowledge and provide exactly two sections:
-
-1. DESCRIPTION: Technical cinematographic analysis:
-
-PHOTOGRAPHIC PLANE (choose one):
-- Wide shot: Full subject visible with environment 
-- Medium shot: Waist up, balanced composition
-- Close-up: Head and shoulders, tight framing
-- Extreme close-up: Facial details or specific elements
-- Detail shot: Small specific elements highlighted
-
-CAMERA ANGLE (identify):
-- Eye level: Natural, relatable perspective
-- Low angle: Looking up, subject appears powerful  
-- High angle: Looking down, shows vulnerability/context
-- Dutch angle: Tilted, creates dynamic tension
-
-LIGHTING TYPE (analyze):
-- Golden hour: Warm, soft directional light
-- Natural daylight: Bright outdoor conditions
-- Soft natural: Overcast, even diffusion
-- Dramatic: High contrast, moody shadows
-- Blue hour: Even twilight, dramatic mood
-
-COMPOSITION TECHNIQUE (apply):
-- Rule of thirds: Subject on intersection points
-- Leading lines: Elements guide eye to subject
-- Symmetrical: Balanced mirror composition
-- Centered: Subject middle for impact
-- Dynamic: Diagonal elements, movement
-
-Describe the scene using these professional cinematography elements in precise technical language.
-
-2. CAMERA_SETUP: Professional equipment recommendation:
-
-PORTRAIT SETUP: Canon EOS R5 with 85mm f/1.4 lens at f/2.8, ISO 200, rule of thirds composition
-LANDSCAPE SETUP: Phase One XT with 24-70mm f/4 lens at f/8, ISO 100, hyperfocal distance focus
-STREET SETUP: Leica M11 with 35mm f/1.4 lens at f/5.6, ISO 800, zone focusing technique
-ARCHITECTURE SETUP: Canon EOS R5 with 24-70mm f/2.8 lens at f/11, ISO 100, perspective correction
-ACTION SETUP: Sony A1 with 70-200mm f/2.8 lens at f/4, ISO 1600, continuous AF tracking
-
-Choose the setup that matches your scene analysis and provide complete technical specifications."""
-
-        else:  # multimodal analysis
-            return """You are a master cinematographer with decades of professional experience. Analyze this image using complete cinematography knowledge and provide exactly two sections:
-
-1. DESCRIPTION: Professional cinematographic analysis combining:
-
-PHOTOGRAPHIC PLANES: Identify if this is a wide shot (full subject with environment), medium shot (waist up), close-up (head/shoulders), extreme close-up (facial details), or detail shot (specific elements).
-
-CAMERA ANGLES: Determine if shot from eye level (natural perspective), low angle (looking up, powerful), high angle (looking down, vulnerable), or dutch angle (tilted, dynamic).
-
-LIGHTING ANALYSIS: Analyze if this is golden hour (warm directional), natural daylight (bright outdoor), soft natural (overcast even), dramatic (high contrast), blue hour (twilight mood), or studio (controlled).
-
-COMPOSITION: Identify rule of thirds (key elements on intersections), leading lines (guiding elements), symmetrical (balanced), centered (middle impact), or dynamic (diagonal movement).
-
-Describe the complete scene using professional cinematography terminology in flowing descriptive language that captures all visual and technical elements.
-
-2. CAMERA_SETUP: Professional equipment recommendation based on scene analysis:
-
-Choose from these professional setups:
-- PORTRAIT: Canon EOS R5, 85mm f/1.4 lens, f/2.8, ISO 200
-- LANDSCAPE: Phase One XT, 24-70mm f/4 lens, f/8, ISO 100  
-- STREET: Leica M11, 35mm f/1.4 lens, f/5.6, ISO 800
-- ARCHITECTURE: Canon EOS R5, 24-70mm f/2.8 lens, f/11, ISO 100
-- ACTION: Sony A1, 70-200mm f/2.8 lens, f/4, ISO 1600
-
-Provide complete technical specifications matching your cinematographic analysis."""
-
-    def _extract_professional_camera_setup(self, description: str) -> Optional[str]:
-        """Extract and enhance camera setup with professional photography knowledge"""
+    def _get_professional_prompt(self, analysis_type: str = "multimodal") -> str:
+        """Get professional prompt created by professional_photography.py"""
         try:
-            camera_setup = None
-            
-            # Extract BAGEL's camera recommendation
-            if "CAMERA_SETUP:" in description:
-                parts = description.split("CAMERA_SETUP:")
-                if len(parts) > 1:
-                    camera_section = parts[1].strip()
-                    # Take the first substantial line
-                    lines = camera_section.split('\n')
-                    for line in lines:
-                        clean_line = line.strip()
-                        if len(clean_line) > 20 and not clean_line.startswith('2.'):
-                            camera_setup = clean_line
-                            break
-            
-            elif "2. CAMERA_SETUP" in description:
-                parts = description.split("2. CAMERA_SETUP")
-                if len(parts) > 1:
-                    camera_section = parts[1].strip()
-                    lines = camera_section.split('\n')
-                    for line in lines:
-                        clean_line = line.strip()
-                        if len(clean_line) > 20:
-                            camera_setup = clean_line
-                            break
+            # Let professional_photography.py create the complete prompt with full knowledge base
+            enhanced_context = self.professional_analyzer.generate_enhanced_context("")
             
-            # Clean and format camera setup
-            if camera_setup:
-                return self._clean_camera_setup(camera_setup)
+            if analysis_type == "cinematic":
+                # Use the professional analyzer to format cinematic prompt
+                prompt = self.professional_analyzer.format_bagel_enhancement_prompt(
+                    base_prompt="Analyze this image with complete professional cinematography expertise for cinema-quality generation.",
+                    enhanced_context=enhanced_context
+                )
+            elif analysis_type == "flux_optimized":
+                # Use the professional analyzer to format FLUX prompt
+                prompt = self.professional_analyzer.format_bagel_enhancement_prompt(
+                    base_prompt="Analyze this image with complete professional photography knowledge for photorealistic prompt generation.",
+                    enhanced_context=enhanced_context
+                )
+            else:
+                # Use the professional analyzer to format multimodal prompt
+                prompt = self.professional_analyzer.format_bagel_enhancement_prompt(
+                    base_prompt="Analyze this image with complete professional cinematography knowledge for multi-engine prompt generation.",
+                    enhanced_context=enhanced_context
+                )
             
-            return None
+            return prompt
             
         except Exception as e:
-            logger.warning(f"Failed to extract professional camera setup: {e}")
-            return None
+            logger.warning(f"Professional prompt generation failed: {e}")
+            # Fallback to basic professional prompt
+            return """Analyze this image using complete professional cinematography expertise. Provide exactly two sections:
 
-    def _clean_camera_setup(self, raw_setup: str) -> str:
-        """Clean and format camera setup"""
-        try:
-            # Remove common prefixes
-            setup = re.sub(r'^(Based on.*?recommend|I would recommend|For this.*?setup)\s*:?\s*', '', raw_setup, flags=re.IGNORECASE)
-            setup = re.sub(r'^(CAMERA_SETUP:|2\.\s*CAMERA_SETUP:?)\s*', '', setup, flags=re.IGNORECASE)
-            
-            # Clean up formatting
-            setup = re.sub(r'\s+', ' ', setup).strip()
-            
-            # Ensure proper format
-            if setup and not setup.lower().startswith('shot on'):
-                setup = f"shot on {setup}"
-            
-            return setup
-            
-        except Exception as e:
-            logger.warning(f"Camera setup cleaning failed: {e}")
-            return raw_setup
+1. DESCRIPTION: Complete professional visual analysis using your full cinematography knowledge - identify the photographic plane (wide shot, close-up, medium shot), camera angle (eye level, low angle, high angle), lighting type (golden hour, natural daylight, dramatic), and composition technique (rule of thirds, leading lines, symmetrical). Describe the specific subject, action, and context in detail.
+
+2. CAMERA_SETUP: Recommend specific professional equipment based on your scene analysis - camera body, lens specifications, aperture settings, ISO, and any special techniques.
+
+Apply your complete professional cinematography knowledge."""
 
     def _save_temp_image(self, image: Image.Image) -> str:
         """Save image to temporary file for API call"""
@@ -313,29 +174,29 @@ Provide complete technical specifications matching your cinematographic analysis
         }
         
         try:
-            # Use professional enhanced prompt if none provided
+            # Use professional prompt created by professional_photography.py
             if prompt is None:
-                prompt = self._create_professional_enhanced_prompt("multimodal")
+                prompt = self._get_professional_prompt("multimodal")
             
             # Save image to temporary file
             temp_path = self._save_temp_image(image)
             if not temp_path:
                 return "Image processing failed", {"error": "Could not save image"}
             
-            logger.info("Calling BAGEL API with professional cinematography prompt...")
+            logger.info("Calling BAGEL API with professional_photography.py prompt...")
             
-            # Call BAGEL API with enhanced prompt
+            # Call BAGEL API with professional prompt - let it do its work
             result = self.client.predict(
                 image=handle_file(temp_path),
                 prompt=prompt,
                 show_thinking=False,
-                do_sample=False,
-                text_temperature=0.2,
-                max_new_tokens=512,
+                do_sample=True,  # Allow creativity
+                text_temperature=0.7,  # Higher temperature for richer descriptions
+                max_new_tokens=1024,  # More tokens for detailed analysis
                 api_name=self.api_endpoint
             )
             
-            # Extract and process response
+            # Extract response without filtering
             if isinstance(result, tuple) and len(result) >= 2:
                 description = result[1] if result[1] else result[0]
             else:
@@ -344,15 +205,12 @@ Provide complete technical specifications matching your cinematographic analysis
             if isinstance(description, str) and description.strip():
                 description = description.strip()
                 
-                # Extract professional camera setup
-                camera_setup = self._extract_professional_camera_setup(description)
-                if camera_setup:
-                    metadata["camera_setup"] = camera_setup
+                # Extract camera setup if present
+                if "CAMERA_SETUP:" in description or "2. CAMERA_SETUP" in description:
                     metadata["has_camera_suggestion"] = True
-                    logger.info(f"Professional camera setup extracted: {camera_setup}")
+                    logger.info("BAGEL provided camera setup recommendation")
                 else:
                     metadata["has_camera_suggestion"] = False
-                    logger.info("No camera setup found in BAGEL response")
                 
                 # Mark as cinematography enhanced
                 metadata["cinematography_context_applied"] = True
@@ -367,7 +225,7 @@ Provide complete technical specifications matching your cinematographic analysis
                 "analysis_type": "professional_enhanced"
             })
             
-            logger.info(f"BAGEL Professional analysis complete: {len(description)} chars, Camera: {metadata.get('has_camera_suggestion', False)}")
+            logger.info(f"BAGEL Professional analysis complete: {len(description)} chars")
             return description, metadata
             
         except Exception as e:
@@ -380,17 +238,17 @@ Provide complete technical specifications matching your cinematographic analysis
 
     def analyze_for_cinematic_prompt(self, image: Image.Image) -> Tuple[str, Dict[str, Any]]:
         """Analyze image specifically for cinematic/MIA TV Series prompt generation"""
-        cinematic_prompt = self._create_professional_enhanced_prompt("cinematic")
+        cinematic_prompt = self._get_professional_prompt("cinematic")
         return self.analyze_image(image, cinematic_prompt)
 
     def analyze_for_flux_with_professional_context(self, image: Image.Image) -> Tuple[str, Dict[str, Any]]:
         """Analyze image for FLUX with enhanced professional cinematography context"""
-        flux_prompt = self._create_professional_enhanced_prompt("flux_optimized")
+        flux_prompt = self._get_professional_prompt("flux_optimized")
         return self.analyze_image(image, flux_prompt)
 
     def analyze_for_multiengine_prompt(self, image: Image.Image) -> Tuple[str, Dict[str, Any]]:
         """Analyze image for multi-engine compatibility (Flux, Midjourney, etc.)"""
-        multiengine_prompt = self._create_professional_enhanced_prompt("multimodal")
+        multiengine_prompt = self._get_professional_prompt("multimodal")
         return self.analyze_image(image, multiengine_prompt)
 
     def cleanup(self) -> None:
@@ -405,7 +263,7 @@ Provide complete technical specifications matching your cinematographic analysis
 
 
 class FallbackAnalyzer(BaseImageAnalyzer):
-    """Enhanced fallback analyzer with basic professional cinematography principles"""
+    """Enhanced fallback analyzer using professional_photography.py knowledge"""
     
     def __init__(self):
         super().__init__()
@@ -417,43 +275,45 @@ class FallbackAnalyzer(BaseImageAnalyzer):
         return True
     
     def analyze_image(self, image: Image.Image) -> Tuple[str, Dict[str, Any]]:
-        """Provide enhanced image description with cinematography context"""
+        """Provide enhanced image description using professional_photography.py"""
         try:
             width, height = image.size
-            mode = image.mode
             aspect_ratio = width / height
             
-            # Enhanced scene detection with cinematographic analysis
-            if aspect_ratio > 1.5:
-                orientation = "landscape"
-                scene_type = "landscape"
-                plane = "Wide shot"
-                camera_suggestion = "Phase One XT with 24-70mm f/4 lens, f/8, ISO 100"
-            elif aspect_ratio < 0.75:
-                orientation = "portrait"
-                scene_type = "portrait_studio"
-                plane = "Close-up"
-                camera_suggestion = "Canon EOS R5 with 85mm f/1.4 lens, f/2.8, ISO 200"
-            else:
-                orientation = "square"
-                scene_type = "general"
-                plane = "Medium shot"
-                camera_suggestion = "Canon EOS R6 with 50mm f/1.8 lens, f/4, ISO 400"
+            # Use professional_photography.py to analyze basic image properties
+            basic_description = f"Professional photograph with {width}x{height} resolution, aspect ratio {aspect_ratio:.2f}"
             
-            # Generate professional cinematographic description
-            description = f"{plane} composition with balanced framing and professional execution, natural lighting with good contrast, rule of thirds composition, suitable for high-quality reproduction across multiple generative platforms"
+            # Let professional_photography.py enhance this
+            try:
+                enhancement_result = export_professional_prompt_enhancement(
+                    bagel_output=basic_description,
+                    bagel_metadata={"image_size": f"{width}x{height}", "aspect_ratio": aspect_ratio}
+                )
+                
+                description = enhancement_result["enhanced_prompt"]
+                camera_setup = enhancement_result["metadata"].get("technical_context", "")
+                
+            except Exception as e:
+                logger.warning(f"Professional enhancement failed in fallback: {e}")
+                # Basic fallback
+                if aspect_ratio > 1.5:
+                    description = "Wide shot composition with natural lighting and balanced framing"
+                    camera_setup = "shot on Phase One XT, 24-70mm f/4 lens, ISO 100"
+                elif aspect_ratio < 0.75:
+                    description = "Portrait composition with professional lighting and sharp focus"
+                    camera_setup = "shot on Canon EOS R5, 85mm f/1.4 lens, ISO 200"
+                else:
+                    description = "Balanced composition with professional execution"
+                    camera_setup = "shot on Canon EOS R6, 50mm f/1.8 lens, ISO 400"
             
             metadata = {
                 "model": "Professional-Fallback",
                 "device": "cpu",
                 "confidence": 0.7,
                 "image_size": f"{width}x{height}",
-                "color_mode": mode,
-                "orientation": orientation,
                 "aspect_ratio": round(aspect_ratio, 2),
-                "scene_type": scene_type,
                 "has_camera_suggestion": True,
-                "camera_setup": f"shot on {camera_suggestion}",
+                "camera_setup": camera_setup,
                 "professional_enhancement": True,
                 "cinematography_context_applied": True
             }
@@ -462,7 +322,7 @@ class FallbackAnalyzer(BaseImageAnalyzer):
             
         except Exception as e:
             logger.error(f"Professional fallback analysis failed: {e}")
-            return "Professional cinematographic analysis with technical excellence", {
+            return "Professional cinematographic analysis", {
                 "error": str(e), 
                 "model": "Professional-Fallback"
             }
@@ -511,15 +371,15 @@ class ModelManager:
         if success and result[1].get("error") is None:
             return result
         else:
-            # Enhanced fallback with cinematography context
-            logger.warning(f"Primary model failed, using cinematography-enhanced fallback: {result}")
+            # Fallback with professional_photography.py
+            logger.warning(f"Primary model failed, using professional fallback")
             fallback_analyzer = self.get_analyzer("fallback")
             fallback_success, fallback_result = safe_execute(fallback_analyzer.analyze_image, image)
             
             if fallback_success:
                 return fallback_result
             else:
-                return "All cinematography analyzers failed", {"error": "Complete analysis failure"}
+                return "All analyzers failed", {"error": "Complete analysis failure"}
     
     def cleanup_all(self) -> None:
         """Clean up all model resources"""
@@ -527,10 +387,10 @@ class ModelManager:
             analyzer.cleanup()
         self.analyzers.clear()
         clean_memory()
-        logger.info("All cinematography analyzers cleaned up")
+        logger.info("All analyzers cleaned up")
 
 
-# Global model manager instance with cinematography enhancement
+# Global model manager instance
 model_manager = ModelManager(preferred_model="bagel-professional")