Update app.py

app.py

@@ -10,13 +10,16 @@ import logging
 from dotenv import load_dotenv
 
 # Configuration du logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
 # Chargement des variables d'environnement
 load_dotenv()
 
-# Styles artistiques
+# Styles artistiques étendus
 ART_STYLES = {
     "Art Moderne": {
         "prompt_prefix": "modern art style poster, professional design",
@@ -33,85 +36,312 @@ ART_STYLES = {
     "Minimaliste": {
         "prompt_prefix": "minimalist design poster, clean composition",
         "negative_prompt": "complex, detailed, ornate, busy"
+    },
+    "Cyberpunk": {
+        "prompt_prefix": "cyberpunk style poster, neon lights, futuristic design",
+        "negative_prompt": "vintage, natural, rustic, traditional"
+    },
+    "Aquarelle": {
+        "prompt_prefix": "watercolor art style poster, fluid artistic design",
+        "negative_prompt": "digital, sharp, photorealistic"
+    },
+    "Art Déco": {
+        "prompt_prefix": "art deco style poster, geometric patterns, luxury design",
+        "negative_prompt": "modern, minimalist, casual"
+    },
+    "Japonais": {
+        "prompt_prefix": "japanese art style poster, ukiyo-e inspired design",
+        "negative_prompt": "western, modern, photographic"
     }
 }
 
-# Configuration de l'API
-API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
+# Paramètres de composition
+COMPOSITION_PARAMS = {
+    "Layouts": {
+        "Centré": "centered composition, balanced layout",
+        "Asymétrique": "dynamic asymmetrical composition",
+        "Grille": "grid-based layout, structured composition",
+        "Diagonal": "diagonal dynamic composition",
+        "Minimaliste": "minimal composition, lots of whitespace"
+    },
+    "Ambiances": {
+        "Dramatique": "dramatic lighting, high contrast",
+        "Doux": "soft lighting, gentle atmosphere",
+        "Vibrant": "vibrant colors, energetic mood",
+        "Mystérieux": "mysterious atmosphere, moody lighting",
+        "Serein": "peaceful atmosphere, calm mood"
+    },
+    "Palette": {
+        "Monochrome": "monochromatic color scheme",
+        "Contrasté": "high contrast color palette",
+        "Pastel": "soft pastel color palette",
+        "Terre": "earthy color palette",
+        "Néon": "neon color palette"
+    }
+}
 
-def generate_image(params: Dict[str, Any]) -> Tuple[Optional[Image.Image], str]:
-    """Génère une image via l'API Hugging Face"""
-    try:
-        headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_TOKEN')}"}
-        
-        style = ART_STYLES[params["style"]]
-        prompt = f"{style['prompt_prefix']}, {params['subject']}"
-        
-        # Configuration de la requête
-        payload = {
-            "inputs": prompt,
-            "parameters": {
-                "negative_prompt": style["negative_prompt"],
-                "num_inference_steps": 30,
-                "guidance_scale": 7.5,
-                "width": 768,
-                "height": 768
+class ImageGenerator:
+    def __init__(self):
+        self.API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
+        token = os.getenv('HUGGINGFACE_TOKEN')
+        if not token:
+            logger.error("HUGGINGFACE_TOKEN non trouvé!")
+        self.headers = {"Authorization": f"Bearer {token}"}
+        logger.info("ImageGenerator initialisé")
+
+    def _build_prompt(self, params: Dict[str, Any]) -> str:
+        """Construction de prompt améliorée"""
+        style_info = ART_STYLES.get(params["style"], ART_STYLES["Neo Vintage"])
+        prompt = f"{style_info['prompt_prefix']}, {params['subject']}"
+
+        # Ajout des paramètres de composition
+        if params.get("layout"):
+            prompt += f", {COMPOSITION_PARAMS['Layouts'][params['layout']]}"
+        if params.get("ambiance"):
+            prompt += f", {COMPOSITION_PARAMS['Ambiances'][params['ambiance']]}"
+        if params.get("palette"):
+            prompt += f", {COMPOSITION_PARAMS['Palette'][params['palette']]}"
+
+        # Ajout des ajustements fins
+        if params.get("detail_level"):
+            detail_strength = params["detail_level"]
+            prompt += f", {'highly detailed' if detail_strength > 7 else 'moderately detailed'}"
+
+        if params.get("contrast"):
+            contrast_strength = params["contrast"]
+            prompt += f", {'high contrast' if contrast_strength > 7 else 'balanced contrast'}"
+
+        if params.get("saturation"):
+            saturation_strength = params["saturation"]
+            prompt += f", {'vibrant colors' if saturation_strength > 7 else 'subtle colors'}"
+
+        if params.get("title"):
+            prompt += f", with text saying '{params['title']}'"
+
+        logger.debug(f"Prompt final: {prompt}")
+        return prompt
+
+    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)
+            
+            # Configuration de base
+            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
+                }
             }
-        }
-        
-        response = requests.post(API_URL, headers=headers, json=payload)
-        
-        if response.status_code == 200:
-            image = Image.open(io.BytesIO(response.content))
-            return image, "✨ Création réussie!"
-        else:
-            return None, f"⚠️ Erreur {response.status_code}: {response.text}"
             
-    except Exception as e:
-        logger.error(f"Erreur: {str(e)}")
-        return None, f"⚠️ Erreur: {str(e)}"
+            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():
-    """Crée l'interface Gradio"""
-    with gr.Blocks() as app:
+    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("""
-            <h1 style='text-align: center'>🎨 Generart</h1>
-            <p style='text-align: center'>Créez des affiches artistiques avec l'IA</p>
+            <div class="welcome">
+                <h1>🎨 Equity Artisan 3.0</h1>
+                <p>Assistant de création d'affiches professionnelles</p>
+            </div>
         """)
         
-        with gr.Row():
-            with gr.Column():
-                style = gr.Dropdown(
-                    choices=list(ART_STYLES.keys()),
-                    value="Neo Vintage",
-                    label="Style artistique"
-                )
-                
+        with gr.Column(elem_classes="container"):
+            # Format et Orientation
+            with gr.Group(elem_classes="controls-group"):
+                gr.Markdown("### 📐 Format et Orientation")
+                with gr.Row():
+                    format_size = gr.Dropdown(
+                        choices=["A4", "A3", "A2", "A1", "A0"],
+                        value="A4",
+                        label="Format"
+                    )
+                    orientation = gr.Radio(
+                        choices=["Portrait", "Paysage"],
+                        value="Portrait",
+                        label="Orientation"
+                    )
+            
+            # Style et Composition
+            with gr.Group(elem_classes="controls-group"):
+                gr.Markdown("### 🎨 Style et Composition")
+                with gr.Row():
+                    style = gr.Dropdown(
+                        choices=list(ART_STYLES.keys()),
+                        value="Neo Vintage",
+                        label="Style artistique"
+                    )
+                    layout = gr.Dropdown(
+                        choices=list(COMPOSITION_PARAMS["Layouts"].keys()),
+                        value="Centré",
+                        label="Composition"
+                    )
+
+                with gr.Row():
+                    ambiance = gr.Dropdown(
+                        choices=list(COMPOSITION_PARAMS["Ambiances"].keys()),
+                        value="Dramatique",
+                        label="Ambiance"
+                    )
+                    palette = gr.Dropdown(
+                        choices=list(COMPOSITION_PARAMS["Palette"].keys()),
+                        value="Contrasté",
+                        label="Palette"
+                    )
+            
+            # Contenu
+            with gr.Group(elem_classes="controls-group"):
+                gr.Markdown("### 📝 Contenu")
                 subject = gr.Textbox(
                     label="Description",
                     placeholder="Décrivez votre vision..."
                 )
-                
-                generate_btn = gr.Button("✨ Générer")
-                
-            with gr.Column():
-                image_output = gr.Image(label="Résultat")
-                status = gr.Textbox(label="Statut")
+                title = gr.Textbox(
+                    label="Titre",
+                    placeholder="Titre de l'affiche..."
+                )
+            
+            # Ajustements fins
+            with gr.Group(elem_classes="advanced-controls"):
+                gr.Markdown("### 🎯 Ajustements Fins")
+                with gr.Row():
+                    detail_level = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=7,
+                        step=1,
+                        label="Niveau de Détail"
+                    )
+                    contrast = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=5,
+                        step=1,
+                        label="Contraste"
+                    )
+                    saturation = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=5,
+                        step=1,
+                        label="Saturation"
+                    )
+            
+            # Paramètres de génération
+            with gr.Group(elem_classes="controls-group"):
+                with gr.Row():
+                    quality = gr.Slider(
+                        minimum=30,
+                        maximum=50,
+                        value=35,
+                        label="Qualité"
+                    )
+                    creativity = gr.Slider(
+                        minimum=5,
+                        maximum=15,
+                        value=7.5,
+                        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)
         
-        def on_generate(style_val, subject_val):
-            return generate_image({
-                "style": style_val,
-                "subject": subject_val
-            })
+        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]
+            }
+            result = generator.generate(params)
+            logger.info(f"Génération terminée avec statut: {result[1]}")
+            return result
         
         generate_btn.click(
-            fn=on_generate,
-            inputs=[style, subject],
+            generate,
+            inputs=[
+                format_size,
+                orientation,
+                style,
+                layout,
+                ambiance,
+                palette,
+                subject,
+                title,
+                detail_level,
+                contrast,
+                saturation,
+                quality,
+                creativity
+            ],
+            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()