Update app.py

app.py

@@ -1,113 +1,543 @@
-import streamlit as st
+import logging
+import json
+import io
+import zipfile
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any, Tuple
 import pandas as pd
 import requests
-from datetime import datetime
+import plotly.express as px
+import streamlit as st
+from tenacity import retry, stop_after_attempt, wait_exponential
+import time
+from collections import defaultdict
+import hashlib
 
-st.set_page_config(page_title="Test Pesticides API", page_icon="🌿", layout="wide")
+# Configuration Streamlit
+st.set_page_config(page_title="Pesticide Data Explorer - Optimized", page_icon="🌿", layout="wide")
 
-def test_api():
-    """Test simple de l'API"""
-    BASE_URL = "https://api.datalake.sante.service.ec.europa.eu/sante/pesticides"
+# Configuration logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler("pesticide_app_optimized.log", encoding="utf-8"),
+        logging.StreamHandler()
+    ],
+)
+logger = logging.getLogger(__name__)
+
+class PesticideDataFetcher:
+    """Fetcher optimisé utilisant les endpoints de téléchargement bulk"""
     
-    # Test 1: Récupérer quelques produits
-    st.write("### Test 1: Récupération des produits")
-    try:
-        url = f"{BASE_URL}/pesticide_residues_products"
+    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"
+    }
+
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update(self.HEADERS)
+        self.api_calls = 0
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+    def download_data(self, endpoint: str, params: Dict) -> Optional[Any]:
+        """Télécharge les données depuis un endpoint de download"""
+        url = f"{self.BASE_URL}{endpoint}"
+        
+        try:
+            self.api_calls += 1
+            logger.info(f"Téléchargement depuis {endpoint} (appel API #{self.api_calls})")
+            
+            response = self.session.get(url, params=params, timeout=120)  # Timeout plus long pour les gros fichiers
+            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:
+                            return content
+            
+            else:
+                # Par défaut, retourner le contenu brut
+                return response.text
+                
+        except requests.RequestException as e:
+            logger.error(f"Erreur lors du téléchargement {endpoint}: {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]}...")
+            return None
+
+    def get_products_paginated(self, language: str = 'FR') -> List[Dict]:
+        """Récupère tous les produits avec pagination (pas d'endpoint download)"""
+        all_products = []
+        url = f"{self.BASE_URL}/pesticide_residues_products"
         params = {
             'format': 'json',
-            'language': 'FR',
+            'language': language,
             'api-version': 'v2.0'
         }
-        response = requests.get(url, params=params, timeout=30)
+        
+        # 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:
-            products = data['value'][:5]  # Prendre seulement 5 produits
-            st.success(f"✅ Récupéré {len(data['value'])} produits")
-            st.write("Exemples de produits:")
-            for p in products:
-                st.write(f"- {p.get('product_name', 'N/A')} (ID: {p.get('product_id', 'N/A')})")
+            all_products.extend(data['value'])
+            
+            # 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:
-            st.error("Format de données inattendu")
-            st.json(data)
-    except Exception as e:
-        st.error(f"Erreur: {e}")
+            # 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")
+        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"""
     
-    # Test 2: Télécharger les substances
-    st.write("### Test 2: Téléchargement des substances")
-    try:
-        url = f"{BASE_URL}/active_substances/download"
-        params = {
-            'format': 'json',
-            'api-version': 'v2.0'
+    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 []
+            
+            results['substances'] = {
+                item['substance_id']: item['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)...")
+        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)
+        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')
         }
-        response = requests.get(url, params=params, timeout=60)
-        response.raise_for_status()
-        substances = response.json()
+        logger.info(f"✓ {len(results['products'])} produits récupérés")
         
-        if isinstance(substances, list):
-            st.success(f"✅ Téléchargé {len(substances)} substances")
-            # Afficher quelques exemples
-            for s in substances[:5]:
-                st.write(f"- {s.get('substance_name', 'N/A')} (ID: {s.get('substance_id', 'N/A')})")
-        else:
-            st.warning("Format inattendu pour les substances")
-            st.json(substances)
-    except Exception as e:
-        st.error(f"Erreur: {e}")
+        # 4. Statistiques
+        results['stats'] = {
+            'api_calls': fetcher.api_calls,
+            'substances_count': len(results.get('substances', {})),
+            'mrls_count': len(results.get('mrls', [])),
+            '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!")
+        
+    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()
     
-    # Test 3: Télécharger un échantillon de LMR
-    st.write("### Test 3: Téléchargement des LMR")
-    try:
-        url = f"{BASE_URL}/pesticide_residues_mrls"
-        params = {
-            'format': 'json',
-            'language': 'FR',
-            'api-version': 'v2.0',
-            'product_id': 110000  # Fruits
+    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')
         }
-        response = requests.get(url, params=params, timeout=30)
-        response.raise_for_status()
-        data = response.json()
         
-        if 'value' in data:
-            mrls = data['value'][:10]
-            st.success(f"✅ Récupéré {len(data['value'])} LMR pour les fruits")
+        logger.info(f"Index créés: {len(self.mrls_by_product)} produits avec LMR")
+
+    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]
+        
+        # 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)
+        
+        if not all_mrls:
+            st.info("Aucune donnée de LMR trouvée pour les produits sélectionnés.")
+            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")
+        
+        # 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()
+            future_date = now + timedelta(days=180)
+            df = df[
+                (df["Date d'application"] > now) &
+                (df["Date d'application"] <= future_date)
+            ]
             
-            # Créer un DataFrame simple
-            if mrls:
-                df = pd.DataFrame(mrls)
-                st.write("Colonnes disponibles:")
-                st.write(list(df.columns))
+            if df.empty:
+                st.info(f"🔍 Aucun changement de LMR prévu dans les 6 prochains mois.")
+                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")
+        
+        # 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() 
+        
+        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]
+        )
+        
+        return df
+
+    def create_interface(self):
+        st.title("🌿 EU Pesticides Database Explorer - Version Optimisée")
+        
+        # Afficher les statistiques
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("📦 Produits", f"{self.data['stats']['products_count']:,}")
+        with col2:
+            st.metric("🧪 Substances", f"{self.data['stats']['substances_count']:,}")
+        with col3:
+            st.metric("📊 LMR totales", f"{self.data['stats']['mrls_count']:,}")
+        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.markdown("---")
+        
+        # Interface de sélection
+        col1, col2 = st.columns([3, 1])
+        with col1:
+            # Recherche avec autocomplétion
+            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:
+            future_only = st.checkbox(
+                "📅 6 prochains mois",
+                value=False,
+                help="Afficher uniquement les changements prévus"
+            )
+        
+        # Affichage des résultats
+        if product_names:
+            df = self.get_product_details(product_names, future_only)
+            
+            if not df.empty:
+                st.markdown("### 📊 Résultats")
+                
+                # Statistiques rapides
+                # Filtrer les NaNs pour les calculs de statistiques
+                df_numeric_mrl = df[df["Valeur LMR"].notna()]
+
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("Entrées trouvées", len(df))
+                with 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")
                 
-                # Afficher quelques données
-                cols_to_show = ['product_id', 'pesticide_residue_id', 'mrl_value', 'regulation_number']
-                cols_to_show = [col for col in cols_to_show if col in df.columns]
+                # 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)
                 
-                if cols_to_show:
-                    st.dataframe(df[cols_to_show].head())
+                # Appliquer les filtres
+                if not show_zero and "Valeur LMR" in df.columns:
+                    df = df[df["Valeur LMR"] != 0.01]
+                
+                if sort_by in df.columns:
+                    df = df.sort_values(sort_by, ascending=(sort_order == "Croissant"))
+                
+                # Afficher le tableau
+                st.dataframe(
+                    df,
+                    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"
+                        ),
+                        "Date d'application": st.column_config.DateColumn(
+                            "Date d'application",
+                            format="DD/MM/YYYY"
+                        ),
+                        "Règlement": st.column_config.LinkColumn(
+                            "Règlement",
+                            help="Cliquez pour voir le règlement officiel"
+                        )
+                    }
+                )
+                
+                # 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.dataframe(df.head())
+                    st.info("Sélectionnez plus de données (au moins 2 entrées) pour générer des visualisations.")
+                
+                # Export
+                csv = df.to_csv(index=False)
+                st.download_button(
+                    label="📥 Télécharger (CSV)",
+                    data=csv,
+                    file_name=f"pesticides_lmr_{datetime.now().strftime('%Y%m%d')}.csv",
+                    mime="text/csv"
+                )
         else:
-            st.warning("Format inattendu pour les LMR")
-            st.json(data)
-    except Exception as e:
-        st.error(f"Erreur: {e}")
+            # 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()
+                }
+                top_products = sorted(
+                    product_mrl_count.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:
+                        product_name = self.data['product_dict'].get(pid, f"ID: {pid}")
+                        st.write(f"- {product_name}: {count} LMR")
+
+    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.
+        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).")
+            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
+                    )
+                    st.plotly_chart(fig, use_container_width=True)
+                else:
+                    st.info("Pas de données temporelles valides disponibles pour cette visualisation après filtrage.")
+            else:
+                st.info("Pas de données temporelles 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"}
+            )
+            st.plotly_chart(fig, 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
+                )
+                st.plotly_chart(fig2, 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
+                    }
+                )
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.info("Pas assez de données pour afficher le Top substances.")
 
 def main():
-    st.title("🌿 Test Simple de l'API Pesticides EU")
-    
-    if st.button("🔍 Lancer les tests"):
-        test_api()
+    # 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)
+        """)
+        
+        if st.button("🔄 Forcer le rechargement des données"):
+            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']}")
     
-    st.markdown("---")
-    st.info("""
-    Cette version de test vérifie:
-    1. La connexion à l'API
-    2. Le format des données reçues
-    3. Les colonnes disponibles dans les données
-    """)
+    # Interface principale
+    interface = PesticideInterface()
+    interface.create_interface()
 
 if __name__ == "__main__":
     main()