Update app.py

app.py

@@ -9,9 +9,9 @@ import requests
 import plotly.express as px
 import streamlit as st
 from tenacity import retry, stop_after_attempt, wait_exponential
-import time
+# import time # Non utilisé directement, peut être enlevé si non requis par une dépendance cachée
 from collections import defaultdict
-import hashlib
+# import hashlib # Non utilisé directement
 
 # Configuration Streamlit
 st.set_page_config(page_title="Pesticide Data Explorer - Optimized", page_icon="🌿", layout="wide")
@@ -34,7 +34,7 @@ class PesticideDataFetcher:
     HEADERS = {
         "Content-Type": "application/json",
         "Cache-Control": "no-cache",
-        "User-Agent": "Mozilla/5.0"
+        "User-Agent": "Mozilla/5.0" # Bon réflexe d'avoir un User-Agent
     }
 
     def __init__(self):
@@ -49,39 +49,32 @@ class PesticideDataFetcher:
         
         try:
             self.api_calls += 1
-            logger.info(f"Téléchargement depuis {endpoint} (appel API #{self.api_calls})")
+            logger.info(f"Téléchargement depuis {url} avec params {params} (appel API #{self.api_calls})")
             
-            response = self.session.get(url, params=params, timeout=120)  # Timeout plus long pour les gros fichiers
+            response = self.session.get(url, params=params, timeout=120)
             response.raise_for_status()
             
             content_type = response.headers.get('Content-Type', '')
             
-            # Si c'est du JSON
             if 'json' in content_type or params.get('format') == 'json':
                 return response.json()
-            
-            # Si c'est du CSV
             elif 'csv' in content_type or params.get('format') == 'csv':
                 return response.text
-            
-            # Si c'est un fichier ZIP (possible pour les gros datasets)
             elif 'zip' in content_type:
                 with zipfile.ZipFile(io.BytesIO(response.content)) as zf:
-                    # Prendre le premier fichier du ZIP
                     filename = zf.namelist()[0]
                     with zf.open(filename) as f:
                         content = f.read().decode('utf-8')
                         if filename.endswith('.json'):
                             return json.loads(content)
-                        else:
+                        else: # Supposons CSV si ce n'est pas JSON dans un ZIP
                             return content
-            
             else:
-                # Par défaut, retourner le contenu brut
+                logger.warning(f"Type de contenu non géré explicitement: {content_type}. Retour du texte brut.")
                 return response.text
                 
         except requests.RequestException as e:
-            logger.error(f"Erreur lors du téléchargement {endpoint}: {e}")
+            logger.error(f"Erreur lors du téléchargement {url}: {e}")
             if hasattr(e, 'response') and e.response is not None:
                 logger.error(f"Status code: {e.response.status_code}")
                 logger.error(f"Response: {e.response.text[:500]}...")
@@ -97,87 +90,75 @@ class PesticideDataFetcher:
             'api-version': 'v2.0'
         }
         
-        # Première requête pour voir s'il y a pagination
-        self.api_calls += 1
-        response = self.session.get(url, params=params, timeout=30)
-        response.raise_for_status()
-        data = response.json()
-        
-        if 'value' in data:
-            all_products.extend(data['value'])
+        current_url = url # Pour gérer le nextLink
+        page_count = 0
+
+        while current_url and self.api_calls < 20 : # Limite de sécurité augmentée légèrement si besoin
+            self.api_calls += 1
+            page_count += 1
+            logger.info(f"Récupération produits - Page {page_count} depuis {current_url} (appel API global #{self.api_calls})")
             
-            # Gérer la pagination avec nextLink si présent
-            while 'nextLink' in data and self.api_calls < 10:  # Limite de sécurité
-                self.api_calls += 1
-                response = self.session.get(data['nextLink'], timeout=30)
-                response.raise_for_status()
-                data = response.json()
-                if 'value' in data:
-                    all_products.extend(data['value'])
-        else:
-            # Pas de structure 'value', c'est directement la liste
-            all_products = data if isinstance(data, list) else [data]
-        
-        logger.info(f"Récupéré {len(all_products)} produits en {self.api_calls} appels")
+            # Utiliser params uniquement pour la première requête
+            current_params = params if page_count == 1 else {'api-version': 'v2.0', 'language': language}
+            
+            response = self.session.get(current_url, params=current_params if page_count == 1 else None, timeout=30) # Params seulement pour la 1ère
+            response.raise_for_status()
+            data = response.json()
+            
+            if 'value' in data:
+                all_products.extend(data['value'])
+                current_url = data.get('nextLink') # Mise à jour de l'URL pour la prochaine itération
+            else: # Cas où la réponse n'a pas de 'value' (par ex. si la première page est la seule)
+                all_products = data if isinstance(data, list) else [data]
+                current_url = None # Pas de pagination
+        
+        logger.info(f"Récupéré {len(all_products)} produits en {page_count} appels paginés (total API: {self.api_calls})")
         return all_products
 
 @st.cache_data(ttl=86400)  # Cache de 24h pour les données bulk
 def download_all_data() -> Dict[str, Any]:
     """Télécharge toutes les données en utilisant les endpoints optimisés"""
-    
     fetcher = PesticideDataFetcher()
     results = {}
     
     with st.spinner("Téléchargement des données complètes..."):
-        
-        # 1. Télécharger toutes les substances actives
         st.text("📥 Téléchargement des substances actives...")
         substances_data = fetcher.download_data(
             "/active_substances/download",
             {"format": "json", "api-version": "v2.0"}
         )
-        
         if substances_data:
-            # Convertir en dictionnaire pour accès rapide
-            if isinstance(substances_data, dict) and 'value' in substances_data:
-                substances_list = substances_data['value']
-            else:
-                substances_list = substances_data if isinstance(substances_data, list) else []
-            
+            substances_list = substances_data.get('value', []) if isinstance(substances_data, dict) else (substances_data if isinstance(substances_data, list) else [])
             results['substances'] = {
                 item['substance_id']: item['substance_name']
-                for item in substances_list
-                if item.get('substance_id') and item.get('substance_name')
+                for item in substances_list if item.get('substance_id') and item.get('substance_name')
             }
             logger.info(f"✓ {len(results['substances'])} substances téléchargées")
-        
-        # 2. Télécharger toutes les LMR
-        st.text("📥 Téléchargement de toutes les LMR (peut prendre quelques secondes)...")
+        else:
+            results['substances'] = {}
+            logger.warning("Aucune donnée de substance active n'a été téléchargée.")
+
+        st.text("📥 Téléchargement de tous les enregistrements LMR...")
         mrls_data = fetcher.download_data(
             "/pesticide_residues_mrls/download",
             {"format": "json", "language": "FR", "api-version": "v2.0"}
         )
-        
         if mrls_data:
-            if isinstance(mrls_data, dict) and 'value' in mrls_data:
-                results['mrls'] = mrls_data['value']
-            else:
-                results['mrls'] = mrls_data if isinstance(mrls_data, list) else []
-            logger.info(f"✓ {len(results['mrls'])} LMR téléchargées")
-        
-        # 3. Récupérer tous les produits (avec pagination si nécessaire)
+            results['mrls'] = mrls_data.get('value', []) if isinstance(mrls_data, dict) else (mrls_data if isinstance(mrls_data, list) else [])
+            logger.info(f"✓ {len(results['mrls'])} enregistrements LMR téléchargés")
+        else:
+            results['mrls'] = []
+            logger.warning("Aucune donnée LMR n'a été téléchargée.")
+
         st.text("📥 Récupération des produits...")
         products_list = fetcher.get_products_paginated(language='FR')
-        
         results['products'] = products_list
         results['product_dict'] = {
             p['product_id']: p['product_name']
-            for p in products_list
-            if p.get('product_id') and p.get('product_name')
+            for p in products_list if p.get('product_id') and p.get('product_name')
         }
         logger.info(f"✓ {len(results['products'])} produits récupérés")
         
-        # 4. Statistiques
         results['stats'] = {
             'api_calls': fetcher.api_calls,
             'substances_count': len(results.get('substances', {})),
@@ -185,359 +166,287 @@ def download_all_data() -> Dict[str, Any]:
             'products_count': len(results.get('products', [])),
             'download_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
         }
-        
-        st.success(f"✅ Toutes les données téléchargées en seulement {fetcher.api_calls} appels API!")
-        
+        st.success(f"✅ Toutes les données téléchargées en {fetcher.api_calls} appels API!")
     return results
 
 class PesticideInterface:
     def __init__(self):
-        # Charger toutes les données une seule fois
         self.data = download_all_data()
-        
-        # Créer des index pour des recherches rapides
         self._create_indexes()
     
     def _create_indexes(self):
-        """Crée des index pour optimiser les recherches"""
-        # Index des LMR par product_id
         self.mrls_by_product = defaultdict(list)
         for mrl in self.data.get('mrls', []):
             if mrl.get('product_id'):
                 self.mrls_by_product[mrl['product_id']].append(mrl)
         
-        # Index des produits par nom
         self.product_choices = {
             p['product_name']: p['product_id'] 
-            for p in self.data.get('products', [])
-            if p.get('product_name') and p.get('product_id')
+            for p in self.data.get('products', []) if p.get('product_name') and p.get('product_id')
         }
-        
-        logger.info(f"Index créés: {len(self.mrls_by_product)} produits avec LMR")
+        logger.info(f"Index créés: {len(self.mrls_by_product)} produits avec des LMR indexées.")
 
     def get_product_details(self, product_names: List[str], future_only: bool = False) -> pd.DataFrame:
-        """Récupère les détails des produits depuis les données en cache"""
-        
-        # Convertir les noms en IDs
-        product_ids = [self.product_choices[name] for name in product_names]
+        product_ids = [self.product_choices[name] for name in product_names if name in self.product_choices]
         
-        # Récupérer les LMR depuis l'index
         all_mrls = []
         for product_id in product_ids:
-            mrls = self.mrls_by_product.get(product_id, [])
-            all_mrls.extend(mrls)
+            all_mrls.extend(self.mrls_by_product.get(product_id, []))
         
         if not all_mrls:
-            st.info("Aucune donnée de LMR trouvée pour les produits sélectionnés.")
+            # st.info("Aucune donnée de LMR trouvée pour les produits sélectionnés.") # Déplacé à create_interface
             return pd.DataFrame()
         
-        # Convertir en DataFrame
         df = pd.DataFrame(all_mrls)
         
-        # Enrichir avec les données
         df["Substance"] = df["pesticide_residue_id"].map(self.data.get('substances', {})).fillna("Inconnu")
         df["Produit"] = df["product_id"].map(self.data.get('product_dict', {})).fillna("Inconnu")
         
-        # Ajouter le lien vers le règlement
-        if 'regulation_url' in df.columns:
-            df["Règlement"] = df.apply(
-                lambda x: f'<a href="{x["regulation_url"]}" target="_blank">{x.get("regulation_number", "N/A")}</a>'
-                if pd.notna(x.get("regulation_url")) else x.get("regulation_number", "N/A"),
-                axis=1
-            )
-        else:
-            df["Règlement"] = df.get("regulation_number", "N/A")
+        # Création du lien Markdown pour le règlement
+        def create_regulation_link(row):
+            url = row.get("regulation_url")
+            number = row.get("regulation_number", "N/A")
+            if pd.notna(url) and str(url).strip(): # S'assurer que l'URL est valide
+                return f"[{number}]({url})"
+            return number
+
+        df["Lien Règlement"] = df.apply(create_regulation_link, axis=1)
         
-        # Conversion des dates
         df["Date d'application"] = pd.to_datetime(df.get("entry_into_force_date"), errors="coerce")
         
-        # Filtrer pour les 6 prochains mois si demandé
         if future_only:
-            now = datetime.now()
+            now = pd.Timestamp.now(tz='UTC') # Utiliser un timestamp avec fuseau horaire pour la comparaison
             future_date = now + timedelta(days=180)
+            # S'assurer que "Date d'application" est tz-aware ou tz-naive comme `now`
+            if df["Date d'application"].dt.tz is None:
+                 df["Date d'application"] = df["Date d'application"].dt.tz_localize('UTC')
+
             df = df[
+                (df["Date d'application"].notna()) &
                 (df["Date d'application"] > now) &
                 (df["Date d'application"] <= future_date)
             ]
-            
             if df.empty:
-                st.info(f"🔍 Aucun changement de LMR prévu dans les 6 prochains mois.")
+                # st.info(f"🔍 Aucun changement de LMR prévu dans les 6 prochains mois.") # Déplacé
                 return pd.DataFrame()
         
-        # Préparer le DataFrame final
-        # C'est ici que les NaNs peuvent apparaître si mrl_value n'est pas numérique
         df["Valeur LMR"] = pd.to_numeric(df.get("mrl_value"), errors='coerce')
         
-        # Sélection des colonnes finales
-        columns_to_keep = ["Produit", "Substance", "Valeur LMR"]
-        if "Date d'application" in df.columns:
-            columns_to_keep.append("Date d'application")
-        if "Règlement" in df.columns:
-            columns_to_keep.append("Règlement")
+        columns_to_keep = ["Produit", "Substance", "Valeur LMR", "Date d'application", "Lien Règlement"]
         
-        # S'assurer que toutes les colonnes à garder existent avant de les sélectionner
-        # Utilisez .copy() pour éviter SettingWithCopyWarning
-        df = df[[col for col in columns_to_keep if col in df.columns]].copy() 
+        # S'assurer que les colonnes existent avant la sélection pour éviter les KeyErrors
+        final_columns = [col for col in columns_to_keep if col in df.columns]
+        df = df[final_columns].copy()
         
-        df = df.sort_values(
-            ["Produit", "Date d'application"] if "Date d'application" in columns_to_keep else ["Produit"],
-            ascending=[True, False] if "Date d'application" in columns_to_keep else [True]
-        )
+        sort_columns = ["Produit"]
+        ascending_order = [True]
+        if "Date d'application" in df.columns:
+            sort_columns.append("Date d'application")
+            ascending_order.append(False) # Plus récent en premier
+        
+        df = df.sort_values(by=sort_columns, ascending=ascending_order)
         
         return df
 
     def create_interface(self):
         st.title("🌿 EU Pesticides Database Explorer - Version Optimisée")
         
-        # Afficher les statistiques
+        stats = self.data.get('stats', {})
         col1, col2, col3, col4 = st.columns(4)
         with col1:
-            st.metric("📦 Produits", f"{self.data['stats']['products_count']:,}")
+            st.metric("📦 Produits", f"{stats.get('products_count', 0):,}")
         with col2:
-            st.metric("🧪 Substances", f"{self.data['stats']['substances_count']:,}")
+            st.metric("🧪 Substances", f"{stats.get('substances_count', 0):,}")
         with col3:
-            st.metric("📊 LMR totales", f"{self.data['stats']['mrls_count']:,}")
+            st.metric("📊 Enregistrements LMR", f"{stats.get('mrls_count', 0):,}") # Nom modifié
         with col4:
-            st.metric("🚀 Appels API", self.data['stats']['api_calls'])
-        
-        st.success(f"✨ Toutes les données ont été téléchargées en {self.data['stats']['api_calls']} appels API seulement!")
+            st.metric("🚀 Appels API", stats.get('api_calls', 0))
         
+        st.success(f"✨ Données téléchargées ({stats.get('download_time', 'N/A')}) en {stats.get('api_calls',0)} appels API.")
         st.markdown("---")
         
-        # Interface de sélection
-        col1, col2 = st.columns([3, 1])
-        with col1:
-            # Recherche avec autocomplétion
+        col1_select, col2_select = st.columns([3, 1])
+        with col1_select:
             product_names = st.multiselect(
                 "🔍 Sélectionnez un ou plusieurs produits",
                 options=sorted(list(self.product_choices.keys())),
                 help="Commencez à taper pour filtrer les produits"
             )
-        
-        with col2:
+        with col2_select:
             future_only = st.checkbox(
-                "📅 6 prochains mois",
+                "📅 Changements prévus (6 prochains mois)",
                 value=False,
-                help="Afficher uniquement les changements prévus"
+                help="Afficher uniquement les changements de LMR prévus dans les 6 prochains mois"
             )
         
-        # Affichage des résultats
         if product_names:
-            df = self.get_product_details(product_names, future_only)
+            df_results = self.get_product_details(product_names, future_only)
             
-            if not df.empty:
+            if df_results.empty:
+                if future_only:
+                    st.info(f"🔍 Aucun changement de LMR prévu dans les 6 prochains mois pour les produits sélectionnés.")
+                else:
+                    st.info("Aucune donnée de LMR trouvée pour les produits sélectionnés avec les filtres actuels.")
+            else:
                 st.markdown("### 📊 Résultats")
-                
-                # Statistiques rapides
-                # Filtrer les NaNs pour les calculs de statistiques
-                df_numeric_mrl = df[df["Valeur LMR"].notna()]
+                df_numeric_mrl = df_results[df_results["Valeur LMR"].notna()]
 
-                col1, col2, col3 = st.columns(3)
-                with col1:
-                    st.metric("Entrées trouvées", len(df))
-                with col2:
+                res_col1, res_col2 = st.columns(2) # Suppression de la LMR moyenne
+                with res_col1:
+                    st.metric("Lignes trouvées", len(df_results))
+                with res_col2:
                     st.metric("Substances uniques", df_numeric_mrl["Substance"].nunique() if not df_numeric_mrl.empty else 0)
-                with col3:
-                    if "Valeur LMR" in df_numeric_mrl.columns:
-                        avg_mrl = df_numeric_mrl["Valeur LMR"].mean()
-                        st.metric("LMR moyenne", f"{avg_mrl:.3f} mg/kg" if not pd.isna(avg_mrl) else "N/A")
                 
-                # Options d'affichage
                 with st.expander("⚙️ Options d'affichage"):
-                    show_zero = st.checkbox("Afficher les LMR à 0.01 mg/kg", value=True)
-                    sort_by = st.selectbox(
-                        "Trier par",
-                        ["Produit", "Substance", "Valeur LMR", "Date d'application"]
-                        if "Date d'application" in df.columns else ["Produit", "Substance", "Valeur LMR"]
-                    )
-                    sort_order = st.radio("Ordre", ["Croissant", "Décroissant"], horizontal=True)
-                
-                # Appliquer les filtres
-                if not show_zero and "Valeur LMR" in df.columns:
-                    df = df[df["Valeur LMR"] != 0.01]
+                    show_low_mrl = st.checkbox("Inclure LMR < 0.01 mg/kg", value=True) # LMR à 0.01 (souvent limite de détection)
+                    
+                    sortable_cols = [col for col in ["Produit", "Substance", "Valeur LMR", "Date d'application"] if col in df_results.columns]
+                    if sortable_cols:
+                        sort_by = st.selectbox("Trier par", sortable_cols)
+                        sort_order = st.radio("Ordre", ["Croissant", "Décroissant"], horizontal=True, index=1 if sort_by == "Date d'application" else 0) # Desc pour date
+                    else:
+                        sort_by = None
+
+                if not show_low_mrl and "Valeur LMR" in df_results.columns:
+                    df_results_filtered = df_results[df_results["Valeur LMR"] >= 0.01].copy()
+                else:
+                    df_results_filtered = df_results.copy()
                 
-                if sort_by in df.columns:
-                    df = df.sort_values(sort_by, ascending=(sort_order == "Croissant"))
+                if sort_by and sort_by in df_results_filtered.columns:
+                    df_results_filtered = df_results_filtered.sort_values(sort_by, ascending=(sort_order == "Croissant"))
                 
-                # Afficher le tableau
                 st.dataframe(
-                    df,
+                    df_results_filtered,
                     use_container_width=True,
                     hide_index=True,
                     column_config={
                         "Valeur LMR": st.column_config.NumberColumn(
-                            "Valeur LMR (mg/kg)",
-                            format="%.3f",
-                            help="Limite Maximale de Résidus"
+                            "Valeur LMR (mg/kg)", format="%.3f", help="Limite Maximale de Résidus"
                         ),
                         "Date d'application": st.column_config.DateColumn(
-                            "Date d'application",
-                            format="DD/MM/YYYY"
+                            "Date d'application", format="DD/MM/YYYY"
                         ),
-                        "Règlement": st.column_config.LinkColumn(
-                            "Règlement",
-                            help="Cliquez pour voir le règlement officiel"
-                        )
+                        # "Lien Règlement" sera rendu par défaut car c'est du Markdown. Aucune config spécifique LinkColumn nécessaire.
                     }
                 )
                 
-                # Visualisations
-                # Condition pour s'assurer qu'il y a assez de données pour visualiser
-                if len(df) > 1:
-                    self.create_visualizations(df)
-                else:
-                    st.info("Sélectionnez plus de données (au moins 2 entrées) pour générer des visualisations.")
+                if len(df_results_filtered) > 1:
+                    self.create_visualizations(df_results_filtered)
                 
-                # Export
-                csv = df.to_csv(index=False)
+                csv = df_results_filtered.to_csv(index=False).encode('utf-8')
                 st.download_button(
-                    label="📥 Télécharger (CSV)",
+                    label="📥 Télécharger les résultats (CSV)",
                     data=csv,
-                    file_name=f"pesticides_lmr_{datetime.now().strftime('%Y%m%d')}.csv",
+                    file_name=f"pesticides_lmr_{'_'.join(product_names)}_{datetime.now().strftime('%Y%m%d')}.csv",
                     mime="text/csv"
                 )
         else:
-            # Afficher quelques statistiques globales
-            st.info("👆 Sélectionnez des produits pour voir leurs LMR")
-            
-            with st.expander("📊 Statistiques globales"):
-                # Top 10 des produits avec le plus de LMR
-                product_mrl_count = {
-                    pid: len(mrls) 
-                    for pid, mrls in self.mrls_by_product.items()
+            st.info("👆 Sélectionnez des produits pour afficher leurs Limites Maximales de Résidus (LMR).")
+            with st.expander("📊 Statistiques globales sur les données disponibles"):
+                product_mrl_counts = {
+                    pid: len(mrls) for pid, mrls in self.mrls_by_product.items()
                 }
-                top_products = sorted(
-                    product_mrl_count.items(), 
-                    key=lambda x: x[1], 
-                    reverse=True
-                )[:10]
+                top_products_ids = sorted(product_mrl_counts.items(), key=lambda x: x[1], reverse=True)[:10]
                 
-                if top_products:
-                    st.markdown("**Top 10 des produits avec le plus de LMR:**")
-                    for pid, count in top_products:
+                if top_products_ids:
+                    st.markdown("**Top 10 des produits par nombre d'enregistrements LMR :**")
+                    for pid, count in top_products_ids:
                         product_name = self.data['product_dict'].get(pid, f"ID: {pid}")
-                        st.write(f"- {product_name}: {count} LMR")
+                        st.write(f"- {product_name}: {count} enregistrements")
 
     def create_visualizations(self, df: pd.DataFrame):
-        """Crée des visualisations interactives"""
-        
-        tabs = st.tabs(["📈 Évolution temporelle", "📊 Distribution", "🏆 Top substances"])
-        
-        # Crée un DataFrame filtré pour les visualisations,
-        # en s'assurant que 'Valeur LMR' n'est pas NaN.
-        # Cela résout le problème de l'erreur 'size' et d'autres opérations numériques.
+        tabs = st.tabs(["📈 Évolution temporelle des LMR", "📊 Distribution des LMR", "🏆 Top substances"])
         plot_df = df[df["Valeur LMR"].notna()].copy()
 
         if plot_df.empty:
-            st.info("Pas de données valides pour la visualisation après filtrage (valeurs LMR manquantes ou non numériques).")
+            st.info("Pas de données numériques de LMR valides pour la visualisation.")
             return
         
         with tabs[0]:
-            # Filtrer davantage pour les données temporelles si nécessaire
             if "Date d'application" in plot_df.columns and plot_df["Date d'application"].notna().any():
                 temp_plot_df = plot_df[plot_df["Date d'application"].notna()]
                 if not temp_plot_df.empty:
                     fig = px.scatter(
-                        temp_plot_df,
-                        x="Date d'application",
-                        y="Valeur LMR",
-                        color="Substance",
-                        size="Valeur LMR", # 'Valeur LMR' est maintenant garantie sans NaNs
-                        hover_data=["Produit", "Valeur LMR", "Substance", "Règlement"], # Plus de détails au survol
-                        title="Évolution des LMR dans le temps",
-                        log_y=True
+                        temp_plot_df, x="Date d'application", y="Valeur LMR",
+                        color="Substance", size="Valeur LMR", 
+                        hover_data=["Produit", "Valeur LMR", "Substance", "Lien Règlement"],
+                        title="Évolution des LMR dans le temps (échelle log.)", log_y=True
                     )
                     st.plotly_chart(fig, use_container_width=True)
                 else:
-                    st.info("Pas de données temporelles valides disponibles pour cette visualisation après filtrage.")
+                    st.info("Pas de données temporelles valides après filtrage.")
             else:
-                st.info("Pas de données temporelles disponibles pour cette visualisation.")
+                st.info("Données de date d'application non disponibles pour cette visualisation.")
         
         with tabs[1]:
-            # Histogramme des valeurs LMR
-            fig = px.histogram(
-                plot_df, # Utiliser le plot_df déjà filtré
-                x="Valeur LMR",
-                nbins=50,
-                title="Distribution des valeurs LMR",
-                log_x=True,
-                labels={"count": "Nombre d'occurrences"}
+            fig_hist = px.histogram(
+                plot_df, x="Valeur LMR", nbins=50, title="Distribution des valeurs LMR (échelle log.)",
+                log_x=True, labels={"count": "Nombre d'occurrences"}
             )
-            st.plotly_chart(fig, use_container_width=True)
+            st.plotly_chart(fig_hist, use_container_width=True)
             
-            # Box plot par produit si plusieurs produits
             if plot_df["Produit"].nunique() > 1:
-                fig2 = px.box(
-                    plot_df, # Utiliser le plot_df déjà filtré
-                    x="Produit",
-                    y="Valeur LMR",
-                    title="Distribution des LMR par produit",
-                    log_y=True
+                fig_box = px.box(
+                    plot_df, x="Produit", y="Valeur LMR",
+                    title="Distribution des LMR par produit (échelle log.)", log_y=True
                 )
-                st.plotly_chart(fig2, use_container_width=True)
+                st.plotly_chart(fig_box, use_container_width=True)
         
         with tabs[2]:
-            # Top substances par valeur maximale
-            # La colonne 'Valeur LMR' est déjà sans NaN dans plot_df
-            top_substances = (
-                plot_df.groupby("Substance")["Valeur LMR"]
-                .agg(['max', 'count', 'mean'])
-                .sort_values('max', ascending=False)
-                .head(15)
-            )
-            
-            if not top_substances.empty:
-                fig = px.bar(
-                    x=top_substances['max'].values,
-                    y=top_substances.index,
-                    orientation='h',
-                    title="Top 15 des substances par LMR maximale",
-                    labels={'x': 'LMR maximale (mg/kg)', 'y': 'Substance'},
-                    hover_data={
-                        'Occurrences': top_substances['count'].values,
-                        'Moyenne': top_substances['mean'].round(3).values
-                    }
+            if not plot_df.empty:
+                top_substances = (
+                    plot_df.groupby("Substance")["Valeur LMR"]
+                    .agg(['max', 'count', 'mean'])
+                    .sort_values('max', ascending=False).head(15).reset_index()
                 )
-                st.plotly_chart(fig, use_container_width=True)
+                if not top_substances.empty:
+                    fig_bar = px.bar(
+                        top_substances, y="Substance", x='max', orientation='h',
+                        title="Top 15 substances par LMR max.",
+                        labels={'max': 'LMR maximale (mg/kg)', 'Substance': 'Substance'},
+                        hover_data={'count': True, 'mean': ':.3f'}
+                    )
+                    fig_bar.update_layout(yaxis={'categoryorder':'total ascending'})
+                    st.plotly_chart(fig_bar, use_container_width=True)
+                else:
+                    st.info("Pas assez de données pour le classement des substances.")
             else:
-                st.info("Pas assez de données pour afficher le Top substances.")
+                st.info("Pas de données pour le classement des substances.")
+
 
 def main():
-    # Configuration de la sidebar
     with st.sidebar:
         st.markdown("## 🌿 EU Pesticides Explorer")
         st.markdown("### Version Ultra-Optimisée")
-        
         st.markdown("""
-        Cette version utilise les **endpoints de téléchargement bulk** 
-        pour récupérer toutes les données en seulement **3-4 appels API** !
-        
-        **Avantages :**
-        - ✅ Pas de limitation à 100 appels
-        - ✅ Accès à TOUTES les données
-        - ✅ Performance maximale
-        - ✅ Cache de 24h
-        
-        **Données disponibles :**
-        - Tous les produits alimentaires
-        - Toutes les substances actives  
-        - Toutes les LMR (>100,000 entrées)
+        Utilise les **endpoints de téléchargement bulk** pour une récupération rapide des données.
+        - Accès à toutes les données LMR, substances et produits.
+        - Cache de 24h pour optimiser les chargements ultérieurs.
         """)
-        
-        if st.button("🔄 Forcer le rechargement des données"):
+        if st.button("🔄 Forcer le rechargement des données", key="force_reload"):
             st.cache_data.clear()
             st.rerun()
         
         st.markdown("---")
-        
-        # Afficher l'heure du dernier téléchargement
-        data = download_all_data()
-        if 'download_time' in data.get('stats', {}):
-            st.caption(f"Dernière mise à jour : {data['stats']['download_time']}")
+        # Essayer d'accéder aux stats pour afficher l'heure sans tout retélécharger si déjà en cache
+        # Cela nécessite que download_all_data soit appelé au moins une fois.
+        # Pour éviter un appel prématuré, on peut le mettre dans l'interface principale.
+        # Ou, si on veut l'heure ici, il faut appeler download_all_data ici.
+        # Le plus simple est de laisser PesticideInterface gérer le premier appel.
+        # On pourrait passer une référence aux stats ici après l'init de PesticideInterface
+        # if 'interface' in st.session_state:
+        #     st.caption(f"Dernière màj: {st.session_state.interface.data['stats']['download_time']}")
+
+    if 'interface' not in st.session_state:
+        st.session_state.interface = PesticideInterface()
     
-    # Interface principale
-    interface = PesticideInterface()
-    interface.create_interface()
+    st.session_state.interface.create_interface()
+
+    # Affichage de l'heure de màj dans la sidebar après initialisation
+    # Cela sera exécuté à chaque rerun, donc l'heure sera toujours à jour si les données sont rechargées.
+    if hasattr(st.session_state.interface, 'data') and 'stats' in st.session_state.interface.data:
+         st.sidebar.caption(f"Données chargées à: {st.session_state.interface.data['stats']['download_time']}")
+
 
 if __name__ == "__main__":
     main()