Update app.py

app.py

@@ -124,120 +124,97 @@ class ImageGenerator:
         logger.info("ImageGenerator initialisé")
 
     def _build_prompt(self, params: Dict[str, Any]) -> str:
+        """Construction de prompt améliorée avec le PromptEnhancer"""
         try:
+            # Initialisation du PromptEnhancer
             enhancer = PromptEnhancer()
+
+            # Récupération du style
             style_info = ART_STYLES.get(params["style"], ART_STYLES["Art Moderne"])
-            
-            # Détection du type de contenu
-            content_type = self._detect_content_type(params["subject"])
-            
-            # Adaptation du style selon le contenu
-            style_adjustments = {
-                "anime_manga": {
-                    "prompt_prefix": "high quality anime artwork, detailed anime illustration, studio anime quality, professional anime art",
-                    "negative_prompt": "low quality, simple, poorly drawn, blurry"
-                },
-                "art_digital": {
-                    "prompt_prefix": "professional digital artwork, detailed digital illustration, modern digital art",
-                    "negative_prompt": "traditional art, poor quality, amateur"
-                },
-                "art_traditionnel": {
-                    "prompt_prefix": "traditional art masterpiece, fine art painting, artistic technique, professional artwork",
-                    "negative_prompt": "digital art, 3d render, poor quality"
-                },
-                "photo_realiste": {
-                    "prompt_prefix": "ultra realistic photograph, professional photography, high end photo, studio quality",
-                    "negative_prompt": "drawing, painting, artificial, digital art"
-                },
-                "graphisme": {
-                    "prompt_prefix": "professional graphic design, clean modern design, commercial quality artwork",
-                    "negative_prompt": "amateur, messy, unrefined"
-                },
-                "fantastique": {
-                    "prompt_prefix": "fantasy art masterpiece, mythical artwork, magical atmosphere, epic fantasy illustration",
-                    "negative_prompt": "realistic, mundane, ordinary"
-                },
-                "sci_fi": {
-                    "prompt_prefix": "futuristic sci-fi artwork, high tech aesthetic, advanced technology, science fiction art",
-                    "negative_prompt": "vintage, retro, traditional"
-                },
-                "art_abstrait": {
-                    "prompt_prefix": "abstract art composition, non-representational artwork, artistic expression",
-                    "negative_prompt": "realistic, figurative, literal"
-                },
-                "art_pop": {
-                    "prompt_prefix": "pop art style, bold colors, graphic art, contemporary pop culture",
-                    "negative_prompt": "classical, traditional, subtle"
-                },
-                "art_conceptuel": {
-                    "prompt_prefix": "concept art, professional design, detailed visualization, production quality",
-                    "negative_prompt": "amateur, unrefined, sketch"
-                }
-            }
 
-            # Ajustement du style en fonction du contenu détecté
-            if content_type in style_adjustments:
-                style_info = style_adjustments[content_type]
-            
-            # Construction du contexte
+            # Construction du contexte de style
             style_context = {
                 "prompt_prefix": style_info['prompt_prefix'],
                 "layout": COMPOSITION_PARAMS['Layouts'][params['layout']],
                 "ambiance": COMPOSITION_PARAMS['Ambiances'][params['ambiance']],
                 "palette": COMPOSITION_PARAMS['Palette'][params['palette']]
             }
-            
+
+            # Préparation du prompt initial
             base_prompt = f"{params['subject']}"
             if params.get('title'):
                 base_prompt += f", with text '{params['title']}'"
 
+            # Amélioration du prompt
             enhanced_prompt = enhancer.enhance_prompt(base_prompt, style_context)
+
+            # Analyse de l'efficacité du prompt
+            prompt_analysis = enhancer.analyze_prompt_effectiveness(enhanced_prompt)
+            logger.debug(f"Analyse du prompt: {json.dumps(prompt_analysis, indent=2)}")
+
             return enhanced_prompt
 
         except Exception as e:
             logger.error(f"Erreur dans la construction du prompt: {str(e)}")
+            # Fallback sur le prompt basique en cas d'erreur
             return f"{style_info['prompt_prefix']}, {params['subject']}"
 
-    def _detect_content_type(self, subject: str) -> str:
-        """Détecte le type de contenu demandé pour adapter le style"""
-        content_types = {
-            "anime_manga": ["manga", "anime", "dragon ball", "naruto", "one piece", "pokemon"],
-            "art_digital": ["pixel art", "digital", "vectoriel", "3d", "game art"],
-            "art_traditionnel": ["peinture", "aquarelle", "huile", "acrylique", "dessin"],
-            "photo_realiste": ["photo", "portrait", "paysage", "architecture", "produit"],
-            "graphisme": ["logo", "affiche", "flyer", "branding", "typographie"],
-            "fantastique": ["fantasy", "dragon", "magie", "heroic fantasy", "mythologie"],
-            "sci_fi": ["science fiction", "futuriste", "cyberpunk", "space", "robot"],
-            "art_abstrait": ["abstrait", "géométrique", "non-figuratif", "minimaliste"],
-            "art_pop": ["pop art", "comics", "bande dessinée", "cartoon", "graffiti"],
-            "art_conceptuel": ["concept art", "character design", "environment design", "matte painting"]
-        }
-
-        subject_lower = subject.lower()
-        detected_types = []
-        
-        for content_type, keywords in content_types.items():
-            if any(keyword in subject_lower for keyword in keywords):
-                detected_types.append(content_type)
-        
-        if len(detected_types) > 1:
-            if "photo_realiste" in detected_types and any(t in detected_types for t in ["art_digital", "anime_manga"]):
-                return "photo_realiste"
-        
-        return detected_types[0] if detected_types else "general"
+    def generate(self, params: Dict[str, Any]) -> Tuple[Optional[Image.Image], str]:
+        try:
+            logger.info(f"Début de génération avec paramètres: {json.dumps(params, indent=2)}")
+
+            if 'Bearer None' in self.headers['Authorization']:
+                return None, "⚠️ Erreur: Token Hugging Face non configuré"
+
+            prompt = self._build_prompt(params)
+
+            payload = {
+                "inputs": prompt,
+                "parameters": {
+                    "negative_prompt": ART_STYLES[params["style"]]["negative_prompt"],
+                    "num_inference_steps": min(int(35 * (params["quality"]/100)), 40),
+                    "guidance_scale": min(7.5 * (params["creativity"]/10), 10.0),
+                    "width": 768,
+                    "height": 768 if params["orientation"] == "Portrait" else 512
+                }
+            }
+
+            logger.debug(f"Payload: {json.dumps(payload, indent=2)}")
+
+            response = requests.post(
+                self.API_URL,
+                headers=self.headers,
+                json=payload,
+                timeout=30
+            )
+
+            if response.status_code == 200:
+                image = Image.open(io.BytesIO(response.content))
+                return image, "✨ Création réussie!"
+            else:
+                error_msg = f"⚠️ Erreur API {response.status_code}: {response.text}"
+                logger.error(error_msg)
+                return None, error_msg
+
+        except Exception as e:
+            error_msg = f"⚠️ Erreur: {str(e)}"
+            logger.exception("Erreur pendant la génération:")
+            return None, error_msg
+        finally:
+            gc.collect()
 
 def create_interface():
     logger.info("Création de l'interface Gradio")
-    
+
     css = """
     .container { max-width: 1200px; margin: auto; }
     .welcome { text-align: center; margin: 20px 0; padding: 20px; background: #1e293b; border-radius: 10px; }
     .controls-group { background: #2d3748; padding: 15px; border-radius: 5px; margin: 10px 0; }
     .advanced-controls { background: #374151; padding: 12px; border-radius: 5px; margin: 8px 0; }
     """
-    
+
     generator = ImageGenerator()
-    
+
     with gr.Blocks(css=css) as app:
         gr.HTML("""
             <div class="welcome">
@@ -245,7 +222,7 @@ def create_interface():
                 <p>Assistant de création d'affiches professionnelles</p>
             </div>
         """)
-        
+
         with gr.Column(elem_classes="container"):
             # Zone d'introduction et guide
             gr.Markdown("""
@@ -272,7 +249,7 @@ def create_interface():
                         label="Orientation",
                         info="Portrait (vertical) ou Paysage (horizontal)"
                     )
-            
+
             with gr.Group(elem_classes="controls-group"):
                 gr.Markdown("### 🎨 Style et Composition")
                 with gr.Row():
@@ -302,7 +279,7 @@ def create_interface():
                         label="Palette",
                         info="Les types de couleurs utilisées"
                     )
-            
+
             with gr.Group(elem_classes="controls-group"):
                 gr.Markdown("""### 📝 Contenu
                 *Conseils pour la description : soyez précis sur ce que vous souhaitez voir dans l'affiche*""")
@@ -316,7 +293,7 @@ def create_interface():
                     placeholder="Le titre qui apparaîtra sur l'affiche...",
                     info="Laissez vide si vous ne voulez pas de titre sur l'affiche"
                 )
-            
+
             with gr.Group(elem_classes="advanced-controls"):
                 gr.Markdown("""### 🎯 Ajustements Fins
                 *Ces paramètres permettent d'affiner le résultat final*""")
@@ -345,7 +322,7 @@ def create_interface():
                         label="Saturation",
                         info="Contrôle la vivacité des couleurs"
                     )
-            
+
             with gr.Group(elem_classes="controls-group"):
                 gr.Markdown("### ⚙️ Paramètres de Génération")
                 with gr.Row():
@@ -363,77 +340,35 @@ def create_interface():
                         label="Créativité",
                         info="Plus la valeur est élevée, plus l'IA prendra de libertés créatives"
                     )
-            
+
             with gr.Row():
                 generate_btn = gr.Button("✨ Générer", variant="primary")
                 clear_btn = gr.Button("🗑️ Effacer", variant="secondary")
-            
+
             image_output = gr.Image(label="Aperçu")
             status = gr.Textbox(label="Statut", interactive=False)
-        
-        def generate(self, params: Dict[str, Any]) -> Tuple[Optional[Image.Image], str]:
-        try:
-            logger.info(f"Début de génération avec paramètres: {json.dumps(params, indent=2)}")
-            
-            if 'Bearer None' in self.headers['Authorization']:
-                logger.error("Token Hugging Face manquant ou invalide")
-                return None, "⚠️ Erreur: Token Hugging Face non configuré"
 
-            prompt = self._build_prompt(params)
-            logger.info(f"Prompt généré: {prompt}")
-            
-            content_type = self._detect_content_type(params["subject"])
-            logger.info(f"Type de contenu détecté: {content_type}")
-
-            payload = {
-                "inputs": prompt,
-                "parameters": {
-                    "negative_prompt": ART_STYLES[params["style"]]["negative_prompt"],
-                    "num_inference_steps": min(int(35 * (params["quality"]/100)), 40),
-                    "guidance_scale": min(7.5 * (params["creativity"]/10), 10.0),
-                    "width": 768,
-                    "height": 768 if params["orientation"] == "Portrait" else 512
-                }
+        def generate(*args):
+            logger.info("Démarrage d'une nouvelle génération")
+            params = {
+                "format_size": args[0],
+                "orientation": args[1],
+                "style": args[2],
+                "layout": args[3],
+                "ambiance": args[4],
+                "palette": args[5],
+                "subject": args[6],
+                "title": args[7],
+                "detail_level": args[8],
+                "contrast": args[9],
+                "saturation": args[10],
+                "quality": args[11],
+                "creativity": args[12]
             }
-            
-            logger.debug(f"Payload pour l'API: {json.dumps(payload, indent=2)}")
-
-            try:
-                response = requests.post(
-                    self.API_URL,
-                    headers=self.headers,
-                    json=payload,
-                    timeout=30
-                )
-                
-                logger.info(f"Statut de la réponse API: {response.status_code}")
-                if response.status_code != 200:
-                    logger.error(f"Contenu de la réponse en erreur: {response.text}")
-                
-                if response.status_code == 200:
-                    image = Image.open(io.BytesIO(response.content))
-                    return image, "✨ Création réussie!"
-                else:
-                    error_msg = f"⚠️ Erreur API {response.status_code}: {response.text}"
-                    logger.error(error_msg)
-                    return None, error_msg
-
-            except requests.exceptions.Timeout:
-                error_msg = "⚠️ Erreur: Le serveur met trop de temps à répondre"
-                logger.error(error_msg)
-                return None, error_msg
-            except requests.exceptions.RequestException as e:
-                error_msg = f"⚠️ Erreur de connexion: {str(e)}"
-                logger.error(error_msg)
-                return None, error_msg
+            result = generator.generate(params)
+            logger.info(f"Génération terminée avec statut: {result[1]}")
+            return result
 
-        except Exception as e:
-            error_msg = f"⚠️ Erreur inattendue: {str(e)}"
-            logger.exception("Erreur détaillée pendant la génération:")
-            return None, error_msg
-        finally:
-            gc.collect()
-        
         generate_btn.click(
             generate,
             inputs=[
@@ -453,16 +388,16 @@ def create_interface():
             ],
             outputs=[image_output, status]
         )
-        
+
         clear_btn.click(
             lambda: (None, "🗑️ Image effacée"),
             outputs=[image_output, status]
         )
-    
+
     logger.info("Interface créée avec succès")
     return app
 
 if __name__ == "__main__":
     app = create_interface()
     logger.info("Démarrage de l'application")
-    app.launch()
+    app.launch()