Update app.py

app.py

@@ -53,15 +53,15 @@ class PesticideDataFetcher:
         self._product_cache: Dict[int, Dict[str, Any]] = {}
         self._mrl_cache: Dict[int, List[Dict[str, Any]]] = {}
         self.use_cache = use_cache
-        
+
         # Création du répertoire de cache si nécessaire
         if not os.path.exists(self.CACHE_DIR):
             os.makedirs(self.CACHE_DIR)
-            
+
         # Chargement des caches si disponibles
         if use_cache:
             self._load_caches()
-            
+
         # Préchargement des substances si le cache est vide
         if not self._substance_cache:
             self.preload_substance_names()
@@ -75,12 +75,12 @@ class PesticideDataFetcher:
                     for substance_id, substance_info in substance_data.items():
                         self._substance_cache[int(substance_id)] = SubstanceDetails(**substance_info)
                 logger.info(f"Cache de substances chargé: {len(self._substance_cache)} substances")
-                
+
             if os.path.exists(self.PRODUCT_CACHE_FILE):
                 with open(self.PRODUCT_CACHE_FILE, 'r', encoding='utf-8') as f:
                     self._product_cache = {int(k): v for k, v in json.load(f).items()}
                 logger.info(f"Cache de produits chargé: {len(self._product_cache)} produits")
-                
+
             if os.path.exists(self.MRL_CACHE_FILE):
                 with open(self.MRL_CACHE_FILE, 'r', encoding='utf-8') as f:
                     self._mrl_cache = {int(k): v for k, v in json.load(f).items()}
@@ -108,16 +108,16 @@ class PesticideDataFetcher:
                 }
                 for substance_id, details in self._substance_cache.items()
             }
-            
+
             with open(self.SUBSTANCE_CACHE_FILE, 'w', encoding='utf-8') as f:
                 json.dump(substance_data, f, ensure_ascii=False, indent=2)
-                
+
             with open(self.PRODUCT_CACHE_FILE, 'w', encoding='utf-8') as f:
                 json.dump({str(k): v for k, v in self._product_cache.items()}, f, ensure_ascii=False, indent=2)
-                
+
             with open(self.MRL_CACHE_FILE, 'w', encoding='utf-8') as f:
                 json.dump({str(k): v for k, v in self._mrl_cache.items()}, f, ensure_ascii=False, indent=2)
-                
+
             logger.info("Tous les caches ont été sauvegardés avec succès")
         except Exception as e:
             logger.error(f"Erreur lors de la sauvegarde des caches: {e}")
@@ -158,7 +158,7 @@ class PesticideDataFetcher:
                         ec_number=substance.get("ecNumber")
                     )
                     substances_loaded += 1
-                    
+
                     # Chargement des détails supplémentaires pour chaque substance
                     self._load_substance_details(substance_id)
 
@@ -167,7 +167,7 @@ class PesticideDataFetcher:
 
         if self.use_cache:
             self._save_caches()
-            
+
         logger.info(f"Préchargement terminé. Total des substances: {len(self._substance_cache)}")
 
     def _load_substance_details(self, substance_id: int) -> None:
@@ -175,7 +175,7 @@ class PesticideDataFetcher:
         url = f"{self.BASE_URL}/pesticide_residues/{substance_id}?format=json&language=FR&api-version=v2.0"
         try:
             data = self.fetch_data(url)
-            
+
             substance = self._substance_cache.get(substance_id)
             if substance:
                 substance.approval_date = data.get("approvalDate")
@@ -190,14 +190,14 @@ class PesticideDataFetcher:
         """Récupère le nom d'une substance à partir de son ID"""
         if substance_id in self._substance_cache:
             return self._substance_cache[substance_id].name
-            
+
         # Si la substance n'est pas dans le cache, essayer de la récupérer
         try:
             url = f"{self.BASE_URL}/pesticide_residues/{substance_id}?format=json&language=FR&api-version=v2.0"
             data = self.fetch_data(url)
-            
+
             substance_name = data.get("pesticideResidueName", f"Substance {substance_id}")
-            
+
             # Mettre à jour le cache
             self._substance_cache[substance_id] = SubstanceDetails(
                 name=substance_name,
@@ -208,42 +208,42 @@ class PesticideDataFetcher:
                 cas_number=data.get("casNumber"),
                 ec_number=data.get("ecNumber")
             )
-            
+
             if self.use_cache:
                 self._save_caches()
-                
+
             return substance_name
         except Exception as e:
             logger.error(f"Erreur lors de la récupération de la substance {substance_id}: {e}")
             return f"Substance inconnue ({substance_id})"
-    
+
     def get_product_list(self) -> List[Dict[str, Any]]:
         """Récupère la liste de tous les produits"""
         if self._product_cache:
             return list(self._product_cache.values())
-            
+
         logger.info("Récupération de la liste des produits...")
         url = f"{self.BASE_URL}/pesticide_residues_products?format=json&language=FR&api-version=v2.0"
         products_loaded = 0
-        
+
         while url:
             data = self.fetch_data(url)
             if "error" in data:
                 logger.error(f"Erreur produits: {data.get('error', 'Aucune info')}")
                 break
-                
+
             for product in data.get("value", []):
                 product_id = product.get("productId")
                 if product_id:
                     self._product_cache[product_id] = product
                     products_loaded += 1
-                    
+
             url = data.get("nextLink")
             logger.info(f"Produits récupérés jusqu'à présent: {products_loaded}")
-            
+
         if self.use_cache:
             self._save_caches()
-            
+
         logger.info(f"Total des produits récupérés: {len(self._product_cache)}")
         return list(self._product_cache.values())
 
@@ -252,26 +252,26 @@ class PesticideDataFetcher:
         # Vérifier d'abord dans le cache
         if product_id in self._mrl_cache:
             return self._mrl_cache[product_id]
-            
+
         logger.info(f"Récupération des LMR pour le produit {product_id}...")
         url = f"{self.BASE_URL}/pesticide_residues_products/{product_id}/mrls?format=json&language=FR&api-version=v2.0"
-        
+
         mrls = []
         while url:
             data = self.fetch_data(url)
             if "error" in data:
                 logger.error(f"Erreur lors de la récupération des LMR: {data.get('error', 'Aucune info')}")
                 break
-                
+
             mrls.extend(data.get("value", []))
             url = data.get("nextLink")
-            
+
         # Mise à jour du cache
         self._mrl_cache[product_id] = mrls
-        
+
         if self.use_cache:
             self._save_caches()
-            
+
         logger.info(f"LMR récupérées pour le produit {product_id}: {len(mrls)}")
         return mrls
 
@@ -283,22 +283,22 @@ class PesticideDataFetcher:
             if query in substance.name.lower()
         ]
         return sorted(results, key=lambda x: x.name)
-        
-    def get_substance_mrls(self, substance_id: int) -> Dict[str, Any]:
+
+    def get_substance_mrls(self, substance_id: int) -> List[Dict[str,Any]]: #Changed List to Dict
         """Récupère tous les produits avec LMR pour une substance donnée"""
         logger.info(f"Récupération des LMR pour la substance {substance_id}...")
         url = f"{self.BASE_URL}/pesticide_residues/{substance_id}/mrls?format=json&language=FR&api-version=v2.0"
-        
+
         all_mrls = []
         while url:
             data = self.fetch_data(url)
             if "error" in data:
                 logger.error(f"Erreur lors de la récupération des LMR: {data.get('error', 'Aucune info')}")
                 break
-                
+
             all_mrls.extend(data.get("value", []))
             url = data.get("nextLink")
-        
+
         logger.info(f"LMR récupérées pour la substance {substance_id}: {len(all_mrls)}")
         return all_mrls
 
@@ -316,7 +316,7 @@ class PesticideApp:
     def __init__(self, use_cache: bool = True):
         logger.info("Initialisation de l'application...")
         self.fetcher = PesticideDataFetcher(use_cache=use_cache)
-        
+
         # Récupération de la liste des produits
         logger.info("Récupération de la liste des produits...")
         products = self.fetcher.get_product_list()
@@ -324,12 +324,12 @@ class PesticideApp:
             p.get('productName', 'Sans nom'): p.get('productId', 0)
             for p in products
         }
-        
+
         # Préparation de la liste des substances
         self.substances = sorted([
             sd.name for sd in self.fetcher._substance_cache.values()
         ])
-        
+
         logger.info(f"Application initialisée avec {len(self.product_list)} produits et {len(self.substances)} substances")
 
     def format_date(self, date_str: Optional[str]) -> str:
@@ -342,17 +342,17 @@ class PesticideApp:
         product_id = self.product_list.get(product_name)
         if not product_id:
             return pd.DataFrame([{"Erreur": "Produit non trouvé"}])
-        
+
         mrls = self.fetcher.get_mrls(product_id)
         if not mrls:
             return pd.DataFrame([{"Erreur": "Aucune donnée LMR trouvée"}])
-        
+
         data = []
         for mrl in mrls:
             substance_id = mrl.get("pesticideResidueId", 0)
             substance_name = self.fetcher.get_substance_name(substance_id)
             substance = self.fetcher._substance_cache.get(substance_id)
-            
+
             data.append({
                 "Substance": substance_name,
                 "Valeur LMR": mrl.get("mrlValue", "N/C"),
@@ -364,7 +364,7 @@ class PesticideApp:
                 "Date d'approbation": self.format_date(getattr(substance, "approval_date", None)),
                 "Date d'expiration": self.format_date(getattr(substance, "expiry_date", None))
             })
-        
+
         df = pd.DataFrame(data)
         logger.info(f"Détails récupérés pour {product_name}: {len(df)} entrées")
         return df
@@ -374,11 +374,11 @@ class PesticideApp:
         logger.info(f"Recherche de substances: {substance_query}")
         if not substance_query or len(substance_query) < 3:
             return pd.DataFrame([{"Message": "Veuillez entrer au moins 3 caractères pour la recherche"}])
-            
+
         results = self.fetcher.search_substances(substance_query)
         if not results:
             return pd.DataFrame([{"Message": "Aucune substance trouvée"}])
-            
+
         data = []
         for substance in results:
             data.append({
@@ -390,34 +390,35 @@ class PesticideApp:
                 "Date d'approbation": self.format_date(substance.approval_date),
                 "Date d'expiration": self.format_date(substance.expiry_date)
             })
-            
+
         df = pd.DataFrame(data)
         logger.info(f"Résultats de la recherche pour '{substance_query}': {len(df)} substances trouvées")
         return df
 
     def get_substance_mrls(self, substance_id: int) -> pd.DataFrame:
-        """Récupère tous les produits avec LMR pour une substance donnée"""
+        """Récupère tous les produits avec LMR pour une substance donnée et retourne un DataFrame."""
         logger.info(f"Récupération des LMR pour la substance ID: {substance_id}")
         if not substance_id:
             return pd.DataFrame([{"Erreur": "ID de substance non valide"}])
-            
+
         substance = self.fetcher._substance_cache.get(substance_id)
         if not substance:
             return pd.DataFrame([{"Erreur": "Substance non trouvée"}])
-            
-        mrls = self.fetcher.get_substance_mrls(substance_id)
-        if not mrls:
+
+        all_mrls = self.fetcher.get_substance_mrls(substance_id)  # Récupère la liste brute
+        if not all_mrls:
             return pd.DataFrame([{"Message": f"Aucune LMR trouvée pour {substance.name}"}])
-            
+
+        # Conversion en DataFrame ici:
         data = []
-        for mrl in mrls:
+        for mrl in all_mrls:
             product_id = mrl.get("productId")
             product_name = "Inconnu"
-            
+
             # Récupérer le nom du produit si possible
             if product_id in self.fetcher._product_cache:
                 product_name = self.fetcher._product_cache[product_id].get("productName", "Inconnu")
-                
+
             data.append({
                 "Produit": product_name,
                 "Valeur LMR": mrl.get("mrlValue", "N/C"),
@@ -425,10 +426,10 @@ class PesticideApp:
                 "Date d'effet": self.format_date(mrl.get("entryIntoForceDate")),
                 "Notes": mrl.get("footnotes", "")
             })
-            
-        df = pd.DataFrame(data)
+
+        df = pd.DataFrame(data)  # Crée le DataFrame
         logger.info(f"LMR récupérées pour {substance.name}: {len(df)} entrées")
-        return df
+        return df # MODIFICATION: retourner le dataframe
 
     def create_histogram(self, df: pd.DataFrame) -> go.Figure:
         """Crée un histogramme des valeurs LMR"""
@@ -436,7 +437,7 @@ class PesticideApp:
             fig = go.Figure()
             fig.update_layout(title="Aucune donnée disponible pour l'histogramme")
             return fig
-            
+
         # Convertir les valeurs LMR en nombres si possible
         numeric_values = []
         for val in df["Valeur LMR"]:
@@ -450,12 +451,12 @@ class PesticideApp:
                     numeric_values.append(float(val))
             except (ValueError, TypeError):
                 continue
-                
+
         if not numeric_values:
             fig = go.Figure()
             fig.update_layout(title="Aucune valeur numérique disponible pour l'histogramme")
             return fig
-            
+
         # Création de l'histogramme
         fig = go.Figure(data=[go.Histogram(x=numeric_values, nbinsx=20)])
         fig.update_layout(
@@ -472,16 +473,16 @@ class PesticideApp:
             fig = go.Figure()
             fig.update_layout(title=f"Aucune donnée disponible pour {column}")
             return fig
-            
+
         # Compter les valeurs
         value_counts = df[column].value_counts()
-        
+
         # Création du graphique
         fig = go.Figure(data=[go.Pie(
             labels=value_counts.index,
             values=value_counts.values
         )])
-        
+
         fig.update_layout(title=f"Répartition par {column}")
         return fig
 
@@ -494,7 +495,7 @@ class PesticideApp:
                     <p>Consultez les limites maximales de résidus (LMR) de pesticides dans les produits alimentaires</p>
                 </div>
             """)
-            
+
             with gr.Tab("Recherche par Produit"):
                 with gr.Row():
                     with gr.Column(scale=3):
@@ -505,20 +506,20 @@ class PesticideApp:
                         )
                     with gr.Column(scale=1):
                         search_btn = gr.Button("Rechercher", variant="primary")
-                
+
                 with gr.Row():
                     output = gr.Dataframe(
                         headers=["Substance", "Valeur LMR", "Unité", "Date d'effet", "Statut"],
                         max_rows=20,
                         interactive=False
                     )
-                
+
                 with gr.Row():
                     with gr.Column():
                         histogram = gr.Plot(label="Distribution des LMR")
                     with gr.Column():
                         status_pie = gr.Plot(label="Statut des substances")
-                
+
                 search_btn.click(
                     fn=lambda p: (
                         self.get_product_details(p),
@@ -528,7 +529,7 @@ class PesticideApp:
                     inputs=[product],
                     outputs=[output, histogram, status_pie]
                 )
-            
+
             with gr.Tab("Recherche par Substance"):
                 with gr.Row():
                     with gr.Column(scale=3):
@@ -539,69 +540,69 @@ class PesticideApp:
                         )
                     with gr.Column(scale=1):
                         substance_search_btn = gr.Button("Rechercher", variant="primary")
-                
+
                 substance_results = gr.Dataframe(
                     headers=["ID", "Nom", "Statut", "N° CAS", "N° EC", "Date d'approbation", "Date d'expiration"],
                     max_rows=15,
                     interactive=True
                 )
-                
+
                 substance_select = gr.Number(label="ID de la substance sélectionnée", interactive=True, visible=False)
                 substance_mrls_btn = gr.Button("Voir les LMR pour cette substance", visible=True)
-                
+
                 substance_mrls = gr.Dataframe(
                     headers=["Produit", "Valeur LMR", "Unité", "Date d'effet", "Notes"],
                     max_rows=20,
                     interactive=False
                 )
-                
+
                 mrl_histogram = gr.Plot(label="Distribution des LMR par produit")
-                
+
                 # Événements
                 substance_search_btn.click(
                     fn=self.search_substance,
                     inputs=[substance_query],
                     outputs=[substance_results]
                 )
-                
+
                 # Mise à jour de l'ID de substance sélectionné
                 substance_results.select(
                     fn=lambda evt: evt["data"]["ID"] if evt and "data" in evt and "ID" in evt["data"] else None,
                     inputs=[],
                     outputs=[substance_select]
                 )
-                
+
                 substance_mrls_btn.click(
                     fn=lambda sid: (
-                        self.get_substance_mrls(sid),
-                        self.create_histogram(self.get_substance_mrls(sid))
+                        self.get_substance_mrls(int(sid)), #MODIFICATION: int() conversion
+                        self.create_histogram(self.get_substance_mrls(int(sid))) #MODIFICATION : int() conversion
                     ),
                     inputs=[substance_select],
                     outputs=[substance_mrls, mrl_histogram]
                 )
-            
+
             with gr.Tab("À propos"):
                 gr.HTML("""
                     <div style="padding: 20px;">
                         <h2>À propos de cette application</h2>
-                        <p>Cette application permet de consulter les limites maximales de résidus (LMR) des pesticides 
+                        <p>Cette application permet de consulter les limites maximales de résidus (LMR) des pesticides
                         autorisés dans les produits alimentaires dans l'Union européenne.</p>
-                        
+
                         <h3>Sources de données</h3>
                         <p>Les données sont extraites de l'API officielle de la Commission européenne:</p>
                         <ul>
                             <li>API Pesticides: <a href="https://api.datalake.sante.service.ec.europa.eu/sante/pesticides">
                             https://api.datalake.sante.service.ec.europa.eu/sante/pesticides</a></li>
                         </ul>
-                        
+
                         <h3>Comment utiliser cette application</h3>
                         <ul>
-                            <li><strong>Recherche par Produit</strong>: Sélectionnez un produit alimentaire pour voir 
+                            <li><strong>Recherche par Produit</strong>: Sélectionnez un produit alimentaire pour voir
                             toutes les substances et leurs LMR associées.</li>
-                            <li><strong>Recherche par Substance</strong>: Recherchez une substance active pour voir son 
+                            <li><strong>Recherche par Substance</strong>: Recherchez une substance active pour voir son
                             statut et les produits dans lesquels elle est réglementée.</li>
                         </ul>
-                        
+
                         <h3>Légende</h3>
                         <ul>
                             <li><strong>LMR</strong>: Limite Maximale de Résidus, exprimée généralement en mg/kg</li>
@@ -610,13 +611,13 @@ class PesticideApp:
                         </ul>
                     </div>
                 """)
-        
+
         return ui
 
 def main():
     # Paramètres de ligne de commande (vous pourriez les ajouter via argparse)
     use_cache = True  # Utiliser le cache par défaut
-    
+
     try:
         app = PesticideApp(use_cache=use_cache)
         logger.info("Lancement de l'interface utilisateur...")