import gradio as gr from openai import OpenAI import openai # Import top-level for error types from pydantic import BaseModel, Field import os import requests from PIL import Image import tempfile import io # For BytesIO # import numpy as np # Not strictly needed if using PIL import markdown # Required by gr.Markdown implicitly import base64 import datetime import json import re # For cleaning JSON from dotenv import load_dotenv # --- Configuration Initiale --- load_dotenv() # Charge les variables depuis un fichier .env s'il existe # Clé OpenRouter (obligatoire pour le fonctionnement de base) openrouter_api_key = os.getenv("OPENROUTER_API_KEY") OPENROUTER_TEXT_MODEL = "google/gemini-pro-1.5" # Modèle OpenRouter par défaut # OPENROUTER_TEXT_MODEL = "google/gemini-flash-1.5" # Alternative plus rapide # Modèles OpenAI (utilisés si clé fournie) OPENAI_TEXT_MODEL = "gpt-4o-mini" # ou "gpt-4o" OPENAI_IMAGE_MODEL = "dall-e-3" # --- Modèles Pydantic (Inchangé) --- class BiasInfo(BaseModel): bias_type: str = Field(..., description="Type de biais identifié (ex: Stéréotype de genre, Biais de confirmation)") explanation: str = Field(..., description="Explication de pourquoi cela pourrait être un biais dans ce contexte.") advice: str = Field(..., description="Conseil spécifique pour atténuer ce biais.") class BiasAnalysisResponse(BaseModel): detected_biases: list[BiasInfo] = Field(default_factory=list, description="Liste des biais potentiels détectés.") overall_comment: str = Field(default="", description="Commentaire général ou indication si aucun biais majeur n'est détecté.") # --- Fonctions Utilitaires (Mises à jour) --- # Dictionnaires de correspondance (Inchangés) posture_mapping = {"": "","Debout": "standing up","Assis": "sitting","Allongé": "lying down","Accroupi": "crouching","En mouvement": "moving","Reposé": "resting"} facial_expression_mapping = {"": "","Souriant": "smiling","Sérieux": "serious","Triste": "sad","En colère": "angry","Surpris": "surprised","Pensif": "thoughtful"} skin_color_mapping = {"": "","Clair": "light","Moyen": "medium","Foncé": "dark","Très foncé": "very dark"} eye_color_mapping = {"": "","Bleu": "blue","Vert": "green","Marron": "brown","Gris": "gray"} hair_style_mapping = {"": "","Court": "short","Long": "long","Bouclé": "curly","Rasé": "shaved","Chauve": "bald","Tresses": "braided","Queue de cheval": "ponytail","Coiffure afro": "afro","Dégradé": "fade"} hair_color_mapping = {"": "","Blond": "blonde","Brun": "brown","Noir": "black","Roux": "red","Gris": "gray","Blanc": "white"} clothing_style_mapping = {"": "","Décontracté": "casual","Professionnel": "professional","Sportif": "sporty"} accessories_mapping = {"": "","Lunettes": "glasses","Montre": "watch","Chapeau": "hat"} # Fonction de mise à jour du journal (Limitée et formatée) MAX_LOG_LINES = 150 def update_log(event_description, session_log_state): """Ajoute une entrée au log et le retourne, en limitant sa taille.""" timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") new_log_entry = f"[{timestamp}] {event_description}" current_log = session_log_state if session_log_state else "" # Limiter la taille du log log_lines = current_log.splitlines() # Garde les N dernières lignes if len(log_lines) >= MAX_LOG_LINES: current_log = "\n".join(log_lines[-(MAX_LOG_LINES-1):]) updated_log = current_log + "\n" + new_log_entry if current_log else new_log_entry return updated_log.strip() # Retourne le log mis à jour def clean_json_response(raw_response): """Tente d'extraire un bloc JSON valide d'une réponse LLM potentiellement bruitée.""" # Recherche d'un bloc JSON marqué par ```json ... ``` match = re.search(r"```json\s*({.*?})\s*```", raw_response, re.DOTALL | re.IGNORECASE) if match: return match.group(1) # Recherche d'un objet JSON commençant par { et finissant par } match = re.search(r"({.*?})", raw_response, re.DOTALL) if match: # Essayer de parser pour vérifier si c'est valide try: json.loads(match.group(1)) return match.group(1) except json.JSONDecodeError: pass # Si ça échoue, on continue # Si rien ne fonctionne, retourne la réponse brute en espérant qu'elle soit déjà du JSON return raw_response.strip() # --- Fonctions Principales de l'Application (Mises à jour) --- def analyze_biases_v2(app_config, objective_text, session_log_state): """Analyse les biais dans l'objectif marketing (utilise le client API actif).""" log = session_log_state log = update_log(f"Analyse Biais Objectif (début): '{objective_text[:50]}...'", log) if not objective_text: return BiasAnalysisResponse(overall_comment="Veuillez fournir un objectif marketing.").dict(), update_log("Analyse Biais: Objectif vide.", log) if not app_config.get("client"): return BiasAnalysisResponse(overall_comment="Erreur: Client API non configuré.").dict(), update_log("ERREUR Analyse Biais: Client non configuré.", log) active_client = app_config["client"] model_name = app_config["text_model"] # Prompt système V2 (Inchangé) system_prompt = f""" Tu es un expert en marketing éthique et en psychologie cognitive, spécialisé dans la création de personas. Analyse l'objectif marketing suivant : "{objective_text}" Identifie les BIAIS COGNITIFS POTENTIELS ou RISQUES DE STÉRÉOTYPES pertinents pour la création de personas. Concentre-toi sur : 1. **Stéréotypes / Généralisations Hâtives :** Suppose-t-on des traits basés sur le genre, l'âge, l'ethnie, le statut socio-économique sans justification ? (Ex: 'tous les jeunes urbains sont écolos') 2. **Biais de Confirmation / Affinité :** L'objectif semble-t-il chercher à valider une idée préconçue ou refléter trop les opinions du concepteur ? (Ex: 'prouver que notre produit est parfait pour CE type de personne') 3. **Simplification Excessive / Manque de Nuance :** Le groupe cible est-il décrit de manière trop monolithique, ignorant la diversité interne ? (Ex: 'les seniors actifs' sans différencier leurs motivations ou capacités) 4. **Autres biais pertinents** (Ex: Oubli de fréquence de base, Biais de normalité si applicable). Pour chaque biais potentiel identifié : - Nomme le type de biais (ex: Stéréotype d'âge). - Explique brièvement POURQUOI c'est un risque DANS CE CONTEXTE de création de persona. - Propose un CONSEIL PRÉCIS pour nuancer l'objectif ou être vigilant lors de la création. Structure ta réponse en utilisant le format JSON suivant (avec la classe Pydantic BiasAnalysisResponse): {{ "detected_biases": [ {{ "bias_type": "Type de biais identifié", "explanation": "Explication contextuelle du risque.", "advice": "Conseil spécifique d'atténuation." }} ], "overall_comment": "Bref commentaire général. Indique si aucun biais majeur n'est détecté." }} Réponds en français. S'il n'y a pas de biais clair, retourne une liste 'detected_biases' vide et indique-le dans 'overall_comment'. """ response_content_str = "" # Init pour le bloc except try: completion = active_client.chat.completions.create( model=model_name, messages=[ # Note: Certains modèles préfèrent l'objectif dans le message user, d'autres intégré au system prompt. # Ici, on le met dans le system_prompt. {"role": "user", "content": system_prompt} ], temperature=0.4, max_tokens=800, # Demander explicitement du JSON si le modèle le supporte bien (OpenAI et certains OpenRouter le font) response_format={"type": "json_object"}, ) response_content_str = completion.choices[0].message.content # Nettoyage de la réponse avant parsing cleaned_response_str = clean_json_response(response_content_str) # Essayer de parser la réponse JSON nettoyée parsed_response = BiasAnalysisResponse.parse_raw(cleaned_response_str) log = update_log(f"Analyse Biais Objectif (fin): Biais trouvés - {len(parsed_response.detected_biases)}", log) return parsed_response.dict(), log except openai.AuthenticationError as e: error_msg = f"Erreur d'authentification API ({app_config.get('api_source', 'Inconnu')}). Vérifiez votre clé." print(error_msg) log = update_log(f"ERREUR API Auth: {error_msg}", log) return BiasAnalysisResponse(overall_comment=error_msg).dict(), log except openai.RateLimitError as e: error_msg = f"Erreur API ({app_config.get('api_source', 'Inconnu')}): Limite de taux atteinte. Réessayez plus tard." print(error_msg) log = update_log(f"ERREUR API RateLimit: {error_msg}", log) return BiasAnalysisResponse(overall_comment=error_msg).dict(), log except Exception as e: error_msg = f"Erreur pendant l'analyse des biais: {str(e)}. Réponse brute: '{response_content_str[:200]}...'" print(error_msg) log = update_log(f"ERREUR Analyse Biais: {str(e)}", log) # Essayer de retourner une structure d'erreur compatible return BiasAnalysisResponse(overall_comment=f"Erreur technique lors de l'analyse: {str(e)}").dict(), log def display_bias_analysis_v2(analysis_result): """Formate l'analyse des biais pour l'affichage avec HighlightedText.""" # Prend directement le dict retourné par analyze_biases_v2 if not analysis_result: return [("Aucune analyse effectuée.", None)], {} # Retourne format HighlightedText et dict vide biases = analysis_result.get("detected_biases", []) overall_comment = analysis_result.get("overall_comment", "") highlighted_data = [] if "Erreur" in overall_comment: highlighted_data.append((overall_comment, "ERROR")) # Étiquette spécifique pour erreurs elif not biases: highlighted_data.append((overall_comment or "Aucun biais majeur détecté.", "INFO")) else: if overall_comment: highlighted_data.append((overall_comment + "\n\n", "COMMENT")) for bias_info in biases: highlighted_data.append((f"⚠️ {bias_info.get('bias_type', 'Type inconnu')}: ", "BIAS_TYPE")) highlighted_data.append((f"{bias_info.get('explanation', 'Pas d’explication.')}\n", "EXPLANATION")) highlighted_data.append((f"💡 Conseil: {bias_info.get('advice', 'Pas de conseil.')}\n", "ADVICE")) # Retourne les données formatées et le résultat brut (qui est déjà un dict) # Le second output (bias_analysis_result_state) est mis à jour par la fonction appelante si nécessaire return highlighted_data def generate_persona_image_v2(app_config, *args): """Génère l'image du persona en utilisant OpenAI si activé, sinon retourne None.""" # Les 13 premiers args sont les inputs de l'image, le dernier est session_log_state inputs = args[:-1] session_log_state = args[-1] log = session_log_state (first_name, last_name, age, gender, persona_description_en, # Renommé pour clarté skin_color, eye_color, hair_style, hair_color, facial_expression, posture, clothing_style, accessories) = inputs # Vérifier si la génération d'image est activée (nécessite clé OpenAI valide) if not app_config.get("image_generation_enabled", False): log = update_log("Génération Image: Désactivée (Clé API OpenAI non fournie/valide).", log) # Retourne None pour l'image et le log mis à jour. # On ajoute aussi un message utilisateur via gr.Info dans le .click return None, log, "Génération d'image désactivée. Veuillez fournir une clé API OpenAI valide dans l'onglet Configuration." # Vérifier les champs obligatoires if not first_name or not last_name or not age or not gender: # Ne pas générer si infos de base manquantes # Le message utilisateur sera géré dans le .click via gr.Info return None, log, "Veuillez remplir Prénom, Nom, Âge et Genre pour générer l'image." # Construire le prompt en anglais # Base prompt_parts = [f"one person only, close-up portrait photo of {first_name} {last_name}, a {gender} aged {age}."] # Préciser "photo", "portrait" # Détails (utilise les mappings pour traduire les choix FR en termes EN) if skin_color_mapping.get(skin_color): prompt_parts.append(f"Skin tone: {skin_color_mapping[skin_color]}.") if eye_color_mapping.get(eye_color): prompt_parts.append(f"Eye color: {eye_color_mapping[eye_color]}.") if hair_style_mapping.get(hair_style): prompt_parts.append(f"Hairstyle: {hair_style_mapping[hair_style]}.") if hair_color_mapping.get(hair_color): prompt_parts.append(f"Hair color: {hair_color_mapping[hair_color]}.") if facial_expression_mapping.get(facial_expression): prompt_parts.append(f"Facial expression: {facial_expression_mapping[facial_expression]}.") if posture_mapping.get(posture): prompt_parts.append(f"Posture: {posture_mapping[posture]}.") if clothing_style_mapping.get(clothing_style): prompt_parts.append(f"Clothing style: {clothing_style_mapping[clothing_style]}.") if accessories_mapping.get(accessories): prompt_parts.append(f"Wearing: {accessories_mapping[accessories]}.") # "Wearing" est souvent mieux pour les accessoires if persona_description_en: prompt_parts.append(f"Background or context: {persona_description_en}.") # Style final prompt_parts.append("Realistic photo style, high detail, natural lighting.") final_prompt = " ".join(prompt_parts) log = update_log(f"Génération Image (début): Prompt='{final_prompt[:100]}...'", log) # Utiliser le client OpenAI (car image_generation_enabled est True) openai_client = app_config.get("client") # Devrait être le client OpenAI ici if not isinstance(openai_client, OpenAI) or app_config.get("api_source") != "openai": error_msg = "Erreur interne: Tentative de génération d'image sans client OpenAI valide." log = update_log(f"ERREUR Génération Image: {error_msg}", log) return None, log, error_msg try: response = openai_client.images.generate( model=OPENAI_IMAGE_MODEL, prompt=final_prompt, size="1024x1024", n=1, response_format="url", # Ou "b64_json" quality="standard", # ou "hd" style="natural" # ou "vivid" ) # Traitement de la réponse (URL ou B64) image_url = response.data[0].url # Alternative si b64_json: # img_b64 = response.data[0].b64_json # img_bytes = base64.b64decode(img_b64) # pil_image = Image.open(io.BytesIO(img_bytes)) # Télécharger l'image depuis l'URL img_response = requests.get(image_url) img_response.raise_for_status() # Vérifie les erreurs HTTP # Ouvrir l'image avec PIL depuis les bytes téléchargés pil_image = Image.open(io.BytesIO(img_response.content)) log = update_log("Génération Image (fin): Succès.", log) # Retourne l'objet PIL Image, le log, et None pour le message d'erreur return pil_image, log, None except openai.AuthenticationError as e: error_msg = f"Erreur d'authentification API OpenAI. Vérifiez votre clé." print(error_msg) log = update_log(f"ERREUR API Auth (Image): {error_msg}", log) return None, log, error_msg # Retourne None pour l'image, log, et message d'erreur except openai.RateLimitError as e: error_msg = f"Erreur API OpenAI (Image): Limite de taux atteinte. Réessayez plus tard." print(error_msg) log = update_log(f"ERREUR API RateLimit (Image): {error_msg}", log) return None, log, error_msg except openai.BadRequestError as e: # Erreur fréquente si le prompt est refusé error_msg = f"Erreur API OpenAI (Image): Requête invalide (prompt refusé ?). Détails: {e}" print(error_msg) log = update_log(f"ERREUR API BadRequest (Image): {error_msg}", log) return None, log, error_msg except Exception as e: error_msg = f"Erreur lors de la génération de l'image: {str(e)}" print(error_msg) log = update_log(f"ERREUR Génération Image: {str(e)}", log) return None, log, error_msg def refine_persona_details_v2(app_config, first_name, last_name, age, field_name, field_value, bias_analysis_json_str, marketing_objectives, session_log_state): """Affine les détails du persona (utilise le client API actif).""" log = session_log_state log = update_log(f"Refinement (début): Champ='{field_name}', Valeur initiale='{field_value[:50]}...'", log) # Vérifier le client API if not app_config.get("client"): error_msg = "Erreur: Client API non configuré pour le raffinement." log = update_log(f"ERREUR Refinement: Client non configuré.", log) # Retourner le log et le message d'erreur pour affichage return log, error_msg active_client = app_config["client"] model_name = app_config["text_model"] # Essayer de récupérer les biais détectés précédemment biases_text = "Aucune analyse de biais précédente disponible ou chargée." if bias_analysis_json_str: # C'est maintenant un dict, pas une str JSON try: # bias_analysis_data = json.loads(bias_analysis_json_str) # Plus nécessaire si c'est un dict detected_biases = bias_analysis_json_str.get("detected_biases", []) if detected_biases: biases_text = "\n".join([f"- {b.get('bias_type','N/A')}: {b.get('explanation','N/A')}" for b in detected_biases]) else: biases_text = "Aucun biais majeur détecté lors de l'analyse initiale." except Exception as e: biases_text = f"Erreur lors de la lecture des biais analysés: {e}" log = update_log(f"ERREUR Lecture Biais pour Refinement: {e}", log) # Prompt système system_prompt = f""" Tu es un assistant IA expert en marketing éthique, aidant à affiner le persona marketing pour '{first_name} {last_name}' ({age} ans). L'objectif marketing initial était : "{marketing_objectives}" L'analyse initiale de cet objectif a soulevé les biais potentiels suivants : {biases_text} Tâche: Concentre-toi UNIQUEMENT sur le champ '{field_name}' dont la valeur actuelle est '{field_value}'. Propose 1 à 2 suggestions CONCISES et ACTIONNABLES pour améliorer, nuancer ou enrichir cette valeur. Tes suggestions doivent viser à : - Rendre le persona plus réaliste et moins cliché. - ATTÉNUER spécifiquement les biais potentiels listés ci-dessus s'ils sont pertinents pour ce champ. - Rester cohérent avec l'objectif marketing général. - Éviter les généralisations excessives. Si la valeur actuelle semble bonne ou si tu manques de contexte pour faire une suggestion pertinente, indique-le simplement (ex: "La valeur actuelle semble appropriée." ou "Difficile de suggérer sans plus de contexte."). Réponds en français. Ne fournis QUE les suggestions ou le commentaire d'approbation/manque de contexte. Ne répète pas la question. """ suggestions = "" # Init pour le bloc except try: response = active_client.chat.completions.create( model=model_name, messages=[{"role": "user", "content": system_prompt}], temperature=0.6, # Un peu plus de créativité pour les suggestions max_tokens=150, ) suggestions = response.choices[0].message.content.strip() log = update_log(f"Refinement (fin): Champ='{field_name}'. Suggestions: '{suggestions[:50]}...'", log) # Retourne le log mis à jour et les suggestions (ou None si erreur) return log, suggestions except openai.AuthenticationError as e: error_msg = f"Erreur d'authentification API ({app_config.get('api_source', 'Inconnu')}) pendant raffinement. Vérifiez votre clé." print(error_msg) log = update_log(f"ERREUR API Auth (Refine): {error_msg}", log) return log, f"ERREUR: {error_msg}" # Retourne message d'erreur pour affichage except openai.RateLimitError as e: error_msg = f"Erreur API ({app_config.get('api_source', 'Inconnu')}) (Refine): Limite de taux atteinte." print(error_msg) log = update_log(f"ERREUR API RateLimit (Refine): {error_msg}", log) return log, f"ERREUR: {error_msg}" except Exception as e: error_msg = f"Erreur lors du raffinement pour '{field_name}': {str(e)}" print(error_msg) log = update_log(f"ERREUR Refinement '{field_name}': {str(e)}", log) return log, f"ERREUR: {error_msg}" def generate_summary_v2(*args): """Génère le résumé HTML du persona (gestion image PIL).""" # Le dernier arg est session_log_state, l'avant-dernier est persona_image (PIL ou None) inputs = args[:-2] # Tous les champs textuels/numériques/dropdowns persona_image_pil = args[-2] # Peut être None ou un objet PIL Image session_log_state = args[-1] log = session_log_state # Extrait tous les champs (assurez-vous que l'ordre correspond à all_persona_inputs_for_summary) (first_name, last_name, age, gender, persona_description_en, # Utiliser la version EN pour le contexte image skin_color, eye_color, hair_style, hair_color, facial_expression, posture, clothing_style, accessories, marital_status, education_level, profession, income, personality_traits, values_beliefs, motivations, hobbies_interests, main_responsibilities, daily_activities, technology_relationship, product_related_activities, pain_points, product_goals, usage_scenarios, brand_relationship, market_segment, commercial_objectives, visual_codes, special_considerations, daily_life, references ) = inputs log = update_log(f"Génération Résumé: Pour '{first_name} {last_name}'.", log) summary = "" image_html = "
\n" # Div pour l'image if not first_name or not last_name or not age: summary += "

Informations de base manquantes

\n" summary += "

Veuillez fournir au moins le prénom, le nom et l'âge (Étape 2).

\n" image_html += "

Image non générée.

\n" else: # Intégrer l'image si elle existe (objet PIL) if persona_image_pil and isinstance(persona_image_pil, Image.Image): try: # Convertir l'image PIL en base64 pour l'intégrer directement buffered = io.BytesIO() # Sauvegarder en PNG (ou JPEG si préféré) dans le buffer mémoire persona_image_pil.save(buffered, format="PNG") img_bytes = buffered.getvalue() img_base64 = base64.b64encode(img_bytes).decode() img_data_url = f"data:image/png;base64,{img_base64}" image_html += f"Persona {first_name}\n" except Exception as e: img_err_msg = f"Erreur encodage image: {e}" image_html += f"

{img_err_msg}

\n" log = update_log(f"ERREUR Encodage Image Résumé: {e}", log) else: image_html += "

Aucune image générée ou disponible.

\n" # Section Informations Personnelles (Titre centré) summary += f"

{first_name} {last_name}, {age} ans ({gender})

\n" # Utiliser persona_description_en ici car c'est ce qui a été utilisé pour l'image, ou ajouter un champ description générale FR ? # Pour l'instant, on affiche pas la desc EN dans le résumé FR. Ajoutons un champ 'description_persona_fr' ? # Solution simple: ne pas afficher de description ici ou ajouter un nouveau champ. # summary += f"

{persona_description_en}

\n" # Commenté # Assemblage des autres sections (avec vérification si champ rempli) def add_section(title, fields): content = "" for label, value in fields.items(): # N'ajoute que si la valeur existe (n'est pas None, False, 0, ou chaîne vide) if value: # Formatage spécial pour les revenus if label == "Revenus annuels (€)" and isinstance(value, (int, float)): # Format numérique avec séparateur de milliers (espace) try: value_str = f"{int(value):,} €".replace(",", " ") except ValueError: # Gère le cas où income serait une chaîne ou autre chose value_str = str(value) + " €" else: value_str = str(value) # Remplace les sauts de ligne par
pour l'affichage HTML value_str_html = value_str.replace("\n", "
") content += f"{label}: {value_str_html}
\n" if content: # Ajoute un peu d'espace avant la section return f"

{title}

\n{content}\n" return "" # Construire le résumé par sections summary += add_section("Infos Socio-Démographiques", { "État civil": marital_status, "Niveau d'éducation": education_level, "Profession": profession, "Revenus annuels (€)": income }) summary += add_section("Psychographie", { "Traits de personnalité": personality_traits, "Valeurs et croyances": values_beliefs, "Motivations intrinsèques": motivations, "Hobbies et intérêts": hobbies_interests }) summary += add_section("Relation au Produit/Service", { "Relation avec la technologie": technology_relationship, "Tâches liées au produit/service": product_related_activities, "Points de douleur (Pain points)": pain_points, "Objectifs d’utilisation du produit/service": product_goals, "Scénarios d’utilisation typiques": usage_scenarios }) summary += add_section("Contexte Professionnel/Vie Quotidienne", { "Responsabilités principales": main_responsibilities, "Activités journalières": daily_activities, "Une journée type / Citation": daily_life # Renommé pour correspondre au label }) summary += add_section("Marketing & Considérations Spéciales", { "Relation avec la marque": brand_relationship, "Segment de marché": market_segment, "Objectifs commerciaux (SMART)": commercial_objectives, "Codes visuels / Marques préférées": visual_codes, "Considérations spéciales (accessibilité, culture...)": special_considerations, "Références / Sources de données": references }) image_html += "
\n" # Ferme div image # Assemblage final avec flexbox pour mettre le texte et l'image côte à côte final_html = "
\n" final_html += f"
\n{summary}
\n" # Colonne texte final_html += image_html # Colonne image final_html += "
" # Retourne le HTML généré et le log mis à jour return final_html, log # --- Interface Gradio V2 (Mise à jour avec BYOK et suggestions) --- with gr.Blocks(theme=gr.themes.Glass()) as demo: gr.Markdown("# PersonaGenAI V2 : Assistant de Création de Persona Marketing") gr.Markdown("Outil d'aide à la création de personas, intégrant l'IA générative (OpenRouter ou OpenAI) pour stimuler la créativité et la réflexivité face aux biais.") # --- État Global Partagé --- # Stocke la configuration active (client API, modèles, flags) app_config_state = gr.State(value={ "client": None, "api_source": None, # 'openai' or 'openrouter' "text_model": None, "image_generation_enabled": False, "openai_key_provided": False, "openrouter_key_provided": bool(openrouter_api_key) }) # Stocke le résultat de l'analyse de biais (maintenant un dict) bias_analysis_result_state = gr.State(value={}) # Stocke l'image générée (objet PIL ou None) persona_image_pil_state = gr.State(value=None) # Stocke le log de session (chaîne de caractères) session_log_state = gr.State(value="") # Pour afficher les messages d'erreur/status globaux status_message_state = gr.State(value="") # --- Affichage Global du Statut/Erreur --- status_display = gr.Markdown(value="", elem_classes="status-message") # Pour afficher les messages d'erreur/info # Fonction pour mettre à jour le message de statut def update_status_display(new_message, current_log): # Met aussi à jour le log si un message est affiché if new_message: current_log = update_log(f"STATUS: {new_message}", current_log) return new_message, current_log # --- Onglets --- with gr.Tabs() as tabs: # --- Onglet 0 : Configuration API (BYOK) --- with gr.Tab("🔑 Configuration API", id=-1): gr.Markdown("### Configuration des Clés API") gr.Markdown("Cette application utilise une IA pour analyser et générer du contenu. Choisissez votre fournisseur d'API.") # Statut de la clé OpenRouter (obligatoire pour le mode de base) if openrouter_api_key: gr.Markdown("✅ Clé API **OpenRouter** trouvée dans l'environnement (`OPENROUTER_API_KEY`).") else: gr.Markdown("❌ **Clé API OpenRouter (`OPENROUTER_API_KEY`) non trouvée.** L'application ne pourra pas fonctionner sans cette clé. Veuillez la définir dans vos variables d'environnement ou un fichier `.env`.") # Champ pour la clé OpenAI (optionnelle) openai_api_key_input = gr.Textbox( label="Clé API OpenAI (Optionnelle)", type="password", placeholder="Entrez votre clé OpenAI ici pour activer DALL-E 3 et utiliser OpenAI pour le texte", info="Si fournie, cette clé sera utilisée pour la génération d'images (DALL-E 3) ET pour l'analyse/raffinement de texte (GPT). Sinon, OpenRouter sera utilisé pour le texte et la génération d'images sera désactivée." ) # Bouton pour appliquer la config (initialise les clients) configure_api_button = gr.Button("Appliquer la Configuration API") # Affichage du statut de la configuration active api_status_display = gr.Markdown("Statut API: Non configuré.") # Fonction de configuration des clients API def configure_api_clients(openai_key, current_config, current_log): openai_key_provided = bool(openai_key) openrouter_key_available = current_config["openrouter_key_provided"] status_msg = "" config = current_config.copy() # Copie pour modification client = None api_source = None text_model = None image_enabled = False # Priorité à OpenAI si clé fournie if openai_key_provided: try: client = OpenAI(api_key=openai_key) # Faire un petit appel test (optionnel mais recommandé) # client.models.list() # Peut coûter un peu api_source = "openai" text_model = OPENAI_TEXT_MODEL image_enabled = True status_msg = f"✅ Configuration **OpenAI** active (Modèle texte: `{text_model}`, Images: DALL-E 3 activé)." config["openai_key_provided"] = True except Exception as e: status_msg = f"⚠️ Clé OpenAI fournie mais invalide ou problème de connexion: {e}. Basculement vers OpenRouter si possible." log_msg = f"ERREUR API Config OpenAI: {e}" current_log = update_log(log_msg, current_log) print(log_msg) # Reset OpenAI specific flags config["openai_key_provided"] = False openai_key_provided = False # Force fallback if error # Fallback vers OpenRouter si clé OpenAI non fournie ou invalide, ET si clé OpenRouter existe if not openai_key_provided: if openrouter_key_available: try: client = OpenAI( base_url="https://openrouter.ai/api/v1", api_key=openrouter_api_key, ) api_source = "openrouter" text_model = OPENROUTER_TEXT_MODEL image_enabled = False # Image désactivée avec OpenRouter dans cette config status_msg = f"✅ Configuration **OpenRouter** active (Modèle texte: `{text_model}`, Images: Désactivé)." except Exception as e: status_msg = f"❌ Erreur lors de l'initialisation d'OpenRouter: {e}. L'application risque de ne pas fonctionner." log_msg = f"ERREUR API Config OpenRouter: {e}" current_log = update_log(log_msg, current_log) print(log_msg) client = None # Assure que le client est None else: status_msg = "❌ Aucune clé API valide (OpenAI ou OpenRouter) n'est configurée. L'application ne peut pas fonctionner." client = None # Assure que le client est None # Mettre à jour l'état global config["client"] = client config["api_source"] = api_source config["text_model"] = text_model config["image_generation_enabled"] = image_enabled log_msg = f"Configuration API appliquée. Source: {api_source or 'Aucune'}, Images: {'Actif' if image_enabled else 'Inactif'}." current_log = update_log(log_msg, current_log) # Retourne la nouvelle config, le message de statut, le log mis à jour, # et l'état interactif du bouton de génération d'image return config, status_msg, current_log, gr.update(interactive=image_enabled) # Lier le bouton de configuration # La sortie met à jour : l'état de config, le markdown de statut, l'état du log, # et l'interactivité du bouton de génération d'image (qui est dans un autre onglet) # On a besoin de référencer le bouton de génération d'image ici. Il faut le définir avant. # Solution : On va plutôt mettre à jour l'état `app_config_state`, et le bouton d'image # lira cet état quand il sera cliqué. La désactivation visuelle se fera via un .change() sur l'état. configure_api_button.click( fn=configure_api_clients, inputs=[openai_api_key_input, app_config_state, session_log_state], outputs=[app_config_state, api_status_display, session_log_state] # L'interactivité du bouton image sera gérée séparément via un .change() ) # --- Onglet 1 : Objectif & Analyse Biais --- with gr.Tab("🎯 Étape 1: Objectif & Analyse Biais", id=0): gr.Markdown("### 1. Définissez votre objectif marketing") gr.Markdown("Décrivez pourquoi vous créez ce persona. L'IA analysera votre objectif pour identifier des biais cognitifs potentiels.") with gr.Row(): objective_input = gr.Textbox(label="Objectif marketing pour ce persona", lines=4, scale=3) with gr.Column(scale=1): gr.Markdown("Suggestions d'objectifs :") suggestion_button1 = gr.Button("Exemple 1 : Service Écologique Urbain", size="sm") suggestion_button2 = gr.Button("Exemple 2 : App Fitness Seniors", size="sm") analyze_button = gr.Button("🔍 Analyser l'Objectif pour Biais") gr.Markdown("---") gr.Markdown("### Analyse des Biais Potentiels") bias_analysis_output_highlighted = gr.HighlightedText( label="Biais détectés et Conseils", show_legend=True, color_map={"BIAS_TYPE": "red", "EXPLANATION": "gray", "ADVICE": "green", "INFO": "blue", "COMMENT": "orange", "ERROR": "darkred"} # Ajout ERROR ) gr.Markdown("---") gr.Markdown("### 🤔 Réflexion") user_reflection_on_biases = gr.Textbox( label="Comment comptez-vous utiliser cette analyse pour la suite ?", lines=2, placeholder="Ex: Je vais veiller à ne pas tomber dans le stéréotype X, je vais chercher des données pour nuancer Y..." ) log_reflection_button = gr.Button("📝 Enregistrer la réflexion", size='sm') # Logique de l'onglet 1 suggestion1_text = "Je souhaite créer un persona pour promouvoir un nouveau service de livraison écologique destiné aux jeunes professionnels urbains soucieux de l'environnement (25-35 ans). Il doit incarner ces valeurs et besoins identifiés lors de notre étude préalable." suggestion2_text = "Développer une application mobile de fitness personnalisée pour les seniors actifs (+65 ans) cherchant à maintenir une vie saine et sociale. Le persona doit refléter leurs besoins (facilité, convivialité) et préférences." suggestion_button1.click(lambda: suggestion1_text, outputs=objective_input) suggestion_button2.click(lambda: suggestion2_text, outputs=objective_input) # Action du bouton Analyser analyze_button.click( fn=analyze_biases_v2, inputs=[app_config_state, objective_input, session_log_state], outputs=[bias_analysis_result_state, session_log_state] # Stocke le dict résultat + maj log ).then( fn=display_bias_analysis_v2, inputs=bias_analysis_result_state, # Utilise le résultat stocké (dict) outputs=bias_analysis_output_highlighted # Affiche formaté ).then( # Met à jour le statut global si l'analyse a retourné une erreur fn=lambda result, log: update_status_display(result.get("overall_comment", "") if "Erreur" in result.get("overall_comment", "") else "", log), inputs=[bias_analysis_result_state, session_log_state], outputs=[status_display, session_log_state] ) # Action du bouton Enregistrer Réflexion def log_user_reflection(reflection_text, log_state): log = update_log(f"Réflexion Utilisateur (Étape 1): '{reflection_text}'", log_state) return log log_reflection_button.click( fn=log_user_reflection, inputs=[user_reflection_on_biases, session_log_state], outputs=[session_log_state] ) # --- Onglet 2 : Image & Infos Base --- with gr.Tab("👤 Étape 2: Image & Infos Base", id=1): gr.Markdown("### 2. Créez l'identité visuelle et les informations de base") with gr.Row(): with gr.Column(scale=1.4): # Colonne de gauche pour les inputs first_name_input = gr.Textbox(label="Prénom") last_name_input = gr.Textbox(label="Nom") age_input = gr.Slider(label="Âge", minimum=18, maximum=100, step=1, value=30) gender_input = gr.Radio(label="Genre", choices=["Homme", "Femme", "Non-binaire"], value="Homme") persona_description_en_input = gr.Textbox(label="Contexte/Activité pour l'image (optionnel, en anglais)", lines=1, info="Ex: 'reading a book in a cozy cafe', 'working on a laptop in a modern office', 'hiking on a sunny day'") with gr.Accordion("🎨 Détails Visuels (Optionnel)", open=False): with gr.Row(): skin_color_input = gr.Dropdown(label="Teint", choices=list(skin_color_mapping.keys()), value="") eye_color_input = gr.Dropdown(label="Yeux", choices=list(eye_color_mapping.keys()), value="") with gr.Row(): hair_style_input = gr.Dropdown(label="Coiffure", choices=list(hair_style_mapping.keys()), value="") hair_color_input = gr.Dropdown(label="Cheveux", choices=list(hair_color_mapping.keys()), value="") with gr.Row(): facial_expression_input = gr.Dropdown(label="Expression", choices=list(facial_expression_mapping.keys()), value="") posture_input = gr.Dropdown(label="Posture", choices=list(posture_mapping.keys()), value="") with gr.Row(): clothing_style_input = gr.Dropdown(label="Style Vêtements", choices=list(clothing_style_mapping.keys()), value="") accessories_input = gr.Dropdown(label="Accessoires", choices=list(accessories_mapping.keys()), value="") reset_visuals_button = gr.Button("Réinitialiser Détails Visuels", size="sm") with gr.Column(scale=1): # Colonne de droite pour l'image et le bouton # Utiliser type="pil" pour gérer l'image en mémoire persona_image_output = gr.Image(label="Image du Persona", type="pil", height=400, interactive=False) # Non éditable par l'utilisateur # Ce bouton sera activé/désactivé par la config API generate_image_button = gr.Button("🖼️ Générer / Mettre à jour l'Image") gr.Markdown("💡 **Attention :** Les IA génératrices d'images peuvent reproduire des stéréotypes. Utilisez les détails visuels avec discernement pour créer une représentation nuancée et inclusive. La génération d'image nécessite une clé API OpenAI valide (voir onglet Configuration).", elem_classes="warning") # Logique de l'onglet 2 visual_inputs = [ skin_color_input, eye_color_input, hair_style_input, hair_color_input, facial_expression_input, posture_input, clothing_style_input, accessories_input ] reset_visuals_button.click(lambda: [""] * len(visual_inputs), outputs=visual_inputs) # Action du bouton Générer Image # Définit une fonction intermédiaire pour gérer les sorties multiples et les messages def handle_image_generation(*args): # Le dernier input est app_config_state, l'avant-dernier est log_state # Les autres sont les champs du persona app_config = args[0] log_state = args[-1] persona_inputs = args[1:-1] # first_name, last_name, etc. pil_image, updated_log, error_message = generate_persona_image_v2(app_config, *persona_inputs, log_state) # Préparer les mises à jour des composants status_update = error_message if error_message else "" # Message pour le statut global # Si infos manquantes (retournées par generate_persona.. comme error_message) if "Veuillez remplir" in (error_message or ""): gr.Info(error_message) # Affiche un popup Gradio Info status_update = "" # Ne pas mettre dans le statut global # Si génération désactivée (aussi retourné comme error_message) if "Génération d'image désactivée" in (error_message or ""): gr.Info(error_message) # Affiche popup status_update = "" # Ne pas mettre dans le statut global return pil_image, updated_log, status_update generate_image_button.click( fn=handle_image_generation, inputs=[app_config_state] + [ # Passer l'état de config en premier first_name_input, last_name_input, age_input, gender_input, persona_description_en_input, skin_color_input, eye_color_input, hair_style_input, hair_color_input, facial_expression_input, posture_input, clothing_style_input, accessories_input, session_log_state # Passer l'état du log en dernier ], outputs=[ persona_image_pil_state, # Met à jour l'état de l'image (PIL ou None) session_log_state, # Met à jour l'état du log status_message_state # Met à jour l'état du message (pour affichage global) ] ).then( # Chaîne pour mettre à jour l'affichage de l'image depuis l'état fn=lambda img_state: img_state, inputs=persona_image_pil_state, outputs=persona_image_output ).then( # Chaîne pour mettre à jour l'affichage du statut depuis l'état fn=lambda status_state, log_state: update_status_display(status_state, log_state), inputs=[status_message_state, session_log_state], outputs=[status_display, session_log_state] ) # Mettre à jour l'interactivité du bouton quand la config API change app_config_state.change( fn=lambda config: gr.update(interactive=config.get("image_generation_enabled", False)), inputs=app_config_state, outputs=generate_image_button ) # --- Onglet 3 : Profil Détaillé & Raffinement IA --- with gr.Tab("📝 Étape 3: Profil Détaillé & Raffinement IA", id=2): gr.Markdown("### 3. Complétez les détails du persona") gr.Markdown("Remplissez les champs suivants. Utilisez le bouton '💡 Affiner' pour obtenir des suggestions de l'IA visant à améliorer le champ spécifique, en tenant compte de votre objectif initial et des biais potentiels identifiés.") # Organiser en sections pour plus de clarté with gr.Row(): with gr.Column(): gr.Markdown("#### Infos Socio-Démographiques") marital_status_input = gr.Dropdown(label="État civil", choices=["", "Célibataire", "En couple", "Marié(e)", "Divorcé(e)", "Veuf(ve)"]) education_level_input = gr.Dropdown(label="Niveau d'éducation", choices=["", "Études secondaires", "Baccalauréat", "Licence", "Master", "Doctorat", "Autre"]) profession_input = gr.Textbox(label="Profession") income_input = gr.Number(label="Revenus annuels (€)", minimum=0, step=1000) gr.Markdown("#### Psychographie") with gr.Row(equal_height=False): personality_traits_input = gr.Textbox(label="Traits de personnalité", lines=2, scale=4) refine_personality_traits_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): values_beliefs_input = gr.Textbox(label="Valeurs et croyances", lines=2, scale=4) refine_values_beliefs_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): motivations_input = gr.Textbox(label="Motivations (objectifs, désirs)", lines=2, scale=4) refine_motivations_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): hobbies_interests_input = gr.Textbox(label="Loisirs et intérêts", lines=2, scale=4) refine_hobbies_interests_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Column(): gr.Markdown("#### Relation au Produit/Service") with gr.Row(equal_height=False): technology_relationship_input = gr.Textbox(label="Relation avec la technologie", lines=2, scale=4, info="Ex: early adopter, prudent, technophobe, pragmatique...") refine_technology_relationship_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): product_related_activities_input = gr.Textbox(label="Tâches/activités liées à votre produit/service", lines=2, scale=4) refine_product_related_activities_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): pain_points_input = gr.Textbox(label="Points de douleur (frustrations, problèmes)", lines=2, scale=4) refine_pain_points_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): product_goals_input = gr.Textbox(label="Objectifs en utilisant votre produit/service", lines=2, scale=4) refine_product_goals_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): usage_scenarios_input = gr.Textbox(label="Scénarios d'utilisation typiques", lines=2, scale=4) refine_usage_scenarios_button = gr.Button("💡 Affiner", scale=1, size='sm') # Ajouter les autres champs de V1 ici si nécessaire (Responsabilités, Journée type, Marketing...) pour un persona complet with gr.Accordion("Autres Informations (Optionnel)", open=False): with gr.Row(): with gr.Column(): gr.Markdown("#### Contexte Professionnel/Vie Quotidienne") with gr.Row(equal_height=False): main_responsibilities_input = gr.Textbox(label="Responsabilités principales (pro/perso)", lines=2, scale=4) refine_main_responsibilities_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): daily_activities_input = gr.Textbox(label="Activités journalières typiques", lines=2, scale=4) refine_daily_activities_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): daily_life_input = gr.Textbox(label="Une journée type / Citation marquante", lines=2, scale=4) refine_daily_life_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Column(): gr.Markdown("#### Marketing & Considérations Spéciales") with gr.Row(equal_height=False): brand_relationship_input = gr.Textbox(label="Relation avec la marque", lines=2, scale=4) refine_brand_relationship_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): market_segment_input = gr.Textbox(label="Segment de marché", lines=2, scale=4) refine_market_segment_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): commercial_objectives_input = gr.Textbox(label="Objectifs commerciaux liés (SMART)", lines=2, scale=4) refine_commercial_objectives_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): visual_codes_input = gr.Textbox(label="Codes visuels / Marques préférées", lines=2, scale=4) refine_visual_codes_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): special_considerations_input = gr.Textbox(label="Considérations spéciales (accessibilité, culturelles...)", lines=2, scale=4) refine_special_considerations_button = gr.Button("💡 Affiner", scale=1, size='sm') with gr.Row(equal_height=False): references_input = gr.Textbox(label="Références / Sources de données", lines=2, scale=4) refine_references_button = gr.Button("💡 Affiner", scale=1, size='sm') # Fonction intermédiaire pour gérer l'appel de raffinement et l'affichage def handle_refinement_request(app_config, fname, lname, age_val, field_name_display, field_val, bias_state, objectives, log_state): # Appel de la fonction de raffinement updated_log, result = refine_persona_details_v2(app_config, fname, lname, age_val, field_name_display, field_val, bias_state, objectives, log_state) # Afficher le résultat (suggestions ou erreur) if result and "ERREUR:" in result: # Afficher dans le statut global si c'est une erreur API status_update = result gr.Warning(f"Erreur lors du raffinement pour '{field_name_display}'. Vérifiez le log.") elif result: # Afficher les suggestions dans une InfoBox gr.Info(f"Suggestions pour '{field_name_display}':\n{result}") status_update = "" # Pas d'erreur à afficher globalement else: # Cas où result est None ou vide (ne devrait pas arriver mais au cas où) status_update = "" gr.Warning(f"Pas de suggestion reçue pour '{field_name_display}'.") return updated_log, status_update # Fonction lambda générique pour appeler le handler de raffinement def create_refine_handler(field_name_display, input_component): # Le lambda prend les inputs requis par handle_refinement_request return lambda app_conf, fname, lname, age_val, field_val, bias_state, objectives, log_state: \ handle_refinement_request(app_conf, fname, lname, age_val, field_name_display, field_val, bias_state, objectives, log_state) # Lier chaque bouton "Affiner" common_inputs_refine = [app_config_state, first_name_input, last_name_input, age_input] state_inputs_refine = [bias_analysis_result_state, objective_input, session_log_state] # La sortie met à jour le log et potentiellement le message de statut global common_outputs_refine = [session_log_state, status_message_state] # Lier tous les boutons refine_buttons_map = { refine_personality_traits_button: ("Traits de personnalité", personality_traits_input), refine_values_beliefs_button: ("Valeurs et croyances", values_beliefs_input), refine_motivations_button: ("Motivations", motivations_input), refine_hobbies_interests_button: ("Loisirs et intérêts", hobbies_interests_input), refine_technology_relationship_button: ("Relation avec la technologie", technology_relationship_input), refine_product_related_activities_button: ("Tâches liées au produit", product_related_activities_input), refine_pain_points_button: ("Points de douleur", pain_points_input), refine_product_goals_button: ("Objectifs produit", product_goals_input), refine_usage_scenarios_button: ("Scénarios d'utilisation", usage_scenarios_input), refine_main_responsibilities_button: ("Responsabilités principales", main_responsibilities_input), refine_daily_activities_button: ("Activités journalières", daily_activities_input), refine_daily_life_button: ("Journée type/Citation", daily_life_input), refine_brand_relationship_button: ("Relation marque", brand_relationship_input), refine_market_segment_button: ("Segment marché", market_segment_input), refine_commercial_objectives_button: ("Objectifs commerciaux", commercial_objectives_input), refine_visual_codes_button: ("Codes visuels", visual_codes_input), refine_special_considerations_button: ("Considérations spéciales", special_considerations_input), refine_references_button: ("Références", references_input), } for btn, (label, input_comp) in refine_buttons_map.items(): btn.click( fn=create_refine_handler(label, input_comp), inputs=common_inputs_refine + [input_comp] + state_inputs_refine, outputs=common_outputs_refine ).then( # Chaîne pour mettre à jour l'affichage du statut depuis l'état fn=lambda status_state, log_state: update_status_display(status_state, log_state), inputs=[status_message_state, session_log_state], outputs=[status_display, session_log_state] ) # --- Onglet 4 : Résumé du Persona --- with gr.Tab("📄 Étape 4: Résumé du Persona", id=3): gr.Markdown("### 4. Visualisez le persona complet") summary_button = gr.Button("Générer le Résumé du Persona") # Utiliser Markdown pour afficher le HTML du résumé summary_content = gr.Markdown(elem_classes="persona-summary", value="Cliquez sur 'Générer' pour voir le résumé.") # Collecter tous les inputs nécessaires pour le résumé DANS LE BON ORDRE pour generate_summary_v2 all_persona_inputs_for_summary = [ first_name_input, last_name_input, age_input, gender_input, persona_description_en_input, # Input EN utilisé pour l'image skin_color_input, eye_color_input, hair_style_input, hair_color_input, facial_expression_input, posture_input, clothing_style_input, accessories_input, marital_status_input, education_level_input, profession_input, income_input, personality_traits_input, values_beliefs_input, motivations_input, hobbies_interests_input, main_responsibilities_input, daily_activities_input, technology_relationship_input, product_related_activities_input, pain_points_input, product_goals_input, usage_scenarios_input, brand_relationship_input, market_segment_input, commercial_objectives_input, visual_codes_input, special_considerations_input, daily_life_input, references_input, # Ajouter les états nécessaires en dernier persona_image_pil_state, # Passer l'état contenant l'image PIL session_log_state ] summary_button.click( fn=generate_summary_v2, inputs=all_persona_inputs_for_summary, outputs=[summary_content, session_log_state] # Met à jour le contenu et le log ) # --- Onglet 5 : Journal de Bord --- with gr.Tab("📓 Journal de Bord", id=4): gr.Markdown("### Suivi du Processus de Création") gr.Markdown("Ce journal enregistre les étapes clés et les erreurs de votre session.") log_display_final = gr.Textbox(label="Historique de la session", lines=20, interactive=False, max_lines=MAX_LOG_LINES) export_log_button_final = gr.Button("Exporter le Journal en .txt") # Utiliser gr.DownloadButton pour une meilleure UX # log_file_output = gr.File(label="Télécharger le Journal", file_count="single", visible=False) # Caché initialement download_log_button = gr.DownloadButton(label="Télécharger le Journal", visible=False) # Mettre à jour l'affichage du log quand l'état change session_log_state.change( fn=lambda log_data: log_data, inputs=session_log_state, outputs=log_display_final ) # Mettre à jour l'affichage global du statut quand l'état change status_message_state.change( fn=lambda status_msg, log: update_status_display(status_msg, log), inputs=[status_message_state, session_log_state], outputs=[status_display, session_log_state] ) # Fonction pour préparer le fichier log pour le DownloadButton def prepare_log_for_download(log_data): if not log_data: return gr.update(visible=False) # Cache le bouton si pas de log # Créer un fichier texte temporaire que Gradio peut servir # Utiliser delete=False car Gradio doit pouvoir lire le fichier après le retour de la fonction try: with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt', encoding='utf-8') as temp_file: temp_file.write(log_data) temp_filepath = temp_file.name print(f"Fichier log prêt pour téléchargement : {temp_filepath}") # Retourner le chemin pour le DownloadButton et le rendre visible # Note: Gradio est censé gérer le nettoyage de ce fichier temporaire. return gr.update(value=temp_filepath, visible=True) except Exception as e: print(f"Erreur création fichier log pour téléchargement: {e}") return gr.update(visible=False) # Cache le bouton en cas d'erreur export_log_button_final.click( fn=prepare_log_for_download, inputs=session_log_state, outputs=download_log_button ) # Lancer l'application # Utiliser queue() pour gérer les appels API potentiellement longs # debug=True est utile pour le développement, False en production # share=False est plus sûr par défaut, surtout avec des clés API if not openrouter_api_key: print("\n" + "="*60) print("ERREUR CRITIQUE : Clé API OpenRouter non trouvée.") print("Veuillez définir OPENROUTER_API_KEY dans votre environnement.") print("L'application ne fonctionnera pas correctement sans elle.") print("="*60 + "\n") # On pourrait arrêter ici, mais on lance quand même Gradio pour voir l'interface # et permettre la configuration OpenAI si l'utilisateur le souhaite. # Cependant, l'état initial sera non fonctionnel sans config valide. demo.queue().launch(debug=False, share=False)