Update optimizer.py

optimizer.py

@@ -1,211 +1,333 @@
 """
-Ultra Supreme Optimizer - Main optimization engine for image analysis
+Ultra Supreme Flux Optimizer - Main Gradio Interface
 """
 
-# IMPORTANT: spaces must be imported BEFORE torch or any CUDA-using library
-import spaces
+import gradio as gr
+import torch
 import gc
 import logging
-from datetime import datetime
-from typing import Tuple, Dict, Any, Optional
+import warnings
+import os
 
-import torch
-import numpy as np
-from PIL import Image
-from clip_interrogator import Config, Interrogator
+from optimizer import UltraSupremeOptimizer
+from constants import SCORE_GRADES
 
-from analyzer import UltraSupremeAnalyzer
+# Configure warnings and environment
+warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", category=UserWarning)
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
+# 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 initialize_model(self) -> bool:
-        """Initialize the CLIP interrogator model"""
-        if self.is_initialized:
-            return True
+def process_ultra_supreme_analysis(image):
+    """Process image and generate ultra supreme analysis"""
+    try:
+        prompt, info, score, breakdown = optimizer.generate_ultra_supreme_prompt(image)
         
-        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
+        # 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
+        
+        if not grade_info:
+            grade_info = SCORE_GRADES[0]  # Default to lowest grade
             
-        except Exception as e:
-            logger.error(f"Initialization error: {e}")
-            return False
+        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>
+        '''
+        
+        return prompt, info, score_html
+        
+    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>'
 
-    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)
-            
-            # 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
 
-    @spaces.GPU
-    def generate_ultra_supreme_prompt(self, image: Any) -> Tuple[str, str, int, Dict[str, int]]:
-        """
-        Generate ultra supreme prompt from image
-        
-        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()
-            
-            # ULTRA SUPREME TRIPLE CLIP ANALYSIS
-            logger.info("ULTRA SUPREME ANALYSIS - Maximum intelligence deployment")
-            
-            clip_fast = self.interrogator.interrogate_fast(image)
-            clip_classic = self.interrogator.interrogate_classic(image) 
-            clip_best = self.interrogator.interrogate(image)
-            
-            logger.info(f"ULTRA CLIP Results:\nFast: {clip_fast}\nClassic: {clip_classic}\nBest: {clip_best}")
-            
-            # ULTRA SUPREME ANALYSIS
-            ultra_analysis = self.analyzer.ultra_supreme_analysis(clip_fast, clip_classic, clip_best)
-            
-            # BUILD ULTRA SUPREME FLUX PROMPT
-            optimized_prompt = self.analyzer.build_ultra_supreme_prompt(
-                ultra_analysis, 
-                [clip_fast, clip_classic, clip_best]
-            )
-            
-            # CALCULATE ULTRA SUPREME SCORE
-            score, breakdown = self.analyzer.calculate_ultra_supreme_score(optimized_prompt, ultra_analysis)
-            
-            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(
-                ultra_analysis, clip_fast, clip_classic, clip_best, 
-                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 _generate_analysis_report(self, ultra_analysis: Dict[str, Any], 
-                                  clip_fast: str, clip_classic: str, clip_best: str,
-                                  score: int, breakdown: Dict[str, int], 
-                                  duration: float) -> str:
-        """Generate detailed analysis report"""
+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:
         
-        gpu_status = "⚡ ZeroGPU" if torch.cuda.is_available() else "💻 CPU"
+        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>
+        """)
         
-        # Format detected elements - Fixed the .title() error by checking for None
-        features = ", ".join(ultra_analysis["facial_ultra"]["facial_hair"]) if ultra_analysis["facial_ultra"]["facial_hair"] else "None detected"
-        cultural = ", ".join(ultra_analysis["demographic"]["cultural_religious"]) if ultra_analysis["demographic"]["cultural_religious"] else "None detected"
-        clothing = ", ".join(ultra_analysis["clothing_accessories"]["eyewear"] + ultra_analysis["clothing_accessories"]["headwear"]) if ultra_analysis["clothing_accessories"]["eyewear"] or ultra_analysis["clothing_accessories"]["headwear"] else "None detected"
+        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")
         
-        # Safe access to potentially None values
-        age_category = ultra_analysis["demographic"].get("age_category", "Unspecified")
-        if age_category and age_category != "Unspecified":
-            age_category = age_category.replace("_", " ").title()
+        # Event handlers
+        analyze_btn.click(
+            fn=process_ultra_supreme_analysis,
+            inputs=[image_input],
+            outputs=[prompt_output, info_output, score_output]
+        )
         
-        setting_type = ultra_analysis["environmental"].get("setting_type", "Standard")
-        if setting_type and setting_type != "Standard":
-            setting_type = setting_type.title()
+        clear_btn.click(
+            fn=clear_outputs,
+            outputs=[prompt_output, info_output, score_output]
+        )
         
-        primary_emotion = ultra_analysis["emotional_state"].get("primary_emotion", "Neutral")
-        if primary_emotion and primary_emotion != "Neutral":
-            primary_emotion = primary_emotion.title()
+        gr.Markdown("""
+        ---
+        ### 🏆 Ultra Supreme Research Foundation
         
-        analysis_info = f"""**🚀 ULTRA SUPREME ANALYSIS COMPLETE**
-**Processing:** {gpu_status} • {duration:.1f}s • Triple CLIP Ultra Intelligence  
-**Ultra Score:** {score}/100 • Breakdown: Structure({breakdown.get('structure',0)}) Features({breakdown.get('features',0)}) Cultural({breakdown.get('cultural',0)}) Emotional({breakdown.get('emotional',0)}) Technical({breakdown.get('technical',0)})  
-**Generation:** #{self.usage_count}  
-**🧠 ULTRA DEEP DETECTION:**
-- **Age Category:** {age_category} (Confidence: {ultra_analysis["demographic"].get("age_confidence", 0)})
-- **Cultural Context:** {cultural}  
-- **Facial Features:** {features}
-- **Accessories:** {clothing}
-- **Setting:** {setting_type}
-- **Emotion:** {primary_emotion}
-- **Total Features:** {ultra_analysis["intelligence_metrics"]["total_features_detected"]}
-**📊 CLIP ANALYSIS SOURCES:**
-- **Fast:** {clip_fast[:50]}...
-- **Classic:** {clip_classic[:50]}...  
-- **Best:** {clip_best[:50]}...
-**⚡ ULTRA OPTIMIZATION:** Applied absolute maximum depth analysis with Pariente AI research rules"""
+        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.
         
-        return analysis_info
+        **🔬 Pariente AI Research Laboratory** • **🚀 Ultra Supreme Intelligence Engine**
+        """)
+    
+    return interface
+
+
+# Main execution
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )