Update src/dashboard_app.py

src/dashboard_app.py

@@ -66,8 +66,6 @@ def init_analysis_state(analysis_index, param_key, default_value):
         if 'params' not in analyses[analysis_index]:
             analyses[analysis_index]['params'] = {}
         analyses[analysis_index]['params'].setdefault(param_key, default_value)
-    # else: # Gérer le cas où l'index est hors limites si nécessaire
-    #     print(f"Warning: Tentative d'initialisation de l'état pour un index d'analyse invalide: {analysis_index}")
 
 # --- Fonction de chargement de données générique ---
 def load_data(source_type, source_value, header_param, sep=None):
@@ -128,8 +126,8 @@ def load_data(source_type, source_value, header_param, sep=None):
         st.rerun() # Indispensable pour mettre à jour toute l'application
     else:
         st.session_state.dataframe_to_export = None
-        st.session_state.data_source_info = f"Erreur: {error_message}" if error_message else "Erreur de chargement inconnue"
         st.session_state.data_loaded_id = None
+        st.session_state.data_source_info = f"Erreur: {error_message}" if error_message else "Erreur de chargement inconnue"
         st.sidebar.error(st.session_state.data_source_info)
         # Pas de rerun en cas d'erreur pour que l'erreur reste visible
 
@@ -179,7 +177,6 @@ with app_tab:
             "Choisissez une méthode de chargement :",
             options=load_options,
             key="data_load_method_radio",
-            # index=get_safe_index(load_options, st.session_state.load_method) # Garder la sélection
         )
 
         # Options communes
@@ -273,7 +270,7 @@ with app_tab:
                             num_non_na_original = col_data.dropna().shape[0]
                             if num_non_na_original > 0 and converted_num.notna().sum() / num_non_na_original > 0.7:
                                 # Heuristique simple pour éviter les ID (grands entiers)
-                                # Vérifie si toutes les valeurs numériques sont des entiers ET si le max est grand
+                                # Vérifier si toutes les valeurs numériques sont des entiers ET si le max est grand
                                 is_int_like = converted_num.dropna().apply(lambda x: x == int(x)).all()
                                 if is_int_like and converted_num.max() > 100000:
                                      pass # Probablement un ID, on n'ajoute pas à numérique
@@ -510,20 +507,20 @@ with app_tab:
                     # ===========================
                     if analysis['type'] == 'aggregated_table':
                         st.markdown("##### Configuration Tableau Agrégé")
-                        if not conf_categorical_columns: st.warning("Nécessite au moins une colonne Catégorielle.")
-                        # Numerical n'est pas requis si méthode = count
-                        # elif not conf_numerical_columns and analysis.get('params',{}).get('agg_method') != 'count':
+                        if not categorical_columns: st.warning("Nécessite au moins une colonne Catégorielle.")
+                        # Numérique n'est pas requis si méthode = count
+                        # elif not numerical_columns and analysis.get('params',{}).get('agg_method') != 'count':
                         #     st.warning("Nécessite au moins une colonne Numérique (sauf pour 'count').")
                         else:
                             init_analysis_state(i, 'group_by_columns', [])
-                            init_analysis_state(i, 'agg_column', conf_numerical_columns[0] if conf_numerical_columns else None)
+                            init_analysis_state(i, 'agg_column', numerical_columns[0] if numerical_columns else None)
                             init_analysis_state(i, 'agg_method', 'count')
 
                             col_agg1, col_agg2, col_agg3 = st.columns(3)
                             with col_agg1:
-                                default_groupby = [col for col in analysis['params'].get('group_by_columns', []) if col in conf_categorical_columns]
+                                default_groupby = [col for col in analysis['params'].get('group_by_columns', []) if col in categorical_columns]
                                 st.session_state.analyses[i]['params']['group_by_columns'] = st.multiselect(
-                                    f"Regrouper par :", conf_categorical_columns,
+                                    f"Regrouper par :", categorical_columns,
                                     default=default_groupby, key=f"agg_table_groupby_{analysis_id}"
                                 )
                             with col_agg3: # Méthode avant colonne
@@ -536,7 +533,7 @@ with app_tab:
                             with col_agg2:
                                 agg_method_selected_agg = st.session_state.analyses[i]['params']['agg_method']
                                 agg_col_needed_agg = agg_method_selected_agg != 'count'
-                                agg_col_options_agg = conf_numerical_columns if agg_col_needed_agg else ["(Non requis pour 'count')"]
+                                agg_col_options_agg = numerical_columns if agg_col_needed_agg else ["(Non requis pour 'count')"]
                                 agg_col_index_agg = get_safe_index(agg_col_options_agg, analysis['params'].get('agg_column'))
                                 current_agg_col_selection_agg = st.selectbox(
                                     f"Calculer sur :", agg_col_options_agg,
@@ -558,7 +555,7 @@ with app_tab:
                                 else:
                                     try:
                                         valid_groupby = all(c in data.columns for c in group_by_cols)
-                                        valid_aggcol = agg_method == 'count' or (agg_col and agg_col in data.columns and agg_col in conf_numerical_columns)
+                                        valid_aggcol = agg_method == 'count' or (agg_col and agg_col in data.columns and agg_col in numerical_columns)
 
                                         if not valid_groupby: st.error("Colonnes de groupement invalides.")
                                         elif not valid_aggcol: st.error(f"Colonne d'agrégation '{agg_col}' invalide ou non numérique (requis pour '{agg_method}').")
@@ -590,15 +587,15 @@ with app_tab:
                     # ===========================
                     elif analysis['type'] == 'graph':
                         st.markdown("##### Configuration Graphique")
-                        if not conf_all_columns: st.warning("Aucune colonne disponible.")
+                        if not all_columns: st.warning("Aucune colonne disponible.")
                         else:
                             # --- Initialisation état graphique ---
-                            init_analysis_state(i, 'chart_type', 'Bar Chart')
+                            init_analysis_state(i, 'chart_type', 'bar')
                             init_analysis_state(i, 'group_by_columns_graph', [])
-                            init_analysis_state(i, 'agg_column_graph', conf_numerical_columns[0] if conf_numerical_columns else None)
+                            init_analysis_state(i, 'agg_column_graph', numerical_columns[0] if numerical_columns else None)
                             init_analysis_state(i, 'agg_method_graph', 'count')
-                            init_analysis_state(i, 'x_column', conf_categorical_columns[0] if conf_categorical_columns else (conf_all_columns[0] if conf_all_columns else None))
-                            init_analysis_state(i, 'y_column', conf_numerical_columns[0] if conf_numerical_columns else None)
+                            init_analysis_state(i, 'x_column', categorical_columns[0] if categorical_columns else (all_columns[0] if all_columns else None))
+                            init_analysis_state(i, 'y_column', numerical_columns[0] if numerical_columns else None)
                             init_analysis_state(i, 'color_column', None)
                             init_analysis_state(i, 'size_column', None)
                             init_analysis_state(i, 'facet_column', None)
@@ -609,7 +606,11 @@ with app_tab:
                             init_analysis_state(i, 'z_column', None)
 
                             # --- Type Graphique ---
-                            chart_type_options = ('Bar Chart', 'Line Chart', 'Scatter Plot', 'Histogram', 'Box Plot', 'Violin Plot', 'Heatmap', 'Density Contour', 'Area Chart', 'Funnel Chart', 'Timeline (Gantt)', 'Sunburst', 'Treemap', '3D Scatter Plot', 'Pair Plot (SPLOM)')
+                            chart_type_options = (
+                                'bar', 'line', 'scatter', 'histogram', 'box', 'violin',
+                                'heatmap', 'density_contour', 'area', 'funnel', 'timeline',
+                                'sunburst', 'treemap', 'scatter_3d', 'scatter_matrix'
+                            )
                             chart_type_index = get_safe_index(chart_type_options, st.session_state.analyses[i]['params'].get('chart_type'))
                             st.session_state.analyses[i]['params']['chart_type'] = st.selectbox(f"Type graphique:", chart_type_options, index=chart_type_index, key=f"graph_type_{analysis_id}")
                             graph_analysis_type = st.session_state.analyses[i]['params']['chart_type']
@@ -630,7 +631,7 @@ with app_tab:
                                 elif current_agg_method_graph != 'count' and not current_agg_col_graph: agg_warning = f"Sélectionnez 'Calculer' pour '{current_agg_method_graph}'."
                                 elif not all(c in data.columns for c in current_group_by_graph): agg_warning = "Colonnes 'Agréger par' invalides."
                                 elif current_agg_method_graph != 'count' and current_agg_col_graph not in data.columns: agg_warning = f"Colonne 'Calculer' ('{current_agg_col_graph}') invalide."
-                                elif current_agg_method_graph != 'count' and current_agg_col_graph not in conf_numerical_columns: agg_warning = f"'{current_agg_col_graph}' doit être numérique pour '{current_agg_method_graph}'."
+                                elif current_agg_method_graph != 'count' and current_agg_col_graph not in numerical_columns: agg_warning = f"'{current_agg_col_graph}' doit être numérique pour '{current_agg_method_graph}'."
                                 else:
                                     try:
                                         if current_agg_method_graph == 'count':
@@ -665,94 +666,95 @@ with app_tab:
                                     st.session_state.analyses[i]['params']['x_column'] = selected_x
                                 # --- Axe Y ---
                                 with col2_axes:
-                                    y_disabled = graph_analysis_type in ['Histogram', 'Pair Plot (SPLOM)', 'Sunburst', 'Treemap']
+                                    y_disabled = graph_analysis_type in ['histogram', 'pair_plot', 'sunburst', 'treemap']
                                     y_label = "Axe Y"
                                     options_y = [c for c in chart_columns if c != selected_x]
-                                    if graph_analysis_type == 'Timeline (Gantt)':
-                                        options_y = [c for c in chart_columns if c in conf_categorical_columns and c != selected_x]; y_label = "Tâche/Groupe (Y)"
+                                    if graph_analysis_type == 'timeline':
+                                        options_y = [c for c in chart_columns if c in categorical_columns and c != selected_x]; y_label = "Tâche/Groupe (Y)"
                                     default_y = analysis['params'].get('y_column')
                                     if y_disabled: default_y = None
                                     elif default_y not in options_y:
                                         if is_aggregated and agg_col_name_new and agg_col_name_new in options_y: default_y = agg_col_name_new
                                         else:
-                                            num_y_opts = [c for c in options_y if c in conf_numerical_columns]
+                                            num_y_opts = [c for c in options_y if c in numerical_columns]
                                             default_y = num_y_opts[0] if num_y_opts else (options_y[0] if options_y else None)
                                     y_col_index = get_safe_index(options_y, default_y)
                                     selected_y = st.selectbox(y_label, options_y, index=y_col_index, key=f"graph_y_{analysis_id}", disabled=y_disabled or not options_y, help="Requis pour la plupart des graphiques.")
                                     st.session_state.analyses[i]['params']['y_column'] = selected_y if not y_disabled else None
                                 # --- Couleur & Taille ---
                                 with col3_axes:
+                                    map_options_num_orig = [None] + [c for c in original_columns if c in numerical_columns]
                                     map_options_all_orig = [None] + original_columns
-                                    map_options_num_orig = [None] + [c for c in original_columns if c in conf_numerical_columns]
                                     selected_color = st.selectbox(f"Couleur (Opt.):", map_options_all_orig, index=get_safe_index(map_options_all_orig, analysis['params'].get('color_column')), key=f"graph_color_{analysis_id}", format_func=lambda x: x if x is not None else "Aucune")
                                     st.session_state.analyses[i]['params']['color_column'] = selected_color
-                                    size_disabled = graph_analysis_type not in ['Scatter Plot', '3D Scatter Plot']
+                                    size_disabled = graph_analysis_type not in ['scatter', 'scatter_3d']
                                     selected_size = st.selectbox(f"Taille (Opt., Num.):", map_options_num_orig, index=get_safe_index(map_options_num_orig, analysis['params'].get('size_column')), key=f"graph_size_{analysis_id}", disabled=size_disabled, format_func=lambda x: x if x is not None else "Aucune")
                                     st.session_state.analyses[i]['params']['size_column'] = selected_size
 
                                 # --- Facet, Hover & Autres ---
                                 col1_extra, col2_extra = st.columns(2)
                                 with col1_extra:
-                                    map_options_cat_orig = [None] + [c for c in original_columns if c in conf_categorical_columns]
-                                    facet_disabled = graph_analysis_type in ['Heatmap', 'Density Contour', 'Pair Plot (SPLOM)', 'Sunburst', 'Treemap']
+                                    map_options_cat_orig = [None] + [c for c in original_columns if c in categorical_columns]
+                                    facet_disabled = graph_analysis_type in ['heatmap', 'density_contour', 'pair_plot', 'sunburst', 'treemap']
                                     selected_facet = st.selectbox(f"Diviser par (Facet, Opt.):", map_options_cat_orig, index=get_safe_index(map_options_cat_orig, analysis['params'].get('facet_column')), key=f"graph_facet_{analysis_id}", disabled=facet_disabled, format_func=lambda x: x if x is not None else "Aucune")
                                     st.session_state.analyses[i]['params']['facet_column'] = selected_facet
-                                    if graph_analysis_type == '3D Scatter Plot':
-                                        options_z = [c for c in chart_columns if c in conf_numerical_columns and c not in [selected_x, selected_y]]
+                                    if graph_analysis_type == 'scatter_3d':
+                                        options_z = [c for c in chart_columns if c in numerical_columns and c not in [selected_x, selected_y]]
                                         selected_z = st.selectbox("Axe Z (Num.):", options_z, index=get_safe_index(options_z, analysis['params'].get('z_column')), key=f"graph_z_{analysis_id}")
                                         st.session_state.analyses[i]['params']['z_column'] = selected_z
                                 with col2_extra:
                                     selected_hover = st.multiselect("Infos survol (Hover):", original_columns, default=analysis['params'].get('hover_data_cols', []), key=f"graph_hover_{analysis_id}")
                                     st.session_state.analyses[i]['params']['hover_data_cols'] = selected_hover
-                                    if graph_analysis_type == 'Timeline (Gantt)':
-                                        options_end = [c for c in chart_columns if c in conf_datetime_columns and c != selected_x]
-                                        selected_end = st.selectbox("Date Fin (Gantt):", options_end, index=get_safe_index(options_end, analysis['params'].get('gantt_end_column')), key=f"graph_gantt_end_{analysis_id}")
+                                    if graph_analysis_type == 'timeline':
+                                        options_end = [c for c in chart_columns if c in datetime_columns and c != selected_x]
+                                        selected_end = st.selectbox("Date Fin (Timeline):", options_end, index=get_safe_index(options_end, analysis['params'].get('gantt_end_column')), key=f"graph_gantt_end_{analysis_id}")
                                         st.session_state.analyses[i]['params']['gantt_end_column'] = selected_end
 
                                 # --- Params spécifiques Sunburst/Treemap ---
-                                if graph_analysis_type in ['Sunburst', 'Treemap']:
+                                if graph_analysis_type in ['sunburst', 'treemap']:
                                     col1_hier, col2_hier = st.columns(2)
                                     with col1_hier:
-                                        options_path = [c for c in chart_columns if c in conf_categorical_columns]
+                                        options_path = [c for c in chart_columns if c in categorical_columns]
                                         selected_path = st.multiselect("Chemin Hiérarchique:", options_path, default=analysis['params'].get('path_columns', []), key=f"graph_path_{analysis_id}")
                                         st.session_state.analyses[i]['params']['path_columns'] = selected_path
                                     with col2_hier:
-                                        options_values = [c for c in chart_columns if c in conf_numerical_columns]
+                                        options_values = [c for c in chart_columns if c in numerical_columns]
                                         selected_value = st.selectbox("Valeurs (Taille):", options_values, index=get_safe_index(options_values, analysis['params'].get('value_column')), key=f"graph_value_{analysis_id}")
                                         st.session_state.analyses[i]['params']['value_column'] = selected_value
 
                                 # --- Options d'agrégation ---
                                 with st.expander("Options d'agrégation (avant graphique)", expanded=aggregation_enabled_graph):
-                                    if not conf_categorical_columns: st.caption("Nécessite cols Catégorielles.")
+                                    if not categorical_columns: st.caption("Nécessite cols Catégorielles.")
                                     else:
                                         col_agg_graph1, col_agg_graph2, col_agg_graph3 = st.columns(3)
                                         with col_agg_graph1:
-                                            valid_gb = [c for c in analysis['params'].get('group_by_columns_graph',[]) if c in conf_categorical_columns]
+                                            valid_gb = [c for c in analysis['params'].get('group_by_columns_graph',[]) if c in categorical_columns]
                                             st.session_state.analyses[i]['params']['group_by_columns_graph'] = st.multiselect(
-                                                f"Agréger par :", conf_categorical_columns, default=valid_gb, key=f"graph_groupby_{analysis_id}"
+                                                f"Agréger par :", categorical_columns, default=valid_gb, key=f"graph_groupby_{analysis_id}"
                                             )
                                         group_by_sel = st.session_state.analyses[i]['params']['group_by_columns_graph']
                                         with col_agg_graph3: # Méthode
-                                            agg_meth_opts = ('count', 'mean', 'sum', 'median', 'min', 'max', 'std', 'nunique')
+                                            agg_method_options = ('count', 'mean', 'sum', 'median', 'min', 'max', 'std', 'nunique')
                                             st.session_state.analyses[i]['params']['agg_method_graph'] = st.selectbox(
-                                                f"Avec fonction :", agg_meth_opts, index=get_safe_index(agg_meth_opts, analysis['params'].get('agg_method_graph','count')), key=f"graph_agg_method_{analysis_id}", disabled=not group_by_sel
+                                                f"Avec fonction :", agg_method_options, index=get_safe_index(agg_method_options, analysis['params'].get('agg_method_graph','count')), key=f"graph_agg_method_{analysis_id}", disabled=not group_by_sel
                                             )
                                         with col_agg_graph2: # Colonne
-                                            agg_meth_sel = st.session_state.analyses[i]['params']['agg_method_graph']
-                                            agg_col_need = agg_meth_sel != 'count'
-                                            agg_col_opts = conf_numerical_columns if agg_col_need else ["(Non requis)"]
+                                            agg_method_sel = st.session_state.analyses[i]['params']['agg_method_graph']
+                                            agg_col_need = agg_method_sel != 'count'
+                                            agg_col_opts = numerical_columns if agg_col_need else ["(Non requis pour 'count')"]
                                             agg_col_sel = st.selectbox(
-                                                f"Calculer :", agg_col_opts, index=get_safe_index(agg_col_opts, analysis['params'].get('agg_column_graph')), key=f"graph_agg_col_{analysis_id}", disabled=not group_by_sel or not agg_col_need
+                                                f"Calculer :", agg_col_opts,
+                                                index=get_safe_index(agg_col_opts, analysis['params'].get('agg_column_graph')), key=f"graph_agg_col_{analysis_id}", disabled=not group_by_sel or not agg_col_need
                                             )
                                             st.session_state.analyses[i]['params']['agg_column_graph'] = agg_col_sel if agg_col_need else None
-                                    if aggregation_enabled_graph and agg_warning: st.warning(f"Avert. Aggr: {agg_warning}", icon="⚠️")
+                                    if aggregation_enabled_graph and agg_warning: st.warning(f"Avert. Agrégation: {agg_warning}", icon="⚠️")
                                     elif is_aggregated: st.caption(f"Utilisation données agrégées ({plot_data_source_df.shape[0]} l.).")
                                     else: st.caption("Utilisation données originales.")
 
                                 # --- Bouton Exécuter ---
                                 if st.button(f"Exécuter Graphique {i+1}", key=f"run_graph_{analysis_id}"):
                                     with st.spinner(f"Génération '{graph_analysis_type}'..."):
-                                        current_params = st.session_state.analyses[i]['params'].copy();
+                                        current_params = st.session_state.analyses[i]['params'].copy()
                                         # --- Récupérer tous les params finaux ---
                                         final_x = current_params.get('x_column'); final_y = current_params.get('y_column')
                                         final_color = current_params.get('color_column'); final_size = current_params.get('size_column')
@@ -763,12 +765,12 @@ with app_tab:
                                         # --- Validation ---
                                         error_msg = None
                                         if not final_x: error_msg = "Axe X requis."
-                                        elif graph_analysis_type not in ['Histogram', 'Pair Plot (SPLOM)', 'Sunburst', 'Treemap'] and not final_y: error_msg = f"Axe Y requis pour '{graph_analysis_type}'."
+                                        elif graph_analysis_type not in ['histogram', 'pair_plot', 'sunburst', 'treemap'] and not final_y: error_msg = f"Axe Y requis pour '{graph_analysis_type}'."
                                         elif final_x and final_x not in plot_data_source_df.columns: error_msg = f"Colonne X '{final_x}' non trouvée."
                                         elif final_y and final_y not in plot_data_source_df.columns: error_msg = f"Colonne Y '{final_y}' non trouvée."
-                                        elif graph_analysis_type == 'Timeline (Gantt)' and not final_gantt_end: error_msg = "'Date Fin' requis pour Timeline."
-                                        elif graph_analysis_type == '3D Scatter Plot' and not final_z: error_msg = "'Axe Z' requis pour 3D Scatter."
-                                        elif graph_analysis_type in ['Sunburst', 'Treemap'] and (not final_path or not final_value): error_msg = "'Chemin Hiérarchique' et 'Valeurs' requis."
+                                        elif graph_analysis_type == 'timeline' and not final_gantt_end: error_msg = "'Date Fin' requis pour Timeline."
+                                        elif graph_analysis_type == 'scatter_3d' and not final_z: error_msg = "'Axe Z' requis pour 3D Scatter."
+                                        elif graph_analysis_type in ['sunburst', 'treemap'] and (not final_path or not final_value): error_msg = "'Chemin Hiérarchique' et 'Valeurs' requis."
 
                                         # --- Préparer Args Plotly ---
                                         px_args = {}
@@ -786,14 +788,14 @@ with app_tab:
                                             if final_color: px_args['color'] = final_color
                                             if final_facet: px_args['facet_col'] = final_facet
                                             if final_hover_valid: px_args['hover_data'] = final_hover_valid
-                                            if final_size and graph_analysis_type in ['Scatter Plot', '3D Scatter Plot']: px_args['size'] = final_size
-                                            if final_z and graph_analysis_type == '3D Scatter Plot': px_args['z'] = final_z
-                                            if final_path and graph_analysis_type in ['Sunburst', 'Treemap']: px_args['path'] = final_path
-                                            if final_value and graph_analysis_type in ['Sunburst', 'Treemap']: px_args['values'] = final_value
-                                            if final_gantt_end and graph_analysis_type == 'Timeline (Gantt)': px_args['x_end'] = final_gantt_end; px_args['x_start'] = final_x
+                                            if final_size and graph_analysis_type in ['scatter', 'scatter_3d']: px_args['size'] = final_size
+                                            if final_z and graph_analysis_type == 'scatter_3d': px_args['z'] = final_z
+                                            if final_path and graph_analysis_type in ['sunburst', 'treemap']: px_args['path'] = final_path
+                                            if final_value and graph_analysis_type in ['sunburst', 'treemap']: px_args['values'] = final_value
+                                            if final_gantt_end and graph_analysis_type == 'timeline': px_args['x_end'] = final_gantt_end; px_args['x_start'] = final_x
 
                                             title_parts = [graph_analysis_type] # Construire titre
-                                            if final_y and graph_analysis_type != 'Histogram': title_parts.append(f"{final_y} vs")
+                                            if final_y and graph_analysis_type != 'histogram': title_parts.append(f"{final_y} vs")
                                             if final_x: title_parts.append(final_x)
                                             if final_color: title_parts.append(f"par {final_color}")
                                             if is_aggregated: title_parts.append("(Agrégé)")
@@ -804,19 +806,19 @@ with app_tab:
                                                 fig = None
                                                 plot_func = getattr(px, graph_analysis_type.lower().replace(' ', '').replace('(','').replace(')',''), None)
 
-                                                if graph_analysis_type == 'Pair Plot (SPLOM)':
-                                                     splom_dims = [c for c in data.columns if c in conf_numerical_columns]
+                                                if graph_analysis_type == 'pair_plot':
+                                                     splom_dims = [c for c in data.columns if c in numerical_columns]
                                                      if len(splom_dims)>=2:
                                                          splom_args={'data_frame':data, 'dimensions':splom_dims}
-                                                         color_splom = final_color if (final_color and final_color in data.columns and final_color in conf_categorical_columns) else None
+                                                         color_splom = final_color if (final_color and final_color in data.columns and final_color in categorical_columns) else None
                                                          if color_splom: splom_args['color'] = color_splom
                                                          splom_args['title'] = f'Pair Plot' + (f' par {color_splom}' if color_splom else '')
                                                          fig=px.scatter_matrix(**splom_args)
                                                      else: st.warning("Pair Plot requiert >= 2 cols numériques.")
-                                                elif graph_analysis_type == 'Histogram':
+                                                elif graph_analysis_type == 'histogram':
                                                     hist_args = {k: v for k, v in px_args.items() if k != 'y'} # Retirer Y pour histogramme
                                                     fig = px.histogram(**hist_args)
-                                                elif graph_analysis_type == 'Timeline (Gantt)':
+                                                elif graph_analysis_type == 'timeline':
                                                      gantt_args = px_args.copy()
                                                      if 'y' in gantt_args: gantt_args['task'] = gantt_args.pop('y') # Renommer y en task pour timeline
                                                      fig = px.timeline(**gantt_args)
@@ -834,20 +836,20 @@ with app_tab:
                                             except Exception as e:
                                                 st.error(f"Erreur génération graphique {i+1}: {e}")
                                                 st.session_state.analyses[i]['result'] = None
-                                                st.session_state.analyses[i]['executed_params'] = current_params # Sauver params même si échec
+                                                st.session_state.analyses[i]['executed_params'] = current_params # Sauver params même si échoué
 
                     # ===========================
                     # Bloc Stats Descriptives
                     # ===========================
                     elif analysis['type'] == 'descriptive_stats':
                         st.markdown("##### Configuration Stats Descriptives")
-                        desc_col_options = conf_all_columns
+                        desc_col_options = all_columns
                         if not desc_col_options: st.warning("Aucune colonne disponible.")
                         else:
                             init_analysis_state(i, 'selected_columns_desc', [])
                             default_desc = analysis['params'].get('selected_columns_desc', [])
                             valid_default = [c for c in default_desc if c in desc_col_options] or \
-                                            [c for c in desc_col_options if c in conf_numerical_columns or c in conf_datetime_columns] or \
+                                            [c for c in desc_col_options if c in numerical_columns or c in datetime_columns] or \
                                             desc_col_options # Fallback
 
                             st.session_state.analyses[i]['params']['selected_columns_desc'] = st.multiselect(
@@ -914,7 +916,7 @@ with app_tab:
         if show_advanced:
              if not data_available: st.warning("Chargez des données pour utiliser les analyses avancées.")
              # Vérifier si les listes de colonnes nécessaires existent et ne sont pas vides
-             elif not columns_defined or not (conf_numerical_columns or conf_categorical_columns):
+             elif not columns_defined or not (numerical_columns or categorical_columns):
                  st.warning("Nécessite des colonnes Numériques ou Catégorielles détectées pour les analyses avancées.")
              else:
                 adv_analysis_key_suffix = st.session_state.data_loaded_id or "adv_data_loaded"
@@ -927,13 +929,13 @@ with app_tab:
                     # Test T
                     if advanced_analysis_type == 'Test T':
                         st.markdown("###### Test T (Comparaison de 2 moyennes)");
-                        cols_valid_t = [c for c in conf_categorical_columns if data[c].nunique() == 2]
-                        if not conf_numerical_columns: st.warning("Nécessite Var Numérique.")
+                        cols_valid_t = [c for c in categorical_columns if data[c].nunique() == 2]
+                        if not numerical_columns: st.warning("Nécessite Var Numérique.")
                         elif not cols_valid_t: st.warning("Nécessite Var Catégorielle à 2 groupes.")
                         else:
                             col_t1, col_t2, col_t3 = st.columns([2, 2, 1])
                             with col_t1: group_col_t = st.selectbox("Var Catégorielle (2 groupes):", cols_valid_t, key=f"t_group_{adv_analysis_key_suffix}")
-                            with col_t2: numeric_var_t = st.selectbox("Var Numérique:", conf_numerical_columns, key=f"t_numeric_{adv_analysis_key_suffix}")
+                            with col_t2: numeric_var_t = st.selectbox("Var Numérique:", numerical_columns, key=f"t_numeric_{adv_analysis_key_suffix}")
                             with col_t3:
                                 st.write(""); st.write("")
                                 if st.button("Effectuer Test T", key=f"run_t_{adv_analysis_key_suffix}", use_container_width=True):
@@ -956,13 +958,13 @@ with app_tab:
                     # ANOVA
                     elif advanced_analysis_type == 'ANOVA':
                         st.markdown("###### ANOVA (Comparaison >2 moyennes)")
-                        cols_valid_a = [c for c in conf_categorical_columns if data[c].nunique() > 2 and data[c].nunique() < 50]
-                        if not conf_numerical_columns: st.warning("Nécessite Var Numérique.")
+                        cols_valid_a = [c for c in categorical_columns if data[c].nunique() > 2 and data[c].nunique() < 50]
+                        if not numerical_columns: st.warning("Nécessite Var Numérique.")
                         elif not cols_valid_a: st.warning("Nécessite Var Catégorielle (>2 et <50 groupes).")
                         else:
                             col_a1, col_a2, col_a3 = st.columns([2, 2, 1])
                             with col_a1: group_col_a = st.selectbox("Var Catégorielle (>2 groupes):", cols_valid_a, key=f"a_group_{adv_analysis_key_suffix}")
-                            with col_a2: anova_numeric_var = st.selectbox("Var Numérique:", conf_numerical_columns, key=f"a_numeric_{adv_analysis_key_suffix}")
+                            with col_a2: anova_numeric_var = st.selectbox("Var Numérique:", numerical_columns, key=f"a_numeric_{adv_analysis_key_suffix}")
                             with col_a3:
                                 st.write(""); st.write("")
                                 if st.button("Effectuer ANOVA", key=f"run_a_{adv_analysis_key_suffix}", use_container_width=True):
@@ -985,11 +987,11 @@ with app_tab:
                     # Chi-Square
                     elif advanced_analysis_type == 'Chi-Square Test':
                         st.markdown("###### Test Chi-carré (Indépendance Vars Catégorielles)")
-                        if len(conf_categorical_columns) < 2: st.warning("Nécessite >= 2 Vars Catégorielles.")
+                        if len(categorical_columns) < 2: st.warning("Nécessite >= 2 Vars Catégorielles.")
                         else:
                             col_c1, col_c2, col_c3 = st.columns([2, 2, 1])
-                            with col_c1: chi2_var1 = st.selectbox("Variable Catégorielle 1:", conf_categorical_columns, key=f"c1_var_{adv_analysis_key_suffix}", index=0)
-                            options_var2 = [c for c in conf_categorical_columns if c != chi2_var1]
+                            with col_c1: chi2_var1 = st.selectbox("Variable Catégorielle 1:", categorical_columns, key=f"c1_var_{adv_analysis_key_suffix}", index=0)
+                            options_var2 = [c for c in categorical_columns if c != chi2_var1]
                             with col_c2: chi2_var2 = st.selectbox("Variable Catégorielle 2:", options_var2, key=f"c2_var_{adv_analysis_key_suffix}", index=0 if options_var2 else None, disabled=not options_var2)
                             with col_c3:
                                 st.write(""); st.write("")
@@ -1005,17 +1007,17 @@ with app_tab:
                                                  if p < alpha: st.success(msg)
                                                  else: st.info(msg)
                                                  with st.expander("Tableau Contingence"): st.dataframe(ct)
-                                                 if np.any(expected < 5): st.warning("Freq. attendues < 5, test moins fiable.", icon="⚠️")
-                                                 with st.expander("Freq. Attendues"): st.dataframe(pd.DataFrame(expected, index=ct.index, columns=ct.columns).style.format("{:.2f}"))
+                                                 if np.any(expected < 5): st.warning("Fréq. attendues < 5, test moins fiable.", icon="⚠️")
+                                                 with st.expander("Fréq. Attendues"): st.dataframe(pd.DataFrame(expected, index=ct.index, columns=ct.columns).style.format("{:.2f}"))
                                          except Exception as e: st.error(f"Erreur Test Chi²: {e}")
                                     else: st.warning("Sélectionnez 2 variables.")
                     # Corrélation
                     elif advanced_analysis_type == 'Corrélation':
                         st.markdown("###### Matrice de Corrélation (Vars Numériques)")
-                        if len(conf_numerical_columns) < 2: st.warning("Nécessite >= 2 Vars Numériques.")
+                        if len(numerical_columns) < 2: st.warning("Nécessite >= 2 Vars Numériques.")
                         else:
-                             default_cols = conf_numerical_columns[:min(len(conf_numerical_columns), 5)]
-                             features = st.multiselect("Sélectionnez 2+ vars numériques:", conf_numerical_columns, default=default_cols, key=f"corr_vars_{adv_analysis_key_suffix}")
+                             default_cols = numerical_columns[:min(len(numerical_columns), 5)]
+                             features = st.multiselect("Sélectionnez 2+ vars numériques:", numerical_columns, default=default_cols, key=f"corr_vars_{adv_analysis_key_suffix}")
                              if st.button("Calculer Matrice Corrélation", key=f"run_corr_{adv_analysis_key_suffix}", use_container_width=True):
                                 if len(features) >= 2:
                                     try:
@@ -1028,13 +1030,13 @@ with app_tab:
                                     except Exception as e: st.error(f"Erreur Corrélation: {e}")
                                 else: st.warning("Sélectionnez >= 2 variables.")
                     # Régression Linéaire
-                    elif advanced_analysis_type == 'Régression Linéaire':
+                    elif advanced_analysis_type == 'Régression Linéaire Simple (Y ~ X)':
                         st.markdown("###### Régression Linéaire Simple (Y ~ X)")
-                        if len(conf_numerical_columns) < 2: st.warning("Nécessite >= 2 Vars Numériques.")
+                        if len(numerical_columns) < 2: st.warning("Nécessite >= 2 Vars Numériques.")
                         else:
                             col_r1, col_r2, col_r3 = st.columns([2, 2, 1])
-                            with col_r1: target = st.selectbox("Variable Cible (Y):", conf_numerical_columns, key=f"reg_target_{adv_analysis_key_suffix}", index=0)
-                            options_feat = [f for f in conf_numerical_columns if f != target]
+                            with col_r1: target = st.selectbox("Variable Cible (Y):", numerical_columns, key=f"reg_target_{adv_analysis_key_suffix}", index=0)
+                            options_feat = [f for f in numerical_columns if f != target]
                             with col_r2: feature = st.selectbox("Variable Explicative (X):", options_feat, key=f"reg_feature_{adv_analysis_key_suffix}", index=0 if options_feat else None, disabled=not options_feat)
                             with col_r3:
                                 st.write(""); st.write("")
@@ -1057,10 +1059,10 @@ with app_tab:
                     # ACP (PCA)
                     elif advanced_analysis_type == 'ACP (PCA)':
                          st.markdown("###### ACP (Analyse en Composantes Principales)")
-                         if len(conf_numerical_columns) < 2: st.warning("Nécessite >= 2 Vars Numériques.")
+                         if len(numerical_columns) < 2: st.warning("Nécessite >= 2 Vars Numériques.")
                          else:
-                              default_cols = conf_numerical_columns[:min(len(conf_numerical_columns), 5)]
-                              features = st.multiselect("Sélectionnez 2+ vars numériques:", conf_numerical_columns, default=default_cols, key=f"pca_vars_{adv_analysis_key_suffix}")
+                              default_cols = numerical_columns[:min(len(numerical_columns), 5)]
+                              features = st.multiselect("Sélectionnez 2+ vars numériques:", numerical_columns, default=default_cols, key=f"pca_vars_{adv_analysis_key_suffix}")
                               if st.button("Effectuer ACP", key=f"run_pca_{adv_analysis_key_suffix}", use_container_width=True):
                                  if len(features) >= 2:
                                      try:
@@ -1090,12 +1092,12 @@ with app_tab:
                     # K-Means
                     elif advanced_analysis_type == 'Clustering K-Means':
                         st.markdown("###### Clustering K-Means")
-                        if len(conf_numerical_columns) < 1: st.warning("Nécessite >= 1 Var Numérique.")
+                        if len(numerical_columns) < 1: st.warning("Nécessite >= 1 Var Numérique.")
                         else:
                              col_cl1, col_cl2, col_cl3 = st.columns([2, 1, 1])
                              with col_cl1:
-                                 default_cols = conf_numerical_columns[:min(len(conf_numerical_columns), 2)]
-                                 features = st.multiselect("Variables Numériques:", conf_numerical_columns, default=default_cols, key=f"clust_vars_{adv_analysis_key_suffix}")
+                                 default_cols = numerical_columns[:min(len(numerical_columns), 2)]
+                                 features = st.multiselect("Variables Numériques:", numerical_columns, default=default_cols, key=f"clust_vars_{adv_analysis_key_suffix}")
                              with col_cl2:
                                  k_suggested = 3
                                  if data is not None and not data.empty and features:
@@ -1143,10 +1145,10 @@ with app_tab:
                     # Détection Anomalies
                     elif advanced_analysis_type == 'Détection d\'Anomalies (Z-score)':
                         st.markdown("###### Détection Anomalies (Z-score)")
-                        if not conf_numerical_columns: st.warning("Nécessite >= 1 Var Numérique.")
+                        if not numerical_columns: st.warning("Nécessite >= 1 Var Numérique.")
                         else:
                             col_anom1, col_anom2, col_anom3 = st.columns([2, 1, 1])
-                            with col_anom1: default_cols = conf_numerical_columns[:1]; features = st.multiselect("Sélectionnez 1+ vars numériques:", conf_numerical_columns, default=default_cols, key=f"anomaly_vars_{adv_analysis_key_suffix}")
+                            with col_anom1: default_cols = numerical_columns[:1]; features = st.multiselect("Sélectionnez 1+ vars numériques:", numerical_columns, default=default_cols, key=f"anomaly_vars_{adv_analysis_key_suffix}")
                             with col_anom2: threshold = st.number_input("Seuil Z-score:", min_value=1.0, max_value=5.0, value=3.0, step=0.1, key=f"anomaly_z_{adv_analysis_key_suffix}", help="|valeur - moy| / std > seuil.")
                             with col_anom3:
                                 st.write(""); st.write("")
@@ -1161,7 +1163,7 @@ with app_tab:
                                                     z = np.abs(stats.zscore(df_raw)); mask = (z > threshold).any(axis=1)
                                                     indices = df_raw.index[mask]; n_anom = len(indices)
                                                     st.metric(label="Anomalies Détectées", value=n_anom); st.caption(f"Z > {threshold} pour au moins une var.")
-                                                    if n_anom > 0: st.write(f"**{n_anom} ligne(s) anormales:**"); st.dataframe(data.loc[indices])
+                                                    if n_anom > 0: st.write(f"**{n_anom} ligne(s) anormale(s):**"); st.dataframe(data.loc[indices])
                                                     else: st.success("Aucune anomalie détectée.")
                                                     if len(valid_f) == 1:
                                                         col = valid_f[0]; moy = data[col].mean(); std = data[col].std()
@@ -1192,8 +1194,8 @@ with manual_tab:
 
     ---
     ### 1. Chargement des Données (Barre Latérale ⚙️)
-    - **Choisir une méthode** : Sélectionnez l'une des options proposées (URL, Coller).
-    - **URL** : Collez l'URL directe d'un fichier CSV ou Excel public et cliquez sur "Charger depuis URL".
+    - **Choisir une méthode** : Sélectionnez l'une des options proposées (URL, Coller depuis presse-papiers).
+    - **URL** : Collez l'URL direct d'un fichier CSV ou Excel public et cliquez sur "Charger depuis URL".
     - **Coller depuis presse-papiers**: Copiez des données depuis un tableur (Excel, Sheets), collez-les dans la zone de texte, vérifiez le séparateur (Tabulation par défaut) et cliquez sur "Charger Données Collées".
     - **Utiliser l'en-tête** : Cochez/décochez la case **avant** de cliquer sur le bouton de chargement correspondant à votre méthode pour indiquer si la première ligne contient les noms de colonnes.
 
@@ -1215,7 +1217,7 @@ with manual_tab:
     ---
     ### 💡 Conseils & Dépannage
     - **Types de Colonnes** : Vérifiez les types détectés dans la section "Afficher détails colonnes". Corrigez vos données sources si nécessaire (ex: formats de date, nombres avec texte). Une mauvaise détection peut limiter les options d'analyse.
-    - **Chargement échoue ?** Vérifiez le format du fichier/URL/données collées, le séparateur choisi (pour coller), la connexion internet (pour URL) et les dépendances (`openpyxl` pour Excel). Assurez-vous que le fichier `sample_excel.xlsx` est bien présent à la racine si vous utilisez l'exemple. Vérifiez le message d'erreur dans la sidebar.
+    - **Chargement échoué ?** Vérifiez le format du fichier/URL/données collées, le séparateur choisi (pour coller), la connexion internet (pour URL) et les dépendances (`openpyxl` pour Excel). Assurez-vous que le fichier `sample_excel.xlsx` est bien présent à la racine si vous utilisez l'exemple. Vérifiez le message d'erreur dans la sidebar.
     - **Erreurs d'analyse ?** Lisez les messages d'erreur. Vérifiez la sélection des colonnes et leur type. Les analyses statistiques nécessitent souvent des données numériques sans valeurs manquantes.
     - **Problèmes sur Hugging Face Spaces ?** Vérifiez `requirements.txt`, la présence de `report_template.html` et `sample_excel.xlsx` à la racine, et la configuration de la clé `GOOGLE_API_KEY` dans les Secrets.
 
@@ -1225,6 +1227,7 @@ with manual_tab:
     📞 Contact : +229 96911346
     🔗 [Profil LinkedIn](https://www.linkedin.com/in/sidoineko) | 📂 [Portfolio](https://huggingface.co/spaces/Sidoineko/portfolio)
     """)
+
 # ==============================================================================
 # ONGLET CHAT IA
 # ==============================================================================
@@ -1259,7 +1262,7 @@ with chat_tab:
                 source_info_context = st.session_state.get('data_source_info', 'Inconnue')
                 context_prompt = f"""
                 CONTEXTE:
-                Tu es un assistant IA dans une application Streamlit d'analyse de données.
+                Vous êtes un assistant IA dans une application Streamlit d'analyse de données.
                 - Source des données: "{source_info_context}"
                 - Colonnes Numériques: {', '.join(num_cols_context) if num_cols_context else 'Aucune'}
                 - Colonnes Catégorielles: {', '.join(cat_cols_context) if cat_cols_context else 'Aucune'}
@@ -1267,13 +1270,12 @@ with chat_tab:
                 - Analyses ajoutées: {', '.join(analyses_context) if analyses_context else 'Aucune'}
                 - Analyses avancées dispo: Test T, ANOVA, Chi-Square, Corrélation, Régression Linéaire, ACP (PCA), Clustering K-Means, Détection Anomalies (Z-score).
 
-                TA TÂCHE: Réponds à la question de l'utilisateur de manière concise et utile, en te basant sur le contexte fourni (types de colonnes, analyses possibles). Ne prétends pas connaître les valeurs des données.
+                TÂCHE: Réponds à la question de l'utilisateur de manière concise et utile, en te basant sur le contexte fourni (types de colonnes, analyses possibles). Ne prétends pas connaître les valeurs des données.
 
                 QUESTION UTILISATEUR: "{user_question}"
 
-                TA RÉPONSE:
+                RÉPONSE:
                 """
-                # Génération de la réponse (identique)
                 try:
                     with st.spinner("L'IA réfléchit..."):
                         response = model_chat.generate_content(context_prompt)
@@ -1290,5 +1292,6 @@ with chat_tab:
                          st.warning(error_msg_ai); st.session_state.gemini_chat_history.append({"role": "assistant", "content": f"({error_msg_ai})"})
                 except Exception as e:
                     error_message = f"Erreur API Gemini: {e}"
-                    st.error(error_message); st.session_state.gemini_chat_history.append({"role": "assistant", "content": f"(Erreur: {e})"})
-        else: st.error("Modèle Chat IA indisponible.")
+                    st.error(error_message); st.session_state.gemini_chat_history.append({"role": "assistant", "content": f"({error_message})"})
+        else:
+            st.error("Modèle Chat IA indisponible.")