Update app.py

app.py

@@ -30,10 +30,45 @@ DEFAULT_FORMAT = "json"
 RETRY_ATTEMPTS = 3
 RETRY_DELAY = 2  # secondes
 
+# 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
+
 # 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)
+
 @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,
@@ -129,9 +164,82 @@ def get_residue_name(residue_id):
         logger.error(f"Erreur lors de la récupération du nom de la substance {residue_id}: {str(e)}")
         return f"Substance {residue_id}"
 
+# 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
+        })
+    
+    # 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,
@@ -236,9 +344,27 @@ def get_mrls_for_product(product_id, time_filter=None):
 
 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)
+            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
         
@@ -250,6 +376,10 @@ def make_api_request(url, params=None):
             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
 
 def generate_download_link(df, filename="pesticide_data.csv"):
     """Génère un lien de téléchargement pour un DataFrame."""
@@ -306,6 +436,28 @@ def main():
         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()
@@ -315,11 +467,77 @@ def main():
     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:
-        st.warning("Aucun produit disponible. Veuillez vérifier la connexion à l'API.")
+    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
@@ -403,5 +621,4 @@ def main():
             st.info("Pas assez de données pour générer un graphique.")
 
 if __name__ == "__main__":
-    main()
-    
+    main()