Spaces:
Sleeping
Sleeping
| 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 = "<div style='flex: 0 0 320px; margin-left: 20px; text-align: center;'>\n" # Div pour l'image | |
| if not first_name or not last_name or not age: | |
| summary += "<h2>Informations de base manquantes</h2>\n" | |
| summary += "<p><i>Veuillez fournir au moins le prénom, le nom et l'âge (Étape 2).</i></p>\n" | |
| image_html += "<p>Image non générée.</p>\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"<img src='{img_data_url}' alt='Persona {first_name}' style='max-width: 300px; height: auto; border: 1px solid #eee; border-radius: 5px; margin-top: 10px;'/>\n" | |
| except Exception as e: | |
| img_err_msg = f"Erreur encodage image: {e}" | |
| image_html += f"<p><i>{img_err_msg}</i></p>\n" | |
| log = update_log(f"ERREUR Encodage Image Résumé: {e}", log) | |
| else: | |
| image_html += "<p><i>Aucune image générée ou disponible.</i></p>\n" | |
| # Section Informations Personnelles (Titre centré) | |
| summary += f"<div style='text-align: center;'><h1>{first_name} {last_name}, {age} ans ({gender})</h1></div>\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"<p><i>{persona_description_en}</i></p>\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 <br> pour l'affichage HTML | |
| value_str_html = value_str.replace("\n", "<br>") | |
| content += f"<b>{label}:</b> {value_str_html}<br>\n" | |
| if content: | |
| # Ajoute un peu d'espace avant la section | |
| return f"<h3 style='margin-top: 15px; margin-bottom: 5px; border-bottom: 1px solid #eee; padding-bottom: 2px;'>{title}</h3>\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 += "</div>\n" # Ferme div image | |
| # Assemblage final avec flexbox pour mettre le texte et l'image côte à côte | |
| final_html = "<div style='display: flex; flex-wrap: wrap; align-items: flex-start; font-family: sans-serif; padding: 10px;'>\n" | |
| final_html += f"<div style='flex: 1; min-width: 350px; padding-right: 15px;'>\n{summary}</div>\n" # Colonne texte | |
| final_html += image_html # Colonne image | |
| final_html += "</div>" | |
| # 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("<small>Suggestions d'objectifs :</small>") | |
| 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("<small>💡 **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).</small>", 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) |