weezy-sdk 0.1.0__tar.gz

weezy_sdk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Weezy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

weezy_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: weezy-sdk
+Version: 0.1.0
+Summary: Typed synchronous and asynchronous Weezy SMS and WhatsApp SDK
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pekenio/weezy-sdk
+Project-URL: Repository, https://github.com/pekenio/weezy-sdk
+Project-URL: Issues, https://github.com/pekenio/weezy-sdk/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<1,>=0.27
+Dynamic: license-file
+
+# weezy-sdk
+
+Typed SMS and WhatsApp clients for Python 3.11+.
+
+## Installation
+
+```sh
+pip install weezy-sdk
+```
+
+The package is named `weezy-sdk`; import clients from `weezy`.
+
+For local development, install from this repository with `pip install ./python`.
+
+## Synchronous client
+
+```python
+import os
+from weezy import Weezy, WeezyError
+
+with Weezy(
+    client_id=os.environ['WEEZY_CLIENT_ID'],
+    client_secret=os.environ['WEEZY_CLIENT_SECRET'],
+) as client:
+    wallet = client.sms.balance()
+    message = client.sms.send(body={
+        'to': '+2250700000000', 'body': 'Bonjour !', 'sender_name': 'WEEZY',
+    })
+    status = client.sms.status(message_x_id=message['x_id'])
+    result = client.whatsapp(os.environ['WEEZY_INSTANCE_ID']).messages.send_text_message(body={
+        'phone': '2250700000000', 'message': 'Bonjour !',
+    })
+```
+
+## Asynchronous client
+
+```python
+import asyncio
+import os
+from weezy import AsyncWeezy
+
+async def main():
+    async with AsyncWeezy(
+        client_id=os.environ['WEEZY_CLIENT_ID'],
+        client_secret=os.environ['WEEZY_CLIENT_SECRET'],
+    ) as client:
+        print(await client.sms.balance())
+
+asyncio.run(main())
+```
+
+Send methods create real messages with live credentials. Use a dedicated test account and recipient when testing.
+
+SMS methods: `balance()`, `senders()`, `send(body=...)`, `send_bulk(body=...)`, `status(message_x_id=...)`, `opt_outs(body=...)`. All arguments are keyword-only. WhatsApp resource methods match the backend handler names; see [the full reference](API.md).
+
+`WeezyError` exposes `status`, `details` and `request_id`. A timeout or transport failure has status `0`. Close clients with `close()` / `await aclose()` or use the context managers above. Options include `base_url` (full client API prefix), `timeout` in seconds and an injectable `httpx` transport. No automatic retries.
+
+TypedDict request and response contracts are exported from `weezy.types`. They support editor/type-checker assistance; runtime validation remains on the API.

weezy_sdk-0.1.0/README.md

@@ -0,0 +1,58 @@
+# weezy-sdk
+
+Typed SMS and WhatsApp clients for Python 3.11+.
+
+## Installation
+
+```sh
+pip install weezy-sdk
+```
+
+The package is named `weezy-sdk`; import clients from `weezy`.
+
+For local development, install from this repository with `pip install ./python`.
+
+## Synchronous client
+
+```python
+import os
+from weezy import Weezy, WeezyError
+
+with Weezy(
+    client_id=os.environ['WEEZY_CLIENT_ID'],
+    client_secret=os.environ['WEEZY_CLIENT_SECRET'],
+) as client:
+    wallet = client.sms.balance()
+    message = client.sms.send(body={
+        'to': '+2250700000000', 'body': 'Bonjour !', 'sender_name': 'WEEZY',
+    })
+    status = client.sms.status(message_x_id=message['x_id'])
+    result = client.whatsapp(os.environ['WEEZY_INSTANCE_ID']).messages.send_text_message(body={
+        'phone': '2250700000000', 'message': 'Bonjour !',
+    })
+```
+
+## Asynchronous client
+
+```python
+import asyncio
+import os
+from weezy import AsyncWeezy
+
+async def main():
+    async with AsyncWeezy(
+        client_id=os.environ['WEEZY_CLIENT_ID'],
+        client_secret=os.environ['WEEZY_CLIENT_SECRET'],
+    ) as client:
+        print(await client.sms.balance())
+
+asyncio.run(main())
+```
+
+Send methods create real messages with live credentials. Use a dedicated test account and recipient when testing.
+
+SMS methods: `balance()`, `senders()`, `send(body=...)`, `send_bulk(body=...)`, `status(message_x_id=...)`, `opt_outs(body=...)`. All arguments are keyword-only. WhatsApp resource methods match the backend handler names; see [the full reference](API.md).
+
+`WeezyError` exposes `status`, `details` and `request_id`. A timeout or transport failure has status `0`. Close clients with `close()` / `await aclose()` or use the context managers above. Options include `base_url` (full client API prefix), `timeout` in seconds and an injectable `httpx` transport. No automatic retries.
+
+TypedDict request and response contracts are exported from `weezy.types`. They support editor/type-checker assistance; runtime validation remains on the API.

weezy_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "weezy-sdk"
+version = "0.1.0"
+license = "MIT"
+license-files = ["LICENSE"]
+description = "Typed synchronous and asynchronous Weezy SMS and WhatsApp SDK"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = ["httpx>=0.27,<1"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+weezy = ["py.typed"]
+
+[project.urls]
+Homepage = "https://github.com/pekenio/weezy-sdk"
+Repository = "https://github.com/pekenio/weezy-sdk"
+Issues = "https://github.com/pekenio/weezy-sdk/issues"

weezy_sdk-0.1.0/setup.cfg

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

weezy_sdk-0.1.0/src/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_sdk-0.1.0/src/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_sdk-0.1.0/src/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()