Update app.py

app.py

@@ -4,8 +4,7 @@ from datetime import datetime, timedelta
 from typing import Dict, List, Optional
 import gradio as gr
 import pandas as pd
-import aiohttp
-import asyncio
+import requests
 from dataclasses import dataclass
 from tenacity import retry, stop_after_attempt, wait_fixed
 import plotly.express as px
@@ -45,32 +44,37 @@ class PesticideDataFetcher:
 
     def __init__(self):
         self.session = self._create_session()
+        self._substance_cache = {}
+        self._product_cache = {}
 
     def _create_session(self):
         """Crée une session pour les requêtes HTTP."""
-        return aiohttp.ClientSession(headers=self.HEADERS)
+        session = requests.Session()
+        for header, value in self.HEADERS.items():
+            session.headers[header] = value
+        return session
 
     @retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
-    async def fetch_data(self, url: str) -> Dict:
+    def fetch_data(self, url: str) -> Dict:
         """Récupère les données depuis l'API avec gestion d'erreurs et retry."""
         try:
-            async with self.session.get(url, timeout=10) as response:
-                response.raise_for_status()
-                data = await response.json()
-                logger.info(f"Fetched data from {url}: {str(data)[:200]}...")
-                return data
-        except aiohttp.ClientError as e:
+            response = self.session.get(url, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            logger.info(f"Fetched data from {url}: {str(data)[:200]}...")
+            return data
+        except requests.RequestException as e:
             logger.error(f"Failed to fetch data from {url}: {str(e)}")
             return {"error": str(e)}
 
-    async def get_active_substance_details(self, substance_name: str) -> Dict:
+    def get_active_substance_details(self, substance_name: str) -> Dict:
         """Récupère les détails d'une substance active."""
         cache_key = f"substance:{substance_name}"
         cached_data = redis_client.get(cache_key)
         if cached_data:
             return eval(cached_data)
         url = f"{self.BASE_URL}/active_substances?format=json&substance_name={substance_name}&api-version=v2.0"
-        response = await self.fetch_data(url)
+        response = self.fetch_data(url)
         if response and "value" in response and response["value"]:
             substance_data = response["value"][0]
             substance_details = {
@@ -82,7 +86,7 @@ class PesticideDataFetcher:
             return substance_details
         return {}
 
-    async def get_products(self) -> List[Dict]:
+    def get_products(self) -> List[Dict]:
         """Récupère la liste complète des produits avec pagination."""
         cache_key = "products"
         cached_data = redis_client.get(cache_key)
@@ -92,7 +96,7 @@ class PesticideDataFetcher:
         base_url = f"{self.BASE_URL}/pesticide_residues_products?format=json&language=FR&api-version=v2.0"
         url = base_url
         while url:
-            response = await self.fetch_data(url)
+            response = self.fetch_data(url)
             if not response or "value" not in response:
                 break
             all_products.extend(response["value"])
@@ -105,25 +109,16 @@ class PesticideDataFetcher:
         logger.info(f"Récupéré {len(all_products)} produits au total")
         return all_products
 
-    async def get_mrls(self, product_id: int) -> List[Dict]:
+    def get_mrls(self, product_id: int) -> List[Dict]:
         """Récupère les LMR pour un produit spécifique."""
-        cache_key = f"mrls:{product_id}"
-        cached_data = redis_client.get(cache_key)
-        if cached_data:
-            return eval(cached_data)
         url = f"{self.BASE_URL}/pesticide_residues_mrls?format=json&product_id={product_id}&api-version=v2.0"
-        response = await self.fetch_data(url)
-        redis_client.set(cache_key, str(response.get("value", [])), ex=3600)
+        response = self.fetch_data(url)
         return response.get("value", [])
 
-    async def get_substance_details(self, pesticide_residue_id: int) -> Dict:
+    def get_substance_details(self, pesticide_residue_id: int) -> Dict:
         """Récupère les détails d'une substance à partir de son ID."""
-        cache_key = f"substance_details:{pesticide_residue_id}"
-        cached_data = redis_client.get(cache_key)
-        if cached_data:
-            return eval(cached_data)
         url = f"{self.BASE_URL}/pesticide_residues/{pesticide_residue_id}?format=json&api-version=v2.0"
-        response = await self.fetch_data(url)
+        response = self.fetch_data(url)
         if not response or "value" not in response or not response["value"]:
             logger.warning(f"Pas de détails trouvés pour la substance {pesticide_residue_id}")
             return {"substance_name": f"Substance {pesticide_residue_id}"}
@@ -133,7 +128,7 @@ class PesticideDataFetcher:
             logger.warning(f"Nom de substance non trouvé pour l'ID {pesticide_residue_id}")
             return {"substance_name": f"Substance {pesticide_residue_id}"}
         active_url = f"{self.BASE_URL}/active_substances?format=json&substance_name={substance_name}&api-version=v2.0"
-        active_response = await self.fetch_data(active_url)
+        active_response = self.fetch_data(active_url)
         details = {
             "substance_name": substance_name,
             "status": None,
@@ -147,32 +142,25 @@ class PesticideDataFetcher:
                 "approval_date": active_data.get("approval_date"),
                 "expiry_date": active_data.get("expiry_date")
             })
-        redis_client.set(cache_key, str(details), ex=3600)
         return details
 
-    async def get_substance_name_by_id(self, substance_id: int) -> str:
+    def get_substance_name_by_id(self, substance_id: int) -> str:
         """Récupère le nom de la substance à partir de son ID."""
-        cache_key = f"substance_name:{substance_id}"
-        cached_data = redis_client.get(cache_key)
-        if cached_data:
-            return cached_data.decode('utf-8')
         url = f"{self.BASE_URL}/active_substances/{substance_id}?format=json&api-version=v2.0"
-        response = await self.fetch_data(url)
+        response = self.fetch_data(url)
         if response and "value" in response and response["value"]:
             substance_data = response["value"][0]
-            substance_name = substance_data.get("substance_name", f"Substance {substance_id}")
-            redis_client.set(cache_key, substance_name, ex=3600)
-            return substance_name
+            return substance_data.get("substance_name", f"Substance {substance_id}")
         return f"Substance {substance_id}"
 
-    async def get_all_substances(self) -> List[str]:
+    def get_all_substances(self) -> List[str]:
         """Récupère la liste complète des substances actives."""
         cache_key = "all_substances"
         cached_data = redis_client.get(cache_key)
         if cached_data:
             return eval(cached_data)
         url = f"{self.BASE_URL}/active_substances?format=json&api-version=v2.0"
-        response = await self.fetch_data(url)
+        response = self.fetch_data(url)
         substances = [item.get("substance_name") for item in response.get("value", [])]
         redis_client.set(cache_key, str(substances), ex=3600)
         return substances
@@ -181,11 +169,11 @@ class PesticideInterface:
     """Classe pour gérer l'interface utilisateur Gradio."""
     def __init__(self):
         self.fetcher = PesticideDataFetcher()
-        self.products = asyncio.run(self.fetcher.get_products())
+        self.products = self.fetcher.get_products()
         self.product_choices = {
             p['product_name']: p['product_id'] for p in self.products
         }
-        self.substances = asyncio.run(self.fetcher.get_all_substances())
+        self.substances = self.fetcher.get_all_substances()
         self._cache = {}
         logger.info(f"Initialized interface with {len(self.product_choices)} products and {len(self.substances)} substances.")
 
@@ -232,58 +220,71 @@ class PesticideInterface:
             return regulation_number
         return f'<a href="{regulation_url}" target="_blank">{regulation_number}</a>'
 
-    async def get_product_details(self, product_name: str, period: str, show_only_changes: bool) -> pd.DataFrame:
+    def get_product_details(self, product_name: str, period: str, show_only_changes: bool) -> pd.DataFrame:
         """Récupère et formate les détails des MRLs pour un produit donné."""
         logger.info(f"Récupération des détails pour le produit: {product_name}")
-        if not product_name:
-            return pd.DataFrame({"Message": ["Veuillez sélectionner un produit"]})
-        product_id = self.product_choices.get(product_name)
-        if not product_id:
-            return pd.DataFrame({"Message": ["Produit non trouvé"]})
-        cache_key = f"{product_id}_{period}_{show_only_changes}"
-        if cache_key in self._cache:
-            return self._cache[cache_key]
-        mrls = await self.fetcher.get_mrls(product_id)
-        if period != "Toutes les dates":
-            mrls = self.filter_by_period(mrls, period)
-        if not mrls:
-            return pd.DataFrame({"Message": ["Aucune donnée trouvée pour la période sélectionnée"]})
-        processed_mrls = []
-        tasks = [self.fetcher.get_substance_details(mrl["pesticide_residue_id"]) for mrl in mrls]
-        substance_details_list = await asyncio.gather(*tasks)
-        for substance_details, mrl in zip(substance_details_list, mrls):
-            logger.info(f"Détails de la substance récupérés: {substance_details}")
-            mrl_value = mrl.get("mrl_value", "")
-            if isinstance(mrl_value, (int, float)):
-                formatted_mrl = f"{mrl_value}{'*' if str(mrl_value).endswith('*') else ''}"
-            else:
-                formatted_mrl = str(mrl_value)
-            mrl_data = {
-                "Substance": substance_details.get("substance_name", ""),
-                "Valeur LMR": formatted_mrl,
-                "Date d'application": self.parse_date(mrl.get("entry_into_force_date")),
-                "Date de modification": self.parse_date(mrl.get("modification_date")),
-                "Règlement": self.format_regulation_link(
-                    mrl.get("regulation_url", ""),
-                    mrl.get("regulation_number", "") or mrl.get("regulation_reference", "")
-                ),
-                "Statut": substance_details.get("status", ""),
-                "Date d'approbation": self.parse_date(substance_details.get("approval_date")),
-                "Date d'expiration": self.parse_date(substance_details.get("expiry_date"))
-            }
-            logger.info(f"Données MRL formatées: {mrl_data}")
-            processed_mrls.append(mrl_data)
-        df = pd.DataFrame(processed_mrls)
-        if show_only_changes and "Date de modification" in df.columns:
-            df = df[df["Date de modification"].notna()]
-        df = df.sort_values("Date d'application", ascending=False)
-        columns_order = [
-            "Substance", "Valeur LMR", "Date d'application", "Date de modification",
-            "Règlement", "Statut", "Date d'approbation", "Date d'expiration"
-        ]
-        df = df[columns_order]
-        self._cache[cache_key] = df
-        return df
+        try:
+            if not product_name:
+                return pd.DataFrame({"Message": ["Veuillez sélectionner un produit"]})
+            product_id = self.product_choices.get(product_name)
+            if not product_id:
+                return pd.DataFrame({"Message": ["Produit non trouvé"]})
+            cache_key = f"{product_id}_{period}_{show_only_changes}"
+            if cache_key in self._cache:
+                return self._cache[cache_key]
+            mrls = self.fetcher.get_mrls(product_id)
+            if period != "Toutes les dates":
+                mrls = self.filter_by_period(mrls, period)
+            if not mrls:
+                return pd.DataFrame({"Message": ["Aucune donnée trouvée pour la période sélectionnée"]})
+            processed_mrls = []
+            with ThreadPoolExecutor(max_workers=10) as executor:
+                futures = {
+                    executor.submit(self.fetcher.get_substance_details, mrl["pesticide_residue_id"]): mrl
+                    for mrl in mrls
+                }
+                for future in futures:
+                    mrl = futures[future]
+                    try:
+                        substance_details = future.result()
+                        logger.info(f"Détails de la substance récupérés: {substance_details}")
+                        # Formatage de la valeur LMR
+                        mrl_value = mrl.get("mrl_value", "")
+                        if isinstance(mrl_value, (int, float)):
+                            formatted_mrl = f"{mrl_value}{'*' if str(mrl_value).endswith('*') else ''}"
+                        else:
+                            formatted_mrl = str(mrl_value)
+                        mrl_data = {
+                            "Substance": substance_details.get("substance_name", ""),
+                            "Valeur LMR": formatted_mrl,
+                            "Date d'application": self.parse_date(mrl.get("entry_into_force_date")),
+                            "Date de modification": self.parse_date(mrl.get("modification_date")),
+                            "Règlement": self.format_regulation_link(
+                                mrl.get("regulation_url", ""),
+                                mrl.get("regulation_number", "") or mrl.get("regulation_reference", "")
+                            ),
+                            "Statut": substance_details.get("status", ""),
+                            "Date d'approbation": self.parse_date(substance_details.get("approval_date")),
+                            "Date d'expiration": self.parse_date(substance_details.get("expiry_date"))
+                        }
+                        logger.info(f"Données MRL formatées: {mrl_data}")
+                        processed_mrls.append(mrl_data)
+                    except Exception as e:
+                        logger.error(f"Erreur lors du traitement de la substance: {e}")
+            df = pd.DataFrame(processed_mrls)
+            if show_only_changes and "Date de modification" in df.columns:
+                df = df[df["Date de modification"].notna()]
+            df = df.sort_values("Date d'application", ascending=False)
+            columns_order = [
+                "Substance", "Valeur LMR", "Date d'application", "Date de modification",
+                "Règlement", "Statut", "Date d'approbation", "Date d'expiration"
+            ]
+            df = df[columns_order]
+            self._cache[cache_key] = df
+            return df
+        except Exception as e:
+            logger.error(f"Erreur dans get_product_details: {str(e)}")
+            return pd.DataFrame({"Message": [f"Erreur: {str(e)}"]})
 
     def create_graph(self, df: pd.DataFrame) -> gr.Plot:
         """Crée un graphique interactif pour les dates d'application."""
@@ -296,22 +297,26 @@ class PesticideInterface:
         df.to_csv(csv_file_path, index=False)
         return csv_file_path
 
-    async def get_substance_details_table(self, substance_name: str) -> pd.DataFrame:
+    def get_substance_details_table(self, substance_name: str) -> pd.DataFrame:
         """Récupère et formate les détails d'une substance active."""
         logger.info(f"Récupération des détails pour la substance: {substance_name}")
-        if not substance_name:
-            return pd.DataFrame({"Message": ["Veuillez sélectionner une substance"]})
-        substance_details = await self.fetcher.get_active_substance_details(substance_name)
-        if not substance_details:
-            return pd.DataFrame({"Message": ["Substance non trouvée"]})
-        df = pd.DataFrame([substance_details])
-        df = df.rename(columns={
-            "status": "Statut",
-            "approval_date": "Date d'approbation",
-            "expiry_date": "Date d'expiration"
-        })
-        df.insert(0, "Substance", substance_name)
-        return df
+        try:
+            if not substance_name:
+                return pd.DataFrame({"Message": ["Veuillez sélectionner une substance"]})
+            substance_details = self.fetcher.get_active_substance_details(substance_name)
+            if not substance_details:
+                return pd.DataFrame({"Message": ["Substance non trouvée"]})
+            df = pd.DataFrame([substance_details])
+            df = df.rename(columns={
+                "status": "Statut",
+                "approval_date": "Date d'approbation",
+                "expiry_date": "Date d'expiration"
+            })
+            df.insert(0, "Substance", substance_name)
+            return df
+        except Exception as e:
+            logger.error(f"Erreur dans get_substance_details_table: {str(e)}")
+            return pd.DataFrame({"Message": [f"Erreur: {str(e)}"]})
 
     def create_interface(self) -> gr.Blocks:
         """Crée l'interface Gradio avec un design amélioré."""
@@ -362,7 +367,7 @@ class PesticideInterface:
                     interactive=False
                 )
             fetch_btn.click(
-                fn=lambda product_name, period, show_only_changes: asyncio.run(self.get_product_details(product_name, period, show_only_changes)),
+                fn=self.get_product_details,
                 inputs=[product_dropdown, period_radio, show_changes],
                 outputs=[mrls_table]
             )
@@ -377,7 +382,7 @@ class PesticideInterface:
                 outputs=export_output
             )
             substance_dropdown.change(
-                fn=lambda substance_name: asyncio.run(self.get_substance_details_table(substance_name)),
+                fn=self.get_substance_details_table,
                 inputs=substance_dropdown,
                 outputs=substance_table
             )
@@ -393,7 +398,7 @@ class PesticideInterface:
             """)
         return interface
 
-async def main():
+def main():
     interface = PesticideInterface()
     app = interface.create_interface()
     app.launch(
@@ -403,5 +408,5 @@ async def main():
     )
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()