rollback async solution

main.py

@@ -700,7 +700,7 @@ class HealthcareChatbot:
             else:
                 return "I apologize, I encountered a processing issue. How can I help you?"
 
-    async def backend_call(self, data: Dict[str, Any]) -> Dict[str, Any]:
+    def backend_call(self, data: Dict[str, Any]) -> Dict[str, Any]:
         """Make API call to backend with retry logic"""
         endpoint_url = data.get('endpoint')
         endpoint_method = data.get('method')
@@ -713,80 +713,80 @@ class HealthcareChatbot:
             endpoint_params['patient_id'] = self.user_id
         
         retries = 0
-        # response = None
-        # while retries < self.max_retries:
-        #     try:
-        #         if endpoint_method.upper() == 'GET':
-        #             response = requests.get(
-        #                 self.BASE_URL + endpoint_url,
-        #                 params=endpoint_params,
-        #                 headers=self.headers,
-        #                 timeout=10
-        #             )
-        #         elif endpoint_method.upper() in ['POST', 'PUT', 'DELETE']:
-        #             response = requests.request(
-        #                 endpoint_method.upper(),
-        #                 self.BASE_URL + endpoint_url,
-        #                 json=endpoint_params,
-        #                 headers=self.headers,
-        #                 timeout=10
-        #             )
+        response = None
+        while retries < self.max_retries:
+            try:
+                if endpoint_method.upper() == 'GET':
+                    response = requests.get(
+                        self.BASE_URL + endpoint_url,
+                        params=endpoint_params,
+                        headers=self.headers,
+                        timeout=10
+                    )
+                elif endpoint_method.upper() in ['POST', 'PUT', 'DELETE']:
+                    response = requests.request(
+                        endpoint_method.upper(),
+                        self.BASE_URL + endpoint_url,
+                        json=endpoint_params,
+                        headers=self.headers,
+                        timeout=10
+                    )
                 
-        #         response.raise_for_status()
-        #         print('Backend Response:', response.json())
-        #         return response.json()
+                response.raise_for_status()
+                print('Backend Response:', response.json())
+                return response.json()
                 
-        #     except requests.exceptions.RequestException as e:
-        #         retries += 1
-        #         if retries >= self.max_retries:
-        #             return {
-        #                 "error": "Backend API call failed after multiple retries",
-        #                 "details": str(e),
-        #                 "status_code": getattr(e.response, 'status_code', None) if hasattr(e, 'response') else None
-        #             }
+            except requests.exceptions.RequestException as e:
+                retries += 1
+                if retries >= self.max_retries:
+                    return {
+                        "error": "Backend API call failed after multiple retries",
+                        "details": str(e),
+                        "status_code": getattr(e.response, 'status_code', None) if hasattr(e, 'response') else None
+                    }
                 
-        #         time.sleep(self.retry_delay)
-        async with aiohttp.ClientSession() as session:
-            while retries < self.max_retries:
-                try:
-                    if endpoint_method.upper() == 'GET':
-                        response = await session.get(
-                            self.BASE_URL + endpoint_url,
-                            params=endpoint_params,
-                            headers=self.headers,
-                            timeout=aiohttp.ClientTimeout(total=10)
-                        )
-                        return await response.json()
-
-                    elif endpoint_method.upper() in ['POST', 'PUT', 'DELETE']:
-                        response = await session.request(
-                            endpoint_method.upper(),
-                            self.BASE_URL + endpoint_url,
-                            json=endpoint_params,
-                            headers=self.headers,
-                            timeout=aiohttp.ClientTimeout(total=10)
-                        )
-                        return await response.json()
-
-                except aiohttp.ClientResponseError as e:
-                    retries += 1
-                    if retries >= self.max_retries:
-                        return {
-                            "error": "Backend API call failed after multiple retries",
-                            "details": str(e),
-                            "status_code": e.status
-                        }
-                    await asyncio.sleep(self.retry_delay)
-
-                except (aiohttp.ClientError, asyncio.TimeoutError) as e:
-                    retries += 1
-                    if retries >= self.max_retries:
-                        return {
-                            "error": "Backend API call failed after multiple retries",
-                            "details": str(e),
-                            "status_code": None
-                        }
-                    await asyncio.sleep(self.retry_delay)
+                time.sleep(self.retry_delay)
+        # async with aiohttp.ClientSession() as session:
+        #     while retries < self.max_retries:
+        #         try:
+        #             if endpoint_method.upper() == 'GET':
+        #                 response = await session.get(
+        #                     self.BASE_URL + endpoint_url,
+        #                     params=endpoint_params,
+        #                     headers=self.headers,
+        #                     timeout=aiohttp.ClientTimeout(total=10)
+        #                 )
+        #                 return await response.json()
+
+        #             elif endpoint_method.upper() in ['POST', 'PUT', 'DELETE']:
+        #                 response = await session.request(
+        #                     endpoint_method.upper(),
+        #                     self.BASE_URL + endpoint_url,
+        #                     json=endpoint_params,
+        #                     headers=self.headers,
+        #                     timeout=aiohttp.ClientTimeout(total=10)
+        #                 )
+        #                 return await response.json()
+
+        #         except aiohttp.ClientResponseError as e:
+        #             retries += 1
+        #             if retries >= self.max_retries:
+        #                 return {
+        #                     "error": "Backend API call failed after multiple retries",
+        #                     "details": str(e),
+        #                     "status_code": e.status
+        #                 }
+        #             await asyncio.sleep(self.retry_delay)
+
+        #         except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+        #             retries += 1
+        #             if retries >= self.max_retries:
+        #                 return {
+        #                     "error": "Backend API call failed after multiple retries",
+        #                     "details": str(e),
+        #                     "status_code": None
+        #                 }
+        #             await asyncio.sleep(self.retry_delay)
 
     def handle_api_action(self, user_query, detected_language, sentiment_result, keywords, router_data):
         """Handle API-based actions using router data"""
@@ -811,28 +811,29 @@ class HealthcareChatbot:
             print(f"🔍 Final API call data: {router_data}")
 
             # Make backend API call
-            # try:
-            #     # api_response = asyncio.run(self.backend_call(router_data))
-            #     loop = asyncio.get_event_loop()
-            #     api_response = loop.run_until_complete(self.backend_call(router_data))
-            #     loop.close()
-            # except:
-            #     print(traceback.format_exc())
             try:
-                def run_async():
-                    new_loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(new_loop)
-                    try:
-                        return new_loop.run_until_complete(self.backend_call(router_data))
-                    finally:
-                        new_loop.close()
-
-                import concurrent.futures
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(run_async)
-                    api_response = future.result(timeout=30)  # 30 second timeout
+                api_response = self.backend_call(router_data)
+                # api_response = asyncio.run(self.backend_call(router_data))
+                # loop = asyncio.get_event_loop()
+                # api_response = loop.run_until_complete(self.backend_call(router_data))
+                loop.close()
             except:
                 print(traceback.format_exc())
+            # try:
+            #     def run_async():
+            #         new_loop = asyncio.new_event_loop()
+            #         asyncio.set_event_loop(new_loop)
+            #         try:
+            #             return new_loop.run_until_complete(self.backend_call(router_data))
+            #         finally:
+            #             new_loop.close()
+
+            #     import concurrent.futures
+            #     with concurrent.futures.ThreadPoolExecutor() as executor:
+            #         future = executor.submit(run_async)
+            #         api_response = future.result(timeout=30)  # 30 second timeout
+            # except:
+            #     print(traceback.format_exc())
             
             print("🔗 API response received:", api_response)