Upload 3 files

Dockerfile

@@ -1,10 +1,10 @@
-# Use the official Python image
+# Use a minimal Python image
 FROM python:3.10-slim
 
-# Set working directory inside the container
+# Set the working directory inside the container
 WORKDIR /app
 
-# Copy all files from your Hugging Face Space into the container
+# Copy bot files into the container
 COPY . .
 
 # Install dependencies

bot_telegram.py

@@ -1,80 +1,120 @@
 import os
 import logging
+import asyncio
 import requests
-import gradio as gr
 from threading import Thread
 from telegram import Update
 from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext
 
-# Read API credentials from environment variables
+# Load environment variables from Hugging Face Secrets
 BOT_TOKEN = os.getenv("BOT_TOKEN")
 BASE_URL = os.getenv("BASE_URL")
 API_USERNAME = os.getenv("API_USERNAME")
 API_PASSWORD = os.getenv("API_PASSWORD")
 
 class TelegramBot:
+    """A Telegram bot that communicates with an AI model via API."""
+
     def __init__(self, bot_token, base_url, username, password):
+        """Initialize the bot with Telegram API token, API credentials, and endpoints."""
         self.bot_token = bot_token
         self.base_url = base_url
         self.username = username
         self.password = password
         self.auth_token = None
+
+        # API Endpoints
         self.login_url = f"{self.base_url}/api/v1/auth/login"
         self.ai_url = f"{self.base_url}/api/v1/questions/text"
+
+        # Start Telegram Bot
         self.app = Application.builder().token(self.bot_token).build()
         self.setup_handlers()
+
+        # Authenticate on startup
         self.authenticate()
 
     def authenticate(self):
+        """Authenticate with the API and retrieve an access token."""
         payload = {"username": self.username, "password": self.password}
         headers = {"Content-Type": "application/x-www-form-urlencoded", "accept": "application/json"}
+
         try:
             response = requests.post(self.login_url, headers=headers, data=payload)
+
             if response.status_code == 200:
                 self.auth_token = response.json().get("access_token")
-                logging.info("Successfully authenticated with API!")
+                logging.info("✅ Successfully authenticated with API!")
             else:
-                logging.error(f"Authentication failed: {response.status_code} - {response.text}")
+                logging.error(f"❌ Authentication failed: {response.status_code} - {response.text}")
+
         except Exception as e:
-            logging.error(f"Authentication Error: {e}")
+            logging.error(f"❌ Authentication Error: {e}")
 
     async def start_command(self, update: Update, context: CallbackContext):
+        """Handles the /start command."""
         await update.message.reply_text("Hello! Ask me any question.")
 
     async def chat_with_ai(self, update: Update, context: CallbackContext):
+        """Handles messages and sends them to the AI API."""
         if not self.auth_token:
             self.authenticate()
+
         if not self.auth_token:
             await update.message.reply_text("Authentication failed. Please try again later.")
             return
 
-        headers = {"Authorization": f"Bearer {self.auth_token}", "Content-Type": "application/x-www-form-urlencoded"}
-        payload = {"question": update.message.text}
+        user_message = update.message.text
+
+        headers = {
+            "Authorization": f"Bearer {self.auth_token}",
+            "Content-Type": "application/x-www-form-urlencoded",
+            "accept": "application/json"
+        }
+
+        payload = {"question": user_message}
+
         try:
             response = requests.post(self.ai_url, headers=headers, data=payload)
-            bot_reply = response.json().get("answer", "I didn't understand that.") if response.status_code == 200 else f"Error: {response.status_code}"
+
+            if response.status_code == 200:
+                bot_reply = response.json().get("answer", "I didn't understand that.")
+            elif response.status_code == 401:  # If unauthorized, refresh the token and retry
+                logging.warning("⚠️ Authorization expired. Re-authenticating...")
+                self.authenticate()
+                await self.chat_with_ai(update, context)  # Retry after re-authentication
+                return
+            elif response.status_code == 422:
+                bot_reply = "⚠️ Error: The API rejected the request. Check payload format."
+            else:
+                bot_reply = f"⚠️ Error: {response.status_code}"
+
         except Exception as e:
-            bot_reply = f"Connection error: {e}"
+            bot_reply = f"⚠️ Connection error: {e}"
 
         await update.message.reply_text(bot_reply)
 
     def setup_handlers(self):
+        """Set up Telegram command and message handlers."""
         self.app.add_handler(CommandHandler("start", self.start_command))
         self.app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self.chat_with_ai))
 
     def run(self):
-        logging.info("Bot is now listening for messages...")
+        """Start the bot and listen for messages."""
+        logging.info("🚀 Bot is now listening for messages...")
+        asyncio.set_event_loop(asyncio.new_event_loop())  # Fixes event loop issue
         self.app.run_polling()
 
+# --- Function to Start Bot Thread ---
 def start_telegram_bot():
-    bot = TelegramBot(BOT_TOKEN, BASE_URL, API_USERNAME, API_PASSWORD)
+    bot = TelegramBot(
+        bot_token=BOT_TOKEN,
+        base_url=BASE_URL,
+        username=API_USERNAME,
+        password=API_PASSWORD
+    )
     bot.run()
 
+# Start the bot in a separate thread
 telegram_thread = Thread(target=start_telegram_bot, daemon=True)
 telegram_thread.start()
-
-def status():
-    return "✅ Telegram Bot is Running on Hugging Face!"
-
-iface = gr.Interface(fn=status, inputs=[], outputs="text", title="Telegram Bot Status")
-iface.launch(share=True)

requirements.txt

@@ -1,3 +1,2 @@
 python-telegram-bot
 requests
-gradio