Update app.py

app.py

@@ -39,7 +39,9 @@ class PesticideDataFetcher:
     HEADERS = {
         'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
         'Accept': 'application/json',
-        'Accept-Language': 'fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7'
+        'Accept-Language': 'fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7',
+        "Content-Type": "application/json",  # Added as per API docs
+        "Cache-Control": "no-cache"          # Added as per API docs
     }
     CACHE_DIR = "cache"
     SUBSTANCE_CACHE_FILE = os.path.join(CACHE_DIR, "substance_cache.json")
@@ -62,10 +64,12 @@ class PesticideDataFetcher:
         if use_cache:
             self._load_caches()
 
-        # Préchargement des substances si le cache est vide
+        # Préchargement des substances si le cache est vide et si le chargement réussi.
         if not self._substance_cache:
             self.preload_substance_names()
 
+
+
     def _load_caches(self):
         """Charge les données de cache depuis les fichiers"""
         try:
@@ -123,10 +127,10 @@ class PesticideDataFetcher:
             logger.error(f"Erreur lors de la sauvegarde des caches: {e}")
 
     @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
-    def fetch_data(self, url: str) -> Dict[str, Any]:
-        """Récupère les données depuis l'API avec mécanisme de retry"""
+    def fetch_data(self, url: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Récupère les données depuis l'API avec mécanisme de retry et paramètres optionnels."""
         try:
-            response = self.session.get(url, timeout=15)
+            response = self.session.get(url, params=params, timeout=15)
             response.raise_for_status()
             data = response.json()
             logger.debug(f"Réponse API pour {url}: {str(data)[:200]}...")
@@ -138,46 +142,60 @@ class PesticideDataFetcher:
     def preload_substance_names(self) -> None:
         """Précharge tous les noms de substances depuis l'API"""
         logger.info("Préchargement des substances...")
-        url = f"{self.BASE_URL}/pesticide_residues?format=json&language=FR&api-version=v2.0"
+        url = f"{self.BASE_URL}/pesticide_residues"  # Corrected endpoint
+        params = {"format": "json", "language": "FR", "api-version": "v1.0"} # Use params dict
         substances_loaded = 0
 
-        while url:
-            data = self.fetch_data(url)
-            if "error" in data:
-                logger.error(f"Erreur lors du préchargement des substances: {data.get('error', 'Erreur inconnue')}")
-                break
+        try:
+            data = self.fetch_data(url, params=params)  # Initial fetch outside the loop
+            if not data or "value" not in data: # Handle potential empty or malformed response
+                logger.warning("Initial fetch returned no data. Skipping preloading.")
+                return
+
+            while url:
+                if "error" in data:
+                    logger.error(f"Erreur lors du préchargement des substances: {data.get('error', 'Erreur inconnue')}")
+                    break
+
+                for substance in data.get("value", []):
+                    substance_id = substance.get("pesticideResidueId")
+                    if substance_id and substance_id not in self._substance_cache:
+                        self._substance_cache[substance_id] = SubstanceDetails(
+                            name=substance.get("pesticideResidueName", "Inconnu"),
+                            substance_id=substance_id,
+                            status=substance.get("status"),
+                            cas_number=substance.get("casNumber"),
+                            ec_number=substance.get("ecNumber")
+                        )
+                        substances_loaded += 1
 
-            for substance in data.get("value", []):
-                substance_id = substance.get("pesticideResidueId")
-                if substance_id and substance_id not in self._substance_cache:
-                    self._substance_cache[substance_id] = SubstanceDetails(
-                        name=substance.get("pesticideResidueName", "Inconnu"),
-                        substance_id=substance_id,
-                        status=substance.get("status"),
-                        cas_number=substance.get("casNumber"),
-                        ec_number=substance.get("ecNumber")
-                    )
-                    substances_loaded += 1
+                        # Chargement des détails supplémentaires pour chaque substance
+                        self._load_substance_details(substance_id)
 
-                    # Chargement des détails supplémentaires pour chaque substance
-                    self._load_substance_details(substance_id)
+                url = data.get("nextLink")
+                logger.info(f"Substances chargées jusqu'à présent: {substances_loaded}")
+                if url: # Only fetch if there's a nextLink
+                    #  No need to pass params again for nextLink, the API handles it
+                   data = self.fetch_data(url)
 
-            url = data.get("nextLink")
-            logger.info(f"Substances chargées jusqu'à présent: {substances_loaded}")
 
-        if self.use_cache:
-            self._save_caches()
+            if self.use_cache:
+                self._save_caches()
 
-        logger.info(f"Préchargement terminé. Total des substances: {len(self._substance_cache)}")
+            logger.info(f"Préchargement terminé. Total des substances: {len(self._substance_cache)}")
+        except Exception as e:
+            logger.error(f"Erreur lors du préchargement des substances: {e}")
+            return # Exit gracefully
 
     def _load_substance_details(self, substance_id: int) -> None:
         """Charge les détails supplémentaires d'une substance"""
-        url = f"{self.BASE_URL}/pesticide_residues/{substance_id}?format=json&language=FR&api-version=v2.0"
+        url = f"{self.BASE_URL}/pesticide_residues/{substance_id}" # Corrected endpoint
+        params = {"format": "json", "language": "FR", "api-version": "v1.0"} # Use params dict
         try:
-            data = self.fetch_data(url)
+            data = self.fetch_data(url, params=params)
 
             substance = self._substance_cache.get(substance_id)
-            if substance:
+            if substance and data: #check also if data is valid
                 substance.approval_date = data.get("approvalDate")
                 substance.expiry_date = data.get("expiryDate")
                 # Mise à jour du statut si non défini précédemment
@@ -193,8 +211,11 @@ class PesticideDataFetcher:
 
         # 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)
+            url = f"{self.BASE_URL}/pesticide_residues/{substance_id}" # Corrected endpoint
+            params = {"format": "json", "language": "FR", "api-version": "v1.0"} # Use params dict
+            data = self.fetch_data(url, params)
+            if not data:
+                return f"Substance inconnue ({substance_id})"
 
             substance_name = data.get("pesticideResidueName", f"Substance {substance_id}")
 
@@ -223,23 +244,28 @@ class PesticideDataFetcher:
             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"
+        url = f"{self.BASE_URL}/pesticide_residues_products"  # Corrected endpoint
+        params = {"format": "json", "language": "FR", "api-version": "v1.0"} # Use params dict
         products_loaded = 0
 
         while url:
-            data = self.fetch_data(url)
+            data = self.fetch_data(url, params=params)
             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
+            if data:
+                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 url :
+                # No need to pass params again for nextLink
+                data = self.fetch_data(url)
 
         if self.use_cache:
             self._save_caches()
@@ -254,17 +280,21 @@ class PesticideDataFetcher:
             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"
+        url = f"{self.BASE_URL}/pesticide_residues_products/{product_id}/mrls"  # Corrected endpoint
+        params = {"format": "json", "language": "FR", "api-version": "v1.0"} # Use params dict
 
         mrls = []
         while url:
-            data = self.fetch_data(url)
+            data = self.fetch_data(url, params=params)
             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", []))
+            if data:
+                mrls.extend(data.get("value", []))
             url = data.get("nextLink")
+            if url:
+                # No need for params in nextLink
+                data = self.fetch_data(url)
 
         # Mise à jour du cache
         self._mrl_cache[product_id] = mrls
@@ -284,20 +314,31 @@ class PesticideDataFetcher:
         ]
         return sorted(results, key=lambda x: x.name)
 
-    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"""
+    def get_substance_mrls(self, substance_id: int) -> List[Dict[str, Any]]:
+        """Récupère tous les produits avec LMR pour une substance donnée en utilisant le nouvel endpoint."""
         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"
+
+        url = f"{self.BASE_URL}/pesticide_residues_mrls" # Correct endpoint
+        params = {
+            "format": "json",
+            "api-version": "v1.0",
+            "pesticide_residue_id": substance_id  # Use the correct parameter name
+        }
 
         all_mrls = []
         while url:
-            data = self.fetch_data(url)
+            data = self.fetch_data(url, params=params)  # Pass params here
             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", []))
+            if data:
+                all_mrls.extend(data.get("value", []))
             url = data.get("nextLink")
+            if url:
+                #  No need to pass params again for the nextLink.
+                data = self.fetch_data(url)
+
 
         logger.info(f"LMR récupérées pour la substance {substance_id}: {len(all_mrls)}")
         return all_mrls
@@ -429,7 +470,7 @@ class PesticideApp:
 
         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 # MODIFICATION: retourner le dataframe
+        return df
 
     def create_histogram(self, df: pd.DataFrame) -> go.Figure:
         """Crée un histogramme des valeurs LMR"""
@@ -574,8 +615,8 @@ class PesticideApp:
 
                 substance_mrls_btn.click(
                     fn=lambda sid: (
-                        self.get_substance_mrls(int(sid)), #MODIFICATION: int() conversion
-                        self.create_histogram(self.get_substance_mrls(int(sid))) #MODIFICATION : int() conversion
+                        self.get_substance_mrls(int(sid)),
+                        self.create_histogram(self.get_substance_mrls(int(sid)))
                     ),
                     inputs=[substance_select],
                     outputs=[substance_mrls, mrl_histogram]