whatsapp-cloud-api-client 0.2.0__py3-none-any.whl

whatsapp_cloud_api/__init__.py

@@ -0,0 +1,21 @@
+from .client import AsyncWhatsAppClient, WhatsAppClient
+from .exceptions import WhatsAppAPIError
+from .models import (
+    MarkAsReadResponse,
+    MediaInfoResponse,
+    MediaUploadResponse,
+    SendMessageResponse,
+)
+from .webhook import verify_webhook_challenge, verify_webhook_signature
+
+__all__ = [
+    "AsyncWhatsAppClient",
+    "WhatsAppClient",
+    "WhatsAppAPIError",
+    "SendMessageResponse",
+    "MediaUploadResponse",
+    "MediaInfoResponse",
+    "MarkAsReadResponse",
+    "verify_webhook_challenge",
+    "verify_webhook_signature",
+]

whatsapp_cloud_api/client.py

@@ -0,0 +1,534 @@
+from __future__ import annotations
+
+import asyncio
+import mimetypes
+import time
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+from pathlib import Path
+from typing import Any, Iterable
+
+import httpx
+
+from .exceptions import WhatsAppAPIError
+from .models import MarkAsReadResponse, MediaInfoResponse, MediaUploadResponse, SendMessageResponse
+
+DEFAULT_RETRY_STATUS_CODES = frozenset({429, 500, 502, 503, 504})
+DEFAULT_RETRY_METHODS = frozenset({"GET"})
+
+
+def _raise_for_api_error(response: httpx.Response, data: Any) -> None:
+    if not response.is_error:
+        return
+
+    err = data.get("error", {}) if isinstance(data, dict) else {}
+    raise WhatsAppAPIError(
+        message=err.get("message") or f"HTTP {response.status_code}",
+        status_code=response.status_code,
+        error_type=err.get("type"),
+        code=err.get("code"),
+        error_subcode=err.get("error_subcode"),
+        fbtrace_id=err.get("fbtrace_id"),
+        details=data if isinstance(data, dict) else {"raw": data},
+    )
+
+
+def _parse_json_response(response: httpx.Response) -> dict[str, Any]:
+    try:
+        data = response.json()
+    except ValueError:
+        data = {}
+
+    _raise_for_api_error(response, data)
+    return data if isinstance(data, dict) else {"raw": data}
+
+
+def _build_media_payload(
+    *,
+    media_id: str | None,
+    link: str | None,
+    caption: str | None,
+    filename: str | None,
+) -> dict[str, Any]:
+    if not media_id and not link:
+        raise ValueError("media_id or link is required")
+    if media_id and link:
+        raise ValueError("use only one of media_id or link")
+
+    media_payload: dict[str, Any] = {}
+    if media_id:
+        media_payload["id"] = media_id
+    if link:
+        media_payload["link"] = link
+    if caption:
+        media_payload["caption"] = caption
+    if filename:
+        media_payload["filename"] = filename
+    return media_payload
+
+
+def _normalize_methods(methods: Iterable[str] | None) -> frozenset[str]:
+    if methods is None:
+        return DEFAULT_RETRY_METHODS
+    return frozenset(method.upper() for method in methods)
+
+
+def _parse_retry_after_seconds(retry_after: str | None) -> float | None:
+    if not retry_after:
+        return None
+
+    retry_after = retry_after.strip()
+    try:
+        seconds = float(retry_after)
+        return seconds if seconds > 0 else None
+    except ValueError:
+        pass
+
+    try:
+        parsed_date = parsedate_to_datetime(retry_after)
+    except (TypeError, ValueError):
+        return None
+
+    if parsed_date.tzinfo is None:
+        parsed_date = parsed_date.replace(tzinfo=timezone.utc)
+    now = datetime.now(timezone.utc)
+    seconds = (parsed_date - now).total_seconds()
+    return seconds if seconds > 0 else None
+
+
+class _RetryMixin:
+    max_retries: int
+    backoff_factor: float
+    max_backoff: float
+    retry_status_codes: frozenset[int]
+    retry_methods: frozenset[str]
+
+    def _should_retry_method(self, method: str) -> bool:
+        return method.upper() in self.retry_methods
+
+    def _get_retry_delay(self, attempt: int, retry_after: str | None) -> float:
+        header_delay = _parse_retry_after_seconds(retry_after)
+        if header_delay is not None:
+            return min(self.max_backoff, header_delay)
+
+        exponential_delay = self.backoff_factor * (2**attempt)
+        return min(self.max_backoff, exponential_delay)
+
+    def _should_retry_response(self, response: httpx.Response) -> bool:
+        return response.status_code in self.retry_status_codes
+
+
+class WhatsAppClient(_RetryMixin):
+    def __init__(
+        self,
+        access_token: str,
+        phone_number_id: str,
+        *,
+        api_version: str = "v20.0",
+        timeout: float = 20.0,
+        base_url: str = "https://graph.facebook.com",
+        http_client: httpx.Client | None = None,
+        max_retries: int = 3,
+        backoff_factor: float = 0.5,
+        max_backoff: float = 8.0,
+        retry_status_codes: Iterable[int] | None = None,
+        retry_methods: Iterable[str] | None = None,
+    ) -> None:
+        if not access_token:
+            raise ValueError("access_token is required")
+        if not phone_number_id:
+            raise ValueError("phone_number_id is required")
+        if max_retries < 0:
+            raise ValueError("max_retries must be >= 0")
+
+        self.access_token = access_token
+        self.phone_number_id = phone_number_id
+        self.api_version = api_version
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.backoff_factor = backoff_factor
+        self.max_backoff = max_backoff
+        self.retry_status_codes = frozenset(retry_status_codes or DEFAULT_RETRY_STATUS_CODES)
+        self.retry_methods = _normalize_methods(retry_methods)
+
+        self._owns_client = http_client is None
+        self._client = http_client or httpx.Client(
+            base_url=f"{self.base_url}/{self.api_version}",
+            timeout=self.timeout,
+            headers={
+                "Authorization": f"Bearer {self.access_token}",
+                "Content-Type": "application/json",
+            },
+        )
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._client.close()
+
+    def __enter__(self) -> "WhatsAppClient":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
+    def send_text(
+        self,
+        *,
+        to: str,
+        body: str,
+        preview_url: bool = False,
+        context_message_id: str | None = None,
+    ) -> SendMessageResponse:
+        payload: dict[str, Any] = {
+            "messaging_product": "whatsapp",
+            "to": to,
+            "type": "text",
+            "text": {"body": body, "preview_url": preview_url},
+        }
+        if context_message_id:
+            payload["context"] = {"message_id": context_message_id}
+        data = self._request("POST", f"/{self.phone_number_id}/messages", json=payload)
+        return SendMessageResponse.model_validate(data)
+
+    def send_template(
+        self,
+        *,
+        to: str,
+        name: str,
+        language_code: str = "pt_BR",
+        components: list[dict[str, Any]] | None = None,
+    ) -> SendMessageResponse:
+        template: dict[str, Any] = {"name": name, "language": {"code": language_code}}
+        if components:
+            template["components"] = components
+
+        payload = {
+            "messaging_product": "whatsapp",
+            "to": to,
+            "type": "template",
+            "template": template,
+        }
+        data = self._request("POST", f"/{self.phone_number_id}/messages", json=payload)
+        return SendMessageResponse.model_validate(data)
+
+    def send_media(
+        self,
+        *,
+        to: str,
+        media_type: str,
+        media_id: str | None = None,
+        link: str | None = None,
+        caption: str | None = None,
+        filename: str | None = None,
+    ) -> SendMessageResponse:
+        media_payload = _build_media_payload(
+            media_id=media_id,
+            link=link,
+            caption=caption,
+            filename=filename,
+        )
+        payload = {
+            "messaging_product": "whatsapp",
+            "to": to,
+            "type": media_type,
+            media_type: media_payload,
+        }
+        data = self._request("POST", f"/{self.phone_number_id}/messages", json=payload)
+        return SendMessageResponse.model_validate(data)
+
+    def upload_media(
+        self,
+        *,
+        file_path: str | Path,
+        mime_type: str | None = None,
+        filename: str | None = None,
+    ) -> MediaUploadResponse:
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(f"file not found: {path}")
+
+        guessed_mime, _ = mimetypes.guess_type(str(path))
+        final_mime = mime_type or guessed_mime or "application/octet-stream"
+        final_name = filename or path.name
+
+        with path.open("rb") as file_handle:
+            files = {
+                "file": (final_name, file_handle, final_mime),
+                "messaging_product": (None, "whatsapp"),
+            }
+            data = self._request(
+                "POST",
+                f"/{self.phone_number_id}/media",
+                files=files,
+                content_type_json=False,
+            )
+        return MediaUploadResponse.model_validate(data)
+
+    def get_media(self, *, media_id: str) -> MediaInfoResponse:
+        data = self._request("GET", f"/{media_id}")
+        return MediaInfoResponse.model_validate(data)
+
+    def mark_as_read(self, *, message_id: str) -> MarkAsReadResponse:
+        payload = {
+            "messaging_product": "whatsapp",
+            "status": "read",
+            "message_id": message_id,
+        }
+        data = self._request("POST", f"/{self.phone_number_id}/messages", json=payload)
+        return MarkAsReadResponse.model_validate(data)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        files: dict[str, Any] | None = None,
+        content_type_json: bool = True,
+    ) -> dict[str, Any]:
+        headers = None
+        if not content_type_json:
+            headers = {"Authorization": f"Bearer {self.access_token}"}
+
+        attempt = 0
+        can_retry_method = self._should_retry_method(method)
+
+        while True:
+            try:
+                response = self._client.request(
+                    method=method,
+                    url=path,
+                    json=json,
+                    files=files,
+                    headers=headers,
+                )
+            except httpx.HTTPError as exc:
+                if not can_retry_method or attempt >= self.max_retries:
+                    raise WhatsAppAPIError(message=f"HTTP communication error: {exc}") from exc
+                delay = self._get_retry_delay(attempt, None)
+                if delay > 0:
+                    time.sleep(delay)
+                attempt += 1
+                continue
+
+            if (
+                can_retry_method
+                and attempt < self.max_retries
+                and self._should_retry_response(response)
+            ):
+                delay = self._get_retry_delay(attempt, response.headers.get("Retry-After"))
+                if delay > 0:
+                    time.sleep(delay)
+                attempt += 1
+                continue
+
+            return _parse_json_response(response)
+
+
+class AsyncWhatsAppClient(_RetryMixin):
+    def __init__(
+        self,
+        access_token: str,
+        phone_number_id: str,
+        *,
+        api_version: str = "v20.0",
+        timeout: float = 20.0,
+        base_url: str = "https://graph.facebook.com",
+        http_client: httpx.AsyncClient | None = None,
+        max_retries: int = 3,
+        backoff_factor: float = 0.5,
+        max_backoff: float = 8.0,
+        retry_status_codes: Iterable[int] | None = None,
+        retry_methods: Iterable[str] | None = None,
+    ) -> None:
+        if not access_token:
+            raise ValueError("access_token is required")
+        if not phone_number_id:
+            raise ValueError("phone_number_id is required")
+        if max_retries < 0:
+            raise ValueError("max_retries must be >= 0")
+
+        self.access_token = access_token
+        self.phone_number_id = phone_number_id
+        self.api_version = api_version
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.backoff_factor = backoff_factor
+        self.max_backoff = max_backoff
+        self.retry_status_codes = frozenset(retry_status_codes or DEFAULT_RETRY_STATUS_CODES)
+        self.retry_methods = _normalize_methods(retry_methods)
+
+        self._owns_client = http_client is None
+        self._client = http_client or httpx.AsyncClient(
+            base_url=f"{self.base_url}/{self.api_version}",
+            timeout=self.timeout,
+            headers={
+                "Authorization": f"Bearer {self.access_token}",
+                "Content-Type": "application/json",
+            },
+        )
+
+    async def aclose(self) -> None:
+        if self._owns_client:
+            await self._client.aclose()
+
+    async def __aenter__(self) -> "AsyncWhatsAppClient":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.aclose()
+
+    async def send_text(
+        self,
+        *,
+        to: str,
+        body: str,
+        preview_url: bool = False,
+        context_message_id: str | None = None,
+    ) -> SendMessageResponse:
+        payload: dict[str, Any] = {
+            "messaging_product": "whatsapp",
+            "to": to,
+            "type": "text",
+            "text": {"body": body, "preview_url": preview_url},
+        }
+        if context_message_id:
+            payload["context"] = {"message_id": context_message_id}
+        data = await self._request("POST", f"/{self.phone_number_id}/messages", json=payload)
+        return SendMessageResponse.model_validate(data)
+
+    async def send_template(
+        self,
+        *,
+        to: str,
+        name: str,
+        language_code: str = "pt_BR",
+        components: list[dict[str, Any]] | None = None,
+    ) -> SendMessageResponse:
+        template: dict[str, Any] = {"name": name, "language": {"code": language_code}}
+        if components:
+            template["components"] = components
+
+        payload = {
+            "messaging_product": "whatsapp",
+            "to": to,
+            "type": "template",
+            "template": template,
+        }
+        data = await self._request("POST", f"/{self.phone_number_id}/messages", json=payload)
+        return SendMessageResponse.model_validate(data)
+
+    async def send_media(
+        self,
+        *,
+        to: str,
+        media_type: str,
+        media_id: str | None = None,
+        link: str | None = None,
+        caption: str | None = None,
+        filename: str | None = None,
+    ) -> SendMessageResponse:
+        media_payload = _build_media_payload(
+            media_id=media_id,
+            link=link,
+            caption=caption,
+            filename=filename,
+        )
+        payload = {
+            "messaging_product": "whatsapp",
+            "to": to,
+            "type": media_type,
+            media_type: media_payload,
+        }
+        data = await self._request("POST", f"/{self.phone_number_id}/messages", json=payload)
+        return SendMessageResponse.model_validate(data)
+
+    async def upload_media(
+        self,
+        *,
+        file_path: str | Path,
+        mime_type: str | None = None,
+        filename: str | None = None,
+    ) -> MediaUploadResponse:
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(f"file not found: {path}")
+
+        guessed_mime, _ = mimetypes.guess_type(str(path))
+        final_mime = mime_type or guessed_mime or "application/octet-stream"
+        final_name = filename or path.name
+
+        with path.open("rb") as file_handle:
+            files = {
+                "file": (final_name, file_handle, final_mime),
+                "messaging_product": (None, "whatsapp"),
+            }
+            data = await self._request(
+                "POST",
+                f"/{self.phone_number_id}/media",
+                files=files,
+                content_type_json=False,
+            )
+        return MediaUploadResponse.model_validate(data)
+
+    async def get_media(self, *, media_id: str) -> MediaInfoResponse:
+        data = await self._request("GET", f"/{media_id}")
+        return MediaInfoResponse.model_validate(data)
+
+    async def mark_as_read(self, *, message_id: str) -> MarkAsReadResponse:
+        payload = {
+            "messaging_product": "whatsapp",
+            "status": "read",
+            "message_id": message_id,
+        }
+        data = await self._request("POST", f"/{self.phone_number_id}/messages", json=payload)
+        return MarkAsReadResponse.model_validate(data)
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        files: dict[str, Any] | None = None,
+        content_type_json: bool = True,
+    ) -> dict[str, Any]:
+        headers = None
+        if not content_type_json:
+            headers = {"Authorization": f"Bearer {self.access_token}"}
+
+        attempt = 0
+        can_retry_method = self._should_retry_method(method)
+
+        while True:
+            try:
+                response = await self._client.request(
+                    method=method,
+                    url=path,
+                    json=json,
+                    files=files,
+                    headers=headers,
+                )
+            except httpx.HTTPError as exc:
+                if not can_retry_method or attempt >= self.max_retries:
+                    raise WhatsAppAPIError(message=f"HTTP communication error: {exc}") from exc
+                delay = self._get_retry_delay(attempt, None)
+                if delay > 0:
+                    await asyncio.sleep(delay)
+                attempt += 1
+                continue
+
+            if (
+                can_retry_method
+                and attempt < self.max_retries
+                and self._should_retry_response(response)
+            ):
+                delay = self._get_retry_delay(attempt, response.headers.get("Retry-After"))
+                if delay > 0:
+                    await asyncio.sleep(delay)
+                attempt += 1
+                continue
+
+            return _parse_json_response(response)

whatsapp_cloud_api/exceptions.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class WhatsAppAPIError(Exception):
+    message: str
+    status_code: int | None = None
+    error_type: str | None = None
+    code: int | None = None
+    error_subcode: int | None = None
+    fbtrace_id: str | None = None
+    details: dict | None = None
+
+    def __str__(self) -> str:
+        parts = [self.message]
+        if self.status_code is not None:
+            parts.append(f"status={self.status_code}")
+        if self.code is not None:
+            parts.append(f"code={self.code}")
+        if self.error_subcode is not None:
+            parts.append(f"subcode={self.error_subcode}")
+        if self.error_type:
+            parts.append(f"type={self.error_type}")
+        return " | ".join(parts)

whatsapp_cloud_api/models.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BaseResponseModel(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+
+class Contact(BaseResponseModel):
+    input: str | None = None
+    wa_id: str | None = None
+
+
+class Message(BaseResponseModel):
+    id: str
+    message_status: str | None = None
+
+
+class SendMessageResponse(BaseResponseModel):
+    messaging_product: str = "whatsapp"
+    contacts: list[Contact] = Field(default_factory=list)
+    messages: list[Message] = Field(default_factory=list)
+
+
+class MediaUploadResponse(BaseResponseModel):
+    id: str
+
+
+class MediaInfoResponse(BaseResponseModel):
+    id: str | None = None
+    messaging_product: str | None = None
+    url: str | None = None
+    mime_type: str | None = None
+    sha256: str | None = None
+    file_size: int | None = None
+
+
+class MarkAsReadResponse(BaseResponseModel):
+    success: bool = False

whatsapp_cloud_api/webhook.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+
+
+def verify_webhook_challenge(
+    *,
+    mode: str | None,
+    token: str | None,
+    challenge: str | None,
+    verify_token: str,
+) -> tuple[bool, str]:
+    if mode == "subscribe" and token == verify_token and challenge is not None:
+        return True, challenge
+    return False, ""
+
+
+def verify_webhook_signature(
+    *,
+    app_secret: str,
+    raw_body: bytes,
+    x_hub_signature_256: str,
+) -> bool:
+    if not x_hub_signature_256.startswith("sha256="):
+        return False
+
+    expected = hmac.new(
+        app_secret.encode("utf-8"),
+        raw_body,
+        hashlib.sha256,
+    ).hexdigest()
+    received = x_hub_signature_256.split("=", 1)[1]
+    return hmac.compare_digest(expected, received)

whatsapp_cloud_api_client-0.2.0.dist-info/METADATA

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: whatsapp-cloud-api-client
+Version: 0.2.0
+Summary: Biblioteca Python para integração com a API Oficial do WhatsApp (Cloud API).
+Author: Seu Nome
+License: MIT
+Project-URL: Homepage, https://github.com/seu-usuario/whatsapp-cloud-api-client
+Project-URL: Documentation, https://github.com/seu-usuario/whatsapp-cloud-api-client#readme
+Project-URL: Issues, https://github.com/seu-usuario/whatsapp-cloud-api-client/issues
+Keywords: whatsapp,whatsapp cloud api,meta,messaging,python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1.0.0,>=0.27.0
+Requires-Dist: pydantic<3.0.0,>=2.7.0
+Requires-Dist: eval-type-backport>=0.2.0; python_version < "3.10"
+Provides-Extra: dev
+Requires-Dist: pytest<9.0.0,>=8.2.0; extra == "dev"
+Requires-Dist: pytest-asyncio<1.0.0,>=0.23.7; extra == "dev"
+
+# WhatsApp Cloud API Client (Python)
+
+Biblioteca Python para integracao com a API Oficial do WhatsApp (Cloud API), com foco em simplicidade de uso em apps.
+
+## Instalacao
+
+```bash
+pip install whatsapp-cloud-api-client
+```
+
+Para desenvolvimento local:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Uso rapido (sync)
+
+```python
+from whatsapp_cloud_api import WhatsAppClient
+
+client = WhatsAppClient(
+    access_token="SEU_TOKEN",
+    phone_number_id="SEU_PHONE_NUMBER_ID",
+)
+
+resp = client.send_text(
+    to="5511999999999",
+    body="Ola! Mensagem enviada via Cloud API.",
+)
+print(resp.model_dump())
+```
+
+## Uso rapido (async)
+
+```python
+import asyncio
+from whatsapp_cloud_api import AsyncWhatsAppClient
+
+
+async def main() -> None:
+    async with AsyncWhatsAppClient(
+        access_token="SEU_TOKEN",
+        phone_number_id="SEU_PHONE_NUMBER_ID",
+    ) as client:
+        resp = await client.send_text(
+            to="5511999999999",
+            body="Mensagem async",
+        )
+        print(resp.model_dump())
+
+
+asyncio.run(main())
+```
+
+## Modelos tipados (Pydantic)
+
+Os metodos retornam modelos Pydantic:
+
+- `SendMessageResponse`
+- `MediaUploadResponse`
+- `MediaInfoResponse`
+- `MarkAsReadResponse`
+
+## Retry, backoff e rate limit
+
+O cliente possui retry configuravel para erros transientes (`429`, `500`, `502`, `503`, `504`).
+
+Por padrao, retry roda apenas para `GET` para evitar duplicidade em envio de mensagem (`POST`).
+
+```python
+from whatsapp_cloud_api import WhatsAppClient
+
+client = WhatsAppClient(
+    access_token="SEU_TOKEN",
+    phone_number_id="SEU_PHONE_NUMBER_ID",
+    max_retries=3,
+    backoff_factor=0.5,
+    max_backoff=8.0,
+    retry_methods={"GET", "POST"},  # habilite POST se quiser retry em envio
+)
+```
+
+Se a API retornar `Retry-After`, esse valor sera respeitado.
+
+## Funcionalidades implementadas
+
+- Envio de mensagem de texto
+- Envio de mensagem template
+- Envio de midia por `media_id` ou `link` (imagem, documento, video, audio, sticker)
+- Upload de midia
+- Marcar mensagem como lida
+- Busca de informacoes de midia
+- Validacao de assinatura de webhook (`X-Hub-Signature-256`)
+- Cliente sincrono e assincrono
+
+## Exemplo com Flask (webhook)
+
+```python
+from flask import Flask, request, jsonify
+from whatsapp_cloud_api import verify_webhook_signature, verify_webhook_challenge
+
+app = Flask(__name__)
+APP_SECRET = "SEU_APP_SECRET"
+VERIFY_TOKEN = "SEU_VERIFY_TOKEN"
+
+
+@app.get("/webhook")
+def webhook_verify():
+    ok, challenge = verify_webhook_challenge(
+        mode=request.args.get("hub.mode"),
+        token=request.args.get("hub.verify_token"),
+        challenge=request.args.get("hub.challenge"),
+        verify_token=VERIFY_TOKEN,
+    )
+    if not ok:
+        return "forbidden", 403
+    return challenge, 200
+
+
+@app.post("/webhook")
+def webhook_receive():
+    if not verify_webhook_signature(
+        app_secret=APP_SECRET,
+        raw_body=request.get_data(),
+        x_hub_signature_256=request.headers.get("X-Hub-Signature-256", ""),
+    ):
+        return "invalid signature", 401
+
+    data = request.get_json(silent=True) or {}
+    return jsonify({"ok": True, "received": bool(data)}), 200
+```
+
+## Rodar testes
+
+```bash
+pytest
+```
+
+## CI e publicacao
+
+- CI: `.github/workflows/ci.yml`
+- Criacao de tag/release: `.github/workflows/release.yml`
+- Publicacao PyPI: `.github/workflows/publish.yml`
+
+Fluxo recomendado:
+
+1. Execute o workflow `Create Release` e informe a tag (ex: `v0.2.0`).
+2. O release publicado dispara `Publish to PyPI`.
+3. Configure Trusted Publisher no PyPI para este repositorio (OIDC), sem token manual.
+
+Opcional: se preferir token, adapte o workflow para usar `PYPI_API_TOKEN`.
+
+## Licenca
+
+MIT

whatsapp_cloud_api_client-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+whatsapp_cloud_api/__init__.py,sha256=5f7TuE8zrUgyhGEZLIx6D6OIjMkYQEJk5ZviBtdBHB0,547
+whatsapp_cloud_api/client.py,sha256=zn1hHqNp4DJSVf_u9FxLaZgrBmL04to-tMz5Avv-4JM,17568
+whatsapp_cloud_api/exceptions.py,sha256=C7G-wWYcSS_WhK0U1Xh9ZEDjynU3gkVod1Aqkdsk5k0,787
+whatsapp_cloud_api/models.py,sha256=zLdPVuQPVCUJ326gn6bLJr33IoRwQaKrsC79kIbrlXw,922
+whatsapp_cloud_api/webhook.py,sha256=lV24A1Kh96k2Ep2UBMGEbWDx6KfBBbE_pw81dHG2myU,774
+whatsapp_cloud_api_client-0.2.0.dist-info/METADATA,sha256=Jnkc-9zXXxPsgWljVj786r4EL7EiPgwRN9MarDP6qOM,4944
+whatsapp_cloud_api_client-0.2.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+whatsapp_cloud_api_client-0.2.0.dist-info/top_level.txt,sha256=2Zz2K8CKiOtHiZE3M5qAHpHd8KF8a5kpJbo2FnB5DpU,19
+whatsapp_cloud_api_client-0.2.0.dist-info/RECORD,,

whatsapp_cloud_api_client-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

whatsapp_cloud_api_client-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+whatsapp_cloud_api