add: Telegram bot with cocurrent processing

bot_telegram.py

@@ -5,6 +5,8 @@ from telegram import Update
 from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext
 import aiohttp
 import io
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
@@ -49,6 +51,9 @@ class TelegramBot:
         logging.info("Authenticating with API...")
         # self.authenticate()
 
+        # Create a ThreadPoolExecutor for handling concurrent requests
+        self.executor = ThreadPoolExecutor(max_workers=10)
+
     # def authenticate(self):
     #     """Authenticate with the API and retrieve an access token."""
     #     payload = {"username": self.username, "password": self.password}
@@ -133,42 +138,56 @@ class TelegramBot:
         #     return
 
         user_message = update.message.text
+        # Send immediate acknowledgment
+        processing_msg = await update.message.reply_text("Processing your request...")
+
+        try:
+            # Run the API request in a separate thread to avoid blocking
+            response = await asyncio.get_event_loop().run_in_executor(
+                self.executor,
+                self._make_api_request,
+                user_message
+            )
+            
+            # Update the processing message with the response
+            await processing_msg.edit_text(response)
 
+        except Exception as e:
+            logging.error(f"Error processing request: {e}")
+            await processing_msg.edit_text(f"❌ Error: {str(e)}")
+
+    def _make_api_request(self, user_message):
+        """Make the actual API request in a separate thread"""
         hf_authorization = "Bearer " + HF_TOKEN
         headers = {
             "Authorization": hf_authorization,
             "accept": "application/json"
         }
 
-
         json_payload = {"question": user_message}
         form_payload = {"question": user_message}
 
         try:
-            logging.info(f"Sending payload as JSON: {json_payload}")
-            response = requests.post(self.ai_url, headers={**headers, "Content-Type": "application/json"}, json=json_payload)
+            response = requests.post(
+                self.ai_url, 
+                headers={**headers, "Content-Type": "application/json"}, 
+                json=json_payload
+            )
 
             if response.status_code == 422:
-                logging.warning("JSON format rejected. Retrying with form-data...")
-                response = requests.post(self.ai_url, headers={**headers, "Content-Type": "application/x-www-form-urlencoded"},
-                                         data=form_payload)
+                response = requests.post(
+                    self.ai_url, 
+                    headers={**headers, "Content-Type": "application/x-www-form-urlencoded"},
+                    data=form_payload
+                )
 
             if response.status_code == 200:
-                bot_reply = response.json().get("answer", "I didn't understand that.")
-            elif response.status_code == 401:
-                logging.warning("Authorization expired. Re-authenticating...")
-                # self.authenticate()
-                await self.chat_with_ai(update, context)
-                return
+                return response.json().get("answer", "I didn't understand that.")
             else:
-                logging.error(f"Error: {response.status_code}")
-                bot_reply = f"Error: {response.status_code}"
+                return f"Error: {response.status_code}"
 
         except Exception as e:
-            logging.error(f"Connection error: {e}")
-            bot_reply = f"Connection error: {e}"
-
-        await update.message.reply_text(bot_reply)
+            return f"Connection error: {e}"
 
     async def handle_excel(self, update: Update, context: CallbackContext):
         """Handles Excel file uploads."""
@@ -190,11 +209,36 @@ class TelegramBot:
             await update.message.reply_text("Please send only Excel files (.xls or .xlsx)")
             return
 
+        # Send initial processing message
+        processing_msg = await update.message.reply_text("📊 Processing your Excel file... This may take a few minutes.")
+
         try:
-            # Send initial processing message
-            processing_msg = await update.message.reply_text("📊 Processing your Excel file... This may take a few minutes.")
+            # Run Excel processing in a separate thread
+            result = await asyncio.get_event_loop().run_in_executor(
+                self.executor,
+                self._process_excel,
+                update, context, document
+            )
+            
+            if isinstance(result, tuple):
+                file_content, error = result
+                if error:
+                    await processing_msg.edit_text(f"❌ Error: {error}")
+                else:
+                    await context.bot.send_document(
+                        chat_id=update.effective_chat.id,
+                        document=io.BytesIO(file_content),
+                        filename='rfp_responses.xlsx',
+                        caption="✅ Here's your processed Excel file with answers!"
+                    )
+                    await processing_msg.delete()
+        except Exception as e:
+            logging.error(f"Error handling Excel file: {e}")
+            await processing_msg.edit_text(f"❌ Error processing Excel file: {str(e)}")
 
-            # Get file from Telegram
+    async def _process_excel(self, update, context, document):
+        """Process Excel file in a separate thread"""
+        try:
             file = await context.bot.get_file(document.file_id)
             file_bytes = await file.download_as_bytearray()
 
@@ -204,39 +248,21 @@ class TelegramBot:
             }
 
             async with aiohttp.ClientSession() as session:
-                # Create form data with the file
                 form_data = aiohttp.FormData()
                 form_data.add_field('file',
-                                    file_bytes,
-                                    filename=document.file_name,
-                                    content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+                                  file_bytes,
+                                  filename=document.file_name,
+                                  content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
 
-                # Send file to API
                 async with session.post(self.excel_url, headers=headers, data=form_data) as response:
                     if response.status == 200:
-                        # Get the Excel file content directly
-                        file_content = await response.read()
-
-                        # Send the Excel file back to Telegram
-                        await context.bot.send_document(
-                            chat_id=update.effective_chat.id,
-                            document=io.BytesIO(file_content),
-                            filename='rfp_responses.xlsx',
-                            caption="✅ Here's your processed Excel file with answers!"
-                        )
-                        await processing_msg.delete()
-
-                    elif response.status == 401:
-                        logging.warning("Authorization expired. Re-authenticating...")
-                        # self.authenticate()
-                        await self.handle_excel(update, context)
+                        return await response.read(), None
                     else:
                         error_text = await response.text()
-                        await processing_msg.edit_text(f"❌ Error processing Excel file: {error_text}")
+                        return None, error_text
 
         except Exception as e:
-            logging.error(f"Error handling Excel file: {e}")
-            await update.message.reply_text(f"❌ Error processing Excel file: {str(e)}")
+            return None, str(e)
 
     def setup_handlers(self):
         """Set up Telegram command and message handlers."""