Update app.py

app.py

@@ -1,4 +1,4 @@
-# -*- coding: utf-8 -*- # Ajout pour assurer la compatibilité de l'encodage
+# -*- coding: utf-8 -*-
 
 import streamlit as st
 import pandas as pd
@@ -27,7 +27,6 @@ st.set_page_config(
 # --- Styles CSS Personnalisés ---
 st.markdown("""
 <style>
-    /* Styles CSS (gardés pour la concision) */
     .main-header { font-size: 2.5rem; color: #1E88E5; font-weight: 700; margin-bottom: 1rem; }
     .sub-header { font-size: 1.5rem; color: #0D47A1; font-weight: 600; margin-top: 1.5rem; margin-bottom: 1rem; }
     .card { background-color: #f9f9f9; border-radius: 10px; padding: 20px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); margin-bottom: 1rem; }
@@ -39,28 +38,26 @@ st.markdown("""
 """, unsafe_allow_html=True)
 
 # --- Constantes (Regex et autres) ---
-# Suppression de REGEX_REPORT_ID
-REGEX_PRODUCT_NAME = r'^([A-Z0-9\s/]+)' # Majuscules, chiffres, espaces ET slash pour certains noms
+REGEX_PRODUCT_NAME = r'^([A-Z0-9\s/]+)'
 REGEX_DLUO = r'DLUO\s+(\d{2}\.\d{2}\.\d{2})'
 REGEX_DATETIME = r'(\d{2}/\d{2}/\d{4}\s+-\s+\d{2}:\d{2})'
-REGEX_WEIGHTS = r'(\d+)\s*\.{5,}\s*([\d,\.]+)\s*g' # Au moins 5 points pour séparer
-REGEX_MEAN = r'x̄\s+\d*[,\.]?\d*\s*%\s+([\d,\.]+)\s*g' # Rend les pourcentages optionnels visuellement
-REGEX_STD = r's\s+\d*[,\.]?\d*\s*%\s+([\d,\.]+)\s*g' # Rend les pourcentages optionnels visuellement
-REGEX_MIN = r'Min\s+\d*[,\.]?\d*\s*%\s+([\d,\.]+)\s*g' # Rend les pourcentages optionnels visuellement
-REGEX_MAX = r'Max\s+\d*[,\.]?\d*\s*%\s+([\d,\.]+)\s*g' # Rend les pourcentages optionnels visuellement
+REGEX_WEIGHTS = r'(\d+)\s*\.{5,}\s*([\d,\.]+)\s*g'
+REGEX_MEAN = r'x̄\s+\d*[,\.]?\d*\s*%\s+([\d,\.]+)\s*g'
+REGEX_STD = r's\s+\d*[,\.]?\d*\s*%\s+([\d,\.]+)\s*g'
+REGEX_MIN = r'Min\s+\d*[,\.]?\d*\s*%\s+([\d,\.]+)\s*g'
+REGEX_MAX = r'Max\s+\d*[,\.]?\d*\s*%\s+([\d,\.]+)\s*g'
 REGEX_NOMINAL = r'Nominal\s+([\d,\.]+)\s*g'
 
-FALLBACK_ID_PREFIX = "IncompleteID_" # Préfixe pour les ID générés quand des infos manquent
+FALLBACK_ID_PREFIX = "IncompleteID_"
 
 # --- Fonctions Utilitaires ---
 
-def safe_extract_group(match, group_index=1, default="Non trouvé"): # Default à "Non trouvé"
+def safe_extract_group(match, group_index=1, default="Non trouvé"):
     """Extrait un groupe d'une correspondance regex en toute sécurité."""
     if match:
         try:
-            # Nettoyage supplémentaire: supprimer les espaces blancs excessifs
             extracted = match.group(group_index).strip()
-            # Remplacer les séquences de plusieurs espaces par un seul
+            # Nettoyage supplémentaire: supprimer les espaces blancs excessifs
             return re.sub(r'\s+', ' ', extracted) if extracted else default
         except IndexError:
             return default
@@ -95,7 +92,7 @@ def create_batch_id(product, dluo, date_time):
 def extract_data_from_pdf(pdf_file_path):
     """
     Extrait les données structurées d'un fichier PDF de rapport de pesée.
-    Utilise maintenant Produit+DLUO+DateHeure comme identifiant de batch.
+    Utilise Produit+DLUO+DateHeure comme identifiant de batch.
     """
     try:
         text_content = ""
@@ -355,12 +352,13 @@ if page == "Extraction des PDF":
                     max_w = metadata.get('max_weight', 'N/A')
                     max_w_display = f"{max_w} g" if isinstance(max_w, (int, float)) else max_w
 
+                    # Correction de la f-string ici :
                     st.markdown(f"""
                     <div class="highlight">
                         <strong>Produit:</strong> {metadata.get('product_name', 'N/A')}<br>
                         <strong>DLUO:</strong> {metadata.get('dluo', 'N/A')}<br>
                         <strong>Date/Heure:</strong> {metadata.get('date_time', 'N/A')}<br>
-                        <strong>ID Batch:</strong> <small>{metadata.get('batch_id', 'N/A')}</small><br> {/* Affichage ID Batch */}
+                        <strong>ID Batch:</strong> <small>{metadata.get('batch_id', 'N/A')}</small><br>
                         <strong>Poids Nominal:</strong> {nom_w_display}<br>
                         <strong>Stats Rapport (Moy/Std/Min/Max):</strong>
                         {mean_w_display} / {std_w_display} /
@@ -375,7 +373,6 @@ if page == "Extraction des PDF":
         current_data = st.session_state.app_data["current_batch_data"]
         if not current_data.empty:
             st.markdown('<div class="sub-header">📈 Visualisation du Dernier Batch Ajouté</div>', unsafe_allow_html=True)
-            # ... (Code de visualisation du batch inchangé, il utilise les données de current_data) ...
             col1, col2 = st.columns(2)
             with col1:
                 fig_hist = px.histogram(
@@ -451,7 +448,7 @@ elif page == "Analyse des Données":
 
     # --- Affichage et Analyse si des Données existent ---
     if not st.session_state.app_data["all_data"].empty:
-        all_data = st.session_state.app_data["all_data"].copy()
+        all_data = st.session_state.app_data["all_data"].copy() # Travailler sur une copie
 
         # --- Préparation des Données d'Analyse ---
         # Conversion Date (robuste)
@@ -494,22 +491,57 @@ elif page == "Analyse des Données":
         col_f1, col_f2 = st.columns(2)
         with col_f1:
             products = sorted(all_data["Produit"].unique())
-            if products: selected_products = st.multiselect("Filtrer par Produit", options=products, default=products)
-            else: selected_products = []
+            # Gère le cas où il n'y a aucun produit
+            if products:
+                selected_products = st.multiselect("Filtrer par Produit", options=products, default=products)
+            else:
+                selected_products = []
+                st.info("Aucun produit trouvé dans les données.")
+
+
         with col_f2:
+            # Vérifie que la colonne Date existe et contient des dates valides
             if "Date" in all_data.columns and all_data["Date"].notna().any():
                 valid_dates = sorted(all_data["Date"].dropna().unique())
-                min_date, max_date = min(valid_dates), max(valid_dates)
-                selected_date_range = st.date_input("Filtrer par Plage de Dates", value=(min_date, max_date),
-                                                    min_value=min_date, max_value=max_date, key="date_filter")
-            else: selected_date_range = None
+                # Vérifie qu'il y a au moins une date valide
+                if valid_dates:
+                    min_date = min(valid_dates)
+                    max_date = max(valid_dates)
+                    # Assure que min_date n'est pas postérieur à max_date
+                    default_start = min_date
+                    default_end = max_date
+                    if min_date > max_date:
+                        default_start, default_end = max_date, min_date # Swap si nécessaire
+
+                    selected_date_range = st.date_input(
+                        "Filtrer par Plage de Dates",
+                        value=(default_start, default_end),
+                        min_value=default_start,
+                        max_value=default_end,
+                        key="date_filter"
+                    )
+                else:
+                    selected_date_range = None
+                    st.info("Aucune date valide trouvée pour le filtre.")
+            else:
+                selected_date_range = None
+                st.info("Filtrage par date non disponible (colonne 'Date' manquante ou invalide).")
 
         # --- Application des Filtres ---
         filtered_data = all_data.copy()
-        if selected_products: filtered_data = filtered_data[filtered_data["Produit"].isin(selected_products)]
+        if selected_products:
+            filtered_data = filtered_data[filtered_data["Produit"].isin(selected_products)]
+
+        # Applique le filtre de date seulement si la colonne Date existe,
+        # que la plage est valide et qu'elle contient des dates non-NaT
         if selected_date_range and len(selected_date_range) == 2 and "Date" in filtered_data.columns and filtered_data["Date"].notna().any():
             start_date, end_date = selected_date_range
-            filtered_data = filtered_data[(filtered_data["Date"] >= start_date) & (filtered_data["Date"] <= end_date)]
+            # Comparaison sécurisée avec les dates (ignore les NaT)
+            filtered_data = filtered_data[
+                (filtered_data["Date"].notna()) &
+                (filtered_data["Date"] >= start_date) &
+                (filtered_data["Date"] <= end_date)
+            ]
 
         # --- Affichage si données filtrées ---
         if not filtered_data.empty:
@@ -525,111 +557,226 @@ elif page == "Analyse des Données":
                 "📦 Analyse par Produit/DLUO" # Nouvelle tabulation
             ])
 
-            with tab1: # Distribution & Histogrammes (inchangé)
+            with tab1: # Distribution & Histogrammes
                 st.markdown("#### Distribution des Poids par Produit (Boîtes à Moustaches)")
                 if not filtered_data.empty:
                     fig_box = px.box(
-                        filtered_data, x="Produit", y="Poids (g)", color="Produit", points=False,
+                        filtered_data, x="Produit", y="Poids (g)", color="Produit", points=False, # 'all' peut être lent
                         title="Distribution des Poids par Produit Filtré", template="plotly_white"
                     )
                     fig_box.update_layout(xaxis_title="Produit", yaxis_title="Poids (g)", showlegend=False)
                     st.plotly_chart(fig_box, use_container_width=True)
+                else:
+                    st.info("Aucune donnée à afficher pour la distribution.")
 
                 st.markdown("#### Histogramme Détaillé par Produit")
                 unique_filtered_products = sorted(filtered_data["Produit"].unique())
                 if unique_filtered_products:
-                    histo_product = st.selectbox("Choisir un produit pour l'histogramme détaillé", options=unique_filtered_products, key="histo_select")
+                    histo_product = st.selectbox(
+                        "Choisir un produit pour l'histogramme détaillé",
+                        options=unique_filtered_products,
+                        key="histo_select"
+                    )
                     if histo_product:
                         product_data = filtered_data[filtered_data["Produit"] == histo_product]
                         if not product_data.empty:
                             fig_hist_detail = px.histogram(product_data, x="Poids (g)", marginal="rug", nbins=30,
                                                            title=f"Histogramme des Poids - {histo_product}", template="plotly_white")
+                            # Ajout ligne nominale si disponible et valide
                             if "Poids_Nominal" in product_data.columns and product_data["Poids_Nominal"].notna().any():
-                                nominal_val = product_data["Poids_Nominal"].dropna().iloc[0]
+                                nominal_val = product_data["Poids_Nominal"].dropna().iloc[0] # Prend la première valeur non nulle
                                 if pd.notna(nominal_val):
-                                    fig_hist_detail.add_vline(x=nominal_val, line_dash="dash", line_color="red",
-                                                              annotation_text=f"Nominal: {nominal_val}g", annotation_position="top right")
+                                    fig_hist_detail.add_vline(
+                                        x=nominal_val, line_dash="dash", line_color="red",
+                                        annotation_text=f"Nominal: {nominal_val}g", annotation_position="top right"
+                                    )
                             st.plotly_chart(fig_hist_detail, use_container_width=True)
-                else: st.info("Aucun produit disponible pour l'histogramme après filtrage.")
+                        else:
+                            st.info(f"Aucune donnée pour le produit sélectionné : {histo_product}")
+                else:
+                     st.info("Aucun produit disponible pour l'histogramme après filtrage.")
 
 
-            with tab2: # Analyse Temporelle (inchangé)
+            with tab2: # Analyse Temporelle
                 st.markdown("#### Évolution Temporelle des Poids Moyens")
+                # Vérifie la présence de dates valides dans les données filtrées
                 if "Date" in filtered_data.columns and filtered_data["Date"].notna().any():
+                    # Agréger par date et produit
                     try:
+                        # Utilise observed=True pour éviter les combinaisons vides si les colonnes sont catégorielles
                         time_data = filtered_data.dropna(subset=["Date", "Produit", "Poids (g)"]).groupby(["Date", "Produit"], observed=True).agg(
-                            Poids_Moyen=("Poids (g)", "mean"), Ecart_Type=("Poids (g)", "std"), Nb_Echantillons=("Poids (g)", "count")
+                            Poids_Moyen=("Poids (g)", "mean"),
+                            Ecart_Type=("Poids (g)", "std"),
+                            Nb_Echantillons=("Poids (g)", "count")
                         ).reset_index()
+
                         if not time_data.empty:
-                            fig_line = px.line(time_data, x="Date", y="Poids_Moyen", color="Produit", markers=True, error_y="Ecart_Type",
-                                               title="Évolution Poids Moyens (± Écart Type)", template="plotly_white", labels={"Poids_Moyen": "Poids Moyen (g)"})
+                            fig_line = px.line(
+                                time_data, x="Date", y="Poids_Moyen", color="Produit",
+                                markers=True, error_y="Ecart_Type",
+                                title="Évolution des Poids Moyens (± Écart Type) dans le Temps",
+                                template="plotly_white", labels={"Poids_Moyen": "Poids Moyen (g)"}
+                            )
                             st.plotly_chart(fig_line, use_container_width=True)
-                        else: st.info("Pas assez de données valides pour l'analyse temporelle.")
-                    except Exception as e_agg: logging.error(f"Erreur agrégation temporelle: {e_agg}", exc_info=True); time_data = pd.DataFrame()
+                        else:
+                            st.info("Pas assez de données valides (Date, Produit, Poids) pour l'analyse temporelle.")
+
+                    except Exception as e_agg:
+                        st.error(f"Erreur lors de l'agrégation des données temporelles: {e_agg}")
+                        logging.error(f"Erreur agrégation temporelle: {e_agg}", exc_info=True)
+                        time_data = pd.DataFrame() # Assurer que time_data existe mais est vide
 
                     st.markdown("#### Heatmap des Poids Moyens par Produit et Date")
+                    # Vérifie s'il y a des données et assez de variété pour une heatmap
                     if not time_data.empty and time_data['Date'].nunique() > 1 and time_data['Produit'].nunique() > 0:
                         try:
+                            # Créer une matrice pivot pour la heatmap
                             heatmap_pivot = time_data.pivot_table(index="Produit", columns="Date", values="Poids_Moyen")
+
                             if not heatmap_pivot.empty:
-                                fig_heatmap = px.imshow(heatmap_pivot, aspect="auto", color_continuous_scale="RdBu_r", title="Heatmap Poids Moyens", template="plotly_white")
-                                fig_heatmap.update_layout(height=max(400, len(heatmap_pivot.index) * 50 + 100))
-                                fig_heatmap.update_layout(xaxis_title="Date", yaxis_title="Produit", coloraxis_colorbar_title="Poids Moyen (g)")
+                                fig_heatmap = px.imshow(
+                                    heatmap_pivot, aspect="auto", # Ajuste l'aspect
+                                    color_continuous_scale="RdBu_r", # Rouge = bas, Bleu = haut
+                                    title="Heatmap des Poids Moyens",
+                                    template="plotly_white"
+                                )
+                                # Amélioration de la taille de la heatmap
+                                fig_heatmap.update_layout(height=max(400, len(heatmap_pivot.index) * 50 + 100)) # Hauteur dynamique + marge
+                                fig_heatmap.update_layout(
+                                    xaxis_title="Date", yaxis_title="Produit",
+                                    coloraxis_colorbar_title="Poids Moyen (g)"
+                                )
                                 st.plotly_chart(fig_heatmap, use_container_width=True)
-                            else: st.info("Pas assez de données variées pour générer une heatmap.")
-                        except Exception as e_heatmap: logging.warning(f"Impossible de générer la heatmap: {e_heatmap}", exc_info=True)
-                    else: st.info("Pas assez de données (dates/produits distincts) pour une heatmap pertinente.")
-                else: st.info("Analyse temporelle non disponible (colonne 'Date' invalide/manquante).")
+                            else:
+                                st.info("Pas assez de données variées (produits/dates) pour générer une heatmap.")
 
+                        except Exception as e_heatmap:
+                            st.warning(f"Impossible de générer la heatmap: {e_heatmap}")
+                            logging.warning(f"Erreur heatmap: {e_heatmap}", exc_info=True)
+                    elif not time_data.empty:
+                        st.info("Pas assez de données (dates ou produits distincts) pour générer une heatmap pertinente.")
+                    # else: # Cas où time_data était vide géré plus haut
 
-            with tab3: # Comparaison Produits (Global) - Radar Chart etc. (inchangé)
+                else:
+                    st.info("Analyse temporelle non disponible (colonne 'Date' invalide ou manquante dans les données filtrées).")
+
+
+            with tab3: # Comparaison Produits (Global)
                 st.markdown("#### Comparaison des Performances Produits (Global)")
+                # Vérifie la présence de déviation valide
                 if "Déviation_%" in filtered_data.columns and filtered_data["Déviation_%"].notna().any():
+
                     st.markdown("##### Déviation Moyenne (%) par Produit")
                     try:
+                        # Utilise observed=True pour la performance avec les catégories
                         dev_stats = filtered_data.dropna(subset=["Produit", "Déviation_%"]).groupby("Produit", observed=True).agg(
-                            Déviation_Moyenne=("Déviation_%", "mean"), Écart_Type_Déviation=("Déviation_%", "std")
+                            Déviation_Moyenne=("Déviation_%", "mean"),
+                            Écart_Type_Déviation=("Déviation_%", "std")
                         ).reset_index()
+
                         if not dev_stats.empty:
-                            fig_bar_dev = px.bar(dev_stats, x="Produit", y="Déviation_Moyenne", error_y="Écart_Type_Déviation", color="Produit",
-                                                 title="Déviation Moyenne / Nominal (%) par Produit", template="plotly_white", labels={"Déviation_Moyenne": "Déviation Moyenne (%)"})
+                            fig_bar_dev = px.bar(
+                                dev_stats, x="Produit", y="Déviation_Moyenne", error_y="Écart_Type_Déviation",
+                                color="Produit", title="Déviation Moyenne / Nominal (%) par Produit",
+                                template="plotly_white", labels={"Déviation_Moyenne": "Déviation Moyenne (%)"}
+                            )
                             fig_bar_dev.update_layout(showlegend=False)
                             st.plotly_chart(fig_bar_dev, use_container_width=True)
-                        else: st.info("Aucune donnée de déviation valide pour le graphique.")
-                    except Exception as e_dev_bar: logging.error(f"Erreur barre déviation: {e_dev_bar}", exc_info=True); dev_stats = pd.DataFrame()
+                        else:
+                            st.info("Aucune donnée de déviation valide pour le graphique à barres.")
+
+                    except Exception as e_dev_bar:
+                        st.error(f"Erreur lors du calcul des statistiques de déviation: {e_dev_bar}")
+                        logging.error(f"Erreur barre déviation: {e_dev_bar}", exc_info=True)
+                        dev_stats = pd.DataFrame()
 
-                    # --- Radar Chart ---
+                    # --- Radar Chart Amélioré ---
                     st.markdown("##### Radar Chart Comparatif (Global Produit)")
                     num_unique_products = filtered_data["Produit"].nunique()
                     if num_unique_products > 1:
                         try:
+                            # Calculer les métriques agrégées par produit, en ignorant les NaN pour chaque métrique
                             radar_metrics = filtered_data.groupby("Produit", observed=True).agg(
-                                Poids_Moyen=("Poids (g)", "mean"), Poids_Std=("Poids (g)", "std"),
-                                Abs_Dev_Moyenne=("Déviation_%", lambda x: x.abs().mean()), Dev_Std=("Déviation_%", "std")
+                                Poids_Moyen=("Poids (g)", "mean"),
+                                Poids_Std=("Poids (g)", "std"),
+                                # Utiliser la moyenne de la valeur absolue pour la déviation moyenne
+                                Abs_Dev_Moyenne=("Déviation_%", lambda x: x.abs().mean()),
+                                Dev_Std=("Déviation_%", "std")
                             ).reset_index()
-                            categories_map = {"Poids_Moyen": "Précision Poids", "Poids_Std": "Stabilité Poids",
-                                              "Abs_Dev_Moyenne": "Conformité Nominale", "Dev_Std": "Consistance Conformité"}
+
+                            # Définir les catégories pour le radar (avec des noms plus intuitifs)
+                            # Inverse Poids_Std, Abs_Dev_Moyenne, Dev_Std car plus petit = mieux
+                            categories_map = {
+                                "Poids_Moyen": "Précision Poids", # Proche de la cible (si connue) - Ici juste la moyenne
+                                "Poids_Std": "Stabilité Poids",   # Faible std = stable
+                                "Abs_Dev_Moyenne": "Conformité Nominale", # Faible déviation = conforme
+                                "Dev_Std": "Consistance Conformité" # Faible std de déviation = consistant
+                            }
                             categories = list(categories_map.values())
+
+                            # Préparer les données pour la normalisation, gérant les NaN et inversant si nécessaire
                             df_to_normalize = pd.DataFrame(index=radar_metrics.index)
-                            df_to_normalize["Précision Poids"] = radar_metrics["Poids_Moyen"]
-                            df_to_normalize["Stabilité Poids"] = -radar_metrics["Poids_Std"]
-                            df_to_normalize["Conformité Nominale"] = -radar_metrics["Abs_Dev_Moyenne"]
-                            df_to_normalize["Consistance Conformité"] = -radar_metrics["Dev_Std"]
+                            # S'assurer que les colonnes existent avant de les utiliser
+                            if "Poids_Moyen" in radar_metrics.columns: df_to_normalize["Précision Poids"] = radar_metrics["Poids_Moyen"]
+                            if "Poids_Std" in radar_metrics.columns: df_to_normalize["Stabilité Poids"] = -radar_metrics["Poids_Std"] # Négatif car moins = mieux
+                            if "Abs_Dev_Moyenne" in radar_metrics.columns: df_to_normalize["Conformité Nominale"] = -radar_metrics["Abs_Dev_Moyenne"] # Négatif car moins = mieux
+                            if "Dev_Std" in radar_metrics.columns: df_to_normalize["Consistance Conformité"] = -radar_metrics["Dev_Std"] # Négatif car moins = mieux
+
+                            # Remplacer les NaN restants *après* l'inversion (ex: std d'un seul point est NaN)
+                            # On remplace par une valeur qui sera "mauvaise" après normalisation (la minimale de la colonne inversée)
                             for col in df_to_normalize.columns:
-                                if df_to_normalize[col].isnull().any(): df_to_normalize[col].fillna(df_to_normalize[col].min(), inplace=True)
-                            normalized_df = df_to_normalize.apply(lambda x: (x - x.min()) / (x.max() - x.min()) if (x.max() - x.min()) > 1e-9 else 0.5, axis=0)
-                            normalized_df["Produit"] = radar_metrics["Produit"]
-                            fig_radar = go.Figure()
-                            theta_cats = categories + categories[:1]
-                            for i, row in normalized_df.iterrows():
-                                values = row[categories].tolist() + row[categories].tolist()[:1]
-                                fig_radar.add_trace(go.Scatterpolar(r=values, theta=theta_cats, fill='toself', name=row["Produit"]))
-                            fig_radar.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 1])),
-                                                    title="Comparaison Radar Produits (0-1, mieux si proche de 1)", template="plotly_white", legend_title="Produit")
-                            st.plotly_chart(fig_radar, use_container_width=True)
-                        except Exception as e_radar: logging.error(f"Erreur radar chart: {e_radar}", exc_info=True); st.error(f"Erreur radar chart: {e_radar}")
-                    else: st.info("Au moins deux produits nécessaires pour le radar chart.")
-                else: st.warning("Comparaison basée sur la déviation non disponible ('Déviation_%' manquante/vide).")
+                                if df_to_normalize[col].isnull().any():
+                                    min_val = df_to_normalize[col].min() # Le min après inversion est la "pire" performance
+                                    df_to_normalize[col].fillna(min_val, inplace=True)
+
+                            # Normalisation Min-Max (0 à 1, où 1 est le "meilleur")
+                            # Vérifier si df_to_normalize n'est pas vide
+                            if not df_to_normalize.empty:
+                                normalized_df = df_to_normalize.apply(
+                                    lambda x: (x - x.min()) / (x.max() - x.min()) if (x.max() - x.min()) > 1e-9 else 0.5, # Gère division par zéro ou quasi-zéro
+                                    axis=0
+                                )
+                                normalized_df["Produit"] = radar_metrics["Produit"] # Rajouter le produit
+
+                                # Créer la figure Radar
+                                fig_radar = go.Figure()
+                                # S'assurer que les catégories utilisées existent bien dans normalized_df
+                                valid_categories = [cat for cat in categories if cat in normalized_df.columns]
+                                if valid_categories:
+                                    theta_cats = valid_categories + valid_categories[:1] # Pour fermer le polygone
+
+                                    for i, row in normalized_df.iterrows():
+                                        values = row[valid_categories].tolist()
+                                        values += values[:1] # Fermer le polygone
+                                        fig_radar.add_trace(go.Scatterpolar(
+                                            r=values,
+                                            theta=theta_cats,
+                                            fill='toself',
+                                            name=row["Produit"]
+                                        ))
+
+                                    fig_radar.update_layout(
+                                        polar=dict(radialaxis=dict(visible=True, range=[0, 1])),
+                                        title="Comparaison Radar des Produits (Normalisé 0-1, plus proche de 1 = mieux)",
+                                        template="plotly_white",
+                                        legend_title="Produit"
+                                    )
+                                    st.plotly_chart(fig_radar, use_container_width=True)
+                                else:
+                                     st.warning("Impossible de générer le radar: aucune métrique valide calculée.")
+                            else:
+                                st.warning("Impossible de générer le radar: pas de données à normaliser.")
+
+
+                        except Exception as e_radar:
+                            st.error(f"Erreur lors de la génération du radar chart: {e_radar}")
+                            logging.error(f"Erreur radar chart: {e_radar}", exc_info=True)
+
+                    else:
+                        st.info("Au moins deux produits sont nécessaires dans les données filtrées pour générer le radar chart comparatif.")
+                else:
+                    st.warning("Comparaison basée sur la déviation non disponible (colonne 'Déviation_%' manquante ou vide dans les données filtrées).")
+
 
             # --- NOUVELLE TABULATION : Analyse par Produit/DLUO ---
             with tab4:
@@ -647,7 +794,7 @@ elif page == "Analyse des Données":
                         agg_funcs["Déviation_%"] = ["mean", "std"]
 
                     try:
-                        # Group by Produit et DLUO
+                        # Group by Produit et DLUO, en ignorant les lignes où Produit ou DLUO sont NaN
                         prod_dluo_stats = filtered_data.dropna(subset=["Produit", "DLUO"]).groupby(["Produit", "DLUO"], observed=True).agg(agg_funcs).reset_index()
 
                         # Aplatir les multi-index des colonnes
@@ -655,6 +802,8 @@ elif page == "Analyse des Données":
 
                         # Renommer les colonnes pour plus de clarté
                         prod_dluo_stats.rename(columns={
+                            "Produit_": "Produit", # Correction si le nom de la colonne devient Produit_
+                            "DLUO_": "DLUO", # Correction si le nom de la colonne devient DLUO_
                             "Poids (g)_mean": "Poids Moyen (g)",
                             "Poids (g)_std": "Poids Std Dev (g)",
                             "Poids (g)_min": "Poids Min (g)",
@@ -670,32 +819,43 @@ elif page == "Analyse des Données":
                             # Optionnel : Graphique comparatif des DLUO pour un produit sélectionné
                             st.markdown("---")
                             st.markdown("##### Comparaison des DLUO pour un Produit")
-                            sel_prod_for_dluo_comp = st.selectbox(
-                                "Choisir un produit pour comparer ses DLUO",
-                                options=sorted(prod_dluo_stats["Produit"].unique()),
-                                key="dluo_comp_select"
-                            )
-                            if sel_prod_for_dluo_comp:
-                                dluo_comp_data = prod_dluo_stats[prod_dluo_stats["Produit"] == sel_prod_for_dluo_comp]
-                                if not dluo_comp_data.empty:
-                                    # Choix de la métrique à comparer
-                                    available_metrics = [col for col in dluo_comp_data.columns if col not in ["Produit", "DLUO"]]
-                                    metric_to_compare = st.selectbox(
-                                        "Choisir la métrique à comparer",
-                                        options=available_metrics,
-                                        index=available_metrics.index("Poids Moyen (g)") if "Poids Moyen (g)" in available_metrics else 0,
-                                        key="dluo_metric_select"
-                                    )
-                                    if metric_to_compare:
-                                        fig_dluo_comp = px.bar(
-                                            dluo_comp_data, x="DLUO", y=metric_to_compare,
-                                            title=f"{metric_to_compare} par DLUO pour {sel_prod_for_dluo_comp}",
-                                            template="plotly_white", color="DLUO"
-                                        )
-                                        fig_dluo_comp.update_layout(showlegend=False)
-                                        st.plotly_chart(fig_dluo_comp, use_container_width=True)
-                                else:
-                                    st.info(f"Aucune donnée de DLUO trouvée pour le produit {sel_prod_for_dluo_comp}.")
+                            # S'assurer qu'il y a des produits à sélectionner
+                            unique_prods_in_stats = sorted(prod_dluo_stats["Produit"].unique())
+                            if unique_prods_in_stats:
+                                sel_prod_for_dluo_comp = st.selectbox(
+                                    "Choisir un produit pour comparer ses DLUO",
+                                    options=unique_prods_in_stats,
+                                    key="dluo_comp_select"
+                                )
+                                if sel_prod_for_dluo_comp:
+                                    dluo_comp_data = prod_dluo_stats[prod_dluo_stats["Produit"] == sel_prod_for_dluo_comp]
+                                    if not dluo_comp_data.empty and dluo_comp_data["DLUO"].nunique() > 1: # Comparaison utile si > 1 DLUO
+                                        # Choix de la métrique à comparer
+                                        available_metrics = [col for col in dluo_comp_data.columns if col not in ["Produit", "DLUO"]]
+                                        if available_metrics:
+                                            metric_to_compare = st.selectbox(
+                                                "Choisir la métrique à comparer",
+                                                options=available_metrics,
+                                                index=available_metrics.index("Poids Moyen (g)") if "Poids Moyen (g)" in available_metrics else 0,
+                                                key="dluo_metric_select"
+                                            )
+                                            if metric_to_compare:
+                                                fig_dluo_comp = px.bar(
+                                                    dluo_comp_data, x="DLUO", y=metric_to_compare,
+                                                    title=f"{metric_to_compare} par DLUO pour {sel_prod_for_dluo_comp}",
+                                                    template="plotly_white", color="DLUO"
+                                                )
+                                                fig_dluo_comp.update_layout(showlegend=False)
+                                                st.plotly_chart(fig_dluo_comp, use_container_width=True)
+                                        else:
+                                            st.info("Aucune métrique numérique disponible pour la comparaison des DLUO.")
+                                    elif not dluo_comp_data.empty:
+                                         st.info(f"Une seule DLUO trouvée pour le produit {sel_prod_for_dluo_comp}, comparaison non applicable.")
+                                    else:
+                                        # Cas où le produit sélectionné n'a pas de données DLUO (ne devrait pas arriver avec le filtre précédent)
+                                        st.info(f"Aucune donnée de DLUO trouvée pour le produit {sel_prod_for_dluo_comp}.")
+                            else:
+                                 st.info("Aucun produit avec DLUO disponible pour la comparaison.")
 
                         else:
                              st.info("Aucune statistique à afficher après regroupement par Produit/DLUO.")
@@ -710,11 +870,13 @@ elif page == "Analyse des Données":
 
             # --- Affichage Table Données Filtrées ---
             st.markdown('<div class="sub-header">📋 Données Filtrées Détaillées</div>', unsafe_allow_html=True)
+            # Affiche le DataFrame sans la colonne 'Date' ajoutée techniquement
             st.dataframe(filtered_data.drop(columns=["Date"], errors='ignore'), use_container_width=True)
 
             # --- Téléchargement Données Filtrées ---
             st.markdown('<div class="sub-header">💾 Téléchargement des Données Filtrées</div>', unsafe_allow_html=True)
             col_dl_hist1, col_dl_hist2 = st.columns(2)
+            # Exclut également la colonne Date du téléchargement
             df_to_download = filtered_data.drop(columns=["Date"], errors='ignore')
             with col_dl_hist1:
                 csv_link_hist = get_download_link(df_to_download, "donnees_filtrees.csv", "📥 Télécharger en CSV")
@@ -723,14 +885,15 @@ elif page == "Analyse des Données":
                 excel_link_hist = get_download_link(df_to_download, "donnees_filtrees.xlsx", "📥 Télécharger en Excel")
                 st.markdown(excel_link_hist, unsafe_allow_html=True)
 
-        elif not st.session_state.app_data["all_data"].empty:
+        elif not st.session_state.app_data["all_data"].empty: # Si on a des données globales mais rien après filtrage
             st.warning("Aucune donnée ne correspond aux filtres sélectionnés.")
+        # Le cas où all_data est vide est géré au début de la page
 
 # --- Pied de Page ---
 st.markdown("---")
 st.markdown("""
 <div style="text-align: center; margin-top: 20px; color: #888; font-size: 0.9em;">
-    <p>⚖️ Extracteur & Analyseur de Rapports de Pesées | Version 1.3 (ID Batch)</p>
+    <p>⚖️ Extracteur & Analyseur de Rapports de Pesées | Version 1.4 (ID Batch)</p>
     <p>Développé avec Streamlit & Plotly</p>
 </div>
 """, unsafe_allow_html=True)