Update app.py

app.py

@@ -1,18 +1,21 @@
-import os
+import telebot
+import google.generativeai as genai
 import logging
-import httpx
-import asyncio
-from flask import Flask, request, jsonify
+import requests
+import gradio as gr
+
+# Suppress experimental warnings
+os.environ['HF_HUB_DISABLE_EXPERIMENTAL_WARNING'] = '1'
 
 # Configuration
-BOT_TOKEN = '7484321656:AAExhpS7sOGMu2BCuPQrDjuXpY3sEQmBgfY'
-WEBHOOK_SECRET = 'A3%26c8%21jP%23xZ1v*Qw5kL%5E0tR%40u9%25yS6'  # URL-encoded secret
-POWER_USER_ID = 75516649
+GOOGLE_API_KEY = 'AIzaSyAYXUMnwmR4nUGDCs97FJJsafcQAPAAuzE'
+BOT_TOKEN = '7484321656:AAFaswxTqaSHu_s4jd_pk2Q2OJJWYcWHwAM'
+WEBHOOK_URL = f"https://measmonysuon-flyingbird.hf.space/webhooks/handle_update"
 
-# Proxy Configuration
-PROXY_URL = 'http://eR3LhYeoZXNWhIp:clIvQ2hSkO5CtLl@107.180.131.170:58874'
+# Initialize the Telegram bot
+bot = telebot.TeleBot(BOT_TOKEN)
 
-# Initialize logging
+# Configure logging
 logging.basicConfig(
     level=logging.DEBUG,
     format='%(asctime)s - %(levelname)s - %(message)s',
@@ -23,89 +26,57 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-app = Flask(__name__)
-
-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"}
-        )
-        if response.status_code == 200:
-            logger.info(f"Message sent successfully to chat_id {chat_id}")
-        else:
-            logger.error(f"Failed to send message: {response.text}")
-
-@app.route(f'/webhooks/{WEBHOOK_SECRET}', methods=['POST'])
-def handle_update():
-    """Handles incoming updates from Telegram."""
-    payload = request.json
-    logger.debug(f"Received payload: {payload}")
-
-    if payload.get('message'):
-        message_text = payload['message'].get('text')
-        chat_id = payload['message']['chat']['id']
+# Set up Google Generative AI
+genai.configure(api_key=GOOGLE_API_KEY)
 
-        if message_text:
-            try:
-                # Forward message to Gradio and get the response
-                async def forward_message():
-                    async with httpx.AsyncClient(proxies=PROXY_URL) as client:
-                        response = await client.post(
-                            'http://localhost:7860/',  # Gradio app URL
-                            json={'text': message_text}
-                        )
-                        if response.status_code == 200:
-                            response_text = response.json().get('data', 'Error processing request.')
-                        else:
-                            response_text = 'Error occurred while processing your request.'
-                        await bot_send_message(chat_id, response_text)
+generation_config = {
+    "temperature": 1,
+    "top_p": 0.95,
+    "top_k": 64,
+    "max_output_tokens": 8192,
+    "response_mime_type": "text/plain",
+}
 
-                asyncio.run(forward_message())
-                logger.info(f"Response sent to chat_id {chat_id}")
+model = genai.GenerativeModel(
+    model_name="gemini-1.5-pro",
+    generation_config=generation_config,
+    system_instruction="Please respond to user input"
+)
 
-            except Exception as e:
-                logger.error(f"Error during 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))
-                logger.error(f"Error message sent to chat_id {chat_id}")
+chat_session = model.start_chat(
+    history=[
+        {"role": "user", "parts": ["hi\n"]},
+        {"role": "model", "parts": ["Hello! 👋 How can I help you today? 😊 \n"]},
+        {"role": "user", "parts": ["I am looking for photo booth service?"]},
+        {"role": "model", "parts": ["That's great! 🎉 I can definitely help you with information about Aforative Media's photo booth services. \n\nTo give you the most relevant information, could you tell me a little more about what you're looking for? ..."]},
+        {"role": "user", "parts": ["How much for photo booth services?"]},
+        {"role": "model", "parts": ["You're smart to ask about pricing upfront! 😉 \n\nAforative Media's Mr. & Ms. Booth photo booth services start at **USD 390 for a minimum of 2 hours**. ..."]},
+        {"role": "user", "parts": ["How about videography service?"]},
+        {"role": "model", "parts": ["You're thinking about capturing the memories on film too? Excellent choice! Videography adds a whole other dimension to remembering special events. \n\nAforative Media offers excellent videography services, and just like their photo booths, their videography packages are competitively priced and flexible. ..."]},
+    ]
+)
 
-    return jsonify({'status': 'ok'}), 200
+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."
 
-async def set_telegram_webhook(flask_url):
-    """Sets the webhook for the Telegram bot using the provided Flask URL."""
-    webhook_url = f"{flask_url}/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.")
-                    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
+# Define Gradio interface
+def gradio_handle_update(user_input):
+    return generate_response(user_input)
 
-def run_flask_app():
-    """Launches the Flask app and sets the Telegram webhook."""
-    flask_url = "https://your-flask-url.com"  # Replace with your actual Flask URL
-    asyncio.run(set_telegram_webhook(flask_url))  # Set the webhook before starting the Flask app
-    app.run(host="0.0.0.0", port=5000, debug=True)
+iface = gr.Interface(
+    fn=gradio_handle_update,
+    inputs=gr.Textbox(label="User Input"),
+    outputs=gr.Textbox(label="Bot Response"),
+    live=True
+)
 
 if __name__ == "__main__":
-    run_flask_app()
+    iface.launch()  # Launch the Gradio app