feat: no timeout limit and more accurate info for end users

bot_telegram.py

@@ -180,37 +180,27 @@ class TelegramBot:
                 self.active_requests[message_id]['end_time'] = time.time()
 
     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}
-
+        """Make API request without timeout"""
         try:
+            headers = {
+                "Authorization": f"Bearer {HF_TOKEN}",
+                "accept": "application/json"
+            }
+
+            # No timeout specified
             response = requests.post(
-                self.ai_url, 
-                headers={**headers, "Content-Type": "application/json"}, 
-                json=json_payload
+                self.ai_url,
+                headers=headers,
+                json={"question": user_message}
             )
 
-            if response.status_code == 422:
-                response = requests.post(
-                    self.ai_url, 
-                    headers={**headers, "Content-Type": "application/x-www-form-urlencoded"},
-                    data=form_payload
-                )
-
             if response.status_code == 200:
-                return response.json().get("answer", "I didn't understand that.")
+                return response.json().get("answer", "No answer received")
             else:
-                return f"Error: {response.status_code}"
+                return f"API Error: {response.status_code}"
 
         except Exception as e:
-            return f"Connection error: {e}"
+            return f"Error: {str(e)}"
 
     async def handle_excel(self, update: Update, context: CallbackContext):
         """Handle Excel files concurrently"""
@@ -220,69 +210,123 @@ class TelegramBot:
         asyncio.create_task(self._process_excel_file(update, context, message_id))
 
     async def _process_excel_file(self, update, context, message_id):
-        """Process Excel file asynchronously"""
+        """Process Excel file with progress updates but no timeout"""
         try:
             document = update.message.document
             
             # Send initial processing message
             processing_msg = await update.message.reply_text(
-                f"📊 Processing Excel file...\n"
+                f"📊 Starting Excel processing...\n"
                 f"File: {document.file_name}\n"
-                f"Request ID: #{message_id}"
+                f"Request ID: #{message_id}\n"
+                f"Processing time may vary depending on file size and complexity. type /status to check the status of the request."
             )
 
-            # Track this Excel file
             self.active_excel_files[message_id] = {
                 'filename': document.file_name,
-                'status': 'downloading',
+                'status': 'processing',
                 'start_time': time.time()
             }
 
-            # Download file
-            file = await context.bot.get_file(document.file_id)
-            file_bytes = await file.download_as_bytearray()
+            # Process in thread pool without timeout
+            try:
+                # Start a background task to update progress message
+                asyncio.create_task(self._update_progress(processing_msg, message_id, document.file_name))
 
-            # Update status to processing
-            self.active_excel_files[message_id]['status'] = 'processing'
-            await processing_msg.edit_text(
-                f"⚙️ Processing Excel file...\n"
-                f"File: {document.file_name}\n"
-                f"Request ID: #{message_id}"
-            )
-
-            # Process in thread pool
-            result = await asyncio.get_event_loop().run_in_executor(
-                self.excel_executor,
-                self._process_excel_sync,
-                file_bytes,
-                document.file_name
-            )
-
-            if result is None:
-                raise Exception("Failed to process Excel file")
+                result = await asyncio.get_event_loop().run_in_executor(
+                    self.excel_executor,
+                    self._process_excel_sync,
+                    file_bytes,
+                    document.file_name
+                )
 
-            # Send processed file
-            await context.bot.send_document(
-                chat_id=update.effective_chat.id,
-                document=io.BytesIO(result),
-                filename=f'processed_{document.file_name}',
-                caption=f"✅ Excel processing completed!\nRequest ID: #{message_id}"
-            )
-            await processing_msg.delete()
+                if result is None:
+                    await processing_msg.edit_text(
+                        f"❌ Failed to process file\n"
+                        f"File: {document.file_name}\n"
+                        f"Please check the file format and try again."
+                    )
+                    return
+
+                # Send processed file
+                await context.bot.send_document(
+                    chat_id=update.effective_chat.id,
+                    document=io.BytesIO(result),
+                    filename=f'processed_{document.file_name}',
+                    caption=f"✅ Excel processing completed!\nRequest ID: #{message_id}"
+                )
+                await processing_msg.delete()
+
+            except Exception as e:
+                logging.error(f"Error processing file: {e}")
+                await processing_msg.edit_text(
+                    f"❌ Error processing file\n"
+                    f"File: {document.file_name}\n"
+                    f"Error: {str(e)}"
+                )
 
-        except Exception as e:
-            logging.error(f"Error handling Excel file: {e}")
-            await update.message.reply_text(
-                f"❌ Error processing Excel file\n"
-                f"File: {document.file_name}\n"
-                f"Request ID: #{message_id}\n"
-                f"Error: {str(e)}"
-            )
         finally:
             if message_id in self.active_excel_files:
                 self.active_excel_files[message_id]['status'] = 'completed'
                 self.active_excel_files[message_id]['end_time'] = time.time()
 
+    async def _process_excel_sync(self, file_bytes, filename):
+        """Synchronous function to process Excel file without timeout"""
+        try:
+            headers = {
+                "Authorization": f"Bearer {HF_TOKEN}",
+                "accept": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            }
+
+            files = {
+                'file': (
+                    filename, 
+                    file_bytes, 
+                    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+                )
+            }
+
+            # No timeout specified - will wait indefinitely
+            response = requests.post(
+                self.excel_url,
+                headers=headers,
+                files=files
+            )
+
+            if response.status_code == 200:
+                return response.content
+            else:
+                error_msg = f"API Error: {response.status_code}"
+                if response.text:
+                    error_msg += f" - {response.text}"
+                logging.error(error_msg)
+                return None
+
+        except Exception as e:
+            logging.error(f"Excel processing error: {e}")
+            return None
+
+    async def _update_progress(self, message, message_id, filename):
+        """Update progress message periodically"""
+        try:
+            while message_id in self.active_excel_files:
+                elapsed_time = time.time() - self.active_excel_files[message_id]['start_time']
+                hours = int(elapsed_time // 3600)
+                minutes = int((elapsed_time % 3600) // 60)
+                
+                await message.edit_text(
+                    f"⚙️ Processing Excel file...\n"
+                    f"File: {filename}\n"
+                    f"Request ID: #{message_id}\n"
+                    f"Time elapsed: {hours}h {minutes}m\n"
+                    f"Status: {self.active_excel_files[message_id]['status']}"
+                )
+                
+                # Update every 5 minutes
+                await asyncio.sleep(300)
+        except Exception as e:
+            logging.error(f"Error updating progress: {e}")
+
     async def status_command(self, update: Update, context: CallbackContext):
         """Show status of all active processes"""
         status_message = "Current Status:\n\n"
@@ -342,43 +386,5 @@ class TelegramBot:
         await self.app.stop()
         await self.app.shutdown()
 
-    def _process_excel_sync(self, file_bytes, filename):
-        """Synchronous function to process Excel file"""
-        try:
-            headers = {
-                "Authorization": f"Bearer {HF_TOKEN}",
-                "accept": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-            }
-
-            # Create files payload
-            files = {
-                'file': (
-                    filename, 
-                    file_bytes, 
-                    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
-                )
-            }
-
-            # Make the request
-            response = requests.post(
-                self.excel_url,
-                headers=headers,
-                files=files,
-                timeout=60  # 60 second timeout for Excel processing
-            )
-
-            if response.status_code == 200:
-                return response.content
-            else:
-                logging.error(f"Excel API Error: {response.status_code} - {response.text}")
-                return None
-
-        except requests.exceptions.Timeout:
-            logging.error("Excel processing timeout")
-            return None
-        except Exception as e:
-            logging.error(f"Excel processing error: {e}")
-            return None
-
 def init_bot():
     return TelegramBot(bot_token=BOT_TOKEN,base_url=BASE_URL)