Update app.py

app.py

@@ -1,11 +1,13 @@
 import logging
 from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
 import pandas as pd
 import requests
-import streamlit as st
 import plotly.express as px
+import streamlit as st
+from tenacity import retry, stop_after_attempt, wait_exponential
+from concurrent.futures import ThreadPoolExecutor
 import time
-import json
 
 # Configuration Streamlit
 st.set_page_config(page_title="Pesticide Data Explorer", page_icon="🌿", layout="wide")
@@ -18,319 +20,585 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Fonction simple pour récupérer les données avec un délai pour éviter les erreurs de taux
-def get_api_data(url, headers=None, params=None):
-    """Fonction simple pour récupérer les données API avec gestion d'erreur basique"""
-    max_retries = 3
-    for attempt in range(max_retries):
+class PesticideDataFetcher:
+    """Classe pour gérer la récupération des données sur les pesticides."""
+    BASE_URL = "https://api.datalake.sante.service.ec.europa.eu/sante/pesticides"
+    HEADERS = {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-cache',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+    }
+
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update(self.HEADERS)
+        self._substance_cache = {}
+        self._product_cache = {}
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+    def fetch_data(self, url: str, params: Optional[Dict] = None) -> Dict[str, Any]:
+        """Effectue une requête GET avec gestion des erreurs améliorée"""
         try:
-            # Ajout d'un petit délai entre les tentatives
-            if attempt > 0:
-                time.sleep(2)
+            logger.info(f"Fetching URL: {url}")
+            if params:
+                logger.info(f"Parameters: {params}")
                 
-            # Log de l'URL
-            logger.info(f"Appel API: {url}")
-            
-            # Headers par défaut
-            if headers is None:
-                headers = {
-                    "Content-Type": "application/json",
-                    "Cache-Control": "no-cache",
-                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
-                }
-            
-            # Appel API
-            response = requests.get(url, headers=headers, params=params, timeout=10)
-            
-            # Log du code de statut
-            logger.info(f"Code de statut: {response.status_code}")
-            
-            # Si succès, retourner les données
-            if response.status_code == 200:
-                data = response.json()
-                return data
-            else:
-                logger.error(f"Erreur API: {response.status_code} - {response.text[:200]}")
+            response = self.session.get(url, params=params, timeout=15)
+            
+            # Log du statut HTTP
+            logger.info(f"Status code: {response.status_code}")
+            
+            # En cas d'erreur, retourner un dictionnaire avec l'erreur
+            if response.status_code >= 400:
+                logger.error(f"Erreur HTTP {response.status_code}: {response.text[:200]}...")
+                return {"error": f"Erreur HTTP {response.status_code}", "status_code": response.status_code}
                 
-        except Exception as e:
-            logger.error(f"Erreur lors de l'appel API: {str(e)}")
-    
-    # Si toutes les tentatives échouent, retourner un dictionnaire vide
-    return {}
+            response.raise_for_status()
+            data = response.json()
+            
+            # Log d'un aperçu des données pour débogage
+            if "value" in data:
+                logger.info(f"Données récupérées: {len(data['value'])} éléments")
+                if data["value"]:
+                    logger.info(f"Premier élément: {str(data['value'][0])[:200]}...")
+            
+            return data
+        except requests.RequestException as e:
+            logger.error(f"Erreur API: {e}")
+            if hasattr(e, 'response') and hasattr(e.response, 'text'):
+                logger.error(f"Détails de l'erreur: {e.response.text[:500]}")
+            return {"error": str(e)}
+        except ValueError as e:
+            # Erreur de parsing JSON
+            logger.error(f"Erreur de parsing JSON: {e}")
+            return {"error": f"Erreur de parsing JSON: {e}"}
 
-# Données statiques pour les cas où l'API ne fonctionne pas
-# Ces données sont fictives mais permettent à l'application de fonctionner
-STATIC_PRODUCTS = {
-    "Pommes": 163,
-    "Oranges": 191,
-    "Blé": 254,
-    "Tomates": 401,
-    "Fraises": 113,
-    "Riz": 510,
-    "Raisins": 305,
-    "Maïs": 240,
-    "Laitue": 355,
-    "Carottes": 228
-}
+    def get_products(self) -> List[Dict]:
+        """Récupère la liste complète des produits avec pagination."""
+        if self._product_cache:
+            return self._product_cache
+            
+        all_products = []
+        url = f"{self.BASE_URL}/pesticide_residues_products?format=json&language=FR&api-version=v2.0"
+        
+        # Tester chaque combinaison possible pour le paramètre format
+        formats_to_try = ["json", "application/json"]
+        
+        for fmt in formats_to_try:
+            test_url = f"{self.BASE_URL}/pesticide_residues_products?format={fmt}&language=FR&api-version=v2.0"
+            response = self.fetch_data(test_url)
+            
+            # Si l'API répond avec succès
+            if "error" not in response and "value" in response:
+                url = test_url
+                break
+        
+        # Si on ne peut pas accéder à l'API du tout
+        test_response = self.fetch_data(url)
+        if "error" in test_response:
+            logger.error(f"Impossible d'accéder à l'API des produits: {test_response['error']}")
+            return []
+        
+        # Si on arrive ici, on a un URL fonctionnel
+        while url:
+            response = self.fetch_data(url)
+            
+            # Vérifier s'il y a une erreur
+            if "error" in response:
+                logger.error(f"Erreur lors de la récupération des produits: {response['error']}")
+                break
+                
+            if "value" not in response:
+                logger.error(f"Format de réponse inattendu: {response}")
+                break
+                
+            all_products.extend(response["value"])
+            
+            # Gérer la pagination (vérifier toutes les variantes possibles)
+            next_link = None
+            for key in ["@odata.nextLink", "nextLink", "@data.nextLink", "next"]:
+                if key in response:
+                    next_link = response[key]
+                    break
+                    
+            if next_link:
+                url = next_link
+            else:
+                break
+                
+        # Mise en cache des résultats
+        self._product_cache = all_products
+        logger.info(f"Récupéré {len(all_products)} produits au total")
+        return all_products
 
-STATIC_SUBSTANCES = {
-    1: "Glyphosate",
-    2: "Chlorpyrifos",
-    3: "Imidaclopride",
-    4: "Atrazine",
-    5: "Trifluraline",
-    6: "Malathion",
-    7: "Diazinon",
-    8: "Carbaryl",
-    9: "Paraquat",
-    10: "Métolachlore"
-}
+    def get_all_substances(self) -> Dict[int, str]:
+        """Récupère toutes les substances actives avec pagination."""
+        if self._substance_cache:
+            return self._substance_cache
+            
+        substances_dict = {}
+        url = f"{self.BASE_URL}/active_substances?format=json&api-version=v2.0"
+        
+        # Tester chaque combinaison possible pour le paramètre format
+        formats_to_try = ["json", "application/json"]
+        
+        for fmt in formats_to_try:
+            test_url = f"{self.BASE_URL}/active_substances?format={fmt}&api-version=v2.0"
+            response = self.fetch_data(test_url)
+            
+            # Si l'API répond avec succès
+            if "error" not in response and "value" in response:
+                url = test_url
+                break
+        
+        # Si on ne peut pas accéder à l'API du tout
+        test_response = self.fetch_data(url)
+        if "error" in test_response:
+            logger.error(f"Impossible d'accéder à l'API des substances: {test_response['error']}")
+            return {}
+        
+        # Si on arrive ici, on a un URL fonctionnel
+        while url:
+            response = self.fetch_data(url)
+            
+            # Vérifier s'il y a une erreur
+            if "error" in response:
+                logger.error(f"Erreur lors de la récupération des substances: {response['error']}")
+                break
+                
+            if "value" not in response:
+                logger.error(f"Format de réponse inattendu: {response}")
+                break
+                
+            for item in response["value"]:
+                # Essayer tous les noms de champs possibles
+                substance_id = None
+                substance_name = None
+                
+                for id_field in ["substanceId", "substance_id", "id"]:
+                    if id_field in item:
+                        substance_id = item[id_field]
+                        break
+                        
+                for name_field in ["substanceName", "substance_name", "name"]:
+                    if name_field in item:
+                        substance_name = item[name_field]
+                        break
+                    
+                if substance_id is not None and substance_name:
+                    substances_dict[substance_id] = substance_name
+            
+            # Gérer la pagination (vérifier toutes les variantes possibles)
+            next_link = None
+            for key in ["@odata.nextLink", "nextLink", "@data.nextLink", "next"]:
+                if key in response:
+                    next_link = response[key]
+                    break
+                    
+            if next_link:
+                url = next_link
+            else:
+                break
+                
+        # Mise en cache des résultats
+        self._substance_cache = substances_dict
+        logger.info(f"Récupéré {len(substances_dict)} substances au total")
+        return substances_dict
 
-# Fonction pour récupérer les produits
-@st.cache_data(ttl=3600)
-def get_products():
-    """Récupération des produits avec fallback sur données statiques"""
-    base_url = "https://api.datalake.sante.service.ec.europa.eu/sante/pesticides"
-    url = f"{base_url}/pesticide_residues_products?format=json&language=FR&api-version=v2.0"
-    
-    # Récupérer les données
-    data = get_api_data(url)
-    
-    # Si la réponse contient des données
-    if data and "value" in data:
-        products = data["value"]
-        # Créer un dictionnaire pour le sélecteur
-        product_dict = {}
-        for p in products:
-            # Vérifier les noms de champs
-            product_id = p.get("productId", None)
-            product_name = p.get("productName", "")
-            
-            # Si les champs n'existent pas, essayer d'autres noms possibles
-            if product_id is None:
-                product_id = p.get("product_id", None)
-            if not product_name:
-                product_name = p.get("product_name", "Produit sans nom")
+    def get_mrls(self, product_ids: List[int]) -> List[Dict]:
+        """Récupère les LMR pour une liste de produits."""
+        if not product_ids:
+            logger.warning("Aucun ID de produit fourni pour la récupération des LMR")
+            return []
+            
+        all_mrls = []
+        
+        # Tester différentes variantes d'URL
+        urls_to_try = [
+            f"{self.BASE_URL}/pesticide_residues_mrls?format=json&product_id={{product_id}}&api-version=v2.0",
+            f"{self.BASE_URL}/pesticide_residues_products/{{product_id}}/mrls?format=json&api-version=v2.0",
+            f"{self.BASE_URL}/pesticide_residues_products/{{product_id}}/mrls?format=json&language=FR&api-version=v2.0"
+        ]
+        
+        # Tester quelle URL fonctionne avec le premier produit
+        working_url_template = None
+        
+        for url_template in urls_to_try:
+            test_url = url_template.format(product_id=product_ids[0])
+            response = self.fetch_data(test_url)
+            
+            if "error" not in response and "value" in response:
+                working_url_template = url_template
+                logger.info(f"URL de LMR fonctionnelle trouvée: {working_url_template}")
+                break
+        
+        if not working_url_template:
+            logger.error("Aucune URL fonctionnelle trouvée pour récupérer les LMR")
+            return []
+        
+        # Utiliser ThreadPoolExecutor pour les requêtes parallèles
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = []
+            for product_id in product_ids:
+                url = working_url_template.format(product_id=product_id)
+                futures.append(executor.submit(self.fetch_data, url))
                 
-            # Ajouter au dictionnaire seulement si ID valide
-            if product_id is not None:
-                product_dict[product_name] = product_id
+            for future in futures:
+                response = future.result()
+                if "error" in response:
+                    logger.error(f"Erreur lors de la récupération des LMR: {response['error']}")
+                    continue
+                    
+                if "value" in response:
+                    all_mrls.extend(response["value"])
+        
+        logger.info(f"Récupéré {len(all_mrls)} LMR au total")
+        return all_mrls
+
+class PesticideInterface:
+    def __init__(self):
+        logger.info("Initialisation de l'application...")
+        self.fetcher = PesticideDataFetcher()
+
+        with st.spinner("Chargement des données de produits et substances..."):
+            # Récupération des produits
+            logger.info("Récupération de la liste des produits...")
+            self.products = self.fetcher.get_products()
+            self.product_choices = {}
+            
+            if self.products:
+                for p in self.products:
+                    # Essayer tous les noms de champs possibles pour le nom et l'ID
+                    product_name = None
+                    product_id = None
+                    
+                    for name_field in ["productName", "product_name", "name"]:
+                        if name_field in p:
+                            product_name = p[name_field]
+                            break
+                            
+                    for id_field in ["productId", "product_id", "id"]:
+                        if id_field in p:
+                            product_id = p[id_field]
+                            break
+                    
+                    if product_name and product_id is not None:
+                        self.product_choices[product_name] = product_id
+                        
+                logger.info(f"Produits récupérés: {len(self.product_choices)}")
+            else:
+                logger.error("Aucun produit récupéré. Vérifiez la connexion à l'API.")
+                    
+            # Récupération des substances
+            logger.info("Récupération des substances actives...")
+            self.substances = self.fetcher.get_all_substances()
+            logger.info(f"Substances récupérées: {len(self.substances)}")
+            
+        logger.info(f"Application initialisée avec {len(self.product_choices)} produits et {len(self.substances)} substances")
+
+    def get_product_details(self, product_names: List[str], future_only: bool = False) -> pd.DataFrame:
+        """Récupère les détails des produits sélectionnés."""
+        if not product_names:
+            return pd.DataFrame()
+
+        product_ids = [self.product_choices[name] for name in product_names if name in self.product_choices]
+        if not product_ids:
+            st.warning("Aucun produit valide sélectionné.")
+            return pd.DataFrame()
+            
+        all_mrls = self.fetcher.get_mrls(product_ids)
+        
+        if not all_mrls:
+            st.info("Aucune donnée trouvée pour les produits sélectionnés.")
+            return pd.DataFrame()
+
+        # Création du DataFrame
+        df = pd.DataFrame(all_mrls)
+        logger.info(f"Nombre total d'entrées: {len(df)}")
+        
+        # Log des colonnes disponibles pour débogage
+        logger.info(f"Colonnes disponibles: {df.columns.tolist()}")
+        
+        # Enrichir avec les noms de substances
+        substance_id_field = None
+        for field in ["pesticideResidueId", "pesticide_residue_id", "substance_id"]:
+            if field in df.columns:
+                substance_id_field = field
+                break
                 
-        logger.info(f"Nombre de produits récupérés de l'API: {len(product_dict)}")
+        if substance_id_field:
+            df["Substance"] = df[substance_id_field].map(self.substances)
+            df["Substance"] = df["Substance"].fillna("Substance inconnue")
+        else:
+            df["Substance"] = "Substance inconnue"
+            logger.warning("Champ d'ID de substance non trouvé dans les données")
         
-        if product_dict:  # Si des produits ont été trouvés
-            return product_dict
-    
-    # Si on arrive ici, utiliser les données statiques
-    logger.warning("Utilisation des données statiques pour les produits")
-    return STATIC_PRODUCTS
+        # Conversion des dates
+        date_field = None
+        for field in ["entryIntoForceDate", "entry_into_force_date", "applicationDate"]:
+            if field in df.columns:
+                date_field = field
+                break
+                
+        if date_field:
+            df["Date d'application"] = pd.to_datetime(df[date_field], errors="coerce")
+        else:
+            df["Date d'application"] = pd.NaT
+            logger.warning("Champ de date non trouvé dans les données")
+
+        # Filtrer pour les changements futurs si demandé
+        if future_only and "Date d'application" in df.columns:
+            now = datetime.now()
+            future_date = now + timedelta(days=180)
+            future_df = df[
+                (df["Date d'application"] > now) &
+                (df["Date d'application"] <= future_date)
+            ]
 
-# Fonction pour récupérer les substances
-@st.cache_data(ttl=3600)
-def get_substances():
-    """Récupération des substances avec fallback sur données statiques"""
-    base_url = "https://api.datalake.sante.service.ec.europa.eu/sante/pesticides"
-    url = f"{base_url}/active_substances?format=json&api-version=v2.0"
-    
-    # Récupérer les données
-    data = get_api_data(url)
-    
-    # Si la réponse contient des données
-    if data and "value" in data:
-        substances = data["value"]
-        # Créer un dictionnaire pour le mapping
-        substance_dict = {}
-        for s in substances:
-            # Vérifier les noms de champs
-            substance_id = s.get("substanceId", None)
-            substance_name = s.get("substanceName", "")
-            
-            # Si les champs n'existent pas, essayer d'autres noms possibles
-            if substance_id is None:
-                substance_id = s.get("substance_id", None)
-            if not substance_name:
-                substance_name = s.get("substance_name", "Substance sans nom")
+            if future_df.empty:
+                st.info(f"🔍 Aucun changement de LMR prévu entre le {now.strftime('%d/%m/%Y')} et le {future_date.strftime('%d/%m/%Y')} pour les produits sélectionnés.")
+                return pd.DataFrame()
+
+            df = future_df
+
+        # Renommer et formater les colonnes
+        mrl_field = None
+        for field in ["mrlValue", "mrl_value", "mrl"]:
+            if field in df.columns:
+                mrl_field = field
+                break
                 
-            # Ajouter au dictionnaire seulement si ID valide
-            if substance_id is not None:
-                substance_dict[substance_id] = substance_name
+        if mrl_field:
+            df = df.rename(columns={mrl_field: "Valeur LMR"})
+            df["Valeur LMR"] = pd.to_numeric(df["Valeur LMR"], errors='coerce')
+        else:
+            logger.warning("Champ de valeur LMR non trouvé dans les données")
+        
+        # Ajouter la colonne Règlement si possible
+        regulation_number_field = None
+        regulation_url_field = None
+        
+        for number_field in ["regulationNumber", "regulation_number", "regulation"]:
+            if number_field in df.columns:
+                regulation_number_field = number_field
+                break
                 
-        logger.info(f"Nombre de substances récupérées de l'API: {len(substance_dict)}")
+        for url_field in ["regulationUrl", "regulation_url", "url"]:
+            if url_field in df.columns:
+                regulation_url_field = url_field
+                break
         
-        if substance_dict:  # Si des substances ont été trouvées
-            return substance_dict
-    
-    # Si on arrive ici, utiliser les données statiques
-    logger.warning("Utilisation des données statiques pour les substances")
-    return STATIC_SUBSTANCES
-
-# Fonction pour récupérer les LMR
-def get_mrls(product_ids):
-    """Récupération des LMR pour les produits donnés"""
-    # Vérifier si product_ids est une liste
-    if not isinstance(product_ids, list):
-        product_ids = [product_ids]
+        if regulation_number_field:
+            if regulation_url_field:
+                df["Règlement"] = df.apply(
+                    lambda x: f'<a href="{x[regulation_url_field]}" target="_blank">{x[regulation_number_field]}</a>'
+                    if pd.notna(x.get(regulation_url_field)) else x.get(regulation_number_field, ""),
+                    axis=1
+                )
+            else:
+                df["Règlement"] = df[regulation_number_field]
+        
+        # Sélection des colonnes finales
+        columns = []
         
-    # Si la liste est vide, retourner une liste vide
-    if not product_ids:
-        return []
-    
-    all_mrls = []
-    substances = get_substances()
-    
-    # En cas d'erreur d'API, générer des données statiques pour chaque produit
-    for product_id in product_ids:
-        # Générer des LMR aléatoires pour chaque substance
-        for substance_id, substance_name in substances.items():
-            # Générer des valeurs aléatoires mais réalistes
-            import random
-            
-            # Valeur LMR entre 0.01 et 5.0
-            mrl_value = round(random.uniform(0.01, 5.0), 3)
-            
-            # Date d'application entre 1 an dans le passé et 1 an dans le futur
-            days_offset = random.randint(-365, 365)
-            application_date = datetime.now() + timedelta(days=days_offset)
-            
-            all_mrls.append({
-                "product_id": product_id,
-                "substance_id": substance_id,
-                "substance_name": substance_name,
-                "mrl_value": mrl_value,
-                "application_date": application_date,
-                "regulation_number": f"EU {random.randint(2020, 2025)}/{random.randint(100, 999)}"
-            })
-    
-    return all_mrls
+        # Ajouter les colonnes si elles existent
+        if "Substance" in df.columns:
+            columns.append("Substance")
+        if "Valeur LMR" in df.columns:
+            columns.append("Valeur LMR")
+        if "Date d'application" in df.columns:
+            columns.append("Date d'application")
+        if "Règlement" in df.columns:
+            columns.append("Règlement")
+            
+        # Si aucune colonne n'est disponible, utiliser toutes les colonnes
+        if not columns:
+            columns = df.columns.tolist()
+            
+        df = df[columns]
+        
+        # Trier par date si disponible
+        if "Date d'application" in df.columns:
+            df = df.sort_values("Date d'application", ascending=False)
+        
+        return df
+
+    def create_interface(self):
+        st.title("🌿 Base de données des pesticides de l'UE")
+
+        if not self.product_choices:
+            st.error("⚠️ Aucun produit n'a pu être récupéré depuis l'API. Vérifiez votre connexion ou les logs pour plus d'informations.")
+            st.info("Essayez de cliquer sur le bouton 'Réinitialiser le cache' dans la barre latérale puis rechargez la page.")
+            return
+
+        col1, col2 = st.columns([3, 1])
+        with col1:
+            product_names = st.multiselect(
+                "Sélectionnez un ou plusieurs produits",
+                list(self.product_choices.keys())
+            )
+        with col2:
+            future_only = st.checkbox("Uniquement les 6 prochains mois", value=False)
+
+        if st.button("Afficher les données"):
+            if not product_names:
+                st.warning("Veuillez sélectionner au moins un produit.")
+                return
+
+            with st.spinner("Récupération des données en cours..."):
+                df = self.get_product_details(product_names, future_only)
+
+            if df.empty:
+                return  # Le message d'info a déjà été affiché dans get_product_details
+            else:
+                if future_only:
+                    st.markdown("### Changements de LMR prévus dans les 6 prochains mois")
+                else:
+                    st.markdown("### Tableau des LMR")
+
+                # Formatage du DataFrame pour l'affichage
+                df_display = df.copy()
+                if "Date d'application" in df_display.columns:
+                    df_display["Date d'application"] = df_display["Date d'application"].dt.strftime('%d/%m/%Y')
+
+                # Ajouter un résumé des changements
+                nb_changes = len(df)
+                st.info(f"📊 {nb_changes} entrée{'s' if nb_changes > 1 else ''} trouvée{'s' if nb_changes > 1 else ''}.")
+                
+                # Afficher le tableau
+                st.dataframe(df_display, use_container_width=True)
+                
+                # Option pour télécharger les données
+                st.download_button(
+                    "Télécharger les données (CSV)",
+                    df_display.to_csv(index=False, sep=';').encode('utf-8-sig'),
+                    "pesticide_data.csv",
+                    "text/csv",
+                    key='download-csv'
+                )
+                
+                # Créer des visualisations si les données requises sont présentes
+                if "Valeur LMR" in df.columns and "Date d'application" in df.columns:
+                    self.create_visualizations(df)
+                else:
+                    st.warning("Données insuffisantes pour créer des visualisations")
+
+    def create_visualizations(self, df: pd.DataFrame):
+        """Crée les visualisations des données de LMR"""
+        # Vérifier que les données ne sont pas vides
+        if df.empty:
+            return
+            
+        # Graphique d'évolution des LMR dans le temps
+        fig1 = px.scatter(
+            df,
+            x="Date d'application",
+            y="Valeur LMR",
+            color="Substance",
+            title="Évolution des LMR dans le temps",
+            hover_data=["Substance"],
+            size_max=15,
+            labels={
+                "Date d'application": "Date d'entrée en vigueur",
+                "Valeur LMR": "Limite Maximale de Résidus (mg/kg)"
+            }
+        )
+        st.plotly_chart(fig1, use_container_width=True)
 
-# Fonction principale
 def main():
     try:
-        st.title("🌿 Base de données des pesticides de l'UE")
-        
         # Ajout d'un bouton pour réinitialiser le cache
         if st.sidebar.button("🔄 Réinitialiser le cache"):
             st.cache_data.clear()
-            st.rerun()  # Utilisation de st.rerun() au lieu de st.experimental_rerun()
+            st.rerun()
             
         st.sidebar.image("https://ec.europa.eu/info/sites/default/files/european-commission.logo_.png", width=200)
         st.sidebar.title("🌿 Pesticide Data Explorer")
+        st.sidebar.markdown("""
+        Cette application permet d'explorer les données de pesticides 
+        de l'Union Européenne, notamment les limites maximales de résidus (LMR).
+        
+        **Source des données:** API officielle de la Commission Européenne
+        """)
         
-        # Informations sur l'application
+        # Ajout d'informations et d'aide dans la barre latérale
         with st.sidebar.expander("ℹ️ À propos"):
             st.markdown("""
-            Cette application permet d'explorer les données de pesticides 
-            de l'Union Européenne, notamment les limites maximales de résidus (LMR).
+            Cette application récupère et visualise les données de pesticides depuis l'API officielle 
+            de la Commission Européenne. Elle permet de:
             
-            **Source des données:** Données simulées basées sur l'API de la Commission Européenne
+            * Rechercher des informations sur les LMR par produit
+            * Visualiser l'évolution des LMR dans le temps
+            
+            Les données sont mises en cache pendant 1 heure pour améliorer les performances.
             """)
+            
+        with st.sidebar.expander("❓ Aide"):
+            st.markdown("""
+            **Comment utiliser cette application:**
+            
+            1. Sélectionnez un ou plusieurs produits dans la liste déroulante
+            2. Cochez "Uniquement les 6 prochains mois" si vous souhaitez voir seulement les changements à venir
+            3. Cliquez sur "Afficher les données" pour visualiser les résultats
+            
+            Vous pouvez télécharger les résultats au format CSV pour une analyse plus approfondie.
+            
+            En cas de problème, utilisez le bouton "Réinitialiser le cache" en haut de cette barre latérale.
+            """)
+            
+        # Ajouter contact et crédits
+        st.sidebar.markdown("---")
+        st.sidebar.markdown("Développé avec ❤️ pour l'UE")
         
         # Afficher l'état de l'API
         with st.sidebar.expander("📊 État de l'API"):
+            st.markdown("### Tests de connexion API")
+            col1, col2 = st.columns(2)
+            
+            # Test de connexion pour l'API des produits
             try:
                 url = "https://api.datalake.sante.service.ec.europa.eu/sante/pesticides/pesticide_residues_products?format=json&language=FR&api-version=v2.0"
-                response = requests.get(url, timeout=5)
-                st.markdown(f"**Statut API:** {response.status_code}")
+                fetcher = PesticideDataFetcher()
+                response = fetcher.session.get(url, timeout=5)
                 if response.status_code == 200:
-                    st.success("✅ Connexion API réussie")
+                    col1.success("✅ API Produits")
                 else:
-                    st.error(f"❌ Erreur API ({response.status_code})")
-                    st.info("⚠️ L'application utilise des données simulées")
+                    col1.error(f"❌ API Produits ({response.status_code})")
+                    col1.info("Essayez de consulter les logs pour plus d'informations")
             except Exception as e:
-                st.error(f"❌ Impossible de se connecter à l'API: {str(e)[:100]}")
-                st.info("⚠️ L'application utilise des données simulées")
-        
-        # Récupérer les produits
-        with st.spinner("Chargement des produits..."):
-            products = get_products()
-        
-        # Interface utilisateur
-        col1, col2 = st.columns([3, 1])
-        with col1:
-            selected_products = st.multiselect(
-                "Sélectionnez un ou plusieurs produits",
-                list(products.keys())
-            )
-        with col2:
-            future_only = st.checkbox("Uniquement les 6 prochains mois", value=False)
-        
-        if st.button("Afficher les données"):
-            if not selected_products:
-                st.warning("Veuillez sélectionner au moins un produit.")
-            else:
-                with st.spinner("Récupération des données..."):
-                    # Récupérer les IDs des produits sélectionnés
-                    selected_ids = [products[p] for p in selected_products]
-                    
-                    # Récupérer les LMR pour ces produits
-                    all_mrls = get_mrls(selected_ids)
-                    
-                    # Créer un DataFrame
-                    df = pd.DataFrame(all_mrls)
-                    
-                    # Filtrer pour les 6 prochains mois si demandé
-                    if future_only:
-                        now = datetime.now()
-                        future_date = now + timedelta(days=180)
-                        df = df[(df['application_date'] > now) & (df['application_date'] <= future_date)]
-                        
-                        if df.empty:
-                            st.info(f"🔍 Aucun changement de LMR prévu dans les 6 prochains mois pour les produits sélectionnés.")
-                            return
-                    
-                    # Renommer les colonnes pour l'affichage
-                    df = df.rename(columns={
-                        "substance_name": "Substance",
-                        "mrl_value": "Valeur LMR",
-                        "application_date": "Date d'application",
-                        "regulation_number": "Règlement"
-                    })
-                    
-                    # Trier par date d'application
-                    df = df.sort_values("Date d'application", ascending=False)
-                    
-                    # Afficher les informations
-                    nb_entries = len(df)
-                    st.success(f"Données récupérées pour {len(selected_products)} produit(s)")
-                    st.info(f"📊 {nb_entries} entrée{'s' if nb_entries > 1 else ''} trouvée{'s' if nb_entries > 1 else ''}.")
-                    
-                    # Formater le DataFrame pour l'affichage
-                    df_display = df.copy()
-                    df_display["Date d'application"] = df_display["Date d'application"].dt.strftime('%d/%m/%Y')
-                    
-                    # Afficher le tableau
-                    st.dataframe(df_display[["Substance", "Valeur LMR", "Date d'application", "Règlement"]], use_container_width=True)
-                    
-                    # Bouton de téléchargement
-                    st.download_button(
-                        "Télécharger les données (CSV)",
-                        df_display.to_csv(index=False, sep=';').encode('utf-8-sig'),
-                        "pesticide_data.csv",
-                        "text/csv",
-                        key='download-csv'
-                    )
-                    
-                    # Créer des visualisations
-                    st.subheader("Visualisation des LMR")
-                    fig = px.scatter(
-                        df,
-                        x="Date d'application",
-                        y="Valeur LMR",
-                        color="Substance",
-                        title="Évolution des LMR dans le temps",
-                        labels={
-                            "Date d'application": "Date d'entrée en vigueur",
-                            "Valeur LMR": "Limite Maximale de Résidus (mg/kg)"
-                        }
-                    )
-                    st.plotly_chart(fig, use_container_width=True)
-    
+                col1.error(f"❌ API Produits: {str(e)[:50]}...")
+                
+            # Test de connexion pour l'API des substances
+            try:
+                url = "https://api.datalake.sante.service.ec.europa.eu/sante/pesticides/active_substances?format=json&api-version=v2.0"
+                fetcher = PesticideDataFetcher()
+                response = fetcher.session.get(url, timeout=5)
+                if response.status_code == 200:
+                    col2.success("✅ API Substances")
+                else:
+                    col2.error(f"❌ API Substances ({response.status_code})")
+                    col2.info("Essayez de consulter les logs pour plus d'informations")
+            except Exception as e:
+                col2.error(f"❌ API Substances: {str(e)[:50]}...")
+            
+        # Afficher les logs dans la barre latérale pour faciliter le débogage
+        with st.sidebar.expander("📜 Logs récents"):
+            try:
+                with open("pesticide_app.log", "r") as f:
+                    logs = f.readlines()
+                    st.code("".join(logs[-20:]))  # Afficher les 20 dernières lignes
+            except Exception as e:
+                st.warning(f"Impossible de lire les logs: {e}")
+            
+        interface = PesticideInterface()
+        interface.create_interface()
     except Exception as e:
-        logger.error(f"Erreur dans l'application: {str(e)}", exc_info=True)
+        logger.error(f"Erreur lors de l'exécution de l'application: {e}", exc_info=True)
         st.error(f"Une erreur est survenue: {str(e)}")
+        st.info("Veuillez rafraîchir la page et réessayer. Si le problème persiste, contactez l'administrateur.")
         
-        # Afficher des détails techniques pour le débogage
-        with st.expander("Détails techniques"):
+        # Fournir des informations de débogage supplémentaires
+        with st.expander("Détails de l'erreur"):
             import traceback
             st.code(traceback.format_exc())