feat: Création de la branche 'coolo' à partir de main pour PR.

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/gitforge/coolo/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/coolo/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/coolo/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/coolo/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/coolo/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/coolo/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/coolo/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/coolo/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/coolo/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/coolo/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/coolo/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."
+}