whatsapp-python 3.0.2.post1__py3-none-any.whl

examples/example_hook_obj.py

@@ -0,0 +1,85 @@
+from whatsapp import Message, Hook, WhatsApp
+from flask import Response
+from os import getenv
+from dotenv import load_dotenv
+
+
+def handler(msg: Message):
+    message_type = msg.type
+    messenger = msg.instance
+    mobile = msg.sender
+
+    if message_type == "text":
+        message = msg.content
+        name = msg.name
+        m = Message(instance=messenger, to=mobile, content="Hello World")
+        m.send()
+
+    elif message_type == "interactive":
+        message_response = msg.interactive
+        if message_response is None:
+            return Response(status=400)
+        interactive_type = message_response.get("type")
+        message_id = message_response[interactive_type]["id"]
+        message_text = message_response[interactive_type]["title"]
+        # Do some action
+
+    elif message_type == "location":
+        message_location = msg.location
+        if message_location is None:
+            return Response(status=400)
+        message_latitude = message_location["latitude"]
+        message_longitude = message_location["longitude"]
+        # Do some action
+
+    elif message_type == "image":
+        image = msg.image
+        if image is None:
+            return Response(status=400)
+        image_id, mime_type = image["id"], image["mime_type"]
+        image_url = messenger.query_media_url(image_id)
+        if image_url is None:
+            return Response(status=400)
+        image_filename = messenger.download_media(image_url, mime_type)
+        # Do some action
+
+    elif message_type == "video":
+        video = msg.video
+        if video is None:
+            return Response(status=400)
+        video_id, mime_type = video["id"], video["mime_type"]
+        video_url = messenger.query_media_url(video_id)
+        if video_url is None:
+            return Response(status=400)
+        video_filename = messenger.download_media(video_url, mime_type)
+        # Do some action
+
+    elif message_type == "audio":
+        audio = msg.audio
+        if audio is None:
+            return Response(status=400)
+        audio_id, mime_type = audio["id"], audio["mime_type"]
+        audio_url = messenger.query_media_url(audio_id)
+        if audio_url is None:
+            return Response(status=400)
+        audio_filename = messenger.download_media(audio_url, mime_type)
+        # Do some action
+
+    elif message_type == "document":
+        file = msg.document
+        if file is None:
+            return Response(status=400)
+        file_id, mime_type = file["id"], file["mime_type"]
+        file_url = messenger.query_media_url(file_id)
+        if file_url is None:
+            return Response(status=400)
+        file_filename = messenger.download_media(file_url, mime_type)
+        # Do some action
+
+
+messenger = WhatsApp(token=getenv("TOKEN"),
+                     phone_number_id=getenv("PHONE_NUMBER_ID"))
+hook = Hook(instance=messenger, handler=handler, port=5000,
+            host="0.0.0.0", verify_token=getenv("VERIFY_TOKEN"))
+
+hook.run()

examples/reply_to_message_obj.py

@@ -0,0 +1,14 @@
+from os import getenv
+from whatsapp import WhatsApp, Message
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+    messenger = WhatsApp(token=getenv("TOKEN"), phone_number_id=getenv("ID"))
+
+    data = {"your": "data"}
+
+    msg = Message(data=data, instance=messenger)
+    msg.reply("lol")
+
+    print(msg)

examples/sending_audio.py

@@ -0,0 +1,15 @@
+from os import getenv
+from whatsapp import WhatsApp
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+    messenger = WhatsApp(token=getenv("TOKEN"),
+                         phone_number_id=getenv("PHONE_NUMBER_ID"))
+
+    response = messenger.send_audio(
+        audio="https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3",
+        recipient_id="255757xxxxxx",
+    )
+
+    print(response)

examples/sending_button.py

@@ -0,0 +1,33 @@
+from os import getenv
+from whatsapp import WhatsApp
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+    messenger = WhatsApp(token=getenv("TOKEN"),
+                         phone_number_id=getenv("PHONE_NUMBER_ID"))
+
+    response = messenger.send_button(
+        recipient_id="255757xxxxxx",
+        button={
+            "header": "Header Testing",
+            "body": "Body Testing",
+            "footer": "Footer Testing",
+            "action": {
+                "button": "Button Testing",
+                "sections": [
+                    {
+                        "title": "iBank",
+                        "rows": [
+                            {"id": "row 1", "title": "Send Money", "description": ""},
+                            {
+                                "id": "row 2",
+                                "title": "Withdraw money",
+                                "description": "",
+                            },
+                        ],
+                    }
+                ],
+            },
+        },
+    )

examples/sending_document.py

@@ -0,0 +1,16 @@
+from os import getenv
+from whatsapp import WhatsApp
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+
+    messenger = WhatsApp(token=getenv("TOKEN"),
+                         phone_number_id=getenv("PHONE_NUMBER_ID"))
+
+    response = messenger.send_document(
+        document="http://www.africau.edu/images/default/sample.pdf",
+        recipient_id="255757294146",
+    )
+
+    print(response)

examples/sending_image.py

@@ -0,0 +1,15 @@
+from os import getenv
+from whatsapp import WhatsApp
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+    messenger = WhatsApp(token=getenv("TOKEN"),
+                         phone_number_id=getenv("PHONE_NUMBER_ID"))
+
+    response = messenger.send_image(
+        image="https://i.imgur.com/Fh7XVYY.jpeg",
+        recipient_id="255757294146",
+    )
+
+    print(response)

examples/sending_location.py

@@ -0,0 +1,18 @@
+from os import getenv
+from whatsapp import WhatsApp
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+    messenger = WhatsApp(token=getenv("TOKEN"),
+                         phone_number_id=getenv("PHONE_NUMBER_ID"))
+
+    response = messenger.send_location(
+        lat=1.29,
+        long=103.85,
+        name="Singapore",
+        address="Singapore",
+        recipient_id="255757294146",
+    )
+
+    print(response)

examples/sending_message.py

@@ -0,0 +1,14 @@
+from os import getenv
+from whatsapp import WhatsApp, Message
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+    messenger = WhatsApp(token=getenv("TOKEN"),
+                         phone_number_id=getenv("PHONE_NUMBER_ID"))
+
+    msg = Message(instance=messenger,
+                  content="Hello World!", to="919999999999")
+    response = msg.send()
+
+    print(response)

examples/sending_template_message.py

@@ -0,0 +1,13 @@
+from os import getenv
+from whatsapp import WhatsApp
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+    messenger = WhatsApp(token=getenv("TOKEN"),
+                         phone_number_id=getenv("PHONE_NUMBER_ID"))
+
+    response = messenger.send_template(
+        "hello_world", "255757xxxxxx", components=[], lang="en_US")
+
+    print(response)

examples/sending_video.py

@@ -0,0 +1,15 @@
+from os import getenv
+from whatsapp import WhatsApp
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+    messenger = WhatsApp(token=getenv("TOKEN"),
+                         phone_number_id=getenv("PHONE_NUMBER_ID"))
+
+    response = messenger.send_video(
+        video="https://www.youtube.com/watch?v=K4TOrB7at0Y",
+        recipient_id="255757xxxxxx",
+    )
+
+    print(response)

examples/standalone_hook.py

@@ -0,0 +1,133 @@
+import os
+import logging
+from whatsapp import WhatsApp, Message
+from dotenv import load_dotenv
+from flask import Flask, request, Response
+
+# Initialize Flask App
+app = Flask(__name__)
+
+# Load .env file
+load_dotenv("../.env")
+messenger = WhatsApp(os.getenv("TOKEN"),
+                     phone_number_id=os.getenv("ID"))
+VERIFY_TOKEN = "30cca545-3838-48b2-80a7-9e43b1ae8ce4"
+
+# Logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+
+@app.get("/")
+def verify_token():
+    if request.args.get("hub.verify_token") == VERIFY_TOKEN:
+        logging.info("Verified webhook")
+        challenge = request.args.get("hub.challenge")
+        return str(challenge)
+    logging.error("Webhook Verification failed")
+    return "Invalid verification token"
+
+
+@app.post("/")
+def hook():
+    # Handle Webhook Subscriptions
+    data = request.get_json()
+    if data is None:
+        return Response(status=200)
+    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:
+            msg = Message(instance=messenger, data=data)
+            mobile = msg.sender
+            name = msg.name
+            message_type = msg.type
+            logging.info(
+                f"New Message; sender:{mobile} name:{name} type:{message_type}"
+            )
+            if message_type == "text":
+                message = msg.content
+                name = msg.name
+                logging.info("Message: %s", message)
+                m = Message(instance=messenger, to=mobile,
+                            content="Hello World")
+                m.send()
+
+            elif message_type == "interactive":
+                message_response = msg.interactive
+                if message_response is None:
+                    return Response(status=400)
+                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}")
+
+            elif message_type == "location":
+                message_location = msg.location
+                if message_location is None:
+                    return Response(status=400)
+                message_latitude = message_location["latitude"]
+                message_longitude = message_location["longitude"]
+                logging.info("Location: %s, %s",
+                             message_latitude, message_longitude)
+
+            elif message_type == "image":
+                image = msg.image
+                if image is None:
+                    return Response(status=400)
+                image_id, mime_type = image["id"], image["mime_type"]
+                image_url = messenger.query_media_url(image_id)
+                if image_url is None:
+                    return Response(status=400)
+                image_filename = messenger.download_media(image_url, mime_type)
+                logging.info(f"{mobile} sent image {image_filename}")
+
+            elif message_type == "video":
+                video = msg.video
+                if video is None:
+                    return Response(status=400)
+                video_id, mime_type = video["id"], video["mime_type"]
+                video_url = messenger.query_media_url(video_id)
+                if video_url is None:
+                    return Response(status=400)
+                video_filename = messenger.download_media(video_url, mime_type)
+                logging.info(f"{mobile} sent video {video_filename}")
+
+            elif message_type == "audio":
+                audio = msg.audio
+                if audio is None:
+                    return Response(status=400)
+                audio_id, mime_type = audio["id"], audio["mime_type"]
+                audio_url = messenger.query_media_url(audio_id)
+                if audio_url is None:
+                    return Response(status=400)
+                audio_filename = messenger.download_media(audio_url, mime_type)
+                logging.info(f"{mobile} sent audio {audio_filename}")
+
+            elif message_type == "document":
+                file = msg.document
+                if file is None:
+                    return Response(status=400)
+                file_id, mime_type = file["id"], file["mime_type"]
+                file_url = messenger.query_media_url(file_id)
+                if file_url is None:
+                    return Response(status=400)
+                file_filename = 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
+
+
+if __name__ == "__main__":
+    app.run(port=6869, debug=False)

setup.py

@@ -0,0 +1,42 @@
+from os import path
+from setuptools import setup
+from whatsapp.constants import VERSION
+
+this_directory = path.abspath(path.dirname(__file__))
+with open(path.join(this_directory, "README.md")) as f:
+    long_description = f.read()
+
+setup(
+    name="whatsapp-python",
+    version=VERSION,
+    description="Open source Python wrapper for the WhatsApp Cloud API",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/filipporomani/whatsapp",
+    download_url="https://github.com/filipporomani/whatsapp/releases/latest",
+    author="Filippo Romani",
+    author_email="mail@filipporomani.it",
+    license="MIT",
+    packages=["whatsapp"],
+    install_requires=["requests", "requests-toolbelt", "typing", "fastapi", "logging"],
+    keywords=[
+        "whatsapp",
+        "whatsapp-libary",
+        "WhatsApp Cloud API Wrapper",
+        "PyWhatsApp",
+        "WhatsApp API in Python",
+    ],
+    python_requires=">=3.6",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Build Tools",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+)

whatsapp/__init__.py

@@ -0,0 +1,238 @@
+"""
+Unofficial Python wrapper for the WhatsApp Cloud API.
+"""
+from __future__ import annotations
+
+import requests
+import logging
+from fastapi import FastAPI, Request
+from .constants import VERSION
+from . import ext
+from .ext._property import authorized
+from .ext._send_others import send_custom_json, send_contacts
+from .ext._message import send_template
+from .ext._send_media import send_image, send_video, send_audio, send_location, send_sticker, send_document
+from .ext._media import upload_media, query_media_url, download_media, delete_media
+from .ext._buttons import send_button, create_button, send_reply_button
+from .ext._static import is_message, get_mobile, get_author, get_name, get_message, get_message_id, get_message_type, get_message_timestamp, get_audio, get_delivery, get_document, get_image, get_interactive_response, get_location, get_video, changed_field
+
+
+
+
+class WhatsApp(object):
+    def __init__(self, token: str = "", phone_number_id: str = "", logger: bool = True, update_check: bool = True):
+        """
+        Initialize the WhatsApp Object
+
+        Args:
+            token[str]: Token for the WhatsApp cloud API obtained from the Facebook developer portal
+            phone_number_id[str]: Phone number id for the WhatsApp cloud API obtained from the developer portal
+            logger[bool]: Whether to enable logging or not (default: True)
+        """
+
+        # Check if the version is up to date
+        logging.getLogger(__name__).addHandler(logging.NullHandler())
+        
+
+        self.VERSION = VERSION
+        if update_check is True:
+            latest = str(requests.get(
+                "https://pypi.org/pypi/whatsapp-python/json").json()["info"]["version"])
+            if self.VERSION != latest:
+                version_int = int(self.VERSION.replace(".", ""))
+                latest_int = int(latest.replace(".", ""))
+                # this is to avoid the case where the version is 1.0.10 and the latest is 1.0.2 (possible if user is using the github version)
+                if version_int < latest_int:
+                    logging.critical(
+                        f"Whatsapp-python is out of date. Please update to the latest version {latest}. READ THE CHANGELOG BEFORE UPDATING. NEW VERSIONS MAY BREAK YOUR CODE IF NOT PROPERLY UPDATED.")
+                if version_int > latest_int:
+                    latest_beta = int(str(requests.get(
+                        "https://raw.githubusercontent.com/filipporomani/whatsapp/main/.version").text).replace(".", ""))
+                    if latest_beta > version_int:
+                        logging.critical(
+                            "A new beta version is available. Please update to the latest version. READ THE CHANGELOG BEFORE UPDATING. NEW VERSIONS MAY BREAK YOUR CODE IF NOT PROPERLY UPDATED.")
+                    logging.critical(
+                        f"You are using a development version of whatsapp-python. Please report any issue on GitHub.")
+
+        if token == "" or phone_number_id == "":
+            logging.error("Token or phone number id not provided")
+            raise ValueError(
+                "Token or phone number ID not provided but is required")
+        self.token = token
+        self.phone_number_id = phone_number_id
+        self.base_url = "https://graph.facebook.com/v17.0"
+        self.url = f"{self.base_url}/{phone_number_id}/messages"
+
+        async def base():
+            pass
+        self.message_handler = base
+        self.other_handler = base
+        self.verification_handler = base
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.token}"
+        }
+        if logger is False:
+            logging.disable(logging.INFO)
+            logging.disable(logging.ERROR)
+
+        self.app = FastAPI()
+
+        # Verification handler has 1 argument: challenge (str | bool): str if verification is successful, False if not
+
+        @self.app.get("/")
+        async def verify_endpoint(r: Request):
+            if r.query_params.get("hub.verify_token") == self.token:
+                logging.info("Verified webhook")
+                challenge = r.query_params.get("hub.challenge")
+                self.verification_handler(challenge)
+                self.other_handler(challenge)
+                return str(challenge)
+            logging.error("Webhook Verification failed")
+            await self.verification_handler(False)
+            await self.other_handler(False)
+            return {"success": False}
+
+        @self.app.post("/")
+        async def hook(r: Request):
+            # Handle Webhook Subscriptions
+            data = await r.json()
+            if data is None:
+                return {"success": False}
+            logging.info("Received webhook data: %s", data)
+            changed_field = self.instance.changed_field(data)
+            if changed_field == "messages":
+                new_message = self.instance.is_message(data)
+                if new_message:
+                    msg = Message(instance=self.instance, data=data)
+                    await self.message_handler(msg)
+                    await self.other_handler(msg)
+            return {"success": True}
+
+    # all the files starting with _ are imported here, and should not be imported directly.
+
+    is_message = staticmethod(is_message)
+    get_mobile = staticmethod(get_mobile)
+    get_name = staticmethod(get_name)
+    get_message = staticmethod(get_message)
+    get_message_id = staticmethod(get_message_id)
+    get_message_type = staticmethod(get_message_type)
+    get_message_timestamp = staticmethod(get_message_timestamp)
+    get_audio = staticmethod(get_audio)
+    get_delivery = staticmethod(get_delivery)
+    get_document = staticmethod(get_document)
+    get_image = staticmethod(get_image)
+    get_interactive_response = staticmethod(get_interactive_response)
+    get_location = staticmethod(get_location)
+    get_video = staticmethod(get_video)
+    changed_field = staticmethod(changed_field)
+    get_author = staticmethod(get_author)
+
+    authorized = property(authorized)
+
+    def create_message(self, **kwargs) -> Message:
+        """
+        Create a message object
+
+        Args:
+            data[dict]: The message data
+            content[str]: The message content
+            to[str]: The recipient
+            rec_type[str]: The recipient type (individual/group)
+        """
+        return Message(**kwargs, instance=self)
+
+    def on_message(self, handler: function):
+        """
+        Set the handler for incoming messages
+
+        Args:
+            handler[function]: The handler function
+        """
+        self.message_handler = handler
+
+    def on_event(self, handler: function):
+        """
+        Set the handler for other events
+
+        Args:
+            handler[function]: The handler function
+        """
+        self.other_handler = handler
+
+    def on_verification(self, handler: function):
+        """
+        Set the handler for verification
+
+        Args:
+            handler[function]: The handler function
+        """
+        self.verification_handler = handler
+
+    def run(self, host: str = "localhost", port: int = 5000, debug: bool = False, **options):
+        self.app.run(host=host, port=port, debug=debug, **options)
+
+
+class Message(object):
+    def __init__(self, data: dict = {}, instance: WhatsApp = None, content: str = "", to: str = "", rec_type: str = "individual"):  # type: ignore
+        try:
+            self.id = instance.get_message_id(data)
+        except:
+            self.id = None
+        try:
+            self.type = self.instance.get_message_type(data)
+        except:
+            self.type = "text"
+        self.data = data
+        self.rec = rec_type
+        self.to = to
+        try:
+            self.content = content if content != "" else self.instance.get_message(
+                data)
+        except:
+            self.content = content
+        try:
+            self.sender = self.instance.get_mobile(data)
+        except:
+            self.sender = None
+        try:
+            self.name = self.instance.get_name(data)
+        except:
+            self.name = None
+
+        if self.type == "image":
+            try:
+                self.image = self.instance.get_image(data)
+            except:
+                self.image = None
+        elif self.type == "video":
+            try:
+                self.video = self.instance.get_video(data)
+            except:
+                self.video = None
+        elif self.type == "audio":
+            try:
+                self.audio = self.instance.get_audio(data)
+            except:
+                pass
+        elif self.type == "document":
+            try:
+                self.document = self.instance.get_document(data)
+            except:
+                pass
+        elif self.type == "location":
+            try:
+                self.location = self.instance.get_location(data)
+            except:
+                pass
+        elif self.type == "interactive":
+            try:
+                self.interactive = self.instance.get_interactive_response(data)
+            except:
+                pass
+
+        self.instance = instance
+        self.url = self.instance.url
+        self.headers = self.instance.headers
+
+    from .ext._message import send, reply, mark_as_read

whatsapp/constants.py

@@ -0,0 +1,3 @@
+# internal use only
+
+VERSION = "3.0.2.post1"