feat: Initialisation du nouveau dépôt 'gitforge-x' à partir de 'gitforge'.

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/Dockerfile

@@ -0,0 +1,67 @@
+# ÉTAPE 1: Image de base
+FROM python:3.11-slim
+
+# ÉTAPE 2: Configuration et Dossier de travail
+# Nous laissons Render injecter le port via $PORT
+ENV FLASK_APP app.py
+# Suppression des variables GUNICORN_WORKERS et GUNICORN_THREADS car elles sont gérées
+# de manière plus efficace et simple dans entrypoint.sh avec Eventlet.
+
+# Création et utilisation du répertoire /app
+WORKDIR /app
+
+# ÉTAPE 3: Installation des dépendances (OPTIMISATION CACHING)
+# Copie uniquement de requirements.txt pour mettre en cache l'installation
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt \
+    && rm requirements.txt
+
+# ÉTAPE 4: Copie de l'Application et des Fichiers
+# CORRECTION MAJEURE : Ajout du dossier templates
+COPY templates /app/templates
+
+# Copie des autres fichiers (y compris app.py, votre point d'entrée)
+COPY app.py .
+COPY config.py .
+COPY user_routes.py .
+COPY web_routes.py .
+COPY decorators.py .
+COPY billing_routes.py .
+COPY auth_backend.py .
+COPY baserow_storage.py .
+COPY huggingface_storage.py .
+COPY pr_routes.py .
+COPY pull_request_backend.py .
+COPY issues_backend.py .
+COPY issue_routes.py .
+COPY project_routes.py .
+COPY huggingface_repo_manager.py .
+COPY hf_deploy_manager.py .
+COPY deployment_routes.py .
+COPY gemini_functions.py .
+COPY gemini_routes.py .
+COPY repo_settings_routes.py .
+COPY repo_settings_manager.py .
+
+
+# Copie du script d'entrée
+COPY entrypoint.sh .
+
+# NOUVEAU: CORRECTION DES FINS DE LIGNE (Résout 'exec ./entrypoint.sh: no such file or directory')
+# Supprime le caractère de retour chariot (\r)
+RUN sed -i 's/\r$//' entrypoint.sh
+
+# Le rendre exécutable
+RUN chmod +x entrypoint.sh
+
+# ÉTAPE 5: Sécurité et Exécution
+# Création et bascule vers l'utilisateur non-root ('user') pour la sécurité
+RUN useradd -ms /bin/bash user
+RUN chown -R user:user /app
+USER user
+
+# Indique à Docker que le conteneur écoute sur ce port
+EXPOSE $PORT
+
+# Lance l'application via le script d'entrée
+CMD ["./entrypoint.sh"]

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/README.md

@@ -0,0 +1,5 @@
+# Dépôt gitforge
+
+Bienvenue sur votre dépôt GitForge, hébergé sur Mailix.
+
+Commencez par ajouter ou créer des fichiers.

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/app.py

@@ -0,0 +1,377 @@
+# app.py
+import requests
+import json
+import os
+import sys
+import io 
+import uuid 
+from functools import wraps
+from datetime import datetime 
+from flask import Flask, request, jsonify, Response, session
+from flask_cors import CORS
+import baserow_storage # Assurez-vous que ceci est présent
+import shutil
+from flask_socketio import SocketIO 
+import huggingface_storage # <-- NOUVEL IMPORT
+import huggingface_storage # <-- NOUVEL IMPORT
+# NOUVEL IMPORT POUR LA GESTION DU TERMINAL
+
+# Importation des modules backend
+from auth_backend import ( 
+    get_user_by_id,
+    login_user, 
+    register_user, 
+    generate_api_key, 
+    get_plan_limit, 
+    reset_password_via_security_question, 
+    generate_password_hash,
+)
+from decorators import api_key_required # <-- NOUVEL IMPORT
+from flask_cors import CORS # <--- S'assurer que l'importation est là
+from project_routes import project_bp # Si vous nommez le nouveau Blueprint 'project_bp'
+from web_routes import web_bp
+from user_routes import user_bp
+from billing_routes import billing_bp
+from pr_routes import pr_bp # <-- NOUVEL IMPORT
+from issue_routes import issue_bp # <-- NOUVEL IMPORT
+from baserow_storage import check_critical_fields_existence
+from deployment_routes import hf_deploy_bp # <-- IMPORT CRITIQUE
+from gemini_routes import gemini_bp
+from repo_settings_routes import settings_bp # Assurez-vous du chemin correct
+DEFAULT_MAX_CONTENT_LENGTH = 16 * 1024 * 1024 
+
+# Dossier pour le stockage temporaire des fichiers HTML uploadés
+# Nous utilisons un dossier 'temp_uploads' à la racine de l'application
+UPLOAD_FOLDER = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'temp_uploads')
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER) # Créer le dossier s'il n'existe pas
+
+# Extensions de fichiers autorisées (très important pour la sécurité)
+ALLOWED_EXTENSIONS = {'html', 'htm'}
+
+# --- Initialisation de l'Application Flask (DÉPLACÉ ICI pour corriger le NameError) ---
+app = Flask(__name__)
+
+app.config['HF_DATASET_REPO_ID'] = os.environ.get('HF_DATASET_REPO_ID')
+
+# Maintenant, 'app' est défini et on peut lui appliquer des configurations
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['ALLOWED_EXTENSIONS'] = ALLOWED_EXTENSIONS
+
+from werkzeug.middleware.proxy_fix import ProxyFix
+app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_port=1, x_prefix=1)
+# ------------------------------------------------------------------
+
+# car Hugging Face utilise souvent Gunicorn avec ces workers.
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+
+# Configuration
+app.secret_key = os.environ.get("FLASK_SECRET_KEY", "super_secret_dev_key") 
+app.config['MAX_CONTENT_LENGTH'] = DEFAULT_MAX_CONTENT_LENGTH 
+
+# Permettre les requêtes cross-origin (CORS)
+CORS(app, supports_credentials=True, origins="*", allow_headers=["Content-Type", "X-User-API-Key"])
+
+
+# Permettre les requêtes cross-origin pour l'API
+CORS(app) 
+
+app.register_blueprint(hf_deploy_bp) # <-- ENREGISTREZ LE NOUVEAU BLUEPRINT
+app.register_blueprint(web_bp)
+app.register_blueprint(user_bp) 
+app.register_blueprint(billing_bp)
+app.register_blueprint(pr_bp) # <-- NOUVEL ENREGISTREMENT
+app.register_blueprint(issue_bp) # <-- NOUVEL ENREGISTREMENT
+app.register_blueprint(project_bp)
+app.register_blueprint(settings_bp)
+app.register_blueprint(gemini_bp)
+
+# --- Décorateurs d'Authentification (Correction) ---
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        user_id = session.get('user_id')
+        
+        if not user_id:
+            # Redirection HTTP 302 vers la page de connexion pour les requêtes non-API
+            if not request.path.startswith('/api/'):
+                from flask import redirect, url_for
+                # NOTE: Il se peut que 'user_bp.connexion' ne soit pas la bonne route. 
+                # Si c'est dans web_bp, utilisez web_bp.connexion_page comme dans user_routes.py
+                return redirect(url_for('web_bp.connexion_page')) # CORRECTION POTENTIELLE DE LA REDIRECTION
+            # Réponse JSON pour les API
+            return jsonify({"status": "Error", "message": "Accès non autorisé. Veuillez vous connecter.", "code": "AUTH_REQUIRED"}), 401
+
+        # 1. Récupérer les données utilisateur
+        user = get_user_by_id(user_id)
+        
+        if not user:
+            # Si l'ID est dans la session mais l'utilisateur n'existe plus en DB
+            session.pop('user_id', None)
+            from flask import redirect, url_for
+            return redirect(url_for('web_bp.connexion_page')) # Rediriger l'utilisateur déconnecté
+            
+        # 2. Injecter les données utilisateur dans la fonction de vue
+        return f(user=user, *args, **kwargs) # <--- CORRECTION CLÉ : Ajout de user=user
+    return decorated_function
+
+
+# --- Routes d'Authentification (API - Conservées) ---
+
+@app.route("/api/register", methods=["POST"])
+def register():
+    data = request.get_json()
+    username = data.get("username")
+    email = data.get("email")
+    password = data.get("password")
+    confirm_password = data.get("confirm_password")
+    security_question = data.get("security_question")
+    security_answer = data.get("security_answer")
+
+    # CORRECTION ICI: Déballage des 3 valeurs retournées par register_user
+    user_id, message, new_user_data = register_user(username, email, password, confirm_password, security_question, security_answer)
+
+    if user_id and new_user_data: # Vérifier l'ID et les données pour s'assurer du succès
+        session['user_id'] = user_id
+        
+        # Réponse JSON pour l'API, incluant la clé API
+        return jsonify({
+            "message": message, 
+            "status": "Success", 
+            "user_id": user_id, 
+            # On récupère la clé API directement des données utilisateur
+            "api_key": new_user_data.get("api_key") 
+            }), 201
+    else:
+        # Échec de l'inscription (message d'erreur de register_user)
+        return jsonify({"message": message, "status": "Error"}), 400
+
+
+
+@app.route("/api/login", methods=["POST"])
+def login():
+    """
+    Route de connexion de l'utilisateur principal.
+    Prend le nom d'utilisateur/email et le mot de passe.
+    """
+    data = request.get_json()
+    username = data.get("username") 
+    password = data.get("password")
+
+    # CORRECTION DE L'ERREUR :
+    # Nous déballons maintenant 3 valeurs (ID, Message, Données Utilisateur)
+    # car la fonction login_user() dans auth_backend.py a été modifiée pour 
+    # retourner les 3 valeurs.
+    user_id, message, user_data = login_user(username, password)
+
+    # Note: user_data est la 3ème valeur (Dict des données utilisateur ou None)
+    if user_id and user_data: 
+        # La connexion est réussie
+        session['user_id'] = user_id
+        
+        # Réponse API avec la clé API de l'utilisateur pour les futures requêtes
+        return jsonify({
+            "message": message, 
+            "status": "Success", 
+            "user_id": user_id, 
+            # On utilise les données utilisateur (user_data) que nous avons déjà récupérées
+            "api_key": user_data.get("api_key") 
+        }), 200
+    else:
+        # La connexion a échoué (identifiants invalides ou autre erreur)
+        return jsonify({"message": message, "status": "Error"}), 401
+
+@app.route("/api/logout", methods=["POST"])
+def logout():
+    session.pop('user_id', None)
+    return jsonify({"message": "Déconnexion réussie.", "status": "Success"}), 200
+
+@app.route("/api/forgot-password", methods=["POST"])
+def forgot_password_api(): # Renommée pour éviter conflit avec la route HTML
+    data = request.get_json()
+    username_or_email = data.get("username_or_email")
+    security_answer = data.get("security_answer")
+    new_password = data.get("new_password")
+    
+    if not username_or_email or not security_answer or not new_password:
+        return jsonify({"message": "Champs manquants.", "status": "Error"}), 400
+        
+    success, message = reset_password_via_security_question(username_or_email, security_answer, new_password)
+    
+    if success:
+        return jsonify({
+            "message": message,
+            "status": "Success"
+        }), 200
+    else:
+        return jsonify({
+            "message": message,
+            "status": "Error"
+        }), 400
+
+
+# --- Routes de Gestion de Compte (API - Conservées) ---
+
+@app.route("/api/user/generate-key", methods=["POST"])
+@login_required
+def generate_user_api_key():
+    user_id = session.get('user_id')
+    
+    new_api_key = create_dynamic_api_key()
+    
+    success, message = update_user_data(user_id, {"api_key": new_api_key})
+    
+    if success:
+        return jsonify({
+            "message": "Clé API utilisateur générée et sauvegardée. Conservez-la en lieu sûr. **Utilisez-la via URL simple ('api_key=...') ou en-tête 'X-User-API-Key'.**",
+            "status": "Success",
+            "api_key": new_api_key
+        }), 200
+    else:
+        return jsonify({
+            "message": f"Erreur lors de la génération de la clé : {message}",
+            "status": "Error"
+        }), 500
+
+@app.route("/api/user/update-info", methods=["POST"])
+@login_required
+def update_user_info():
+    user_id = session.get('user_id')
+    data = request.get_json()
+    
+    updates = {}
+    if 'username' in data: 
+        updates['username'] = data['username']
+    if 'email' in data:
+        updates['email'] = data['email']
+    if 'plan' in data:
+        updates['plan'] = data['plan']
+        
+    if not updates:
+        return jsonify({
+            "message": "Aucune information à mettre à jour fournie.",
+            "status": "Error"
+        }), 400
+        
+    success, message = update_user_data(user_id, updates)
+
+    if success:
+        return jsonify({
+            "message": message,
+            "status": "Success"
+        }), 200
+    else:
+        return jsonify({
+            "message": f"Échec de la mise à jour : {message}",
+            "status": "Error"
+        }), 400
+
+
+
+@app.route("/api/user-info", methods=["GET"])
+@api_key_required
+def api_user_info(client_user):
+    """
+    Route API pour récupérer les informations de l'utilisateur principal (client)
+    à partir de la clé API fournie.
+    Le 'client_user' est injecté par le décorateur api_key_required.
+    """
+    # client_user est l'objet utilisateur complet injecté par le décorateur
+    
+    # Sécurité : créer une copie et supprimer les données sensibles avant l'envoi
+    user_info_safe = client_user.copy()
+    user_info_safe.pop('password_hash', None)
+    user_info_safe.pop('security_answer_hash', None)
+    
+    return jsonify({
+        "message": "Informations utilisateur récupérées avec succès.",
+        "status": "Success", 
+        "user": user_info_safe
+    }), 200
+
+
+
+@app.route("/api/health", methods=["GET"])
+def health_check():
+    """Vérifie l'état du service en utilisant le statut Baserow."""
+    
+    # 1. Tenter d'obtenir le statut Baserow réel
+    try:
+        # Appelle la fonction de baserow_storage pour vérifier l'état
+        health_status = baserow_storage.get_health_status()
+        
+        # Le statut 'data_storage' est la clé pour le frontend
+        db_status_message = health_status.get('data_storage', 'Unknown')
+        
+        # Si la DB est 'operational', on envoie 'Ready'
+        if db_status_message == 'operational':
+             data_status = "Ready"
+        else:
+             data_status = f"Failed (Baserow: {db_status_message})"
+             
+    except Exception as e:
+        # Erreur générale, Baserow inaccessible ou problème de configuration critique
+        data_status = f"Failed (Exception: {str(e)})"
+        
+    return jsonify({
+        "status": "Online",
+        "data_storage": data_status
+    }), 200
+
+@app.route("/", methods=["GET"])
+def read_root():
+    """Endpoint racine pour le Health Check (Flask version)."""
+    
+    if baserow_storage.is_baserow_up():
+        # Statut OK (200) avec le message
+        return jsonify({"status": "ok", "message": "Backend and Baserow API are reachable."}), 200
+    else:
+        # Statut de service non disponible (503) avec le message d'erreur
+        return jsonify({"detail": "Baserow service unavailable (Health Check failed)."}), 503
+
+
+
+def perform_startup_checks():
+    """
+    Exécute des vérifications critiques au démarrage (Baserow et Hugging Face)
+    pour que les problèmes de configuration soient visibles dans les logs de Render.
+    """
+    print("\n--- DÉBUT DES VÉRIFICATIONS DE DÉMARRAGE CRITIQUES ---", file=sys.stderr)
+    
+    # --- 1. VÉRIFICATION BASEROW (Connexion et Champs) ---
+    baserow_config_status = baserow_storage.check_baserow_connection()
+    
+    if baserow_config_status != "operational":
+        print(f"CRITIQUE: Configuration Baserow ÉCHOUÉE: {baserow_config_status}", file=sys.stderr)
+    else:
+        print("SUCCÈS: Configuration Baserow (Tokens/IDs) trouvée.", file=sys.stderr)
+        
+        # 1.1 VÉRIFICATION DE L'ÉTAT DU SERVICE BASEROW
+        if not baserow_storage.is_baserow_up():
+            print("CRITIQUE: Baserow est configuré mais le Health Check API a ÉCHOUÉ (Vérifiez la connexion ou le token).", file=sys.stderr)
+        else:
+            print("SUCCÈS: Connexion Baserow API OK.", file=sys.stderr)
+            
+            # NOUVEAU: 1.2 VÉRIFICATION DE L'EXISTENCE DES CHAMPS CRITIQUES
+            fields_check_status = baserow_storage.check_critical_fields_existence()
+            if fields_check_status != "operational":
+                print(f"CRITIQUE: Vérification des Champs Baserow ÉCHOUÉE: {fields_check_status}", file=sys.stderr)
+            else:
+                print("SUCCÈS: Tous les champs critiques de la table Baserow sont présents.", file=sys.stderr)
+            
+    # --- 2. VÉRIFICATION HUGGING FACE (Stockage de Dépôt) ---
+    hf_repo_id = os.environ.get("HF_DATASET_REPO_ID")
+    hf_token = os.environ.get("HF_TOKEN")
+    
+    if not hf_repo_id:
+        print("CRITIQUE: HF_DATASET_REPO_ID est MANQUANT. Impossible de créer un dépôt.", file=sys.stderr)
+    elif not hf_token:
+        print("ATTENTION: HF_TOKEN est MANQUANT. Les opérations Hugging Face pourraient échouer sans jeton dans l'environnement.", file=sys.stderr)
+    else:
+        print(f"SUCCÈS: Configuration Hugging Face (Repo ID: {hf_repo_id}) trouvée.", file=sys.stderr)
+        
+    print("--- FIN DES VÉRIFICATIONS DE DÉMARRAGE CRITIQUES ---\n", file=sys.stderr)
+
+# Exécutez les vérifications au démarrage de Gunicorn
+perform_startup_checks()

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/auth_backend.py

@@ -0,0 +1,371 @@
+# auth_backend.py
+
+import json
+import uuid
+import secrets 
+import string 
+import sys # Nécessaire pour print(..., file=sys.stderr)
+from datetime import datetime
+from werkzeug.security import generate_password_hash, check_password_hash
+from huggingface_repo_manager import initialize_user_hf_folder # <--- AJOUTEZ CET IMPORT
+# Ces fonctions sont maintenant implémentées dans baserow_storage.py
+from baserow_storage import (
+    # Fonctions de lecture/écriture pour les utilisateurs principaux (simulant l'ancienne API)
+    get_client_user_by_api_key,
+    load_primary_user_data,
+    save_primary_user_data,
+    # Fonctions de recherche indexées (nouvelles et plus efficaces)
+    get_user_by_email,
+    get_client_user_by_api_key, 
+    FIELD_USER_TYPE, 
+    FIELD_CLIENT_ID,
+)
+
+from config import PLANS_CONFIG 
+from typing import Optional, Dict 
+
+# ----------------------------------------------------------------------
+# --- Fonctions Utilitaires et de Configuration ---
+# ----------------------------------------------------------------------
+
+def get_plan_limit(plan: str) -> float: 
+    """Retourne la limite de compte pour un plan donné."""
+    return PLANS_CONFIG.get(plan, {}).get("limit", PLANS_CONFIG["free"]["limit"])
+
+def get_plan_details(plan_id: str) -> Optional[Dict]:
+    """Retourne les détails complets d'un plan à partir de son ID."""
+    return PLANS_CONFIG.get(plan_id)
+
+def generate_api_key(length: int = 32) -> str:
+    """Génère une clé API sécurisée."""
+    chars = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(chars) for _ in range(length))
+
+# ----------------------------------------------------------------------
+# --- Fonctions d'Authentification WEB (Primary Users) ---
+# ----------------------------------------------------------------------
+
+
+def register_user(username: str, email: str, password: str, confirm_password: str, security_question: str, security_answer: str) -> tuple[Optional[str], str, Optional[Dict]]:
+    """
+    Tente d'enregistrer un nouvel utilisateur principal.
+    Retourne l'ID utilisateur (str), un message (str), et les données utilisateur complètes (Dict) ou None.
+    """
+    email = email.lower().strip()
+    
+    # Validation du formulaire
+    if not all([username, email, password, confirm_password, security_question, security_answer]):
+        # Retourne (ID, message, Data)
+        return None, "Tous les champs sont requis.", None
+        
+    if password != confirm_password:
+        return None, "Les mots de passe ne correspondent pas.", None
+        
+    if len(password) < 8:
+        return None, "Le mot de passe est trop court (min 8 caractères).", None
+
+    # 1. Vérification de l'existence de l'utilisateur par email
+    if get_user_by_email(email):
+        return None, "Un compte avec cette adresse e-mail existe déjà.", None
+
+    # 2. Hachage des données
+    password_hash = generate_password_hash(password)
+    security_answer_hash = generate_password_hash(security_answer.lower())
+    
+    # 3. Création des données utilisateur
+    user_id = str(uuid.uuid4())
+    # Ligne optimisée: on génère les 5 clés en une seule liste
+    api_keys = [generate_api_key() for _ in range(5)] 
+    
+    new_user = {
+        'user_id': user_id,
+        'username': username,
+        'email': email,
+        'password_hash': password_hash,
+        # ASSIGNATION DES 5 CLÉS API AUX CHAMPS CORRESPONDANTS
+        'api_key': api_keys[0],
+        'api_key_2': api_keys[1],
+        'api_key_3': api_keys[2],
+        'api_key_4': api_keys[3],
+        'api_key_5': api_keys[4],
+        'security_question': security_question,
+        'security_answer_hash': security_answer_hash,
+        'plan_id': PLANS_CONFIG['free']['baserow_value'],
+        'stripe_subscription_id': None, # Pas d'abonnement Stripe au début
+        'date_creation': datetime.now().isoformat(),
+        'date_plan_start': datetime.now().isoformat(),
+        'api_calls_month': 0,
+        'status': 'Active',
+        'baserow_row_id': None, # Sera rempli par la fonction save_primary_user_data si c'est une création
+        # Note: D'autres champs pourraient être nécessaires ici, selon les besoins non-vus
+    }
+
+    # 4. Sauvegarde dans Baserow 
+    # La fonction save_primary_user_data mettra à jour 'baserow_row_id' dans new_user si la création est réussie.
+    success = save_primary_user_data(new_user, commit_msg=f"feat: Création de l'utilisateur {user_id} ({email})")
+    
+    if success:
+        # Retourne : ID utilisateur, message de succès, Dictionnaire utilisateur complet
+        return user_id, "Inscription réussie. Vous pouvez maintenant vous connecter.", new_user
+    else:
+        # Échec de l'écriture dans la BDD (Baserow)
+        # Retourne : None, message d'erreur, None
+        return None, "Erreur interne lors de l'enregistrement de l'utilisateur.", None
+        
+def login_user(username_or_email: str, password: str) -> tuple[Optional[str], str, Optional[Dict]]: # <-- NOUVEAU: Ajout de Optional[Dict] dans le type hint
+    """
+    Tente de connecter un utilisateur principal.
+    Retourne l'ID utilisateur (str), un message (str) et les données utilisateur (Dict).
+    """
+    username_or_email = username_or_email.lower().strip()
+    
+    # 1. Recherche de l'utilisateur par email (Utilisation de la nouvelle fonction rapide Baserow)
+    user = get_user_by_email(username_or_email)
+    
+    if user:
+        # 2. Vérification du mot de passe
+        if check_password_hash(user['password_hash'], password):
+            # CORRECTION : Retourne 3 valeurs : ID, Message, Données Utilisateur
+            return user['user_id'], "Connexion réussie.", user 
+
+    # CORRECTION : Retourne 3 valeurs : None ID, Message, None Data
+    return None, "Email/Nom d'utilisateur ou mot de passe invalide.", None
+
+
+def get_user_by_id(user_id: str) -> Optional[Dict]:
+    """
+    Récupère un utilisateur principal par son ID.
+    Utilise la fonction load_primary_user_data (qui est get_user_by_id dans Baserow).
+    """
+    return load_primary_user_data(user_id)
+    
+def get_user_by_api_key(api_key: str) -> Optional[Dict]:
+    """
+    Récupère un utilisateur principal par sa Clé API (utilisé par le décorateur).
+    Utilise la nouvelle fonction indexée et rapide de Baserow.
+    """
+    return get_client_user_by_api_key(api_key)
+
+
+def reset_password_via_security_question(username_or_email: str, question: str, answer: str, new_password: str) -> tuple[bool, str]:
+    """Réinitialise le mot de passe via la question de sécurité."""
+    username_or_email = username_or_email.lower().strip()
+    
+    # Validation du mot de passe
+    if len(new_password) < 8:
+        return False, "Le nouveau mot de passe est trop court (min 8 caractères)."
+
+    # 1. Recherche de l'utilisateur
+    user = get_user_by_email(username_or_email)
+    
+    if not user:
+        return False, "Utilisateur introuvable."
+        
+    # 2. Vérification de la question/réponse
+    if user.get('security_question') != question:
+        return False, "Question de sécurité incorrecte."
+        
+    if not check_password_hash(user.get('security_answer_hash', ''), answer.lower()):
+        return False, "Réponse de sécurité incorrecte."
+        
+    # 3. Hachage du nouveau mot de passe
+    new_hashed_password = generate_password_hash(new_password)
+    
+    # 4. Mise à jour et sauvegarde en BDD (Baserow)
+    user['password_hash'] = new_hashed_password
+    
+    success = save_primary_user_data(user, commit_msg=f"feat: Réinitialisation MDP utilisateur {user['user_id']}")
+    
+    if success:
+        return True, "Mot de passe réinitialisé avec succès."
+    else:
+        return False, "Erreur interne lors de la mise à jour du mot de passe."
+
+
+def update_user_plan(user_id: str, new_plan_id: str, stripe_subscription_id: Optional[str]) -> bool:
+    """Met à jour le plan et l'ID d'abonnement Stripe pour un utilisateur."""
+    
+    user = get_user_by_id(user_id)
+    
+    if not user:
+        print(f"Erreur: Utilisateur {user_id} non trouvé pour la mise à jour du plan.", file=sys.stderr)
+        return False
+
+    user['plan_id'] = new_plan_id
+    user['stripe_subscription_id'] = stripe_subscription_id
+    user['date_plan_start'] = datetime.now().isoformat()
+    
+    success = save_primary_user_data(user, commit_msg=f"feat: Mise à jour du plan pour {user_id} vers {new_plan_id}")
+    
+    return success
+
+
+def update_user_profile(user_id: str, username: str, email: str, new_password: Optional[str] = None) -> tuple[bool, str]:
+    """
+    Met à jour le profil de l'utilisateur principal (client).
+    user_id: L'UUID de l'utilisateur.
+    username: Le nouveau nom d'utilisateur.
+    email: Le nouvel email.
+    new_password: Le nouveau mot de passe (si fourni et non vide).
+    """
+    
+    # 1. Chargement des données existantes
+    user_data = load_primary_user_data(user_id)
+    if not user_data:
+        return False, "Erreur critique : Utilisateur introuvable pour la mise à jour."
+        
+    original_email = user_data.get('email')
+    
+    # 2. Validation et mise à jour de l'email
+    if email and email != original_email:
+        # Vérification si le nouvel email n'est pas déjà utilisé par un autre utilisateur
+        # Note: get_user_by_email retourne l'objet utilisateur, pas juste l'ID.
+        existing_user_by_email = get_user_by_email(email)
+        
+        # S'il trouve un utilisateur ET que son ID ne correspond pas à l'utilisateur actuel,
+        # l'email est déjà pris.
+        if existing_user_by_email and existing_user_by_email.get('user_id') != user_id:
+            return False, "Cet email est déjà utilisé par un autre compte."
+        
+        # Mise à jour de l'email si la validation passe
+        user_data['email'] = email
+        
+    # 3. Mise à jour du nom d'utilisateur (pas de validation d'unicité assumée ici)
+    user_data['username'] = username
+    
+    # 4. Mise à jour du mot de passe (si un nouveau est fourni)
+    if new_password:
+        if len(new_password) < 8:
+            # Assurez-vous que cette limite est cohérente avec la fonction register_user
+            return False, "Le nouveau mot de passe est trop court (min 8 caractères)."
+            
+        user_data['password_hash'] = generate_password_hash(new_password)
+        
+    # 5. Sauvegarde des données
+    # Le row_id est stocké dans l'objet utilisateur après la première sauvegarde.
+    baserow_row_id = user_data.get('baserow_row_id')
+    
+    if baserow_row_id is None:
+        return False, "Erreur de configuration : ID de ligne Baserow manquant."
+        
+    if save_primary_user_data(user_data, commit_msg=f"feat: Mise à jour du profil utilisateur {user_id}"):
+        return True, "Votre profil a été mis à jour avec succès."
+    else:
+        return False, "Une erreur s'est produite lors de la sauvegarde du profil."
+
+def register_end_user(client_id: str, username: str, email: str, password: str, confirm_password: str) -> tuple[Optional[str], str, Optional[Dict]]:
+    """
+    Enregistre un nouvel utilisateur final (End User) lié à un utilisateur client (Primary User).
+    """
+    if password != confirm_password:
+        return None, "Les mots de passe ne correspondent pas.", None
+    if len(password) < 8:
+        return None, "Le mot de passe doit contenir au moins 8 caractères.", None
+
+    # Vérification de l'unicité de l'email UNIQUEMENT pour ce client et pour le type 'End'
+    existing_user_by_email = load_primary_user_data(
+        filters={
+            FIELD_EMAIL: email,
+            FIELD_USER_TYPE: 'End',
+            FIELD_CLIENT_ID: client_id
+        }
+    )
+    if existing_user_by_email:
+        return None, "Cet email est déjà utilisé pour votre service.", None
+
+    # 1. Création des données de l'utilisateur final
+    user_id = str(uuid.uuid4())
+    password_hash = generate_password_hash(password)
+    
+    new_user_data = {
+        FIELD_ID: user_id,
+        FIELD_EMAIL: email,
+        FIELD_USERNAME: username,
+        FIELD_PASSWORD_HASH: password_hash,
+        FIELD_DATE_CREATION: datetime.now().isoformat(),
+        FIELD_USER_TYPE: 'End',         # <-- IMPORTANT: Marquer comme utilisateur final
+        FIELD_CLIENT_ID: client_id,     # <-- IMPORTANT: Lier au client principal
+        FIELD_PLAN: PLANS_CONFIG['free']['baserow_value'], # Plan par défaut
+    }
+    
+    # 2. Sauvegarde dans Baserow (dans la même table)
+    success, row_id = save_primary_user_data(new_user_data, is_new=True)
+
+    if success:
+        new_user_data['baserow_row_id'] = row_id 
+        return user_id, "Inscription réussie !", new_user_data
+    else:
+        return None, f"Erreur lors de l'enregistrement dans la base de données. ID: {user_id}", None
+
+def login_end_user(client_id: str, email: str, password: str) -> tuple[Optional[str], str, Optional[Dict]]:
+    """
+    Connecte un utilisateur final (End User) lié à un client donné.
+    """
+    user_data_list = load_primary_user_data(
+        filters={
+            FIELD_EMAIL: email,
+            FIELD_USER_TYPE: 'End', # Filtrer uniquement les utilisateurs finaux
+            FIELD_CLIENT_ID: client_id # Filtrer par l'ID du client
+        }
+    )
+    
+    if not user_data_list:
+        return None, "Email ou mot de passe invalide.", None
+    
+    user_data = user_data_list[0]
+    
+    if check_password_hash(user_data.get(FIELD_PASSWORD_HASH), password):
+        return user_data.get(FIELD_ID), "Connexion réussie.", user_data
+    else:
+        return None, "Email ou mot de passe invalide.", None
+
+def reset_end_user_password(client_id: str, email: str, new_password: str, confirm_password: str) -> tuple[bool, str]:
+    """
+    Réinitialise le mot de passe d'un utilisateur final (End User) lié à un client donné.
+    """
+    if new_password != confirm_password:
+        return False, "Les mots de passe ne correspondent pas."
+    if len(new_password) < 8:
+        return False, "Le nouveau mot de passe est trop court (min 8 caractères)."
+
+    user_data_list = load_primary_user_data(
+        filters={
+            FIELD_EMAIL: email,
+            FIELD_USER_TYPE: 'End',
+            FIELD_CLIENT_ID: client_id
+        }
+    )
+    
+    if not user_data_list:
+        return False, "Utilisateur non trouvé." 
+    
+    user_data = user_data_list[0]
+    
+    # Mise à jour du mot de passe
+    user_data[FIELD_PASSWORD_HASH] = generate_password_hash(new_password)
+    
+    baserow_row_id = user_data.get('baserow_row_id')
+    
+    if baserow_row_id is None:
+        return False, "Erreur de configuration: ID de ligne Baserow manquant."
+        
+    success, _ = save_primary_user_data(user_data, commit_to_baserow=True)
+    
+    if success:
+        return True, "Votre mot de passe a été réinitialisé avec succès."
+    else:
+        return False, "Une erreur s'est produite lors de la réinitialisation du mot de passe."
+
+def get_client_user_by_uuid(user_uuid: str) -> Optional[Dict]:
+    """
+    Récupère les données d'un utilisateur principal (Client) par son UUID/ID.
+    
+    Ceci est un alias pour satisfaire l'appel de fonction dans decorators.py
+    sans avoir à modifier ce dernier fichier.
+    
+    Elle suppose que la fonction 'get_user_by_id' est déjà définie 
+    dans ce module et gère la logique de récupération de données.
+    """
+    # Assurez-vous que get_user_by_id est bien définie avant cet alias.
+    # get_user_by_id doit retourner les données utilisateur ou None.
+    return get_user_by_id(user_uuid)

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/baserow_storage.py

@@ -0,0 +1,791 @@
+# baserow_storage.py (Version Modifiée)
+
+import os
+import requests
+import json
+import sys
+from datetime import datetime
+from typing import Optional, Dict
+import logging
+# Configuration du logger (ajoutez ceci en haut du fichier)
+logger = logging.getLogger(__name__)
+# --- Configuration Baserow (Doit être défini dans les secrets) ---
+HEALTH_CHECK_URL = "https://api.baserow.io/api/database/rows/table/"
+
+# 2. URL de BASE CORRECTE pour la construction des requêtes de données (connexion, inscription, etc.)
+DATA_BASE_URL = "https://api.baserow.io/api/database/rows/"
+API_TOKEN = os.environ.get("BASEROW_API_TOKEN")
+
+# Les IDs de table seront récupérés depuis les variables d'environnement
+PRIMARY_USERS_TABLE_ID = os.environ.get("PRIMARY_USERS_TABLE_ID") 
+END_USERS_TABLE_ID = os.environ.get("END_USERS_TABLE_ID") 
+# NOUVEL ID DE TABLE POUR LES DÉPLOIEMENTS (Projets)
+DEPLOYMENTS_TABLE_ID = os.environ.get("DEPLOYMENTS_TABLE_ID")
+
+# Headers pour l'authentification
+HEADERS = {
+    "Authorization": f"Token {API_TOKEN}",
+    "Content-Type": "application/json"
+}
+
+
+FIELD_ID = 'ID' # Correspond à 'user_id' dans le code
+FIELD_EMAIL = 'Email' # Correspond à 'email'
+FIELD_USERNAME = 'Nom d\'utilisateur' # Correspond à 'username'
+FIELD_PASSWORD_HASH = 'Hachage Mot de Passe' # Correspond à 'password_hash'
+FIELD_API_KEY = 'Clé API' # Correspond à 'api_key'
+FIELD_API_KEY_2 = 'Clé API 2'
+FIELD_API_KEY_3 = 'Clé API 3'
+FIELD_API_KEY_4 = 'Clé API 4'
+FIELD_API_KEY_5 = 'Clé API 5'
+FIELD_SECURITY_Q = 'Question de Sécurité'
+FIELD_SECURITY_A_HASH = 'Hachage Réponse Secrète'
+FIELD_PLAN_ID = 'Plan ID'
+FIELD_STRIPE_SUB_ID = 'ID Abonnement Stripe'
+FIELD_DATE_CREATION = 'Date Création'
+FIELD_DATE_PLAN_START = 'Date Plan Start'
+FIELD_API_CALLS_MONTH = 'API Calls Month' # À vérifier avec votre nom exact dans Baserow!
+FIELD_STATUS = 'Status'
+FIELD_END_USER_ID = 'ID Utilisateur Final' # Correspond à 'end_user_id'
+FIELD_END_USER_IDENTIFIER = 'Identifiant' # Correspond à 'identifier'
+FIELD_END_USER_METADATA = 'Métadonnées' # Correspond à 'metadata'
+FIELD_CLIENT_ID_LINK = 'ID Client Principal' # Lien vers Primary_Users
+FIELD_USER_TYPE = 'UserType' # Ex: 'Primary' pour les clients, 'End' pour leurs utilisateurs
+FIELD_CLIENT_ID = 'ClientID' # L'ID de l'utilisateur 'Primary' qui possède cet utilisateur 'End'
+
+# ----------------------------------------------------------------------
+# --- Noms de Colonnes pour la Table des Utilisateurs Finaux (End Users) ---
+# ----------------------------------------------------------------------
+# Ces champs sont spécifiques à la table END_USERS
+FIELD_END_USER_ID = 'ID Utilisateur Final'
+FIELD_END_USER_IDENTIFIER = 'Identifiant' # Champ pour compatibilité ou recherche
+FIELD_END_USER_EMAIL = 'Email' # NOUVEAU
+FIELD_END_USER_USERNAME = 'Nom d\'utilisateur' # NOUVEAU
+FIELD_END_USER_SECURITY_Q = 'Question de Sécurité' # NOUVEAU (Peut être différent de Primary)
+FIELD_END_USER_SECURITY_A_HASH = 'Hachage Réponse Secrète' # NOUVEAU
+FIELD_END_USER_STATUS = 'Statut' # NOUVEAU
+FIELD_END_USER_METADATA = 'Métadonnées' 
+FIELD_PASSWORD_HASH_END_USER = 'Hachage Mot de Passe End User' # Renommer pour éviter le conflit si possible
+FIELD_CLIENT_ID_LINK = 'ID Client Principal'
+
+def _get_table_url(table_id: str) -> str:
+    """Construit l'URL d'API pour une table donnée (avec le bon endpoint)."""
+    return f"{DATA_BASE_URL}table/{table_id}/"
+
+def _baserow_record_to_user(record: Dict, is_end_user: bool) -> Dict:
+    """
+    Convertit un enregistrement Baserow (avec noms de champs utilisateur)
+    en format de dictionnaire Python attendu par le backend.
+    """
+    
+
+        
+    # LOGIQUE POUR L'UTILISATEUR PRINCIPAL (PRIMARY USER)
+    
+    # 1. Récupération des champs individuels
+    user_data = {
+        # Champs communs / Primary Users
+        'baserow_row_id': record['id'], # ID interne de la ligne Baserow (pour les mises à jour)
+        'date_creation': record.get(FIELD_DATE_CREATION),
+        
+        # Primary User specific fields
+        'user_id': record.get(FIELD_ID),
+        'email': record.get(FIELD_EMAIL),
+        'username': record.get(FIELD_USERNAME),
+        'password_hash': record.get(FIELD_PASSWORD_HASH),
+        
+        # Récupération des 5 clés individuelles (pour l'authentification par clé)
+        'api_key': record.get(FIELD_API_KEY),
+        'api_key_2': record.get(FIELD_API_KEY_2),
+        'api_key_3': record.get(FIELD_API_KEY_3),
+        'api_key_4': record.get(FIELD_API_KEY_4),
+        'api_key_5': record.get(FIELD_API_KEY_5),
+        
+        'security_question': record.get(FIELD_SECURITY_Q),
+        'security_answer_hash': record.get(FIELD_SECURITY_A_HASH),
+        'plan_id': record.get(FIELD_PLAN_ID),
+        'stripe_subscription_id': record.get(FIELD_STRIPE_SUB_ID),
+        'date_plan_start': record.get(FIELD_DATE_PLAN_START),
+    }
+
+    # 2. ÉTAPE CRUCIALE AJOUTÉE : Création de la liste 'api_keys' pour l'affichage
+    # Cette liste est nécessaire pour que la boucle dans api_key.html fonctionne correctement.
+    user_data['api_keys'] = [
+        user_data['api_key'],
+        user_data['api_key_2'],
+        user_data['api_key_3'],
+        user_data['api_key_4'],
+        user_data['api_key_5'],
+    ]
+    
+    # Nettoyage des clés None ou non-pertinentes
+    return {k: v for k, v in user_data.items() if v is not None}
+
+
+def _user_to_baserow_data(user_data: Dict, is_end_user: bool) -> Dict:
+    """
+    Convertit le format de dictionnaire Python du backend en format
+    JSON attendu par l'API Baserow (avec noms de champs utilisateur).
+    """
+    if is_end_user:
+        # End User fields (Ajout des NOUVEAUX champs)
+        baserow_data = {
+            FIELD_END_USER_ID: user_data.get('end_user_id'),
+            FIELD_END_USER_IDENTIFIER: user_data.get('identifier'),
+            FIELD_END_USER_EMAIL: user_data.get('email'), # NOUVEAU
+            FIELD_END_USER_USERNAME: user_data.get('username'), # NOUVEAU
+            FIELD_END_USER_SECURITY_Q: user_data.get('security_question'), # NOUVEAU
+            FIELD_END_USER_SECURITY_A_HASH: user_data.get('security_answer_hash'), # NOUVEAU
+            FIELD_END_USER_STATUS: user_data.get('status'), # NOUVEAU
+            
+            # CORRECTION CRUCIALE : Utilisation du nom de champ correct pour l'End User
+            FIELD_PASSWORD_HASH_END_USER: user_data.get('password_hash'), 
+            
+            FIELD_END_USER_METADATA: user_data.get('metadata'),
+            FIELD_DATE_CREATION: user_data.get('date_creation'),
+            # Le lien vers Primary_Users est géré dans save_end_user_data
+        }
+    else:
+        # Primary User fields
+        baserow_data = {
+            FIELD_ID: user_data.get('user_id'),
+            FIELD_EMAIL: user_data.get('email'),
+            FIELD_USERNAME: user_data.get('username'),
+            FIELD_PASSWORD_HASH: user_data.get('password_hash'),
+            FIELD_API_KEY: user_data.get('api_key'),
+            FIELD_API_KEY_2: user_data.get('api_key_2'),
+            FIELD_API_KEY_3: user_data.get('api_key_3'),
+            FIELD_API_KEY_4: user_data.get('api_key_4'),
+            FIELD_API_KEY_5: user_data.get('api_key_5'),
+            FIELD_SECURITY_Q: user_data.get('security_question'),
+            FIELD_SECURITY_A_HASH: user_data.get('security_answer_hash'),
+            FIELD_PLAN_ID: user_data.get('plan_id'),
+            FIELD_STRIPE_SUB_ID: user_data.get('stripe_subscription_id'),
+            FIELD_DATE_CREATION: user_data.get('date_creation'),
+            FIELD_DATE_PLAN_START: user_data.get('date_plan_start'),
+            FIELD_API_CALLS_MONTH: user_data.get('api_calls_month', 0),
+            FIELD_STATUS: user_data.get('status', 'Active') # Assurez-vous que 'Active' est une option valide dans Baserow
+        }
+
+    # Suppression des clés non-valorisées (None)
+    return {k: v for k, v in baserow_data.items() if v is not None}
+
+
+def _get_single_user_record(table_id: str, field_name: str, value: str, is_end_user: bool) -> Optional[Dict]:
+    """Fonction générique pour rechercher un seul enregistrement par un champ (filtrage Baserow)."""
+    url = _get_table_url(table_id)
+    # Utilisation du paramètre de filtre de Baserow pour une recherche indexée (plus rapide)
+    filter_param = f"filter__{field_name}__equal={value}"
+    
+    try:
+        response = requests.get(
+            f"{url}?user_field_names=true&{filter_param}",
+            headers=HEADERS
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        if data and data.get('results'):
+            # On ne prend que le premier résultat (car ID/Email/API Key sont uniques)
+            return _baserow_record_to_user(data['results'][0], is_end_user)
+        return None
+        
+    except requests.exceptions.RequestException as e:
+        print(f"Erreur de Baserow lors de la recherche par filtre {field_name}: {e}", file=sys.stderr)
+        return None
+
+# ----------------------------------------------------------------------
+# --- Fonctions CRUD Primary_Users (Nouveau et Remplacement) ---
+# ----------------------------------------------------------------------
+
+def get_user_by_email(email: str) -> Optional[Dict]:
+    """Recherche un utilisateur principal par son adresse Email."""
+    return _get_single_user_record(PRIMARY_USERS_TABLE_ID, FIELD_EMAIL, email, is_end_user=False)
+
+API_KEY_FIELDS = [
+    FIELD_API_KEY,  # Clé API
+    FIELD_API_KEY_2,
+    FIELD_API_KEY_3,
+    FIELD_API_KEY_4,
+    FIELD_API_KEY_5,
+]
+
+# baserow_storage.py - à partir de la ligne ~180 (ou autour de la fonction get_client_user_by_api_key)
+
+def get_client_user_by_api_key(api_key: str) -> Optional[Dict]:
+    """
+    Recherche un utilisateur principal dans Baserow en vérifiant la clé API
+    dans chacun des cinq champs de clé API de la table.
+    """
+    if not api_key:
+        logger.debug("get_client_user_by_api_key: Clé API est None ou vide.")
+        return None
+
+    # Construction de l'URL de base pour la table
+    url = f"{DATA_BASE_URL}table/{PRIMARY_USERS_TABLE_ID}/"
+    
+    # Recherche large dans la table (jusqu'à 100 lignes)
+    # NOTE: L'API Baserow utilise `search` pour une recherche FULL TEXT dans tous les champs.
+    # C'est la source potentielle de l'inexactitude qui nécessite un filtrage manuel.
+    params = {'search': api_key, 'size': 100} 
+    
+    try:
+        # CORRECTION 1: Utilisation de la fonction _make_baserow_request
+        # (Cette fonction est maintenant définie à la fin du fichier)
+        # On utilise log_response=True ici pour avoir un log détaillé si la requête échoue
+        response = _make_baserow_request("GET", url, params=params, log_response=True)
+        
+        if response.status_code == 200:
+            data = response.json()
+            
+            # NOUVEAU LOG : Afficher combien de résultats ont été renvoyés par la recherche Baserow
+            num_results = len(data.get('results', []))
+            logger.info(f"BASEROW SEARCH: Clé API: {api_key[:8]}... | URL: {url} | Résultats Baserow: {num_results}")
+            
+            if data and 'results' in data and num_results > 0:
+                # Filtrage manuel des résultats pour vérifier la clé exacte
+                for row in data['results']:
+                    # Vérifier si la clé API correspond à l'un des 5 champs
+                    if any(row.get(field) == api_key for field in API_KEY_FIELDS):
+                        # NOUVEAU LOG : SUCCÈS - L'utilisateur a été trouvé
+                        logger.info(f"BASEROW SUCCESS: Utilisateur trouvé avec la clé API {api_key[:8]}... dans un des 5 champs.")
+                        try:
+                            # On suppose que _baserow_record_to_user existe et prend un booléen
+                            return _baserow_record_to_user(row, is_end_user=False)
+                        except NameError:
+                            logger.error("_baserow_record_to_user non définie. Erreur critique.")
+                            return None
+                
+                # NOUVEAU LOG : ÉCHEC DU FILTRAGE
+                logger.warning(f"BASEROW FILTER FAIL: {num_results} ligne(s) trouvée(s) par 'search' Baserow, mais aucune ne correspondait exactement à la clé API: {api_key[:8]}...")
+                return None 
+            
+            # Aucune ligne trouvée dans Baserow (num_results est 0)
+            logger.debug(f"BASEROW NO RESULT: Aucune ligne trouvée par la recherche Baserow pour la clé API: {api_key[:8]}...")
+            return None 
+
+        # Traiter les erreurs HTTP de Baserow (log déjà dans _make_baserow_request)
+        return None
+        
+    except Exception as e:
+        # Erreur inattendue pendant le traitement
+        logger.error(f"Erreur CRITIQUE lors du traitement de la recherche par clé API: {e}", exc_info=True)
+        return None
+
+# Remplacement de l'ancien load_primary_user_data(user_id)
+def load_primary_user_data(user_id: str) -> Optional[Dict]:
+    """Recherche un utilisateur principal par son ID (user_id)."""
+    return _get_single_user_record(PRIMARY_USERS_TABLE_ID, FIELD_ID, user_id, is_end_user=False)
+
+
+def save_primary_user_data(user_data: Dict, commit_msg: str = "") -> bool:
+    """Crée ou met à jour un utilisateur principal, avec détection d'erreur ultra-précise."""
+    row_id = user_data.get('baserow_row_id')
+    
+    # Définition de l'URL de base pour la table des utilisateurs principaux
+    url = _get_table_url(PRIMARY_USERS_TABLE_ID)
+    
+    # 1. Conversion des données
+    baserow_data = _user_to_baserow_data(user_data, is_end_user=False)
+    
+    # 2. Suppression des champs en lecture seule (comme dans la correction précédente)
+    if baserow_data.pop(FIELD_ID, None):
+        print(f"DEBUG: Suppression du champ '{FIELD_ID}' (UUID auto) avant l'envoi { 'POST' if not row_id else 'PATCH'}.", file=sys.stderr)
+    
+    try:
+        # Détermination de l'action (PATCH ou POST)
+        if row_id:
+            action = "PATCH" # ⬅️ CORRECTION: Définition de 'action'
+            # MISE À JOUR (PATCH)
+            response = requests.patch(
+                f"{url}{row_id}/?user_field_names=true",
+                headers=HEADERS, 
+                json=baserow_data
+            )
+        else:
+            action = "POST" # ⬅️ CORRECTION: Définition de 'action'
+            # CRÉATION (POST)
+            response = requests.post(
+                f"{url}?user_field_names=true", # ⬅️ CORRECTION: Utilise l'URL de table 'url'
+                headers=HEADERS, 
+                json=baserow_data
+            )
+        
+        # Déclenche une exception requests.exceptions.HTTPError pour les statuts 4xx/5xx
+        response.raise_for_status() 
+        
+        # Succès
+        if not row_id:
+            new_record = response.json()
+            # 1. Mettre à jour l'ID de ligne Baserow
+            user_data['baserow_row_id'] = new_record.get('id')
+            # 2. Mettre à jour l'UUID de l'utilisateur (généré par Baserow)
+            user_data['user_id'] = new_record.get(FIELD_ID) 
+            
+            print(f"DEBUG: UUID de l'utilisateur généré par Baserow et enregistré: {user_data['user_id']}", file=sys.stderr)
+            
+        print(f"DEBUG: Baserow Primary User action '{action}' réussie. Row ID: {user_data.get('baserow_row_id')}. Message: {commit_msg}", file=sys.stderr)
+        return True
+        
+    except requests.exceptions.RequestException as e:
+        # --- BLOC DE DÉTECTION D'ERREUR PRÉCISE (Ultra-Complet) ---
+        
+        # Note: 'action' est définie dans le bloc try/except, mais si l'erreur survient 
+        # AVANT la définition de 'action', nous devons la gérer. 
+        # Pour être sûr, nous allons la définir ici par défaut si elle n'existe pas.
+        if 'action' not in locals():
+            action = "INCONNU"
+            
+        error_message = f"🚨 ÉCHEC: Erreur lors de la sauvegarde/mise à jour du Primary User dans Baserow. Requête: {action}"
+        error_details = ""
+
+        if hasattr(e, 'response') and e.response is not None:
+            # 1. Statut HTTP et URL
+            error_details += f"\n  -> STATUT HTTP: {e.response.status_code} ({e.response.reason})"
+            error_details += f"\n  -> URL de la requête: {e.response.url}"
+            
+            # 2. Tenter de décoder le corps de la réponse en JSON (contient les erreurs Baserow)
+            try:
+                response_json = e.response.json()
+                error_details += f"\n\n  -> ERREUR BASEROW DÉTAILLÉE (JSON):\n{json.dumps(response_json, indent=4)}"
+                
+                # Optionnel: Synthèse des erreurs de validation de champ
+                if isinstance(response_json, dict):
+                    validation_errors = {k: v for k, v in response_json.items() if isinstance(v, list) and k != 'detail'}
+                    if validation_errors:
+                        error_details += "\n  -> SYNTHÈSE DES CHAMPS INVALIDES (Vérifiez les noms de colonnes/IDs de table!):"
+                        for field_name, errors in validation_errors.items():
+                             error_details += f"\n    - Champ '{field_name}': {', '.join([err.get('error', 'Erreur inconnue') for err in errors])}"
+                    
+            except json.JSONDecodeError:
+                # 3. Si le corps de la réponse n'est pas du JSON
+                error_details += f"\n\n  -> ERREUR BRUTE (Réponse non-JSON):\n{e.response.text[:500]}..."
+
+        # 4. Afficher les données que nous avons tenté d'envoyer (après la suppression de l'ID si c'était une création)
+        error_details += f"\n\n  -> DONNÉES ENVOYÉES À BASEROW:\n{json.dumps(baserow_data, indent=4)}"
+        
+        # Log complet de l'erreur
+        print(error_message + error_details, file=sys.stderr)
+        
+        return False
+        
+        
+# ----------------------------------------------------------------------
+# --- Fonctions CRUD End_Users (Remplacement) ---
+# ----------------------------------------------------------------------
+
+# baserow_storage.py : Dans la section CRUD End_Users
+
+
+def _get_client_baserow_row_id(client_user_id: str) -> Optional[int]:
+    """Récupère l'ID de ligne interne Baserow du client principal pour le lien."""
+    client_user = load_primary_user_data(client_user_id) # utilise la fonction déjà créée
+    return client_user.get('baserow_row_id') if client_user else None
+
+
+def check_baserow_connection() -> str:
+    """
+    Vérifie l'état de connexion de la base de données Baserow.
+    Retourne 'operational' ou 'outage'.
+    """
+    # Liste des IDs de tables critiques à vérifier
+    CRITICAL_TABLE_IDS = [
+        PRIMARY_USERS_TABLE_ID, 
+        END_USERS_TABLE_ID
+    ]
+    
+    if not API_TOKEN:
+        # Si le token API n'est pas défini, échec immédiat
+        print("DEBUG: BASEROW_API_TOKEN manquant.", file=sys.stderr)
+        return "outage" 
+
+    for table_id in CRITICAL_TABLE_IDS:
+        if not table_id:
+            # Si un des IDs de table critiques n'est pas défini, échec
+            print(f"DEBUG: Un ID de table critique Baserow est manquant (ID: {table_id}).", file=sys.stderr)
+            return "outage"
+
+        # Tenter de faire un appel très léger (récupérer la première ligne)
+        # On utilise page_size=1 pour minimiser la charge
+        url = f"{DATA_BASE_URL}table/{table_id}/?page_size=1"
+        
+        try:
+            response = requests.get(url, headers=HEADERS, timeout=5)
+            
+            if response.status_code != 200:
+                # Si un 404, 403, ou autre erreur est retournée par Baserow pour CETTE table
+                print(f"DEBUG: Baserow check failed for table {table_id} with status code {response.status_code}", file=sys.stderr)
+                return "outage"
+                
+        except requests.exceptions.RequestException as e:
+            # Erreur de réseau (timeout, DNS, etc.)
+            print(f"DEBUG: Baserow connection error for table {table_id}: {e}", file=sys.stderr)
+            return "outage"
+            
+    # Si toutes les tables critiques ont été vérifiées avec succès
+    return "operational"
+
+
+def get_health_status() -> Dict:
+    """
+    Collecte l'état de santé de tous les services pour la page /statut.
+    """
+    
+    db_status = check_baserow_connection()
+    
+    # L'état de l'authentification et de l'API principale sont 
+    # généralement liés à l'état de la DB pour une application simple.
+    # Si la DB est HS, l'auth est HS. Sinon, ils sont OK.
+    
+    auth_status = db_status # Lié à la DB (pour charger les utilisateurs)
+    api_endpoint_status = "operational" # L'endpoint Flask lui-même est considéré comme OK s'il tourne
+    
+    # Version du service (pour information)
+    service_version = os.environ.get("SERVICE_VERSION", "1.0.0 (Baserow)")
+
+
+    return {
+        # Ces valeurs correspondent aux attributs 'data-status' dans statut.html
+        "auth": auth_status, 
+        "data_storage": db_status, 
+        "api_endpoint": api_endpoint_status,
+        "version": service_version,
+        "last_update": datetime.now().strftime("%Y-%m-%d %H:%M:%S UTC")
+    }
+
+def is_baserow_up() -> bool:
+    """
+    Vérifie l'état de Baserow en utilisant l'URL qui garantit un statut 100% fonctionnel
+    sur Hugging Face, SANS utiliser la fonction de construction d'URL de table.
+    """
+    try:
+        # Envoie une requête GET à l'URL qui répond positivement pour le health check.
+        response = requests.get(
+            HEALTH_CHECK_URL,
+            headers=HEADERS,
+            timeout=5
+        )
+        # On vérifie si la réponse est un succès (code 200).
+        return response.status_code == 200
+    except requests.exceptions.RequestException as e:
+        print(f"DEBUG: Baserow health check failed: {e}")
+        return False
+
+def _make_baserow_request(method: str, url: str, params: Optional[Dict] = None, data: Optional[Dict] = None, log_response: bool = True):
+    """
+    Fonction utilitaire pour effectuer des appels API à Baserow et journaliser 
+    les requêtes et les réponses dans les logs du Space Hugging Face.
+    """
+    # 1. Journalisation de la requête
+    logger.info(f"BASEROW REQUEST: {method} {url}")
+    # ATTENTION: Ne pas logger le token API complet!
+    logged_headers = {k: v.replace(API_TOKEN, '[TOKEN_MASKED]') if k == 'Authorization' else v for k, v in HEADERS.items()}
+    logger.debug(f"BASEROW REQUEST Headers: {logged_headers}")
+    if data:
+        # Pour les requêtes POST/PUT, logger les données (sans le hash du mot de passe si possible)
+        logged_data = data.copy() if isinstance(data, dict) else data
+        # 'Hachage Mot de Passe' est le nom du champ dans _user_to_baserow_data
+        if isinstance(logged_data, dict) and FIELD_PASSWORD_HASH in logged_data: 
+             logged_data[FIELD_PASSWORD_HASH] = '[PASSWORD_HASH_MASKED]'
+        # Le nom du champ n'était pas le même dans l'ancienne version, on utilise la constante
+        if isinstance(logged_data, dict) and 'Hachage du mot de passe' in logged_data:
+             logged_data['Hachage du mot de passe'] = '[PASSWORD_HASH_MASKED]'
+        logger.debug(f"BASEROW REQUEST Body: {logged_data}")
+    
+    # 2. Exécution de la requête
+    try:
+        # NOTE IMPORTANTE: Utilisation des HEADERS globaux et des 'params' pour GET
+        if method == "GET":
+            response = requests.get(url, headers=HEADERS, params=params)
+        elif method == "POST":
+            response = requests.post(url, headers=HEADERS, json=data)
+        elif method == "PUT":
+            response = requests.put(url, headers=HEADERS, json=data)
+        elif method == "DELETE":
+            response = requests.delete(url, headers=HEADERS)
+        elif method == "PATCH": # Ajout de la méthode PATCH pour la complétude
+            response = requests.patch(url, headers=HEADERS, json=data)
+        else:
+            raise ValueError(f"Méthode HTTP non supportée: {method}")
+        
+        # 3. Journalisation de la réponse
+        if log_response:
+            logger.info(f"BASEROW RESPONSE: Status {response.status_code}")
+            # Journaliser le contenu pour les erreurs
+            if response.status_code >= 400:
+                logger.error(f"BASEROW ERROR RESPONSE Body: {response.text}")
+                
+        # 4. Retourner la réponse
+        return response
+        
+    except requests.exceptions.RequestException as e:
+        logger.error(f"BASEROW CONNECTION ERROR: {e}")
+        # Retourne un objet Response factice pour l'utiliser dans la fonction appelante
+        return requests.Response()
+
+# --- NOUVELLES FONCTIONS POUR LES DÉPLOIEMENTS (Projets) ---
+
+
+
+def update_user_deployment_data(
+    user_baserow_row_id: int, 
+    deploy_id: str, 
+    user_link: str, # Utilisera l'ID interne de l'utilisateur
+    hf_repo_path: str
+) -> tuple[bool, str]:
+    """
+    Met à jour la ligne de l'utilisateur principal (PRIMARY_USERS_TABLE_ID) 
+    avec les données de déploiement du projet (ID, Repo, etc.).
+    """
+    if not PRIMARY_USERS_TABLE_ID:
+        return False, "Erreur de configuration: ID de la table utilisateur principal manquant."
+
+    url = f"{DATA_BASE_URL}table/{PRIMARY_USERS_TABLE_ID}/{user_baserow_row_id}/"
+    
+    # Les données à mettre à jour
+    data = {
+        FIELD_DEPLOY_ID: deploy_id,
+        FIELD_USER_REF: user_link,
+        FIELD_HF_REPO_PATH: hf_repo_path
+    }
+
+    # Utiliser PATCH pour mettre à jour seulement les champs spécifiés
+    response = _baserow_request(url, method="PATCH", data=data)
+    
+    if response.status_code == 200:
+        logger.info(f"Déploiement ID {deploy_id} enregistré sur l'utilisateur Row ID {user_baserow_row_id}.")
+        return True, "Données de déploiement enregistrées avec succès sur le compte utilisateur."
+    else:
+        logger.error(f"Échec de la mise à jour du déploiement Baserow pour l'utilisateur {user_baserow_row_id}. Status: {response.status_code}, Body: {response.text}")
+        return False, f"Échec de la mise à jour Baserow: {response.status_code}"
+
+
+# ----------------------------------------------------------------------
+# --- MODIFICATION DE FONCTION : Récupérer le déploiement par ID ---
+# La recherche doit maintenant se faire dans la table utilisateur.
+# ----------------------------------------------------------------------
+def get_deployment_by_id(deploy_id: str) -> Optional[Dict]:
+    """
+    Récupère les détails du déploiement (la ligne de l'utilisateur) par son ID unique (le nom du dossier HF).
+    """
+    if not PRIMARY_USERS_TABLE_ID:
+        return None
+        
+    # Utiliser un filtre Baserow pour chercher par l'ID de déploiement dans la table utilisateur
+    url = f"{DATA_BASE_URL}table/{PRIMARY_USERS_TABLE_ID}/"
+    
+    # Construction du filtre Baserow: filter__Deployment ID__equal={deploy_id}
+    filter_param = f"filter__{FIELD_DEPLOY_ID}__equal"
+    params = {
+        filter_param: deploy_id
+    }
+    
+    response = _baserow_request(url, method="GET", params=params)
+    
+    if response.status_code == 200:
+        results = response.json().get('results', [])
+        if results:
+            # Retourne les données de l'utilisateur contenant les données de déploiement
+            # Notez que cela renvoie la ligne utilisateur complète.
+            return results[0] 
+        else:
+            return None
+    else:
+        logger.error(f"Échec de la récupération du déploiement Baserow. Status: {response.status_code}, Body: {response.text}")
+        return None
+
+def save_new_repository(
+    user_id: int, 
+    repo_data: Dict
+) -> tuple[bool, str]:
+    """
+    Ajoute un nouveau dépôt à la liste 'FIELD_REPOS_DATA' de l'utilisateur.
+    Ceci remplace l'ancienne approche 'save_new_deployment' qui supposait un seul déploiement par utilisateur.
+    """
+    
+    user_record = load_primary_user_data(filters={FIELD_ID: user_id}, single_record=True)
+    if not user_record:
+        logger.error(f"Utilisateur ID '{user_id}' non trouvé pour l'enregistrement du dépôt.")
+        return False, "Utilisateur non trouvé."
+
+    row_id = user_record.get('id')
+    if not row_id:
+        return False, f"Erreur critique: ID de ligne Baserow manquant pour l'utilisateur '{user_id}'."
+
+    # 1. Récupérer et désérialiser la liste des dépôts existants
+    repos_json = user_record.get(FIELD_REPOS_DATA)
+    try:
+        # Baserow renvoie 'None' ou une chaîne vide si le champ est vide
+        existing_repos = json.loads(repos_json) if repos_json and isinstance(repos_json, str) else []
+    except json.JSONDecodeError:
+        logger.warning(f"Champs Repositories Data corrompu pour l'utilisateur {user_id}. Réinitialisation.")
+        existing_repos = []
+
+    # 2. Ajouter le nouveau dépôt
+    existing_repos.append(repo_data)
+
+    # 3. Sérialiser la liste mise à jour
+    updated_repos_json = json.dumps(existing_repos)
+
+    # 4. Mettre à jour Baserow
+    url = f"{DATA_BASE_URL}table/{PRIMARY_USERS_TABLE_ID}/{row_id}/"
+    data = {
+        FIELD_REPOS_DATA: updated_repos_json
+    }
+
+    response = _make_baserow_request(
+        method="PATCH", 
+        url=url, 
+        data=data,
+        log_response=True
+    )
+
+    if response.status_code == 200:
+        logger.info(f"Nouveau dépôt '{repo_data['repo_name']}' enregistré pour l'utilisateur ID {user_id}.")
+        return True, "Dépôt enregistré avec succès."
+    else:
+        # Gérer l'échec de la mise à jour (ex: données trop volumineuses ou erreur API)
+        error_message = response.text
+        logger.error(f"Échec de l'enregistrement du dépôt pour l'utilisateur {user_id}: {error_message}")
+        return False, f"Échec de la mise à jour Baserow: {error_message}"
+
+# Nouvelle fonction pour récupérer la liste de tous les dépôts d'un utilisateur
+def get_all_user_repositories(user_id: int) -> list:
+    """Récupère tous les dépôts d'un utilisateur depuis le champ JSON."""
+    user_record = load_primary_user_data(filters={FIELD_ID: user_id}, single_record=True)
+    if not user_record:
+        return []
+        
+    repos_json = user_record.get(FIELD_REPOS_DATA)
+    try:
+        return json.loads(repos_json) if repos_json and isinstance(repos_json, str) else []
+    except json.JSONDecodeError:
+        logger.warning(f"Champs Repositories Data corrompu pour l'utilisateur {user_id}.")
+        return []
+
+
+def delete_deployment_by_id(deploy_id: str) -> tuple[bool, str]:
+    """
+    Supprime l'enregistrement d'un déploiement (la ligne utilisateur) 
+    dans la table PRIMARY_USERS_TABLE_ID par le Deployment ID.
+    
+    Note: Cela supprime la ligne utilisateur complète. Si la structure 
+    change (1 utilisateur -> plusieurs déploiements), cela devra être adapté.
+    Pour l'instant, on suppose 1 utilisateur = 1 ligne = 1 déploiement.
+    
+    Version modifiée pour mettre à NULL les champs de déploiement au lieu de supprimer la ligne utilisateur.
+    """
+    # 1. Récupérer l'enregistrement de l'utilisateur par l'ID de déploiement (le dossier HF)
+    user_record = get_deployment_by_id(deploy_id) 
+    
+    if not user_record:
+        logger.warning(f"Tentative de suppression de déploiement échouée: ID '{deploy_id}' non trouvé dans Baserow.")
+        return True, "Déploiement non trouvé dans Baserow (considéré comme déjà supprimé)."
+
+    # 2. Récupérer l'ID de ligne Baserow pour la mise à jour
+    row_id = user_record.get('id')
+    
+    if not row_id:
+        return False, f"Erreur critique: ID de ligne Baserow manquant pour le déploiement '{deploy_id}'."
+        
+    # 3. Mettre à jour les champs de déploiement à NULL (ou vide) au lieu de supprimer la ligne utilisateur
+    # Note: On suppose que la suppression de déploiement réinitialise ces champs.
+    url = f"{DATA_BASE_URL}table/{PRIMARY_USERS_TABLE_ID}/{row_id}/"
+    data = {
+        FIELD_DEPLOY_ID: None,
+        FIELD_USER_REF: None,
+        FIELD_HF_REPO_PATH: None
+    }
+    
+    response = _make_baserow_request(
+        method="PATCH", 
+        url=url, 
+        data=data,
+        log_response=True
+    )
+    
+    if response.status_code == 200:
+        logger.info(f"Déploiement ID {deploy_id} supprimé (champs mis à NULL) sur l'utilisateur Row ID {row_id}.")
+        return True, "Déploiement supprimé de la base de données avec succès."
+    else:
+        logger.error(f"Échec de la suppression du déploiement Baserow (PATCH à NULL) pour l'utilisateur Row ID {row_id}. Status: {response.status_code}, Body: {response.text}")
+        return False, f"Échec de la suppression Baserow: {response.status_code}"
+
+# baserow_storage.py - NOUVELLES FONCTIONS DE VÉRIFICATION DE CHAMPS
+
+# --- Liste des Champs Critiques pour la Table Primary Users (pour la vérification) ---
+# Ces champs sont nécessaires pour le fonctionnement global de l'app (Connexion, Profil, Déploiement)
+CRITICAL_PRIMARY_USER_FIELDS = [
+    # Primary User Fields (Fonctions Utilisateur)
+    FIELD_ID,
+    FIELD_EMAIL,
+    FIELD_USERNAME,
+    FIELD_PASSWORD_HASH,
+    FIELD_API_KEY,
+    FIELD_API_KEY_2,
+    FIELD_API_KEY_3,
+    FIELD_API_KEY_4,
+    FIELD_API_KEY_5,
+    FIELD_SECURITY_Q,
+    FIELD_SECURITY_A_HASH,
+    FIELD_PLAN_ID,
+    FIELD_STRIPE_SUB_ID,
+    FIELD_DATE_CREATION,
+    FIELD_DATE_PLAN_START,
+    FIELD_API_CALLS_MONTH,
+    FIELD_STATUS,
+]
+
+def _get_table_fields_url(table_id: str) -> str:
+    """Construit l'URL d'API pour lister les champs (colonnes) d'une table."""
+    # L'endpoint pour lister les champs est généralement /api/database/fields/table/{table_id}/
+    return f"https://api.baserow.io/api/database/fields/table/{table_id}/"
+
+def check_critical_fields_existence() -> str:
+    """
+    Vérifie que tous les champs critiques requis sont présents dans la table PRIMARY_USERS_TABLE_ID.
+    Retourne "operational" ou un message d'erreur listant les champs manquants.
+    """
+    if not API_TOKEN or not PRIMARY_USERS_TABLE_ID:
+        return "Configuration Baserow incomplète (Token ou ID de Table Manquant)."
+    
+    table_id = PRIMARY_USERS_TABLE_ID
+    url = _get_table_fields_url(table_id)
+    
+    try:
+        # Assurez-vous d'utiliser une fonction de requête qui gère l'authentification (e.g., _make_baserow_request si elle existe)
+        # Ici, nous utilisons directement requests pour un exemple clair.
+        response = requests.get(url, headers=HEADERS, timeout=10)
+        response.raise_for_status() # Lève une exception pour les codes d'erreur HTTP (4xx, 5xx)
+        
+        fields_data = response.json().get('results', [])
+        
+        # 1. Obtenir les noms des champs existants
+        existing_field_names = {field.get('name') for field in fields_data if 'name' in field}
+        
+        # 2. Identifier les champs manquants
+        missing_fields = [
+            field_name for field_name in CRITICAL_PRIMARY_USER_FIELDS 
+            if field_name not in existing_field_names
+        ]
+        
+        if missing_fields:
+            missing_str = ", ".join(missing_fields)
+            logger.error(f"Champs Baserow Manquants dans la table {table_id}: {missing_str}")
+            return f"CHAMPS BASEROW MANQUANTS: {missing_str}. Veuillez les créer."
+        
+        logger.info(f"SUCCÈS: Tous les {len(CRITICAL_PRIMARY_USER_FIELDS)} champs critiques Baserow sont trouvés.")
+        return "operational"
+
+    except requests.exceptions.HTTPError as e:
+        # Gérer l'erreur 404 si la table n'existe pas, ou 401/403 si le token est invalide
+        logger.error(f"Échec de l'API Baserow lors de la vérification des champs pour la table {table_id}: {e}")
+        return f"ÉCHEC API LORS DE LA VÉRIFICATION DES CHAMPS (Statut: {e.response.status_code}). Le token ou l'ID de table est probablement incorrect."
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Erreur de connexion lors de la vérification des champs Baserow: {e}")
+        return f"ERREUR RÉSEAU/TIMEOUT lors de la vérification des champs Baserow: {e}"
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors de la vérification des champs Baserow: {e}")
+        return f"ERREUR INATTENDUE: {e}"
+
+

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/billing_routes.py

@@ -0,0 +1,137 @@
+# billing_routes.py
+
+import os
+import stripe
+import json
+from flask import Blueprint, request, jsonify, Response, session, current_app, url_for
+from decorators import login_required 
+from auth_backend import get_user_by_id, get_plan_details, update_user_plan
+import traceback
+
+# Initialisation de Stripe avec la clé secrète
+# La clé sera lue depuis les variables d'environnement (secrets HF)
+stripe.api_key = os.environ.get("STRIPE_SECRET_KEY")
+
+# Création du Blueprint 'billing_bp'
+billing_bp = Blueprint('billing_bp', __name__)
+
+# --- Route API pour créer la session de paiement (Phase 3) ---
+@billing_bp.route("/api/create-checkout-session", methods=["POST"])
+@login_required
+def create_checkout_session():
+    """
+    Crée une session de checkout Stripe pour un plan donné.
+    """
+    data = request.get_json()
+    # Le plan_id doit être l'ID complet (ex: 'standard_monthly' ou 'illimited_annual')
+    final_plan_id = data.get('plan_id') 
+    user_id = session.get('user_id')
+    
+    plan_details = get_plan_details(final_plan_id)
+    
+    # Détermination de l'ID de prix Stripe (utilise monthly ou annual selon ce qui est défini)
+    price_id = plan_details.get('price_id_monthly') or plan_details.get('price_id_annual')
+
+    # Vérification de l'existence du plan et de l'ID de prix Stripe
+    if not plan_details or not price_id:
+        if final_plan_id == 'free':
+             return jsonify({"message": "Ce plan est gratuit, pas de session de paiement requise.", "url": url_for('user_bp.dashboard')}), 200
+        
+        # Logique de sécurité/erreur si l'ID de prix est manquant pour un plan payant
+        current_app.logger.error(f"Erreur: ID de prix Stripe manquant pour le plan {final_plan_id}.")
+        return jsonify({"message": "Erreur de configuration du plan.", "status": "Error"}), 500
+
+    try:
+        # Création de la session de paiement Stripe
+        checkout_session = stripe.checkout.Session.create(
+            # Type de paiement pour les abonnements récurrents
+            mode='subscription', 
+            # Les IDs de prix Stripe
+            line_items=[
+                {
+                    'price': price_id, 
+                    'quantity': 1
+                }
+            ],
+            # URLs de redirection après paiement/annulation
+            # _external=True est crucial pour que Stripe puisse rediriger correctement
+            success_url=url_for('user_bp.dashboard', payment='success', _external=True),
+            cancel_url=url_for('web_bp.checkout', plan=final_plan_id, payment='cancel', _external=True),
+            
+            # Informations personnalisées CRITIQUES pour le Webhook
+            metadata={
+                'user_id': user_id,
+                'plan_id': final_plan_id, # L'ID de plan complet (e.g. 'standard_monthly')
+            },
+            # Laisse Stripe pré-remplir l'email du client (si on le souhaite)
+            # customer_email=get_user_by_id(user_id).get('email'), 
+        )
+        
+        # Retourne l'URL de la session Stripe au frontend
+        return jsonify({'url': checkout_session.url}), 200
+
+    except stripe.error.StripeError as e:
+        current_app.logger.error(f"Erreur Stripe lors de la création de session: {e}")
+        return jsonify({"message": f"Une erreur Stripe est survenue: {e.user_message}", "status": "Error"}), 400
+    except Exception as e:
+        # Log toutes les autres erreurs pour le diagnostic
+        current_app.logger.error(f"Erreur inattendue lors de la création de session: {e}\n{traceback.format_exc()}")
+        return jsonify({"message": "Erreur interne du serveur lors de la création de la session.", "status": "Error"}), 500
+
+
+# --- Route Webhook Stripe (Phase 4) ---
+@billing_bp.route('/webhook/stripe', methods=['POST'])
+def stripe_webhook():
+    """
+    Gère les événements envoyés par Stripe pour mettre à jour l'abonnement de l'utilisateur.
+    """
+    payload = request.data
+    sig_header = request.headers.get('stripe-signature')
+    endpoint_secret = os.environ.get("STRIPE_WEBHOOK_SECRET")
+
+    # 1. Vérification que le secret est bien configuré
+    if not endpoint_secret:
+        current_app.logger.error("Erreur de configuration: STRIPE_WEBHOOK_SECRET est manquant.")
+        return jsonify({'message': 'Erreur de configuration serveur.'}), 500
+
+    try:
+        # 2. Validation de la signature du Webhook
+        event = stripe.Webhook.construct_event(
+            payload, sig_header, endpoint_secret
+        )
+    except Exception as e:
+        current_app.logger.error(f"Erreur Webhook Stripe (Validation): {e}")
+        # Retourne 400 pour que Stripe sache qu'il ne doit pas retenter cet événement
+        return 'Invalid payload or signature', 400
+
+    # 3. Traitement des événements
+    if event['type'] == 'checkout.session.completed':
+        session_data = event['data']['object']
+        
+        # Récupération des métadonnées CRITIQUES
+        user_id = session_data.get('metadata', {}).get('user_id')
+        plan_id = session_data.get('metadata', {}).get('plan_id') # L'ID de plan complet (e.g. 'standard_monthly')
+        subscription_id = session_data.get('subscription') # L'ID d'abonnement Stripe
+        
+        if user_id and plan_id and subscription_id:
+            # Appel à la fonction de mise à jour de la base de données (Phase 4)
+            success = update_user_plan(user_id, plan_id, subscription_id)
+            
+            if success:
+                current_app.logger.info(f"SUCCESS: Utilisateur {user_id} mis à jour au plan {plan_id} (Sub ID: {subscription_id})")
+            else:
+                # Le paiement a eu lieu, mais la BDD n'a pas été mise à jour: CRITIQUE
+                current_app.logger.error(f"FAILURE: Échec de la mise à jour Git pour l'utilisateur {user_id} après paiement Stripe. Plan: {plan_id}")
+        else:
+             # Manque d'infos critiques dans le webhook
+             current_app.logger.error(f"FAILURE: Données critiques manquantes dans le webhook. Session ID: {session_data.get('id')}. User ID: {user_id}. Plan ID: {plan_id}")
+             # Retourne 200 pour éviter une boucle de ré-envoi par Stripe
+             return jsonify({'message': 'Données utilisateur critiques manquantes dans la session Stripe.'}), 200 
+             
+    # Vous pouvez ajouter d'autres événements si nécessaire (ex: 'customer.subscription.deleted')
+    # elif event['type'] == 'customer.subscription.deleted':
+    #     current_app.logger.info(f"INFO: Abonnement Stripe supprimé. ID de souscription: {event['data']['object'].get('id')}")
+
+
+    # Retourne une réponse pour accuser réception de l'événement (très important)
+    return jsonify({'status': 'success'}), 200

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/config.py

@@ -0,0 +1,122 @@
+# config.py
+
+# Fichier de configuration pour le backend ErnestMind 2.5
+import os
+
+# --- Configuration Baserow (Nouveau) ---
+# Clés à définir dans les secrets d'environnement Hugging Face Space
+BASEROW_DATABASE_ID = os.environ.get("BASEROW_DATABASE_ID") 
+PRIMARY_USERS_TABLE_ID = os.environ.get("PRIMARY_USERS_TABLE_ID") 
+END_USERS_TABLE_ID = os.environ.get("END_USERS_TABLE_ID")
+# Le token d'accès API
+BASEROW_API_TOKEN = os.environ.get("BASEROW_API_TOKEN")
+
+# --- Configuration Stripe (Paiement) ---
+# Clés à définir dans les secrets d'environnement Hugging Face Space
+STRIPE_SECRET_KEY = os.environ.get("STRIPE_SECRET_KEY")
+STRIPE_WEBHOOK_SECRET = os.environ.get("STRIPE_WEBHOOK_SECRET")
+# Clé Publique (utilisée par le Frontend, mais stockée ici pour référence)
+STRIPE_PUBLIC_KEY = os.environ.get("STRIPE_PUBLIC_KEY")
+# --- Configuration Hugging Face (NOUVEAU: PRs) ---
+HF_DATASET_REPO_ID = os.environ.get("HF_DATASET_REPO_ID") # Déjà existant
+# NOUVELLE VARIABLE pour le dépôt des métadonnées de Pull Requests
+PULL_REQUESTS_HF_REPO_ID = os.environ.get("PULL_REQUESTS_HF_REPO_ID")
+# NOUVELLE VARIABLE pour le dépôt des métadonnées des Issues
+ISSUES_HF_REPO_ID = os.environ.get("ISSUES_HF_REPO_ID")
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+HF_TOKEN = os.environ.get("HF_TOKEN")
+GRMINI_HF_REPO_ID = os.environ.get("GEMINI_HF_REPO_ID")
+# ID du Dataset Hugging Face dédié au stockage d'images
+IMAGE_STORAGE_HF_REPO_ID = os.environ.get("IMAGE_STORAGE_HF_REPO_ID")
+# Les 'price_id' doivent correspondre aux IDs créés dans Stripe.
+PLANS_CONFIG = {
+    # Plan Gratuit
+    "free": {
+        "title": "Gratuit",
+        "baserow_value": "Free", # <--- NOUVEAU: Mettre la valeur EXACTE attendue par Baserow (ex: GRATUIT, Free, etc.)
+        "description": "Idéal pour les tests et les petits projets.",
+        "limit": 500,
+        "price_monthly": 0.0,
+        "price_annual": 0.0,
+        "price_id_monthly": None, 
+        "price_id_annual": None,  
+        "currency": "EUR"
+    },
+    # Plan Standard - Mensuel
+    "standard_monthly": {
+        "title": "Standard (Mensuel)",
+        "description": "Pour les utilisateurs réguliers. Paiement mensuel.",
+        "limit": 1000,
+        "price_monthly": 19.99,
+        "price_annual": 0.0,
+        "price_id_monthly": "price_1OvXXXXXXX", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+    # Plan Standard - Annuel
+    "standard_annual": {
+        "title": "Standard (Annuel)",
+        "description": "Pour les utilisateurs réguliers. Économisez 20% en payant à l'année.",
+        "limit": 1000,
+        "price_monthly": 0.0,
+        "price_annual": 199.90, 
+        "price_id_monthly": None,
+        "price_id_annual": "price_1OwYYYYYYY", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "currency": "EUR"
+    },
+    # Plan Pro - Mensuel
+    "pro_monthly": {
+        "title": "Pro (Mensuel)",
+        "description": "Pour les professionnels et les projets importants. Paiement mensuel.",
+        "limit": 2000,
+        "price_monthly": 49.99,
+        "price_annual": 0.0,
+        "price_id_monthly": "price_1OxZZZZZZZ", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+    # Plan Pro - Annuel
+    "pro_annual": {
+        "title": "Pro (Annuel)",
+        "description": "Pour les professionnels et les projets importants. Économisez 20% en payant à l'année.",
+        "limit": 2000,
+        "price_monthly": 0.0,
+        "price_annual": 499.90, 
+        "price_id_monthly": None,
+        "price_id_annual": "price_1OyAAAAAAA", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "currency": "EUR"
+    },
+    # Plan Illimité - Mensuel
+    "illimited_monthly": {
+        "title": "Illimité (Mensuel)",
+        "description": "Sans aucune restriction, pour les grandes entreprises. Paiement mensuel.",
+        "limit": float('inf'),
+        "price_monthly": 99.99,
+        "price_annual": 0.0,
+        "price_id_monthly": "price_1OzBBBBBBB", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+    # Plan Illimité - Annuel
+    "illimited_annual": {
+        "title": "Illimité (Annuel)",
+        "description": "Sans aucune restriction, pour les grandes entreprises. Économisez 20% en payant à l'année.",
+        "limit": float('inf'),
+        "price_monthly": 0.0,
+        "price_annual": 999.90, 
+        "price_id_monthly": None,
+        "price_id_annual": "price_1OzAACCCCC", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "currency": "EUR"
+    },
+    # Plan Spécial pour les End-users (pas listé sur la page de prix)
+    "end_user": {
+        "title": "End-User",
+        "description": "Compte utilisateur créé par un client.",
+        "limit": 0,
+        "price_monthly": 0.0,
+        "price_annual": 0.0,
+        "price_id_monthly": None,
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+}

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/data_processing.py

@@ -0,0 +1,366 @@
+import pandas as pd
+import numpy as np
+import streamlit as st
+import io
+import json
+import hashlib
+import os
+import matplotlib.pyplot as plt
+import seaborn as sns
+import tempfile
+from sklearn.preprocessing import LabelEncoder, StandardScaler, MinMaxScaler
+from sklearn.impute import KNNImputer
+from collections import Counter
+from wordcloud import WordCloud
+import spacy
+import matplotlib.colors as mcolors
+import plotly.express as px
+from sklearn.cluster import KMeans
+from sklearn.ensemble import IsolationForest
+
+from translations import txt, set_language, slugify
+
+
+def _get_themes_file_path():
+    """
+    Retourne le chemin du fichier JSON pour les thèmes.
+    """
+    # Utilise un répertoire temporaire ou le répertoire de l'application Streamlit
+    return os.path.join(tempfile.gettempdir(), 'app_themes.json')
+
+def save_theme_preferences(theme_name, theme_data):
+    """
+    Sauvegarde un thème nommé dans un fichier JSON.
+    """
+    themes_path = _get_themes_file_path()
+    try:
+        if os.path.exists(themes_path):
+            with open(themes_path, 'r', encoding='utf-8') as f:
+                saved_themes = json.load(f)
+        else:
+            saved_themes = {}
+        
+        saved_themes[theme_name] = theme_data
+        
+        with open(themes_path, 'w', encoding='utf-8') as f:
+            json.dump(saved_themes, f, ensure_ascii=False, indent=4)
+        
+        return True, txt("theme_saved_success")
+    except Exception as e:
+        return False, f"{txt('error_saving_theme')} : {e}"
+
+def get_saved_themes():
+    """
+    Récupère les thèmes sauvegardés depuis le fichier JSON.
+    """
+    themes_path = _get_themes_file_path()
+    try:
+        if os.path.exists(themes_path):
+            with open(themes_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return {}
+    except Exception:
+        return {}
+
+def delete_theme_preferences(theme_name):
+    """
+    Supprime un thème nommé du fichier JSON.
+    """
+    themes_path = _get_themes_file_path()
+    try:
+        if os.path.exists(themes_path):
+            with open(themes_path, 'r', encoding='utf-8') as f:
+                saved_themes = json.load(f)
+            
+            if theme_name in saved_themes:
+                del saved_themes[theme_name]
+                with open(themes_path, 'w', encoding='utf-8') as f:
+                    json.dump(saved_themes, f, ensure_ascii=False, indent=4)
+                return True, txt("theme_deleted_success")
+        return False, txt("theme_not_found")
+    except Exception as e:
+        return False, f"{txt('error_deleting_theme')} : {e}"
+
+def update_theme(theme_data):
+    """
+    Applique le thème sélectionné en mettant à jour le fichier de configuration de Streamlit.
+    """
+    st.session_state['theme'] = theme_data
+    # Note: Streamlit doit être relancé pour que le thème s'applique complètement
+    st.rerun()
+
+def read_data_file(file_path, delimiter=','):
+    """
+    Reads a file from a given path and returns a pandas DataFrame.
+    Supports CSV, TXT, JSON, and Excel formats.
+    """
+    try:
+        file_extension = os.path.splitext(file_path)[1].lower()
+        if file_extension in ['.csv', '.txt']:
+            # Essayer différentes encodages si le premier échoue
+            try:
+                df = pd.read_csv(file_path, delimiter=delimiter, encoding='utf-8')
+            except UnicodeDecodeError:
+                df = pd.read_csv(file_path, delimiter=delimiter, encoding='latin1')
+        elif file_extension == '.json':
+            df = pd.read_json(file_path)
+        elif file_extension in ['.xls', '.xlsx']:
+            df = pd.read_excel(file_path)
+        elif file_extension == '.parquet': # Ajout de support pour Parquet
+            df = pd.read_parquet(file_path)
+        elif file_extension == '.orc': # Ajout de support pour ORC
+            df = pd.read_orc(file_path)
+        elif file_extension == '.feather': # Ajout de support pour Feather
+            df = pd.read_feather(file_path)
+        elif file_extension == '.dta': # Ajout de support pour Stata
+            df = pd.read_stata(file_path)
+        elif file_extension == '.sas7bdat': # Ajout de support pour SAS
+            df = pd.read_sas(file_path)
+        else:
+            return None, txt("unsupported_file_type")
+        return df, txt("file_read_success")
+    except Exception as e:
+        return None, f"{txt('error_reading_file')} : {e}"
+
+def get_data_overview(df):
+    """
+    Aperçu général du DataFrame.
+    """
+    return {
+        "rows": df.shape[0],
+        "cols": df.shape[1],
+        "column_types": df.dtypes.to_dict()
+    }
+
+def get_missing_values_summary(df):
+    """
+    Résumé des valeurs manquantes.
+    """
+    missing_data = df.isnull().sum()
+    missing_data = missing_data[missing_data > 0].sort_values(ascending=False)
+    missing_percent = (missing_data / len(df)) * 100
+    missing_summary = pd.DataFrame({'Total': missing_data, 'Pourcentage': missing_percent})
+    return missing_summary
+
+def generate_multicolor_plots(df):
+    """
+    Génère 6 visualisations multicolores pour l'analyse des données.
+    """
+    st.subheader(txt("auto_generated_visualizations_title"))
+
+    numeric_cols = df.select_dtypes(include=np.number).columns.tolist()
+    categorical_cols = df.select_dtypes(include=['object', 'category']).columns.tolist()
+
+    # Définir une palette de couleurs dynamique
+    colors = px.colors.qualitative.Plotly # Utiliser une palette Plotly
+    
+    # 1. Histogramme de distribution pour une colonne numérique clé (ex: Prix ou première numérique)
+    if numeric_cols:
+        col = 'Prix' if 'Prix' in numeric_cols else numeric_cols[0]
+        fig = px.histogram(df, x=col, title=txt("dist_of").format(col=col), color_discrete_sequence=[colors[0]])
+        st.plotly_chart(fig, use_container_width=True)
+    
+    # 2. Bar plot pour la fréquence d'une colonne catégorielle clé (ex: Type_Propriete ou première catégorielle)
+    if categorical_cols:
+        col = 'Type_Propriete' if 'Type_Propriete' in categorical_cols else categorical_cols[0]
+        if not df[col].empty:
+            value_counts_df = df[col].value_counts().reset_index(name='count')
+            fig = px.bar(value_counts_df, x=value_counts_df.columns[0], y='count', title=txt("freq_of").format(col=col), 
+                         color='count', color_continuous_scale=px.colors.sequential.Viridis)
+            st.plotly_chart(fig, use_container_width=True)
+
+    # 3. Scatter plot entre deux colonnes numériques (ex: Surface_m2 vs Prix)
+    if 'Surface_m2' in numeric_cols and 'Prix' in numeric_cols:
+        fig = px.scatter(df, x='Surface_m2', y='Prix', title=txt("scatter_surface_price"), 
+                         color='Type_Propriete' if 'Type_Propriete' in categorical_cols else None,
+                         color_discrete_sequence=colors)
+        st.plotly_chart(fig, use_container_width=True)
+    elif len(numeric_cols) >= 2:
+        fig = px.scatter(df, x=numeric_cols[0], y=numeric_cols[1], title=txt("scatter_generic").format(col1=numeric_cols[0], col2=numeric_cols[1]), 
+                         color=df.columns[0] if df.columns[0] in categorical_cols else None, # Utilise une colonne catégorielle pour la couleur si disponible
+                         color_discrete_sequence=colors)
+        st.plotly_chart(fig, use_container_width=True)
+
+    # 4. Box plot pour une colonne numérique par catégorie (ex: Prix par Localisation)
+    if 'Prix' in numeric_cols and 'Localisation' in categorical_cols:
+        fig = px.box(df, x='Localisation', y='Prix', title=txt("box_price_by_location"), color_discrete_sequence=colors)
+        st.plotly_chart(fig, use_container_width=True)
+    elif numeric_cols and categorical_cols:
+        fig = px.box(df, x=categorical_cols[0], y=numeric_cols[0], title=txt("box_generic").format(num_col=numeric_cols[0], cat_col=categorical_cols[0]), color_discrete_sequence=colors)
+        st.plotly_chart(fig, use_container_width=True)
+
+    # 5. Matrice de corrélation
+    num_df_for_corr = df.select_dtypes(include=np.number)
+    if num_df_for_corr.shape[1] > 1:
+        corr_matrix = num_df_for_corr.corr()
+        fig = px.imshow(corr_matrix, text_auto=True, aspect="auto", 
+                        color_continuous_scale=px.colors.sequential.RdBu,
+                        title=txt("correlation_matrix_title"))
+        st.plotly_chart(fig, use_container_width=True)
+
+    # 6. Sunburst chart pour la hiérarchie catégorielle ou simple pie chart
+    if len(categorical_cols) >= 2:
+        # Créer une hiérarchie fictive pour l'exemple si possible
+        path = [categorical_cols[0], categorical_cols[1]]
+        fig = px.sunburst(df, path=path, title=txt("sunburst_hierarchical"), 
+                          color_discrete_sequence=colors)
+        st.plotly_chart(fig, use_container_width=True)
+    elif categorical_cols:
+        col = categorical_cols[0]
+        fig = px.pie(df, names=col, title=txt("pie_chart_of").format(col=col), 
+                     color_discrete_sequence=colors)
+        st.plotly_chart(fig, use_container_width=True)
+
+
+def generate_data_quality_visualizations(df):
+    """
+    Génère des visualisations pour l'analyse de la qualité des données.
+    Cette fonction est désormais un wrapper pour generate_multicolor_plots et wordcloud.
+    """
+    generate_multicolor_plots(df) # Appelle la nouvelle fonction pour les 6 graphiques
+
+    st.subheader(txt("word_cloud_title"))
+    text_cols = df.select_dtypes(include=['object']).columns
+    if len(text_cols) > 0:
+        st.info(txt("word_cloud_info"))
+        selected_text_col = st.selectbox(txt("select_text_column"), text_cols)
+        text = " ".join(review for review in df[selected_text_col].astype(str).dropna())
+        if text:
+            wordcloud = WordCloud(
+                width=800, 
+                height=400, 
+                background_color='white'
+            ).generate(text)
+            
+            fig, ax = plt.subplots()
+            ax.imshow(wordcloud, interpolation='bilinear')
+            ax.axis('off')
+            st.pyplot(fig)
+        else:
+            st.warning(txt("no_text_data_for_wordcloud"))
+    else:
+        st.write(txt("no_text_columns"))
+
+def generate_ai_report_visualizations(df, shap_values_data, X_test_data):
+    """
+    Generates SHAP visualizations for the AI report section.
+    """
+    if shap_values_data is not None and X_test_data is not None:
+        try:
+            st.markdown("### Importance des Caractéristiques (SHAP)")
+            st.info("Les valeurs SHAP sont calculées pour expliquer l'impact de chaque caractéristique sur la prédiction du modèle. Un graphique récapitulatif est généré pour montrer l'importance globale et la direction de l'impact.")
+            
+            # Convert SHAP values and X_test_data to the correct format for the plot
+            shap_values = shap_values_data
+            # Assurez-vous d'avoir les noms de colonnes réels si possible, sinon utilisez des génériques
+            if isinstance(X_test_data, pd.DataFrame):
+                X_test_display = X_test_data
+            else:
+                X_test_display = pd.DataFrame(X_test_data, columns=[f'col_{i}' for i in range(X_test_data.shape[1])])
+            
+            # SHAP Summary Plot
+            fig, ax = plt.subplots()
+            shap.summary_plot(shap_values, X_test_display, show=False)
+            st.pyplot(fig)
+        except Exception as e:
+            st.error(f"Erreur lors de la génération du graphique SHAP : {e}")
+
+def get_theme_preferences(theme_name):
+    """
+    Récupère un thème spécifique.
+    """
+    themes_path = _get_themes_file_path()
+    try:
+        if os.path.exists(themes_path):
+            with open(themes_path, 'r', encoding='utf-8') as f:
+                saved_themes = json.load(f)
+            return saved_themes.get(theme_name, {})
+        return {}
+    except Exception:
+        return {}
+
+def impute_missing_values(df, method="mean"):
+    """
+    Impute les valeurs manquantes.
+    """
+    df_copy = df.copy()
+    num_cols = df_copy.select_dtypes(include=np.number).columns
+    if method == "mean":
+        df_copy[num_cols] = df_copy[num_cols].fillna(df_copy[num_cols].mean())
+    elif method == "median":
+        df_copy[num_cols] = df_copy[num_cols].fillna(df_copy[num_cols].median())
+    elif method == "knn":
+        imputer = KNNImputer(n_neighbors=5)
+        df_copy[num_cols] = imputer.fit_transform(df_copy[num_cols])
+    return df_copy
+
+def scale_features(df, method="standard"):
+    """
+    Met à l'échelle les caractéristiques numériques.
+    """
+    df_copy = df.copy()
+    num_cols = df_copy.select_dtypes(include=np.number).columns
+    if method == "standard":
+        scaler = StandardScaler()
+    elif method == "minmax":
+        scaler = MinMaxScaler()
+    df_copy[num_cols] = scaler.fit_transform(df_copy[num_cols])
+    return df_copy
+
+def create_polynomial_features(df, degree):
+    """
+    Crée des caractéristiques polynômiales.
+    """
+    # Placeholder pour l'exemple
+    return df
+
+def create_interaction_term(df, col1, col2):
+    """
+    Crée un terme d'interaction.
+    """
+    new_col_name = f"{col1}_{col2}_interaction"
+    df[new_col_name] = df[col1] * df[col2]
+    return df
+
+def extract_datetime_features(df, col, features):
+    """
+    Extrait des caractéristiques de date/heure.
+    """
+    df[col] = pd.to_datetime(df[col])
+    for feature in features:
+        if feature == "year":
+            df[f'{col}_year'] = df[col].dt.year
+        elif feature == "month":
+            df[f'{col}_month'] = df[col].dt.month
+        elif feature == "day":
+            df[f'{col}_day'] = df[col].dt.day
+        # Add more features as needed
+    return df
+
+def apply_aggregation(df, groupby_col, target_col, agg_method):
+    """
+    Applique une agrégation.
+    """
+    agg_df = df.groupby(groupby_col)[target_col].agg(agg_method)
+    return agg_df
+
+def detect_outliers_isolation_forest(df, contamination=0.05):
+    """
+    Détecte les valeurs aberrantes avec Isolation Forest.
+    """
+    num_df = df.select_dtypes(include=np.number)
+    model = IsolationForest(contamination=contamination, random_state=42)
+    df['outlier_score'] = model.fit_predict(num_df)
+    return df
+
+def perform_kmeans_clustering(df, n_clusters=3):
+    """
+    Effectue un clustering K-Means sur les données numériques.
+    """
+    num_df = df.select_dtypes(include=np.number).dropna()
+    if num_df.shape[0] > n_clusters:
+        kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10) # Ajout de n_init
+        df['cluster'] = kmeans.fit_predict(num_df)
+    else:
+        df['cluster'] = np.nan
+    return df

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/decorators.py

@@ -0,0 +1,87 @@
+# decorators.py
+
+from functools import wraps
+from flask import session, redirect, url_for, flash, request, jsonify
+
+# Import nécessaire pour le décorateur API 
+import auth_backend 
+
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if session.get('user_id') is None:
+            flash("Vous devez être connecté pour accéder à cette page.", "error")
+            # REDIRECTION VERS LA NOUVELLE ROUTE DE CONNEXION DU BACKEND
+            return redirect(url_for('web_bp.connexion_page')) 
+        return f(*args, **kwargs)
+    return decorated_function
+
+def api_key_required(f):
+    """
+    Décorateur pour les routes d'API nécessitant une clé API valide (pour les clients externes).
+    ... (Reste inchangé)
+    """
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        # 1. Récupérer la clé depuis l'en-tête ou les paramètres de requête
+        api_key = request.headers.get('X-API-Key')
+        if not api_key:
+            api_key = request.args.get('api_key') 
+
+        if not api_key:
+            return jsonify({
+                "message": "Authentification requise. Clé API manquante dans l'en-tête X-API-Key ou le paramètre api_key.", 
+                "status": "Unauthorized"
+            }), 401
+        
+        # 2. Valider la clé et récupérer l'utilisateur principal
+        client_user = auth_backend.get_client_user_by_api_key(api_key)
+
+        if not client_user:
+            return jsonify({
+                "message": "Clé API invalide ou non reconnue.", 
+                "status": "Forbidden"
+            }), 403
+            
+        # 3. Injecter les données de l'utilisateur principal (le client)
+        kwargs['client_user'] = client_user
+        
+        return f(*args, **kwargs)
+
+    return decorated_function
+
+# DÉCORATEUR : Pour les routes d'API qui doivent utiliser l'authentification par session
+def api_session_required(f):
+    """
+    Décorateur pour les routes d'API nécessitant une session utilisateur active (Web UI via session cookie).
+    Récupère l'ID utilisateur de la session et injecte les données de l'utilisateur dans la fonction.
+    """
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        # 1. Récupérer l'ID utilisateur de la session
+        user_uuid = session.get('user_id')
+
+        if not user_uuid:
+            # Si l'ID est manquant, on renvoie une réponse JSON 401 (standard pour une API).
+            return jsonify({
+                "message": "Authentification par session requise. Utilisateur non connecté.", 
+                "status": "Unauthorized"
+            }), 401
+        
+        # 2. Récupérer l'utilisateur principal (client) à partir de son UUID
+        client_user = auth_backend.get_client_user_by_uuid(user_uuid)
+
+        if not client_user:
+            # L'utilisateur existe en session mais pas/plus dans la base.
+            session.pop('user_id', None) # Vider la session
+            return jsonify({
+                "message": "Session invalide ou utilisateur non reconnu.", 
+                "status": "Forbidden"
+            }), 403
+            
+        # 3. Injecter les données de l'utilisateur principal (le client)
+        kwargs['client_user'] = client_user
+        
+        return f(*args, **kwargs)
+
+    return decorated_function

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/deployment_routes.py

@@ -0,0 +1,149 @@
+# deployment_routes.py
+
+import logging
+from flask import Blueprint, request, jsonify
+from decorators import api_session_required, api_key_required
+from hf_deploy_manager import (
+    deploy_repo_to_space,
+    get_space_status,
+    fetch_space_logs,
+    stop_space,
+    get_public_space_url,
+)
+
+
+logger = logging.getLogger(__name__)
+
+# Création du Blueprint 'hf_deploy_bp'
+# Préfixe d'URL pour toutes les routes de ce Blueprint: /api/v1/deployment
+hf_deploy_bp = Blueprint('hf_deploy_bp', __name__, url_prefix='/api/v1/deployment')
+
+# --- Route 1 : Lancement du Déploiement (Création/Configuration du Space) ---
+
+
+@hf_deploy_bp.route("/<string:user_id>/<string:repo_slug>/deploy", methods=['POST'])
+@api_session_required # Assurez-vous que l'utilisateur est authentifié
+def deploy_project(user_id, repo_slug, client_user):
+    """
+    Lance le déploiement d'un dépôt utilisateur vers un nouveau Hugging Face Space.
+    Nécessite le 'sdk_type' (gradio, streamlit, docker, static) dans le corps JSON.
+    """
+    data = request.get_json()
+    sdk_type = data.get('sdk_type', 'gradio')
+    
+    # Validation minimale
+    if not user_id or not repo_slug:
+        return jsonify({"success": False, "message": "ID utilisateur ou slug de dépôt manquant dans l'URL."}), 400
+
+    logger.info(f"Déploiement initié pour le dépôt '{repo_slug}' (User: {user_id}, SDK: {sdk_type})")
+    
+    # Appel de la fonction de logique métier
+    result = deploy_repo_to_space(
+        user_id=user_id,
+        repo_slug=repo_slug,
+        sdk_type=sdk_type
+    )
+
+    if result.get("success"):
+        return jsonify(result), 200
+    else:
+        # Renvoie le message d'erreur et un code 500 ou 400 approprié
+        status_code = 500 if "erreur inattendue" in result.get("message", "").lower() else 400
+        return jsonify(result), status_code
+
+
+# --- Route 2 : Vérification du Statut du Space ---
+@hf_deploy_bp.route("/<path:space_id>/status", methods=['GET']) # Utiliser path pour autoriser le slash dans l'ID
+@api_session_required
+def get_deployment_status(space_id, client_user):
+    """
+    Récupère le statut (Running, Building, Error, etc.) d'un Space HF.
+    Le space_id DOIT être l'ID complet (ex: owner/repo-slug).
+    """
+    # L'ID complet (owner/repo_slug) est passé directement dans 'space_id'
+    if not space_id:
+        return jsonify({"success": False, "message": "L'ID complet du Space est manquant dans l'URL."}), 400
+
+    logger.debug(f"Demande de statut pour le Space: {space_id}")
+    result = get_space_status(space_id=space_id)
+
+    if result.get("success"):
+        return jsonify(result), 200
+    else:
+        return jsonify(result), 404 # 404 si le Space n'est pas trouvé
+
+
+# --- Route 3 : Récupération des Logs du Space ---
+@hf_deploy_bp.route("/<path:space_id>/logs", methods=['GET']) # Utiliser path pour autoriser le slash dans l'ID
+@api_session_required
+def get_deployment_logs(space_id, client_user):
+    """
+    Récupère les logs (build ou runtime) d'un Space HF.
+    """
+    # L'ID complet (owner/repo_slug) est passé directement dans 'space_id'
+    if not space_id:
+        return jsonify({"success": False, "message": "L'ID complet du Space est manquant dans l'URL."}), 400
+
+    logs_type = request.args.get('type', 'build') # Valeur par défaut: 'build'
+
+    logger.debug(f"Demande de logs de type '{logs_type}' pour le Space: {space_id}")
+    result = fetch_space_logs(space_id=space_id, logs_type=logs_type) # 'space_id' est l'ID complet
+
+    if result.get("success"):
+        return jsonify(result), 200
+    else:
+        return jsonify(result), 404
+
+
+# --- Route 4 : Arrêt (Mise en Pause) du Space ---
+@hf_deploy_bp.route("/<path:space_id>/stop", methods=['POST']) # Utiliser path pour autoriser le slash dans l'ID
+@api_session_required
+def stop_deployment(space_id, client_user):
+    """
+    Met en pause (Stop) un Space HF pour économiser des ressources.
+    """
+    # L'ID complet (owner/repo_slug) est passé directement dans 'space_id'
+    if not space_id:
+        return jsonify({"success": False, "message": "L'ID complet du Space est manquant dans l'URL."}), 400
+
+    logger.info(f"Arrêt demandé pour le Space: {space_id}")
+    result = stop_space(space_id=space_id) # 'space_id' est l'ID complet
+
+    if result.get("success"):
+        return jsonify(result), 200
+    else:
+        return jsonify(result), 400
+
+# --- Route 5 : Récupération de l'URL publique du Space ---
+@hf_deploy_bp.route("/<path:space_id>/url", methods=['GET']) # Utiliser path pour autoriser le slash dans l'ID
+@api_session_required
+def get_space_url(space_id, client_user):
+    """
+    Construit et retourne l'URL publique d'un Space HF à partir de son ID COMPLET ou du SLUG.
+    """
+    # L'ID complet (owner/repo_slug) est passé directement dans 'space_id'
+    if not space_id:
+        return jsonify({"success": False, "message": "L'ID complet du Space est manquant dans l'URL."}), 400
+
+    try:
+        # Extraire le SLUG du repo à partir de l'ID complet (owner/repo_slug)
+        # S'il y a un slash, on utilise la partie après, sinon on suppose que c'est déjà le slug
+        parts = space_id.split('/')
+        if len(parts) == 2:
+            space_id_slug = parts[1] # Cas 'owner/repo_slug'
+        elif len(parts) == 1:
+            space_id_slug = parts[0] # Cas où on reçoit seulement le 'repo_slug'
+        else:
+            raise ValueError("L'ID du Space doit être au format 'owner/repo_slug' ou juste le slug.")
+        
+        space_url = get_public_space_url(space_id_slug) # Utilise le SLUG pour l'URL publique
+        
+        return jsonify({
+            "success": True, 
+            "space_url": space_url,
+            "space_id": space_id # Retourne l'ID initial pour cohérence
+        }), 200
+        
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors de la récupération de l'URL pour {space_id}: {e}")
+        return jsonify({"success": False, "message": f"Erreur lors de la construction de l'URL: {str(e)}"}), 500

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/main.py

@@ -0,0 +1,1261 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import io
+import base64
+import json
+import time
+import os
+from datetime import datetime
+import hashlib
+import unicodedata
+import string
+import tempfile
+import matplotlib.pyplot as plt
+import seaborn as sns
+import re
+from collections import Counter
+import shap
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, accuracy_score, r2_score
+from lightgbm import LGBMClassifier, LGBMRegressor
+from sklearn.preprocessing import LabelEncoder, StandardScaler, MinMaxScaler
+from sklearn.impute import KNNImputer
+from wordcloud import WordCloud
+import spacy
+import plotly.express as px
+from sklearn.ensemble import IsolationForest
+from sklearn.cluster import KMeans
+
+# Importation des dictionnaires de traduction spécifiques
+from translations_base import fr_translations_base, load_users, save_users
+from translations_data_processing import fr_translations_data_processing
+from translations_ai_report import fr_translations_ai_report
+from translations_report_content import fr_translations_report_content
+from report_pdf_exporter import PdfExporter
+from report_excel_exporter import ExcelExporter
+from report_generator import ReportContent, AIRecommender
+from data_processing import (
+    read_data_file, get_data_overview, get_missing_values_summary,
+    generate_data_quality_visualizations, generate_ai_report_visualizations,
+    get_saved_themes, save_theme_preferences, get_theme_preferences,
+    delete_theme_preferences, update_theme, impute_missing_values,
+    scale_features, create_polynomial_features, create_interaction_term,
+    extract_datetime_features, apply_aggregation, detect_outliers_isolation_forest,
+    perform_kmeans_clustering, generate_multicolor_plots
+)
+from translations import txt, set_language, translations # translations reste pour le dictionnaire complet
+
+# --- Initialisation de st.session_state pour éviter AttributeError ---
+if 'df' not in st.session_state:
+    st.session_state.df = None
+if 'model' not in st.session_state:
+    st.session_state.model = None
+if 'shap_values_data' not in st.session_state:
+    st.session_state.shap_values_data = None
+if 'X_test_data' not in st.session_state:
+    st.session_state.X_test_data = None
+if 'y_test_data' not in st.session_state:
+    st.session_state.y_test_data = None
+if 'target_column' not in st.session_state:
+    st.session_state.target_column = None
+if 'model_type' not in st.session_state:
+    st.session_state.model_type = None
+if 'current_section' not in st.session_state:
+    st.session_state.current_section = "home" # Nouvelle section d'accueil
+if 'last_module_choice' not in st.session_state:
+    st.session_state.last_module_choice = "home"
+if 'theme' not in st.session_state:
+    st.session_state.theme = "Light" # Thème par défaut
+if 'user_id' not in st.session_state:
+    st.session_state.user_id = None
+if 'is_logged_in' not in st.session_state:
+    st.session_state.is_logged_in = False
+if 'username' not in st.session_state:
+    st.session_state.username = None
+if 'demo_mode' not in st.session_state:
+    st.session_state.demo_mode = False
+if 'show_static_page' not in st.session_state: # Initialisation manquante
+    st.session_state.show_static_page = False
+if 'active_discussion_id' not in st.session_state:
+    st.session_state.active_discussion_id = None
+if 'active_discussion_name' not in st.session_state:
+    st.session_state.active_discussion_name = "Nouvelle Discussion"
+if 'generate_visuals_clicked' not in st.session_state:
+    st.session_state.generate_visuals_clicked = False # Pour contrôler l'affichage des graphiques et boutons de rapport
+if 'show_database_form' not in st.session_state:
+    st.session_state.show_database_form = False
+if 'is_database_connected' not in st.session_state:
+    st.session_state.is_database_connected = False
+if 'database_user' not in st.session_state:
+    st.session_state.database_user = None
+if 'database_files' not in st.session_state:
+    st.session_state.database_files = {} # Stores file data as {filename: base64_content}
+
+
+# --- Fonctions de gestion de l'état de l'application ---
+def set_section(section_name):
+    st.session_state.current_section = section_name
+    st.session_state.last_module_choice = section_name
+    st.session_state.show_static_page = False
+    st.session_state.show_database_form = False # Hide database form when changing section
+    
+def static_page(page_key):
+    st.session_state.show_static_page = True
+    st.session_state.last_module_choice = page_key # Mettre à jour pour afficher le bon titre et contenu
+    st.session_state.show_database_form = False # Hide database form when showing static page
+    
+def get_page_hash(page_name):
+    return hashlib.md5(page_name.encode('utf-8')).hexdigest()
+
+def update_discussion_state():
+    """Sauvegarde l'état actuel de la discussion pour l'utilisateur connecté."""
+    if st.session_state.is_logged_in and st.session_state.username and st.session_state.active_discussion_id:
+        users_data = load_users()
+        if st.session_state.username not in users_data:
+            users_data[st.session_state.username] = {'profile': {}, 'discussions': {}}
+
+        discussion_state = {
+            'df': st.session_state.df.to_json() if st.session_state.df is not None else None,
+            'model': base64.b64encode(io.dumps(st.session_state.model)).decode('utf-8') if st.session_state.model else None,
+            'shap_values_data': base64.b64encode(io.dumps(st.session_state.shap_values_data)).decode('utf-8') if st.session_state.shap_values_data else None,
+            'X_test_data': st.session_state.X_test_data.to_json() if st.session_state.X_test_data is not None else None,
+            'y_test_data': st.session_state.y_test_data.to_json() if st.session_state.y_test_data is not None else None,
+            'target_column': st.session_state.target_column,
+            'model_type': st.session_state.model_type,
+            'current_section': st.session_state.current_section,
+            'last_module_choice': st.session_state.last_module_choice,
+            'generate_visuals_clicked': st.session_state.generate_visuals_clicked,
+            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+        users_data[st.session_state.username]['discussions'][st.session_state.active_discussion_id] = discussion_state
+        save_users(users_data)
+        #st.sidebar.success(f"Discussion '{st.session_state.active_discussion_name}' sauvegardée.")
+
+def load_discussion_state(discussion_id):
+    """Charge l'état d'une discussion spécifique pour l'utilisateur connecté."""
+    users_data = load_users()
+    discussions = users_data.get(st.session_state.username, {}).get('discussions', {})
+    
+    if discussion_id in discussions:
+        state = discussions[discussion_id]
+        if state['df']:
+            st.session_state.df = pd.read_json(state['df'])
+        else:
+            st.session_state.df = None
+        # Pour le modèle et SHAP, un processus de désérialisation plus complexe serait nécessaire.
+        # Pour l'instant, je les laisse à None ou gère comme des chaînes si c'est suffisant pour le besoin.
+        st.session_state.model = None # Ou désérialiser si le format est compatible
+        st.session_state.shap_values_data = None # Idem
+        if state['X_test_data']:
+            st.session_state.X_test_data = pd.read_json(state['X_test_data'])
+        else:
+            st.session_state.X_test_data = None
+        if state['y_test_data']:
+            st.session_state.y_test_data = pd.read_json(state['y_test_data'], typ='series')
+        else:
+            st.session_state.y_test_data = None
+
+        st.session_state.target_column = state['target_column']
+        st.session_state.model_type = state['model_type']
+        st.session_state.current_section = state['current_section']
+        st.session_state.last_module_choice = state['last_module_choice']
+        st.session_state.generate_visuals_clicked = state.get('generate_visuals_clicked', False)
+        
+        # Mettre à jour l'ID et le nom de la discussion active
+        st.session_state.active_discussion_id = discussion_id
+        # Trouver le nom correspondant à l'ID
+        for name, disc_id in users_data[st.session_state.username]['discussions_meta'].items():
+            if disc_id == discussion_id:
+                st.session_state.active_discussion_name = name
+                break
+
+        st.sidebar.success(f"Discussion '{st.session_state.active_discussion_name}' chargée.")
+        st.session_state.show_static_page = False # Assurez-vous de quitter la page statique
+        st.rerun()
+    else:
+        st.sidebar.error("Discussion non trouvée.")
+
+def create_new_discussion(discussion_name):
+    """Crée une nouvelle discussion et la rend active."""
+    if not st.session_state.is_logged_in:
+        st.sidebar.warning("Veuillez vous connecter pour créer une nouvelle discussion.")
+        return
+
+    users_data = load_users()
+    user_data = users_data.get(st.session_state.username, {})
+
+    # Initialiser 'discussions_meta' si elle n'existe pas
+    if 'discussions_meta' not in user_data:
+        user_data['discussions_meta'] = {}
+    
+    # Vérifier si le nom de discussion existe déjà
+    if discussion_name in user_data['discussions_meta']:
+        st.sidebar.error(txt("discussion_name_exists"))
+        return
+
+    new_discussion_id = hashlib.md5(f"{st.session_state.username}_{discussion_name}_{datetime.now()}".encode('utf-8')).hexdigest()
+    
+    # Enregistrer le nom et l'ID dans discussions_meta
+    user_data['discussions_meta'][discussion_name] = new_discussion_id
+
+    # Créer un état initial vide pour la nouvelle discussion
+    user_data['discussions'][new_discussion_id] = {
+        'df': None,
+        'model': None,
+        'shap_values_data': None,
+        'X_test_data': None,
+        'y_test_data': None,
+        'target_column': None,
+        'model_type': None,
+        'current_section': "home",
+        'last_module_choice': "home",
+        'generate_visuals_clicked': False,
+        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    users_data[st.session_state.username] = user_data # Mettre à jour les données de l'utilisateur
+    save_users(users_data)
+
+    st.session_state.active_discussion_id = new_discussion_id
+    st.session_state.active_discussion_name = discussion_name
+    
+    # Réinitialiser l'état de l'application pour la nouvelle discussion
+    st.session_state.df = None
+    st.session_state.model = None
+    st.session_state.shap_values_data = None
+    st.session_state.X_test_data = None
+    st.session_state.y_test_data = None
+    st.session_state.target_column = None
+    st.session_state.model_type = None
+    st.session_state.current_section = "home"
+    st.session_state.last_module_choice = "home"
+    st.session_state.show_static_page = False
+    st.session_state.generate_visuals_clicked = False
+
+    st.sidebar.success(txt("discussion_created_success").format(discussion_name=discussion_name))
+    st.rerun()
+
+def delete_discussion(discussion_id, discussion_name):
+    """Supprime une discussion."""
+    if not st.session_state.is_logged_in:
+        st.sidebar.warning("Veuillez vous connecter pour supprimer une discussion.")
+        return
+
+    users_data = load_users()
+    user_data = users_data.get(st.session_state.username, {})
+
+    if 'discussions' in user_data and discussion_id in user_data['discussions']:
+        del user_data['discussions'][discussion_id]
+        
+        # Supprimer aussi de discussions_meta
+        if 'discussions_meta' in user_data:
+            for name, did in list(user_data['discussions_meta'].items()): # Utiliser list() pour itérer et modifier
+                if did == discussion_id:
+                    del user_data['discussions_meta'][name]
+                    break
+        
+        users_data[st.session_state.username] = user_data
+        save_users(users_data)
+        
+        # Si la discussion supprimée était la discussion active, réinitialiser
+        if st.session_state.active_discussion_id == discussion_id:
+            st.session_state.active_discussion_id = None
+            st.session_state.active_discussion_name = "Nouvelle Discussion"
+            st.session_state.df = None
+            st.session_state.model = None
+            st.session_state.shap_values_data = None
+            st.session_state.X_test_data = None
+            st.session_state.y_test_data = None
+            st.session_state.target_column = None
+            st.session_state.model_type = None
+            st.session_state.current_section = "home"
+            st.session_state.last_module_choice = "home"
+            st.session_state.show_static_page = False
+            st.session_state.generate_visuals_clicked = False
+
+        st.sidebar.success(txt("discussion_deleted_success").format(discussion_name=discussion_name))
+        st.rerun()
+    else:
+        st.sidebar.error("Discussion non trouvée pour la suppression.")
+
+
+def check_password(username, password):
+    users_data = load_users()
+    user_data = users_data.get(username)
+    if user_data:
+        if hashlib.sha256(password.encode('utf-8')).hexdigest() == user_data['password']:
+            return True, user_data['user_id']
+    return False, None
+
+def create_account(username, password, profile_type):
+    users_data = load_users()
+    if username in users_data:
+        return False, "Ce nom d'utilisateur existe déjà."
+    
+    # Password strength validation
+    if not (8 <= len(password) <= 15 and
+            any(c.isdigit() for c in password) and
+            any(c.isalpha() for c in password) and
+            any(c in string.punctuation for c in password)):
+        return False, txt("enter_password_strong_requirements")
+    
+    hashed_password = hashlib.sha256(password.encode('utf-8')).hexdigest()
+    new_user_id = hashlib.md5(username.encode('utf-8')).hexdigest()
+    
+    users_data[username] = {
+        'password': hashed_password,
+        'user_id': new_user_id,
+        'profile': {'type': profile_type}, # Sauvegarde du type de profil
+        'discussions': {}, # Pour les discussions de l'utilisateur
+        'discussions_meta': {}, # Pour stocker les noms de discussion et leurs IDs
+        'database_files': {} # Initialize database files for the user
+    }
+    save_users(users_data)
+    return True, "Compte créé avec succès !"
+
+def login_form():
+    st.subheader(txt("login_title"))
+    st.markdown(txt("login_intro"))
+    
+    username = st.text_input(f"{txt('username_label')} 👤", key="login_username") 
+    password = st.text_input(f"{txt('password_label')} 🔒", type="password", key="login_password")
+    
+    # Pour la création de compte, demander le type de profil
+    is_create_account_mode = st.checkbox(txt("create_account_button"), key="create_account_checkbox")
+    profile_type = None
+    if is_create_account_mode:
+        st.markdown(txt("create_profile_explanation"))
+        profile_options = [
+            txt("profile_agent_immobilier"),
+            txt("profile_investisseur"),
+            txt("profile_expert_data"),
+            txt("profile_autre")
+        ]
+        profile_type = st.selectbox(txt("profile_type_label"), options=profile_options, key="profile_type_selector")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button(txt("login_button"), key="login_btn"):
+            if username and password:
+                is_valid, user_id = check_password(username, password)
+                if is_valid:
+                    st.session_state.is_logged_in = True
+                    st.session_state.username = username
+                    st.session_state.user_id = user_id
+                    st.session_state.demo_mode = False
+                    st.success(txt("login_success"))
+                    
+                    # Load database files for the logged-in user
+                    users_data = load_users()
+                    st.session_state.database_files = users_data.get(username, {}).get('database_files', {})
+
+                    # Charger la dernière discussion ou créer une par défaut
+                    user_discussions_meta = users_data.get(username, {}).get('discussions_meta', {})
+                    if user_discussions_meta:
+                        # Charger la dernière discussion par timestamp si implémenté, ou la première trouvée
+                        first_discussion_name = list(user_discussions_meta.keys())[0]
+                        first_discussion_id = user_discussions_meta[first_discussion_name]
+                        load_discussion_state(first_discussion_id) # Cela va aussi mettre à jour active_discussion_name
+                    else:
+                        # Créer une discussion par défaut pour le nouvel utilisateur
+                        default_discussion_name = "Première discussion"
+                        create_new_discussion(default_discussion_name)
+                    st.rerun()
+                else:
+                    st.error(txt("login_error"))
+            else:
+                st.warning(txt("login_fields_prompt"))
+    with col2:
+        if is_create_account_mode and st.button(txt("create_account_button"), key="create_new_account_btn"):
+            if username and password and profile_type:
+                success, message = create_account(username, password, profile_type)
+                if success:
+                    st.success(message)
+                    st.info(txt("profile_saved_success"))
+                    # After account creation, the user will need to log in.
+                else:
+                    st.error(message)
+            else:
+                st.warning(txt("create_account_fields_prompt"))
+
+    if st.button(txt("explore_demo_button"), key="demo_mode_btn", use_container_width=True):
+        st.session_state.is_logged_in = False
+        st.session_state.username = "Mode Démo"
+        st.session_state.user_id = "demo_user"
+        st.session_state.demo_mode = True
+        st.session_state.df = pd.DataFrame(translations['fr']['demo_data'])
+        st.session_state.active_discussion_id = "demo_discussion" # Fictitious ID
+        st.session_state.active_discussion_name = "Données de Démonstration"
+        st.session_state.database_files = {} # No database files in demo mode
+        st.success(txt("demo_mode_activated"))
+        set_section("data_diagnostic_title")
+        st.rerun()
+
+
+def save_user_data(df_to_save, filename="current_data.csv"):
+    # This function is now less used directly for files,
+    # because "discussions" manage the complete state.
+    # However, it can be adapted to save specific files if needed.
+    if st.session_state.is_logged_in and st.session_state.user_id and not st.session_state.demo_mode:
+        # The file saving logic is now integrated into discussions
+        # The df is saved in the discussion state.
+        st.info("Le DataFrame est sauvegardé dans la discussion active.")
+        update_discussion_state() # Save current state
+    elif st.session_state.demo_mode:
+        st.info(txt("save_not_available_demo"))
+    else:
+        st.warning(txt("login_required_save"))
+
+def load_user_data_from_list(discussion_id, discussion_name):
+    load_discussion_state(discussion_id)
+
+def database_login_form():
+    """
+    Formulaire de connexion/création de compte pour la base de données.
+    Utilise les mêmes comptes que l'application principale.
+    """
+    st.subheader(txt("login_to_database"))
+    db_username = st.text_input(f"{txt('username_label')} 👤", key="db_login_username") 
+    db_password = st.text_input(f"{txt('password_label')} 🔒", type="password", key="db_login_password")
+    
+    if st.button(txt("login_button"), key="db_login_btn"):
+        if db_username and db_password:
+            is_valid, user_id = check_password(db_username, db_password)
+            if is_valid:
+                st.session_state.is_database_connected = True
+                st.session_state.database_user = db_username
+                # Load database files for the logged-in user
+                users_data = load_users()
+                st.session_state.database_files = users_data.get(db_username, {}).get('database_files', {})
+                st.success(txt("login_success"))
+                st.rerun()
+            else:
+                st.error(txt("login_error"))
+        else:
+            st.warning(txt("login_fields_prompt"))
+
+    if st.button(txt("create_account_button"), key="db_create_account_btn"):
+        # Redirect to the main login form for account creation if not already logged in
+        st.session_state.show_database_form = False # Hide DB form to show main login
+        st.session_state.is_logged_in = False # Force showing main login form
+        st.rerun() # This will display the main login form where account creation is handled
+        st.warning("Veuillez créer un compte via le formulaire de connexion principal.")
+
+
+def database_management_interface():
+    """
+    Interface pour gérer les fichiers dans la base de données.
+    """
+    st.header(txt("database_section"))
+    st.info(txt("database_intro"))
+
+    # Fonctionnalité 1: Importer un ou plusieurs fichiers
+    st.subheader(txt("import_files_to_db_title"))
+    uploaded_db_files = st.file_uploader(
+        txt("upload_db_files_label"),
+        type=["csv", "txt", "json", "xls", "xlsx", "parquet", "orc", "feather", "dta", "sas7bdat"],
+        accept_multiple_files=True,
+        key="db_file_uploader"
+    )
+
+    if uploaded_db_files:
+        if len(uploaded_db_files) > 10:
+            st.warning("Vous ne pouvez télécharger que 10 fichiers maximum à la fois.")
+            uploaded_db_files = uploaded_db_files[:10]
+
+        action_choice = st.radio(
+            "Que souhaitez-vous faire avec le(s) fichier(s) téléchargé(s) ?",
+            [txt("file_storage_option"), txt("advanced_analysis_option")],
+            key="db_action_choice"
+        )
+
+        if action_choice == txt("file_storage_option"):
+            if st.button("Stocker les fichiers", key="store_db_files_btn"):
+                if uploaded_db_files:
+                    users_data = load_users()
+                    user_db_files = users_data.get(st.session_state.database_user, {}).get('database_files', {})
+                    
+                    stored_count = 0
+                    for uploaded_file in uploaded_db_files:
+                        file_contents = uploaded_file.getvalue()
+                        encoded_content = base64.b64encode(file_contents).decode('utf-8')
+                        user_db_files[uploaded_file.name] = {
+                            'content': encoded_content,
+                            'type': uploaded_file.type,
+                            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        }
+                        stored_count += 1
+                    
+                    users_data[st.session_state.database_user]['database_files'] = user_db_files
+                    save_users(users_data)
+                    st.session_state.database_files = user_db_files # Update session state
+                    st.success(txt("files_saved_to_db").format(count=stored_count))
+                    st.rerun()
+                else:
+                    st.warning(txt("no_files_uploaded_for_db"))
+
+        elif action_choice == txt("advanced_analysis_option"):
+            if len(uploaded_db_files) == 1:
+                selected_file_for_analysis = uploaded_db_files[0]
+                if st.button(txt("analyze_selected_file_button"), key="analyze_uploaded_file_btn"):
+                    # Process the single file for advanced analysis
+                    file_contents = selected_file_for_analysis.getvalue()
+                    
+                    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(selected_file_for_analysis.name)[1]) as tmp_file:
+                        tmp_file.write(file_contents)
+                        tmp_file_path = tmp_file.name
+                    
+                    df, message = read_data_file(tmp_file_path)
+                    os.unlink(tmp_file_path) # Clean up temp file
+
+                    if df is not None:
+                        st.session_state.df = df
+                        st.session_state.current_section = "data_diagnostic_title"
+                        st.success(txt("analysis_triggered_for_file").format(filename=selected_file_for_analysis.name))
+                        st.rerun()
+                    else:
+                        st.error(f"{txt('error_reading_file')} : {message}")
+            else:
+                st.warning(txt("please_select_one_file_for_analysis"))
+
+    # Fonctionnalité 2: Afficher les fichiers stockés et lancer une analyse sur un fichier existant
+    st.markdown("---")
+    st.subheader(txt("stored_files_title"))
+    if st.session_state.database_files:
+        file_names = list(st.session_state.database_files.keys())
+        selected_stored_file = st.selectbox(
+            txt("select_stored_file_for_analysis"),
+            options=file_names,
+            key="selected_stored_file"
+        )
+
+        col_view, col_analyze, col_delete = st.columns(3)
+
+        with col_view:
+            if st.button(txt("view_file_content_button"), key="view_stored_file_btn"):
+                file_data = st.session_state.database_files[selected_stored_file]
+                decoded_content = base64.b64decode(file_data['content'])
+                
+                # Display content based on file type
+                if 'csv' in file_data['type'] or 'text' in file_data['type']:
+                    st.text_area(f"Contenu de {selected_stored_file}", decoded_content.decode('utf-8'), height=300)
+                elif 'json' in file_data['type']:
+                    st.json(json.loads(decoded_content.decode('utf-8')))
+                else:
+                    st.write("Aperçu non disponible pour ce type de fichier. Téléchargez pour voir.")
+                    st.download_button(
+                        label=f"Télécharger {selected_stored_file}",
+                        data=decoded_content,
+                        file_name=selected_stored_file,
+                        mime=file_data['type'],
+                        key=f"download_stored_{selected_stored_file}"
+                    )
+
+        with col_analyze:
+            if st.button(txt("analyze_selected_file_button"), key="analyze_stored_file_btn"):
+                file_data = st.session_state.database_files[selected_stored_file]
+                decoded_content = base64.b64decode(file_data['content'])
+
+                with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(selected_stored_file)[1]) as tmp_file:
+                    tmp_file.write(decoded_content)
+                    tmp_file_path = tmp_file.name
+                
+                df, message = read_data_file(tmp_file_path)
+                os.unlink(tmp_file_path)
+
+                if df is not None:
+                    st.session_state.df = df
+                    st.session_state.current_section = "data_diagnostic_title"
+                    st.success(txt("analysis_triggered_for_file").format(filename=selected_stored_file))
+                    st.rerun()
+                else:
+                    st.error(f"{txt('error_reading_file')} : {message}")
+
+        with col_delete:
+            if st.button(txt("delete_file_button"), key="delete_stored_file_btn"):
+                users_data = load_users()
+                if st.session_state.database_user in users_data and 'database_files' in users_data[st.session_state.database_user]:
+                    del users_data[st.session_state.database_user]['database_files'][selected_stored_file]
+                    save_users(users_data)
+                    st.session_state.database_files = users_data[st.session_state.database_user]['database_files']
+                    st.success(txt("file_deleted_success").format(filename=selected_stored_file))
+                    st.rerun()
+    else:
+        st.info(txt("no_stored_files"))
+
+    # Fonctionnalité 3: Renommer un fichier (simple exemple)
+    st.markdown("---")
+    st.subheader("Renommer un fichier")
+    if st.session_state.database_files:
+        old_file_name = st.selectbox("Sélectionnez le fichier à renommer", options=list(st.session_state.database_files.keys()), key="rename_old_file")
+        new_file_name = st.text_input("Nouveau nom du fichier", key="rename_new_file")
+        if st.button("Renommer", key="rename_file_btn"):
+            if new_file_name and new_file_name != old_file_name:
+                users_data = load_users()
+                if st.session_state.database_user in users_data and 'database_files' in users_data[st.session_state.database_user]:
+                    file_data = users_data[st.session_state.database_user]['database_files'].pop(old_file_name)
+                    users_data[st.session_state.database_user]['database_files'][new_file_name] = file_data
+                    save_users(users_data)
+                    st.session_state.database_files = users_data[st.session_state.database_user]['database_files']
+                    st.success(f"Fichier '{old_file_name}' renommé en '{new_file_name}'.")
+                    st.rerun()
+            else:
+                st.warning("Veuillez entrer un nouveau nom de fichier valide.")
+
+    # Fonctionnalité 4: Télécharger un fichier
+    st.markdown("---")
+    st.subheader("Télécharger un fichier")
+    if st.session_state.database_files:
+        file_to_download = st.selectbox("Sélectionnez le fichier à télécharger", options=list(st.session_state.database_files.keys()), key="download_file_select")
+        if st.button("Télécharger", key="download_file_btn"):
+            file_data = st.session_state.database_files[file_to_download]
+            decoded_content = base64.b64decode(file_data['content'])
+            st.download_button(
+                label=f"Télécharger {file_to_download}",
+                data=decoded_content,
+                file_name=file_to_download,
+                mime=file_data['type'],
+                key=f"download_actual_file_{file_to_download}"
+            )
+    
+    # Fonctionnalité 5: Rechercher des fichiers (simple recherche par nom)
+    st.markdown("---")
+    st.subheader("Rechercher des fichiers")
+    search_query = st.text_input("Rechercher par nom de fichier", key="file_search_query")
+    if st.button("Rechercher", key="search_files_btn"):
+        if search_query:
+            found_files = [f for f in st.session_state.database_files.keys() if search_query.lower() in f.lower()]
+            if found_files:
+                st.write("Fichiers trouvés :")
+                for f in found_files:
+                    st.write(f"- {f}")
+            else:
+                st.info("Aucun fichier trouvé correspondant à votre recherche.")
+        else:
+            st.warning("Veuillez entrer un terme de recherche.")
+
+    # Fonctionnalité 6: Vider la base de données (pour l'utilisateur connecté)
+    st.markdown("---")
+    st.subheader("Vider la Base de Données")
+    st.warning("Attention : Cette action supprimera TOUS les fichiers stockés pour votre compte. Cette action est irréversible.")
+    if st.button("Vider tous les fichiers", key="clear_database_btn"):
+        users_data = load_users()
+        if st.session_state.database_user in users_data:
+            users_data[st.session_state.database_user]['database_files'] = {}
+            save_users(users_data)
+            st.session_state.database_files = {}
+            st.success("Tous les fichiers ont été supprimés de votre base de données.")
+            st.rerun()
+
+
+# --- Gestion de l'état de la page principale ---
+st.set_page_config(layout="wide")
+
+# Appliquer le thème (mode sombre/clair)
+current_theme = get_theme_preferences(st.session_state.theme)
+if st.session_state.theme == "Dark":
+    st._config.set_option('theme.base', 'dark')
+    st._config.set_option('theme.backgroundColor', '#0E1117')
+    st._config.set_option('theme.primaryColor', '#265DCC')
+    st._config.set_option('theme.secondaryBackgroundColor', '#262730')
+    st._config.set_option('theme.textColor', '#FAFAFA')
+    st._config.set_option('theme.font', 'sans serif')
+else: # Light theme or custom theme
+    st._config.set_option('theme.base', 'light')
+    st._config.set_option('theme.backgroundColor', '#FFFFFF')
+    st._config.set_option('theme.primaryColor', '#FF4B4B') # Default Streamlit red
+    st._config.set_option('theme.secondaryBackgroundColor', '#F0F2F6')
+    st._config.set_option('theme.textColor', '#303030')
+    st._config.set_option('theme.font', 'sans serif')
+
+# --- Barre latérale pour la navigation ---
+with st.sidebar:
+    st.title(txt("app_title"))
+    st.markdown(f"**{txt('app_subtitle')}**") # Mettre en gras le sous-titre
+    
+    if not st.session_state.is_logged_in and not st.session_state.demo_mode:
+        pass # The login form is handled in the main body
+    else:
+        st.info(f"{txt('logged_in_as')}: **{st.session_state.username}**") # Display username in bold
+
+        # Section de gestion des discussions
+        st.subheader("Discussions")
+        st.markdown(f"**{txt('current_discussion_label').format(discussion_name=st.session_state.active_discussion_name)}**")
+
+        # Bouton Nouvelle Discussion
+        if st.button(f"✨ {txt('new_discussion_button')}", use_container_width=True):
+            with st.popover(txt("enter_discussion_name")):
+                new_disc_name = st.text_input("Nom de la nouvelle discussion", key="new_discussion_name_input")
+                if st.button("Créer"):
+                    create_new_discussion(new_disc_name)
+
+        # Liste des discussions existantes
+        if st.session_state.is_logged_in and not st.session_state.demo_mode:
+            users_data = load_users()
+            user_discussions_meta = users_data.get(st.session_state.username, {}).get('discussions_meta', {})
+            
+            if user_discussions_meta:
+                st.markdown("---")
+                st.markdown("Historique des discussions :")
+                for disc_name, disc_id in user_discussions_meta.items():
+                    col_disc_name, col_load_btn, col_del_btn = st.columns([0.6, 0.2, 0.2])
+                    with col_disc_name:
+                        st.write(disc_name)
+                    with col_load_btn:
+                        if st.button("Charger", key=f"load_disc_{disc_id}"):
+                            load_discussion_state(disc_id)
+                    with col_del_btn:
+                        if st.button("🗑️", key=f"del_disc_{disc_id}"):
+                            delete_discussion(disc_id, disc_name)
+            else:
+                st.info(txt("no_discussions_saved"))
+
+
+        st.markdown("---")
+        st.header(txt("main_modules"))
+        if st.button(f"🏠 {txt('home_section')}", use_container_width=True):
+            set_section("home")
+        if st.button(f"📊 {txt('data_diagnostic_title')}", use_container_width=True):
+            set_section("data_diagnostic_title")
+        if st.button(f"🛠️ {txt('data_prep_title')}", use_container_width=True):
+            set_section("data_prep_title")
+        if st.button(f"🧠 {txt('ai_prediction_title')}", use_container_width=True):
+            set_section("ai_prediction_title")
+        if st.button(f"📄 {txt('report_generation_title')}", use_container_width=True):
+            set_section("report_generation_title")
+        
+        # New Database button and explanation
+        st.markdown("---")
+        if st.button(f"🗄️ {txt('database_section')}", use_container_width=True, key="database_button"):
+            st.session_state.show_database_form = not st.session_state.show_database_form
+            st.session_state.show_static_page = False # Hide static page if database button is clicked
+            st.session_state.current_section = "database" # Set a specific section for the database interface
+
+        if st.session_state.show_database_form:
+            st.markdown(txt("database_intro"))
+
+        st.markdown("---")
+        st.header(txt("settings_section"))
+        
+        # Theme management
+        theme_options = ["Light", "Dark"] + list(get_saved_themes().keys())
+        selected_theme = st.selectbox(
+            txt("select_theme"),
+            options=theme_options,
+            index=theme_options.index(st.session_state.theme) if st.session_state.theme in theme_options else 0,
+            key="theme_selector",
+            on_change=lambda: st.session_state.update({'theme': st.session_state.theme_selector})
+        )
+        
+        if selected_theme not in ["Light", "Dark"]:
+            if st.button(txt("delete_theme_button")):
+                success, msg = delete_theme_preferences(selected_theme)
+                if success:
+                    st.success(msg)
+                    st.session_state.theme = "Light"
+                else:
+                    st.error(msg)
+                st.rerun()
+        
+        st.info(txt("theme_reload_info"))
+        
+        # Logout button in the sidebar
+        st.markdown("---")
+        if st.button(txt("logout_button"), use_container_width=True):
+            # Before logging out, save active discussion if it exists
+            if st.session_state.is_logged_in and st.session_state.active_discussion_id:
+                update_discussion_state()
+            
+            st.session_state.is_logged_in = False
+            st.session_state.username = None
+            st.session_state.user_id = None
+            st.session_state.df = None
+            st.session_state.demo_mode = False
+            st.session_state.active_discussion_id = None
+            st.session_state.active_discussion_name = "Nouvelle Discussion"
+            st.session_state.current_section = "home"
+            st.session_state.last_module_choice = "home"
+            st.session_state.show_static_page = False
+            st.session_state.generate_visuals_clicked = False
+            st.session_state.show_database_form = False
+            st.session_state.is_database_connected = False
+            st.session_state.database_user = None
+            st.session_state.database_files = {} # Clear database files on logout
+            st.rerun()
+
+
+# --- Main page content ---
+if not st.session_state.is_logged_in and not st.session_state.demo_mode:
+    st.title(txt("app_title_welcome"))
+    login_form()
+elif st.session_state.show_static_page:
+    st.header(txt(st.session_state.last_module_choice)) # Uses the section key
+    st.write(txt(f"{st.session_state.last_module_choice}_content")) # Uses the key_content
+    if st.button(txt("back_to_dashboard_button")):
+        st.session_state.show_static_page = False
+        st.rerun()
+elif st.session_state.current_section == "database":
+    if not st.session_state.is_database_connected:
+        database_login_form()
+    else:
+        database_management_interface()
+elif st.session_state.current_section == "home":
+    st.title(txt("home_welcome_title").format(username=st.session_state.username))
+    st.markdown(txt("home_intro"))
+
+    st.subheader(txt("home_feature_discovery_title"))
+    
+    # Concrete use cases
+    st.markdown("#### Exemples d'Analyse :")
+    st.markdown("""
+    - **Agent Immobilier 🏡:** Analysez les prix du marché, identifiez les propriétés surévaluées/sous-évaluées, comprenez les facteurs clés de valeur.
+    - **Investisseur 💰:** Détectez des opportunités d'investissement, segmentez le marché pour trouver des niches, évaluez les risques.
+    - **Promoteur Immobilier 🏗️:** Évaluez le potentiel de nouveaux projets, anticipez les tendances, optimisez les stratégies de vente.
+    """)
+
+    st.subheader(txt("home_ai_models_title"))
+    st.markdown(txt("home_ai_models_description"))
+    
+    st.markdown(f"- **LightGBM:** Un algorithme d'apprentissage puissant pour la prédiction. 🚀")
+    st.markdown(f"- **Isolation Forest:** Idéal pour détecter les anomalies et les valeurs aberrantes. 🔍")
+    st.markdown(f"- **K-Means:** Pour regrouper les propriétés similaires et découvrir des segments de marché. 🧩")
+    
+    # Main button to import a file, visible on the home page if not in demo mode
+    if not st.session_state.demo_mode:
+        st.markdown("---")
+        if st.button(txt("main_section_import_button"), use_container_width=True):
+            set_section("data_diagnostic_title")
+            st.rerun()
+
+else: # Main application logic
+    # Section for file upload if not in demo mode
+    if not st.session_state.demo_mode:
+        st.header(f"📥 {txt('data_diagnostic_title')} - {txt('upload_label')}")
+        st.info(txt("import_file_types_info"))
+        uploaded_file = st.file_uploader(txt("upload_label"), type=["csv", "txt", "json", "xls", "xlsx", "parquet", "orc", "feather", "dta", "sas7bdat"])
+
+        if uploaded_file is not None:
+            file_details = {"FileName": uploaded_file.name, "FileType": uploaded_file.type}
+            st.write(txt("file_details"))
+            st.write(file_details)
+            
+            # Use a unique filename to avoid conflicts in temporary folders
+            unique_filename = f"{datetime.now().strftime('%Y%m%d%H%M%S')}_{uploaded_file.name}"
+            
+            # Save the file temporarily for reading by read_data_file
+            with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(uploaded_file.name)[1]) as tmp_file:
+                tmp_file.write(uploaded_file.getvalue())
+                tmp_file_path = tmp_file.name
+
+            df, message = read_data_file(tmp_file_path)
+            
+            # Delete the temporary file after reading
+            os.unlink(tmp_file_path)
+
+            if df is not None:
+                st.session_state.df = df
+                st.success(txt("file_uploaded_success"))
+                st.session_state.generate_visuals_clicked = False # Reset when a new file is loaded
+                update_discussion_state() # Save the DF to the active discussion
+                st.rerun() # To display the information directly
+
+            else:
+                st.error(f"{txt('error_reading_file')} : {message}")
+    
+    # Display demo DataFrame or loaded data
+    if st.session_state.df is not None:
+        if st.session_state.demo_mode:
+            st.subheader(txt("demo_data_title"))
+            st.write(txt("demo_data_intro"))
+            st.dataframe(st.session_state.df.head())
+        else:
+            st.subheader(txt("dataframe_sample"))
+            st.dataframe(st.session_state.df.head())
+        
+        # --- Automatic display of initial information and visualizations ---
+        st.markdown("---")
+        st.header(f"📊 {txt('data_diagnostic_title')}")
+        st.info(txt("data_diagnostic_intro"))
+        
+        overview = get_data_overview(st.session_state.df)
+        st.subheader(txt("overview_data"))
+        st.write(txt("num_rows").format(rows=overview['rows']))
+        st.write(txt("num_cols").format(cols=overview['cols']))
+        
+        st.subheader(txt("descriptive_stats"))
+        st.write(st.session_state.df.describe())
+        
+        st.subheader(txt("missing_values"))
+        missing_summary = get_missing_values_summary(st.session_state.df)
+        if not missing_summary.empty:
+            st.write(missing_summary)
+        else:
+            st.info(txt("no_missing_values"))
+
+        # Button to generate visualizations
+        if st.button(txt("generate_visualizations_button"), key="generate_data_viz_button"):
+            st.session_state.generate_visuals_clicked = True
+            st.rerun() # To display the charts below the button
+
+        if st.session_state.generate_visuals_clicked:
+            generate_multicolor_plots(st.session_state.df.copy())
+            
+            # Display PDF/Excel download buttons here if the model is trained
+            if st.session_state.model is not None:
+                st.markdown("---")
+                st.subheader(txt("report_generation_title"))
+                st.info(txt("report_generation_intro"))
+
+                report_content = ReportContent(
+                    df=st.session_state.df,
+                    model=st.session_state.model,
+                    shap_values_data=st.session_state.shap_values_data,
+                    X_test_data=st.session_state.X_test_data,
+                    y_test_data=st.session_state.y_test_data,
+                    target_column=st.session_state.target_column,
+                    model_type=st.session_state.model_type,
+                    txt_func=txt
+                )
+                
+                # Report customization (simplified for display here)
+                report_custom_title_line1 = txt("default_report_title_line1")
+                report_custom_subtitle = txt("default_report_subtitle")
+                report_custom_footer = txt("default_report_footer").format(date=datetime.now().strftime("%Y-%m-%d"))
+                selected_sections = report_content.available_report_sections # All default sections
+                
+                report_options = {
+                    "report_custom_title_line1": report_custom_title_line1,
+                    "report_custom_subtitle": report_custom_subtitle,
+                    "report_custom_footer": report_custom_footer,
+                    "selected_report_sections": selected_sections
+                }
+                report_content.update_report_options(report_options)
+
+                col_pdf, col_excel = st.columns(2)
+                
+                with col_pdf:
+                    pdf_exporter = PdfExporter(report_content)
+                    pdf_output = io.BytesIO()
+                    pdf_exporter.export_pdf(pdf_output)
+                    st.download_button(
+                        label=txt("download_pdf_button"),
+                        data=pdf_output.getvalue(),
+                        file_name=f"Rapport_ErnestMind_{slugify(report_custom_title_line1)}.pdf",
+                        mime="application/pdf",
+                        use_container_width=True
+                    )
+
+                with col_excel:
+                    try:
+                        excel_exporter = ExcelExporter(report_content)
+                        with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp_excel_file:
+                            excel_output_path = tmp_excel_file.name
+                        
+                        excel_exporter.export_excel(excel_output_path)
+                        with open(excel_output_path, "rb") as f:
+                            excel_data = f.read()
+                        st.download_button(
+                            label=txt("download_excel_button"),
+                            data=excel_data,
+                            file_name=f"Rapport_ErnestMind_{slugify(report_custom_title_line1)}.xlsx",
+                            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                            use_container_width=True
+                        )
+                        os.unlink(excel_output_path)
+                    except ImportError:
+                        st.error(txt("excel_dependency_error"))
+                    except Exception as e:
+                        st.error(f"{txt('error_creating_excel')}: {e}")
+            else:
+                st.info(txt("upload_data_for_report_prompt")) # Reuse this message to indicate that a trained model is needed
+
+
+        elif st.session_state.current_section == "data_prep_title":
+            st.header(f"🛠️ {txt('data_prep_title')}")
+            
+            st.info(txt("data_prep_intro"))
+
+            st.subheader(txt("missing_values_imputation_title"))
+            imputation_method = st.selectbox(txt("select_imputation_method"), ["mean", "median", "knn"])
+            if st.button(txt("apply_imputation_button")):
+                st.session_state.df = impute_missing_values(st.session_state.df, method=imputation_method)
+                st.success(txt("imputation_applied").format(method=imputation_method))
+                update_discussion_state() # Save state after modification
+                st.rerun()
+
+            st.subheader(txt("feature_scaling_title"))
+            scaling_method = st.selectbox(txt("select_scaling_method"), ["standard", "minmax"])
+            if st.button(txt("apply_scaling_button")):
+                st.session_state.df = scale_features(st.session_state.df, method=scaling_method)
+                st.success(txt("scaling_applied").format(method=scaling_method))
+                update_discussion_state()
+                st.rerun()
+                
+            st.subheader(txt("outlier_detection_title"))
+            if st.button(txt("detect_outliers_button")):
+                st.session_state.df = detect_outliers_isolation_forest(st.session_state.df)
+                st.success(txt("outliers_detected"))
+                st.write(st.session_state.df.head())
+                update_discussion_state()
+                st.rerun()
+
+            st.subheader(txt("clustering_title"))
+            n_clusters = st.number_input(txt("select_num_clusters"), min_value=2, value=3)
+            if st.button(txt("apply_clustering_button")):
+                st.session_state.df = perform_kmeans_clustering(st.session_state.df, n_clusters=n_clusters)
+                st.success(txt("clustering_applied").format(n_clusters=n_clusters))
+                st.write(st.session_state.df.head())
+                update_discussion_state()
+                st.rerun()
+
+            st.subheader(txt("feature_engineering_title"))
+            
+            # Create polynomial features
+            st.markdown("#### Créer des caractéristiques polynômiales")
+            degree = st.number_input("Degré", min_value=2, max_value=5, value=2)
+            if st.button("Créer des caractéristiques polynômiales"):
+                st.session_state.df = create_polynomial_features(st.session_state.df, degree)
+                st.success(f"Caractéristiques polynômiales de degré {degree} créées.")
+                update_discussion_state()
+                st.rerun()
+
+            # Create interaction terms
+            st.markdown("#### Créer un terme d'interaction")
+            num_cols = st.session_state.df.select_dtypes(include=np.number).columns
+            col1 = st.selectbox("Première colonne", num_cols, key="interaction_col1")
+            col2 = st.selectbox("Deuxième colonne", num_cols, key="interaction_col2")
+            if st.button("Créer le terme d'interaction"):
+                st.session_state.df = create_interaction_term(st.session_state.df, col1, col2)
+                st.success(f"Terme d'interaction créé entre {col1} et {col2}.")
+                update_discussion_state()
+                st.rerun()
+            
+            # Extract date/time features
+            st.markdown("#### Extraire des caractéristiques de date/heure")
+            # Convert potential date columns if not already
+            for col in st.session_state.df.columns:
+                if 'date' in col.lower():
+                    try:
+                        st.session_state.df[col] = pd.to_datetime(st.session_state.df[col], errors='coerce')
+                    except Exception:
+                        pass # Leave as is if not a valid date
+            
+            datetime_cols = st.session_state.df.select_dtypes(include=['datetime64']).columns
+            if len(datetime_cols) > 0:
+                datetime_col = st.selectbox("Sélectionner la colonne de date/heure", datetime_cols)
+                features_to_extract = st.multiselect("Sélectionner les caractéristiques à extraire", ["year", "month", "day", "hour", "minute", "second"])
+                if st.button("Extraire les caractéristiques"):
+                    st.session_state.df = extract_datetime_features(st.session_state.df, datetime_col, features_to_extract)
+                    st.success("Caractéristiques de date/heure extraites.")
+                    update_discussion_state()
+                    st.rerun()
+            else:
+                st.info("Aucune colonne de date/heure détectée.")
+        
+        elif st.session_state.current_section == "ai_prediction_title":
+            st.header(f"🧠 {txt('ai_prediction_title')}")
+
+            if st.session_state.df is not None:
+                st.info(txt("ai_prediction_intro"))
+
+                st.subheader(txt("model_training"))
+                num_cols = st.session_state.df.select_dtypes(include=np.number).columns
+                
+                # Filter columns that are not purely identifying for the target
+                possible_target_cols = [col for col in num_cols if len(st.session_state.df[col].unique()) > 1]
+
+                if not possible_target_cols:
+                    st.warning(txt("no_suitable_target_column"))
+                else:
+                    target_column = st.selectbox(txt("select_target_column"), options=possible_target_cols)
+                    model_type = st.selectbox(txt("select_model_type"), options=[txt("regression_model"), txt("classification_model")])
+                    
+                    if st.button(txt("train_model_button")):
+                        if target_column:
+                            with st.spinner(txt("training_model_in_progress")):
+                                st.session_state.target_column = target_column
+                                st.session_state.model_type = model_type
+                                
+                                X = st.session_state.df.drop(columns=[target_column])
+                                y = st.session_state.df[target_column]
+                                
+                                # Encode categorical features
+                                X = pd.get_dummies(X, drop_first=True)
+                                
+                                # Ensure X does not contain the target column after get_dummies if it was numeric
+                                if target_column in X.columns:
+                                    X = X.drop(columns=[target_column])
+
+                                # Handle remaining columns with NaN if they appear after get_dummies or other operations
+                                X = X.fillna(X.mean(numeric_only=True))
+
+                                # Split data
+                                if len(X) > 1:
+                                    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+                                else: # Case where there is not enough data to split
+                                    X_train, X_test = X, X
+                                    y_train, y_test = y, y
+                                
+                                st.session_state.X_test_data = X_test
+                                st.session_state.y_test_data = y_test
+
+                                if model_type == txt("regression_model"):
+                                    model = LGBMRegressor(random_state=42)
+                                else:
+                                    # For classification, ensure y is of int/categorical type
+                                    if pd.api.types.is_numeric_dtype(y):
+                                        y = y.astype('category').cat.codes # Convert to numeric codes for LGBM
+                                    model = LGBMClassifier(random_state=42)
+                                
+                                model.fit(X_train, y_train)
+                                st.session_state.model = model
+                                
+                                # Calculate SHAP values
+                                try:
+                                    explainer = shap.Explainer(model, X_train) # Use X_train for the explainer
+                                    shap_values = explainer(X_test)
+                                    st.session_state.shap_values_data = shap_values
+                                    st.success(txt("model_trained_success"))
+                                except Exception as e:
+                                    st.error(f"{txt('error_shap_calculation')}: {e}. Le modèle est entraîné mais les valeurs SHAP n'ont pas pu être calculées.")
+                                    st.session_state.shap_values_data = None # Reset if error
+                                
+                                update_discussion_state() # Save state after model training
+                                st.rerun() # To refresh model performance
+
+                        else:
+                            st.warning(txt("select_target_column_prompt"))
+                    
+                    if st.session_state.model:
+                        st.subheader(txt("model_performance"))
+                        
+                        y_pred = st.session_state.model.predict(st.session_state.X_test_data)
+                        
+                        if st.session_state.model_type == txt("regression_model"):
+                            rmse = np.sqrt(mean_squared_error(st.session_state.y_test_data, y_pred))
+                            r2 = r2_score(st.session_state.y_test_data, y_pred)
+                            st.metric(label=txt("rmse"), value=f"{rmse:.2f}")
+                            st.metric(label=txt("r2_score"), value=f"{r2:.2f}")
+                        else:
+                            accuracy = accuracy_score(st.session_state.y_test_data, y_pred.round())
+                            st.metric(label=txt("accuracy"), value=f"{accuracy:.2f}")
+                            
+                        # Display SHAP visualizations only if they have been calculated
+                        if st.session_state.shap_values_data is not None:
+                            generate_ai_report_visualizations(st.session_state.df, st.session_state.shap_values_data, st.session_state.X_test_data)
+                        else:
+                            st.info(txt("shap_not_available"))
+
+
+            else:
+                st.warning(txt("upload_data_for_report_prompt"))
+
+        elif st.session_state.current_section == "report_generation_title":
+            st.header(f"📄 {txt('report_generation_title')}")
+            
+            if st.session_state.df is not None and st.session_state.model is not None:
+                st.info(txt("report_generation_intro"))
+
+                # Create a ReportContent instance with session data
+                report_content = ReportContent(
+                    df=st.session_state.df,
+                    model=st.session_state.model,
+                    shap_values_data=st.session_state.shap_values_data,
+                    X_test_data=st.session_state.X_test_data,
+                    y_test_data=st.session_state.y_test_data,
+                    target_column=st.session_state.target_column,
+                    model_type=st.session_state.model_type,
+                    txt_func=txt
+                )
+                
+                # Report customization
+                st.subheader(txt("report_customization_title"))
+                report_custom_title_line1 = st.text_input(txt("custom_report_title_line1_label"), value=txt("default_report_title_line1"))
+                report_custom_subtitle = st.text_input(txt("custom_report_subtitle_label"), value=txt("default_report_subtitle"))
+                report_custom_footer = st.text_area(txt("custom_report_footer_label"), value=txt("default_report_footer").format(date=datetime.now().strftime("%Y-%m-%d")))
+                
+                selected_sections = st.multiselect(
+                    txt("select_report_sections"),
+                    options=report_content.available_report_sections,
+                    default=report_content.available_report_sections
+                )
+                
+                report_options = {
+                    "report_custom_title_line1": report_custom_title_line1,
+                    "report_custom_subtitle": report_custom_subtitle,
+                    "report_custom_footer": report_custom_footer,
+                    "selected_report_sections": selected_sections
+                }
+                
+                # Update options for the ReportContent instance
+                report_content.update_report_options(report_options)
+                
+                col_pdf, col_excel = st.columns(2)
+                
+                # PDF download button
+                with col_pdf:
+                    pdf_exporter = PdfExporter(report_content)
+                    pdf_output = io.BytesIO()
+                    pdf_exporter.export_pdf(pdf_output)
+                    st.download_button(
+                        label=txt("download_pdf_button"),
+                        data=pdf_output.getvalue(),
+                        file_name=f"Rapport_ErnestMind_{slugify(report_custom_title_line1)}.pdf",
+                        mime="application/pdf",
+                        use_container_width=True
+                    )
+
+                # Excel download button
+                with col_excel:
+                    try:
+                        excel_exporter = ExcelExporter(report_content)
+                        # Use a temporary file on the file system for xlsxwriter
+                        with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp_excel_file:
+                            excel_output_path = tmp_excel_file.name
+                        
+                        excel_exporter.export_excel(excel_output_path)
+                        with open(excel_output_path, "rb") as f:
+                            excel_data = f.read()
+                        st.download_button(
+                            label=txt("download_excel_button"),
+                            data=excel_data,
+                            file_name=f"Rapport_ErnestMind_{slugify(report_custom_title_line1)}.xlsx",
+                            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                            use_container_width=True
+                        )
+                        os.unlink(excel_output_path) # Delete temporary file
+                    except ImportError:
+                        st.error(txt("excel_dependency_error"))
+                    except Exception as e:
+                        st.error(f"{txt('error_creating_excel')}: {e}")
+
+            else:
+                st.warning(txt("upload_data_for_report_prompt"))
+
+# --- Global footer (new: moved from sidebar) ---
+st.markdown("---") # Visual separator
+col_footer_priv, col_footer_legal, col_footer_terms, col_footer_about, col_footer_help = st.columns(5)
+with col_footer_priv:
+    if st.button(txt("footer_privacy_policy"), key="footer_privacy_policy_button_main", use_container_width=True):
+        static_page("privacy_policy_section")
+        st.rerun()
+with col_footer_legal:
+    if st.button(txt("footer_legal_notices"), key="footer_legal_notices_button_main", use_container_width=True):
+        static_page("legal_notices_section")
+        st.rerun()
+with col_footer_terms:
+    if st.button(txt("footer_terms_of_use"), key="footer_terms_of_use_button_main", use_container_width=True):
+        static_page("terms_of_use_section")
+        st.rerun()
+with col_footer_about:
+    if st.button(txt("footer_about_ernestmind"), key="footer_about_ernestmind_button_main", use_container_width=True):
+        static_page("about_ernestmind_section")
+        st.rerun()
+with col_footer_help:
+    if st.button(txt("read_more_need_help"), key="footer_help_button_main", use_container_width=True):
+        static_page("help_section")
+        st.rerun()
+
+# Note : Static pages are now displayed by the `elif st.session_state.show_static_page:` logic
+# and the contents are pulled from `translations_report_content.py` or `translations_base.py`.

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/report_excel_exporter.py

@@ -0,0 +1,121 @@
+import pandas as pd
+import numpy as np
+import os
+import io
+import base64
+import tempfile
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+from PIL import Image
+import json
+from matplotlib.colors import LinearSegmentedColormap
+
+# Importation de la fonction de traduction et des traductions
+from translations import txt, translations, slugify # Importe slugify depuis translations
+# xlsxwriter est utilisé pour des fonctionnalités avancées comme le style
+try:
+    import xlsxwriter
+except ImportError:
+    xlsxwriter = None
+
+
+class ExcelExporter:
+    """Class to export reports in Excel format."""
+
+    def __init__(self, report_content):
+        self.content = report_content
+        self.report_title_line1 = self.content.report_options['report_custom_title_line1']
+        self.report_title_line2 = self.content.report_title_line2
+        self.report_subtitle = self.content.report_options['report_custom_subtitle']
+        self.report_footer_text = self.content.report_options['report_custom_footer']
+        self.report_logo_path = self.content.custom_logo_path
+
+    def export_excel(self, tmpfile_path):
+        """Exports the report in Excel format."""
+        if xlsxwriter is None:
+            raise ImportError(f"{txt('Erreur : Une dépendance nécessaire pour ce format est manquante. Veuillez installer `xlsxwriter` via `pip install xlsxwriter`')}")
+
+        try:
+            workbook = xlsxwriter.Workbook(tmpfile_path, {'in_memory': True})
+            
+            # Définition des formats
+            title_format = workbook.add_format({'bold': True, 'font_size': 20, 'align': 'center', 'valign': 'vcenter'})
+            subheader_format = workbook.add_format({'bold': True, 'font_size': 14, 'bg_color': '#D9D9D9', 'border': 1})
+            text_format = workbook.add_format({'font_size': 11, 'align': 'left', 'valign': 'top', 'text_wrap': True})
+            
+            # Création des feuilles
+            if txt("report_cover_page_title") in self.content.selected_report_sections:
+                cover_sheet = workbook.add_worksheet(txt("report_cover_page_title"))
+                cover_sheet.merge_range('A1:B1', self.report_title_line1, title_format)
+                cover_sheet.merge_range('A2:B2', self.report_title_line2, title_format)
+                cover_sheet.merge_range('A3:B3', self.report_subtitle, text_format)
+
+            if txt("about_this_report_title") in self.content.selected_report_sections:
+                about_sheet = workbook.add_worksheet(txt("about_this_report_title"))
+                about_sheet.write(0, 0, txt("about_this_report_title"), subheader_format)
+                about_sheet.write(1, 0, self.content.get_about_this_report_content(), text_format)
+
+            if txt("data_info_section") in self.content.selected_report_sections:
+                data_info_sheet = workbook.add_worksheet(txt("data_info_section"))
+                data_info_sheet.write(0, 0, txt("data_info_section"), subheader_format)
+                data_info_sheet.write(1, 0, self.content.get_data_info_content(), text_format)
+
+            if txt("report_data_quality_title") in self.content.selected_report_sections:
+                data_quality_sheet = workbook.add_worksheet(txt("report_data_quality_title"))
+                data_quality_sheet.write(0, 0, txt("report_data_quality_title"), subheader_format)
+                data_quality_sheet.write(1, 0, self.content.get_data_quality_content(), text_format)
+                
+            if txt("report_kpis_infographic_title") in self.content.selected_report_sections:
+                kpis_sheet = workbook.add_worksheet(txt("report_kpis_infographic_title"))
+                kpis_sheet.write(0, 0, txt("report_kpis_infographic_title"), subheader_format)
+                # Ajout des KPIs
+                kpis_content = self.content.get_kpis_content()
+                kpis_sheet.write(1, 0, kpis_content, text_format)
+
+
+            if txt("report_ai_observations_title") in self.content.selected_report_sections:
+                observations_sheet = workbook.add_worksheet(txt("report_ai_observations_title"))
+                observations_sheet.write(0, 0, txt("report_ai_observations_title"), subheader_format)
+                observations_sheet.write(1, 0, self.content.get_strategic_observations_content(), text_format)
+            
+            if txt("report_ai_recommendations_title") in self.content.selected_report_sections:
+                recommendations_sheet = workbook.add_worksheet(txt("report_ai_recommendations_title"))
+                recommendations_sheet.write(0, 0, txt("report_ai_recommendations_title"), subheader_format)
+                recommendations_sheet.write(1, 0, self.content.get_strategic_recommendations_content(), text_format)
+
+            if txt("report_methodology_annex_title") in self.content.selected_report_sections:
+                methodology_sheet = workbook.add_worksheet(txt("report_methodology_annex_title"))
+                methodology_sheet.write(0, 0, txt("report_methodology_annex_title"), subheader_format)
+                methodology_sheet.write(1, 0, self.content.get_methodology_content(), text_format)
+
+            if txt("report_glossary_annex_title") in self.content.selected_report_sections:
+                glossary_sheet = workbook.add_worksheet(txt("report_glossary_annex_title"))
+                glossary_sheet.write(0, 0, txt("report_glossary_annex_title"), subheader_format)
+                glossary_sheet.write(1, 0, self.content.get_glossary_content(), text_format)
+                glossary_sheet.set_column(0, 0, 100)
+                glossary_sheet.set_row(1, 150)
+
+            if txt("report_about_app_annex_title") in self.content.selected_report_sections:
+                about_app_sheet = workbook.add_worksheet(txt("report_about_app_annex_title"))
+                about_app_sheet.write(0, 0, txt("report_about_app_annex_title"), subheader_format)
+                about_app_text = self.content.get_about_app_content()
+                about_app_text_formatted = about_app_text.replace('**', '')
+                about_app_sheet.write(1, 0, about_app_text_formatted, text_format)
+                about_app_sheet.set_column(0, 0, 100)
+                about_app_sheet.set_row(1, 400) # Increased height for all content
+
+
+            # --- Footer global ---
+            footer_text_lines = self.content.footer_lines
+            for sheet_name in workbook.sheetnames:
+                worksheet = workbook.get_worksheet_by_name(sheet_name)
+                # Ajouter un pied de page à chaque feuille (peut être fait plus proprement avec un gestionnaire d'événements si xlsxwriter le permet)
+                # Pour un exemple simple, ajoutons-le aux dernières lignes utilisées
+                last_row = worksheet.dim_rowmax + 2
+                worksheet.write(last_row, 0, self.report_footer_text, text_format)
+
+            workbook.close()
+        
+        except Exception as e:
+            st.error(f"Erreur lors de la création du fichier Excel : {e}")

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/report_generator.py

@@ -0,0 +1,461 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime
+from translations import txt, translations, slugify
+import streamlit as st
+import shap
+import matplotlib.pyplot as plt
+from sklearn.metrics import mean_squared_error, accuracy_score, r2_score
+from lightgbm import LGBMClassifier, LGBMRegressor
+import os
+import tempfile
+import re
+from collections import Counter
+from matplotlib.colors import LinearSegmentedColormap
+from sklearn.cluster import KMeans
+from sklearn.ensemble import IsolationForest
+
+class AIRecommender:
+    """
+    Génère des observations stratégiques et des recommandations actionnables
+    basées sur l'analyse des données.
+    """
+    def __init__(self, df: pd.DataFrame, shap_values_data=None, X_test_data=None, txt_func=None, target_column=None):
+        self.df = df
+        self.ai_knowledge_profile = {}
+        self.shap_values_data = shap_values_data
+        self.X_test_data = X_test_data
+        self.txt = txt_func if txt_func else (lambda key, **kwargs: key)
+        self.target_column = target_column
+        self._extract_insights()
+        self.observations = self._generate_potential_strategic_observations()
+        self.recommendations = self._generate_strategic_recommendations()
+
+    def _extract_insights(self):
+        """
+        Phase 1 : Extraction d'Insights Contextuels Approfondis.
+        Cette méthode peuple le ai_knowledge_profile avec des observations
+        spécifiques au domaine immobilier.
+        """
+        df = self.df.copy()
+        
+        # Aperçu des données
+        self.ai_knowledge_profile['num_rows'] = df.shape[0]
+        self.ai_knowledge_profile['num_cols'] = df.shape[1]
+        self.ai_knowledge_profile['column_types'] = df.dtypes.apply(lambda x: x.name).to_dict()
+        self.ai_knowledge_profile['duplicate_rows'] = df.duplicated().sum()
+        
+        # Valeurs manquantes
+        missing_data = df.isnull().sum()
+        self.ai_knowledge_profile['missing_cols'] = missing_data[missing_data > 0].index.tolist()
+        if self.target_column and df[self.target_column].isnull().any():
+            self.ai_knowledge_profile['missing_target_values'] = True
+        else:
+            self.ai_knowledge_profile['missing_target_values'] = False
+        
+        # Détection d'anomalies (Isolation Forest)
+        num_df = df.select_dtypes(include=np.number).dropna()
+        if not num_df.empty:
+            try:
+                model = IsolationForest(random_state=42)
+                outliers = model.fit_predict(num_df)
+                self.ai_knowledge_profile['num_outliers'] = list(outliers).count(-1)
+                self.ai_knowledge_profile['outlier_percentage'] = (self.ai_knowledge_profile['num_outliers'] / len(df)) * 100
+            except Exception:
+                self.ai_knowledge_profile['num_outliers'] = 0
+                self.ai_knowledge_profile['outlier_percentage'] = 0.0
+
+        # Analyse des colonnes numériques
+        num_cols = df.select_dtypes(include=np.number).columns
+        for col in num_cols:
+            self.ai_knowledge_profile[f'median_of_{col}'] = df[col].median()
+            self.ai_knowledge_profile[f'mean_of_{col}'] = df[col].mean()
+            self.ai_knowledge_profile[f'std_of_{col}'] = df[col].std()
+            
+            # Détection d'asymétrie
+            if len(df[col].dropna()) > 1:
+                skewness = df[col].skew()
+                if abs(skewness) > 1: # Seuil pour considérer une distribution asymétrique
+                    self.ai_knowledge_profile[f'skewed_distribution_{col}'] = True
+                else:
+                    self.ai_knowledge_profile[f'skewed_distribution_{col}'] = False
+            else:
+                self.ai_knowledge_profile[f'skewed_distribution_{col}'] = False
+
+            # Faible variance
+            if df[col].nunique() < 5 and len(df[col].dropna()) > 0: # Moins de 5 valeurs uniques pour une colonne numérique
+                 if df[col].std() < 0.1: # Seuil arbitraire pour faible écart-type
+                     self.ai_knowledge_profile[f'low_variance_{col}'] = True
+                 else:
+                     self.ai_knowledge_profile[f'low_variance_{col}'] = False
+            else:
+                self.ai_knowledge_profile[f'low_variance_{col}'] = False
+
+
+        # Analyse des colonnes catégorielles
+        cat_cols = df.select_dtypes(include=['object', 'category']).columns
+        for col in cat_cols:
+            top_value = df[col].mode()[0]
+            self.ai_knowledge_profile[f'top_category_in_{col}'] = top_value
+            self.ai_knowledge_profile[f'top_category_count_in_{col}'] = df[col].value_counts().get(top_value, 0)
+            
+            # Déséquilibre de classes
+            value_counts = df[col].value_counts(normalize=True)
+            if value_counts.min() < 0.1 and len(value_counts) > 1: # Si une classe représente moins de 10%
+                self.ai_knowledge_profile[f'categorical_imbalance_{col}'] = True
+                self.ai_knowledge_profile[f'minority_category_{col}'] = value_counts.idxmin()
+            else:
+                self.ai_knowledge_profile[f'categorical_imbalance_{col}'] = False
+
+            # Cardinalité élevée
+            if df[col].nunique() / df.shape[0] > 0.5: # Si plus de 50% de valeurs uniques
+                self.ai_knowledge_profile[f'high_cardinality_{col}'] = df[col].nunique()
+            else:
+                self.ai_knowledge_profile[f'high_cardinality_{col}'] = None
+
+
+        # Clustering (K-Means)
+        if not num_df.empty and len(num_df) > 1 and len(num_df) >= 3: # Au moins 3 points pour 3 clusters
+            try:
+                kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
+                clusters = kmeans.fit_predict(num_df)
+                self.ai_knowledge_profile['cluster_means'] = kmeans.cluster_centers_.tolist()
+            except Exception:
+                self.ai_knowledge_profile['cluster_means'] = []
+        else:
+            self.ai_knowledge_profile['cluster_means'] = []
+
+        # Analyse des dates
+        datetime_cols = df.select_dtypes(include=['datetime64']).columns
+        for col in datetime_cols:
+            if len(df[col].dropna()) > 1:
+                # Vérifier si la colonne est effectivement une série temporelle avec une tendance
+                # Une détection simple ici : si la moyenne des différences consécutives est non nulle
+                # et que les valeurs ne sont pas toutes identiques.
+                diffs = df[col].diff().dropna()
+                if not diffs.empty and diffs.mean() != 0 and df[col].nunique() > 1:
+                    self.ai_knowledge_profile[f'time_series_trend_{col}'] = True
+                else:
+                    self.ai_knowledge_profile[f'time_series_trend_{col}'] = False
+            else:
+                self.ai_knowledge_profile[f'time_series_trend_{col}'] = False
+        
+        # Multicolinéarité
+        if num_df.shape[1] > 1:
+            corr_matrix = num_df.corr().abs()
+            # Compter les paires avec une corrélation très élevée (excluant la diagonale)
+            upper_tri = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
+            to_drop = [column for column in upper_tri.columns if any(upper_tri[column] > 0.9)] # Seuil > 0.9 pour forte multicolinéarité
+            if len(to_drop) > 0:
+                self.ai_knowledge_profile['multicollinearity'] = True
+                self.ai_knowledge_profile['highly_correlated_cols'] = to_drop
+            else:
+                self.ai_knowledge_profile['multicollinearity'] = False
+        else:
+            self.ai_knowledge_profile['multicollinearity'] = False
+
+
+    def _generate_potential_strategic_observations(self):
+        """
+        Phase 2 : Génération d'observations stratégiques en se basant sur les insights.
+        Retourne une liste des observations les plus pertinentes.
+        """
+        observations_list = []
+        
+        # Règle 1: Observation sur les valeurs manquantes
+        if self.ai_knowledge_profile.get('missing_cols'):
+            observations_list.append(self.txt("obs_missing_values").format(
+                cols=", ".join(self.ai_knowledge_profile['missing_cols'])
+            ))
+        
+        # Règle 2: Observation sur les valeurs aberrantes
+        outlier_percent = self.ai_knowledge_profile.get('outlier_percentage', 0)
+        if outlier_percent > 5.0:
+            observations_list.append(self.txt("obs_high_outlier_rate").format(
+                percent=f"{outlier_percent:.2f}"
+            ))
+        elif outlier_percent > 0:
+            observations_list.append(self.txt("obs_outliers_exist").format(
+                percent=f"{outlier_percent:.2f}"
+            ))
+
+        # Règle 3: Observation sur les clusters de données
+        if self.ai_knowledge_profile.get('cluster_means'):
+            observations_list.append(self.txt("obs_data_clusters"))
+
+        # Règle 4: Observation sur la distribution des prix (s'il y a une colonne de prix)
+        price_col = None
+        for col in self.df.columns:
+            if re.search(r'prix|price', col, re.IGNORECASE) and self.df[col].dtype in ['int64', 'float64']:
+                price_col = col
+                break
+        
+        if price_col:
+            median_price = self.ai_knowledge_profile.get(f'median_of_{price_col}')
+            if median_price:
+                observations_list.append(self.txt("obs_median_price").format(
+                    price=median_price, col=price_col
+                ))
+
+        # Règle 5: Observation sur la corrélation
+        # Cette règle est maintenant intégrée directement dans _extract_insights
+        num_df = self.df.select_dtypes(include=np.number)
+        if num_df.shape[1] > 1:
+            corr_matrix = num_df.corr().abs()
+            high_corr_pairs = []
+            # On cherche des corrélations > 0.8 (moins strict que multicolinéarité)
+            for col1 in corr_matrix.columns:
+                for col2 in corr_matrix.index:
+                    if col1 != col2 and corr_matrix.loc[col1, col2] > 0.8:
+                        pair = sorted([col1, col2])
+                        if pair not in high_corr_pairs: # Éviter les doublons (A,B) et (B,A)
+                            high_corr_pairs.append(pair)
+            
+            if high_corr_pairs:
+                observations_list.append(self.txt("obs_high_correlation").format(
+                    pairs=", ".join([f"({p[0]}, {p[1]})" for p in high_corr_pairs])
+                ))
+        
+        # Nouvelles observations basées sur les insights
+        for col in self.df.select_dtypes(include=np.number).columns:
+            if self.ai_knowledge_profile.get(f'skewed_distribution_{col}'):
+                observations_list.append(self.txt("obs_skewed_distribution").format(col=col))
+            if self.ai_knowledge_profile.get(f'low_variance_{col}'):
+                observations_list.append(self.txt("obs_low_variance").format(col=col))
+
+        for col in self.df.select_dtypes(include=['object', 'category']).columns:
+            if self.ai_knowledge_profile.get(f'categorical_imbalance_{col}'):
+                observations_list.append(self.txt("obs_categorical_imbalance").format(
+                    col=col, minority=self.ai_knowledge_profile[f'minority_category_{col}']
+                ))
+            if self.ai_knowledge_profile.get(f'high_cardinality_{col}'):
+                observations_list.append(self.txt("obs_high_cardinality").format(
+                    col=col, count=self.ai_knowledge_profile[f'high_cardinality_{col}']
+                ))
+        
+        for col in self.df.select_dtypes(include=['datetime64']).columns:
+            if self.ai_knowledge_profile.get(f'time_series_trend_{col}'):
+                observations_list.append(self.txt("obs_time_series_trend").format(col=col))
+
+        if self.ai_knowledge_profile.get('missing_target_values') and self.target_column:
+            observations_list.append(self.txt("obs_missing_target_values").format(target_col=self.target_column))
+
+        if self.ai_knowledge_profile.get('duplicate_rows') > 0:
+            observations_list.append(self.txt("obs_duplicate_rows").format(count=self.ai_knowledge_profile['duplicate_rows']))
+
+        if self.ai_knowledge_profile.get('multicollinearity'):
+            observations_list.append(self.txt("obs_multicollinearity"))
+
+        # Sélectionner les 5 observations les plus pertinentes (ou moins si moins de 5)
+        # Ceci est une simplification. Dans une vraie application, on pourrait prioriser
+        # ou utiliser des scores pour choisir les plus impactantes.
+        return observations_list[:5] # Limiter à 5 observations
+
+
+    def _generate_strategic_recommendations(self):
+        """
+        Génère les recommandations stratégiques en se basant sur les insights.
+        Retourne une liste des recommandations les plus pertinentes.
+        """
+        recommendations_list = []
+        
+        # Règle 1: Recommandation sur la préparation des données
+        if self.ai_knowledge_profile.get('missing_cols') or self.ai_knowledge_profile.get('num_outliers', 0) > 0:
+            recommendations_list.append(self.txt("rec_data_prep_focus"))
+
+        # Règle 2: Recommandation sur l'analyse des caractéristiques SHAP
+        if self.shap_values_data is not None and self.X_test_data is not None and not self.X_test_data.empty:
+            try:
+                shap_df = pd.DataFrame(self.shap_values_data.values, columns=self.X_test_data.columns)
+                mean_abs_shap = shap_df.abs().mean().sort_values(ascending=False)
+                top_features = mean_abs_shap.index[:3].tolist()
+                if top_features:
+                    recommendations_list.append(self.txt("rec_focus_on_features").format(
+                        features=", ".join(top_features)
+                    ))
+            except Exception:
+                pass # Ignorer si SHAP a échoué
+
+        # Règle 3: Recommandation pour les modèles de clustering
+        if self.ai_knowledge_profile.get('cluster_means'):
+            recommendations_list.append(self.txt("rec_explore_segmentation"))
+
+        # Règle 4: Recommandation pour la détection d'anomalies
+        if self.ai_knowledge_profile.get('num_outliers', 0) > 0:
+            recommendations_list.append(self.txt("rec_investigate_anomalies"))
+
+        # Règle 5: Recommandation sur la collecte de données supplémentaires
+        if self.df.shape[0] < 500: # Seuil arbitraire
+             recommendations_list.append(self.txt("rec_collect_more_data"))
+        
+        # Règle 6: Recommandation pour l'ingénierie des caractéristiques
+        num_cols = self.df.select_dtypes(include=np.number).columns
+        if len(num_cols) >= 2:
+            recommendations_list.append(self.txt("rec_feature_engineering_terms"))
+        
+        # Nouvelles recommandations basées sur les insights
+        for col in self.df.select_dtypes(include=np.number).columns:
+            if self.ai_knowledge_profile.get(f'skewed_distribution_{col}'):
+                recommendations_list.append(self.txt("rec_handle_skewness").format(col=col))
+            if self.ai_knowledge_profile.get(f'low_variance_{col}'):
+                recommendations_list.append(self.txt("rec_remove_low_variance_features").format(col=col))
+
+        for col in self.df.select_dtypes(include=['object', 'category']).columns:
+            if self.ai_knowledge_profile.get(f'categorical_imbalance_{col}'):
+                recommendations_list.append(self.txt("rec_balance_categories").format(col=col))
+            if self.ai_knowledge_profile.get(f'high_cardinality_{col}'):
+                recommendations_list.append(self.txt("rec_dimensionality_reduction").format(col=col))
+        
+        for col in self.df.select_dtypes(include=['datetime64']).columns:
+            if self.ai_knowledge_profile.get(f'time_series_trend_{col}'):
+                recommendations_list.append(self.txt("rec_time_series_model"))
+
+        if self.ai_knowledge_profile.get('missing_target_values') and self.target_column:
+            recommendations_list.append(self.txt("rec_clean_target_missing").format(target_col=self.target_column))
+
+        if self.ai_knowledge_profile.get('duplicate_rows') > 0:
+            recommendations_list.append(self.txt("rec_deduplicate_data"))
+
+        if self.ai_knowledge_profile.get('multicollinearity'):
+            recommendations_list.append(self.txt("rec_address_multicollinearity"))
+
+        # Sélectionner les 5 recommandations les plus pertinentes (ou moins si moins de 5)
+        return recommendations_list[:5] # Limiter à 5 recommandations
+
+    def get_strategic_observations(self):
+        return self.observations
+
+    def get_strategic_recommendations(self):
+        return self.recommendations
+
+
+class ReportContent:
+    """
+    Génère le contenu des différentes sections du rapport.
+    """
+    def __init__(self, df: pd.DataFrame, model=None, shap_values_data=None, X_test_data=None, y_test_data=None, target_column=None, model_type=None, txt_func=None):
+        self.df = df
+        self.model = model
+        self.shap_values_data = shap_values_data
+        self.X_test_data = X_test_data
+        self.y_test_data = y_test_data
+        self.target_column = target_column
+        self.model_type = model_type
+        self.txt = txt_func if txt_func else (lambda key, **kwargs: key)
+        self.report_options = {}
+        self.custom_logo_path = None
+        self.report_title_line2 = txt("default_report_title_line2")
+        
+        self.ai_recommender = AIRecommender(
+            df=self.df,
+            shap_values_data=self.shap_values_data,
+            X_test_data=self.X_test_data,
+            txt_func=self.txt,
+            target_column=self.target_column # Passer la colonne cible au recommender
+        )
+        
+        self.available_report_sections = [
+            txt("report_cover_page_title"),
+            txt("about_this_report_title"),
+            txt("data_info_section"),
+            txt("report_data_quality_title"),
+            txt("report_kpis_infographic_title"),
+            txt("report_ai_observations_title"),
+            txt("report_ai_recommendations_title"),
+            txt("report_methodology_annex_title"),
+            txt("report_glossary_annex_title"),
+            txt("report_about_app_annex_title")
+        ]
+        
+    def update_report_options(self, options):
+        self.report_options = options
+        self.selected_report_sections = options.get('selected_report_sections', [])
+        
+    def get_about_this_report_content(self):
+        return self.txt("about_this_report_content")
+
+    def get_data_info_content(self):
+        overview = {
+            "Numéro de lignes": self.df.shape[0],
+            "Numéro de colonnes": self.df.shape[1],
+            "Types de colonnes": self.df.dtypes.to_dict()
+        }
+        content = self.txt("data_info_intro") + "\n\n"
+        for key, value in overview.items():
+            content += f"- **{key}** : {value}\n"
+        return content
+
+    def get_data_quality_content(self):
+        missing_summary = self.df.isnull().sum()
+        missing_summary = missing_summary[missing_summary > 0].to_dict()
+        
+        outliers = detect_outliers_isolation_forest(self.df.copy())
+        num_outliers = (outliers['outlier_score'] == -1).sum()
+        
+        content = self.txt("data_quality_intro") + "\n\n"
+        content += self.txt("missing_values_title") + ":\n"
+        if missing_summary:
+            for col, count in missing_summary.items():
+                content += f"- **{col}** : {count} ({count/len(self.df)*100:.2f}%)\n"
+        else:
+            content += self.txt("no_missing_values") + "\n"
+            
+        content += "\n" + self.txt("outlier_detection_title") + ":\n"
+        content += f"- {num_outliers} outliers détectés ({num_outliers/len(self.df)*100:.2f}%).\n"
+        
+        return content
+
+    def get_kpis_content(self):
+        if self.model and self.y_test_data is not None and self.X_test_data is not None and not self.X_test_data.empty:
+            y_pred = self.model.predict(self.X_test_data)
+            
+            content = self.txt("kpis_intro") + "\n\n"
+            
+            if self.model_type == self.txt("regression_model"):
+                rmse = np.sqrt(mean_squared_error(self.y_test_data, y_pred))
+                r2 = r2_score(self.y_test_data, y_pred)
+                content += f"- **{self.txt('rmse')}** : {rmse:.2f}\n"
+                content += f"- **{self.txt('r2_score')}** : {r2:.2f}\n"
+            else:
+                accuracy = accuracy_score(self.y_test_data, y_pred.round())
+                content += f"- **{self.txt('accuracy')}** : {accuracy:.2f}\n"
+            
+            return content
+        else:
+            return self.txt("no_kpis_available")
+
+    def get_strategic_observations_content(self):
+        observations = self.ai_recommender.get_strategic_observations()
+        if observations:
+            content = self.txt('res_observations_intro') + "\n\n"
+            content += "\n".join([f"- {obs}" for obs in observations])
+            return content
+        else:
+            return self.txt("no_observations_available")
+
+    def get_strategic_recommendations_content(self):
+        recommendations = self.ai_recommender.get_strategic_recommendations()
+        if recommendations:
+            content = ""
+            for rec in recommendations:
+                content += f"- {rec}\n"
+            return content
+        else:
+            return self.txt("no_recommendations_available")
+
+    def get_methodology_content(self):
+        """Returns the methodology content for the report."""
+        content = self.txt("methodology_intro") + "\n\n"
+        content += self.txt("methodology_data_prep") + "\n"
+        content += self.txt("methodology_model_training") + "\n"
+        content += self.txt("methodology_shap_explanation") + "\n"
+        content += self.txt("methodology_report_generation") + "\n"
+        content += self.txt("methodology_data_confidentiality") + "\n"
+        return content
+
+    def get_glossary_content(self):
+        """Returns the glossary content for the report."""
+        return self.txt("glossary_full_text")
+
+    def get_about_app_content(self):
+        return self.txt("about_app_content")

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/report_pdf_exporter.py

@@ -0,0 +1,203 @@
+import pandas as pd
+import numpy as np
+import os
+import io
+import base64
+import tempfile
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.pdfgen import canvas
+from reportlab.lib.utils import ImageReader
+from PIL import Image
+import json
+from matplotlib.colors import LinearSegmentedColormap
+from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_RIGHT
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.platypus import Paragraph, Spacer
+from reportlab.lib.colors import black, blue, green, red, HexColor
+from reportlab.platypus import Table, TableStyle
+
+from translations import txt, slugify
+from report_generator import ReportContent
+
+class PdfCore:
+    """
+    Gère la logique de base de la création de PDF en utilisant ReportLab.
+    Fournit des méthodes pour la gestion du canevas, des styles, des en-têtes/pieds de page,
+    et l'ajout générique de texte, images et tableaux.
+    """
+
+    def __init__(self, canvas_obj, report_title_line1, report_title_line2, report_footer_text):
+        """
+        Initialise PdfCore avec un objet canvas ReportLab et des informations de rapport.
+        """
+        self.c = canvas_obj
+        self.report_title_line1 = report_title_line1
+        self.report_title_line2 = report_title_line2
+        self.report_footer_text = report_footer_text
+        self.width, self.height = A4
+        self.margin = 50
+        self.styles = getSampleStyleSheet()
+        self.styles.add(ParagraphStyle(name='TitleStyle', fontSize=20, leading=24, alignment=TA_CENTER, fontName='Helvetica-Bold'))
+        self.styles.add(ParagraphStyle(name='SubtitleStyle', fontSize=14, leading=16, alignment=TA_CENTER))
+        self.styles.add(ParagraphStyle(name='SectionTitleStyle', fontSize=16, leading=20, alignment=TA_LEFT, fontName='Helvetica-Bold'))
+        self.styles.add(ParagraphStyle(name='ParagraphStyle', fontSize=10, leading=12, alignment=TA_LEFT, text_wrap=True))
+        self.c.setPageSize(A4)
+
+    def add_header(self, page_num):
+        """Ajoute l'en-tête de page."""
+        self.c.setFont('Helvetica-Bold', 10)
+        self.c.drawString(self.margin, self.height - 30, f"{self.report_title_line1} {self.report_title_line2}")
+        self.c.drawString(self.width - self.margin - 20, self.height - 30, f"Page {page_num}")
+
+    def add_footer(self):
+        """Ajoute le pied de page."""
+        self.c.setFont('Helvetica', 8)
+        self.c.drawString(self.margin, 30, self.report_footer_text)
+
+    def add_section_title(self, y_cursor, title):
+        """Ajoute un titre de section au PDF."""
+        p_title = Paragraph(title, self.styles['SectionTitleStyle'])
+        p_title.wrapOn(self.c, self.width - 2 * self.margin, self.height)
+        p_title.drawOn(self.c, self.margin, y_cursor - p_title.height)
+        return y_cursor - p_title.height - 10
+
+    def add_paragraph(self, y_cursor, text):
+        """Ajoute un paragraphe de texte au PDF."""
+        p_text = Paragraph(text, self.styles['ParagraphStyle'])
+        p_text.wrapOn(self.c, self.width - 2 * self.margin, self.height)
+        if y_cursor - p_text.height < self.margin:
+            self.c.showPage()
+            y_cursor = self.height - self.margin
+        p_text.drawOn(self.c, self.margin, y_cursor - p_text.height)
+        return y_cursor - p_text.height - 10
+
+    def add_image_from_plt(self, y_cursor, fig):
+        """Ajoute une image à partir d'une figure Matplotlib."""
+        img_buffer = io.BytesIO()
+        fig.savefig(img_buffer, format='png', bbox_inches='tight')
+        img_buffer.seek(0)
+        img = ImageReader(img_buffer)
+        aspect = img.getSize()[1] / img.getSize()[0]
+        img_width = self.width * 0.8
+        img_height = img_width * aspect
+        
+        if y_cursor - img_height < self.margin:
+            self.c.showPage()
+            y_cursor = self.height - self.margin
+        
+        self.c.drawImage(img, self.margin + (self.width - 2*self.margin - img_width)/2, y_cursor - img_height, width=img_width, height=img_height)
+        plt.close(fig) # Ferme la figure pour libérer la mémoire
+        return y_cursor - img_height - 10
+        
+class PdfExporter:
+    """Class to export reports in PDF format."""
+
+    def __init__(self, report_content):
+        self.content = report_content
+        self.report_title_line1 = self.content.report_options['report_custom_title_line1']
+        self.report_title_line2 = self.content.report_title_line2
+        self.report_subtitle = self.content.report_options['report_custom_subtitle']
+        self.report_footer_text = self.content.report_options['report_custom_footer']
+
+    def export_pdf(self, buffer):
+        c = canvas.Canvas(buffer, pagesize=A4)
+        pdf_core = PdfCore(c, self.report_title_line1, self.report_title_line2, self.report_footer_text)
+        page_num = 1
+        
+        for section in self.content.selected_report_sections:
+            if section == txt("report_cover_page_title"):
+                pdf_core.c.showPage()
+                y_cursor = pdf_core.height / 2
+                p_title = Paragraph(self.report_title_line1, pdf_core.styles['TitleStyle'])
+                p_subtitle = Paragraph(self.report_title_line2, pdf_core.styles['TitleStyle'])
+                p_custom_subtitle = Paragraph(self.report_subtitle, pdf_core.styles['SubtitleStyle'])
+
+                p_title.wrapOn(c, pdf_core.width, pdf_core.height)
+                p_title.drawOn(c, pdf_core.margin, y_cursor)
+                y_cursor -= p_title.height
+                p_subtitle.wrapOn(c, pdf_core.width, pdf_core.height)
+                p_subtitle.drawOn(c, pdf_core.margin, y_cursor)
+                y_cursor -= p_subtitle.height
+                p_custom_subtitle.wrapOn(c, pdf_core.width, pdf_core.height)
+                p_custom_subtitle.drawOn(c, pdf_core.margin, y_cursor)
+                
+            elif section == txt("about_this_report_title"):
+                pdf_core.c.showPage()
+                page_num += 1
+                pdf_core.add_header(page_num)
+                pdf_core.add_footer()
+                y_cursor = pdf_core.height - pdf_core.margin
+                y_cursor = pdf_core.add_section_title(y_cursor, txt("about_this_report_title"))
+                y_cursor = pdf_core.add_paragraph(y_cursor, self.content.get_about_this_report_content())
+
+            elif section == txt("data_info_section"):
+                pdf_core.c.showPage()
+                page_num += 1
+                pdf_core.add_header(page_num)
+                pdf_core.add_footer()
+                y_cursor = pdf_core.height - pdf_core.margin
+                y_cursor = pdf_core.add_section_title(y_cursor, txt("data_info_section"))
+                y_cursor = pdf_core.add_paragraph(y_cursor, self.content.get_data_info_content())
+
+            elif section == txt("report_data_quality_title"):
+                pdf_core.c.showPage()
+                page_num += 1
+                pdf_core.add_header(page_num)
+                pdf_core.add_footer()
+                y_cursor = pdf_core.height - pdf_core.margin
+                y_cursor = pdf_core.add_section_title(y_cursor, txt("report_data_quality_title"))
+                y_cursor = pdf_core.add_paragraph(y_cursor, self.content.get_data_quality_content())
+
+            elif section == txt("report_kpis_infographic_title"):
+                pdf_core.c.showPage()
+                page_num += 1
+                pdf_core.add_header(page_num)
+                pdf_core.add_footer()
+                y_cursor = pdf_core.height - pdf_core.margin
+                y_cursor = pdf_core.add_section_title(y_cursor, txt("report_kpis_infographic_title"))
+                y_cursor = pdf_core.add_paragraph(y_cursor, self.content.get_kpis_content())
+
+            elif section == txt("report_ai_observations_title"):
+                pdf_core.c.showPage()
+                page_num += 1
+                pdf_core.add_header(page_num)
+                pdf_core.add_footer()
+                y_cursor = pdf_core.height - pdf_core.margin
+                y_cursor = pdf_core.add_section_title(y_cursor, txt("report_ai_observations_title"))
+                y_cursor = pdf_core.add_paragraph(y_cursor, self.content.get_strategic_observations_content())
+                c.showPage()
+                page_num += 1
+            
+            elif section == txt("report_ai_recommendations_title"):
+                y_cursor = pdf_core.height - pdf_core.margin
+                y_cursor = pdf_core.add_section_title(y_cursor, txt("report_ai_recommendations_title"))
+                y_cursor = pdf_core.add_paragraph(y_cursor, self.content.get_strategic_recommendations_content())
+                c.showPage()
+                page_num += 1
+
+            # Annexes
+            elif section == txt("report_methodology_annex_title"):
+                y_cursor = pdf_core.height - pdf_core.margin
+                y_cursor = pdf_core.add_section_title(y_cursor, txt("report_methodology_annex_title"))
+                y_cursor = pdf_core.add_paragraph(y_cursor, self.content.get_methodology_content())
+                c.showPage()
+                page_num += 1
+
+            elif section == txt("report_glossary_annex_title"):
+                y_cursor = pdf_core.height - pdf_core.margin
+                y_cursor = pdf_core.add_section_title(y_cursor, txt("report_glossary_annex_title"))
+                y_cursor = pdf_core.add_paragraph(y_cursor, self.content.get_glossary_content())
+                c.showPage()
+                page_num += 1
+
+            elif section == txt("report_about_app_annex_title"):
+                y_cursor = pdf_core.height - pdf_core.margin
+                y_cursor = pdf_core.add_section_title(y_cursor, txt("report_about_app_annex_title"))
+                y_cursor = pdf_core.add_paragraph(y_cursor, self.content.get_about_app_content())
+                c.showPage()
+                page_num += 1
+
+        c.save()

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/translations.py

@@ -0,0 +1,142 @@
+import streamlit as st
+import unicodedata
+import string
+import re
+import hashlib
+import json
+import pandas as pd
+import numpy as np
+from datetime import datetime
+
+
+# Importation des dictionnaires de traduction spécifiques
+from translations_base import fr_translations_base # load_users et save_users ne sont plus importés ici
+from translations_data_processing import fr_translations_data_processing
+from translations_ai_report import fr_translations_ai_report
+from translations_report_content import fr_translations_report_content
+
+# Variable globale pour stocker le code de la langue actuelle
+_current_language_code = 'fr'
+
+# --- Données de Démonstration Fictives ---
+# Ces données sont intégrées directement pour le mode démo.
+# Elles représentent un petit jeu de données immobilier avec des types variés.
+demo_data_fr = {
+    "ID_Propriete": [101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115],
+    "Type_Propriete": ["Appartement", "Maison", "Appartement", "Maison", "Appartement", "Studio", "Maison", "Appartement", "Maison", "Appartement", "Studio", "Maison", "Appartement", "Maison", "Loft"],
+    "Surface_m2": [75, 120, 90, 150, 60, 30, 180, 85, 130, 70, 35, 200, 95, 160, 100],
+    "Nombre_Pieces": [3, 5, 4, 6, 2, 1, 7, 3, 5, 3, 1, 8, 4, 6, 3],
+    "Prix": [350000, 600000, 420000, 750000, 280000, 180000, 900000, 380000, 650000, 320000, 195000, 1100000, 450000, 800000, 500000],
+    "Date_Construction": ["2005-01-15", "1998-06-20", "2010-03-01", "1975-11-10", "2015-08-22", "2020-02-01", "1960-04-05", "2008-09-12", "1985-07-30", "2012-05-01", "2021-01-01", "1950-02-15", "2000-11-20", "1970-03-25", "2018-04-10"],
+    "Localisation": ["Paris", "Lyon", "Marseille", "Toulouse", "Nice", "Bordeaux", "Nantes", "Strasbourg", "Montpellier", "Lille", "Rennes", "Reims", "Le Havre", "Saint-Étienne", "Dijon"],
+    "Latitude": [48.8566, 45.7640, 43.2965, 43.6047, 43.7102, 44.8378, 47.2184, 48.5734, 43.6108, 50.6292, 48.1173, 49.2583, 49.4944, 45.4397, 47.3220],
+    "Longitude": [2.3522, 4.8357, 5.3698, 1.4442, 7.2620, -0.5792, -1.5536, 7.7521, 3.8767, 3.0573, -1.6778, 4.0317, 0.1077, 4.3899, 5.0415],
+    "Description": [
+        "Bel appartement en centre-ville, proche commodités.",
+        "Grande maison familiale avec jardin, quartier calme.",
+        "Appartement moderne avec balcon, vue imprenable.",
+        "Maison de caractère rénovée, grand terrain arboré.",
+        "Petit appartement idéal étudiant ou jeune couple.",
+        "Studio fonctionnel, lumineux, proche transports.",
+        "Propriété d'exception avec piscine, grand luxe.",
+        "Appartement traversant, lumineux, deux chambres.",
+        "Maison avec potentiel, travaux à prévoir, bon investissement.",
+        "Appartement refait à neuf, équipements modernes.",
+        "Studio étudiant avec kitchenette, très demandé.",
+        "Vaste demeure historique, cadre unique, grand parc.",
+        "Appartement spacieux, à rénover, forte demande locative.",
+        "Maison avec jardin, proche écoles et commerces.",
+        "Loft design, esprit industriel, très recherché."
+    ]
+}
+
+# Fusionner tous les dictionnaires de traduction pour chaque langue
+translations = {
+    "fr": {
+        **fr_translations_base,
+        **fr_translations_data_processing,
+        **fr_translations_ai_report,
+        **fr_translations_report_content,
+        "demo_data": demo_data_fr, # Ajout des données de démo
+        # Nouvelles observations pour enrichir le modèle AIRecommender
+        "obs_skewed_distribution": "La distribution de la colonne '{col}' est asymétrique, ce qui peut affecter les performances de certains modèles. Une transformation des données pourrait être bénéfique.",
+        "obs_categorical_imbalance": "La colonne catégorielle '{col}' présente un déséquilibre important de classes, avec la catégorie '{minority}' sous-représentée. Cela peut biaiser les prédictions pour cette classe.",
+        "obs_high_cardinality": "La colonne '{col}' a une cardinalité élevée ({count} valeurs uniques). Cela pourrait rendre l'encodage coûteux et potentiellement introduire du surapprentissage.",
+        "obs_time_series_trend": "Une tendance claire a été détectée dans la colonne de date '{col}', suggérant que le temps est un facteur important dans les variations des données.",
+        "obs_missing_target_values": "Des valeurs manquantes ont été trouvées dans la colonne cible '{target_col}'. Il est crucial de les traiter avant l'entraînement du modèle.",
+        "obs_low_variance": "La colonne '{col}' présente une très faible variance, ce qui signifie qu'elle ne contient pas beaucoup d'informations utiles pour le modèle et pourrait être retirée.",
+        "obs_duplicate_rows": "Des lignes dupliquées ({count} duplicata) ont été identifiées dans le jeu de données. Leur suppression peut améliorer la qualité de l'analyse.",
+        "obs_multicollinearity": "Une forte multicolinéarité est présente parmi les variables. Cela peut rendre l'interprétation des coefficients du modèle difficile et impacter sa stabilité.",
+
+        # Nouvelles recommandations pour enrichir le modèle AIRecommender
+        "rec_handle_skewness": "Envisagez d'appliquer une transformation logarithmique ou Box-Cox à la colonne '{col}' pour normaliser sa distribution et améliorer la performance du modèle.",
+        "rec_balance_categories": "Pour la colonne '{col}', utilisez des techniques de rééchantillonnage (suréchantillonnage ou sous-échantillonnage) pour équilibrer les classes et éviter le biais du modèle.",
+        "rec_dimensionality_reduction": "Compte tenu de la cardinalité élevée de la colonne '{col}', explorez des techniques de réduction de dimensionnalité (comme le PCA ou l'encodage d'entités) pour gérer cette variable.",
+        "rec_time_series_model": "Puisqu'une tendance temporelle a été observée, l'utilisation de modèles de séries chronologiques (ARIMA, Prophet) pourrait être plus appropriée pour des prédictions futures.",
+        "rec_clean_target_missing": "Nettoyez ou imputez soigneusement les valeurs manquantes dans la colonne cible '{target_col}' pour garantir l'intégrité de l'entraînement du modèle.",
+        "rec_remove_low_variance_features": "Supprimez la colonne '{col}' en raison de sa faible variance. Elle n'apporte pas d'informations significatives au modèle.",
+        "rec_deduplicate_data": "Supprimez les lignes dupliquées pour éviter que le modèle n'apprenne sur des observations redondantes et n'en surestime l'importance.",
+        "rec_address_multicollinearity": "Utilisez des méthodes comme l'analyse en composantes principales (PCA) ou la suppression de l'une des variables fortement corrélées pour gérer la multicolinéarité."
+    }
+}
+
+# Utility function to get translated text
+def txt(key, **kwargs):
+    """
+    Récupère la traduction pour une clé donnée dans la langue actuelle, avec un avertissement si non trouvée.
+    Permet également le formatage de chaînes avec des arguments nommés.
+    """
+    global _current_language_code
+
+    # Vérifier si la clé est présente directement dans la langue actuelle
+    translation = translations[_current_language_code].get(key)
+    if translation is not None:
+        try:
+            return translation.format(**kwargs)
+        except KeyError:
+            return translation
+    
+    # Si la clé n'est pas trouvée directement, chercher dans les sous-dictionnaires
+    for _, lang_dict in translations.items():
+        if key in lang_dict:
+            try:
+                return lang_dict[key].format(**kwargs)
+            except KeyError:
+                return lang_dict[key]
+        # Vérifier si la clé est dans un sous-dictionnaire comme "users" ou "demo_data"
+        for sub_key, sub_dict in lang_dict.items():
+            if isinstance(sub_dict, dict) and key in sub_dict:
+                try:
+                    return sub_dict[key].format(**kwargs)
+                except KeyError:
+                    return sub_dict[key]
+
+
+    return f"[{key}]"
+
+
+def set_language(lang_code):
+    """Définit la langue actuelle."""
+    global _current_language_code
+    if lang_code in translations:
+        _current_language_code = lang_code
+    else:
+        st.warning(f"La langue '{lang_code}' n'est pas supportée. Utilisation du français par défaut.", icon="⚠️")
+        _current_language_code = 'fr'
+
+
+def slugify(value):
+    """
+    Convertit une chaîne en un format compatible avec les noms de fichiers.
+    """
+    value = str(value)
+    # Normalise la chaîne pour supprimer les accents et les caractères spéciaux
+    value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore').decode('utf-8')
+    # Remplace les espaces et les tirets par des tirets
+    value = re.sub(r'[-\s]+', '-', value).strip('-_')
+    # Supprime les caractères non alphanumériques sauf les tirets
+    value = re.sub(r'[^\w\s-]', '', value)
+    return value.lower()
+
+# Les fonctions _get_users_file_path, load_users, save_users ne sont plus ici
+# Elles sont déplacées dans translations_base.py

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/translations_ai_report.py

@@ -0,0 +1,68 @@
+# translations_ai_report.py - Contient les traductions pour la prédiction IA et la génération de rapports
+
+# Dictionnaire pour la langue française
+fr_translations_ai_report = {
+    "model_training": "Entraînement du Modèle",
+    "select_target_column": "Sélectionnez la colonne cible",
+    "select_model_type": "Sélectionnez le type de modèle",
+    "regression_model": "Modèle de Régression",
+    "classification_model": "Modèle de Classification",
+    "train_model_button": "Entraîner le Modèle",
+    "training_model_in_progress": "Entraînement du modèle en cours...",
+    "model_trained_success": "Modèle entraîné avec succès !",
+    "feature_importance_shap": "Importance des Caractéristiques (SHAP)",
+    "shap_values_calculated": "Valeurs SHAP calculées et graphique généré.",
+    "select_target_column_prompt": "Veuillez sélectionner une colonne cible pour l'entraînement du modèle.",
+    "model_performance": "Performance du Modèle",
+    "accuracy": "Précision",
+    "rmse": "RMSE",
+    "r2_score": "Score R²",
+    "upload_data_for_report_prompt": "Veuillez télécharger un fichier de données et le préparer pour générer un rapport.",
+    "shap_summary_plot": "Graphique récapitulatif SHAP",
+    "report_customization_title": "Personnalisation du Rapport",
+    "custom_report_title_line1_label": "Titre du Rapport (Ligne 1)",
+    "custom_report_subtitle_label": "Sous-titre du Rapport",
+    "custom_report_footer_label": "Texte de Pied de Page",
+    "default_report_title_line1": "Rapport d'Analyse Automatisée",
+    "default_report_title_line2": "Généré par ErnestMind",
+    "default_report_subtitle": "Analyse de Données et Insights IA",
+    "default_report_footer": "Rapport généré le {date}. Tous droits réservés.",
+    "select_report_sections": "Sélectionnez les sections à inclure dans le rapport",
+    "download_pdf_button": "Télécharger au format PDF",
+    "download_excel_button": "Télécharger au format Excel",
+    
+    # Clés pour les informations clés du rapport
+    "key_info_report_title": "Titre du rapport",
+    "key_info_app_version": "Version de l'application",
+    "key_info_targeted_sector": "Secteur ciblé",
+    "key_info_language": "Langue du rapport",
+    "key_info_table_data": "Informations Clés du Rapport",
+    "key_info_model_ai": "Informations Clés du Modèle IA",
+
+    # Nouvelles clés pour les cartes d'information
+    "card_model_status_title": "Statut du Modèle",
+    "card_model_status_desc_trained": "Le modèle est entraîné et prêt pour l'analyse.",
+    "card_model_status_desc_not_trained": "Le modèle n'est pas entraîné. Veuillez charger des données et lancer l'entraînement.",
+    "card_target_column_title": "Colonne Cible",
+    "card_target_column_desc": "La colonne {target_column} est utilisée comme variable cible.",
+    "card_target_column_desc_na": "Aucune colonne cible sélectionnée.",
+    "card_model_type_title": "Type de Modèle",
+    "card_model_type_desc": "Modèle de {model_type}.",
+    "card_model_type_desc_na": "Type de modèle non défini.",
+    
+    # Nouvelles recommandations stratégiques
+    "rec_data_prep_focus": "Concentrez-vous sur la préparation des données pour améliorer la précision du modèle. Les valeurs manquantes et aberrantes peuvent fausser les résultats.",
+    "rec_explore_segmentation": "Explorez une segmentation plus fine des données à l'aide d'algorithmes de clustering (comme K-Means) pour découvrir des sous-groupes de propriétés aux caractéristiques similaires. Cela peut révéler des niches de marché inexploitées ou des tendances cachées.",
+    "rec_investigate_anomalies": "Menez une investigation plus approfondie sur les propriétés identifiées comme anomalies. Elles pourraient représenter des opportunités d'investissement uniques ou des erreurs de saisie à corriger.",
+    "rec_collect_more_data": "Vos données sont limitées. La collecte de plus d'informations (plus de lignes) ou l'ajout de nouvelles variables (plus de colonnes) pourrait considérablement améliorer la capacité prédictive du modèle et la robustesse de l'analyse.",
+    "rec_feature_engineering_terms": "Considérez la création de nouvelles caractéristiques (feature engineering) en combinant des variables existantes. Par exemple, un terme d'interaction entre la superficie et le nombre de pièces pourrait mieux capturer la valeur d'une propriété.",
+    "rec_focus_on_features": "Les caractéristiques suivantes sont les plus influentes sur les prédictions du modèle : {features}. Concentrez vos efforts d'analyse sur ces variables pour comprendre les principaux leviers de valeur.",
+    "rec_handle_skewness": "Envisagez d'appliquer une transformation logarithmique ou Box-Cox à la colonne '{col}' pour normaliser sa distribution et améliorer la performance du modèle.",
+    "rec_balance_categories": "Pour la colonne '{col}', utilisez des techniques de rééchantillonnage (suréchantillonnage ou sous-échantillonnage) pour équilibrer les classes et éviter le biais du modèle.",
+    "rec_dimensionality_reduction": "Compte tenu de la cardinalité élevée de la colonne '{col}', explorez des techniques de réduction de dimensionnalité (comme le PCA ou l'encodage d'entités) pour gérer cette variable.",
+    "rec_time_series_model": "Puisqu'une tendance temporelle a été observée, l'utilisation de modèles de séries chronologiques (ARIMA, Prophet) pourrait être plus appropriée pour des prédictions futures.",
+    "rec_clean_target_missing": "Nettoyez ou imputez soigneusement les valeurs manquantes dans la colonne cible '{target_col}' pour garantir l'intégrité de l'entraînement du modèle.",
+    "rec_remove_low_variance_features": "Supprimez la colonne '{col}' en raison de sa faible variance. Elle n'apporte pas d'informations significatives au modèle.",
+    "rec_deduplicate_data": "Supprimez les lignes dupliquées pour éviter que le modèle n'apprenne sur des observations redondantes et n'en surestime l'importance.",
+    "rec_address_multicollinearity": "Utilisez des méthodes comme l'analyse en composantes principales (PCA) ou la suppression de l'une des variables fortement corrélées pour gérer la multicolinéarité."
+}

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/translations_base.py

@@ -0,0 +1,222 @@
+# translations_base.py - Contient les traductions de base de l'application et de l'aide
+import hashlib
+import json
+import os
+import tempfile
+import unicodedata # Ajout pour slugify si besoin dans ce fichier
+import re # Ajout pour slugify si besoin dans ce fichier
+
+# Fonctions pour gérer la persistance des utilisateurs
+def _get_users_file_path():
+    """Retourne le chemin du fichier JSON pour les utilisateurs."""
+    return os.path.join(tempfile.gettempdir(), 'app_users.json')
+
+def load_users():
+    """Charge les utilisateurs depuis le fichier JSON ou initialise avec l'admin par défaut."""
+    users_path = _get_users_file_path()
+    try:
+        if os.path.exists(users_path):
+            with open(users_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        else:
+            # Initialiser avec l'utilisateur admin par défaut
+            default_users = {
+                "admin": {
+                    "password": hashlib.sha256("admin_password".encode('utf-8')).hexdigest(),
+                    "user_id": hashlib.md5("admin".encode('utf-8')).hexdigest(),
+                    "profile": {},
+                    "discussions": {}, # Initialise les discussions pour l'admin
+                    "database_files": {} # Initialize database files for the admin
+                }
+            }
+            with open(users_path, 'w', encoding='utf-8') as f:
+                json.dump(default_users, f, ensure_ascii=False, indent=4)
+            return default_users
+    except Exception as e:
+        # Gérer l'erreur si le fichier est corrompu ou illisible
+        print(f"Erreur lors du chargement des utilisateurs: {e}. Réinitialisation du fichier des utilisateurs.")
+        default_users = {
+            "admin": {
+                "password": hashlib.sha256("admin_password".encode('utf-8')).hexdigest(),
+                "user_id": hashlib.md5("admin".encode('utf-8')).hexdigest(),
+                "profile": {},
+                "discussions": {},
+                "database_files": {}
+            }
+        }
+        with open(users_path, 'w', encoding='utf-8') as f:
+            json.dump(default_users, f, ensure_ascii=False, indent=4)
+        return default_users
+
+
+def save_users(users_data):
+    """Sauvegarde les utilisateurs dans le fichier JSON."""
+    users_path = _get_users_file_path()
+    with open(users_path, 'w', encoding='utf-8') as f:
+        json.dump(users_data, f, ensure_ascii=False, indent=4)
+
+# Dictionnaire pour la langue française
+fr_translations_base = {
+    "lang_name": "Français",
+    "app_title": "ErnestMind V80 - Plateforme d'Analyse Immobilière",
+    "app_subtitle": "Plateforme IA locale et collaborative pour l'analyse de données — confidentielle, puissante, multilingue.",
+    "upload_label": "Téléchargez un fichier de données",
+    "file_uploaded_success": "Fichier téléchargé avec succès !",
+    "file_read_success": "Fichier lu et converti en DataFrame avec succès.",
+    "unsupported_file_type": "Type de fichier non supporté.",
+    "error_reading_file": "Une erreur est survenue lors de la lecture du fichier.",
+    "select_delimiter": "Sélectionnez le délimiteur pour le fichier CSV/TXT",
+    "file_details": "Détails du Fichier",
+    
+    # Nouveaux modules
+    "data_diagnostic_title": "Diagnostic des Données",
+    "data_prep_title": "Préparation des Données",
+    "ai_prediction_title": "Prédiction & Rapports IA",
+    "report_generation_title": "Génération de Rapports",
+    "settings_section": "Paramètres",
+    "visualizations": "Visualisations des Données",
+    "home_section": "Accueil", # Nouvelle clé pour la section Accueil
+    "main_modules": "Modules Principaux",
+    
+    # Footer
+    "footer_privacy_policy": "Politique de Confidentialité",
+    "footer_legal_notices": "Mentions Légales",
+    "footer_terms_of_use": "Conditions d'Utilisation",
+    "footer_about_ernestmind": "À Propos d'ErnestMind",
+    "help_title": "Aide et Guide d'Utilisation",
+    
+    # Aide et guide
+    "help_intro_part1": """
+    **Bienvenue dans le guide d'aide d'ErnestMind !**
+
+    Pour commencer, suivez ces trois étapes simples :
+
+    1.  **Télécharger un Fichier :** Utilisez le module 'Diagnostic des Données' pour téléchargez un fichier de données (CSV, XLSX, JSON, etc.) ou explorez en mode démo.
+    2.  **Préparation des Données :** Une fois le fichier lu, les statistiques descriptives et un résumé des valeurs manquantes s'afficheront.
+    3.  **Entraînement du Modèle :** Le système sélectionnera automatiquement une colonne numérique comme cible. Cliquez sur "Entraîner le Modèle" pour générer des insights IA et activer les autres modules.
+    """,
+    "help_our_strengths": """
+    ErnestMind est conçu pour la simplicité et la puissance. Ses points forts incluent :
+    * **Autonomie :** Traitez vos données directement sur votre machine, sans besoin de les t��lécharger sur des serveurs externes.
+    * **Puissance :** Bénéficiez d'algorithmes d'IA avancés pour l'analyse prédictive, l'explicabilité et la génération d'insights.
+    * **Simplicité :** Une interface utilisateur conçue pour être intuitive, rendant l'analyse complexe accessible à tous.
+    * **Personnalisation :** Adaptez les rapports et les analyses à vos besoins spécifiques.
+    * **Multilinguisme :** Travaillez dans la langue de votre choix pour une expérience utilisateur optimale.
+    """,
+    "read_more_need_help": "Aide", # Renommé pour être plus court pour le footer
+    "close_button": "Fermer",
+    "back_to_dashboard_button": "Retour au Tableau de Bord",
+    "help_module_data_diag_content": "Ce module offre un diagnostic rapide et complet de vos données : aperçu, statistiques descriptives, analyse des valeurs manquantes et visualisations automatiques (histogrammes, barres, matrices de corrélation, nuages de mots).",
+    "help_module_data_prep_content": "Préparez vos données pour l'analyse IA. Gérez les valeurs manquantes, les valeurs aberrantes, appliquez la mise à l'échelle des caractéristiques et créez de nouvelles fonctionnalités (polynômiales, interaction, date/heure, agrégation).",
+    "help_module_ai_pred_content": "Entraînez et évaluez des modèles d'intelligence artificielle (régression ou classification). Obtenez des métriques de performance et visualisez l'importance des caractéristiques avec les valeurs SHAP.",
+    "help_module_report_gen_content": "Générez des rapports professionnels personnalisés en formats PDF ou Excel. Incluez des observations stratégiques, des recommandations IA, des visualisations et toutes les informations clés de votre analyse.",
+    "privacy_policy_section": "Politique de Confidentialité", # Renommé pour correspondre à la clé de section
+    "privacy_policy_section_content": "Cette application est 100% locale et ne collecte aucune de vos données personnelles ou de vos fichiers. Tout est traité sur votre machine. Votre confidentialité est notre priorité absolue. Nous n'accédons ni ne stockons vos informations.",
+    "legal_notices_section": "Mentions Légales", # Renommé
+    "legal_notices_section_content": "ErnestMind V80 est une plateforme d'analyse de données en mode local. Son utilisation est soumise à nos conditions générales d'utilisation. Pour toute question, veuillez nous contacter à support@ernestmind.ai.",
+    "terms_of_use_section": "Conditions d'Utilisation", # Renommé
+    "terms_of_use_section_content": "En utilisant cette application, vous acceptez de ne pas l'utiliser à des fins illégales ou non autorisées. Vous êtes seul responsable du contenu de vos données et de leur conformité avec les lois en vigueur. Toute utilisation abusive est strictement interdite.",
+    "about_ernestmind_section": "À Propos d'ErnestMind", # Renommé
+    "about_ernestmind_section_content": "ErnestMind V80 est une plateforme d'analyse de données immobilières propulsée par l'IA, conçue pour être puissante, confidentielle et facile d'utilisation. Notre mission est de démocratiser l'analyse avancée des données pour les professionnels de l'immobilier, en garantissant une autonomie totale et une sécurité maximale des données.",
+    "about_app_content": "ErnestMind V80 est une plateforme d'analyse de données immobilières propulsée par l'IA. Elle vous permet d'analyser vos données en toute confidentialité, directement sur votre machine, sans aucune collecte ni stockage externe. Profitez de fonctionnalités avancées pour la prédiction, la détection d'anomalies, le clustering et la génération de rapports personnalisés.",
+    
+    # Nouvelles clés pour les observations
+    "res_observations_intro": "Voici une série d'observations stratégiques générées automatiquement à partir de l'analyse de vos données :",
+    "no_observations_available": "Aucune observation pertinente n'a pu être générée à partir des données fournies.",
+    "obs_missing_values": "Des valeurs manquantes ont été détectées dans les colonnes suivantes : {cols}. Ce phénomène peut impacter la performance des modèles si elles ne sont pas traitées.",
+    "obs_high_outlier_rate": "Un taux élevé de valeurs aberrantes ({percent}%) a été identifié. Ces points de données inhabituels méritent une attention particulière car ils peuvent biaiser l'analyse et les prédictions.",
+    "obs_outliers_exist": "Des valeurs aberrantes existent dans vos données ({percent}%). Il est recommandé d'examiner ces cas pour s'assurer qu'ils ne sont pas le résultat d'erreurs de saisie.",
+    "obs_data_clusters": "Le modèle a identifié des clusters distincts dans vos données. Cette segmentation suggère la présence de sous-groupes de propriétés avec des caractéristiques et des comportements de prix différents.",
+    "obs_median_price": "Le prix médian de la colonne '{col}' est de {price:.2f}. Ce chiffre est un indicateur clé pour évaluer le marché global de votre jeu de données.",
+    "obs_high_correlation": "Une forte corrélation a été observée entre certaines paires de caractéristiques ({pairs}). Ceci peut indiquer une redondance ou une interaction significative qui pourrait être exploitée ou gérée dans le modèle.",
+    "obs_skewed_distribution": "La distribution de la colonne '{col}' est asymétrique, ce qui peut affecter les performances de certains modèles. Une transformation des données pourrait être bénéfique.",
+    "obs_categorical_imbalance": "La colonne catégorielle '{col}' présente un déséquilibre important de classes, avec la catégorie '{minority}' sous-représentée. Cela peut biaiser les prédictions pour cette classe.",
+    "obs_high_cardinality": "La colonne '{col}' a une cardinalité élevée ({count} valeurs uniques). Cela pourrait rendre l'encodage coûteux et potentiellement introduire du surapprentissage.",
+    "obs_time_series_trend": "Une tendance claire a été détectée dans la colonne de date '{col}', suggérant que le temps est un facteur important dans les variations des données.",
+    "obs_missing_target_values": "Des valeurs manquantes ont été trouvées dans la colonne cible '{target_col}'. Il est crucial de les traiter avant l'entraînement du modèle.",
+    "obs_low_variance": "La colonne '{col}' présente une très faible variance, ce qui signifie qu'elle ne contient pas beaucoup d'informations utiles pour le modèle et pourrait être retirée.",
+    "obs_duplicate_rows": "Des lignes dupliquées ({count} duplicata) ont été identifiées dans le jeu de données. Leur suppression peut améliorer la qualité de l'analyse.",
+    "obs_multicollinearity": "Une forte multicolinéarité est présente parmi les variables. Cela peut rendre l'interprétation des coefficients du modèle difficile et impacter sa stabilité.",
+
+    # Messages d'interface utilisateur
+    "login_title": "Connexion / Création de compte",
+    "login_intro": "Bienvenue ! Connectez-vous ou créez un compte pour accéder à toutes les fonctionnalités, ou explorez en mode démo.",
+    "username_label": "Nom d'utilisateur",
+    "password_label": "Mot de passe",
+    "login_button": "Se connecter",
+    "create_account_button": "Créer un compte",
+    "explore_demo_button": "Explorer en mode Démo",
+    "login_success": "Connexion réussie !",
+    "login_error": "Nom d'utilisateur ou mot de passe incorrect.",
+    "login_fields_prompt": "Veuillez entrer un nom d'utilisateur et un mot de passe.",
+    "create_account_fields_prompt": "Veuillez entrer un nom d'utilisateur, un mot de passe et sélectionner un type de profil pour créer un compte.",
+    "demo_mode_activated": "Mode Démo activé ! Données fictives chargées.",
+    "logged_in_as": "Connecté en tant que",
+    "logout_button": "Se déconnecter",
+    "theme_reload_info": "Le thème changera après le rechargement de la page.",
+    "app_title_welcome": "Bienvenue sur ErnestMind V80",
+    "login_prompt_or_demo": "Veuillez vous connecter, créer un compte ou explorer en mode démo pour commencer.",
+    "home_welcome_title": "Bienvenue, {username} !",
+    "home_intro": "Explorez les capacités d'analyse de données et d'IA d'ErnestMind V80.",
+    "home_feature_discovery_title": "Découvrez nos fonctionnalités clés",
+    "home_ai_models_title": "Modèles d'IA utilisés",
+    "home_ai_models_description": "ErnestMind V80 exploite plusieurs algorithmes d'IA puissants pour vous offrir des analyses approfondies et des prédictions fiables :",
+    "ai_model_lightgbm": "Un algorithme de machine learning rapide et performant pour la régression et la classification.",
+    "ai_model_isolation_forest": "Utilisé pour la détection efficace des anomalies dans vos données.",
+    "ai_model_kmeans": "Un algorithme de clustering pour identifier des groupes naturels au sein de vos données.",
+    "your_latest_projects_title": "Vos derniers projets",
+    "load_project_button": "Charger {filename}",
+    "no_projects_saved": "Aucun projet sauvegardé pour cet utilisateur.",
+    "demo_data_title": "Données de Démonstration",
+    "demo_data_intro": "Voici un aperçu des données fictives préchargées que vous pouvez utiliser en mode démo pour explorer les fonctionnalités de l'application.",
+    "interactive_map_title": "Carte Interactive des Propriétés",
+    "property_map_title": "Localisation des propriétés de démonstration",
+    "demo_kpis_title": "Indicateurs Clés de Performance (KPIs) de Démonstration",
+    "average_price": "Prix Moyen",
+    "number_of_properties": "Nombre de Propriétés",
+    "average_surface": "Surface Moyenne",
+    "user_data_saved": "Données de l'utilisateur sauvegardées localement.",
+    "user_data_loaded": "Données de l'utilisateur '{filename}' chargées avec succès.",
+    "save_not_available_demo": "La sauvegarde n'est pas disponible en mode démo.",
+    "login_required_save": "Veuillez vous connecter pour sauvegarder vos données.",
+    "load_not_available_demo": "Le chargement de projets n'est pas disponible en mode démo.",
+    "login_required_load": "Veuillez vous connecter pour charger vos projets.",
+    "error_loading_user_data": "Erreur lors du chargement des données utilisateur.",
+    "file_not_found_on_server": "Le fichier '{filename}' n'a pas été trouvé sur le serveur.",
+    "file_not_found_for_user": "Le fichier '{filename}' n'a pas été trouvé pour cet utilisateur.",
+    "no_suitable_target_column": "Aucune colonne numérique appropriée trouvée pour la colonne cible. Veuillez vérifier vos données.",
+    "error_shap_calculation": "Erreur lors du calcul des valeurs SHAP",
+    "shap_not_available": "Les valeurs SHAP n'ont pas pu être calculées ou affichées pour ce modèle. Vérifiez les données ou les paramètres du modèle.",
+    "error_creating_excel": "Erreur lors de la création du fichier Excel",
+    "excel_dependency_error": "Erreur : Une dépendance nécessaire pour ce format est manquante. Veuillez installer `xlsxwriter` via `pip install xlsxwriter`.",
+    "create_profile_explanation": "Créer un profil aide ErnestMind à mieux adapter les analyses et les rapports à vos besoins spécifiques. Vos données restent confidentielles et locales.",
+    "profile_type_label": "Quel est votre profil ?",
+    "profile_agent_immobilier": "Agent Immobilier",
+    "profile_investisseur": "Investisseur Immobilier",
+    "profile_expert_data": "Expert en Science des Données",
+    "profile_autre": "Autre",
+    "profile_saved_success": "Profil sauvegardé avec succès !",
+    "new_discussion_button": "Nouvelle Discussion",
+    "current_discussion_label": "Discussion actuelle : {discussion_name}",
+    "load_discussion_button": "Charger {discussion_name}",
+    "delete_discussion_button": "Supprimer",
+    "discussion_deleted_success": "Discussion '{discussion_name}' supprimée avec succès.",
+    "discussion_created_success": "Nouvelle discussion '{discussion_name}' créée !",
+    "enter_discussion_name": "Veuillez nommer votre nouvelle discussion :",
+    "discussion_name_exists": "Une discussion avec ce nom existe déjà. Veuillez en choisir un autre.",
+    "no_discussions_saved": "Aucune discussion sauvegardée pour cet utilisateur.",
+    "select_discussion_to_load": "Sélectionnez une discussion à charger",
+    "auto_generated_visualizations_title": "Visualisations Automatiques des Données",
+    "scatter_surface_price": "Prix vs Surface ($m^2$)",
+    "scatter_generic": "Nuage de points : {col1} vs {col2}",
+    "box_price_by_location": "Distribution des Prix par Localisation",
+    "box_generic": "Distribution de {num_col} par {cat_col}",
+    "sunburst_hierarchical": "Répartition Hiérarchique des Catégories",
+    "pie_chart_of": "Diagramme Circulaire de {col}",
+    "main_section_import_button": "Importer un fichier pour l'analyse",
+    "import_file_types_info": "Formats supportés : CSV, TXT, JSON, XLSX, XLS, Parquet, ORC, Feather, Stata, SAS."
+}
+
+# Mettre à jour la structure des traductions de base avec la gestion des utilisateurs
+# Cette ligne doit être exécutée APRÈS la définition des fonctions de gestion des utilisateurs
+fr_translations_base['users'] = load_users()

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/translations_data_processing.py

@@ -0,0 +1,73 @@
+# translations_data_processing.py - Contient les traductions pour le diagnostic et la préparation des données
+
+# Dictionnaire pour la langue française
+fr_translations_data_processing = {
+    "overview_data": "Aperçu des Données",
+    "num_rows": "Nombre de lignes : {rows}",
+    "num_cols": "Nombre de colonnes : {cols}",
+    "descriptive_stats": "Statistiques Descriptives",
+    "missing_values": "Valeurs Manquantes",
+    "no_missing_values": "Aucune valeur manquante détectée dans le jeu de données.",
+    "dataframe_sample": "Échantillon du DataFrame",
+    "visualizations_generated_success": "Visualisations générées avec succès !",
+    "dist_num_cols": "Distributions des principales colonnes numériques",
+    "dist_of": "Distribution de",
+    "frequency": "Fréquence",
+    "freq_cat_cols": "Fréquences des principales colonnes catégorielles",
+    "freq_of": "Fréquence de",
+    "count": "Compte",
+    "correlation_matrix": "Matrice de Corrélation",
+    "correlation_matrix_title": "Matrice de Corrélation des Caractéristiques Numériques",
+    "correlation_matrix_caption": "Heatmap de la matrice de corrélation",
+    
+    "data_prep_intro": "Utilisez ce module pour nettoyer, transformer et préparer vos données pour l'analyse IA. Les options incluent le traitement des valeurs manquantes et aberrantes, la mise à l'échelle des caractéristiques et la création de nouvelles fonctionnalités.",
+    
+    # Nouvelles clés pour la préparation des données
+    "missing_values_imputation_title": "Traitement des Valeurs Manquantes",
+    "select_imputation_method": "Sélectionnez la méthode d'imputation",
+    "apply_imputation_button": "Appliquer l'Imputation",
+    "imputation_applied": "Imputation par '{method}' appliquée avec succès.",
+    "feature_scaling_title": "Mise à l'Échelle des Caractéristiques",
+    "select_scaling_method": "Sélectionnez la méthode de mise à l'échelle",
+    "apply_scaling_button": "Appliquer la Mise à l'Échelle",
+    "scaling_applied": "Mise à l'échelle par '{method}' appliquée avec succès.",
+    "feature_engineering_title": "Ingénierie des Caractéristiques",
+    "create_polynomial_features": "Créer des Caractéristiques Polynômiales",
+    "select_poly_degree": "Sélectionnez le degré pour les caractéristiques polynômiales.",
+    "create_interaction_term": "Créer un Terme d'Interaction",
+    "select_interaction_cols": "Sélectionnez deux colonnes pour le terme d'interaction",
+    "create_interaction_button": "Créer le terme d'interaction",
+    "interaction_term_created": "Terme d'interaction '{new_name}' créé à partir de '{col1}' et '{col2}'.",
+    "extract_datetime_features": "Extraire les Caractéristiques de Date/Heure",
+    "select_datetime_col": "Sélectionnez une colonne de date/heure",
+    "select_datetime_features": "Sélectionnez les caractéristiques à extraire",
+    "extract_features": "Extraire les caractéristiques",
+    "datetime_features_extracted": "Caractéristiques de date/heure '{features}' extraites de la colonne '{col}'.",
+    "select_datetime_col_and_features": "Veuillez sélectionner une colonne de date/heure et au moins une caractéristique à extraire.",
+    "apply_aggregation": "Appliquer l'Agrégation",
+    "select_groupby_col": "Sélectionnez la colonne de groupement",
+    "select_target_col_agg": "Sélectionnez la colonne cible pour l'agrégation",
+    "select_agg_method": "Sélectionnez la (les) méthode(s) d'agrégation",
+    "apply_aggregation_button": "Appliquer l'agrégation",
+    "aggregation_applied": "Agrégation '{method}' appliquée à la colonne '{target}' groupée par '{group}'.",
+    
+    # Nouvelles clés pour les visualisations
+    "no_numeric_columns": "Aucune colonne numérique n'a été trouvée pour les distributions.",
+    "no_categorical_columns": "Aucune colonne catégorielle n'a été trouvée pour les fréquences.",
+    "not_enough_numeric_for_corr": "Pas assez de colonnes numériques pour une matrice de corrélation.",
+    "word_cloud_title": "Nuage de Mots",
+    "word_cloud_info": "Génère un nuage de mots à partir d'une colonne de texte pour visualiser les termes les plus fréquents.",
+    "select_text_column": "Sélectionnez une colonne de texte",
+    "no_text_data_for_wordcloud": "La colonne sélectionnée ne contient pas de données textuelles à analyser pour le nuage de mots.",
+    "no_text_columns": "Aucune colonne de type texte n'a été trouvée.",
+    "generate_visualizations_button": "Générer les Visualisations",
+    
+    # Nouvelles clés pour les modèles avancés
+    "outlier_detection_title": "Détection des Valeurs Aberrantes",
+    "detect_outliers_button": "Détecter les Valeurs Aberrantes",
+    "outliers_detected": "Valeurs aberrantes détectées. Une nouvelle colonne 'outlier_score' a été ajoutée. -1 pour les outliers, 1 pour les autres.",
+    "clustering_title": "Clustering des Données",
+    "select_num_clusters": "Sélectionnez le nombre de clusters",
+    "apply_clustering_button": "Appliquer le Clustering",
+    "clustering_applied": "Clustering K-Means avec {n_clusters} clusters appliqué avec succès. Une nouvelle colonne 'cluster' a été ajoutée."
+}

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge-x/translations_report_content.py

@@ -0,0 +1,85 @@
+# translations_report_content.py - Contient les traductions pour le contenu des sections de rapport spécifiques
+
+# Dictionnaire pour la langue française
+fr_translations_report_content = {
+    # Nouvelles clés pour les sections du rapport et annexes
+    "report_cover_page_title": "Page de Garde",
+    "about_this_report_title": "À Propos de ce Rapport",
+    "about_this_report_content": """
+    Ce rapport a été généré automatiquement par ErnestMind V80, une plateforme d'analyse immobilière basée sur l'IA. Il vise à fournir une compréhension approfondie des données immobilières fournies, à identifier les tendances clés, à évaluer la performance des modèles prédictifs et à proposer des recommandations stratégiques actionnables.
+
+    Le contenu de ce rapport est structuré en plusieurs sections clés, chacune conçue pour éclairer différents aspects de votre analyse immobilière.
+    """,
+    "data_info_section": "Informations Générales sur les Données",
+    "data_info_intro": "Cette section présente un aperçu général et des statistiques descriptives du jeu de données analysé.",
+    "report_data_quality_title": "Qualité des Données et Traitement",
+    "data_quality_intro": "Une analyse de la qualité des données a été effectuée, incluant la détection et la gestion des valeurs manquantes et des valeurs aberrantes.",
+    "report_kpis_infographic_title": "Indicateurs Clés de Performance (KPIs)",
+    "kpis_intro": "Cette section présente les principaux indicateurs de performance du modèle prédictif.",
+    "report_ai_observations_title": "Observations Stratégiques",
+    "report_ai_recommendations_title": "Recommandations d'Actions IA",
+    "report_methodology_annex_title": "Annexe - Méthodologie",
+    "methodology_intro": "Ce rapport a été généré en utilisant la méthodologie suivante pour l'analyse des données et la création de modèles IA :",
+    "methodology_data_prep": "- **Préparation des Données :** Nettoyage, gestion des valeurs manquantes, encodage des variables catégorielles et standardisation des caractéristiques numériques.",
+    "methodology_model_training": "- **Entraînement du Modèle :** Un modèle LightGBM a été entraîné pour la prédiction sur un sous-ensemble des données (80% pour l'entraînement, 20% pour les tests).",
+    "methodology_shap_explanation": "- **Explicabilité du Modèle (SHAP) :** Les valeurs SHAP ont été calculées pour expliquer l'impact de chaque caractéristique sur les prédictions du modèle.",
+    "methodology_report_generation": "- **Génération de Rapport :** Le rapport a été généré automatiquement, incluant des observations et des recommandations basées sur les insights du modèle IA.",
+    "methodology_data_confidentiality": "- **Confidentialité des Données :** Toutes les analyses sont effectuées localement sur votre machine. Aucune de vos données n'est transmise ou stockée sur des serveurs externes.",
+    "report_glossary_annex_title": "Annexe - Glossaire",
+    "glossary_full_text": """
+    **KPI (Key Performance Indicator) :** Indicateur clé de performance.
+    **RMSE (Root Mean Squared Error) :** Erreur quadratique moyenne. Mesure la différence entre les valeurs prédites et les valeurs réelles.
+    **R² Score (Coefficient de Détermination) :** Mesure la proportion de la variance de la variable dépendante qui est prévisible à partir de la ou des variables indépendantes.
+    **SHAP (SHapley Additive exPlanations) :** Une méthode d'explicabilité de l'IA qui permet d'expliquer comment les caractéristiques d'un modèle influencent les prédictions.
+    **LightGBM :** Un algorithme d'apprentissage automatique de type gradient boosting. Très performant et rapide.
+    **Valeurs Manquantes :** Données non disponibles dans le jeu de données.
+    **Valeurs Aberrantes (Outliers) :** Observations qui s'écartent significativement des autres observations.
+    **Clustering :** Technique non supervisée qui regroupe des points de données similaires.
+    """,
+    "report_about_app_annex_title": "Annexe - À Propos d'ErnestMind V80",
+    "about_app_content": """
+    ErnestMind V80 est une plateforme d'analyse de données en mode local, conçue pour les professionnels de l'immobilier. Elle combine l'autonomie des logiciels de bureau avec la puissance de l'IA pour offrir une expérience d'analyse unique.
+
+    **Nos Atouts :**
+    * **Autonomie :** Traitez vos données directement sur votre machine, sans besoin de les télécharger sur des serveurs externes.
+    * **Puissance :** Bénéficiez d'algorithmes d'IA avancés pour l'analyse prédictive, l'explicabilité et la génération d'insights.
+    * **Simplicité :** Une interface utilisateur conçue pour être intuitive, rendant l'analyse complexe accessible à tous.
+    * **Personnalisation :** Adaptez les rapports et les analyses à vos besoins spécifiques.
+    * **Multilinguisme :** Travaillez dans la langue de votre choix pour une expérience utilisateur optimale.
+
+    **Notre Engagement :**
+    * **Confidentialité :** La sécurité de vos données est notre priorité absolue. Nous n'accédons ni ne stockons vos informations.
+    * **Innovation :** Nous nous engageons à améliorer constamment ErnestMind V80 avec les dernières avancées en IA et en science des données.
+    * **Support :** Notre équipe est là pour vous aider et répondre à vos questions.
+
+    Rejoignez la communauté ErnestMind.ai et transformez la façon dont vous interagissez avec vos données !
+    """,
+    # Observations et recommandations du modèle (exemples)
+    "observation_median_price_per_sqm": "Le prix médian par mètre carré est de {price:.2f} €, ce qui est un indicateur clé de la valeur immobilière dans cette région.",
+    "recommendation_price_analysis": "Analysez plus en profondeur les facteurs qui influencent le prix par mètre carré pour identifier les opportunités d'investissement.",
+    "no_kpis_available": "Aucun KPI n'est disponible car le modèle n'a pas été entraîné ou les données de test sont insuffisantes.",
+
+    # Database specific translations
+    "database_section": "Base de Données",
+    "database_intro": "Gérez et analysez vos fichiers de données de manière sécurisée et locale. Importez jusqu'à 10 fichiers à la fois pour les stocker ou lancer une analyse avancée sur un seul fichier.",
+    "login_to_database": "Connectez-vous pour accéder à la base de données",
+    "open_database_button": "Ouvrir la Base de Données",
+    "import_files_to_db_title": "Importer des Fichiers dans la Base de Données",
+    "upload_db_files_label": "Téléchargez un ou plusieurs fichiers (max. 10)",
+    "file_storage_option": "Stocker le(s) fichier(s) dans la base de données",
+    "advanced_analysis_option": "Lancer une analyse avancée sur un seul fichier",
+    "select_file_for_analysis": "Sélectionnez un fichier pour l'analyse avancée",
+    "analyze_selected_file_button": "Analyser le Fichier Sélectionné",
+    "file_saved_to_db": "Fichier '{filename}' sauvegardé dans la base de données.",
+    "files_saved_to_db": "{count} fichiers sauvegardés dans la base de données.",
+    "analysis_triggered_for_file": "Analyse avancée déclenchée pour le fichier '{filename}'.",
+    "please_select_one_file_for_analysis": "Veuillez sélectionner un seul fichier pour l'analyse avancée.",
+    "no_files_uploaded_for_db": "Veuillez télécharger au moins un fichier.",
+    "stored_files_title": "Fichiers Stockés",
+    "no_stored_files": "Aucun fichier stocké dans votre base de données.",
+    "select_stored_file_for_analysis": "Sélectionnez un fichier stocké pour lancer une analyse",
+    "view_file_content_button": "Voir le Contenu du Fichier",
+    "delete_file_button": "Supprimer le Fichier",
+    "file_deleted_success": "Fichier '{filename}' supprimé avec succès de la base de données.",
+    "enter_password_strong_requirements": "Le mot de passe doit contenir entre 8 et 15 caractères, incluant des chiffres, des lettres et des caractères spéciaux."
+}