weezy-sdk 0.1.0__py3-none-any.whl

weezy/__init__.py

@@ -0,0 +1,5 @@
+from .client import Weezy, AsyncWeezy
+from ._transport import WeezyError
+
+__all__ = ["Weezy", "AsyncWeezy", "WeezyError"]
+__version__ = "0.1.0"

weezy/_transport.py

@@ -0,0 +1,43 @@
+from typing import Any
+from urllib.parse import quote, urlsplit
+import httpx
+
+
+class WeezyError(Exception):
+    def __init__(self, message: str, *, status: int = 0, details: Any = None, request_id: str | None = None):
+        super().__init__(message)
+        self.status = status
+        self.details = details
+        self.request_id = request_id
+
+
+def segment(value: Any) -> str:
+    if value is None or str(value) in ("", ".", ".."):
+        raise ValueError("A valid path parameter is required")
+    return quote(str(value), safe="")
+
+
+def validate(client_id: str, client_secret: str, base_url: str, timeout: float) -> str:
+    if not client_id or not client_secret or ":" in client_id:
+        raise ValueError("Valid client_id and client_secret are required")
+    url = urlsplit(base_url)
+    if url.scheme not in ("https", "http") or not url.netloc or url.username or url.password or url.query or url.fragment:
+        raise ValueError("Invalid base_url")
+    if not timeout > 0 or timeout == float("inf"):
+        raise ValueError("timeout must be finite and positive")
+    return base_url.rstrip("/")
+
+
+def decode(response: httpx.Response, *, unwrap: bool) -> Any:
+    if response.status_code == 204:
+        return None
+    try:
+        data = response.json()
+    except ValueError:
+        raise WeezyError("API returned a non-JSON response", status=response.status_code, details=response.text,
+                         request_id=response.headers.get("x-request-id")) from None
+    envelope = isinstance(data, dict) and isinstance(data.get("code"), int) and "msg" in data
+    if response.is_error or response.is_redirect or (unwrap and envelope and data['code'] >= 400):
+        raise WeezyError(data.get("msg", f"API request failed ({response.status_code})") if isinstance(data, dict) else f"API request failed ({response.status_code})",
+                         status=response.status_code, details=data, request_id=response.headers.get("x-request-id"))
+    return data.get("data") if unwrap and envelope else data

weezy/client.py

@@ -0,0 +1,70 @@
+from typing import Any
+import httpx
+from ._transport import WeezyError, decode, segment, validate
+from .resources import SmsAPI, AsyncSmsAPI, WhatsAppAPI, AsyncWhatsAppAPI
+
+DEFAULT_BASE_URL = "https://api.weezy.app/client/api/v1"
+
+
+class Weezy:
+    def __init__(self, *, client_id: str, client_secret: str, base_url: str = DEFAULT_BASE_URL,
+                 timeout: float = 30, transport: httpx.BaseTransport | None = None):
+        self._base_url = validate(client_id, client_secret, base_url, timeout)
+        self._http = httpx.Client(auth=(client_id, client_secret), timeout=timeout, transport=transport,
+                                  headers={"Accept": "application/json"}, follow_redirects=False)
+        self.sms = SmsAPI(self)
+
+    def whatsapp(self, instance_id: str) -> WhatsAppAPI:
+        segment(instance_id)
+        return WhatsAppAPI(self, instance_id)
+
+    def request(self, method: str, path: str, *, body: Any = None, query: dict | None = None, unwrap: bool = False) -> Any:
+        try:
+            response = self._http.request(method, self._base_url + path, json=body,
+                                          params={k: v for k, v in (query or {}).items() if v is not None})
+        except httpx.TimeoutException:
+            raise WeezyError("Request timed out") from None
+        except httpx.HTTPError:
+            raise WeezyError("Network request failed") from None
+        return decode(response, unwrap=unwrap)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+class AsyncWeezy:
+    def __init__(self, *, client_id: str, client_secret: str, base_url: str = DEFAULT_BASE_URL,
+                 timeout: float = 30, transport: httpx.AsyncBaseTransport | None = None):
+        self._base_url = validate(client_id, client_secret, base_url, timeout)
+        self._http = httpx.AsyncClient(auth=(client_id, client_secret), timeout=timeout, transport=transport,
+                                       headers={"Accept": "application/json"}, follow_redirects=False)
+        self.sms = AsyncSmsAPI(self)
+
+    def whatsapp(self, instance_id: str) -> AsyncWhatsAppAPI:
+        segment(instance_id)
+        return AsyncWhatsAppAPI(self, instance_id)
+
+    async def request(self, method: str, path: str, *, body: Any = None, query: dict | None = None, unwrap: bool = False) -> Any:
+        try:
+            response = await self._http.request(method, self._base_url + path, json=body,
+                                                params={k: v for k, v in (query or {}).items() if v is not None})
+        except httpx.TimeoutException:
+            raise WeezyError("Request timed out") from None
+        except httpx.HTTPError:
+            raise WeezyError("Network request failed") from None
+        return decode(response, unwrap=unwrap)
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        await self.aclose()