app.py

import gradio as gr
import os
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.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Chargement des variables d'environnement
load_dotenv()

# Styles artistiques étendus
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"
    },
    "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"
    },
    "Ultra Réaliste": {
        "prompt_prefix": "hyper-realistic poster, photographic quality, extremely detailed",
        "negative_prompt": "cartoon, illustration, stylized, abstract"
    },
    "Bande Dessinée": {
        "prompt_prefix": "comic book style poster, vibrant colors, bold outlines",
        "negative_prompt": "realistic, photographic, subtle colors"
    }
}

# Paramètres de composition étendus
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 with lots of whitespace'",
        # Nouvelles options ajoutées
        'Radial': "'radial' composition with circular arrangement",
        'En Z': "'Z-shaped' composition guiding the viewer's eye",
        'Règle des tiers': "'rule of thirds' composition for balance",
        'Symétrie': "'symmetrical' composition for mirror-like balance",
        'Cadre dans le cadre': "'frame within a frame' composition"
    },
    'Ambiances': {
        # Options existantes
        'Dramatique': "'dramatic' lighting with high contrast",
        'Doux': "'soft' lighting creating a gentle atmosphere",
        # Nouvelles options ajoutées
        'Vibrant': "'vibrant' colors creating an energetic mood",
        'Mystérieux': "'mysterious' atmosphere with moody lighting",
        # Nouvelles ambiances ajoutées
        'Serein': "'peaceful' atmosphere for calmness",
        'Rétro': "'retro' atmosphere evoking nostalgia",
        'Futuriste': "'futuristic' atmosphere with a high-tech feel",
        'Onirique': "'dreamy' atmosphere for surreal effects",
        'Industriel': "'industrial' atmosphere with raw urban vibes",
        'Naturel': "'natural' atmosphere with organic elements"
    },
    'Palette': {
       # Options existantes
       'Monochrome': 'monochromatic color scheme',
       'Contrasté': 'high contrast color palette',
       # Nouvelles options ajoutées
       'Pastel': 'soft pastel color palette',
       'Terre': 'earthy color palette',
       # Nouvelles palettes ajoutées
       'Néon': 'neon color palette',
       'Complémentaire': 'complementary color scheme',
       'Analogique': 'analogous color scheme',
       'Triadique': 'triadic color scheme',
       'Tétradique': 'tetradic color scheme',
       'Tons rompus': 'muted tones color palette'
   }
}

class ImageGenerator:
    def __init__(self):
        self.API_URL = (
            f"https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
            )
        
        # Chargement du token Hugging Face depuis les variables d'environnement
        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)}")
             
             if 'Bearer None' in self.headers['Authorization']:
                 return None,"⚠️ Erreur: Token Hugging Face non configuré"

             prompt = self._build_prompt(params)
             
             payload = {
                 # Construction de la requête pour l'API Hugging Face
                 “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)}")
             
             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: #3498db; border-radius: 10px; color: white; }
     .controls-group { background: #ecf0f1; padding: 15px; border-radius: 5px; margin: 10px 0; color: #2c3e50; }
     .advanced-controls { background: #bdc3c7; padding: 12px; border-radius: 5px; margin: 8px 0; }
     .gradio-slider input[type="range"] { accent-color: #3498db; }
     .gradio-button { transition: all 0.3s ease; }
     .gradio-button:hover { transform: translateY(-2px); box-shadow: 0 4px 6px rgba(52, 152, 219, 0.11), 
                           0 1px 3px rgba(0 ,0 ,0 ,0.08); }
     """

     generator = ImageGenerator()

     with gr.Blocks(css=css) as app:
         gr.HTML("""
         <div class="welcome">
             <h1>🎨 Equity Artisan 4.0</h1>
             <p>Assistant de création d'affiches professionnelles avancé</p>
         </div>
         """)

         with gr.Column(elem_classes="container"):
             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")

             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")

             with gr.Group(elem_classes="controls-group"):
                 gr.Markdown("### 📝 Contenu")
                 subject = gr.Textbox(label="Description", placeholder="Décrivez votre vision...")
                 title = gr.Textbox(label="Titre", placeholder="Titre de l'affiche...")

             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")

             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é")

             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(*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(
             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()