Update app.py

app.py

@@ -1,16 +1,16 @@
-import asyncio
-import threading
-import os
-from dotenv import load_dotenv
 import requests
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI
 from pydantic import BaseModel
 from huggingface_hub import InferenceClient
 import uvicorn
+import asyncio
+import threading
+import os
+from dotenv import load_dotenv
 from telegram import Update
 from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext
 
-# Load environment variables (ensure these are set in Hugging Face Secrets)
+# Load environment variables
 load_dotenv()
 TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
 
@@ -20,54 +20,45 @@ app = FastAPI()
 # Hugging Face Model Client
 client = InferenceClient("RahulGanapathy/MisInfo-ChatBot")
 
-# Request schema for API requests
+# Request schema for Telegram API
 class RequestData(BaseModel):
     text: str
 
 @app.post("/predict")
 async def predict(data: RequestData):
-    """
-    API endpoint for AI response.
-    """
+    """API endpoint for Telegram bot and Gradio UI."""
     try:
         response = client.text_generation(prompt=data.text, max_new_tokens=100)
         return {"response": response}
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        return {"response": f"Error: {str(e)}"}
 
 # 🚀 Telegram Bot Integration
 async def start(update: Update, context: CallbackContext):
-    """Handles /start command."""
-    await update.message.reply_text("Hello! Send me a message and I'll check for misinformation.")
+    """Send a welcome message when the /start command is issued."""
+    await update.message.reply_text("Hello! Send me a message and I'll respond!")
 
 async def handle_message(update: Update, context: CallbackContext):
-    """Handles user messages and fetches AI response."""
+    """Handles user messages and gets response from Hugging Face API."""
     user_message = update.message.text
-    response = requests.post(
-        "http://0.0.0.0:8000/predict",
-        json={"text": user_message},
-    )
-
-    if response.status_code == 200:
-        result = response.json()["response"]
-    else:
-        result = "Error: Unable to get response from AI."
+    response = requests.post("http://0.0.0.0:8000/predict", json={"text": user_message})
 
+    result = response.json()["response"] if response.status_code == 200 else "Error: Unable to get response from AI."
     await update.message.reply_text(result)
 
-# 🚀 Start Telegram Bot
 async def run_telegram_bot():
+    """Runs the Telegram bot using asyncio properly."""
     application = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
     application.add_handler(CommandHandler("start", start))
     application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
-    
-    await application.run_polling()
 
-# 🚀 Start Telegram Bot in Background
-@app.on_event("startup")
-async def startup_event():
-    asyncio.create_task(run_telegram_bot())
+    # Start polling as an async task
+    asyncio.create_task(application.run_polling())
 
-# Run FastAPI Server
-if __name__ == "__main__":
+# 🚀 Start FastAPI in a separate thread
+def run_fastapi():
     uvicorn.run(app, host="0.0.0.0", port=8000)
+
+# Run FastAPI & Telegram Bot
+if __name__ == "__main__":
+    threading.Thread(target=run_fastapi, daemo