Update app.py

app.py

@@ -4,9 +4,7 @@ import google.generativeai as genai
 import logging
 import requests
 import gradio as gr
-import httpx
-import asyncio
-from flask import Flask, request, jsonify
+import time
 
 # Suppress experimental warnings
 os.environ['HF_HUB_DISABLE_EXPERIMENTAL_WARNING'] = '1'
@@ -14,9 +12,7 @@ os.environ['HF_HUB_DISABLE_EXPERIMENTAL_WARNING'] = '1'
 # Configuration
 GOOGLE_API_KEY = 'AIzaSyAYXUMnwmR4nUGDCs97FJJsafcQAPAAuzE'
 BOT_TOKEN = '7484321656:AAFaswxTqaSHu_s4jd_pk2Q2OJJWYcWHwAM'
-WEBHOOK_SECRET = 'A3%26c8%21jP%23xZ1v*Qw5kL%5E0tR%40u9%25yS6'  # URL-encoded secret
-POWER_USER_ID = 75516649
-PROXY_URL = 'http://eR3LhYeoZXNWhIp:clIvQ2hSkO5CtLl@107.180.131.170:58874'
+WEBHOOK_SECRET = 'A3&c8!jP#xZ1v*Qw5kL^0tR@u9%yS6'  # Define your webhook secret here
 
 # Initialize the Telegram bot
 bot = telebot.TeleBot(BOT_TOKEN)
@@ -62,114 +58,62 @@ chat_session = model.start_chat(
     ]
 )
 
-def generate_response(user_input):
-    """Generate a response using Google Generative AI."""
-    try:
-        prompt = f"Respond to the user: {user_input}"
-        response = chat_session.send_message(prompt)  # Generate response using text and prompt
-        response_text = response.text
-        return response_text
-    except Exception as e:
-        logger.error(f"Error during GenAI processing: {e}")
-        return "Sorry, I can't answer this query right now but I will improve from time to time."
-
-# Define Gradio interface
-def gradio_handle_update(user_input):
-    return generate_response(user_input)
-
-iface = gr.Interface(
-    fn=gradio_handle_update,
-    inputs=gr.Textbox(label="User Input"),
-    outputs=gr.Textbox(label="Bot Response"),
-    live=True
-)
-
-# Initialize Flask app
-app = Flask(__name__)
-
-@app.route(f'/webhooks/{WEBHOOK_SECRET}', methods=['POST'])
-def handle_update():
+def handle_update(payload):
     """Handles incoming updates from Telegram."""
-    payload = request.json
-    logger.debug(f"Received payload: {payload}")  # Log the incoming payload
-
     if payload.get('message'):
         message_text = payload['message'].get('text')
         chat_id = payload['message']['chat']['id']
 
         if message_text:
             try:
-                # Forward message to Gradio and get the response
-                response = requests.post('http://localhost:7860/', json={'text': message_text})
-                if response.status_code == 200:
-                    response_text = response.json().get('data', 'Sorry, I cannot process this request.')
-                else:
-                    response_text = 'Error occurred while processing your request.'
-
-                # Log and send the response
+                # Generate a response using Google Generative AI
+                prompt = f"Respond to the user: {message_text}"
+                response = chat_session.send_message(prompt)  # Generate response using text and prompt
+                response_text = response.text
+
+                # Log the response
                 logger.debug(f"Generated response: {response_text}")
-                asyncio.run(bot_send_message(chat_id, response_text))
+
+                # Send the response to the chat
+                bot.send_message(chat_id, response_text, parse_mode='Markdown')
                 logger.info(f"Response sent to chat_id {chat_id}")
 
             except Exception as e:
-                logger.error(f"Error during processing: {e}")
+                logger.error(f"Error during GenAI processing: {e}")
                 error_message = "Sorry, I can't answer this query right now but I will improve from time to time."
-                asyncio.run(bot_send_message(chat_id, error_message))
+                bot.send_message(chat_id, error_message, parse_mode='Markdown')
                 logger.error(f"Error message sent to chat_id {chat_id}")
 
-    return jsonify({'status': 'ok'}), 200
+    return 'OK'
 
-async def set_telegram_webhook():
-    """Sets the webhook for the Telegram bot with proxy configuration."""
-    webhook_url = f"https://measmonysuon-flyingbird.hf.space/webhooks/{WEBHOOK_SECRET}"
-    retry_attempts = 5
-    retry_delay = 1  # seconds
-    
-    for attempt in range(retry_attempts):
-        try:
-            async with httpx.AsyncClient(proxies=PROXY_URL) as client:
-                response = await client.post(
-                    f"https://api.telegram.org/bot{BOT_TOKEN}/setWebhook",
-                    data={"url": webhook_url},
-                )
-                result = response.json()
-                if result.get('ok'):
-                    logger.info("Webhook set successfully.")
-                    # Notify power user
-                    await bot_send_message(POWER_USER_ID, "🚀 The webhook has been successfully connected! 🎉")
-                    return
-                elif result.get('error_code') == 429:
-                    retry_after = result['parameters'].get('retry_after', retry_delay)
-                    logger.warning(f"Rate limit exceeded. Retrying after {retry_after} seconds.")
-                    await asyncio.sleep(retry_after)
-                else:
-                    logger.error(f"Failed to set webhook: {result}")
-                    return
-        except httpx.RequestError as e:
-            logger.error(f"Request exception: {e}")
-            return
-
-async def bot_send_message(chat_id, text):
-    """Send a message to the specified chat ID using the proxy configuration."""
-    async with httpx.AsyncClient(proxies=PROXY_URL) as client:
-        response = await client.post(
-            f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage",
-            data={"chat_id": chat_id, "text": text, "parse_mode": "Markdown"}
+def set_telegram_webhook(gradio_url):
+    """Sets the webhook for the Telegram bot."""
+    webhook_url = f"{gradio_url}/webhooks/handle_update"
+    try:
+        response = requests.post(
+            f"https://api.telegram.org/bot{BOT_TOKEN}/setWebhook",
+            data={"url": webhook_url}
         )
-        if response.status_code == 200:
-            logger.info(f"Message sent successfully to chat_id {chat_id}")
+        result = response.json()
+        if result.get('ok'):
+            logger.info("Webhook set successfully.")
         else:
-            logger.error(f"Failed to send message: {response.text}")
+            logger.error(f"Failed to set webhook: {result}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Request exception: {e}")
 
-def run_flask_app():
-    """Launches the Flask app and sets the Telegram webhook."""
-    asyncio.run(set_telegram_webhook())
-    app.run(host="0.0.0.0", port=5000, debug=True)
+def run_gradio_app():
+    """Launches the Gradio app and sets the Telegram webhook."""
+    with gr.Blocks() as app:
+        gr.Textbox(label="Input")  # Dummy input component
+        gr.Textbox(label="Output")  # Dummy output component
 
-if __name__ == "__main__":
-    # Launch the Gradio app in a separate thread/process
-    import threading
-    threading.Thread(target=iface.launch, kwargs={'server_name': '0.0.0.0', 'server_port': 7860}).start()
+    iface = app.launch(server_name="0.0.0.0", server_port=5000, debug=True)
+    
+    # Directly set the webhook URL for local testing
+    gradio_url = "http://localhost:5000"  # Use local URL for testing
+    
+    set_telegram_webhook(gradio_url)  # Set the webhook for Telegram
 
-    # Start Flask app
-    run_flask_app()
+if __name__ == "__main__":
+    run_gradio_app()