Update app.py

app.py

@@ -1,333 +1,317 @@
 """
-Ultra Supreme Flux Optimizer - Main Gradio Interface
+Ultra Supreme Optimizer - Main optimization engine for image analysis
+VERSIÓN MEJORADA - Usa el prompt completo de CLIP Interrogator
 """
 
-import gradio as gr
-import torch
+# IMPORTANT: spaces must be imported BEFORE torch or any CUDA-using library
+import spaces
 import gc
 import logging
-import warnings
-import os
+import re
+from datetime import datetime
+from typing import Tuple, Dict, Any, Optional
 
-from optimizer import UltraSupremeOptimizer
-from constants import SCORE_GRADES
+import torch
+import numpy as np
+from PIL import Image
+from clip_interrogator import Config, Interrogator
 
-# Configure warnings and environment
-warnings.filterwarnings("ignore", category=FutureWarning)
-warnings.filterwarnings("ignore", category=UserWarning)
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
+from analyzer import UltraSupremeAnalyzer
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Initialize the optimizer globally
-optimizer = UltraSupremeOptimizer()
 
+class UltraSupremeOptimizer:
+    """Main optimizer class for ultra supreme image analysis"""
+    
+    def __init__(self):
+        self.interrogator: Optional[Interrogator] = None
+        self.analyzer = UltraSupremeAnalyzer()
+        self.usage_count = 0
+        self.device = self._get_device()
+        self.is_initialized = False
+
+    @staticmethod
+    def _get_device() -> str:
+        """Determine the best available device for computation"""
+        if torch.cuda.is_available():
+            return "cuda"
+        elif torch.backends.mps.is_available():
+            return "mps"
+        else:
+            return "cpu"
 
-def process_ultra_supreme_analysis(image):
-    """Process image and generate ultra supreme analysis"""
-    try:
-        prompt, info, score, breakdown = optimizer.generate_ultra_supreme_prompt(image)
-        
-        # Find appropriate grade based on score
-        grade_info = None
-        for threshold, grade_data in sorted(SCORE_GRADES.items(), reverse=True):
-            if score >= threshold:
-                grade_info = grade_data
-                break
+    def initialize_model(self) -> bool:
+        """Initialize the CLIP interrogator model"""
+        if self.is_initialized:
+            return True
         
-        if not grade_info:
-            grade_info = SCORE_GRADES[0]  # Default to lowest grade
+        try:
+            config = Config(
+                clip_model_name="ViT-L-14/openai",
+                download_cache=True,
+                chunk_size=2048,
+                quiet=True,
+                device=self.device
+            )
+            
+            self.interrogator = Interrogator(config)
+            self.is_initialized = True
+            
+            # Clean up memory after initialization
+            if self.device == "cpu":
+                gc.collect()
+            else:
+                torch.cuda.empty_cache()
+                
+            return True
+            
+        except Exception as e:
+            logger.error(f"Initialization error: {e}")
+            return False
+
+    def optimize_image(self, image: Any) -> Optional[Image.Image]:
+        """Optimize image for processing"""
+        if image is None:
+            return None
+            
+        try:
+            # Convert to PIL Image if necessary
+            if isinstance(image, np.ndarray):
+                image = Image.fromarray(image)
+            elif not isinstance(image, Image.Image):
+                image = Image.open(image)
             
-        score_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: 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;">Ultra Supreme Intelligence Score</div>
-        </div>
-        '''
+            # Convert to RGB if necessary
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # Resize if too large
+            max_size = 768 if self.device != "cpu" else 512
+            if image.size[0] > max_size or image.size[1] > max_size:
+                image.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
+            
+            return image
+            
+        except Exception as e:
+            logger.error(f"Image optimization error: {e}")
+            return None
+
+    def apply_flux_rules(self, base_prompt: str) -> str:
+        """Aplica las reglas de Flux a un prompt base de CLIP Interrogator"""
+        
+        # Limpiar el prompt de elementos no deseados
+        cleanup_patterns = [
+            r',\s*trending on artstation',
+            r',\s*trending on [^,]+',
+            r',\s*\d+k\s*',
+            r',\s*\d+k resolution',
+            r',\s*artstation',
+            r',\s*concept art',
+            r',\s*digital art',
+            r',\s*by greg rutkowski',  # Remover artistas genéricos overused
+        ]
+        
+        cleaned_prompt = base_prompt
+        for pattern in cleanup_patterns:
+            cleaned_prompt = re.sub(pattern, '', cleaned_prompt, flags=re.IGNORECASE)
+        
+        # Detectar el tipo de imagen para añadir configuración de cámara apropiada
+        camera_config = ""
+        if any(word in base_prompt.lower() for word in ['portrait', 'person', 'man', 'woman', 'face']):
+            camera_config = ", Shot on Hasselblad X2D 100C, 90mm f/2.5 lens at f/2.8, professional portrait photography"
+        elif any(word in base_prompt.lower() for word in ['landscape', 'mountain', 'nature', 'outdoor']):
+            camera_config = ", Shot on Phase One XT, 40mm f/4 lens at f/8, epic landscape photography"
+        elif any(word in base_prompt.lower() for word in ['street', 'urban', 'city']):
+            camera_config = ", Shot on Leica M11, 35mm f/1.4 lens at f/2.8, documentary street photography"
+        else:
+            camera_config = ", Shot on Phase One XF IQ4, 80mm f/2.8 lens at f/4, professional photography"
+        
+        # Añadir mejoras de iluminación si no están presentes
+        if 'lighting' not in cleaned_prompt.lower():
+            if 'dramatic' in cleaned_prompt.lower():
+                cleaned_prompt += ", dramatic cinematic lighting"
+            elif 'portrait' in cleaned_prompt.lower():
+                cleaned_prompt += ", professional studio lighting with subtle rim light"
+            else:
+                cleaned_prompt += ", masterful natural lighting"
+        
+        # Construir el prompt final
+        final_prompt = cleaned_prompt + camera_config
+        
+        # Asegurar que empiece con mayúscula
+        final_prompt = final_prompt[0].upper() + final_prompt[1:] if final_prompt else final_prompt
         
-        return prompt, info, score_html
+        # Limpiar espacios y comas duplicadas
+        final_prompt = re.sub(r'\s+', ' ', final_prompt)
+        final_prompt = re.sub(r',\s*,+', ',', final_prompt)
         
-    except Exception as e:
-        logger.error(f"Ultra supreme wrapper error: {e}")
-        return "❌ Processing failed", f"Error: {str(e)}", '<div style="text-align: center; color: red;">Error</div>'
+        return final_prompt
 
+    @spaces.GPU
+    def generate_ultra_supreme_prompt(self, image: Any) -> Tuple[str, str, int, Dict[str, int]]:
+        """
+        Generate ultra supreme prompt from image usando el pipeline completo
+        
+        Returns:
+            Tuple of (prompt, analysis_info, score, breakdown)
+        """
+        try:
+            # Initialize model if needed
+            if not self.is_initialized:
+                if not self.initialize_model():
+                    return "❌ Model initialization failed.", "Please refresh and try again.", 0, {}
+            
+            # Validate input
+            if image is None:
+                return "❌ Please upload an image.", "No image provided.", 0, {}
+            
+            self.usage_count += 1
+            
+            # Optimize image
+            image = self.optimize_image(image)
+            if image is None:
+                return "❌ Image processing failed.", "Invalid image format.", 0, {}
+            
+            start_time = datetime.now()
+            
+            # NUEVO PIPELINE: Usar CLIP Interrogator completo
+            logger.info("ULTRA SUPREME ANALYSIS - Usando pipeline completo de CLIP Interrogator")
+            
+            # 1. Obtener el prompt COMPLETO de CLIP Interrogator (no solo análisis)
+            # Este incluye descripción + artistas + estilos + mediums
+            full_prompt = self.interrogator.interrogate(image)
+            logger.info(f"Prompt completo de CLIP Interrogator: {full_prompt}")
+            
+            # 2. También obtener los análisis individuales para el reporte
+            clip_fast = self.interrogator.interrogate_fast(image)
+            clip_classic = self.interrogator.interrogate_classic(image)
+            
+            logger.info(f"Análisis Fast: {clip_fast}")
+            logger.info(f"Análisis Classic: {clip_classic}")
+            
+            # 3. Aplicar reglas de Flux al prompt completo
+            optimized_prompt = self.apply_flux_rules(full_prompt)
+            
+            # 4. Crear análisis para el reporte (simplificado)
+            analysis_summary = {
+                "base_prompt": full_prompt,
+                "clip_fast": clip_fast,
+                "clip_classic": clip_classic,
+                "optimized": optimized_prompt,
+                "detected_style": self._detect_style(full_prompt),
+                "detected_subject": self._detect_subject(full_prompt)
+            }
+            
+            # 5. Calcular score basado en la riqueza del prompt
+            score = self._calculate_score(optimized_prompt, full_prompt)
+            breakdown = {
+                "base_quality": min(len(full_prompt) // 10, 25),
+                "technical_enhancement": 25 if "Shot on" in optimized_prompt else 0,
+                "lighting_quality": 25 if "lighting" in optimized_prompt.lower() else 0,
+                "composition": 25 if any(word in optimized_prompt.lower() for word in ["professional", "masterful", "epic"]) else 0
+            }
+            score = sum(breakdown.values())
+            
+            end_time = datetime.now()
+            duration = (end_time - start_time).total_seconds()
+            
+            # Memory cleanup
+            if self.device == "cpu":
+                gc.collect()
+            else:
+                torch.cuda.empty_cache()
+            
+            # Generate analysis report
+            analysis_info = self._generate_analysis_report(
+                analysis_summary, score, breakdown, duration
+            )
+            
+            return optimized_prompt, analysis_info, score, breakdown
+            
+        except Exception as e:
+            logger.error(f"Ultra supreme generation error: {e}")
+            return f"❌ Error: {str(e)}", "Please try with a different image.", 0, {}
 
-def clear_outputs():
-    """Clear all outputs and free memory"""
-    gc.collect()
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-    return "", "", '<div style="text-align: center; padding: 1rem;"><div style="font-size: 2rem; color: #ccc;">--</div><div style="font-size: 0.875rem; color: #999;">Ultra Supreme Score</div></div>'
+    def _detect_style(self, prompt: str) -> str:
+        """Detecta el estilo principal del prompt"""
+        styles = {
+            "portrait": ["portrait", "person", "face", "headshot"],
+            "landscape": ["landscape", "mountain", "nature", "scenery"],
+            "street": ["street", "urban", "city"],
+            "artistic": ["artistic", "abstract", "conceptual"],
+            "dramatic": ["dramatic", "cinematic", "moody"]
+        }
+        
+        for style_name, keywords in styles.items():
+            if any(keyword in prompt.lower() for keyword in keywords):
+                return style_name
+        
+        return "general"
 
+    def _detect_subject(self, prompt: str) -> str:
+        """Detecta el sujeto principal del prompt"""
+        # Tomar las primeras palabras significativas
+        words = prompt.split(',')[0].split()
+        if len(words) > 3:
+            return ' '.join(words[:4])
+        return prompt.split(',')[0]
 
-def create_interface():
-    """Create the Gradio interface"""
-    
-    css = """
-    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800;900&display=swap');
-    
-    .gradio-container {
-        max-width: 1600px !important;
-        margin: 0 auto !important;
-        font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif !important;
-        background: linear-gradient(135deg, #f8fafc 0%, #f1f5f9 100%) !important;
-    }
-    
-    /* FIX CRÍTICO PARA TEXTO BLANCO SOBRE BLANCO */
-    .markdown-text, .markdown-text *, 
-    .prose, .prose *,
-    .gr-markdown, .gr-markdown *,
-    div[class*="markdown"], div[class*="markdown"] * {
-        color: #1f2937 !important;
-    }
-    
-    .markdown-text h1, .markdown-text h2, .markdown-text h3, 
-    .prose h1, .prose h2, .prose h3,
-    .gr-markdown h1, .gr-markdown h2, .gr-markdown h3 {
-        color: #111827 !important;
-        font-weight: 700 !important;
-    }
-    
-    .markdown-text p, .markdown-text li, .markdown-text ul, .markdown-text ol,
-    .prose p, .prose li, .prose ul, .prose ol,
-    .gr-markdown p, .gr-markdown li, .gr-markdown ul, .gr-markdown ol {
-        color: #374151 !important;
-    }
-    
-    .markdown-text strong, .prose strong, .gr-markdown strong {
-        color: #111827 !important;
-        font-weight: 700 !important;
-    }
-    
-    /* Asegurar que las listas sean visibles */
-    ul, ol {
-        color: #374151 !important;
-    }
-    
-    li {
-        color: #374151 !important;
-    }
-    
-    /* Bullets de listas */
-    ul li::marker {
-        color: #374151 !important;
-    }
-    
-    .main-header {
-        text-align: center;
-        padding: 3rem 0 4rem 0;
-        background: linear-gradient(135deg, #0c0a09 0%, #1c1917 30%, #292524 60%, #44403c 100%);
-        color: white;
-        margin: -2rem -2rem 3rem -2rem;
-        border-radius: 0 0 32px 32px;
-        box-shadow: 0 20px 50px -10px rgba(0, 0, 0, 0.25);
-        position: relative;
-        overflow: hidden;
-    }
-    
-    .main-header::before {
-        content: '';
-        position: absolute;
-        top: 0;
-        left: 0;
-        right: 0;
-        bottom: 0;
-        background: linear-gradient(45deg, rgba(59, 130, 246, 0.1) 0%, rgba(147, 51, 234, 0.1) 50%, rgba(236, 72, 153, 0.1) 100%);
-        z-index: 1;
-    }
-    
-    .main-title {
-        font-size: 4rem !important;
-        font-weight: 900 !important;
-        margin: 0 0 1rem 0 !important;
-        letter-spacing: -0.05em !important;
-        background: linear-gradient(135deg, #60a5fa 0%, #3b82f6 25%, #8b5cf6 50%, #a855f7 75%, #ec4899 100%);
-        -webkit-background-clip: text;
-        -webkit-text-fill-color: transparent;
-        background-clip: text;
-        position: relative;
-        z-index: 2;
-    }
-    
-    .subtitle {
-        font-size: 1.5rem !important;
-        font-weight: 500 !important;
-        opacity: 0.95 !important;
-        margin: 0 !important;
-        position: relative;
-        z-index: 2;
-        color: #ffffff !important;
-    }
-    
-    .prompt-output {
-        font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', monospace !important;
-        font-size: 15px !important;
-        line-height: 1.8 !important;
-        background: linear-gradient(135deg, #ffffff 0%, #f8fafc 100%) !important;
-        border: 2px solid #e2e8f0 !important;
-        border-radius: 20px !important;
-        padding: 2.5rem !important;
-        box-shadow: 0 20px 50px -10px rgba(0, 0, 0, 0.1) !important;
-        transition: all 0.3s ease !important;
-        color: #1f2937 !important;
-    }
-    
-    .prompt-output:hover {
-        box-shadow: 0 25px 60px -5px rgba(0, 0, 0, 0.15) !important;
-        transform: translateY(-2px) !important;
-    }
-    
-    /* Fix para el output de información */
-    .gr-textbox label {
-        color: #374151 !important;
-    }
-    
-    /* Fix para footer */
-    footer, .footer, [class*="footer"] {
-        color: #374151 !important;
-    }
-    
-    footer *, .footer *, [class*="footer"] * {
-        color: #374151 !important;
-    }
-    
-    footer a, .footer a, [class*="footer"] a {
-        color: #3b82f6 !important;
-        text-decoration: underline;
-    }
-    
-    footer a:hover, .footer a:hover, [class*="footer"] a:hover {
-        color: #2563eb !important;
-    }
-    
-    /* Botones */
-    .gr-button-primary {
-        background: linear-gradient(135deg, #3b82f6 0%, #2563eb 100%) !important;
-        border: none !important;
-        color: white !important;
-    }
-    
-    .gr-button-primary:hover {
-        background: linear-gradient(135deg, #2563eb 0%, #1d4ed8 100%) !important;
-        transform: translateY(-1px);
-        box-shadow: 0 4px 12px rgba(37, 99, 235, 0.3);
-    }
-    
-    /* Asegurar que TODOS los elementos de texto sean visibles */
-    * {
-        -webkit-text-fill-color: initial !important;
-    }
-    
-    /* Solo el título principal mantiene su gradiente */
-    .main-title {
-        -webkit-text-fill-color: transparent !important;
-    }
-    """
-    
-    with gr.Blocks(
-        theme=gr.themes.Soft(),
-        title="🚀 Ultra Supreme Flux Optimizer",
-        css=css
-    ) as interface:
+    def _calculate_score(self, optimized_prompt: str, base_prompt: str) -> int:
+        """Calcula el score basado en la calidad del prompt"""
+        score = 0
         
-        gr.HTML("""
-        <div class="main-header">
-            <div class="main-title">🚀 ULTRA SUPREME FLUX OPTIMIZER</div>
-            <div class="subtitle">Maximum Absolute Intelligence • Triple CLIP Analysis • Zero Compromise • Research Supremacy</div>
-        </div>
-        """)
+        # Base score por longitud y riqueza
+        score += min(len(base_prompt) // 10, 25)
         
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("## 🧠 Ultra Supreme Analysis Engine")
-                
-                image_input = gr.Image(
-                    label="Upload image for MAXIMUM intelligence analysis",
-                    type="pil",
-                    height=500
-                )
-                
-                analyze_btn = gr.Button(
-                    "🚀 ULTRA SUPREME ANALYSIS",
-                    variant="primary",
-                    size="lg"
-                )
-                
-                gr.Markdown("""
-                ### 🔬 Maximum Absolute Intelligence
-                
-                **🚀 Triple CLIP Interrogation:**
-                • Fast analysis for broad contextual mapping
-                • Classic analysis for detailed feature extraction  
-                • Best analysis for maximum depth intelligence
-                
-                **🧠 Ultra Deep Feature Extraction:**
-                • Micro-age detection with confidence scoring
-                • Cultural/religious context with semantic analysis
-                • Facial micro-features and expression mapping
-                • Emotional state and micro-expression detection
-                • Environmental lighting and atmospheric analysis
-                • Body language and pose interpretation
-                • Technical photography optimization
-                
-                **⚡ Absolute Maximum Intelligence** - No configuration, no limits, no compromise.
-                """)
-            
-            with gr.Column(scale=1):
-                gr.Markdown("## ⚡ Ultra Supreme Result")
-                
-                prompt_output = gr.Textbox(
-                    label="🚀 Ultra Supreme Optimized Flux Prompt",
-                    placeholder="Upload an image to witness absolute maximum intelligence analysis...",
-                    lines=12,
-                    max_lines=20,
-                    elem_classes=["prompt-output"],
-                    show_copy_button=True
-                )
-                
-                score_output = gr.HTML(
-                    value='<div style="text-align: center; padding: 1rem;"><div style="font-size: 2rem; color: #ccc;">--</div><div style="font-size: 0.875rem; color: #999;">Ultra Supreme Score</div></div>'
-                )
-                
-                info_output = gr.Markdown(value="")
-                
-                clear_btn = gr.Button("🗑️ Clear Ultra Analysis", size="sm")
+        # Technical enhancement
+        if "Shot on" in optimized_prompt:
+            score += 25
+        
+        # Lighting quality
+        if "lighting" in optimized_prompt.lower():
+            score += 25
         
-        # Event handlers
-        analyze_btn.click(
-            fn=process_ultra_supreme_analysis,
-            inputs=[image_input],
-            outputs=[prompt_output, info_output, score_output]
-        )
+        # Professional quality
+        if any(word in optimized_prompt.lower() for word in ["professional", "masterful", "epic", "cinematic"]):
+            score += 25
         
-        clear_btn.click(
-            fn=clear_outputs,
-            outputs=[prompt_output, info_output, score_output]
-        )
+        return min(score, 100)
+
+    def _generate_analysis_report(self, analysis: Dict[str, Any], 
+                                  score: int, breakdown: Dict[str, int], 
+                                  duration: float) -> str:
+        """Generate detailed analysis report"""
         
-        gr.Markdown("""
-        ---
-        ### 🏆 Ultra Supreme Research Foundation
+        gpu_status = "⚡ ZeroGPU" if torch.cuda.is_available() else "💻 CPU"
         
-        This system represents the **absolute pinnacle** of image analysis and Flux prompt optimization. Using triple CLIP interrogation, 
-        ultra-deep feature extraction, cultural context awareness, and emotional intelligence mapping, it achieves maximum possible 
-        understanding and applies research-validated Flux rules with supreme intelligence.
+        # Extraer información clave
+        detected_style = analysis.get("detected_style", "general").title()
+        detected_subject = analysis.get("detected_subject", "Unknown")
+        base_prompt_preview = analysis.get("base_prompt", "")[:100] + "..." if len(analysis.get("base_prompt", "")) > 100 else analysis.get("base_prompt", "")
         
-        **🔬 Pariente AI Research Laboratory** • **🚀 Ultra Supreme Intelligence Engine**
-        """)
-    
-    return interface
+        analysis_info = f"""**🚀 ULTRA SUPREME ANALYSIS COMPLETE**
+**Processing:** {gpu_status} • {duration:.1f}s • Full CLIP Interrogator Pipeline  
+**Ultra Score:** {score}/100 • Breakdown: Base({breakdown.get('base_quality',0)}) Technical({breakdown.get('technical_enhancement',0)}) Lighting({breakdown.get('lighting_quality',0)}) Composition({breakdown.get('composition',0)})  
+**Generation:** #{self.usage_count}  
+
+**🧠 INTELLIGENT DETECTION:**
+- **Detected Style:** {detected_style}
+- **Main Subject:** {detected_subject}
+- **Pipeline:** CLIP Interrogator → Flux Optimization → Technical Enhancement
 
+**📊 CLIP INTERROGATOR ANALYSIS:**
+- **Base Prompt:** {base_prompt_preview}
+- **Fast Analysis:** {analysis.get('clip_fast', '')[:80]}...
+- **Classic Analysis:** {analysis.get('clip_classic', '')[:80]}...
 
-# Main execution
-if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        show_error=True
-    )
+**⚡ OPTIMIZATION APPLIED:**
+- ✅ Preserved CLIP Interrogator's rich description
+- ✅ Added professional camera specifications
+- ✅ Enhanced lighting descriptions
+- ✅ Applied Flux-specific optimizations
+- ✅ Removed redundant/generic elements
+
+**🔬 Powered by Pariente AI Research + CLIP Interrogator**"""
+        
+        return analysis_info