whatsapp-python 4.3.0__py3-none-any.whl → 4.4.0__py3-none-any.whl

whatsapp/__init__.py

@@ -3,15 +3,19 @@ Unofficial Python wrapper for the WhatsApp Cloud API.
 """
 
 from __future__ import annotations
-import requests
-import logging
-import json
+
 import asyncio
+import logging
+from typing import Any, Callable, Optional, Union
+
 import aiohttp
-from bs4 import BeautifulSoup
+import requests
 from fastapi import FastAPI, HTTPException, Request
 from uvicorn import run as _run
+
 from .constants import VERSION
+from .errors import Handle
+from .graph_api import resolve_graph_api_version
 from .ext._property import authorized
 from .ext._send_others import send_custom_json, send_contacts
 from .ext._message import send_template
@@ -24,7 +28,13 @@ from .ext._send_media import (
     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._buttons import (
+    send_button,
+    create_button,
+    send_reply_button,
+    send_cta_url,
+    send_location_request,
+)
 from .ext._static import (
     is_message,
     get_mobile,
@@ -42,6 +52,7 @@ from .ext._static import (
     get_interactive_response,
     get_location,
     get_video,
+    get_reaction,
     changed_field,
 )
 
@@ -69,6 +80,8 @@ from .async_ext._buttons import (
     send_button as async_send_button,
     create_button as async_create_button,
     send_reply_button as async_send_reply_button,
+    send_cta_url as async_send_cta_url,
+    send_location_request as async_send_location_request,
 )
 from .async_ext._static import (
     is_message as async_is_message,
@@ -87,17 +100,60 @@ from .async_ext._static import (
     get_interactive_response as async_get_interactive_response,
     get_location as async_get_location,
     get_video as async_get_video,
+    get_reaction as async_get_reaction,
     changed_field as async_changed_field,
 )
 
-from .errors import Handle
+
+def _check_package_update(current_version: str) -> None:
+    try:
+        latest = str(
+            requests.get(
+                "https://pypi.org/pypi/whatsapp-python/json", timeout=10
+            ).json()["info"]["version"]
+        )
+    except Exception as exc:  # noqa: BLE001
+        logging.debug("Skipped package update check: %s", exc)
+        return
+
+    if current_version == latest:
+        return
+
+    try:
+        version_int = int(current_version.replace(".", ""))
+    except ValueError:
+        version_int = 0
+    try:
+        latest_int = int(latest.replace(".", ""))
+    except ValueError:
+        latest_int = 0
+
+    # Avoid false positives such as 1.0.10 vs 1.0.2 when using local builds.
+    if version_int >= latest_int:
+        return
+
+    if version_int == 0:
+        logging.critical(
+            "There was an error while checking for updates, please check for "
+            "updates manually. This may be due to the version being a "
+            "post-release version (e.g. 1.0.0.post1) or a pre-release version "
+            "(e.g. 1.0.0a1). READ THE CHANGELOG BEFORE UPDATING. NEW VERSIONS "
+            "MAY BREAK YOUR CODE IF NOT PROPERLY UPDATED."
+        )
+    else:
+        logging.critical(
+            "Whatsapp-python is out of date. Please update to the latest "
+            "version %s. READ THE CHANGELOG BEFORE UPDATING. NEW VERSIONS MAY "
+            "BREAK YOUR CODE IF NOT PROPERLY UPDATED.",
+            latest,
+        )
 
 
 class WhatsApp:
     def __init__(
         self,
         token: str = "",
-        phone_number_id: dict = "",
+        phone_number_id: Union[dict, str] = "",
         logger: bool = True,
         update_check: bool = True,
         verify_token: str = "",
@@ -109,11 +165,14 @@ class WhatsApp:
 
         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
+            phone_number_id[dict]: Mapping of friendly keys to phone number IDs from the developer portal
             logger[bool]: Whether to enable logging or not (default: True)
+            update_check[bool]: Whether to check PyPI for package updates
+            verify_token[str]: Verification token used by the webhook challenge
+            debug[bool]: Whether to keep debug logs enabled
+            version[str]: Graph API version (``\"latest\"`` or e.g. ``\"v27.0\"``)
         """
 
-        # Check if the version is up to date
         logging.getLogger(__name__).addHandler(logging.NullHandler())
 
         self.l = phone_number_id
@@ -121,7 +180,6 @@ class WhatsApp:
         if isinstance(phone_number_id, dict):
             # use first phone number id as default
             phone_number_id = phone_number_id[list(phone_number_id.keys())[0]]
-
         elif phone_number_id == "":
             logging.error("Phone number ID not provided")
             raise ValueError("Phone number ID not provided but required")
@@ -132,60 +190,12 @@ class WhatsApp:
             raise ValueError(
                 "Phone number ID should be a dictionary of phone numbers and their IDs"
             )
-        else:
-            pass
 
-        self.VERSION = VERSION  # package version
-        r = requests.get(
-            "https://developers.facebook.com/docs/graph-api/changelog/"
-        ).text
-
-        # dynamically get the latest version of the API
-        if version == "latest":
-            soup = BeautifulSoup(r, features="html.parser")
-            t1 = soup.findAll("table")
-
-            def makeversion(table: BeautifulSoup) -> str:
-                result = []
-                allrows = table.findAll("tr")
-                for row in allrows:
-                    result.append([])
-                    allcols = row.findAll("td")
-                    for col in allcols:
-                        thestrings = [(s) for s in col.findAll(text=True)]
-                        thetext = "".join(thestrings)
-                        result[-1].append(thetext)
-                return result[0][1]
-
-            self.LATEST = makeversion(t1[0])  # latest version of the API
-        else:
-            self.LATEST = version
+        self.VERSION = VERSION
+        self.LATEST = resolve_graph_api_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:
-                try:
-                    version_int = int(self.VERSION.replace(".", ""))
-                except:
-                    version_int = 0
-                try:
-                    latest_int = int(latest.replace(".", ""))
-                except:
-                    latest_int = 0
-                # 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:
-                    if version_int == 0:
-                        logging.critical(
-                            f"There was an error while checking for updates, please check for updates manually. This may be due to the version being a post-release version (e.g. 1.0.0.post1) or a pre-release version (e.g. 1.0.0a1). READ THE CHANGELOG BEFORE UPDATING. NEW VERSIONS MAY BREAK YOUR CODE IF NOT PROPERLY UPDATED."
-                        )
-                    else:
-                        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."
-                        )
+            _check_package_update(self.VERSION)
 
         if token == "":
             logging.error("Token not provided")
@@ -193,6 +203,7 @@ class WhatsApp:
         if phone_number_id == "":
             logging.error("Phone number ID not provided")
             raise ValueError("Phone number ID not provided but required")
+
         self.token = token
         self.phone_number_id = phone_number_id
         self.base_url = f"https://graph.facebook.com/{self.LATEST}"
@@ -240,15 +251,15 @@ class WhatsApp:
                 data = await r.json()
                 if data is None:
                     return {"success": False}
-                data_str = json.dumps(data, indent=4)
-                # log the data received only if the log level is debug
-                logging.debug(f"Received webhook data: {data_str}")
+                # Avoid logging raw webhook payloads — they contain phone numbers
+                # and message content that CodeQL treats as sensitive clear-text data.
+                logging.debug("Received webhook payload")
 
-                changed_field = self.changed_field(data)
-                if changed_field == "messages":
+                changed = self.changed_field(data)
+                if changed == "messages":
                     new_message = self.is_message(data)
                     if new_message:
-                        msg = Message(instance=self, data=data)
+                        msg = self.create_message(data=data)
                         await self.message_handler(msg)
                         await self.other_handler(msg)
                 return {"success": True}
@@ -275,12 +286,15 @@ class WhatsApp:
     get_interactive_response = staticmethod(get_interactive_response)
     get_location = staticmethod(get_location)
     get_video = staticmethod(get_video)
+    get_reaction = staticmethod(get_reaction)
     changed_field = staticmethod(changed_field)
     get_author = staticmethod(get_author)
 
     send_button = send_button
     create_button = create_button
     send_reply_button = send_reply_button
+    send_cta_url = send_cta_url
+    send_location_request = send_location_request
     send_image = send_image
     send_video = send_video
     send_audio = send_audio
@@ -296,7 +310,7 @@ class WhatsApp:
     send_contacts = send_contacts
     authorized = property(authorized)
 
-    def create_message(self, **kwargs) -> Message:
+    def create_message(self, **kwargs) -> "Message":
         """
         Create a message object
 
@@ -308,7 +322,7 @@ class WhatsApp:
         """
         return Message(**kwargs, instance=self)
 
-    def on_message(self, handler: function):
+    def on_message(self, handler: Callable[..., Any]):
         """
         Set the handler for incoming messages
 
@@ -317,7 +331,7 @@ class WhatsApp:
         """
         self.message_handler = handler
 
-    def on_event(self, handler: function):
+    def on_event(self, handler: Callable[..., Any]):
         """
         Set the handler for other events
 
@@ -326,7 +340,7 @@ class WhatsApp:
         """
         self.other_handler = handler
 
-    def on_verification(self, handler: function):
+    def on_verification(self, handler: Callable[..., Any]):
         """
         Set the handler for verification
 
@@ -340,192 +354,32 @@ class WhatsApp:
 
 
 class AsyncWhatsApp(WhatsApp):
-    def __init__(
-        self,
-        token: str = "",
-        phone_number_id: dict = "",
-        logger: bool = True,
-        update_check: bool = True,
-        verify_token: str = "",
-        debug: bool = True,
-        version: str = "latest",
-    ):
-        """
-        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.l = phone_number_id
-
-        if isinstance(phone_number_id, dict):
-            # use first phone number id as default
-            phone_number_id = phone_number_id[list(phone_number_id.keys())[0]]
-
-        elif phone_number_id == "":
-            logging.error("Phone number ID not provided")
-            raise ValueError("Phone number ID not provided but required")
-        elif isinstance(phone_number_id, str):
-            logging.critical(
-                "The phone number ID should be a dictionary of phone numbers and their IDs. Using strings is deprecated."
-            )
-            raise ValueError(
-                "Phone number ID should be a dictionary of phone numbers and their IDs"
-            )
-        else:
-            pass
-
-        self.VERSION = VERSION  # package version
-        r = requests.get(
-            "https://developers.facebook.com/docs/graph-api/changelog/"
-        ).text
-
-        # dynamically get the latest version of the API
-        if version == "latest":
-            soup = BeautifulSoup(r, features="html.parser")
-            t1 = soup.findAll("table")
-
-            def makeversion(table: BeautifulSoup) -> str:
-                result = []
-                allrows = table.findAll("tr")
-                for row in allrows:
-                    result.append([])
-                    allcols = row.findAll("td")
-                    for col in allcols:
-                        thestrings = [(s) for s in col.findAll(text=True)]
-                        thetext = "".join(thestrings)
-                        result[-1].append(thetext)
-                return result[0][1]
-
-            self.LATEST = makeversion(t1[0])  # latest version of the API
-        else:
-            self.LATEST = version
-
-        if update_check is True:
-            latest = str(
-                requests.get("https://pypi.org/pypi/whatsapp-python/json").json()[
-                    "info"
-                ]["version"]
-            )
-            if self.VERSION != latest:
-                try:
-                    version_int = int(self.VERSION.replace(".", ""))
-                except:
-                    version_int = 0
-                try:
-                    latest_int = int(latest.replace(".", ""))
-                except:
-                    latest_int = 0
-                # 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:
-                    if version_int == 0:
-                        logging.critical(
-                            f"There was an error while checking for updates, please check for updates manually. This may be due to the version being a post-release version (e.g. 1.0.0.post1) or a pre-release version (e.g. 1.0.0a1). READ THE CHANGELOG BEFORE UPDATING. NEW VERSIONS MAY BREAK YOUR CODE IF NOT PROPERLY UPDATED."
-                        )
-                    else:
-                        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 token == "":
-            logging.error("Token not provided")
-            raise ValueError("Token not provided but required")
-        if phone_number_id == "":
-            logging.error("Phone number ID not provided")
-            raise ValueError("Phone number ID not provided but required")
-        self.token = token
-        self.phone_number_id = phone_number_id
-        self.base_url = f"https://graph.facebook.com/{self.LATEST}"
-        self.url = f"{self.base_url}/{phone_number_id}/messages"
-        self.verify_token = verify_token
-
-        async def base(*args):
-            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)
-        if debug is False:
-            logging.disable(logging.DEBUG)
-            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.verify_token:
-                logging.debug("Webhook verified successfully")
-                challenge = r.query_params.get("hub.challenge")
-                await self.verification_handler(challenge)
-                await self.other_handler(challenge)
-                return int(challenge)
-            logging.error("Webhook Verification failed - token mismatch")
-            await self.verification_handler(False)
-            await self.other_handler(False)
-            return {"success": False}
-
-        @self.app.post("/")
-        async def hook(r: Request):
-            try:
-                # Handle Webhook Subscriptions
-                data = await r.json()
-                if data is None:
-                    return {"success": False}
-                data_str = json.dumps(data, indent=4)
-                # log the data received only if the log level is debug
-                logging.debug(f"Received webhook data: {data_str}")
-
-                changed_field = self.changed_field(data)
-                if changed_field == "messages":
-                    new_message = self.is_message(data)
-                    if new_message:
-                        msg = Message(instance=self, data=data)
-                        await self.message_handler(msg)
-                        await self.other_handler(msg)
-                return {"success": True}
-            except Exception as e:
-                logging.error(f"Error parsing message: {e}")
-                raise HTTPException(
-                    status_code=500, detail={"success": False, "error": str(e)}
-                )
-
-    # 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_sticker = staticmethod(get_sticker)
-    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)
+    """Async variant of :class:`WhatsApp` that returns awaitable HTTP calls."""
+
+    is_message = staticmethod(async_is_message)
+    get_mobile = staticmethod(async_get_mobile)
+    get_name = staticmethod(async_get_name)
+    get_message = staticmethod(async_get_message)
+    get_message_id = staticmethod(async_get_message_id)
+    get_message_type = staticmethod(async_get_message_type)
+    get_message_timestamp = staticmethod(async_get_message_timestamp)
+    get_audio = staticmethod(async_get_audio)
+    get_delivery = staticmethod(async_get_delivery)
+    get_document = staticmethod(async_get_document)
+    get_image = staticmethod(async_get_image)
+    get_sticker = staticmethod(async_get_sticker)
+    get_interactive_response = staticmethod(async_get_interactive_response)
+    get_location = staticmethod(async_get_location)
+    get_video = staticmethod(async_get_video)
+    get_reaction = staticmethod(async_get_reaction)
+    changed_field = staticmethod(async_changed_field)
+    get_author = staticmethod(async_get_author)
 
     send_button = async_send_button
     create_button = async_create_button
     send_reply_button = async_send_reply_button
+    send_cta_url = async_send_cta_url
+    send_location_request = async_send_location_request
     send_image = async_send_image
     send_video = async_send_video
     send_audio = async_send_audio
@@ -540,13 +394,13 @@ class AsyncWhatsApp(WhatsApp):
     send_custom_json = async_send_custom_json
     send_contacts = async_send_contacts
     authorized = property(async_authorized)
-    
+
     def handle(self, data: dict):
         return Handle(data)
 
-    def create_message(self, **kwargs) -> AsyncMessage:
+    def create_message(self, **kwargs) -> "AsyncMessage":
         """
-        Create a message object
+        Create an async message object
 
         Args:
             data[dict]: The message data
@@ -556,107 +410,93 @@ class AsyncWhatsApp(WhatsApp):
         """
         return AsyncMessage(**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, **options):
-        _run(self.app, host=host, port=port, **options)
-
 
 class Message:
     # type: ignore
     def __init__(
         self,
-        id: int = None,
-        data: dict = {},
-        instance: WhatsApp = None,
+        id: Optional[str] = None,
+        data: Optional[dict] = None,
+        instance: Optional[WhatsApp] = None,
         content: str = "",
         to: str = "",
         rec_type: str = "individual",
     ):
+        data = data or {}
         self.instance = instance
         self.url = self.instance.url
         self.headers = self.instance.headers
 
         try:
             self.id = instance.get_message_id(data)
-        except:
+        except Exception:
             self.id = id
         try:
             self.type = self.instance.get_message_type(data)
-        except:
+        except Exception:
             self.type = "text"
         self.data = data
         self.rec = rec_type
-        self.to = to
+
+        try:
+            self.to = to if to != "" else self.instance.get_mobile(data)
+        except Exception:
+            self.to = to
+
+        try:
+            self.sender = self.instance.get_author(data) or self.to
+        except Exception:
+            self.sender = self.to
+
         try:
             self.content = content if content != "" else self.instance.get_message(data)
-        except:
+        except Exception:
             self.content = content
         try:
             self.name = self.instance.get_name(data)
-        except:
+        except Exception:
             self.name = None
 
         if self.type == "image":
             try:
                 self.image = self.instance.get_image(data)
-            except:
+            except Exception:
                 self.image = None
         if self.type == "sticker":
             try:
                 self.sticker = self.instance.get_sticker(data)
-            except:
+            except Exception:
                 self.sticker = None
         elif self.type == "video":
             try:
                 self.video = self.instance.get_video(data)
-            except:
+            except Exception:
                 self.video = None
         elif self.type == "audio":
             try:
                 self.audio = self.instance.get_audio(data)
-            except:
+            except Exception:
                 pass
         elif self.type == "document":
             try:
                 self.document = self.instance.get_document(data)
-            except:
+            except Exception:
                 pass
         elif self.type == "location":
             try:
                 self.location = self.instance.get_location(data)
-            except:
+            except Exception:
                 pass
         elif self.type == "interactive":
             try:
                 self.interactive = self.instance.get_interactive_response(data)
-            except:
+            except Exception:
                 pass
+        elif self.type == "reaction":
+            try:
+                self.reaction = self.instance.get_reaction(data)
+            except Exception:
+                self.reaction = None
 
     def reply(self, reply_text: str = "", preview_url: bool = True) -> dict:
         if self.data == {}:
@@ -677,36 +517,47 @@ class Message:
             return r.json()
         logging.info(f"Message not sent to {self.instance.get_author(self.data)}")
         logging.info(f"Status code: {r.status_code}")
-        logging.error(f"Response: {r.json()}")
+        logging.error("Request failed (status=%s)", r.status_code)
         return r.json()
 
-    def mark_as_read(self) -> dict:
+    def mark_as_read(self, typing: bool = False) -> dict:
+        """
+        Mark this inbound message as read.
 
-        payload = {
+        Args:
+            typing: When True, also display a typing indicator (dismissed after
+                a reply or ~25 seconds). See Meta typing-indicators docs.
+        """
+        payload: dict[str, Any] = {
             "messaging_product": "whatsapp",
             "status": "read",
             "message_id": self.id,
         }
+        if typing:
+            payload["typing_indicator"] = {"type": "text"}
 
         response = requests.post(
             f"{self.instance.url}", headers=self.instance.headers, json=payload
         )
         if response.status_code == 200:
-            logging.info(response.json())
-            return response.json()
-        else:
-            logging.error(response.json())
+            logging.info("Request succeeded (status=%s)", response.status_code)
             return response.json()
+        logging.error("Request failed (status=%s)", response.status_code)
+        return response.json()
+
+    def show_typing(self) -> dict:
+        """Mark as read and show a typing indicator while preparing a reply."""
+        return self.mark_as_read(typing=True)
 
     def send(self, sender=None, preview_url: bool = True) -> dict:
 
         try:
             sender = dict(self.instance.l)[sender]
 
-        except:
+        except Exception:
             sender = self.instance.phone_number_id
 
-        if sender == None:
+        if sender is None:
             sender = self.instance.phone_number_id
 
         url = f"https://graph.facebook.com/{self.instance.LATEST}/{sender}/messages"
@@ -724,7 +575,7 @@ class Message:
             return r.json()
         logging.info(f"Message not sent to {self.to}")
         logging.info(f"Status code: {r.status_code}")
-        logging.error(f"Response: {r.json()}")
+        logging.error("Request failed (status=%s)", r.status_code)
         return r.json()
 
     def react(self, emoji: str) -> dict:
@@ -742,7 +593,7 @@ class Message:
             return r.json()
         logging.info(f"Reaction not sent to {self.to}")
         logging.info(f"Status code: {r.status_code}")
-        logging.debug(f"Response: {r.json()}")
+        logging.debug("Request failed (status=%s)", r.status_code)
         return r.json()
 
 
@@ -750,72 +601,85 @@ class AsyncMessage:
     # type: ignore
     def __init__(
         self,
-        id: int = None,
-        data: dict = {},
-        instance: WhatsApp = None,
+        id: Optional[str] = None,
+        data: Optional[dict] = None,
+        instance: Optional[WhatsApp] = None,
         content: str = "",
         to: str = "",
         rec_type: str = "individual",
     ):
+        data = data or {}
         self.instance = instance
         self.url = self.instance.url
         self.headers = self.instance.headers
 
         try:
             self.id = instance.get_message_id(data)
-        except:
+        except Exception:
             self.id = id
         try:
             self.type = self.instance.get_message_type(data)
-        except:
+        except Exception:
             self.type = "text"
         self.data = data
         self.rec = rec_type
-        self.to = to
+        try:
+            self.to = to if to != "" else self.instance.get_mobile(data)
+        except Exception:
+            self.to = to
+        try:
+            self.sender = self.instance.get_author(data) or self.to
+        except Exception:
+            self.sender = self.to
         try:
             self.content = content if content != "" else self.instance.get_message(data)
-        except:
+        except Exception:
             self.content = content
         try:
             self.name = self.instance.get_name(data)
-        except:
+        except Exception:
             self.name = None
 
         if self.type == "image":
             try:
                 self.image = self.instance.get_image(data)
-            except:
+            except Exception:
                 self.image = None
         if self.type == "sticker":
             try:
                 self.sticker = self.instance.get_sticker(data)
-            except:
+            except Exception:
                 self.sticker = None
         elif self.type == "video":
             try:
                 self.video = self.instance.get_video(data)
-            except:
+            except Exception:
                 self.video = None
         elif self.type == "audio":
             try:
                 self.audio = self.instance.get_audio(data)
-            except:
+            except Exception:
                 pass
         elif self.type == "document":
             try:
                 self.document = self.instance.get_document(data)
-            except:
+            except Exception:
                 pass
         elif self.type == "location":
             try:
                 self.location = self.instance.get_location(data)
-            except:
+            except Exception:
                 pass
         elif self.type == "interactive":
             try:
                 self.interactive = self.instance.get_interactive_response(data)
-            except:
+            except Exception:
                 pass
+        elif self.type == "reaction":
+            try:
+                self.reaction = self.instance.get_reaction(data)
+            except Exception:
+                self.reaction = None
 
     async def reply(
         self, reply_text: str = "", preview_url: bool = True
@@ -847,20 +711,28 @@ class AsyncMessage:
                         f"Message not sent to {self.instance.get_author(self.data)}"
                     )
                     logging.info(f"Status code: {response.status}")
-                    logging.error(f"Response: {await response.json()}")
+                    logging.error("Request failed (status=%s)", response.status)
                     return await response.json()
 
         f = asyncio.ensure_future(call())
         await asyncio.sleep(0.001)  # make asyncio run the task
         return f
 
-    async def mark_as_read(self) -> asyncio.Future:
+    async def mark_as_read(self, typing: bool = False) -> asyncio.Future:
+        """
+        Mark this inbound message as read.
 
-        payload = {
+        Args:
+            typing: When True, also display a typing indicator (dismissed after
+                a reply or ~25 seconds). See Meta typing-indicators docs.
+        """
+        payload: dict[str, Any] = {
             "messaging_product": "whatsapp",
             "status": "read",
             "message_id": self.id,
         }
+        if typing:
+            payload["typing_indicator"] = {"type": "text"}
 
         async def call():
             async with aiohttp.ClientSession() as session:
@@ -868,24 +740,27 @@ class AsyncMessage:
                     f"{self.instance.url}", headers=self.instance.headers, json=payload
                 ) as response:
                     if response.status == 200:
-                        logging.info(await response.json())
-                        return await response.json()
-                    else:
-                        logging.error(await response.json())
+                        logging.info("Request succeeded (status=%s)", response.status)
                         return await response.json()
+                    logging.error("Request failed (status=%s)", response.status)
+                    return await response.json()
 
         f = asyncio.ensure_future(call())
         await asyncio.sleep(0.001)  # make asyncio run the task
         return f
 
+    async def show_typing(self) -> asyncio.Future:
+        """Mark as read and show a typing indicator while preparing a reply."""
+        return await self.mark_as_read(typing=True)
+
     async def send(self, sender=None, preview_url: bool = True) -> asyncio.Future:
         try:
             sender = dict(self.instance.l)[sender]
 
-        except:
+        except Exception:
             sender = self.instance.phone_number_id
 
-        if sender == None:
+        if sender is None:
             sender = self.instance.phone_number_id
 
         url = f"https://graph.facebook.com/{self.instance.LATEST}/{sender}/messages"
@@ -899,7 +774,6 @@ class AsyncMessage:
         logging.info(f"Sending message to {self.to}")
 
         async def call():
-            print("sending")
             async with aiohttp.ClientSession() as session:
                 async with session.post(
                     url, headers=self.headers, json=data
@@ -909,7 +783,7 @@ class AsyncMessage:
                         return await response.json()
                     logging.info(f"Message not sent to {self.to}")
                     logging.info(f"Status code: {response.status}")
-                    logging.error(f"Response: {await response.json()}")
+                    logging.error("Request failed (status=%s)", response.status)
                     return await response.json()
 
         f = asyncio.ensure_future(call())
@@ -936,7 +810,7 @@ class AsyncMessage:
                         return await response.json()
                     logging.info(f"Reaction not sent to {self.to}")
                     logging.info(f"Status code: {response.status}")
-                    logging.debug(f"Response: {await response.json()}")
+                    logging.debug("Request failed (status=%s)", response.status)
                     return await response.json()
 
         f = asyncio.ensure_future(call())