Update app.py

app.py

@@ -4,105 +4,127 @@ from PIL import Image
 import requests
 import io
 import gc
+import json
 from typing import Tuple, Optional, Dict, Any
 import logging
 from dotenv import load_dotenv
 
-# Configuration du logging
-logging.basicConfig(level=logging.INFO)
+# Configuration du logging détaillé
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
 # Chargement des variables d'environnement
 load_dotenv()
 
+# Styles pour la génération
+ART_STYLES = {
+    "Art Moderne": {
+        "prompt_prefix": "modern art style poster, professional design",
+        "negative_prompt": "traditional, photorealistic, cluttered, busy design"
+    },
+    "Neo Vintage": {
+        "prompt_prefix": "vintage style advertising poster, retro design",
+        "negative_prompt": "modern, digital, contemporary style"
+    },
+    "Pop Art": {
+        "prompt_prefix": "pop art style poster, bold design",
+        "negative_prompt": "subtle, realistic, traditional art"
+    },
+    "Minimaliste": {
+        "prompt_prefix": "minimalist design poster, clean composition",
+        "negative_prompt": "complex, detailed, ornate, busy"
+    }
+}
+
 class ImageGenerator:
-    """Gestionnaire de génération d'images optimisé pour les ressources limitées"""
-    
     def __init__(self):
         self.API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
-        self.headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_TOKEN')}"}
-        
-        # Configurations optimisées pour les ressources limitées
-        self.MAX_IMAGE_SIZE = 768  # Limite la taille maximale pour la mémoire
-        self.MAX_STEPS = 40  # Limite les steps pour optimiser le temps
-        self.DEFAULT_TIMEOUT = 30
-        
-    @staticmethod
-    def get_image_dimensions(format_size: str, orientation: str) -> Tuple[int, int]:
-        """Calcule les dimensions optimisées selon le format"""
-        base_dimensions = {
-            "A4": (768, 1024),
-            "A3": (768, 1024),
-            "A2": (768, 1024),
-            "A1": (768, 1024),
-            "A0": (768, 1024)
-        }
-        width, height = base_dimensions.get(format_size, (768, 768))
-        return (height, width) if orientation == "Paysage" else (width, height)
+        token = os.getenv('HUGGINGFACE_TOKEN')
+        if not token:
+            logger.error("HUGGINGFACE_TOKEN non trouvé dans les variables d'environnement!")
+        self.headers = {"Authorization": f"Bearer {token}"}
+        logger.info("ImageGenerator initialisé")
+
+    def _build_prompt(self, params: Dict[str, Any]) -> str:
+        style_info = ART_STYLES.get(params["style"], ART_STYLES["Neo Vintage"])
+        prompt = f"{style_info['prompt_prefix']}, {params['subject']}"
+        if params.get("title"):
+            prompt += f", with text saying '{params['title']}'"
+        logger.debug(f"Prompt construit: {prompt}")
+        return prompt
+
+    def _get_negative_prompt(self, style: str) -> str:
+        return ART_STYLES.get(style, ART_STYLES["Neo Vintage"])["negative_prompt"]
 
     def generate(self, params: Dict[str, Any]) -> Tuple[Optional[Image.Image], str]:
-        """Génère une image avec gestion optimisée des ressources"""
         try:
-            # Nettoyage mémoire préventif
-            gc.collect()
-            
-            # Préparation des dimensions
-            width, height = self.get_image_dimensions(params["format_size"], params["orientation"])
+            # Log des paramètres
+            logger.info(f"Début de génération avec paramètres: {json.dumps(params, indent=2)}")
             
+            # Vérification du token
+            if 'Bearer None' in self.headers['Authorization']:
+                return None, "⚠️ Erreur: Token Hugging Face non configuré"
+
             # Construction du prompt
             prompt = self._build_prompt(params)
-            
+            logger.debug(f"Prompt final: {prompt}")
+
             # Configuration de la requête
             payload = {
                 "inputs": prompt,
                 "parameters": {
                     "negative_prompt": self._get_negative_prompt(params["style"]),
-                    "num_inference_steps": min(int(35 * (params["quality"]/100)), self.MAX_STEPS),
+                    "num_inference_steps": min(int(35 * (params["quality"]/100)), 40),
                     "guidance_scale": min(7.5 * (params["creativity"]/10), 10.0),
-                    "width": width,
-                    "height": height
+                    "width": 768,
+                    "height": 768 if params["orientation"] == "Portrait" else 512
                 }
             }
             
-            logger.info(f"Génération avec prompt: {prompt}")
-            
-            # Requête API avec gestion d'erreur
+            logger.debug(f"Payload de la requête: {json.dumps(payload, indent=2)}")
+
+            # Requête API
+            logger.info("Envoi de la requête à l'API...")
             response = requests.post(
                 self.API_URL,
                 headers=self.headers,
                 json=payload,
-                timeout=self.DEFAULT_TIMEOUT
+                timeout=30
             )
             
+            logger.debug(f"Statut de la réponse: {response.status_code}")
+            logger.debug(f"Contenu de la réponse: {response.text[:200]}...")  # Premiers 200 caractères
+
             if response.status_code == 200:
                 image = Image.open(io.BytesIO(response.content))
+                logger.info("Image générée avec succès")
                 return image, "✨ Création réussie!"
             else:
-                logger.error(f"Erreur API: {response.status_code} - {response.text}")
-                return None, f"⚠️ Erreur {response.status_code}: Ajustez les paramètres"
-                
+                error_msg = f"⚠️ Erreur API {response.status_code}: {response.text}"
+                logger.error(error_msg)
+                return None, error_msg
+
         except Exception as e:
-            logger.error(f"Erreur de génération: {str(e)}")
-            return None, f"⚠️ Erreur: {str(e)}"
-        finally:
-            gc.collect()  # Nettoyage final
+            error_msg = f"⚠️ Erreur: {str(e)}"
+            logger.exception("Erreur pendant la génération:")
+            return None, error_msg
 
 def create_interface():
-    """Crée l'interface utilisateur Gradio"""
+    """Crée l'interface utilisateur Gradio avec logging"""
+    logger.info("Création de l'interface Gradio")
     
-    # CSS optimisé
     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; }
     """
     
-    # Initialisation du générateur
     generator = ImageGenerator()
     
-    # Interface Gradio optimisée
     with gr.Blocks(css=css) as app:
-        # En-tête
         gr.HTML("""
             <div class="welcome">
                 <h1>🎨 Equity Artisan 3.0</h1>
@@ -110,9 +132,7 @@ def create_interface():
             </div>
         """)
         
-        # Conteneur principal
         with gr.Column(elem_classes="container"):
-            # Groupe Format
             with gr.Group(elem_classes="controls-group"):
                 with gr.Row():
                     format_size = gr.Dropdown(
@@ -126,21 +146,13 @@ def create_interface():
                         label="Orientation"
                     )
             
-            # Groupe Style
             with gr.Group(elem_classes="controls-group"):
-                with gr.Row():
-                    style = gr.Dropdown(
-                        choices=["Art Moderne", "Neo Vintage", "Pop Art", "Minimaliste"],
-                        value="Neo Vintage",
-                        label="Style artistique"
-                    )
-                    text_effect = gr.Dropdown(
-                        choices=["Standard", "Néon", "3D", "Métallique", "Graffiti"],
-                        value="Standard",
-                        label="Effet de texte"
-                    )
+                style = gr.Dropdown(
+                    choices=list(ART_STYLES.keys()),
+                    value="Neo Vintage",
+                    label="Style artistique"
+                )
             
-            # Groupe Contenu
             with gr.Group(elem_classes="controls-group"):
                 subject = gr.Textbox(
                     label="Description",
@@ -151,7 +163,6 @@ def create_interface():
                     placeholder="Titre de l'affiche..."
                 )
             
-            # Groupe Qualité
             with gr.Group(elem_classes="controls-group"):
                 with gr.Row():
                     quality = gr.Slider(
@@ -167,37 +178,35 @@ def create_interface():
                         label="Créativité"
                     )
             
-            # Boutons
             with gr.Row():
                 generate_btn = gr.Button("✨ Générer", variant="primary")
                 clear_btn = gr.Button("🗑️ Effacer", variant="secondary")
             
-            # Sortie
             image_output = gr.Image(label="Aperçu")
             status = gr.Textbox(label="Statut", interactive=False)
         
-        # Événements
         def generate(*args):
+            logger.info("Démarrage d'une nouvelle génération")
             params = {
                 "format_size": args[0],
                 "orientation": args[1],
-                "subject": args[2],
-                "style": args[3],
-                "text_effect": args[4],
-                "title": args[5],
-                "quality": args[6],
-                "creativity": args[7]
+                "style": args[2],
+                "subject": args[3],
+                "title": args[4],
+                "quality": args[5],
+                "creativity": args[6]
             }
-            return generator.generate(params)
+            result = generator.generate(params)
+            logger.info(f"Génération terminée avec statut: {result[1]}")
+            return result
         
         generate_btn.click(
             generate,
             inputs=[
                 format_size,
                 orientation,
-                subject,
                 style,
-                text_effect,
+                subject,
                 title,
                 quality,
                 creativity
@@ -210,8 +219,10 @@ def create_interface():
             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()