Update main.py

main.py

@@ -1,6 +1,6 @@
-# messenger object
 import os
 import logging
+import requests
 from heyoo import WhatsApp
 from dotenv import load_dotenv
 from flask import Flask, request, make_response
@@ -8,106 +8,138 @@ from flask import Flask, request, make_response
 # Initialize Flask App
 app = Flask(__name__)
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
 # Load .env file
 load_dotenv()
-messenger = WhatsApp(os.environ["whatsapp_token"],phone_number_id=os.environ["phone_number_id"])
 
+# Initialize WhatsApp with error handling
+try:
+    messenger = WhatsApp(
+        os.environ.get("whatsapp_token"),
+        phone_number_id=os.environ.get("phone_number_id")
+    )
+    if not os.environ.get("whatsapp_token") or not os.environ.get("phone_number_id"):
+        raise ValueError("Missing required environment variables")
+except Exception as e:
+    logger.error(f"Failed to initialize WhatsApp messenger: {str(e)}")
+    raise
 
 VERIFY_TOKEN = "30cca545-3838-48b2-80a7-9e43b1ae8ce4"
 
-g_api_key = os.environ["google_api_key"]
-
-# Logging
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-
-
 @app.get("/")
 async def verify_token():
-    if request.args.get("hub.verify_token") == VERIFY_TOKEN:
-        logging.info("Verified webhook")
-        response = make_response(request.args.get("hub.challenge"), 200)
-        response.mimetype = "text/plain"
-        return response
-    logging.error("Webhook Verification failed")
-    return "Invalid verification token"
-
+    try:
+        if request.args.get("hub.verify_token") == VERIFY_TOKEN:
+            logger.info("Verified webhook")
+            response = make_response(request.args.get("hub.challenge"), 200)
+            response.mimetype = "text/plain"
+            return response
+        logger.error("Webhook Verification failed")
+        return "Invalid verification token"
+    except Exception as e:
+        logger.error(f"Error in verify_token: {str(e)}")
+        return "Internal server error", 500
 
 @app.post("/")
 async def hook():
-    # Handle Webhook Subscriptions
-    data = request.get_json()
-    logging.info("Received webhook data: %s", data)
-    changed_field = messenger.changed_field(data)
-    if changed_field == "messages":
-        new_message = messenger.is_message(data)
-        if new_message:
-            mobile = messenger.get_mobile(data)
-            name = messenger.get_name(data)
-            message_type = messenger.get_message_type(data)
-            logging.info(
-                f"New Message; sender:{mobile} name:{name} type:{message_type}"
-            )
+    try:
+        data = request.get_json()
+        logger.info("Received webhook data: %s", data)
+        
+        changed_field = messenger.changed_field(data)
+        if changed_field != "messages":
+            return "OK", 200
+            
+        if not messenger.is_message(data):
+            delivery = messenger.get_delivery(data)
+            if delivery:
+                logger.info(f"Message delivery status: {delivery}")
+            return "OK", 200
+
+        # Extract message details
+        mobile = messenger.get_mobile(data)
+        name = messenger.get_name(data)
+        message_type = messenger.get_message_type(data)
+        
+        logger.info(f"New Message; sender:{mobile} name:{name} type:{message_type}")
+
+        # Handle different message types
+        try:
             if message_type == "text":
                 message = messenger.get_message(data)
-                name = messenger.get_name(data)
-                logging.info("Message: %s", message)
-                await messenger.send_message(f"Hi {name}, nice to connect with you", mobile)
+                logger.info("Message: %s", message)
+                try:
+                    await messenger.send_message(f"Hi {name}, nice to connect with you", mobile)
+                except requests.exceptions.ConnectionError as ce:
+                    logger.error(f"Connection error while sending message: {str(ce)}")
+                    # Implement retry logic here if needed
+                except Exception as e:
+                    logger.error(f"Error sending message: {str(e)}")
 
             elif message_type == "interactive":
                 message_response = messenger.get_interactive_response(data)
                 interactive_type = message_response.get("type")
                 message_id = message_response[interactive_type]["id"]
                 message_text = message_response[interactive_type]["title"]
-                logging.info(f"Interactive Message; {message_id}: {message_text}")
+                logger.info(f"Interactive Message; {message_id}: {message_text}")
 
             elif message_type == "location":
                 message_location = messenger.get_location(data)
                 message_latitude = message_location["latitude"]
                 message_longitude = message_location["longitude"]
-                logging.info("Location: %s, %s", message_latitude, message_longitude)
-
-            elif message_type == "image":
-                image = messenger.get_image(data)
-                image_id, mime_type = image["id"], image["mime_type"]
-                image_url = await messenger.query_media_url(image_id)
-                image_filename = await messenger.download_media(image_url, mime_type)
-                logging.info(f"{mobile} sent image {image_filename}")
-
-            elif message_type == "video":
-                video = messenger.get_video(data)
-                video_id, mime_type = video["id"], video["mime_type"]
-                video_url = await messenger.query_media_url(video_id)
-                video_filename = await messenger.download_media(video_url, mime_type)
-                logging.info(f"{mobile} sent video {video_filename}")
-
-            elif message_type == "audio":
-                audio = messenger.get_audio(data)
-                audio_id, mime_type = audio["id"], audio["mime_type"]
-                audio_url = await messenger.query_media_url(audio_id)
-                audio_filename = await messenger.download_media(audio_url, mime_type)
-                logging.info(f"{mobile} sent audio {audio_filename}")
-
-            elif message_type == "document":
-                file = messenger.get_document(data)
-                file_id, mime_type = file["id"], file["mime_type"]
-                file_url = await messenger.query_media_url(file_id)
-                file_filename = await messenger.download_media(file_url, mime_type)
-                logging.info(f"{mobile} sent file {file_filename}")
-            else:
-                logging.info(f"{mobile} sent {message_type} ")
-                logging.info(data)
-        else:
-            delivery = messenger.get_delivery(data)
-            if delivery:
-                logging.info(f"Message : {delivery}")
-            else:
-                logging.info("No new message")
-    return "OK", 200
-
+                logger.info("Location: %s, %s", message_latitude, message_longitude)
 
+            elif message_type in ["image", "video", "audio", "document"]:
+                await handle_media_message(messenger, data, message_type, mobile)
 
+            else:
+                logger.info(f"{mobile} sent unsupported message type: {message_type}")
+                logger.debug(f"Full message data: {data}")
+
+        except Exception as e:
+            logger.error(f"Error processing message type {message_type}: {str(e)}")
+            return "Internal server error", 500
+
+        return "OK", 200
+
+    except Exception as e:
+        logger.error(f"Error in webhook handler: {str(e)}")
+        return "Internal server error", 500
+
+async def handle_media_message(messenger, data, message_type, mobile):
+    """Handle different types of media messages with error handling."""
+    try:
+        media_methods = {
+            "image": messenger.get_image,
+            "video": messenger.get_video,
+            "audio": messenger.get_audio,
+            "document": messenger.get_document
+        }
+        
+        media = media_methods[message_type](data)
+        media_id, mime_type = media["id"], media["mime_type"]
+        
+        try:
+            media_url = await messenger.query_media_url(media_id)
+            media_filename = await messenger.download_media(media_url, mime_type)
+            logger.info(f"{mobile} sent {message_type} {media_filename}")
+        except requests.exceptions.ConnectionError as ce:
+            logger.error(f"Connection error while downloading {message_type}: {str(ce)}")
+        except Exception as e:
+            logger.error(f"Error downloading {message_type}: {str(e)}")
+            
+    except Exception as e:
+        logger.error(f"Error processing {message_type} message: {str(e)}")
+        raise
 
 if __name__ == "__main__":
-  app.run(debug=True,host="0.0.0.0", port=7860)
+    try:
+        app.run(debug=True, host="0.0.0.0", port=7860)
+    except Exception as e:
+        logger.error(f"Failed to start Flask app: {str(e)}")