omdaa-api-client 1.0.0__tar.gz

omdaa_api_client-1.0.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: omdaa-api-client
+Version: 1.0.0
+Summary: Official Python client for Omdaa WhatsApp Business API
+Author: Omdaa
+License: MIT
+Project-URL: Homepage, https://omdaa.com
+Project-URL: Documentation, https://omdaanet/docs/sdk
+Keywords: omdaa,whatsapp,api,client,sdk
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+
+# omdaa-api-client (Python)
+
+Official Python client for the [Omdaa](https://omdaa.com) WhatsApp Business API.
+
+## Installation
+
+```bash
+pip install omdaa-api-client
+```
+
+## Quick Start
+
+```python
+from omdaa import OmdaaClient, OmdaaError
+
+client = OmdaaClient("your-api-key")
+# Optional: OmdaaClient("your-api-key", base_url="https://omdaa.com/api/v1")
+
+try:
+    sessions = client.sessions.list()
+    result = client.messages.send_text({
+        "sessionId": "default",
+        "to": "201234567890",
+        "message": "Hello from Omdaa Python!",
+    })
+    client.webhooks.set({"url": "https://yoursite.com/webhook", "enabled": True})
+except OmdaaError as e:
+    print(e.status_code, str(e))
+```
+
+## API Resources
+
+Same as the Node.js SDK: `messages`, `sessions`, `webhooks`, `templates`, `scheduled`, `bulk`, `contacts`, `groups`, `chats`, `business`, `storage`, `labels`, `integrations`, `queue`, `interactive`, `api_keys`, `profile`, `dashboard`, `plans`, `billing`, `referral`, `notifications`, `metrics`, `backup`, `security`, `audit`, `organizations`, `settings`, `channels`, `privacy`, `support`, `proxy`, `calls`, `auth`, `users`, `email`, `ai`.
+
+## Requirements
+
+- Python 3.9+
+- requests >= 2.28.0
+
+## Development & tests
+
+```bash
+pip install -e ".[dev]"
+python -m pytest tests -v
+# or: python -m unittest discover -s tests -v
+```
+
+## License
+
+MIT

omdaa_api_client-1.0.0/README.md

@@ -0,0 +1,50 @@
+# omdaa-api-client (Python)
+
+Official Python client for the [Omdaa](https://omdaa.com) WhatsApp Business API.
+
+## Installation
+
+```bash
+pip install omdaa-api-client
+```
+
+## Quick Start
+
+```python
+from omdaa import OmdaaClient, OmdaaError
+
+client = OmdaaClient("your-api-key")
+# Optional: OmdaaClient("your-api-key", base_url="https://omdaa.com/api/v1")
+
+try:
+    sessions = client.sessions.list()
+    result = client.messages.send_text({
+        "sessionId": "default",
+        "to": "201234567890",
+        "message": "Hello from Omdaa Python!",
+    })
+    client.webhooks.set({"url": "https://yoursite.com/webhook", "enabled": True})
+except OmdaaError as e:
+    print(e.status_code, str(e))
+```
+
+## API Resources
+
+Same as the Node.js SDK: `messages`, `sessions`, `webhooks`, `templates`, `scheduled`, `bulk`, `contacts`, `groups`, `chats`, `business`, `storage`, `labels`, `integrations`, `queue`, `interactive`, `api_keys`, `profile`, `dashboard`, `plans`, `billing`, `referral`, `notifications`, `metrics`, `backup`, `security`, `audit`, `organizations`, `settings`, `channels`, `privacy`, `support`, `proxy`, `calls`, `auth`, `users`, `email`, `ai`.
+
+## Requirements
+
+- Python 3.9+
+- requests >= 2.28.0
+
+## Development & tests
+
+```bash
+pip install -e ".[dev]"
+python -m pytest tests -v
+# or: python -m unittest discover -s tests -v
+```
+
+## License
+
+MIT

omdaa_api_client-1.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "omdaa-api-client"
+version = "1.0.0"
+description = "Official Python client for Omdaa WhatsApp Business API"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Omdaa" }]
+keywords = ["omdaa", "whatsapp", "api", "client", "sdk"]
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-cov>=4.0"]
+
+[project.urls]
+Homepage = "https://omdaa.com"
+Documentation = "https://omdaanet/docs/sdk"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"

omdaa_api_client-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

omdaa_api_client-1.0.0/src/omdaa/__init__.py

@@ -0,0 +1,9 @@
+"""
+Omdaa API Client - Official Python SDK for Omdaa WhatsApp Business API.
+"""
+
+from omdaa.client import OmdaaClient
+from omdaa.exceptions import OmdaaError
+
+__all__ = ["OmdaaClient", "OmdaaError"]
+__version__ = "1.0.0"

omdaa_api_client-1.0.0/src/omdaa/client.py

@@ -0,0 +1,157 @@
+"""
+HTTP client for Omdaa API with Bearer auth.
+"""
+
+from typing import Optional
+
+import requests
+from omdaa.exceptions import OmdaaError
+
+DEFAULT_BASE_URL = "https://omdaa.com/api/v1"
+
+
+class Client:
+    def __init__(self, api_key: str, base_url: Optional[str] = None):
+        self.api_key = api_key
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self._session = requests.Session()
+        self._session.headers.update({
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        })
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        body: Optional[dict] = None,
+        params: Optional[dict] = None,
+    ) -> dict:
+        url = f"{self.base_url}{path}" if path.startswith("/") else f"{self.base_url}/{path}"
+        kwargs = {}
+        if params:
+            kwargs["params"] = {k: v for k, v in params.items() if v is not None}
+        if body and method != "GET":
+            kwargs["json"] = body
+        try:
+            r = self._session.request(method, url, **kwargs)
+            data = r.json() if r.content else {}
+            if not r.ok:
+                raise OmdaaError(
+                    data.get("message", r.text or r.reason),
+                    status_code=r.status_code,
+                    body=data if isinstance(data, dict) else None,
+                )
+            return data
+        except OmdaaError:
+            raise
+        except requests.RequestException as e:
+            raise OmdaaError(str(e)) from e
+
+    def get(self, path: str, params: dict | None = None) -> dict:
+        return self.request("GET", path, params=params)
+
+    def post(self, path: str, body: Optional[dict] = None) -> dict:
+        return self.request("POST", path, body=body or {})
+
+    def put(self, path: str, body: Optional[dict] = None) -> dict:
+        return self.request("PUT", path, body=body or {})
+
+    def delete(self, path: str, body: Optional[dict] = None) -> dict:
+        return self.request("DELETE", path, body=body)
+
+
+class OmdaaClient:
+    """Main client with all API resources. Use with API Key (Bearer auth)."""
+
+    def __init__(self, api_key: str, base_url: Optional[str] = None):
+        self._client = Client(api_key, base_url)
+        from omdaa.resources.resources import (
+            MessagesResource,
+            SessionsResource,
+            WebhooksResource,
+            TemplatesResource,
+            ScheduledResource,
+            BulkResource,
+            ContactsResource,
+            GroupsResource,
+            ChatsResource,
+            BusinessResource,
+            StorageResource,
+            LabelsResource,
+            IntegrationsResource,
+            QueueResource,
+            InteractiveResource,
+            ApiKeysResource,
+            ProfileResource,
+            DashboardResource,
+            PlansResource,
+            BillingResource,
+            ReferralResource,
+            NotificationsResource,
+            MetricsResource,
+            BackupResource,
+            SecurityResource,
+            AuditResource,
+            OrganizationsResource,
+            SettingsResource,
+            ChannelsResource,
+            PrivacyResource,
+            SupportResource,
+            ProxyResource,
+            CallsResource,
+            AuthResource,
+            UsersResource,
+            EmailResource,
+            AiResource,
+        )
+        self.messages = MessagesResource(self)
+        self.sessions = SessionsResource(self)
+        self.webhooks = WebhooksResource(self)
+        self.templates = TemplatesResource(self)
+        self.scheduled = ScheduledResource(self)
+        self.bulk = BulkResource(self)
+        self.contacts = ContactsResource(self)
+        self.groups = GroupsResource(self)
+        self.chats = ChatsResource(self)
+        self.business = BusinessResource(self)
+        self.storage = StorageResource(self)
+        self.labels = LabelsResource(self)
+        self.integrations = IntegrationsResource(self)
+        self.queue = QueueResource(self)
+        self.interactive = InteractiveResource(self)
+        self.api_keys = ApiKeysResource(self)
+        self.profile = ProfileResource(self)
+        self.dashboard = DashboardResource(self)
+        self.plans = PlansResource(self)
+        self.billing = BillingResource(self)
+        self.referral = ReferralResource(self)
+        self.notifications = NotificationsResource(self)
+        self.metrics = MetricsResource(self)
+        self.backup = BackupResource(self)
+        self.security = SecurityResource(self)
+        self.audit = AuditResource(self)
+        self.organizations = OrganizationsResource(self)
+        self.settings = SettingsResource(self)
+        self.channels = ChannelsResource(self)
+        self.privacy = PrivacyResource(self)
+        self.support = SupportResource(self)
+        self.proxy = ProxyResource(self)
+        self.calls = CallsResource(self)
+        self.auth = AuthResource(self)
+        self.users = UsersResource(self)
+        self.email = EmailResource(self)
+        self.ai = AiResource(self)
+
+    def get(self, path: str, params: Optional[dict] = None) -> dict:
+        return self._client.get(path, params=params)
+
+    def post(self, path: str, body: Optional[dict] = None) -> dict:
+        return self._client.post(path, body=body)
+
+    def put(self, path: str, body: Optional[dict] = None) -> dict:
+        return self._client.put(path, body=body)
+
+    def delete(self, path: str, body: Optional[dict] = None) -> dict:
+        return self._client.delete(path, body=body)

omdaa_api_client-1.0.0/src/omdaa/exceptions.py

@@ -0,0 +1,8 @@
+from typing import Optional
+
+
+class OmdaaError(Exception):
+    def __init__(self, message: str, status_code: Optional[int] = None, body: Optional[dict] = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body

omdaa_api_client-1.0.0/src/omdaa/resources/__init__.py

@@ -0,0 +1,79 @@
+from omdaa.resources.resources import (
+    MessagesResource,
+    SessionsResource,
+    WebhooksResource,
+    TemplatesResource,
+    ScheduledResource,
+    BulkResource,
+    ContactsResource,
+    GroupsResource,
+    ChatsResource,
+    BusinessResource,
+    StorageResource,
+    LabelsResource,
+    IntegrationsResource,
+    QueueResource,
+    InteractiveResource,
+    ApiKeysResource,
+    ProfileResource,
+    DashboardResource,
+    PlansResource,
+    BillingResource,
+    ReferralResource,
+    NotificationsResource,
+    MetricsResource,
+    BackupResource,
+    SecurityResource,
+    AuditResource,
+    OrganizationsResource,
+    SettingsResource,
+    ChannelsResource,
+    PrivacyResource,
+    SupportResource,
+    ProxyResource,
+    CallsResource,
+    AuthResource,
+    UsersResource,
+    EmailResource,
+    AiResource,
+)
+
+__all__ = [
+    "MessagesResource",
+    "SessionsResource",
+    "WebhooksResource",
+    "TemplatesResource",
+    "ScheduledResource",
+    "BulkResource",
+    "ContactsResource",
+    "GroupsResource",
+    "ChatsResource",
+    "BusinessResource",
+    "StorageResource",
+    "LabelsResource",
+    "IntegrationsResource",
+    "QueueResource",
+    "InteractiveResource",
+    "ApiKeysResource",
+    "ProfileResource",
+    "DashboardResource",
+    "PlansResource",
+    "BillingResource",
+    "ReferralResource",
+    "NotificationsResource",
+    "MetricsResource",
+    "BackupResource",
+    "SecurityResource",
+    "AuditResource",
+    "OrganizationsResource",
+    "SettingsResource",
+    "ChannelsResource",
+    "PrivacyResource",
+    "SupportResource",
+    "ProxyResource",
+    "CallsResource",
+    "AuthResource",
+    "UsersResource",
+    "EmailResource",
+    "AiResource",
+]

omdaa_api_client-1.0.0/src/omdaa/resources/resources.py

@@ -0,0 +1,617 @@
+# All API resources - mirror omdaa-js SDK paths and methods.
+from urllib.parse import quote
+
+
+class MessagesResource:
+    def __init__(self, client):
+        self._client = client
+
+    def send_text(self, params):
+        body = {
+            "sessionId": params.get("sessionId"),
+            "to": params.get("to"),
+            "message": params.get("message") or params.get("text"),
+            "quotedMessageId": params.get("quotedMessageId"),
+            "quoted": params.get("quoted"),
+        }
+        return self._client.post("/messages/send-text", body)
+
+    def send_image(self, params):
+        return self._client.post("/messages/send-image", params)
+
+    def get_received(self, params=None):
+        return self._client.get("/messages/received", params=params)
+
+    def get_sent(self, params=None):
+        return self._client.get("/messages/sent", params=params)
+
+    def get_stats(self, params=None):
+        return self._client.get("/messages/stats", params=params)
+
+    def get_by_chat(self, remote_jid, params=None):
+        return self._client.get(f"/messages/chat/{quote(remote_jid)}", params=params)
+
+    def search(self, params=None):
+        return self._client.get("/messages/search", params=params)
+
+    def get_recent_chats(self, params=None):
+        return self._client.get("/messages/recent-chats", params=params)
+
+    def get_chats(self, params=None):
+        return self._client.get("/messages/chats", params=params)
+
+    def delete_message(self, message_id):
+        return self._client.delete(f"/messages/{quote(message_id)}")
+
+    def forward(self, body):
+        return self._client.post("/messages/forward", body)
+
+    def forward_multiple(self, body):
+        return self._client.post("/messages/forward-multiple", body)
+
+    def delete_multiple(self, body):
+        return self._client.delete("/messages/multiple", body)
+
+    def schedule(self, body):
+        return self._client.post("/messages/schedule", body)
+
+    def send_location(self, body):
+        return self._client.post("/messages/send-location", body)
+
+    def send_contact(self, body):
+        return self._client.post("/messages/send-contact", body)
+
+    def send_voice(self, body):
+        return self._client.post("/messages/send-voice", body)
+
+    def send_audio(self, body):
+        return self._client.post("/messages/send-audio", body)
+
+    def send_reaction(self, body):
+        return self._client.post("/messages/reaction", body)
+
+    def remove_reaction(self, body):
+        return self._client.delete("/messages/reaction", body)
+
+    def send_read_receipt(self, body):
+        return self._client.post("/messages/read-receipt", body)
+
+    def mark_chat_read(self, body):
+        return self._client.post("/messages/mark-chat-read", body)
+
+    def get_read_status(self, message_id):
+        return self._client.get(f"/messages/read-status/{quote(message_id)}")
+
+    def update_read_receipts_privacy(self, body):
+        return self._client.put("/messages/privacy/read-receipts", body)
+
+    def send_typing(self, body):
+        return self._client.post("/messages/typing", body)
+
+    def send_recording(self, body):
+        return self._client.post("/messages/recording", body)
+
+    def send_file(self, body):
+        return self._client.post("/messages/send-file", body)
+
+    def send_media(self, body):
+        return self._client.post("/messages/send-media", body)
+
+    def send_poll(self, body):
+        return self._client.post("/messages/send-poll", body)
+
+    def send_list(self, body):
+        return self._client.post("/messages/send-list", body)
+
+    def send_buttons(self, body):
+        return self._client.post("/messages/send-buttons", body)
+
+    def send_status(self, body):
+        return self._client.post("/messages/send-status", body)
+
+    def send_media_advanced(self, body):
+        return self._client.post("/messages/send-media-advanced", body)
+
+    def send_ptv(self, body):
+        return self._client.post("/messages/send-ptv", body)
+
+    def send_sticker(self, body):
+        return self._client.post("/messages/send-sticker", body)
+
+    def get_poll_results(self, poll_id, params=None):
+        return self._client.get(f"/messages/poll/{quote(poll_id)}/results", params=params)
+
+
+class SessionsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self):
+        return self._client.get("/sessions")
+
+    def create(self, params=None):
+        return self._client.post("/sessions/create", params or {})
+
+    def get(self, session_id):
+        return self._client.get(f"/sessions/{quote(session_id)}")
+
+    def get_qr(self, session_id):
+        return self._client.get(f"/sessions/{quote(session_id)}/qr")
+
+    def disconnect(self, session_id):
+        return self._client.delete(f"/sessions/{quote(session_id)}/logout")
+
+    def delete(self, session_id):
+        return self._client.delete(f"/sessions/delete/{quote(session_id)}")
+
+
+class WebhooksResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get(self):
+        return self._client.get("/webhooks")
+
+    def set(self, params):
+        return self._client.post("/webhooks/set", params)
+
+    def remove(self):
+        return self._client.delete("/webhooks/remove")
+
+    def test(self):
+        return self._client.get("/webhooks/test")
+
+    def get_events(self, params=None):
+        return self._client.get("/webhooks/events", params=params)
+
+    def get_stats(self):
+        return self._client.get("/webhooks/stats")
+
+
+class TemplatesResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/templates", params=params)
+
+    def get(self, template_id):
+        return self._client.get(f"/templates/{quote(template_id)}")
+
+    def create(self, body):
+        return self._client.post("/templates", body)
+
+    def delete(self, template_id):
+        return self._client.delete(f"/templates/{quote(template_id)}")
+
+
+class ScheduledResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/scheduled", params=params)
+
+    def get(self, scheduled_id):
+        return self._client.get(f"/scheduled/{quote(scheduled_id)}")
+
+    def cancel(self, scheduled_id):
+        return self._client.delete(f"/scheduled/{quote(scheduled_id)}")
+
+
+class BulkResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/bulk", params=params)
+
+    def get(self, bulk_id):
+        return self._client.get(f"/bulk/{quote(bulk_id)}")
+
+    def create(self, body):
+        return self._client.post("/bulk", body)
+
+    def cancel(self, bulk_id):
+        return self._client.delete(f"/bulk/{quote(bulk_id)}")
+
+
+class ContactsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/contacts", params=params)
+
+    def get(self, contact_id):
+        return self._client.get(f"/contacts/{quote(contact_id)}")
+
+    def create(self, body):
+        return self._client.post("/contacts", body)
+
+    def update(self, contact_id, body):
+        return self._client.put(f"/contacts/{quote(contact_id)}", body)
+
+    def delete(self, contact_id):
+        return self._client.delete(f"/contacts/{quote(contact_id)}")
+
+
+class GroupsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/groups", params=params)
+
+    def get(self, group_id):
+        return self._client.get(f"/groups/{quote(group_id)}")
+
+    def create(self, body):
+        return self._client.post("/groups", body)
+
+    def update(self, group_id, body):
+        return self._client.put(f"/groups/{quote(group_id)}", body)
+
+    def leave(self, group_id):
+        return self._client.post(f"/groups/{quote(group_id)}/leave", {})
+
+
+class ChatsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/chats", params=params)
+
+    def get(self, chat_id):
+        return self._client.get(f"/chats/{quote(chat_id)}")
+
+    def archive(self, chat_id, body=None):
+        return self._client.post(f"/chats/{quote(chat_id)}/archive", body or {})
+
+    def unarchive(self, chat_id):
+        return self._client.post(f"/chats/{quote(chat_id)}/unarchive", {})
+
+
+class BusinessResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get(self, params=None):
+        return self._client.get("/business", params=params)
+
+    def update(self, body):
+        return self._client.put("/business", body)
+
+
+class StorageResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get_usage(self, params=None):
+        return self._client.get("/storage/usage", params=params)
+
+    def list_files(self, params=None):
+        return self._client.get("/storage/files", params=params)
+
+
+class LabelsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/labels", params=params)
+
+    def get(self, label_id):
+        return self._client.get(f"/labels/{quote(label_id)}")
+
+    def create(self, body):
+        return self._client.post("/labels", body)
+
+    def delete(self, label_id):
+        return self._client.delete(f"/labels/{quote(label_id)}")
+
+
+class IntegrationsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/integrations", params=params)
+
+    def get(self, integration_id):
+        return self._client.get(f"/integrations/{quote(integration_id)}")
+
+    def connect(self, body):
+        return self._client.post("/integrations/connect", body)
+
+    def disconnect(self, integration_id):
+        return self._client.delete(f"/integrations/{quote(integration_id)}")
+
+
+class QueueResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/queue", params=params)
+
+    def get(self, job_id):
+        return self._client.get(f"/queue/{quote(job_id)}")
+
+    def cancel(self, job_id):
+        return self._client.delete(f"/queue/{quote(job_id)}")
+
+
+class InteractiveResource:
+    def __init__(self, client):
+        self._client = client
+
+    def send_list(self, body):
+        return self._client.post("/interactive/list", body)
+
+    def send_buttons(self, body):
+        return self._client.post("/interactive/buttons", body)
+
+
+class ApiKeysResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/api-keys", params=params)
+
+    def create(self, body):
+        return self._client.post("/api-keys", body)
+
+    def revoke(self, key_id):
+        return self._client.delete(f"/api-keys/{quote(key_id)}")
+
+
+class ProfileResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get(self):
+        return self._client.get("/profile")
+
+    def update(self, body):
+        return self._client.put("/profile", body)
+
+
+class DashboardResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get(self, params=None):
+        return self._client.get("/dashboard", params=params)
+
+
+class PlansResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/plans", params=params)
+
+    def get(self, plan_id):
+        return self._client.get(f"/plans/{quote(plan_id)}")
+
+
+class BillingResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get(self):
+        return self._client.get("/billing")
+
+    def get_invoices(self, params=None):
+        return self._client.get("/billing/invoices", params=params)
+
+
+class ReferralResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get(self):
+        return self._client.get("/referral")
+
+    def get_links(self, params=None):
+        return self._client.get("/referral/links", params=params)
+
+
+class NotificationsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/notifications", params=params)
+
+    def mark_read(self, notification_id):
+        return self._client.post(f"/notifications/{quote(notification_id)}/read", {})
+
+
+class MetricsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get(self, params=None):
+        return self._client.get("/metrics", params=params)
+
+
+class BackupResource:
+    def __init__(self, client):
+        self._client = client
+
+    def create(self, body=None):
+        return self._client.post("/backup", body or {})
+
+    def list(self, params=None):
+        return self._client.get("/backup", params=params)
+
+    def restore(self, backup_id):
+        return self._client.post(f"/backup/{quote(backup_id)}/restore", {})
+
+
+class SecurityResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get_settings(self):
+        return self._client.get("/security/settings")
+
+    def update_settings(self, body):
+        return self._client.put("/security/settings", body)
+
+
+class AuditResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/audit", params=params)
+
+    def get(self, audit_id):
+        return self._client.get(f"/audit/{quote(audit_id)}")
+
+
+class OrganizationsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/organizations", params=params)
+
+    def get(self, org_id):
+        return self._client.get(f"/organizations/{quote(org_id)}")
+
+    def create(self, body):
+        return self._client.post("/organizations", body)
+
+    def update(self, org_id, body):
+        return self._client.put(f"/organizations/{quote(org_id)}", body)
+
+
+class SettingsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get(self):
+        return self._client.get("/settings")
+
+    def update(self, body):
+        return self._client.put("/settings", body)
+
+
+class ChannelsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/channels", params=params)
+
+    def get(self, channel_id):
+        return self._client.get(f"/channels/{quote(channel_id)}")
+
+
+class PrivacyResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get(self):
+        return self._client.get("/privacy")
+
+    def update(self, body):
+        return self._client.put("/privacy", body)
+
+
+class SupportResource:
+    def __init__(self, client):
+        self._client = client
+
+    def tickets(self, params=None):
+        return self._client.get("/support/tickets", params=params)
+
+    def create_ticket(self, body):
+        return self._client.post("/support/tickets", body)
+
+
+class ProxyResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get(self):
+        return self._client.get("/proxy")
+
+    def update(self, body):
+        return self._client.put("/proxy", body)
+
+
+class CallsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/calls", params=params)
+
+    def get(self, call_id):
+        return self._client.get(f"/calls/{quote(call_id)}")
+
+
+class AuthResource:
+    def __init__(self, client):
+        self._client = client
+
+    def login(self, body):
+        return self._client.post("/auth/login", body)
+
+    def logout(self):
+        return self._client.post("/auth/logout", {})
+
+    def refresh(self, body=None):
+        return self._client.post("/auth/refresh", body or {})
+
+    def me(self):
+        return self._client.get("/auth/me")
+
+
+class UsersResource:
+    def __init__(self, client):
+        self._client = client
+
+    def list(self, params=None):
+        return self._client.get("/users", params=params)
+
+    def get(self, user_id):
+        return self._client.get(f"/users/{quote(user_id)}")
+
+    def create(self, body):
+        return self._client.post("/users", body)
+
+    def update(self, user_id, body):
+        return self._client.put(f"/users/{quote(user_id)}", body)
+
+    def delete(self, user_id):
+        return self._client.delete(f"/users/{quote(user_id)}")
+
+
+class EmailResource:
+    def __init__(self, client):
+        self._client = client
+
+    def send(self, body):
+        return self._client.post("/email/send", body)
+
+    def get_settings(self):
+        return self._client.get("/email/settings")
+
+
+class AiResource:
+    def __init__(self, client):
+        self._client = client
+
+    def chat(self, body):
+        return self._client.post("/ai/chat", body)
+
+    def completions(self, body):
+        return self._client.post("/ai/completions", body)

omdaa_api_client-1.0.0/src/omdaa_api_client.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: omdaa-api-client
+Version: 1.0.0
+Summary: Official Python client for Omdaa WhatsApp Business API
+Author: Omdaa
+License: MIT
+Project-URL: Homepage, https://omdaa.com
+Project-URL: Documentation, https://omdaanet/docs/sdk
+Keywords: omdaa,whatsapp,api,client,sdk
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+
+# omdaa-api-client (Python)
+
+Official Python client for the [Omdaa](https://omdaa.com) WhatsApp Business API.
+
+## Installation
+
+```bash
+pip install omdaa-api-client
+```
+
+## Quick Start
+
+```python
+from omdaa import OmdaaClient, OmdaaError
+
+client = OmdaaClient("your-api-key")
+# Optional: OmdaaClient("your-api-key", base_url="https://omdaa.com/api/v1")
+
+try:
+    sessions = client.sessions.list()
+    result = client.messages.send_text({
+        "sessionId": "default",
+        "to": "201234567890",
+        "message": "Hello from Omdaa Python!",
+    })
+    client.webhooks.set({"url": "https://yoursite.com/webhook", "enabled": True})
+except OmdaaError as e:
+    print(e.status_code, str(e))
+```
+
+## API Resources
+
+Same as the Node.js SDK: `messages`, `sessions`, `webhooks`, `templates`, `scheduled`, `bulk`, `contacts`, `groups`, `chats`, `business`, `storage`, `labels`, `integrations`, `queue`, `interactive`, `api_keys`, `profile`, `dashboard`, `plans`, `billing`, `referral`, `notifications`, `metrics`, `backup`, `security`, `audit`, `organizations`, `settings`, `channels`, `privacy`, `support`, `proxy`, `calls`, `auth`, `users`, `email`, `ai`.
+
+## Requirements
+
+- Python 3.9+
+- requests >= 2.28.0
+
+## Development & tests
+
+```bash
+pip install -e ".[dev]"
+python -m pytest tests -v
+# or: python -m unittest discover -s tests -v
+```
+
+## License
+
+MIT

omdaa_api_client-1.0.0/src/omdaa_api_client.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/omdaa/__init__.py
+src/omdaa/client.py
+src/omdaa/exceptions.py
+src/omdaa/resources/__init__.py
+src/omdaa/resources/resources.py
+src/omdaa_api_client.egg-info/PKG-INFO
+src/omdaa_api_client.egg-info/SOURCES.txt
+src/omdaa_api_client.egg-info/dependency_links.txt
+src/omdaa_api_client.egg-info/requires.txt
+src/omdaa_api_client.egg-info/top_level.txt
+tests/test_client.py

omdaa_api_client-1.0.0/src/omdaa_api_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

omdaa_api_client-1.0.0/src/omdaa_api_client.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests>=2.28.0
+
+[dev]
+pytest>=7.0
+pytest-cov>=4.0

omdaa_api_client-1.0.0/src/omdaa_api_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+omdaa

omdaa_api_client-1.0.0/tests/test_client.py

@@ -0,0 +1,97 @@
+"""Tests for OmdaaClient and Client."""
+import sys
+from pathlib import Path
+from unittest import main, TestCase
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+from omdaa import OmdaaClient, OmdaaError
+from omdaa.client import Client
+
+
+class TestOmdaaError(TestCase):
+    def test_omdaa_error_has_status_code_and_body(self):
+        e = OmdaaError("Bad request", status_code=400, body={"code": "invalid"})
+        self.assertEqual(str(e), "Bad request")
+        self.assertEqual(e.status_code, 400)
+        self.assertEqual(e.body, {"code": "invalid"})
+
+
+class TestOmdaaClientResources(TestCase):
+    def test_omdaa_client_creates_all_resources(self):
+        with patch.object(Client, "request", return_value={"success": True}):
+            client = OmdaaClient("test-key")
+        self.assertIsNotNone(client.messages)
+        self.assertIsNotNone(client.sessions)
+        self.assertIsNotNone(client.webhooks)
+        self.assertIsNotNone(client.templates)
+        self.assertIsNotNone(client.scheduled)
+        self.assertIsNotNone(client.bulk)
+        self.assertIsNotNone(client.contacts)
+        self.assertIsNotNone(client.groups)
+        self.assertIsNotNone(client.chats)
+        self.assertIsNotNone(client.business)
+        self.assertIsNotNone(client.storage)
+        self.assertIsNotNone(client.labels)
+        self.assertIsNotNone(client.integrations)
+        self.assertIsNotNone(client.queue)
+        self.assertIsNotNone(client.interactive)
+        self.assertIsNotNone(client.api_keys)
+        self.assertIsNotNone(client.profile)
+        self.assertIsNotNone(client.dashboard)
+        self.assertIsNotNone(client.plans)
+        self.assertIsNotNone(client.billing)
+        self.assertIsNotNone(client.referral)
+        self.assertIsNotNone(client.notifications)
+        self.assertIsNotNone(client.metrics)
+        self.assertIsNotNone(client.backup)
+        self.assertIsNotNone(client.security)
+        self.assertIsNotNone(client.audit)
+        self.assertIsNotNone(client.organizations)
+        self.assertIsNotNone(client.settings)
+        self.assertIsNotNone(client.channels)
+        self.assertIsNotNone(client.privacy)
+        self.assertIsNotNone(client.support)
+        self.assertIsNotNone(client.proxy)
+        self.assertIsNotNone(client.calls)
+        self.assertIsNotNone(client.auth)
+        self.assertIsNotNone(client.users)
+        self.assertIsNotNone(client.email)
+        self.assertIsNotNone(client.ai)
+
+
+class TestMessagesSendText(TestCase):
+    def test_messages_send_text_calls_post(self):
+        with patch.object(Client, "request", return_value={"success": True, "messageId": "msg-1"}) as m:
+            client = OmdaaClient("test-key")
+            out = client.messages.send_text({
+                "sessionId": "default",
+                "to": "201234567890",
+                "message": "Hello",
+            })
+        self.assertEqual(out["messageId"], "msg-1")
+        m.assert_called_once()
+        call = m.call_args
+        args, kwargs = call[0], call[1]
+        self.assertIn("POST", args)
+        self.assertIn("/messages/send-text", args)
+        self.assertEqual(kwargs["body"]["sessionId"], "default")
+        self.assertEqual(call[1]["body"]["to"], "201234567890")
+        self.assertEqual(call[1]["body"]["message"], "Hello")
+
+
+class TestSessionsList(TestCase):
+    def test_sessions_list_calls_get(self):
+        with patch.object(Client, "request", return_value={"sessions": []}) as m:
+            client = OmdaaClient("test-key")
+            out = client.sessions.list()
+        self.assertIn("sessions", out)
+        m.assert_called_once()
+        args = m.call_args[0]
+        self.assertIn("GET", args)
+        self.assertIn("/sessions", args)
+
+
+if __name__ == "__main__":
+    main()