Update app.py

app.py

@@ -42,7 +42,11 @@ class PesticideDataFetcher:
             response = self.session.get(url, timeout=10)
             response.raise_for_status()
             data = response.json()
-            logger.info(f"Réponse API pour {url}: {data[:200]}")
+            # Correction du slicing et vérification du type de `data`
+            if isinstance(data, dict):
+                logger.info(f"Réponse API pour {url}: {str(data)[:200]}")
+            else:
+                logger.warning(f"Réponse inattendue de l'API pour {url}: {type(data)}")
             return data
         except requests.RequestException as e:
             logger.error(f"Échec de la requête {url}: {e}")
@@ -50,22 +54,27 @@ class PesticideDataFetcher:
 
     def preload_substance_names(self):
         url = f"{self.BASE_URL}/active_substances?format=json&api-version=v2.0"
-        while url:
-            data = self.fetch_data(url)
-            if "error" in data:
-                logger.error(f"Erreur préchargement substances: {data.get('error')}")
-                break
-            for item in data.get("value", []):
-                substance_id = item.get("substanceId")  # Utilisation de substanceId (camelCase)
-                if substance_id:
-                    self._substance_cache[substance_id] = SubstanceDetails(
-                        name=item.get("substanceName", "Nom non trouvé"),
-                        status=item.get("substanceStatus"),
-                        approval_date=item.get("approvalDate"),
-                        expiry_date=item.get("expiryDate")
-                    )
-            url = data.get("nextLink")
-        logger.info(f"Cache substances prérempli avec {len(self._substance_cache)} entrées")
+        with ThreadPoolExecutor(max_workers=5) as executor:
+            while url:
+                data = self.fetch_data(url)
+                if "error" in data:
+                    logger.error(f"Erreur lors du préchargement: {data.get('error', 'Aucune info')}")
+                    break
+                tasks = []
+                for item in data.get("value", []):
+                    tasks.append(executor.submit(self._cache_substance, item))
+                url = data.get("nextLink")
+        logger.info(f"Cache prérempli avec {len(self._substance_cache)} substances")
+
+    def _cache_substance(self, item: Dict[str, Any]):
+        substance_id = item.get("substanceId")
+        if substance_id:
+            self._substance_cache[substance_id] = SubstanceDetails(
+                name=item.get("substanceName", "Nom non trouvé"),
+                status=item.get("substanceStatus"),
+                approval_date=item.get("approvalDate"),
+                expiry_date=item.get("expiryDate")
+            )
 
     def get_product_list(self) -> List[Dict[str, Any]]:
         if self._product_cache:
@@ -74,10 +83,10 @@ class PesticideDataFetcher:
         while url:
             data = self.fetch_data(url)
             if "error" in data:
-                logger.error(f"Erreur récupération produits: {data.get('error')}")
+                logger.error(f"Erreur produits: {data.get('error', 'Aucune info')}")
                 break
             for product in data.get("value", []):
-                product_id = product.get("productId")  # Utilisation de productId (camelCase)
+                product_id = product.get("productId")
                 if product_id:
                     self._product_cache[product_id] = product
             url = data.get("nextLink")
@@ -88,18 +97,21 @@ class PesticideDataFetcher:
         url = f"{self.BASE_URL}/pesticide_residues_mrls?format=json&product_id={product_id}&api-version=v2.0"
         response = self.fetch_data(url)
         if "error" in response:
-            logger.error(f"Erreur MRLs pour {product_id}: {response.get('error')}")
+            logger.error(f"Erreur MRLs pour le produit {product_id}: {response.get('error', 'Aucune info')}")
             return []
         return response.get("value", [])
 
+    def get_substance_name(self, substance_id: int) -> str:
+        substance = self._substance_cache.get(substance_id)
+        return substance.name if substance else f"Substance {substance_id}"
+
 class PesticideApp:
     def __init__(self):
         self.fetcher = PesticideDataFetcher()
         self.product_list = {
-            p.get('productName', 'Aucun nom'): p.get('productId', 0)  # Utilisation de productName (camelCase)
+            p.get('productName', 'Aucun nom'): p.get('productId', 0)
             for p in self.fetcher.get_product_list()
         }
-        # Correction : Accès au cache via self.fetcher
         self.substances = [
             sd.name for sd in self.fetcher._substance_cache.values()
         ]
@@ -112,7 +124,7 @@ class PesticideApp:
                 return datetime.strptime(date_str, fmt).strftime("%d/%m/%Y")
             except ValueError:
                 continue
-        return "Format inconnu"
+        return "Format de date inconnu"
 
     def get_product_details(self, product_name: str) -> pd.DataFrame:
         product_id = self.product_list.get(product_name)
@@ -120,28 +132,28 @@ class PesticideApp:
             return pd.DataFrame([{"Erreur": "Produit non trouvé"}])
         
         mrls = self.fetcher.get_mrls(product_id)
+        if not mrls:
+            return pd.DataFrame([{"Erreur": "Aucune donnée MRL trouvée"}])
+        
         data = []
         for mrl in mrls:
-            substance_id = mrl.get("pesticideResidueId", 0)  # Utilisation de pesticideResidueId (camelCase)
-            substance_name = self.fetcher._substance_cache.get(substance_id, {}).get("name", "Substance inconnue")
+            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"),
-                "Date d'effet": self.format_date(mrl.get("entryIntoForceDate")),  # entryIntoForceDate (camelCase)
-                "Statut": self.fetcher._substance_cache.get(substance_id, {}).get("status", "N/C")
+                "Date d'effet": self.format_date(mrl.get("entryIntoForceDate")),
+                "Statut": getattr(substance, "status", "N/C")
             })
         return pd.DataFrame(data)
 
-    def search_substances(self, query: str) -> pd.DataFrame:
-        matches = [s for s in self.substances if query.lower() in s.lower()]
-        return pd.DataFrame(matches, columns=["Substance"]) if matches else pd.DataFrame([{"Message": "Aucun résultat"}])
-
     def create_ui(self) -> gr.Blocks:
-        with gr.Blocks() as ui:
+        with gr.Blocks(theme=gr.themes.Default()) as ui:
             gr.HTML("""
                 <div style="text-align: center; padding: 20px; background: #006633; color: white;">
-                    <h1>Base de Données Pesticides UE</h1>
+                    <h1>Base de Données des Pesticides UE</h1>
                 </div>
             """)
             
@@ -154,6 +166,7 @@ class PesticideApp:
                 output = gr.Dataframe(
                     headers=["Substance", "Valeur LMR", "Date d'effet", "Statut"],
                     max_height=500,
+                    overflow_scroll=True,
                     interactive=False
                 )
                 product.change(
@@ -161,22 +174,6 @@ class PesticideApp:
                     inputs=[product],
                     outputs=output
                 )
-                
-            with gr.Tab("Recherche par Substance"):
-                substance_search = gr.Textbox(
-                    label="Rechercher une substance",
-                    placeholder="Entrez un nom..."
-                )
-                substance_results = gr.Dataframe(max_height=300)
-                substance_search.submit(
-                    fn=self.search_substances,
-                    inputs=[substance_search],
-                    outputs=substance_results
-                )
-                
-            gr.Button("Actualiser les données", variant="secondary").click(
-                lambda: self.fetcher.preload_substance_names()
-            )
         return ui
 
 def main():
@@ -184,4 +181,4 @@ def main():
     app.create_ui().launch(share=False)
 
 if __name__ == "__main__":
-    main()
+    main()