Update app.py

app.py

@@ -1,12 +1,10 @@
 import logging
-import time
-import asyncio
-from flask import Flask
-from threading import Thread
-from telegram import Update
-from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, ContextTypes, filters
-from telegram.error import NetworkError, TimedOut
+import json
+from flask import Flask, request
+from telegram import Update, Bot
+from telegram.ext import Application, CommandHandler, MessageHandler, ContextTypes, filters
 import google.generativeai as genai
+import asyncio
 
 # ==== CONFIG ====
 TELEGRAM_TOKEN = "7745816717:AAGKTpRtuPknjRAIct_2kdoANpJx3ZFztrg"
@@ -23,15 +21,11 @@ genai.configure(api_key=GEMINI_API_KEY)
 model = genai.GenerativeModel("gemini-1.5-flash")
 
 # ==== FLASK APP ====
-flask_app = Flask(__name__)
-
-@flask_app.route("/")
-def home():
-    return "✅ Telegram AI Chatbot is running on port 7860!"
+app = Flask(__name__)
 
-@flask_app.route("/health")
-def health():
-    return {"status": "healthy", "timestamp": time.time()}
+# ==== TELEGRAM SETUP ====
+bot = Bot(token=TELEGRAM_TOKEN)
+application = Application.builder().token(TELEGRAM_TOKEN).build()
 
 # ==== TELEGRAM BOT HANDLERS ====
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
@@ -51,56 +45,50 @@ async def chat(update: Update, context: ContextTypes.DEFAULT_TYPE):
     except Exception as e:
         logger.error(f"Telegram reply error: {e}")
 
-def start_bot_with_retry():
-    """Start bot with retry logic for network issues"""
-    max_retries = 5
-    retry_delay = 10
-    
-    for attempt in range(max_retries):
-        try:
-            logger.info(f"Attempting to start bot (attempt {attempt + 1}/{max_retries})")
-            
-            # Build application with custom settings for better reliability
-            app = ApplicationBuilder().token(TELEGRAM_TOKEN).build()
-            app.add_handler(CommandHandler("start", start))
-            app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, chat))
-            
-            # Start polling with error handling
-            app.run_polling(
-                timeout=30,
-                bootstrap_retries=3,
-                read_timeout=30,
-                write_timeout=30,
-                connect_timeout=30,
-                pool_timeout=30
-            )
-            
-        except (NetworkError, TimedOut, OSError) as e:
-            logger.error(f"Network error on attempt {attempt + 1}: {e}")
-            if attempt < max_retries - 1:
-                logger.info(f"Retrying in {retry_delay} seconds...")
-                time.sleep(retry_delay)
-                retry_delay *= 2  # Exponential backoff
-            else:
-                logger.error("Max retries reached. Bot failed to start.")
-                raise
-        except Exception as e:
-            logger.error(f"Unexpected error: {e}")
-            raise
+# Add handlers
+application.add_handler(CommandHandler("start", start))
+application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, chat))
+
+# ==== FLASK ROUTES ====
+@app.route("/")
+def home():
+    return "✅ Telegram AI Chatbot is running with webhooks!"
 
-def run_flask():
-    """Run Flask app"""
-    flask_app.run(host="0.0.0.0", port=7860, debug=False)
+@app.route("/health")
+def health():
+    return {"status": "healthy"}
+
+@app.route(f"/{TELEGRAM_TOKEN}", methods=["POST"])
+def webhook():
+    """Handle incoming updates from Telegram"""
+    try:
+        update = Update.de_json(request.get_json(force=True), bot)
+        # Process update asynchronously
+        asyncio.create_task(application.process_update(update))
+        return "OK"
+    except Exception as e:
+        logger.error(f"Webhook error: {e}")
+        return "Error", 500
+
+@app.route("/set_webhook", methods=["GET"])
+def set_webhook():
+    """Set up the webhook (call this once after deployment)"""
+    webhook_url = f"https://your-space-name-your-username.hf.space/{TELEGRAM_TOKEN}"
+    try:
+        # This will need to be called manually or you can set it via Telegram API
+        success = asyncio.run(bot.set_webhook(url=webhook_url))
+        if success:
+            return f"Webhook set to {webhook_url}"
+        else:
+            return "Failed to set webhook"
+    except Exception as e:
+        logger.error(f"Error setting webhook: {e}")
+        return f"Error: {e}"
 
 # ==== MAIN ====
 if __name__ == "__main__":
-    # Start Flask in a separate thread
-    flask_thread = Thread(target=run_flask, daemon=True)
-    flask_thread.start()
-    
-    # Wait a bit for Flask to start
-    time.sleep(2)
-    logger.info("Flask app started, now starting Telegram bot...")
+    # Initialize the application
+    asyncio.run(application.initialize())
     
-    # Start bot with retry logic
-    start_bot_with_retry()
+    # Run Flask app
+    app.run(host="0.0.0.0", port=7860, debug=False)