sendbyte 0.1.0__tar.gz → 0.2.1__tar.gz

{sendbyte-0.1.0/sendbyte.egg-info → sendbyte-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sendbyte
-Version: 0.1.0
+Version: 0.2.1
 Summary: SendByte Python SDK: the email API for Africa.
 Author: Echospectra Technology Limited
 License: MIT

{sendbyte-0.1.0 → sendbyte-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sendbyte"
-version = "0.1.0"
+version = "0.2.1"
 description = "SendByte Python SDK: the email API for Africa."
 readme = "README.md"
 license = { text = "MIT" }
@@ -21,6 +21,9 @@ classifiers = [
 # Zero runtime dependencies: stdlib urllib for transport.
 dependencies = []
 
+[tool.setuptools]
+include-package-data = true
+
 [project.urls]
 Homepage = "https://sendbyte.africa"
 Documentation = "https://docs.sendbyte.africa"
@@ -29,3 +32,7 @@ Issues = "https://github.com/Sendbyte-Africa/sendbyte-python/issues"
 
 [tool.setuptools.packages.find]
 include = ["sendbyte*"]
+
+# Ship the PEP 561 marker so type checkers treat the installed package as typed.
+[tool.setuptools.package-data]
+sendbyte = ["py.typed"]

{sendbyte-0.1.0 → sendbyte-0.2.1}/sendbyte/__init__.py

@@ -17,14 +17,18 @@ same surface; errors carry the API's error shape (code, message, docs_url).
 from __future__ import annotations
 
 import asyncio
+import email.utils as email_utils
 import hashlib
 import hmac
 import json
+import random
 import time
 import urllib.error
 import urllib.parse
 import urllib.request
+import uuid
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from urllib.parse import urlsplit
 
 __all__ = [
     "SendByte",
@@ -36,10 +40,16 @@ __all__ = [
 
 DEFAULT_BASE_URL = "https://api.sendbyte.africa"
 SIGNATURE_HEADER = "sendbyte-signature"
-_VERSION = "0.1.0"
+_VERSION = "0.2.0"
+DEFAULT_MAX_ATTEMPTS = 3
+DEFAULT_TIMEOUT_SECONDS = 30.0
+_MAX_BACKOFF_SECONDS = 20.0
 
-# transport(method, url, headers, body) -> (status, response_text)
-Transport = Callable[[str, str, Dict[str, str], Optional[bytes]], Tuple[int, str]]
+# transport(method, url, headers, body) -> (status, response_text). The default
+# transport also exposes the response headers as a third tuple element so the
+# retry policy can read Retry-After; a custom transport may return only
+# (status, text), in which case headers are treated as absent.
+Transport = Callable[..., Tuple]
 
 
 class SendByteError(Exception):
@@ -52,19 +62,76 @@ class SendByteError(Exception):
         self.docs_url = docs_url
 
 
+def _is_secure_base_url(base_url: str) -> bool:
+    """https is required; http is tolerated only for localhost/loopback dev hosts."""
+    parts = urlsplit(base_url)
+    if parts.scheme == "https":
+        return True
+    host = parts.hostname or ""
+    return host in ("localhost", "127.0.0.1", "::1")
+
+
+def _is_retryable_status(status: int) -> bool:
+    return status == 429 or 500 <= status < 600
+
+
+def _parse_retry_after(value: Optional[str]) -> Optional[float]:
+    if not value:
+        return None
+    try:
+        return max(0.0, float(value))
+    except ValueError:
+        pass
+    try:
+        parsed = email_utils.parsedate_to_datetime(value)
+    except (TypeError, ValueError):
+        return None
+    if parsed is None:
+        return None
+    return max(0.0, parsed.timestamp() - time.time())
+
+
+def _backoff_delay(attempt: int, retry_after: Optional[str]) -> float:
+    """Exponential backoff with full jitter, capped, honoring Retry-After.
+
+    attempt is 1-based.
+    """
+    after = _parse_retry_after(retry_after)
+    if after is not None:
+        return min(after, _MAX_BACKOFF_SECONDS)
+    base = min(_MAX_BACKOFF_SECONDS, 0.25 * (2 ** (attempt - 1)))
+    return random.random() * base
+
+
 def _default_transport(
-    method: str, url: str, headers: Dict[str, str], body: Optional[bytes]
-) -> Tuple[int, str]:
+    method: str, url: str, headers: Dict[str, str], body: Optional[bytes], timeout: float
+) -> Tuple[int, str, Dict[str, 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")
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return response.status, response.read().decode("utf-8"), dict(response.headers)
     except urllib.error.HTTPError as err:  # non-2xx still carries a JSON body
-        return err.code, err.read().decode("utf-8")
+        return err.code, err.read().decode("utf-8"), dict(err.headers or {})
+
+
+def _normalize_transport_result(result: Tuple) -> Tuple[int, str, Dict[str, str]]:
+    """Accept (status, text) or (status, text, headers) from any transport."""
+    if len(result) >= 3:
+        status, text, raw = result[0], result[1], result[2]
+        headers = {str(k).lower(): str(v) for k, v in (raw or {}).items()}
+        return status, text, headers
+    return result[0], result[1], {}
 
 
 class _Http:
-    def __init__(self, api_key: str, base_url: str, transport: Optional[Transport]):
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str,
+        transport: Optional[Transport],
+        max_attempts: int,
+        timeout: float,
+    ):
         if not api_key or not (api_key.startswith("sk_live_") or api_key.startswith("sk_test_")):
             raise SendByteError(
                 "invalid_api_key",
@@ -74,30 +141,111 @@ class _Http:
             )
         self.api_key = api_key
         self.base_url = base_url.rstrip("/")
-        self.transport = transport or _default_transport
+        self.transport = transport
+        self.max_attempts = max(1, max_attempts)
+        self.timeout = max(0.001, timeout)
+
+        # A live key over a non-https base URL would send the secret in cleartext.
+        if api_key.startswith("sk_live_") and not _is_secure_base_url(self.base_url):
+            raise SendByteError(
+                "insecure_base_url",
+                "Refusing to send a live API key (sk_live_) over an insecure base URL. "
+                "Use https, or a test key for local http.",
+                0,
+            )
+
+    def _call_transport(
+        self, method: str, url: str, headers: Dict[str, str], payload: Optional[bytes]
+    ) -> Tuple[int, str, Dict[str, str]]:
+        if self.transport is not None:
+            # A custom transport keeps the historical (method, url, headers, body)
+            # signature; only the default transport receives the timeout.
+            return _normalize_transport_result(self.transport(method, url, headers, payload))
+        return _default_transport(method, url, headers, payload, self.timeout)
 
     def request(self, method: str, path: str, body: Optional[Dict[str, Any]] = None) -> Any:
+        # Auto-generate an idempotency key for sends and reuse it across retries
+        # so a retried POST /v1/emails cannot double-send. Body-based, matching
+        # the API.
+        payload_body = body
+        if (
+            method == "POST"
+            and path == "/v1/emails"
+            and isinstance(payload_body, dict)
+            and payload_body.get("idempotency_key") is None
+        ):
+            payload_body = {**payload_body, "idempotency_key": str(uuid.uuid4())}
+
         headers = {
             "authorization": f"Bearer {self.api_key}",
             "user-agent": f"sendbyte-python/{_VERSION}",
         }
         payload: Optional[bytes] = None
-        if body is not None:
+        if payload_body is not None:
             headers["content-type"] = "application/json"
-            payload = json.dumps(body).encode("utf-8")
+            payload = json.dumps(payload_body).encode("utf-8")
+
+        url = f"{self.base_url}{path}"
+        last_error: Optional[SendByteError] = None
+        for attempt in range(1, self.max_attempts + 1):
+            try:
+                status, text, response_headers = self._call_transport(
+                    method, url, headers, payload
+                )
+            except urllib.error.URLError as err:
+                # Network or timeout error: retry if attempts remain.
+                last_error = SendByteError(
+                    "request_failed",
+                    f"Could not reach the SendByte API: {err.reason}",
+                    0,
+                )
+                if attempt < self.max_attempts:
+                    time.sleep(_backoff_delay(attempt, None))
+                    continue
+                raise last_error
+
+            if status >= 400:
+                if _is_retryable_status(status) and attempt < self.max_attempts:
+                    last_error = _parse_error(text, status)
+                    time.sleep(_backoff_delay(attempt, response_headers.get("retry-after")))
+                    continue
+                raise _parse_error(text, status)
+
+            # 2xx: parse the success body, guarding against a non-JSON proxy response.
+            if not text:
+                return {}
+            try:
+                return json.loads(text)
+            except ValueError:
+                raise SendByteError(
+                    "invalid_response",
+                    f"The API returned a 2xx response that was not valid JSON (status {status}).",
+                    status,
+                )
+
+        raise last_error or SendByteError(
+            "request_failed", "Request failed after exhausting retries.", 0
+        )
 
-        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"),
+def _parse_error(text: str, status: int) -> SendByteError:
+    """Parse a non-2xx body into a typed error, never raising on non-JSON bodies."""
+    data: Any = {}
+    if text:
+        try:
+            data = json.loads(text)
+        except ValueError:
+            # A gateway/proxy 502/504 may return HTML or plain text.
+            return SendByteError(
+                "request_failed", f"Request failed with status {status}.", status
             )
-        return data
+    error = data.get("error", {}) if isinstance(data, dict) else {}
+    return SendByteError(
+        error.get("code", "request_failed"),
+        error.get("message", f"Request failed with status {status}"),
+        status,
+        error.get("docs_url"),
+    )
 
 
 def _build_send_body(
@@ -116,6 +264,7 @@ def _build_send_body(
         "attachments",
         "tags",
         "headers",
+        "list_unsubscribe",
         "scheduled_at",
         "template_id",
         "variables",
@@ -200,7 +349,16 @@ class _Webhooks:
 
 
 class SendByte:
-    """Synchronous SendByte client."""
+    """Synchronous SendByte client.
+
+    Retries 429 and 5xx responses (and network errors) with exponential
+    backoff plus jitter, honoring Retry-After, up to ``max_attempts``. Each
+    attempt by the built-in transport is bounded by ``timeout`` seconds; a
+    custom ``transport`` you inject is responsible for its own timeout (it keeps
+    the historical ``(method, url, headers, body)`` signature). On POST
+    /v1/emails an idempotency key is generated and reused across retries when the
+    caller did not supply one, so a retried send cannot double-send.
+    """
 
     def __init__(
         self,
@@ -208,8 +366,10 @@ class SendByte:
         *,
         base_url: str = DEFAULT_BASE_URL,
         transport: Optional[Transport] = None,
+        max_attempts: int = DEFAULT_MAX_ATTEMPTS,
+        timeout: float = DEFAULT_TIMEOUT_SECONDS,
     ):
-        http = _Http(api_key, base_url, transport)
+        http = _Http(api_key, base_url, transport, max_attempts, timeout)
         self.emails = _Emails(http)
         self.domains = _Domains(http)
         self.webhooks = _Webhooks(http)
@@ -228,8 +388,16 @@ class AsyncSendByte:
         *,
         base_url: str = DEFAULT_BASE_URL,
         transport: Optional[Transport] = None,
+        max_attempts: int = DEFAULT_MAX_ATTEMPTS,
+        timeout: float = DEFAULT_TIMEOUT_SECONDS,
     ):
-        self._sync = SendByte(api_key, base_url=base_url, transport=transport)
+        self._sync = SendByte(
+            api_key,
+            base_url=base_url,
+            transport=transport,
+            max_attempts=max_attempts,
+            timeout=timeout,
+        )
 
     async def _run(self, fn: Callable[[], Any]) -> Any:
         loop = asyncio.get_event_loop()
@@ -253,6 +421,9 @@ class AsyncSendByte:
     async def create_domain(self, domain: str) -> Dict[str, Any]:
         return await self._run(lambda: self._sync.domains.create(domain))
 
+    async def get_domain(self, domain_id: str) -> Dict[str, Any]:
+        return await self._run(lambda: self._sync.domains.get(domain_id))
+
     async def verify_domain(self, domain_id: str) -> Dict[str, Any]:
         return await self._run(lambda: self._sync.domains.verify(domain_id))
 
@@ -266,6 +437,12 @@ class AsyncSendByte:
     async def list_webhooks(self) -> Dict[str, Any]:
         return await self._run(lambda: self._sync.webhooks.list())
 
+    async def disable_webhook(self, endpoint_id: str) -> Dict[str, Any]:
+        return await self._run(lambda: self._sync.webhooks.disable(endpoint_id))
+
+    async def replay_webhook(self, delivery_id: str) -> Dict[str, Any]:
+        return await self._run(lambda: self._sync.webhooks.replay(delivery_id))
+
 
 def verify_webhook_signature(
     secret: str,

{sendbyte-0.1.0 → sendbyte-0.2.1/sendbyte.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sendbyte
-Version: 0.1.0
+Version: 0.2.1
 Summary: SendByte Python SDK: the email API for Africa.
 Author: Echospectra Technology Limited
 License: MIT

sendbyte-0.2.1/tests/test_sdk.py

@@ -0,0 +1,257 @@
+"""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 SequenceTransport:
+    """Returns a scripted list of (status, text[, headers]) tuples, one per call."""
+
+    def __init__(self, responses):
+        self.responses = responses
+        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.responses[min(len(self.calls) - 1, len(self.responses) - 1)]
+
+
+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")
+
+    def test_auto_idempotency_key_when_absent(self):
+        transport = FakeTransport(201)
+        client = SendByte("sk_test_abc", base_url="https://api.test", transport=transport)
+        client.emails.send(from_="a@b.ng", to="c@d.ng", subject="Hi", text="x")
+        key = transport.calls[0]["body"]["idempotency_key"]
+        self.assertRegex(
+            key,
+            r"^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$",
+        )
+
+    def test_retries_429_and_reuses_idempotency_key(self):
+        transport = SequenceTransport(
+            [
+                (429, json.dumps({"error": {"code": "rate_limited"}}), {"retry-after": "0"}),
+                (201, json.dumps(EMAIL), {}),
+            ]
+        )
+        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", text="x")
+        self.assertEqual(result["id"], "em_1")
+        self.assertEqual(len(transport.calls), 2)
+        self.assertEqual(
+            transport.calls[0]["body"]["idempotency_key"],
+            transport.calls[1]["body"]["idempotency_key"],
+        )
+
+    def test_retries_5xx_then_raises_typed_error(self):
+        transport = SequenceTransport(
+            [(503, json.dumps({"error": {"code": "unavailable"}}), {})]
+        )
+        client = SendByte(
+            "sk_test_abc", base_url="https://api.test", transport=transport, max_attempts=2
+        )
+        with self.assertRaises(SendByteError) as ctx:
+            client.emails.send(from_="a@b.ng", to="c@d.ng", subject="x", text="x")
+        self.assertEqual(ctx.exception.status, 503)
+        self.assertEqual(len(transport.calls), 2)
+
+    def test_non_json_error_body_raises_typed_error(self):
+        transport = SequenceTransport([(502, "<html>502 Bad Gateway</html>", {})])
+        client = SendByte(
+            "sk_test_abc", base_url="https://api.test", transport=transport, max_attempts=1
+        )
+        with self.assertRaises(SendByteError) as ctx:
+            client.emails.send(from_="a@b.ng", to="c@d.ng", subject="x", text="x")
+        self.assertEqual(ctx.exception.code, "request_failed")
+        self.assertEqual(ctx.exception.status, 502)
+
+    def test_non_json_success_body_raises_invalid_response(self):
+        transport = SequenceTransport([(200, "<html>not json</html>", {})])
+        client = SendByte("sk_test_abc", base_url="https://api.test", transport=transport)
+        with self.assertRaises(SendByteError) as ctx:
+            client.emails.list()
+        self.assertEqual(ctx.exception.code, "invalid_response")
+        self.assertEqual(ctx.exception.status, 200)
+
+    def test_list_unsubscribe_passes_through(self):
+        transport = FakeTransport(201)
+        client = SendByte("sk_test_abc", base_url="https://api.test", transport=transport)
+        client.emails.send(
+            from_="a@b.ng",
+            to="c@d.ng",
+            subject="Hi",
+            text="x",
+            list_unsubscribe={"url": "https://x.ng/u", "mailto": "unsub@x.ng"},
+        )
+        self.assertEqual(
+            transport.calls[0]["body"]["list_unsubscribe"],
+            {"url": "https://x.ng/u", "mailto": "unsub@x.ng"},
+        )
+
+    def test_refuses_live_key_over_insecure_base_url(self):
+        with self.assertRaises(SendByteError) as ctx:
+            SendByte("sk_live_abc", base_url="http://api.example.com")
+        self.assertEqual(ctx.exception.code, "insecure_base_url")
+        # http tolerated for localhost dev; test keys always allowed.
+        SendByte("sk_live_abc", base_url="http://localhost:8080", transport=FakeTransport())
+        SendByte("sk_test_abc", base_url="http://api.example.com", transport=FakeTransport())
+
+    def test_async_parity_methods(self):
+        transport = FakeTransport(200, {"id": "dom_1", "ses_verified": True})
+        client = AsyncSendByte("sk_test_abc", base_url="https://api.test", transport=transport)
+
+        async def run():
+            # The methods missing before this fix: get_domain, disable_webhook, replay_webhook.
+            await client.get_domain("dom_1")
+            await client.disable_webhook("wh_1")
+            await client.replay_webhook("evt_1")
+            return [c["url"] for c in transport.calls]
+
+        urls = asyncio.new_event_loop().run_until_complete(run())
+        self.assertEqual(
+            urls,
+            [
+                "https://api.test/v1/domains/dom_1",
+                "https://api.test/v1/webhooks/wh_1",
+                "https://api.test/v1/webhooks/deliveries/evt_1/replay",
+            ],
+        )
+
+
+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()

sendbyte-0.1.0/tests/test_sdk.py

@@ -1,138 +0,0 @@
-"""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()