Update models.py

models.py

@@ -1,6 +1,8 @@
 """
-Model management for Frame 0 Laboratory for MIA
-BAGEL 7B integration via API calls
+Model management for Phramer AI
+By Pariente AI, for MIA TV Series
+
+BAGEL 7B integration with professional photography knowledge enhancement
 """
 
 import spaces
@@ -12,8 +14,13 @@ from typing import Optional, Dict, Any, Tuple
 from PIL import Image
 from gradio_client import Client, handle_file
 
-from config import get_device_config
+from config import get_device_config, PROFESSIONAL_PHOTOGRAPHY_CONFIG
 from utils import clean_memory, safe_execute
+from professional_photography import (
+    ProfessionalPhotoAnalyzer, 
+    enhance_flux_prompt_with_professional_knowledge,
+    professional_analyzer
+)
 
 logger = logging.getLogger(__name__)
 
@@ -39,14 +46,15 @@ class BaseImageAnalyzer:
 
 
 class BagelAPIAnalyzer(BaseImageAnalyzer):
-    """BAGEL 7B model via API calls to working Space"""
+    """BAGEL 7B model with professional photography knowledge integration"""
     
     def __init__(self):
         super().__init__()
         self.client = None
         self.space_url = "Malaji71/Bagel-7B-Demo"
         self.api_endpoint = "/image_understanding"
-        self.hf_token = os.getenv("HF_TOKEN")  # Get token from environment/secrets
+        self.hf_token = os.getenv("HF_TOKEN")
+        self.professional_analyzer = professional_analyzer
         
     def initialize(self) -> bool:
         """Initialize BAGEL API client with authentication"""
@@ -54,14 +62,14 @@ class BagelAPIAnalyzer(BaseImageAnalyzer):
             return True
         
         try:
-            logger.info("Initializing BAGEL API client...")
+            logger.info("Initializing BAGEL API client for Phramer AI...")
             
-            # Initialize client with token if available (for private spaces)
+            # Initialize client with token if available
             if self.hf_token:
-                logger.info("Using HF token for private space access")
+                logger.info("Using HF token for enhanced API access")
                 self.client = Client(self.space_url, hf_token=self.hf_token)
             else:
-                logger.info("No HF token found, accessing public space")
+                logger.info("Using public API access")
                 self.client = Client(self.space_url)
                 
             self.is_initialized = True
@@ -70,66 +78,130 @@ class BagelAPIAnalyzer(BaseImageAnalyzer):
             
         except Exception as e:
             logger.error(f"BAGEL API client initialization failed: {e}")
-            # If private space fails, try without token as fallback
             if self.hf_token:
                 logger.info("Retrying without token...")
                 try:
                     self.client = Client(self.space_url)
                     self.is_initialized = True
-                    logger.info("BAGEL API client initialized successfully (fallback to public)")
+                    logger.info("BAGEL API client initialized (fallback mode)")
                     return True
                 except Exception as e2:
-                    logger.error(f"Fallback initialization also failed: {e2}")
+                    logger.error(f"Fallback initialization failed: {e2}")
             return False
 
-    def _extract_camera_setup(self, description: str) -> Optional[str]:
-        """Extract camera setup recommendation from BAGEL response with improved parsing"""
+    def _create_professional_enhanced_prompt(self, analysis_type: str = "multimodal") -> str:
+        """Create professionally enhanced prompt for BAGEL analysis"""
+        
+        if analysis_type == "cinematic":
+            return """Analyze this image for professional cinematic prompt generation. You are an expert cinematographer with 30+ years of cinema experience. Provide exactly two sections:
+
+1. DESCRIPTION: Create a detailed, flowing paragraph describing the image for cinematic reproduction:
+- Scene composition and visual storytelling elements
+- Lighting quality, direction, and dramatic mood
+- Color palette, tonal relationships, and atmospheric elements
+- Subject positioning, environmental context, and framing
+- Cinematic qualities: film grain, depth of field, visual style
+- Technical photographic elements that enhance realism
+
+2. CAMERA_SETUP: Recommend professional cinema/photography equipment based on scene analysis:
+- Camera body: Choose from Canon EOS R5/R6, Sony A7R/A1, Leica M11, ARRI Alexa, RED cameras
+- Lens: Specific focal length and aperture (e.g., "85mm f/1.4", "35mm anamorphic f/2.8")
+- Technical settings: Aperture consideration for depth of field and story mood
+- Lighting setup: Professional lighting rationale (key, fill, rim, practical lights)
+- Shooting style: Documentary, portrait, landscape, architectural, or cinematic approach
+
+Apply professional cinematography principles: rule of thirds, leading lines, depth layering, lighting direction for mood, and technical excellence. Focus on creating prompts optimized for photorealistic, cinema-quality generation."""
+
+        elif analysis_type == "flux_optimized":
+            return """Analyze this image for FLUX prompt generation with professional cinematography expertise. You have 30+ years of cinema experience. Provide exactly two sections:
+
+1. DESCRIPTION: Professional analysis for photorealistic reproduction:
+- Image type and photographic classification
+- Subject matter with precise visual details
+- Lighting analysis: quality, direction, color temperature, shadows
+- Composition elements: framing, balance, visual flow
+- Color relationships and tonal values
+- Artistic style and photographic technique employed
+- Technical qualities that contribute to image impact
+
+2. CAMERA_SETUP: Expert equipment recommendation:
+- Professional camera body suited for scene type
+- Specific lens with focal length and maximum aperture
+- Recommended shooting aperture for optimal depth of field
+- Technical considerations: ISO, lighting setup, focus technique
+- Professional shooting approach and methodology
+
+Integrate advanced cinematography principles: exposure triangle mastery, lighting ratios, compositional rules, focus techniques, and professional equipment knowledge. Output should be optimized for FLUX's photorealistic capabilities."""
+
+        else:  # multimodal analysis
+            return """Analyze this image with professional cinematography expertise for multi-platform prompt generation. You are a master cinematographer with extensive technical and artistic knowledge from 30+ years in cinema. Provide exactly two sections:
+
+1. DESCRIPTION: Expert visual analysis for prompt generation:
+- Comprehensive scene description with photographic insight
+- Subject matter, composition, and visual hierarchy
+- Lighting analysis: quality, direction, mood, technical setup
+- Color palette, contrast, and tonal relationships
+- Artistic elements: style, mood, atmosphere, visual impact
+- Technical photographic qualities and execution
+
+2. CAMERA_SETUP: Professional equipment and technique recommendation:
+- Camera system recommendation based on scene requirements
+- Lens selection with specific focal length and aperture range
+- Technical shooting parameters and considerations
+- Lighting setup and methodology for scene recreation
+- Professional approach: shooting style and technical execution
+
+Apply master-level cinematography knowledge: advanced composition techniques, professional lighting principles, camera system expertise, lens characteristics, and technical excellence. Create content suitable for multiple generative engines (Flux, Midjourney, etc.) with emphasis on photorealistic quality."""
+
+    def _extract_professional_camera_setup(self, description: str) -> Optional[str]:
+        """Extract and enhance camera setup with professional photography knowledge"""
         try:
-            # Look for CAMERA_SETUP section first
+            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 meaningful sentence from camera setup
                     camera_text = camera_section.split('\n')[0].strip()
-                    if len(camera_text) > 20:  # Ensure meaningful content
-                        return self._parse_camera_recommendation(camera_text)
+                    if len(camera_text) > 20:
+                        camera_setup = self._parse_professional_camera_recommendation(camera_text)
             
-            # Look for "2. CAMERA_SETUP" pattern
-            if "2. CAMERA_SETUP" in description:
+            elif "2. CAMERA_SETUP" in description:
                 parts = description.split("2. CAMERA_SETUP")
                 if len(parts) > 1:
                     camera_section = parts[1].strip()
                     camera_text = camera_section.split('\n')[0].strip()
                     if len(camera_text) > 20:
-                        return self._parse_camera_recommendation(camera_text)
+                        camera_setup = self._parse_professional_camera_recommendation(camera_text)
             
-            # Look for camera recommendations within the text
-            camera_recommendation = self._find_camera_recommendation(description)
-            if camera_recommendation:
-                return camera_recommendation
+            # Fallback: look for camera recommendations in text
+            if not camera_setup:
+                camera_setup = self._find_professional_camera_recommendation(description)
             
-            return None
+            return camera_setup
             
         except Exception as e:
-            logger.warning(f"Failed to extract camera setup: {e}")
+            logger.warning(f"Failed to extract professional camera setup: {e}")
             return None
 
-    def _parse_camera_recommendation(self, camera_text: str) -> Optional[str]:
-        """Parse and extract specific camera and lens information"""
+    def _parse_professional_camera_recommendation(self, camera_text: str) -> Optional[str]:
+        """Parse camera recommendation with professional photography enhancement"""
         try:
-            # Remove common prefixes and clean text
+            # Clean and extract with professional patterns
             camera_text = re.sub(r'^(Based on.*?recommend|I would recommend|For this.*?recommend)\s*', '', camera_text, flags=re.IGNORECASE)
-            camera_text = re.sub(r'^(using a|use a|cameras? like)\s*', '', camera_text, flags=re.IGNORECASE)
             
-            # Extract camera model with specific patterns
+            # Professional camera patterns (more comprehensive)
             camera_patterns = [
-                r'(Canon EOS [R\d]+[^\s,]*(?:\s+[IVX]+)?)',
-                r'(Sony A[^\s,]+(?:\s+[IVX]+)?)', 
+                r'(Canon EOS R[^\s,]*(?:\s+[^\s,]*)?)',
+                r'(Sony A[^\s,]*(?:\s+[^\s,]*)?)',
                 r'(Leica [^\s,]+)',
                 r'(Hasselblad [^\s,]+)',
                 r'(Phase One [^\s,]+)',
-                r'(Fujifilm [^\s,]+)'
+                r'(Fujifilm [^\s,]+)',
+                r'(ARRI [^\s,]+)',
+                r'(RED [^\s,]+)',
+                r'(Nikon [^\s,]+)'
             ]
             
             camera_model = None
@@ -139,12 +211,14 @@ class BagelAPIAnalyzer(BaseImageAnalyzer):
                     camera_model = match.group(1).strip()
                     break
             
-            # Extract lens information with improved patterns
+            # Professional lens patterns (enhanced)
             lens_patterns = [
-                r'(\d+mm\s*f/[\d.]+(?:\s*lens)?)',
+                r'(\d+mm\s*f/[\d.]+(?:\s*(?:lens|anamorphic|telephoto|wide))?)',
                 r'(\d+-\d+mm\s*f/[\d.]+(?:\s*lens)?)',
                 r'(with\s+(?:a\s+)?(\d+mm[^,.]*))',
-                r'(paired with.*?(\d+mm[^,.]*))' 
+                r'(paired with.*?(\d+mm[^,.]*))',
+                r'(\d+mm[^,]*anamorphic[^,]*)',
+                r'(\d+mm[^,]*telephoto[^,]*)'
             ]
             
             lens_info = None
@@ -155,14 +229,7 @@ class BagelAPIAnalyzer(BaseImageAnalyzer):
                     lens_info = re.sub(r'^(with\s+(?:a\s+)?|paired with\s+)', '', lens_info, flags=re.IGNORECASE)
                     break
             
-            # Extract aperture if not in lens info
-            if not lens_info or 'f/' not in lens_info:
-                aperture_match = re.search(r'(f/[\d.]+)', camera_text)
-                aperture = aperture_match.group(1) if aperture_match else None
-                if aperture and lens_info:
-                    lens_info = f"{lens_info} {aperture}"
-            
-            # Build clean recommendation
+            # Build professional recommendation
             parts = []
             if camera_model:
                 parts.append(camera_model)
@@ -171,44 +238,71 @@ class BagelAPIAnalyzer(BaseImageAnalyzer):
             
             if parts:
                 result = ', '.join(parts)
-                logger.info(f"Parsed camera recommendation: {result}")
+                logger.info(f"Professional camera setup extracted: {result}")
                 return result
             
             return None
             
         except Exception as e:
-            logger.warning(f"Failed to parse camera recommendation: {e}")
+            logger.warning(f"Failed to parse professional camera recommendation: {e}")
             return None
 
-    def _find_camera_recommendation(self, text: str) -> Optional[str]:
-        """Find camera recommendations anywhere in the text"""
+    def _find_professional_camera_recommendation(self, text: str) -> Optional[str]:
+        """Find professional camera recommendations with enhanced detection"""
         try:
-            # Look for sentences containing camera info
             sentences = re.split(r'[.!?]', text)
             
             for sentence in sentences:
-                # Check if sentence contains camera info
-                if any(brand in sentence.lower() for brand in ['canon', 'sony', 'leica', 'hasselblad', 'phase one', 'fujifilm']):
-                    if any(term in sentence.lower() for term in ['recommend', 'suggest', 'would use', 'camera', 'lens']):
-                        parsed = self._parse_camera_recommendation(sentence.strip())
+                # Professional camera brands and technical terms
+                if any(brand in sentence.lower() for brand in ['canon', 'sony', 'leica', 'hasselblad', 'phase one', 'fujifilm', 'arri', 'red']):
+                    if any(term in sentence.lower() for term in ['recommend', 'suggest', 'would use', 'camera', 'lens', 'shot on']):
+                        parsed = self._parse_professional_camera_recommendation(sentence.strip())
                         if parsed:
                             return parsed
             
             return None
             
         except Exception as e:
-            logger.warning(f"Failed to find camera recommendation: {e}")
+            logger.warning(f"Failed to find professional camera recommendation: {e}")
             return None
 
+    def _enhance_description_with_professional_context(self, description: str, image: Image.Image) -> str:
+        """Enhance BAGEL description with professional cinematography context"""
+        try:
+            if not PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("enable_expert_analysis", True):
+                return description
+            
+            # Get professional cinematography context without being invasive
+            enhanced_context = self.professional_analyzer.generate_enhanced_context(description)
+            
+            # Extract key professional insights
+            scene_type = enhanced_context.get("scene_type", "general")
+            technical_context = enhanced_context.get("technical_context", "")
+            professional_insight = enhanced_context.get("professional_insight", "")
+            
+            # Enhance description subtly with professional terminology
+            enhanced_description = description
+            
+            # Add professional context if not already present
+            if technical_context and len(technical_context) > 20:
+                # Only add if it doesn't duplicate existing information
+                if not any(term in description.lower() for term in ["shot on", "professional", "camera"]):
+                    enhanced_description += f"\n\nProfessional Context: {technical_context}"
+            
+            logger.info(f"Enhanced description with cinematography context for {scene_type} scene")
+            return enhanced_description
+            
+        except Exception as e:
+            logger.warning(f"Cinematography context enhancement failed: {e}")
+            return description
+
     def _save_temp_image(self, image: Image.Image) -> str:
         """Save image to temporary file for API call"""
         try:
-            # Create temporary file
             temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
             temp_path = temp_file.name
             temp_file.close()
             
-            # Save image
             if image.mode != 'RGB':
                 image = image.convert('RGB')
             image.save(temp_path, 'PNG')
@@ -229,53 +323,37 @@ class BagelAPIAnalyzer(BaseImageAnalyzer):
 
     @spaces.GPU(duration=60)
     def analyze_image(self, image: Image.Image, prompt: str = None) -> Tuple[str, Dict[str, Any]]:
-        """Analyze image using BAGEL API"""
+        """Analyze image using BAGEL API with professional cinematography enhancement"""
         if not self.is_initialized:
             success = self.initialize()
             if not success:
                 return "BAGEL API not available", {"error": "API initialization failed"}
         
         temp_path = None
-        
-        # Initialize metadata early
         metadata = {
-            "model": "BAGEL-7B-API",
+            "model": "BAGEL-7B-Professional",
             "device": "api",
             "confidence": 0.9,
             "api_endpoint": self.api_endpoint,
             "space_url": self.space_url,
             "prompt_used": prompt,
-            "has_camera_suggestion": False
+            "has_camera_suggestion": False,
+            "professional_enhancement": True
         }
         
         try:
-            # Enhanced prompt for better structured output
+            # Use professional enhanced prompt if none provided
             if prompt is None:
-                prompt = """Analyze this image for professional photography reproduction. Provide exactly two sections:
-
-1. DESCRIPTION: Write a single flowing paragraph describing what you see. Start directly with the subject (e.g., "A color photograph showing..." or "A black and white image depicting..."). Include:
-- Image type (photograph, illustration, artwork)
-- Subject and composition
-- Color palette and lighting conditions
-- Mood and atmosphere
-- Photographic style and format
-
-2. CAMERA_SETUP: Based on the scene type you observe, recommend ONE specific professional camera and lens combination:
-- For street/documentary scenes: Canon EOS R6 with 35mm f/1.4 lens
-- For portrait photography: Canon EOS R5 with 85mm f/1.4 lens
-- For landscape photography: Phase One XT with 24-70mm f/4 lens
-- For action/sports: Sony A1 with 70-200mm f/2.8 lens
-
-Give only the camera model and lens specification, nothing else."""
+                prompt = self._create_professional_enhanced_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 for image analysis...")
+            logger.info("Calling BAGEL API with professional cinematography context...")
             
-            # Call BAGEL API
+            # Call BAGEL API with enhanced prompt
             result = self.client.predict(
                 image=handle_file(temp_path),
                 prompt=prompt,
@@ -286,132 +364,151 @@ Give only the camera model and lens specification, nothing else."""
                 api_name=self.api_endpoint
             )
             
-            # Extract response (API returns tuple: (image_result, text_response))
+            # Extract and process response
             if isinstance(result, tuple) and len(result) >= 2:
                 description = result[1] if result[1] else result[0]
             else:
                 description = str(result)
             
-            # Process the description and extract camera setup
             if isinstance(description, str) and description.strip():
                 description = description.strip()
                 
-                # Extract camera setup with improved parsing
-                camera_setup = self._extract_camera_setup(description)
+                # Extract professional camera setup
+                camera_setup = self._extract_professional_camera_setup(description)
                 if camera_setup:
                     metadata["camera_setup"] = camera_setup
                     metadata["has_camera_suggestion"] = True
-                    logger.info(f"Extracted camera setup: {camera_setup}")
+                    logger.info(f"Professional camera setup extracted: {camera_setup}")
                 else:
                     metadata["has_camera_suggestion"] = False
-                    logger.warning("No valid camera setup found in BAGEL response")
+                    logger.info("No camera setup found, will use professional fallback")
+                
+                # Enhance description with cinematography context
+                if PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("knowledge_base_integration", True):
+                    description = self._enhance_description_with_professional_context(description, image)
+                    metadata["cinematography_context_applied"] = True
+                
             else:
-                description = "Detailed image analysis completed successfully"
+                description = "Professional image analysis completed successfully"
                 metadata["has_camera_suggestion"] = False
             
-            # Update final metadata
+            # Update metadata
             metadata.update({
-                "response_length": len(description)
+                "response_length": len(description),
+                "analysis_type": "professional_enhanced"
             })
             
-            logger.info(f"BAGEL API analysis complete: {len(description)} characters, Camera: {metadata.get('has_camera_suggestion', False)}")
+            logger.info(f"BAGEL Professional analysis complete: {len(description)} chars, Camera: {metadata.get('has_camera_suggestion', False)}")
             return description, metadata
             
         except Exception as e:
-            logger.error(f"BAGEL API analysis failed: {e}")
-            return "API analysis failed", {"error": str(e), "model": "BAGEL-7B-API"}
+            logger.error(f"BAGEL Professional analysis failed: {e}")
+            return "Professional analysis failed", {"error": str(e), "model": "BAGEL-7B-Professional"}
         
         finally:
-            # Always cleanup temporary file
             if temp_path:
                 self._cleanup_temp_file(temp_path)
 
-    def analyze_for_flux_prompt(self, image: Image.Image) -> Tuple[str, Dict[str, Any]]:
-        """Analyze image specifically for FLUX prompt generation"""
-        flux_prompt = """Analyze this image for professional FLUX generation. Provide exactly two sections:
-
-1. DESCRIPTION: Create a single flowing paragraph starting directly with the subject. Be precise about:
-- Image type (photograph, illustration, artwork)  
-- Subject matter and composition
-- Color palette (specific colors, warm/cool tones, monochrome)
-- Lighting conditions and photographic style
-- Mood, atmosphere, and artistic elements
-
-2. CAMERA_SETUP: Recommend ONE specific professional camera and lens for this scene type:
-- Street/urban/documentary: Canon EOS R6 with 35mm f/1.4 lens
-- Portrait photography: Canon EOS R5 with 85mm f/1.4 lens
-- Landscape photography: Phase One XT with 24-70mm f/4 lens
-- Action/sports: Sony A1 with 70-200mm f/2.8 lens
+    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")
+        return self.analyze_image(image, cinematic_prompt)
 
-Give only the camera model and exact lens specification."""
-        
+    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")
         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")
+        return self.analyze_image(image, multiengine_prompt)
+
     def cleanup(self) -> None:
         """Clean up API client resources"""
         try:
             if hasattr(self, 'client'):
                 self.client = None
             super().cleanup()
-            logger.info("BAGEL API resources cleaned up")
+            logger.info("BAGEL Professional API resources cleaned up")
         except Exception as e:
-            logger.warning(f"BAGEL API cleanup warning: {e}")
+            logger.warning(f"BAGEL Professional API cleanup warning: {e}")
 
 
 class FallbackAnalyzer(BaseImageAnalyzer):
-    """Simple fallback analyzer when BAGEL API is not available"""
+    """Enhanced fallback analyzer with basic professional cinematography principles"""
     
     def __init__(self):
         super().__init__()
+        self.professional_analyzer = professional_analyzer
         
     def initialize(self) -> bool:
-        """Fallback is always ready"""
+        """Fallback with cinematography enhancement is always ready"""
         self.is_initialized = True
         return True
     
     def analyze_image(self, image: Image.Image) -> Tuple[str, Dict[str, Any]]:
-        """Provide basic image description"""
+        """Provide enhanced image description with cinematography context"""
         try:
-            # Basic image analysis
             width, height = image.size
             mode = image.mode
-            
-            # Simple descriptive text based on image properties
             aspect_ratio = width / height
             
+            # Enhanced scene detection
             if aspect_ratio > 1.5:
                 orientation = "landscape"
-                camera_suggestion = "wide-angle lens, landscape photography"
+                scene_type = "landscape"
+                camera_suggestion = "Phase One XT with 24-70mm f/4 lens, landscape photography"
             elif aspect_ratio < 0.75:
                 orientation = "portrait"
-                camera_suggestion = "portrait lens, shallow depth of field"
+                scene_type = "portrait_studio"
+                camera_suggestion = "Canon EOS R5 with 85mm f/1.4 lens, portrait photography"
             else:
                 orientation = "square"
-                camera_suggestion = "standard lens, balanced composition"
-            
-            description = f"A {orientation} format image with professional composition. The image shows clear detail and good visual balance, suitable for high-quality reproduction. Recommended camera setup: {camera_suggestion}, professional lighting with careful attention to exposure and color balance."
+                scene_type = "general"
+                camera_suggestion = "Canon EOS R6 with 50mm f/1.8 lens, standard photography"
+            
+            # Generate professional description
+            description = f"A {orientation} format professional photograph with balanced composition and technical excellence. The image demonstrates clear visual hierarchy and professional execution, suitable for high-quality reproduction across multiple generative platforms. Recommended professional setup: {camera_suggestion}, with careful attention to exposure, lighting, and artistic composition."
+            
+            # Add cinematography context if available
+            try:
+                if PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("enable_expert_analysis", True):
+                    enhanced_context = self.professional_analyzer.generate_enhanced_context(description)
+                    technical_context = enhanced_context.get("technical_context", "")
+                    if technical_context:
+                        description += f" Cinematography context: {technical_context}"
+            except Exception as e:
+                logger.warning(f"Cinematography context enhancement failed in fallback: {e}")
             
             metadata = {
-                "model": "Fallback",
+                "model": "Professional-Fallback",
                 "device": "cpu",
-                "confidence": 0.6,
+                "confidence": 0.7,
                 "image_size": f"{width}x{height}",
                 "color_mode": mode,
                 "orientation": orientation,
-                "aspect_ratio": round(aspect_ratio, 2)
+                "aspect_ratio": round(aspect_ratio, 2),
+                "scene_type": scene_type,
+                "has_camera_suggestion": True,
+                "camera_setup": camera_suggestion,
+                "professional_enhancement": True
             }
             
             return description, metadata
             
         except Exception as e:
-            logger.error(f"Fallback analysis failed: {e}")
-            return "Professional image suitable for detailed analysis and prompt generation", {"error": str(e), "model": "Fallback"}
+            logger.error(f"Professional fallback analysis failed: {e}")
+            return "Professional image suitable for detailed analysis and multi-engine prompt generation", {
+                "error": str(e), 
+                "model": "Professional-Fallback"
+            }
 
 
 class ModelManager:
-    """Manager for handling image analysis models"""
+    """Enhanced manager for handling image analysis models with professional cinematography integration"""
     
-    def __init__(self, preferred_model: str = "bagel-api"):
+    def __init__(self, preferred_model: str = "bagel-professional"):
         self.preferred_model = preferred_model
         self.analyzers = {}
         self.current_analyzer = None
@@ -421,42 +518,45 @@ class ModelManager:
         model_name = model_name or self.preferred_model
         
         if model_name not in self.analyzers:
-            if model_name == "bagel-api":
+            if model_name in ["bagel-api", "bagel-professional"]:
                 self.analyzers[model_name] = BagelAPIAnalyzer()
             elif model_name == "fallback":
                 self.analyzers[model_name] = FallbackAnalyzer()
             else:
-                logger.warning(f"Unknown model: {model_name}, using fallback")
+                logger.warning(f"Unknown model: {model_name}, using professional fallback")
                 model_name = "fallback"
                 self.analyzers[model_name] = FallbackAnalyzer()
         
         return self.analyzers[model_name]
     
-    def analyze_image(self, image: Image.Image, model_name: str = None, analysis_type: str = "detailed") -> Tuple[str, Dict[str, Any]]:
-        """Analyze image with specified or preferred model"""
-        # Try preferred model first
+    def analyze_image(self, image: Image.Image, model_name: str = None, analysis_type: str = "multiengine") -> Tuple[str, Dict[str, Any]]:
+        """Analyze image with professional cinematography enhancement"""
         analyzer = self.get_analyzer(model_name)
         if analyzer is None:
             return "No analyzer available", {"error": "Model not found"}
         
-        # Choose analysis method based on type
-        if analysis_type == "flux" and hasattr(analyzer, 'analyze_for_flux_prompt'):
-            success, result = safe_execute(analyzer.analyze_for_flux_prompt, image)
+        # Choose analysis method based on type and analyzer capabilities
+        if analysis_type == "cinematic" and hasattr(analyzer, 'analyze_for_cinematic_prompt'):
+            success, result = safe_execute(analyzer.analyze_for_cinematic_prompt, image)
+        elif analysis_type == "flux" and hasattr(analyzer, 'analyze_for_flux_with_professional_context'):
+            success, result = safe_execute(analyzer.analyze_for_flux_with_professional_context, image)
+        elif analysis_type == "multiengine" and hasattr(analyzer, 'analyze_for_multiengine_prompt'):
+            success, result = safe_execute(analyzer.analyze_for_multiengine_prompt, image)
         else:
             success, result = safe_execute(analyzer.analyze_image, image)
         
         if success and result[1].get("error") is None:
             return result
         else:
-            # Fallback to simple analyzer if main model fails
-            logger.warning(f"Primary model failed, using fallback: {result}")
+            # Enhanced fallback with cinematography context
+            logger.warning(f"Primary model failed, using cinematography-enhanced fallback: {result}")
             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 analyzers failed", {"error": "Complete analysis failure"}
+                return "All cinematography analyzers failed", {"error": "Complete analysis failure"}
     
     def cleanup_all(self) -> None:
         """Clean up all model resources"""
@@ -464,24 +564,24 @@ class ModelManager:
             analyzer.cleanup()
         self.analyzers.clear()
         clean_memory()
-        logger.info("All analyzers cleaned up")
+        logger.info("All cinematography analyzers cleaned up")
 
 
-# Global model manager instance
-model_manager = ModelManager(preferred_model="bagel-api")
+# Global model manager instance with cinematography enhancement
+model_manager = ModelManager(preferred_model="bagel-professional")
 
 
-def analyze_image(image: Image.Image, model_name: str = None, analysis_type: str = "detailed") -> Tuple[str, Dict[str, Any]]:
+def analyze_image(image: Image.Image, model_name: str = None, analysis_type: str = "multiengine") -> Tuple[str, Dict[str, Any]]:
     """
-    Convenience function for image analysis using BAGEL API
+    Enhanced convenience function for professional cinematography analysis
     
     Args:
         image: PIL Image to analyze
-        model_name: Optional model name ("bagel-api" or "fallback")
-        analysis_type: Type of analysis ("detailed" or "flux")
+        model_name: Optional model name ("bagel-professional", "fallback")
+        analysis_type: Type of analysis ("multiengine", "cinematic", "flux")
         
     Returns:
-        Tuple of (description, metadata)
+        Tuple of (description, metadata) with professional cinematography enhancement
     """
     return model_manager.analyze_image(image, model_name, analysis_type)