sending-sdk 0.1.0__py3-none-any.whl

sending/__init__.py

@@ -0,0 +1,9 @@
+"""SDK Python ufficiale per l'API di Sending.dev."""
+
+from ._client import DEFAULT_BASE_URL
+from ._errors import SendingError
+from .async_client import AsyncSending
+from .client import Sending
+
+__version__ = "0.1.0"
+__all__ = ["Sending", "AsyncSending", "SendingError", "DEFAULT_BASE_URL", "__version__"]

sending/_async_client.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional
+
+import httpx
+
+from ._client import DEFAULT_BASE_URL, _to_jsonable
+from ._errors import SendingError
+
+
+class AsyncHttpClient:
+    """Variante asincrona di HttpClient su httpx.AsyncClient."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        *,
+        timeout: float = 30.0,
+        transport: Optional[httpx.AsyncBaseTransport] = None,
+    ) -> None:
+        if not api_key:
+            raise ValueError("Sending: api_key richiesta")
+        self._client = httpx.AsyncClient(
+            base_url=base_url.rstrip("/"),
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Accept": "application/json",
+            },
+            timeout=timeout,
+            transport=transport,
+        )
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Mapping[str, Any]] = None,
+        body: Any = None,
+    ) -> Any:
+        params = (
+            {k: v for k, v in query.items() if v is not None} if query else None
+        )
+        json_body = _to_jsonable(body) if body is not None else None
+
+        res = await self._client.request(method, path, params=params, json=json_body)
+
+        content_type = res.headers.get("content-type", "")
+        if "application/json" in content_type and res.content:
+            data: Any = res.json()
+        else:
+            data = res.text or None
+
+        if res.is_error:
+            raise SendingError(res.status_code, data)
+        return data
+
+    async def aclose(self) -> None:
+        await self._client.aclose()

sending/_client.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional
+
+import httpx
+from pydantic import BaseModel
+
+from ._errors import SendingError
+
+DEFAULT_BASE_URL = "https://sending.dev/api/v1"
+
+
+def _to_jsonable(value: Any) -> Any:
+    """Converte i modelli Pydantic in dict; lascia il resto invariato."""
+    if isinstance(value, BaseModel):
+        return value.model_dump(exclude_none=True, by_alias=True)
+    return value
+
+
+class HttpClient:
+    """Client HTTP minimale: auth bearer, JSON, gestione errori."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        *,
+        timeout: float = 30.0,
+        transport: Optional[httpx.BaseTransport] = None,
+    ) -> None:
+        if not api_key:
+            raise ValueError("Sending: api_key richiesta")
+        self._client = httpx.Client(
+            base_url=base_url.rstrip("/"),
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Accept": "application/json",
+            },
+            timeout=timeout,
+            transport=transport,
+        )
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Mapping[str, Any]] = None,
+        body: Any = None,
+    ) -> Any:
+        params = (
+            {k: v for k, v in query.items() if v is not None} if query else None
+        )
+        json_body = _to_jsonable(body) if body is not None else None
+
+        res = self._client.request(method, path, params=params, json=json_body)
+
+        content_type = res.headers.get("content-type", "")
+        if "application/json" in content_type and res.content:
+            data: Any = res.json()
+        else:
+            data = res.text or None
+
+        if res.is_error:
+            raise SendingError(res.status_code, data)
+        return data
+
+    def close(self) -> None:
+        self._client.close()

sending/_errors.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class SendingError(Exception):
+    """Errore sollevato quando l'API risponde con uno stato non 2xx."""
+
+    def __init__(self, status: int, body: Any) -> None:
+        self.status = status
+        self.body = body
+        self.code = _extract_code(body)
+        suffix = f" ({self.code})" if self.code else ""
+        super().__init__(f"Sending API error {status}{suffix}")
+
+
+def _extract_code(body: Any) -> Optional[str]:
+    if isinstance(body, dict):
+        err = body.get("error")
+        if isinstance(err, str):
+            return err
+    return None

sending/_protocols.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional, Protocol
+
+
+class RequestClient(Protocol):
+    """Interfaccia comune ai backend HTTP sync e async.
+
+    Il backend sync restituisce direttamente il valore; quello async restituisce
+    una coroutine da attendere. In entrambi i casi il tipo statico e' `Any`.
+    """
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Mapping[str, Any]] = None,
+        body: Any = None,
+    ) -> Any: ...

sending/async_client.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ._async_client import AsyncHttpClient
+from ._client import DEFAULT_BASE_URL
+from .resources import (
+    Automations,
+    Campaigns,
+    Contacts,
+    CustomFields,
+    Domains,
+    EmailRules,
+    Emails,
+    Events,
+    Inboxes,
+    Integrations,
+    Lists,
+    Messages,
+    Segments,
+    Tags,
+    Usage,
+    Utm,
+    Webhooks,
+)
+
+
+class AsyncSending:
+    """Client asincrono dell'API di Sending.dev.
+
+    Le stesse classi risorsa del client sync: con il backend async ogni metodo
+    restituisce una coroutine da attendere.
+
+    Esempio::
+
+        import asyncio
+        from sending import AsyncSending
+
+        async def main():
+            async with AsyncSending(api_key="sk_...") as client:
+                await client.emails.send({
+                    "to": "a@b.com",
+                    "from": "you@dominio.com",
+                    "subject": "Ciao",
+                    "html": "<p>Hi</p>",
+                    "idempotencyKey": "welcome-001",
+                })
+
+        asyncio.run(main())
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        transport: Optional[httpx.AsyncBaseTransport] = None,
+    ) -> None:
+        self._http = AsyncHttpClient(api_key, base_url, timeout=timeout, transport=transport)
+
+        self.emails = Emails(self._http)
+        self.messages = Messages(self._http)
+        self.events = Events(self._http)
+        self.campaigns = Campaigns(self._http)
+        self.contacts = Contacts(self._http)
+        self.lists = Lists(self._http)
+        self.tags = Tags(self._http)
+        self.custom_fields = CustomFields(self._http)
+        self.segments = Segments(self._http)
+        self.domains = Domains(self._http)
+        self.inboxes = Inboxes(self._http)
+        self.email_rules = EmailRules(self._http)
+        self.automations = Automations(self._http)
+        self.webhooks = Webhooks(self._http)
+        self.utm = Utm(self._http)
+        self.integrations = Integrations(self._http)
+        self.usage = Usage(self._http)
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> "AsyncSending":
+        return self
+
+    async def __aexit__(self, *_exc: object) -> None:
+        await self.aclose()

sending/client.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ._client import DEFAULT_BASE_URL, HttpClient
+from .resources import (
+    Automations,
+    Campaigns,
+    Contacts,
+    CustomFields,
+    Domains,
+    EmailRules,
+    Emails,
+    Events,
+    Inboxes,
+    Integrations,
+    Lists,
+    Messages,
+    Segments,
+    Tags,
+    Usage,
+    Utm,
+    Webhooks,
+)
+
+
+class Sending:
+    """Client ufficiale dell'API di Sending.dev.
+
+    Esempio::
+
+        from sending import Sending
+
+        client = Sending(api_key="sk_...")
+        client.emails.send({
+            "to": "a@b.com",
+            "from": "you@dominio.com",
+            "subject": "Ciao",
+            "html": "<p>Hi</p>",
+            "idempotencyKey": "welcome-001",
+        })
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        transport: Optional[httpx.BaseTransport] = None,
+    ) -> None:
+        self._http = HttpClient(api_key, base_url, timeout=timeout, transport=transport)
+
+        self.emails = Emails(self._http)
+        self.messages = Messages(self._http)
+        self.events = Events(self._http)
+        self.campaigns = Campaigns(self._http)
+        self.contacts = Contacts(self._http)
+        self.lists = Lists(self._http)
+        self.tags = Tags(self._http)
+        self.custom_fields = CustomFields(self._http)
+        self.segments = Segments(self._http)
+        self.domains = Domains(self._http)
+        self.inboxes = Inboxes(self._http)
+        self.email_rules = EmailRules(self._http)
+        self.automations = Automations(self._http)
+        self.webhooks = Webhooks(self._http)
+        self.utm = Utm(self._http)
+        self.integrations = Integrations(self._http)
+        self.usage = Usage(self._http)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "Sending":
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()