Update processor.py

processor.py

@@ -1,6 +1,8 @@
 """
-Main processing logic for FLUX Prompt Optimizer
-Handles image analysis, prompt optimization, and scoring
+Main processing logic for Phramer AI
+By Pariente AI, for MIA TV Series
+
+Enhanced image analysis with professional cinematography integration and multi-engine optimization
 """
 
 import logging
@@ -9,19 +11,20 @@ from typing import Tuple, Dict, Any, Optional
 from PIL import Image
 from datetime import datetime
 
-from config import APP_CONFIG, PROCESSING_CONFIG, get_device_config
+from config import APP_CONFIG, PROCESSING_CONFIG, get_device_config, PROFESSIONAL_PHOTOGRAPHY_CONFIG
 from utils import (
     optimize_image, validate_image, apply_flux_rules, 
     calculate_prompt_score, get_score_grade, format_analysis_report,
-    clean_memory, safe_execute
+    clean_memory, safe_execute, detect_scene_type_from_analysis,
+    enhance_prompt_with_cinematography_knowledge
 )
 from models import analyze_image
 
 logger = logging.getLogger(__name__)
 
 
-class FluxOptimizer:
-    """Main optimizer class for FLUX prompt generation"""
+class PhramerlAIOptimizer:
+    """Main optimizer class for Phramer AI prompt generation with cinematography integration"""
     
     def __init__(self, model_name: str = None):
         self.model_name = model_name
@@ -30,17 +33,20 @@ class FluxOptimizer:
             "total_processed": 0,
             "successful_analyses": 0,
             "failed_analyses": 0,
-            "average_processing_time": 0.0
+            "average_processing_time": 0.0,
+            "cinematography_enhancements": 0,
+            "scene_types_detected": {}
         }
         
-        logger.info(f"FluxOptimizer initialized - Device: {self.device_config['device']}")
+        logger.info(f"Phramer AI Optimizer initialized - Device: {self.device_config['device']}")
     
-    def process_image(self, image: Any) -> Tuple[str, str, str, Dict[str, Any]]:
+    def process_image(self, image: Any, analysis_type: str = "multiengine") -> Tuple[str, str, str, Dict[str, Any]]:
         """
-        Complete image processing pipeline
+        Complete image processing pipeline with cinematography enhancement
         
         Args:
             image: Input image (PIL, numpy array, or file path)
+            analysis_type: Type of analysis ("multiengine", "cinematic", "flux")
             
         Returns:
             Tuple of (optimized_prompt, analysis_report, score_html, metadata)
@@ -49,14 +55,17 @@ class FluxOptimizer:
         metadata = {
             "processing_time": 0.0,
             "success": False,
-            "model_used": self.model_name or "auto",
+            "model_used": self.model_name or "bagel-professional",
             "device": self.device_config["device"],
+            "analysis_type": analysis_type,
+            "cinematography_enhanced": False,
+            "scene_type": "unknown",
             "error": None
         }
         
         try:
             # Step 1: Validate and optimize input image
-            logger.info("Starting image processing pipeline...")
+            logger.info(f"Starting Phramer AI processing pipeline - Analysis type: {analysis_type}")
             
             if not validate_image(image):
                 error_msg = "Invalid or unsupported image format"
@@ -71,36 +80,56 @@ class FluxOptimizer:
             
             logger.info(f"Image optimized to size: {optimized_image.size}")
             
-            # Step 2: Analyze image with selected model
-            logger.info("Running image analysis...")
+            # Step 2: Enhanced image analysis with cinematography context
+            logger.info("Running enhanced BAGEL analysis with cinematography integration...")
             analysis_success, analysis_result = safe_execute(
                 analyze_image, 
                 optimized_image, 
-                self.model_name
+                self.model_name,
+                analysis_type
             )
             
             if not analysis_success:
-                error_msg = f"Image analysis failed: {analysis_result}"
+                error_msg = f"Enhanced image analysis failed: {analysis_result}"
                 logger.error(error_msg)
                 return self._create_error_response(error_msg, metadata)
             
             description, analysis_metadata = analysis_result
-            logger.info(f"Analysis complete: {len(description)} characters")
+            logger.info(f"Enhanced analysis complete: {len(description)} characters")
+            
+            # Step 3: Detect scene type and apply cinematography enhancements
+            scene_type = detect_scene_type_from_analysis(analysis_metadata)
+            metadata["scene_type"] = scene_type
+            
+            # Update scene statistics
+            if scene_type in self.processing_stats["scene_types_detected"]:
+                self.processing_stats["scene_types_detected"][scene_type] += 1
+            else:
+                self.processing_stats["scene_types_detected"][scene_type] = 1
+            
+            logger.info(f"Scene type detected: {scene_type}")
+            
+            # Step 4: Apply enhanced FLUX optimization with cinematography knowledge
+            logger.info("Applying enhanced multi-engine optimization...")
+            optimized_prompt = apply_flux_rules(description, analysis_metadata)
             
-            # Step 3: Apply FLUX optimization rules
-            logger.info("Applying FLUX optimization rules...")
-            optimized_prompt = apply_flux_rules(description)
+            # Step 5: Additional cinematography enhancement if enabled
+            if PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("enable_expert_analysis", True):
+                logger.info("Applying professional cinematography enhancement...")
+                optimized_prompt = enhance_prompt_with_cinematography_knowledge(optimized_prompt, scene_type)
+                metadata["cinematography_enhanced"] = True
+                self.processing_stats["cinematography_enhancements"] += 1
             
             if not optimized_prompt:
-                optimized_prompt = "A professional photograph"
-                logger.warning("Empty prompt after optimization, using fallback")
+                optimized_prompt = "A professional cinematic photograph with technical excellence"
+                logger.warning("Empty prompt after optimization, using cinematography fallback")
             
-            # Step 4: Calculate quality score
-            logger.info("Calculating quality score...")
+            # Step 6: Calculate enhanced quality score
+            logger.info("Calculating professional quality score...")
             score, score_breakdown = calculate_prompt_score(optimized_prompt, analysis_metadata)
             grade_info = get_score_grade(score)
             
-            # Step 5: Generate analysis report
+            # Step 7: Generate comprehensive analysis report
             processing_time = time.time() - start_time
             metadata.update({
                 "processing_time": processing_time,
@@ -108,26 +137,29 @@ class FluxOptimizer:
                 "prompt_length": len(optimized_prompt),
                 "score": score,
                 "grade": grade_info["grade"],
-                "analysis_metadata": analysis_metadata
+                "analysis_metadata": analysis_metadata,
+                "score_breakdown": score_breakdown,
+                "has_camera_suggestion": analysis_metadata.get("has_camera_suggestion", False),
+                "professional_enhancement": analysis_metadata.get("professional_enhancement", False)
             })
             
-            analysis_report = self._generate_detailed_report(
+            analysis_report = self._generate_enhanced_report(
                 optimized_prompt, analysis_metadata, score, 
-                score_breakdown, processing_time
+                score_breakdown, processing_time, scene_type
             )
             
-            # Step 6: Create score HTML
-            score_html = self._generate_score_html(score, grade_info)
+            # Step 8: Create enhanced score HTML
+            score_html = self._generate_enhanced_score_html(score, grade_info, scene_type)
             
             # Update statistics
             self._update_stats(processing_time, True)
             
-            logger.info(f"Processing complete - Score: {score}, Time: {processing_time:.1f}s")
+            logger.info(f"Phramer AI processing complete - Scene: {scene_type}, Score: {score}, Time: {processing_time:.1f}s")
             return optimized_prompt, analysis_report, score_html, metadata
             
         except Exception as e:
             processing_time = time.time() - start_time
-            error_msg = f"Unexpected error in processing pipeline: {str(e)}"
+            error_msg = f"Unexpected error in Phramer AI pipeline: {str(e)}"
             logger.error(error_msg, exc_info=True)
             
             metadata.update({
@@ -142,74 +174,122 @@ class FluxOptimizer:
             # Always clean up memory
             clean_memory()
     
+    def process_for_cinematic(self, image: Any) -> Tuple[str, str, str, Dict[str, Any]]:
+        """Process image specifically for cinematic/MIA TV Series production"""
+        return self.process_image(image, analysis_type="cinematic")
+    
+    def process_for_flux(self, image: Any) -> Tuple[str, str, str, Dict[str, Any]]:
+        """Process image specifically for FLUX generation"""
+        return self.process_image(image, analysis_type="flux")
+    
+    def process_for_multiengine(self, image: Any) -> Tuple[str, str, str, Dict[str, Any]]:
+        """Process image for multi-engine compatibility (Flux, Midjourney, etc.)"""
+        return self.process_image(image, analysis_type="multiengine")
+    
     def _create_error_response(self, error_msg: str, metadata: Dict[str, Any]) -> Tuple[str, str, str, Dict[str, Any]]:
         """Create standardized error response"""
-        error_prompt = "❌ Processing failed"
-        error_report = f"**Error:** {error_msg}\n\nPlease try with a different image or check the logs for more details."
-        error_html = self._generate_score_html(0, get_score_grade(0))
+        error_prompt = "❌ Phramer AI processing failed"
+        error_report = f"""**Error:** {error_msg}
+
+**Troubleshooting:**
+• Verify image format (JPG, PNG, WebP)
+• Check image size (max 1024px)
+• Ensure stable internet connection
+• Try with a different image
+
+**Support:** Contact Pariente AI technical team"""
+        
+        error_html = self._generate_enhanced_score_html(0, get_score_grade(0), "error")
         
         metadata["success"] = False
         metadata["error"] = error_msg
         
         return error_prompt, error_report, error_html, metadata
     
-    def _generate_detailed_report(self, prompt: str, analysis_metadata: Dict[str, Any], 
+    def _generate_enhanced_report(self, prompt: str, analysis_metadata: Dict[str, Any], 
                                 score: int, breakdown: Dict[str, int], 
-                                processing_time: float) -> str:
-        """Generate comprehensive analysis report"""
+                                processing_time: float, scene_type: str) -> str:
+        """Generate comprehensive analysis report with cinematography insights"""
         
         model_used = analysis_metadata.get("model", "Unknown")
         device_used = analysis_metadata.get("device", self.device_config["device"])
         confidence = analysis_metadata.get("confidence", 0.0)
+        has_cinema_context = analysis_metadata.get("cinematography_context_applied", False)
+        camera_setup = analysis_metadata.get("camera_setup", "Not detected")
         
         # Device status emoji
         device_emoji = "⚡" if device_used == "cuda" else "💻"
+        cinema_emoji = "🎬" if has_cinema_context else "📸"
         
-        report = f"""**Analysis Complete**
+        report = f"""**{cinema_emoji} PHRAMER AI ANALYSIS COMPLETE**
 **Processing:** {device_emoji} {device_used.upper()} • {processing_time:.1f}s • Model: {model_used}
-**Score:** {score}/100 • Confidence: {confidence:.0%}
+**Score:** {score}/100 • Scene: {scene_type.replace('_', ' ').title()} • Confidence: {confidence:.0%}
 
-**Score Breakdown:**
-• **Prompt Quality:** {breakdown.get('prompt_quality', 0)}/30 - Content detail and description
-• **Technical Details:** {breakdown.get('technical_details', 0)}/25 - Camera and photography settings
-• **Artistic Value:** {breakdown.get('artistic_value', 0)}/25 - Creative elements  
-• **FLUX Optimization:** {breakdown.get('flux_optimization', 0)}/20 - Platform optimizations
+**🎯 SCORE BREAKDOWN:**
+• **Prompt Quality:** {breakdown.get('prompt_quality', 0)}/25 - Content detail and structure
+• **Technical Details:** {breakdown.get('technical_details', 0)}/25 - Camera and equipment specs
+• **Professional Cinematography:** {breakdown.get('professional_cinematography', 0)}/25 - Cinema expertise applied
+• **Multi-Engine Optimization:** {breakdown.get('multi_engine_optimization', 0)}/25 - Platform compatibility
 
-**Analysis Summary:**
-**Description Length:** {len(prompt)} characters
-**Model Used:** {analysis_metadata.get('model', 'N/A')}
+**🎬 CINEMATOGRAPHY ANALYSIS:**
+**Scene Type:** {scene_type.replace('_', ' ').title()}
+**Camera Setup:** {camera_setup}
+**Professional Context:** {'✅ Applied' if has_cinema_context else '❌ Basic'}
 
-**Applied Optimizations:**
-✅ Camera settings added
-✅ Lighting configuration applied
-✅ Technical parameters optimized
-✅ FLUX rules implemented
-✅ Content cleaned and enhanced
+**⚙️ OPTIMIZATIONS APPLIED:**
+✅ Professional camera configuration
+✅ Cinematography lighting principles
+✅ Technical specifications enhanced
+✅ Multi-engine compatibility (Flux, Midjourney)
+✅ Cinema-quality terminology
+✅ Scene-specific enhancements
 
-**Performance:**
+**📊 PERFORMANCE METRICS:**
 • **Processing Time:** {processing_time:.1f}s
 • **Device:** {device_used.upper()}
 • **Model Confidence:** {confidence:.0%}
+• **Prompt Length:** {len(prompt)} characters
+• **Enhancement Level:** {'Professional' if has_cinema_context else 'Standard'}
 
-**Frame 0 Laboratory for MIA**"""
+**🏆 COMPATIBILITY:**
+• **FLUX:** ✅ Optimized
+• **Midjourney:** ✅ Compatible  
+• **Stable Diffusion:** ✅ Ready
+• **Other Engines:** ✅ Universal format
+
+**Pariente AI • MIA TV Series • 30+ Years Cinema Experience**"""
         
         return report
     
-    def _generate_score_html(self, score: int, grade_info: Dict[str, str]) -> str:
-        """Generate HTML for score display"""
+    def _generate_enhanced_score_html(self, score: int, grade_info: Dict[str, str], scene_type: str) -> str:
+        """Generate enhanced HTML for score display with cinematography context"""
+        
+        # Scene type emoji
+        scene_emojis = {
+            "cinematic": "🎬",
+            "portrait": "👤", 
+            "landscape": "🏔️",
+            "street": "🏙️",
+            "architectural": "🏛️",
+            "commercial": "💼",
+            "error": "❌"
+        }
+        scene_emoji = scene_emojis.get(scene_type, "📸")
         
         html = f'''
         <div style="text-align: center; padding: 2rem; background: linear-gradient(135deg, #f0fdf4 0%, #dcfce7 100%); border: 3px solid {grade_info["color"]}; border-radius: 16px; margin: 1rem 0; box-shadow: 0 8px 25px -5px rgba(0, 0, 0, 0.1);">
+            <div style="font-size: 2.5rem; margin-bottom: 0.5rem;">{scene_emoji}</div>
             <div style="font-size: 3rem; font-weight: 800; color: {grade_info["color"]}; margin: 0; text-shadow: 0 2px 4px rgba(0,0,0,0.1);">{score}</div>
             <div style="font-size: 1.25rem; color: #15803d; margin: 0.5rem 0; text-transform: uppercase; letter-spacing: 0.1em; font-weight: 700;">{grade_info["grade"]}</div>
-            <div style="font-size: 1rem; color: #15803d; margin: 0; text-transform: uppercase; letter-spacing: 0.05em; font-weight: 500;">FLUX Quality Score</div>
+            <div style="font-size: 0.9rem; color: #15803d; margin: 0; text-transform: capitalize; letter-spacing: 0.05em; font-weight: 500;">{scene_type.replace('_', ' ')} Scene</div>
+            <div style="font-size: 0.8rem; color: #15803d; margin: 0.5rem 0 0 0; text-transform: uppercase; letter-spacing: 0.05em; font-weight: 500;">Phramer AI Quality</div>
         </div>
         '''
         
         return html
     
     def _update_stats(self, processing_time: float, success: bool) -> None:
-        """Update processing statistics"""
+        """Update processing statistics with cinematography tracking"""
         self.processing_stats["total_processed"] += 1
         
         if success:
@@ -225,16 +305,19 @@ class FluxOptimizer:
             (current_avg * (total_count - 1) + processing_time) / total_count
         )
     
-    def get_stats(self) -> Dict[str, Any]:
-        """Get current processing statistics"""
+    def get_enhanced_stats(self) -> Dict[str, Any]:
+        """Get enhanced processing statistics with cinematography insights"""
         stats = self.processing_stats.copy()
         
         if stats["total_processed"] > 0:
             stats["success_rate"] = stats["successful_analyses"] / stats["total_processed"]
+            stats["cinematography_enhancement_rate"] = stats["cinematography_enhancements"] / stats["total_processed"]
         else:
             stats["success_rate"] = 0.0
+            stats["cinematography_enhancement_rate"] = 0.0
         
         stats["device_info"] = self.device_config
+        stats["most_common_scene"] = max(stats["scene_types_detected"].items(), key=lambda x: x[1])[0] if stats["scene_types_detected"] else "none"
         
         return stats
     
@@ -244,89 +327,162 @@ class FluxOptimizer:
             "total_processed": 0,
             "successful_analyses": 0,
             "failed_analyses": 0,
-            "average_processing_time": 0.0
+            "average_processing_time": 0.0,
+            "cinematography_enhancements": 0,
+            "scene_types_detected": {}
         }
-        logger.info("Processing statistics reset")
+        logger.info("Phramer AI processing statistics reset")
 
 
-class BatchProcessor:
-    """Handle batch processing of multiple images"""
+class CinematicBatchProcessor:
+    """Handle batch processing for MIA TV Series production"""
     
-    def __init__(self, optimizer: FluxOptimizer):
+    def __init__(self, optimizer: PhramerlAIOptimizer):
         self.optimizer = optimizer
         self.batch_results = []
+        self.batch_stats = {
+            "total_images": 0,
+            "successful_analyses": 0,
+            "scene_type_distribution": {},
+            "average_score": 0.0,
+            "processing_time_total": 0.0
+        }
     
-    def process_batch(self, images: list) -> list:
-        """Process multiple images in batch"""
+    def process_cinematic_batch(self, images: list, analysis_type: str = "cinematic") -> list:
+        """Process multiple images for cinematic production"""
         results = []
+        total_score = 0
+        successful_count = 0
+        
+        logger.info(f"Starting cinematic batch processing: {len(images)} images")
         
         for i, image in enumerate(images):
-            logger.info(f"Processing batch item {i+1}/{len(images)}")
+            logger.info(f"Processing cinematic batch item {i+1}/{len(images)}")
             
             try:
-                result = self.optimizer.process_image(image)
+                if analysis_type == "cinematic":
+                    result = self.optimizer.process_for_cinematic(image)
+                elif analysis_type == "flux":
+                    result = self.optimizer.process_for_flux(image)
+                else:
+                    result = self.optimizer.process_for_multiengine(image)
+                
+                success = result[3]["success"]
+                
+                if success:
+                    score = result[3].get("score", 0)
+                    scene_type = result[3].get("scene_type", "unknown")
+                    
+                    total_score += score
+                    successful_count += 1
+                    
+                    # Update scene distribution
+                    if scene_type in self.batch_stats["scene_type_distribution"]:
+                        self.batch_stats["scene_type_distribution"][scene_type] += 1
+                    else:
+                        self.batch_stats["scene_type_distribution"][scene_type] = 1
+                
                 results.append({
                     "index": i,
-                    "success": result[3]["success"],
-                    "result": result
+                    "success": success,
+                    "result": result,
+                    "scene_type": result[3].get("scene_type", "unknown"),
+                    "score": result[3].get("score", 0)
                 })
                 
             except Exception as e:
-                logger.error(f"Batch item {i} failed: {e}")
+                logger.error(f"Cinematic batch item {i} failed: {e}")
                 results.append({
                     "index": i,
                     "success": False,
-                    "error": str(e)
+                    "error": str(e),
+                    "scene_type": "error",
+                    "score": 0
                 })
         
+        # Update batch statistics
+        self.batch_stats.update({
+            "total_images": len(images),
+            "successful_analyses": successful_count,
+            "average_score": total_score / successful_count if successful_count > 0 else 0.0
+        })
+        
         self.batch_results = results
+        logger.info(f"Cinematic batch processing complete: {successful_count}/{len(images)} successful")
+        
         return results
     
-    def get_batch_summary(self) -> Dict[str, Any]:
-        """Get summary of batch processing results"""
+    def get_cinematic_batch_summary(self) -> Dict[str, Any]:
+        """Get comprehensive summary of cinematic batch processing"""
         if not self.batch_results:
-            return {"total": 0, "successful": 0, "failed": 0}
+            return {"total": 0, "successful": 0, "failed": 0, "average_score": 0.0}
         
         successful = sum(1 for r in self.batch_results if r["success"])
         total = len(self.batch_results)
         
-        return {
+        summary = {
             "total": total,
             "successful": successful,
             "failed": total - successful,
-            "success_rate": successful / total if total > 0 else 0.0
+            "success_rate": successful / total if total > 0 else 0.0,
+            "average_score": self.batch_stats["average_score"],
+            "scene_distribution": self.batch_stats["scene_type_distribution"],
+            "most_common_scene": max(self.batch_stats["scene_type_distribution"].items(), key=lambda x: x[1])[0] if self.batch_stats["scene_type_distribution"] else "none"
         }
+        
+        return summary
 
 
-# Global optimizer instance
-flux_optimizer = FluxOptimizer()
+# Global optimizer instance for Phramer AI
+phramer_optimizer = PhramerlAIOptimizer()
 
 
-def process_image_simple(image: Any, model_name: str = None) -> Tuple[str, str, str]:
+def process_image_simple(image: Any, model_name: str = None, analysis_type: str = "multiengine") -> Tuple[str, str, str]:
     """
-    Simple interface for image processing
+    Simple interface for Phramer AI image processing
     
     Args:
         image: Input image
         model_name: Optional model name
+        analysis_type: Type of analysis ("multiengine", "cinematic", "flux")
         
     Returns:
         Tuple of (prompt, report, score_html)
     """
-    if model_name and model_name != flux_optimizer.model_name:
+    if model_name and model_name != phramer_optimizer.model_name:
         # Create temporary optimizer with specified model
-        temp_optimizer = FluxOptimizer(model_name)
-        prompt, report, score_html, _ = temp_optimizer.process_image(image)
+        temp_optimizer = PhramerlAIOptimizer(model_name)
+        prompt, report, score_html, _ = temp_optimizer.process_image(image, analysis_type)
     else:
-        prompt, report, score_html, _ = flux_optimizer.process_image(image)
+        prompt, report, score_html, _ = phramer_optimizer.process_image(image, analysis_type)
     
     return prompt, report, score_html
 
 
+def process_for_mia_tv_series(image: Any) -> Tuple[str, str, str]:
+    """
+    Specialized processing for MIA TV Series production
+    
+    Args:
+        image: Input image
+        
+    Returns:
+        Tuple of (cinematic_prompt, detailed_report, score_html)
+    """
+    return phramer_optimizer.process_for_cinematic(image)[:3]
+
+
+def get_phramer_stats() -> Dict[str, Any]:
+    """Get comprehensive Phramer AI processing statistics"""
+    return phramer_optimizer.get_enhanced_stats()
+
+
 # Export main components
 __all__ = [
-    "FluxOptimizer",
-    "BatchProcessor", 
-    "flux_optimizer",
-    "process_image_simple"
+    "PhramerlAIOptimizer",
+    "CinematicBatchProcessor", 
+    "phramer_optimizer",
+    "process_image_simple",
+    "process_for_mia_tv_series",
+    "get_phramer_stats"
 ]