Update app.py

app.py

@@ -1,624 +1,95 @@
 import streamlit as st
-import pandas as pd
-import plotly.express as px
 import requests
-import json
-import time
-import logging
-import datetime
-from functools import lru_cache
-import base64
-from io import StringIO
+import pandas as pd
+import matplotlib.pyplot as plt
+from datetime import datetime, timedelta
 
-# Configuration du logging
-logging.basicConfig(level=logging.INFO, 
-                   format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger('pesticide_explorer')
+# Configuration de l'application
+st.title("Base de données des pesticides de l'UE")
 
-# Configuration de la page
-st.set_page_config(
-    page_title="Base de données des pesticides de l'UE",
-    page_icon="🌱",
-    layout="wide"
-)
+# Fonction pour récupérer la liste des produits
+@st.cache_data
+def get_products():
+    url = "https://api.datalake.sante.service.ec.europa.eu/sante/pesticides/pesticide_residues_products"
+    params = {"format": "json", "language": "FR", "api-version": "v2.0"}
+    response = requests.get(url, params=params)
+    response.raise_for_status()
+    return response.json()
 
-# Constantes
-BASE_URL = "https://api.datalake.sante.service.ec.europa.eu/sante/pesticides"
-API_VERSION = "v2.0"
-DEFAULT_LANGUAGE = "FR"
-DEFAULT_FORMAT = "json"
-RETRY_ATTEMPTS = 3
-RETRY_DELAY = 2  # secondes
+# Fonction pour récupérer les LMR par produit
+@st.cache_data
+def get_mrls(product_id):
+    url = f"https://api.datalake.sante.service.ec.europa.eu/sante/pesticides/pesticide_residues_mrls"
+    params = {"format": "json", "product_id": product_id, "api-version": "v2.0"}
+    response = requests.get(url, params=params)
+    response.raise_for_status()
+    return response.json()
 
-# Paramètres d'authentification
-def get_api_key():
-    """Récupère la clé API depuis les secrets Streamlit ou l'interface utilisateur."""
-    # Essayer de récupérer depuis les secrets Streamlit
-    try:
-        return st.secrets["eu_pesticides_api_key"]
-    except:
-        # Si pas disponible dans les secrets, demander à l'utilisateur
-        if "api_key" not in st.session_state:
-            st.session_state.api_key = ""
-        
-        return st.session_state.api_key
+# Fonction pour récupérer les informations sur les substances
+@st.cache_data
+def get_substance_info(substance_id):
+    url = f"https://api.datalake.sante.service.ec.europa.eu/sante/pesticides/pesticide_residues"
+    params = {"format": "json", "pesticide_residue_id": substance_id, "api-version": "v2.0"}
+    response = requests.get(url, params=params)
+    response.raise_for_status()
+    return response.json()
 
-# Cache pour les données
-# Fonction pour charger des données de démonstration
-def load_demo_data():
-    """Charge des données de démonstration pour montrer les fonctionnalités de l'application."""
-    # Produits de démonstration
-    products_data = [
-        {"product_id": 1, "product_name": "Pommes", "product_code": "0130010"},
-        {"product_id": 2, "product_name": "Poires", "product_code": "0130020"},
-        {"product_id": 3, "product_name": "Tomates", "product_code": "0231010"},
-        {"product_id": 4, "product_name": "Raisins", "product_code": "0151010"},
-        {"product_id": 5, "product_name": "Oranges", "product_code": "0110010"},
-        {"product_id": 6, "product_name": "Blé", "product_code": "0500010"},
-        {"product_id": 7, "product_name": "Riz", "product_code": "0500060"},
-        {"product_id": 8, "product_name": "Carottes", "product_code": "0213020"},
-    ]
-    
-    # Convertir en DataFrame
-    return pd.DataFrame(products_data)
+# Interface utilisateur
+products = get_products()
+product_names = [product['name'] for product in products]
+selected_product = st.selectbox("Sélectionnez un produit agricole", product_names)
 
-@st.cache_data(ttl=3600)  # Cache d'une heure
-def get_products():
-    """Récupère la liste complète des produits agricoles."""
-    # Vérifier si le mode démo est activé
-    if hasattr(st.session_state, 'demo_mode') and st.session_state.demo_mode:
-        return load_demo_data()
-    
-    url = f"{BASE_URL}/pesticide_residues_products"
-    params = {
-        "format": DEFAULT_FORMAT,
-        "language": DEFAULT_LANGUAGE,
-        "api-version": API_VERSION
-    }
-    
-    all_products = []
-    next_link = None
-    
-    try:
-        with st.spinner("Chargement de la liste des produits..."):
-            while True:
-                if next_link:
-                    response = make_api_request(next_link)
-                else:
-                    response = make_api_request(url, params)
-                
-                if not response:
-                    st.error("Impossible de récupérer la liste des produits. Veuillez réessayer plus tard.")
-                    return pd.DataFrame()
-                
-                data = response.json()
-                
-                # Récupérer les produits de la page actuelle
-                products = data.get('value', [])
-                all_products.extend(products)
-                
-                # Vérifier s'il y a une page suivante
-                next_link = data.get('nextLink') or data.get('@odata.nextLink')
-                if not next_link:
-                    break
-        
-        # Convertir en DataFrame pour faciliter la manipulation
-        df_products = pd.DataFrame(all_products)
-        
-        # Renommer les colonnes pour une utilisation cohérente (gestion des inconsistances de l'API)
-        column_mapping = {
-            'productId': 'product_id',
-            'product_Id': 'product_id',
-            'productName': 'product_name',
-            'product_Name': 'product_name'
-        }
-        
-        df_products = df_products.rename(columns={col: column_mapping[col] 
-                                                for col in column_mapping 
-                                                if col in df_products.columns})
-        
-        # Tri par nom de produit
-        if 'product_name' in df_products.columns:
-            df_products = df_products.sort_values('product_name')
-        
-        logger.info(f"Récupération réussie de {len(df_products)} produits")
-        return df_products
-    
-    except Exception as e:
-        logger.error(f"Erreur lors de la récupération des produits: {str(e)}")
-        st.error(f"Erreur lors de la récupération des produits: {str(e)}")
-        return pd.DataFrame()
+# Filtrage par période
+period = st.radio("Filtrer par période", ["Toutes dates", "Dernière semaine", "Dernier mois", "6 prochains mois"])
+
+# Bouton pour lancer l'analyse
+if st.button("Analyser les données"):
+    product_id = next(product['id'] for product in products if product['name'] == selected_product)
+    mrls = get_mrls(product_id)
 
-@st.cache_data(ttl=3600)
-def get_residue_name(residue_id):
-    """Récupère le nom d'une substance active à partir de son ID."""
-    url = f"{BASE_URL}/pesticide_residues"
-    params = {
-        "format": DEFAULT_FORMAT,
-        "pesticide_residue_id": residue_id,
-        "api-version": API_VERSION
-    }
-    
-    try:
-        response = make_api_request(url, params)
-        if not response:
-            logger.warning(f"Impossible de récupérer le nom de la substance {residue_id}")
-            return f"Substance {residue_id}"
-        
-        data = response.json()
-        substances = data.get('value', [])
-        
-        if substances:
-            # Chercher le nom dans différentes variables possibles
-            name_fields = ['pesticide_residue_name', 'pesticideResidueName', 'name']
-            for field in name_fields:
-                if field in substances[0]:
-                    return substances[0][field]
-            
-            # Si aucun champ de nom n'est trouvé
-            return f"Substance {residue_id}"
-        else:
-            return f"Substance {residue_id}"
-    
-    except Exception as e:
-        logger.error(f"Erreur lors de la récupération du nom de la substance {residue_id}: {str(e)}")
-        return f"Substance {residue_id}"
+    # Filtrer les données par période
+    today = datetime.today()
+    if period == "Dernière semaine":
+        start_date = today - timedelta(days=7)
+    elif period == "Dernier mois":
+        start_date = today - timedelta(days=30)
+    elif period == "6 prochains mois":
+        start_date = today + timedelta(days=180)
+    else:
+        start_date = datetime.min
 
-# Fonction pour charger des LMR de démonstration
-def load_demo_mrls(product_id, time_filter=None):
-    """Charge des LMR de démonstration pour le produit sélectionné."""
-    # Substances de démonstration
-    substances = {
-        1: "Glyphosate",
-        2: "Clothianidine",
-        3: "Pendiméthaline",
-        4: "Imidaclopride",
-        5: "Thiamethoxam",
-        6: "Lambda-cyhalothrine",
-        7: "Acetamipride"
-    }
-    
-    # Générer des données aléatoires
-    import random
-    
-    # Date de base
-    base_date = datetime.datetime.now().date()
-    
-    # Générer entre 20 et 40 entrées aléatoires
-    num_entries = random.randint(20, 40)
-    
-    mrls_data = []
-    
-    for _ in range(num_entries):
-        # Choisir une substance aléatoire
-        substance_id = random.choice(list(substances.keys()))
-        
-        # Générer une date aléatoire dans les 3 dernières années
-        days_offset = random.randint(-1095, 180)  # -3 ans à +6 mois
-        random_date = base_date + datetime.timedelta(days=days_offset)
-        
-        # Générer une valeur LMR aléatoire (entre 0.01 et 5.0)
-        mrl_value = round(random.uniform(0.01, 5.0), 2)
-        
-        # Règlement fictif
-        regulation = f"{random.randint(2020, 2024)}/{random.randint(100, 999)}"
-        
-        mrls_data.append({
-            "pesticide_residue_id": substance_id,
-            "substance_name": substances[substance_id],
-            "mrl_value": mrl_value,
-            "application_date": pd.to_datetime(random_date),
-            "regulation_number": regulation
+    filtered_mrls = [mrl for mrl in mrls if datetime.strptime(mrl['date'], "%Y-%m-%d") >= start_date]
+
+    # Afficher les résultats dans un tableau
+    mrl_data = []
+    for mrl in filtered_mrls:
+        substance_info = get_substance_info(mrl['substance_id'])
+        mrl_data.append({
+            "Substance": substance_info['name'],
+            "Valeur LMR": mrl['value'],
+            "Date d'application": mrl['date'],
+            "Règlement": f"[Lien]({mrl['regulation_url']})"
         })
-    
-    # Convertir en DataFrame
-    df_mrls = pd.DataFrame(mrls_data)
-    
-    # Appliquer le filtre temporel si spécifié
-    if time_filter:
-        today = datetime.datetime.now().date()
-        
-        if time_filter == 'last_week':
-            one_week_ago = today - datetime.timedelta(days=7)
-            df_mrls = df_mrls[df_mrls['application_date'].dt.date >= one_week_ago]
-        
-        elif time_filter == 'last_month':
-            one_month_ago = today - datetime.timedelta(days=30)
-            df_mrls = df_mrls[df_mrls['application_date'].dt.date >= one_month_ago]
-        
-        elif time_filter == 'next_six_months':
-            six_months_later = today + datetime.timedelta(days=180)
-            df_mrls = df_mrls[(df_mrls['application_date'].dt.date >= today) & 
-                              (df_mrls['application_date'].dt.date <= six_months_later)]
-    
-    return df_mrls
 
-@st.cache_data(ttl=1800)  # Cache de 30 minutes
-def get_mrls_for_product(product_id, time_filter=None):
-    """Récupère les LMR pour un produit spécifique avec gestion de la pagination."""
-    # Vérifier si le mode démo est activé
-    if hasattr(st.session_state, 'demo_mode') and st.session_state.demo_mode:
-        return load_demo_mrls(product_id, time_filter)
-    
-    url = f"{BASE_URL}/pesticide_residues_mrls"
-    params = {
-        "format": DEFAULT_FORMAT,
-        "product_id": product_id,
-        "api-version": API_VERSION
-    }
-    
-    all_mrls = []
-    next_link = None
-    
-    try:
-        with st.spinner("Chargement des LMR..."):
-            progress_bar = st.progress(0)
-            pages_processed = 0
-            
-            while True:
-                if next_link:
-                    response = make_api_request(next_link)
-                else:
-                    response = make_api_request(url, params)
-                
-                if not response:
-                    if not all_mrls:  # Si aucune donnée n'a été récupérée
-                        st.error("Impossible de récupérer les LMR pour ce produit. Veuillez réessayer plus tard.")
-                        return pd.DataFrame()
-                    else:  # Si des données partielles ont été récupérées
-                        st.warning("Récupération partielle des LMR. Certaines données peuvent manquer.")
-                        break
-                
-                data = response.json()
-                
-                # Récupérer les LMR de la page actuelle
-                mrls = data.get('value', [])
-                all_mrls.extend(mrls)
-                
-                # Vérifier s'il y a une page suivante
-                next_link = data.get('nextLink') or data.get('@odata.nextLink')
-                
-                # Mettre à jour la barre de progression
-                pages_processed += 1
-                progress_bar.progress(min(1.0, pages_processed / 10))  # Estimation de progression
-                
-                if not next_link:
-                    progress_bar.progress(1.0)
-                    break
-        
-        if not all_mrls:
-            st.info("Aucune LMR trouvée pour ce produit.")
-            return pd.DataFrame()
-        
-        # Convertir en DataFrame
-        df_mrls = pd.DataFrame(all_mrls)
-        
-        # Renommer les colonnes pour une utilisation cohérente
-        column_mapping = {
-            'pesticideResidueId': 'pesticide_residue_id',
-            'pesticide_Residue_Id': 'pesticide_residue_id',
-            'mrlValue': 'mrl_value',
-            'mrl_Value': 'mrl_value',
-            'applicationDate': 'application_date',
-            'application_Date': 'application_date',
-            'regulationNumber': 'regulation_number',
-            'regulation_Number': 'regulation_number'
-        }
-        
-        df_mrls = df_mrls.rename(columns={col: column_mapping[col] 
-                                          for col in column_mapping 
-                                          if col in df_mrls.columns})
-        
-        # Convertir les dates (gestion de différents formats possibles)
-        if 'application_date' in df_mrls.columns:
-            df_mrls['application_date'] = pd.to_datetime(df_mrls['application_date'], errors='coerce')
-        
-        # Ajouter le nom de la substance
-        if 'pesticide_residue_id' in df_mrls.columns:
-            df_mrls['substance_name'] = df_mrls['pesticide_residue_id'].apply(get_residue_name)
-        
-        # Appliquer le filtre temporel si spécifié
-        if time_filter and 'application_date' in df_mrls.columns:
-            today = datetime.datetime.now().date()
-            
-            if time_filter == 'last_week':
-                one_week_ago = today - datetime.timedelta(days=7)
-                df_mrls = df_mrls[df_mrls['application_date'].dt.date >= one_week_ago]
-            
-            elif time_filter == 'last_month':
-                one_month_ago = today - datetime.timedelta(days=30)
-                df_mrls = df_mrls[df_mrls['application_date'].dt.date >= one_month_ago]
-            
-            elif time_filter == 'next_six_months':
-                six_months_later = today + datetime.timedelta(days=180)
-                df_mrls = df_mrls[(df_mrls['application_date'].dt.date >= today) & 
-                                  (df_mrls['application_date'].dt.date <= six_months_later)]
-        
-        logger.info(f"Récupération réussie de {len(df_mrls)} LMR pour le produit {product_id}")
-        return df_mrls
-    
-    except Exception as e:
-        logger.error(f"Erreur lors de la récupération des LMR pour le produit {product_id}: {str(e)}")
-        st.error(f"Erreur lors de la récupération des LMR: {str(e)}")
-        return pd.DataFrame()
+    df = pd.DataFrame(mrl_data)
+    st.write(df)
 
-def make_api_request(url, params=None):
-    """Effectue une requête API avec gestion des erreurs et tentatives."""
-    # Récupérer la clé API 
-    api_key = get_api_key()
-    
-    # Ajouter les en-têtes d'authentification si une clé API est disponible
-    headers = {}
-    if api_key:
-        headers["Authorization"] = f"Bearer {api_key}"
-        # Selon l'API, il peut y avoir d'autres formats d'authentification comme :
-        # headers["X-API-Key"] = api_key
-        # ou
-        # headers["Ocp-Apim-Subscription-Key"] = api_key
-    
-    for attempt in range(RETRY_ATTEMPTS):
-        try:
-            response = requests.get(url, params=params, headers=headers)
-            
-            # Si nous obtenons une erreur 403 et que nous n'avons pas de clé API, 
-            # lever une exception spécifique
-            if response.status_code == 403 and not api_key:
-                raise Exception("Authentification requise pour accéder à l'API")
-            
-            response.raise_for_status()
-            return response
-        
-        except requests.exceptions.RequestException as e:
-            logger.warning(f"Tentative {attempt+1}/{RETRY_ATTEMPTS} échouée: {str(e)}")
-            
-            if attempt < RETRY_ATTEMPTS - 1:
-                time.sleep(RETRY_DELAY * (attempt + 1))  # Délai progressif
-            else:
-                logger.error(f"Échec de la requête après {RETRY_ATTEMPTS} tentatives: {url}")
-                return None
-        
-        except Exception as e:
-            logger.error(f"Erreur: {str(e)}")
-            return None
+    # Visualisation graphique
+    plt.figure(figsize=(10, 6))
+    for substance in df['Substance'].unique()[:10]:  # Limiter aux 10 substances les plus fréquentes
+        subset = df[df['Substance'] == substance]
+        plt.plot(subset['Date d'application'], subset['Valeur LMR'], label=substance)
+    plt.xlabel("Date d'application")
+    plt.ylabel("Valeur LMR")
+    plt.title("Évolution des LMR dans le temps")
+    plt.legend()
+    st.pyplot(plt)
 
-def generate_download_link(df, filename="pesticide_data.csv"):
-    """Génère un lien de téléchargement pour un DataFrame."""
+    # Téléchargement CSV
     csv = df.to_csv(index=False)
-    b64 = base64.b64encode(csv.encode()).decode()
-    href = f'<a href="data:file/csv;base64,{b64}" download="{filename}">Télécharger les données (CSV)</a>'
-    return href
-
-def create_mrls_chart(df_mrls):
-    """Crée un graphique montrant l'évolution des LMR dans le temps."""
-    if df_mrls.empty or 'application_date' not in df_mrls.columns or 'mrl_value' not in df_mrls.columns:
-        return None
-    
-    # Sélectionner les 10 substances les plus fréquentes
-    top_substances = df_mrls['substance_name'].value_counts().nlargest(10).index.tolist()
-    df_plot = df_mrls[df_mrls['substance_name'].isin(top_substances)]
-    
-    # Filtrer les valeurs NaN
-    df_plot = df_plot.dropna(subset=['application_date', 'mrl_value'])
-    
-    if df_plot.empty:
-        return None
-    
-    # Créer le graphique
-    fig = px.scatter(
-        df_plot,
-        x='application_date',
-        y='mrl_value',
-        color='substance_name',
-        hover_name='substance_name',
-        size_max=10,
-        title='Évolution des LMR par substance active',
-        labels={
-            'application_date': 'Date d\'application',
-            'mrl_value': 'Valeur LMR (mg/kg)',
-            'substance_name': 'Substance active'
-        }
-    )
-    
-    fig.update_layout(
-        xaxis_title='Date d\'application',
-        yaxis_title='Valeur LMR (mg/kg)',
-        legend_title='Substance active',
-        height=600
+    st.download_button(
+        label="Télécharger les données en CSV",
+        data=csv,
+        file_name="lmr_data.csv",
+        mime="text/csv",
     )
-    
-    return fig
-
-# Fonction principale de l'application
-def main():
-    # Barre latérale
-    with st.sidebar:
-        st.image("https://european-union.europa.eu/sites/default/files/styles/oe_theme_medium_no_crop/public/2021-12/Flag_of_Europe.png", width=150)
-        st.title("Pesticide Data Explorer")
-        st.markdown("Application pour explorer les données de pesticides de l'Union Européenne.")
-        
-        # Section d'authentification
-        st.subheader("Authentification API")
-        api_key = st.text_input("Clé API (obligatoire)", 
-                              type="password", 
-                              help="Entrez votre clé API pour accéder aux données")
-        st.session_state.api_key = api_key
-        
-        st.info("""
-        Pour obtenir une clé API, inscrivez-vous sur le portail européen des données 
-        et demandez l'accès à l'API des pesticides.
-        """)
-        
-        # Mode démonstration
-        st.subheader("Mode démonstration")
-        use_demo = st.checkbox("Utiliser des données de démonstration", 
-                              help="Activez cette option pour utiliser des données fictives et tester l'application sans clé API")
-        if use_demo:
-            st.session_state.demo_mode = True
-            st.success("Mode démonstration activé!")
-        else:
-            st.session_state.demo_mode = False
-        
-        # Bouton de réinitialisation du cache
-        if st.button("Réinitialiser le cache"):
-            st.cache_data.clear()
-            st.success("Cache réinitialisé avec succès!")
-    
-    # Titre principal
-    st.title("Base de données des pesticides de l'UE")
-    st.markdown("Explorez les Limites Maximales de Résidus (LMR) par produit agricole")
-    
-    # Vérifier si le mode démo est activé ou si une clé API est fournie
-    if not ((hasattr(st.session_state, 'demo_mode') and st.session_state.demo_mode) or get_api_key()):
-        st.error("""
-        ⚠️ Authentification requise! 
-        
-        Cette API nécessite une clé d'accès. Veuillez soit:
-        1. Entrer votre clé API dans la barre latérale pour accéder aux données réelles, ou
-        2. Activer le "Mode démonstration" pour utiliser des données fictives.
-        
-        Erreur actuelle: 403 Forbidden - L'accès à l'API est refusé sans authentification valide.
-        """)
-        
-        # Afficher une section d'aide pour obtenir une clé API
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.subheader("Option 1: Obtenir une clé API")
-            st.markdown("""
-            1. Rendez-vous sur le [Portail des données de l'UE](https://data.europa.eu/)
-            2. Créez un compte ou connectez-vous
-            3. Naviguez vers la section API des pesticides
-            4. Demandez une clé d'accès pour l'API
-            5. Copiez la clé dans le champ "Clé API" dans la barre latérale
-            """)
-        
-        with col2:
-            st.subheader("Option 2: Mode démonstration")
-            st.markdown("""
-            1. Activez l'option "Utiliser des données de démonstration" dans la barre latérale
-            2. Utilisez l'application avec des données fictives pour tester les fonctionnalités
-            3. Notez que les données affichées ne seront pas réelles
-            """)
-            
-            if st.button("Activer le mode démonstration"):
-                st.session_state.demo_mode = True
-                st.experimental_rerun()
-                
-        return
-    
-    # Afficher un message si en mode démonstration
-    if hasattr(st.session_state, 'demo_mode') and st.session_state.demo_mode:
-        st.warning("""
-        🔍 **Mode démonstration activé** 
-        
-        Vous utilisez des données fictives pour tester l'application. 
-        Les valeurs affichées ne correspondent pas aux données réelles de l'API de l'UE.
-        
-        Pour accéder aux données réelles, désactivez le mode démonstration et fournissez une clé API valide.
-        """)
-        
-    # Récupération de la liste des produits
-    df_products = get_products()
-    
-    if df_products.empty and not (hasattr(st.session_state, 'demo_mode') and st.session_state.demo_mode):
-        st.warning("Aucun produit disponible. Veuillez vérifier votre clé API ou la connexion à l'API.")
-        
-        # Ajouter des options alternatives
-        st.subheader("Options alternatives")
-        st.markdown("""
-        Si vous rencontrez des difficultés pour accéder à l'API en direct, vous pouvez:
-        
-        1. **Activer le mode démonstration** dans la barre latérale pour tester les fonctionnalités
-        2. Accéder directement aux données via le site web de l'UE:
-           - [Base de données des pesticides de l'UE](https://ec.europa.eu/food/plant/pesticides/eu-pesticides-database/products/)
-           - [Téléchargement direct des fichiers CSV](https://ec.europa.eu/food/plant/pesticides/eu-pesticides-database/products/download/)
-        """)
-        
-        if st.button("Activer le mode démonstration", key="demo_btn_alt"):
-            st.session_state.demo_mode = True
-            st.experimental_rerun()
-            
-        return
-    
-    # Interface de sélection
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        # Sélection du produit
-        product_options = [(row['product_id'], row['product_name']) 
-                          for _, row in df_products.iterrows()]
-        selected_product_id = st.selectbox(
-            "Sélectionnez un produit agricole",
-            options=[id for id, _ in product_options],
-            format_func=lambda x: next((name for id, name in product_options if id == x), str(x))
-        )
-    
-    with col2:
-        # Filtre temporel
-        time_filter = st.radio(
-            "Période",
-            options=[
-                ("all", "Toutes dates"), 
-                ("last_week", "Dernière semaine"), 
-                ("last_month", "Dernier mois"), 
-                ("next_six_months", "6 prochains mois")
-            ],
-            format_func=lambda x: x[1],
-            index=0
-        )
-    
-    # Bouton pour lancer l'analyse
-    if st.button("Analyser les données", type="primary"):
-        # Récupérer les LMR pour le produit sélectionné
-        df_mrls = get_mrls_for_product(selected_product_id, time_filter[0] if time_filter[0] != "all" else None)
-        
-        if df_mrls.empty:
-            st.info(f"Aucune donnée LMR trouvée pour ce produit avec les filtres sélectionnés.")
-            return
-        
-        # Afficher les résultats
-        st.subheader("Limites Maximales de Résidus (LMR)")
-        
-        # Formater les données pour l'affichage
-        display_df = df_mrls.copy()
-        
-        # Formater les liens vers les règlements
-        if 'regulation_number' in display_df.columns:
-            display_df['regulation_number'] = display_df['regulation_number'].apply(
-                lambda x: f'<a href="https://eur-lex.europa.eu/search.html?qid=1673437220860&text={x}&scope=EURLEX&type=quick&lang=fr" target="_blank">{x}</a>' if x else "")
-        
-        # Sélectionner et renommer les colonnes pour l'affichage
-        columns_to_display = {
-            'substance_name': 'Substance active',
-            'mrl_value': 'LMR (mg/kg)',
-            'application_date': 'Date d\'application',
-            'regulation_number': 'Règlement'
-        }
-        
-        display_df = display_df[[col for col in columns_to_display.keys() if col in display_df.columns]]
-        display_df = display_df.rename(columns=columns_to_display)
-        
-        # Formater la date
-        if 'Date d\'application' in display_df.columns:
-            display_df['Date d\'application'] = display_df['Date d\'application'].dt.strftime('%d/%m/%Y')
-        
-        # Afficher le tableau avec liens cliquables
-        st.markdown(display_df.to_html(escape=False, index=False), unsafe_allow_html=True)
-        
-        # Afficher le nombre total de LMR
-        st.info(f"Nombre total de LMR: {len(df_mrls)}")
-        
-        # Lien de téléchargement
-        st.markdown(generate_download_link(df_mrls), unsafe_allow_html=True)
-        
-        # Graphique d'évolution des LMR
-        st.subheader("Évolution des LMR dans le temps")
-        fig = create_mrls_chart(df_mrls)
-        
-        if fig:
-            st.plotly_chart(fig, use_container_width=True)
-        else:
-            st.info("Pas assez de données pour générer un graphique.")
-
-if __name__ == "__main__":
-    main()