sendbyte 0.1.0__tar.gz

sendbyte-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Echospectra Technology Limited
+
+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.

sendbyte-0.1.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: sendbyte
+Version: 0.1.0
+Summary: SendByte Python SDK: the email API for Africa.
+Author: Echospectra Technology Limited
+License: MIT
+Project-URL: Homepage, https://sendbyte.africa
+Project-URL: Documentation, https://docs.sendbyte.africa
+Project-URL: Repository, https://github.com/Sendbyte-Africa/sendbyte-python
+Project-URL: Issues, https://github.com/Sendbyte-Africa/sendbyte-python/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications :: Email
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# sendbyte
+
+The official Python SDK for [SendByte](https://sendbyte.africa), the email API for Africa. Zero runtime dependencies (standard library only), with both synchronous and asynchronous clients.
+
+## Install
+
+```bash
+pip install sendbyte
+```
+
+Requires Python 3.8 or newer.
+
+## Quickstart
+
+```python
+from sendbyte import SendByte
+
+sendbyte = SendByte("sk_test_...")
+
+email = sendbyte.emails.send(
+    from_="PayLink <receipts@paylink.ng>",
+    to="amaka@halo.ng",
+    subject="Receipt for your payment",
+    html="<p>Thank you. Your payment was received.</p>",
+)
+
+print(email["id"])
+```
+
+`from_` is spelled with a trailing underscore because `from` is a reserved word in Python. Keys that start with `sk_test_` run in the sandbox: every endpoint behaves the same, but nothing is actually delivered. Switch to an `sk_live_` key to send for real.
+
+## Configuration
+
+```python
+sendbyte = SendByte("sk_live_...", base_url="https://api.sendbyte.africa")
+```
+
+## Async client
+
+`AsyncSendByte` exposes the same surface with awaitable methods, running the transport in the default executor so the SDK stays dependency free.
+
+```python
+import asyncio
+from sendbyte import AsyncSendByte
+
+async def main():
+    sendbyte = AsyncSendByte("sk_test_...")
+    email = await sendbyte.send_email(
+        from_="PayLink <receipts@paylink.ng>",
+        to="amaka@halo.ng",
+        subject="Receipt",
+        html="<p>Thank you.</p>",
+    )
+    print(email["id"])
+
+asyncio.run(main())
+```
+
+## API
+
+### Emails
+
+```python
+sendbyte.emails.send(from_=..., to=..., subject=..., html=...)
+sendbyte.emails.get("em_123")
+sendbyte.emails.list(limit=20, status="delivered")
+```
+
+`to`, `cc`, `bcc`, and `reply_to` accept a single address or a list. Pass `idempotency_key` to make retries safe, `scheduled_at` for future sends, and `template_id` with `variables` to render a server side template.
+
+### Domains
+
+```python
+domain = sendbyte.domains.create("paylink.ng")
+# domain["dns_records"] lists the SPF, DKIM, and DMARC records to publish
+sendbyte.domains.list()
+sendbyte.domains.get(domain["id"])
+sendbyte.domains.verify(domain["id"])
+```
+
+### Webhooks
+
+```python
+endpoint = sendbyte.webhooks.create(
+    "https://example.com/hooks/sendbyte",
+    ["email.delivered", "email.bounced"],
+)
+# endpoint["secret"] is shown once, store it now
+sendbyte.webhooks.list()
+sendbyte.webhooks.disable(endpoint["id"])
+sendbyte.webhooks.replay("evt_123")
+```
+
+## Verifying webhook signatures
+
+Every webhook request carries a `sendbyte-signature` header. Verify it against the raw request body before trusting the payload.
+
+```python
+from sendbyte import verify_webhook_signature
+
+@app.post("/hooks/sendbyte")
+def hooks(request):
+    valid = verify_webhook_signature(
+        secret=os.environ["SENDBYTE_WEBHOOK_SECRET"],
+        header=request.headers.get("sendbyte-signature"),
+        body=request.get_data(),  # the raw, unparsed body
+    )
+    if not valid:
+        return "", 401
+    # handle the event
+    return "", 200
+```
+
+The check rejects missing, malformed, tampered, and stale signatures (default tolerance is 300 seconds) and never raises.
+
+## Errors
+
+Failed requests raise a `SendByteError` carrying the API error shape.
+
+```python
+from sendbyte import SendByteError
+
+try:
+    sendbyte.emails.send(from_=..., to=..., subject=..., html=...)
+except SendByteError as err:
+    print(err.code, err.status, err.docs_url)
+```
+
+## Links
+
+- Documentation: https://docs.sendbyte.africa
+
+## License
+
+MIT

sendbyte-0.1.0/README.md

@@ -0,0 +1,135 @@
+# sendbyte
+
+The official Python SDK for [SendByte](https://sendbyte.africa), the email API for Africa. Zero runtime dependencies (standard library only), with both synchronous and asynchronous clients.
+
+## Install
+
+```bash
+pip install sendbyte
+```
+
+Requires Python 3.8 or newer.
+
+## Quickstart
+
+```python
+from sendbyte import SendByte
+
+sendbyte = SendByte("sk_test_...")
+
+email = sendbyte.emails.send(
+    from_="PayLink <receipts@paylink.ng>",
+    to="amaka@halo.ng",
+    subject="Receipt for your payment",
+    html="<p>Thank you. Your payment was received.</p>",
+)
+
+print(email["id"])
+```
+
+`from_` is spelled with a trailing underscore because `from` is a reserved word in Python. Keys that start with `sk_test_` run in the sandbox: every endpoint behaves the same, but nothing is actually delivered. Switch to an `sk_live_` key to send for real.
+
+## Configuration
+
+```python
+sendbyte = SendByte("sk_live_...", base_url="https://api.sendbyte.africa")
+```
+
+## Async client
+
+`AsyncSendByte` exposes the same surface with awaitable methods, running the transport in the default executor so the SDK stays dependency free.
+
+```python
+import asyncio
+from sendbyte import AsyncSendByte
+
+async def main():
+    sendbyte = AsyncSendByte("sk_test_...")
+    email = await sendbyte.send_email(
+        from_="PayLink <receipts@paylink.ng>",
+        to="amaka@halo.ng",
+        subject="Receipt",
+        html="<p>Thank you.</p>",
+    )
+    print(email["id"])
+
+asyncio.run(main())
+```
+
+## API
+
+### Emails
+
+```python
+sendbyte.emails.send(from_=..., to=..., subject=..., html=...)
+sendbyte.emails.get("em_123")
+sendbyte.emails.list(limit=20, status="delivered")
+```
+
+`to`, `cc`, `bcc`, and `reply_to` accept a single address or a list. Pass `idempotency_key` to make retries safe, `scheduled_at` for future sends, and `template_id` with `variables` to render a server side template.
+
+### Domains
+
+```python
+domain = sendbyte.domains.create("paylink.ng")
+# domain["dns_records"] lists the SPF, DKIM, and DMARC records to publish
+sendbyte.domains.list()
+sendbyte.domains.get(domain["id"])
+sendbyte.domains.verify(domain["id"])
+```
+
+### Webhooks
+
+```python
+endpoint = sendbyte.webhooks.create(
+    "https://example.com/hooks/sendbyte",
+    ["email.delivered", "email.bounced"],
+)
+# endpoint["secret"] is shown once, store it now
+sendbyte.webhooks.list()
+sendbyte.webhooks.disable(endpoint["id"])
+sendbyte.webhooks.replay("evt_123")
+```
+
+## Verifying webhook signatures
+
+Every webhook request carries a `sendbyte-signature` header. Verify it against the raw request body before trusting the payload.
+
+```python
+from sendbyte import verify_webhook_signature
+
+@app.post("/hooks/sendbyte")
+def hooks(request):
+    valid = verify_webhook_signature(
+        secret=os.environ["SENDBYTE_WEBHOOK_SECRET"],
+        header=request.headers.get("sendbyte-signature"),
+        body=request.get_data(),  # the raw, unparsed body
+    )
+    if not valid:
+        return "", 401
+    # handle the event
+    return "", 200
+```
+
+The check rejects missing, malformed, tampered, and stale signatures (default tolerance is 300 seconds) and never raises.
+
+## Errors
+
+Failed requests raise a `SendByteError` carrying the API error shape.
+
+```python
+from sendbyte import SendByteError
+
+try:
+    sendbyte.emails.send(from_=..., to=..., subject=..., html=...)
+except SendByteError as err:
+    print(err.code, err.status, err.docs_url)
+```
+
+## Links
+
+- Documentation: https://docs.sendbyte.africa
+
+## License
+
+MIT

sendbyte-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sendbyte"
+version = "0.1.0"
+description = "SendByte Python SDK: the email API for Africa."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+authors = [{ name = "Echospectra Technology Limited" }]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Communications :: Email",
+  "Typing :: Typed",
+]
+# Zero runtime dependencies: stdlib urllib for transport.
+dependencies = []
+
+[project.urls]
+Homepage = "https://sendbyte.africa"
+Documentation = "https://docs.sendbyte.africa"
+Repository = "https://github.com/Sendbyte-Africa/sendbyte-python"
+Issues = "https://github.com/Sendbyte-Africa/sendbyte-python/issues"
+
+[tool.setuptools.packages.find]
+include = ["sendbyte*"]

sendbyte-0.1.0/sendbyte/__init__.py

@@ -0,0 +1,304 @@
+"""SendByte Python SDK: the email API for Africa.
+
+Zero runtime dependencies (stdlib urllib). Sync and async clients with the
+same surface; errors carry the API's error shape (code, message, docs_url).
+
+    from sendbyte import SendByte
+
+    sendbyte = SendByte("sk_test_...")
+    email = sendbyte.emails.send(
+        from_="PayLink <receipts@paylink.ng>",
+        to="amaka@halo.ng",
+        subject="Receipt",
+        html="<p>Thank you.</p>",
+    )
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import hmac
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+__all__ = [
+    "SendByte",
+    "AsyncSendByte",
+    "SendByteError",
+    "verify_webhook_signature",
+    "SIGNATURE_HEADER",
+]
+
+DEFAULT_BASE_URL = "https://api.sendbyte.africa"
+SIGNATURE_HEADER = "sendbyte-signature"
+_VERSION = "0.1.0"
+
+# transport(method, url, headers, body) -> (status, response_text)
+Transport = Callable[[str, str, Dict[str, str], Optional[bytes]], Tuple[int, str]]
+
+
+class SendByteError(Exception):
+    """An error returned by the SendByte API."""
+
+    def __init__(self, code: str, message: str, status: int, docs_url: Optional[str] = None):
+        super().__init__(message)
+        self.code = code
+        self.status = status
+        self.docs_url = docs_url
+
+
+def _default_transport(
+    method: str, url: str, headers: Dict[str, str], body: Optional[bytes]
+) -> Tuple[int, str]:
+    request = urllib.request.Request(url, data=body, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(request, timeout=30) as response:
+            return response.status, response.read().decode("utf-8")
+    except urllib.error.HTTPError as err:  # non-2xx still carries a JSON body
+        return err.code, err.read().decode("utf-8")
+
+
+class _Http:
+    def __init__(self, api_key: str, base_url: str, transport: Optional[Transport]):
+        if not api_key or not (api_key.startswith("sk_live_") or api_key.startswith("sk_test_")):
+            raise SendByteError(
+                "invalid_api_key",
+                "API key must start with sk_live_ or sk_test_. "
+                "Create one in the dashboard under API keys.",
+                0,
+            )
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.transport = transport or _default_transport
+
+    def request(self, method: str, path: str, body: Optional[Dict[str, Any]] = None) -> Any:
+        headers = {
+            "authorization": f"Bearer {self.api_key}",
+            "user-agent": f"sendbyte-python/{_VERSION}",
+        }
+        payload: Optional[bytes] = None
+        if body is not None:
+            headers["content-type"] = "application/json"
+            payload = json.dumps(body).encode("utf-8")
+
+        status, text = self.transport(method, f"{self.base_url}{path}", headers, payload)
+        data = json.loads(text) if text else {}
+
+        if status >= 400:
+            error = data.get("error", {}) if isinstance(data, dict) else {}
+            raise SendByteError(
+                error.get("code", "request_failed"),
+                error.get("message", f"Request failed with status {status}"),
+                status,
+                error.get("docs_url"),
+            )
+        return data
+
+
+def _build_send_body(
+    from_: str,
+    to: Union[str, List[str]],
+    subject: str,
+    **options: Any,
+) -> Dict[str, Any]:
+    body: Dict[str, Any] = {"from": from_, "to": to, "subject": subject}
+    for key in (
+        "html",
+        "text",
+        "cc",
+        "bcc",
+        "reply_to",
+        "attachments",
+        "tags",
+        "headers",
+        "scheduled_at",
+        "template_id",
+        "variables",
+        "idempotency_key",
+    ):
+        value = options.pop(key, None)
+        if value is not None:
+            body[key] = value
+    if options:
+        raise TypeError(f"Unknown arguments: {', '.join(sorted(options))}")
+    return body
+
+
+def _list_query(limit: Optional[int], after: Optional[str], status: Optional[str]) -> str:
+    params = {}
+    if limit is not None:
+        params["limit"] = str(limit)
+    if after is not None:
+        params["after"] = after
+    if status is not None:
+        params["status"] = status
+    return f"?{urllib.parse.urlencode(params)}" if params else ""
+
+
+class _Emails:
+    def __init__(self, http: _Http):
+        self._http = http
+
+    def send(
+        self, *, from_: str, to: Union[str, List[str]], subject: str, **options: Any
+    ) -> Dict[str, Any]:
+        return self._http.request("POST", "/v1/emails", _build_send_body(from_, to, subject, **options))
+
+    def get(self, email_id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/v1/emails/{email_id}")
+
+    def list(
+        self,
+        *,
+        limit: Optional[int] = None,
+        after: Optional[str] = None,
+        status: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        return self._http.request("GET", f"/v1/emails{_list_query(limit, after, status)}")
+
+
+class _Domains:
+    def __init__(self, http: _Http):
+        self._http = http
+
+    def create(self, domain: str) -> Dict[str, Any]:
+        return self._http.request("POST", "/v1/domains", {"domain": domain})
+
+    def list(self) -> Dict[str, Any]:
+        return self._http.request("GET", "/v1/domains")
+
+    def get(self, domain_id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/v1/domains/{domain_id}")
+
+    def verify(self, domain_id: str) -> Dict[str, Any]:
+        return self._http.request("POST", f"/v1/domains/{domain_id}/verify")
+
+
+class _Webhooks:
+    def __init__(self, http: _Http):
+        self._http = http
+
+    def create(self, url: str, events: Optional[List[str]] = None) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"url": url}
+        if events is not None:
+            body["events"] = events
+        return self._http.request("POST", "/v1/webhooks", body)
+
+    def list(self) -> Dict[str, Any]:
+        return self._http.request("GET", "/v1/webhooks")
+
+    def disable(self, endpoint_id: str) -> Dict[str, Any]:
+        return self._http.request("DELETE", f"/v1/webhooks/{endpoint_id}")
+
+    def replay(self, delivery_id: str) -> Dict[str, Any]:
+        return self._http.request("POST", f"/v1/webhooks/deliveries/{delivery_id}/replay")
+
+
+class SendByte:
+    """Synchronous SendByte client."""
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        transport: Optional[Transport] = None,
+    ):
+        http = _Http(api_key, base_url, transport)
+        self.emails = _Emails(http)
+        self.domains = _Domains(http)
+        self.webhooks = _Webhooks(http)
+
+
+class AsyncSendByte:
+    """Asynchronous SendByte client (same surface, awaitable methods).
+
+    Transport runs in the default executor, keeping the SDK dependency-free
+    while staying event-loop friendly.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        transport: Optional[Transport] = None,
+    ):
+        self._sync = SendByte(api_key, base_url=base_url, transport=transport)
+
+    async def _run(self, fn: Callable[[], Any]) -> Any:
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, fn)
+
+    # Emails
+    async def send_email(
+        self, *, from_: str, to: Union[str, List[str]], subject: str, **options: Any
+    ) -> Dict[str, Any]:
+        return await self._run(
+            lambda: self._sync.emails.send(from_=from_, to=to, subject=subject, **options)
+        )
+
+    async def get_email(self, email_id: str) -> Dict[str, Any]:
+        return await self._run(lambda: self._sync.emails.get(email_id))
+
+    async def list_emails(self, **params: Any) -> Dict[str, Any]:
+        return await self._run(lambda: self._sync.emails.list(**params))
+
+    # Domains
+    async def create_domain(self, domain: str) -> Dict[str, Any]:
+        return await self._run(lambda: self._sync.domains.create(domain))
+
+    async def verify_domain(self, domain_id: str) -> Dict[str, Any]:
+        return await self._run(lambda: self._sync.domains.verify(domain_id))
+
+    async def list_domains(self) -> Dict[str, Any]:
+        return await self._run(lambda: self._sync.domains.list())
+
+    # Webhooks
+    async def create_webhook(self, url: str, events: Optional[List[str]] = None) -> Dict[str, Any]:
+        return await self._run(lambda: self._sync.webhooks.create(url, events))
+
+    async def list_webhooks(self) -> Dict[str, Any]:
+        return await self._run(lambda: self._sync.webhooks.list())
+
+
+def verify_webhook_signature(
+    secret: str,
+    header: Optional[str],
+    body: Union[str, bytes],
+    *,
+    tolerance_seconds: int = 300,
+    now: Optional[int] = None,
+) -> bool:
+    """Verify a webhook request came from SendByte.
+
+    The header format is ``t=<unix seconds>,v1=<hex hmac-sha256>`` over
+    ``"<t>.<raw body>"``. Returns False for missing, malformed, stale, or
+    forged signatures; never raises.
+    """
+    if not header:
+        return False
+    parts: Dict[str, str] = {}
+    for piece in header.split(","):
+        key, _, value = piece.partition("=")
+        parts[key] = value
+    timestamp_raw = parts.get("t", "")
+    signature = parts.get("v1", "")
+    if not timestamp_raw.isdigit() or not signature:
+        return False
+
+    timestamp = int(timestamp_raw)
+    current = now if now is not None else int(time.time())
+    if abs(current - timestamp) > tolerance_seconds:
+        return False
+
+    raw = body.encode("utf-8") if isinstance(body, str) else body
+    expected = hmac.new(
+        secret.encode("utf-8"), f"{timestamp}.".encode("utf-8") + raw, hashlib.sha256
+    ).hexdigest()
+    return hmac.compare_digest(expected, signature)

sendbyte-0.1.0/sendbyte.egg-info/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: sendbyte
+Version: 0.1.0
+Summary: SendByte Python SDK: the email API for Africa.
+Author: Echospectra Technology Limited
+License: MIT
+Project-URL: Homepage, https://sendbyte.africa
+Project-URL: Documentation, https://docs.sendbyte.africa
+Project-URL: Repository, https://github.com/Sendbyte-Africa/sendbyte-python
+Project-URL: Issues, https://github.com/Sendbyte-Africa/sendbyte-python/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications :: Email
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# sendbyte
+
+The official Python SDK for [SendByte](https://sendbyte.africa), the email API for Africa. Zero runtime dependencies (standard library only), with both synchronous and asynchronous clients.
+
+## Install
+
+```bash
+pip install sendbyte
+```
+
+Requires Python 3.8 or newer.
+
+## Quickstart
+
+```python
+from sendbyte import SendByte
+
+sendbyte = SendByte("sk_test_...")
+
+email = sendbyte.emails.send(
+    from_="PayLink <receipts@paylink.ng>",
+    to="amaka@halo.ng",
+    subject="Receipt for your payment",
+    html="<p>Thank you. Your payment was received.</p>",
+)
+
+print(email["id"])
+```
+
+`from_` is spelled with a trailing underscore because `from` is a reserved word in Python. Keys that start with `sk_test_` run in the sandbox: every endpoint behaves the same, but nothing is actually delivered. Switch to an `sk_live_` key to send for real.
+
+## Configuration
+
+```python
+sendbyte = SendByte("sk_live_...", base_url="https://api.sendbyte.africa")
+```
+
+## Async client
+
+`AsyncSendByte` exposes the same surface with awaitable methods, running the transport in the default executor so the SDK stays dependency free.
+
+```python
+import asyncio
+from sendbyte import AsyncSendByte
+
+async def main():
+    sendbyte = AsyncSendByte("sk_test_...")
+    email = await sendbyte.send_email(
+        from_="PayLink <receipts@paylink.ng>",
+        to="amaka@halo.ng",
+        subject="Receipt",
+        html="<p>Thank you.</p>",
+    )
+    print(email["id"])
+
+asyncio.run(main())
+```
+
+## API
+
+### Emails
+
+```python
+sendbyte.emails.send(from_=..., to=..., subject=..., html=...)
+sendbyte.emails.get("em_123")
+sendbyte.emails.list(limit=20, status="delivered")
+```
+
+`to`, `cc`, `bcc`, and `reply_to` accept a single address or a list. Pass `idempotency_key` to make retries safe, `scheduled_at` for future sends, and `template_id` with `variables` to render a server side template.
+
+### Domains
+
+```python
+domain = sendbyte.domains.create("paylink.ng")
+# domain["dns_records"] lists the SPF, DKIM, and DMARC records to publish
+sendbyte.domains.list()
+sendbyte.domains.get(domain["id"])
+sendbyte.domains.verify(domain["id"])
+```
+
+### Webhooks
+
+```python
+endpoint = sendbyte.webhooks.create(
+    "https://example.com/hooks/sendbyte",
+    ["email.delivered", "email.bounced"],
+)
+# endpoint["secret"] is shown once, store it now
+sendbyte.webhooks.list()
+sendbyte.webhooks.disable(endpoint["id"])
+sendbyte.webhooks.replay("evt_123")
+```
+
+## Verifying webhook signatures
+
+Every webhook request carries a `sendbyte-signature` header. Verify it against the raw request body before trusting the payload.
+
+```python
+from sendbyte import verify_webhook_signature
+
+@app.post("/hooks/sendbyte")
+def hooks(request):
+    valid = verify_webhook_signature(
+        secret=os.environ["SENDBYTE_WEBHOOK_SECRET"],
+        header=request.headers.get("sendbyte-signature"),
+        body=request.get_data(),  # the raw, unparsed body
+    )
+    if not valid:
+        return "", 401
+    # handle the event
+    return "", 200
+```
+
+The check rejects missing, malformed, tampered, and stale signatures (default tolerance is 300 seconds) and never raises.
+
+## Errors
+
+Failed requests raise a `SendByteError` carrying the API error shape.
+
+```python
+from sendbyte import SendByteError
+
+try:
+    sendbyte.emails.send(from_=..., to=..., subject=..., html=...)
+except SendByteError as err:
+    print(err.code, err.status, err.docs_url)
+```
+
+## Links
+
+- Documentation: https://docs.sendbyte.africa
+
+## License
+
+MIT

sendbyte-0.1.0/sendbyte.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+sendbyte/__init__.py
+sendbyte/py.typed
+sendbyte.egg-info/PKG-INFO
+sendbyte.egg-info/SOURCES.txt
+sendbyte.egg-info/dependency_links.txt
+sendbyte.egg-info/top_level.txt
+tests/test_sdk.py

sendbyte-0.1.0/sendbyte.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sendbyte-0.1.0/sendbyte.egg-info/top_level.txt

@@ -0,0 +1 @@
+sendbyte

sendbyte-0.1.0/setup.cfg

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

sendbyte-0.1.0/tests/test_sdk.py

@@ -0,0 +1,138 @@
+"""SDK tests: stdlib unittest, fake transport, no network."""
+
+import asyncio
+import hashlib
+import hmac
+import json
+import unittest
+
+from sendbyte import AsyncSendByte, SendByte, SendByteError, verify_webhook_signature
+
+EMAIL = {
+    "id": "em_1",
+    "from": "a@b.ng",
+    "to": ["c@d.ng"],
+    "subject": "Hi",
+    "status": "queued",
+    "sandbox": True,
+}
+
+
+class FakeTransport:
+    def __init__(self, status=200, body=None):
+        self.status = status
+        self.body = body if body is not None else EMAIL
+        self.calls = []
+
+    def __call__(self, method, url, headers, payload):
+        self.calls.append(
+            {
+                "method": method,
+                "url": url,
+                "headers": headers,
+                "body": json.loads(payload) if payload else None,
+            }
+        )
+        return self.status, json.dumps(self.body)
+
+
+class ClientTests(unittest.TestCase):
+    def test_rejects_malformed_keys(self):
+        with self.assertRaises(SendByteError) as ctx:
+            SendByte("pk_live_nope")
+        self.assertEqual(ctx.exception.code, "invalid_api_key")
+
+    def test_sends_with_auth_and_body(self):
+        transport = FakeTransport(201)
+        client = SendByte("sk_test_abc", base_url="https://api.test", transport=transport)
+        result = client.emails.send(
+            from_="a@b.ng",
+            to="c@d.ng",
+            subject="Hi",
+            html="<p>x</p>",
+            idempotency_key="order-1",
+        )
+        self.assertEqual(result["id"], "em_1")
+        call = transport.calls[0]
+        self.assertEqual(call["url"], "https://api.test/v1/emails")
+        self.assertEqual(call["headers"]["authorization"], "Bearer sk_test_abc")
+        self.assertEqual(call["body"]["from"], "a@b.ng")
+        self.assertEqual(call["body"]["idempotency_key"], "order-1")
+
+    def test_rejects_unknown_send_kwargs(self):
+        client = SendByte("sk_test_abc", transport=FakeTransport())
+        with self.assertRaises(TypeError):
+            client.emails.send(from_="a@b.ng", to="c@d.ng", subject="x", htlm="typo")
+
+    def test_list_builds_query(self):
+        transport = FakeTransport(200, {"data": [], "has_more": False})
+        client = SendByte("sk_test_abc", base_url="https://api.test", transport=transport)
+        client.emails.list(limit=5, status="delivered")
+        self.assertEqual(transport.calls[0]["url"], "https://api.test/v1/emails?limit=5&status=delivered")
+
+    def test_maps_api_errors(self):
+        transport = FakeTransport(
+            403,
+            {
+                "error": {
+                    "code": "domain_not_verified",
+                    "message": "paylink.ng is not verified.",
+                    "docs_url": "https://docs.sendbyte.africa/errors/domain_not_verified",
+                }
+            },
+        )
+        client = SendByte("sk_live_abc", base_url="https://api.test", transport=transport)
+        with self.assertRaises(SendByteError) as ctx:
+            client.emails.send(from_="a@paylink.ng", to="c@d.ng", subject="x", text="x")
+        self.assertEqual(ctx.exception.code, "domain_not_verified")
+        self.assertEqual(ctx.exception.status, 403)
+        self.assertIn("/errors/domain_not_verified", ctx.exception.docs_url)
+
+    def test_domains_and_webhooks_surfaces(self):
+        transport = FakeTransport(200, {"data": []})
+        client = SendByte("sk_test_abc", base_url="https://api.test", transport=transport)
+        client.domains.list()
+        client.webhooks.list()
+        urls = [c["url"] for c in transport.calls]
+        self.assertEqual(urls, ["https://api.test/v1/domains", "https://api.test/v1/webhooks"])
+
+    def test_async_client(self):
+        transport = FakeTransport(201)
+        client = AsyncSendByte("sk_test_abc", base_url="https://api.test", transport=transport)
+
+        async def run():
+            return await client.send_email(from_="a@b.ng", to="c@d.ng", subject="Hi", text="x")
+
+        result = asyncio.get_event_loop().run_until_complete(run())
+        self.assertEqual(result["id"], "em_1")
+
+
+class WebhookSignatureTests(unittest.TestCase):
+    SECRET = "whsec_secret"
+    NOW = 1_750_000_000
+    BODY = '{"type":"email.delivered"}'
+
+    def sign(self, timestamp):
+        digest = hmac.new(
+            self.SECRET.encode(), f"{timestamp}.{self.BODY}".encode(), hashlib.sha256
+        ).hexdigest()
+        return f"t={timestamp},v1={digest}"
+
+    def test_accepts_valid(self):
+        self.assertTrue(
+            verify_webhook_signature(self.SECRET, self.sign(self.NOW), self.BODY, now=self.NOW)
+        )
+
+    def test_rejects_tampered_stale_and_missing(self):
+        self.assertFalse(
+            verify_webhook_signature(self.SECRET, self.sign(self.NOW), '{"type":"x"}', now=self.NOW)
+        )
+        self.assertFalse(
+            verify_webhook_signature(self.SECRET, self.sign(self.NOW - 301), self.BODY, now=self.NOW)
+        )
+        self.assertFalse(verify_webhook_signature(self.SECRET, None, self.BODY, now=self.NOW))
+        self.assertFalse(verify_webhook_signature(self.SECRET, "garbage", self.BODY, now=self.NOW))
+
+
+if __name__ == "__main__":
+    unittest.main()