sendly-python 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

sendly/__init__.py

@@ -6,6 +6,12 @@ Example:
     >>> sendly.emails.send(
     ...     {"from": "a@b.com", "to": "c@d.com", "subject": "hi", "body": "<p>hi</p>"}
     ... )
+
+The same client also speaks the ``/api/v1`` surface — campaigns, segments,
+workflows, analytics, usage, and the v1 event methods:
+
+    >>> for campaign in sendly.campaigns.iter_list({"limit": 100}):
+    ...     print(campaign["name"], campaign["status"])
 """
 
 from __future__ import annotations
@@ -22,14 +28,20 @@ from sendly.errors import (
     SendlyServerError,
     SendlyValidationError,
 )
+from sendly.resources.analytics import AnalyticsResource
+from sendly.resources.campaigns import CampaignsResource
 from sendly.resources.contacts import ContactsResource
 from sendly.resources.domains import DomainsResource
 from sendly.resources.emails import EmailsResource
 from sendly.resources.events import EventsResource
+from sendly.resources.lists import ListsResource
+from sendly.resources.segments import SegmentsResource
 from sendly.resources.suppression import SuppressionResource
 from sendly.resources.templates import TemplatesResource
+from sendly.resources.usage import UsageResource
 from sendly.resources.verify import VerifyResource
 from sendly.resources.webhooks import WebhooksResource
+from sendly.resources.workflows import WorkflowsResource
 from sendly.webhook_utils import DEFAULT_TOLERANCE_MS, construct_event, verify_signature
 
 __version__ = SDK_VERSION
@@ -38,10 +50,14 @@ __all__ = [
     "DEFAULT_BASE_URL",
     "DEFAULT_TOLERANCE_MS",
     "SDK_VERSION",
+    "AnalyticsResource",
+    "CampaignsResource",
     "ContactsResource",
     "DomainsResource",
     "EmailsResource",
     "EventsResource",
+    "ListsResource",
+    "SegmentsResource",
     "Sendly",
     "SendlyAuthenticationError",
     "SendlyConflictError",
@@ -54,8 +70,10 @@ __all__ = [
     "SendlyValidationError",
     "SuppressionResource",
     "TemplatesResource",
+    "UsageResource",
     "VerifyResource",
     "WebhooksResource",
+    "WorkflowsResource",
     "__version__",
     "construct_event",
     "verify_signature",

sendly/client.py

@@ -7,6 +7,14 @@ Ported from the reference TypeScript SDK's ``client.ts``. Behavioural parity:
 * Error envelope ``{error: {code, message}}`` mapped to typed exceptions.
 * Query params skip ``None``/empty-string; list values append repeated keys.
 * 204 / No-Content -> ``None``; non-JSON success body -> raw text.
+
+One client, two response dialects. The legacy ``/api/*`` resources wrap results
+in ``{success, data}`` and report failures as ``{error: {code, message}}``. The
+``/api/v1/*`` resources (``campaigns``, ``segments``, ``workflows``,
+``analytics``, ``usage``, and the v1 methods on ``events``) return the resource
+body directly — no envelope, so they never call :meth:`Sendly.unwrap` — and
+report failures as RFC 9457 problem documents. Both dialects raise the same
+:class:`~sendly.errors.SendlyError` subclasses.
 """
 
 from __future__ import annotations
@@ -18,15 +26,27 @@ from urllib.parse import urlencode
 
 import httpx
 
-from sendly.errors import SendlyConnectionError, SendlyError, error_from_response
+from sendly.errors import (
+    SendlyConnectionError,
+    SendlyError,
+    error_from_problem,
+    error_from_response,
+    is_problem_document,
+)
+from sendly.resources.analytics import AnalyticsResource
+from sendly.resources.campaigns import CampaignsResource
 from sendly.resources.contacts import ContactsResource
 from sendly.resources.domains import DomainsResource
 from sendly.resources.emails import EmailsResource
 from sendly.resources.events import EventsResource
+from sendly.resources.lists import ListsResource
+from sendly.resources.segments import SegmentsResource
 from sendly.resources.suppression import SuppressionResource
 from sendly.resources.templates import TemplatesResource
+from sendly.resources.usage import UsageResource
 from sendly.resources.verify import VerifyResource
 from sendly.resources.webhooks import WebhooksResource
+from sendly.resources.workflows import WorkflowsResource
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -37,7 +57,7 @@ if TYPE_CHECKING:
 __all__ = ["DEFAULT_BASE_URL", "SDK_VERSION", "Sendly"]
 
 #: Package version. Kept in sync with ``pyproject.toml``.
-SDK_VERSION = "0.1.0"
+SDK_VERSION = "0.2.0"
 
 #: Default production API base. Override via ``base_url`` for staging/self-hosted.
 DEFAULT_BASE_URL = "https://api.sendly.now"
@@ -56,9 +76,11 @@ def _stringify(value: Any) -> str:
 class Sendly:
     """Sendly SDK entry point.
 
-    Construct once with an API key and reuse the resource accessors
-    (``emails``, ``contacts``, ``events``, ``domains``, ``templates``,
-    ``verify``, ``webhooks``, ``suppression``) for all calls.
+    Construct once with an API key and reuse the resource accessors for all
+    calls: ``emails``, ``contacts``, ``events``, ``domains``, ``templates``,
+    ``verify``, ``webhooks``, ``suppression`` and ``lists`` on the legacy
+    surface, plus ``campaigns``, ``segments``, ``workflows``, ``analytics`` and
+    ``usage`` on ``/api/v1``.
 
     Args:
         api_key: Project API key (``sk_*`` for full access, ``pk_*`` for
@@ -112,6 +134,14 @@ class Sendly:
         self.verify = VerifyResource(self)
         self.webhooks = WebhooksResource(self)
         self.suppression = SuppressionResource(self)
+        self.lists = ListsResource(self)
+        # /api/v1 surface. Same client, same auth; bare resource bodies instead
+        # of the legacy {success, data} envelope, and RFC 9457 problem errors.
+        self.campaigns = CampaignsResource(self)
+        self.segments = SegmentsResource(self)
+        self.workflows = WorkflowsResource(self)
+        self.analytics = AnalyticsResource(self)
+        self.usage = UsageResource(self)
 
     def request(
         self,
@@ -180,7 +210,9 @@ class Sendly:
                 return text
 
         if not response.is_success:
-            self._raise_from_body(response.status_code, parsed)
+            self._raise_from_body(
+                response.status_code, parsed, response.headers.get("content-type")
+            )
 
         return parsed
 
@@ -238,9 +270,16 @@ class Sendly:
                 body = json.loads(text)
             except json.JSONDecodeError:
                 body = None
-        self._raise_from_body(response.status_code, body)
+        self._raise_from_body(response.status_code, body, response.headers.get("content-type"))
+
+    def _raise_from_body(
+        self, status_code: int, body: Any, content_type: str | None = None
+    ) -> NoReturn:
+        # /api/v1 speaks RFC 9457; the legacy surface speaks {success, error}.
+        # Both land on the same exception classes, keyed off the status.
+        if is_problem_document(body, content_type):
+            raise error_from_problem(status_code, body)
 
-    def _raise_from_body(self, status_code: int, body: Any) -> NoReturn:
         error = body.get("error") if isinstance(body, dict) else None
         error = error if isinstance(error, dict) else {}
         raw_message = error.get("message")

sendly/errors.py

@@ -3,30 +3,63 @@
 Mirrors the TypeScript SDK's ``errors.ts``: a single :class:`SendlyError` base with
 one subclass per meaningful HTTP status so callers can ``except`` a narrow type
 without inspecting the response body.
+
+The API speaks two error dialects and both land on the same exception classes:
+
+* legacy ``/api/*`` — ``{success: false, error: {code, message}}``;
+* ``/api/v1/*`` — an RFC 9457 problem document served as
+  ``application/problem+json``. Its ``code`` becomes :attr:`SendlyError.error_code`
+  and its ``detail`` (falling back to ``title``) becomes the message, so
+  ``except SendlyValidationError`` behaves identically across both surfaces.
+  Two problem-only fields are surfaced additively: :attr:`SendlyError.request_id`
+  and :attr:`SendlyError.field_errors`.
 """
 
 from __future__ import annotations
 
 from typing import Any
 
+#: Media type of an RFC 9457 problem document.
+PROBLEM_CONTENT_TYPE = "application/problem+json"
+
 
 class SendlyError(Exception):
     """Base error for any non-2xx HTTP response or transport failure.
 
     Attributes:
         status_code: HTTP status (``0`` for client-side/transport failures).
-        error_code: Machine-readable code from the API error envelope, or a
-            synthesized ``http_<status>`` / ``invalid_response`` / ``connection_error``.
+        error_code: Machine-readable code from the API error envelope (legacy
+            ``error.code`` or v1 problem ``code``), or a synthesized
+            ``http_<status>`` / ``invalid_response`` / ``connection_error``.
         message: Human-readable message.
-        body: The parsed (or raw) response body, when available.
+        body: The parsed (or raw) response body, when available. For a v1
+            failure this is the whole problem document, so ``type``, ``title``,
+            ``instance`` and any other member stays reachable.
+        request_id: Correlation id from a v1 problem document (``request_id``);
+            ``None`` on the legacy surface. Quote it in support requests.
+        field_errors: Field-level failures from a v1 ``validation_error``
+            problem (``errors``), each ``{pointer, code, message}``; ``None``
+            when the response carried none. The legacy surface puts its own
+            breakdown at ``body["error"]["details"]["errors"]`` instead.
     """
 
-    def __init__(self, status_code: int, error_code: str, message: str, body: Any = None) -> None:
+    def __init__(
+        self,
+        status_code: int,
+        error_code: str,
+        message: str,
+        body: Any = None,
+        *,
+        request_id: str | None = None,
+        field_errors: list[dict[str, Any]] | None = None,
+    ) -> None:
         super().__init__(message)
         self.status_code = status_code
         self.error_code = error_code
         self.message = message
         self.body = body
+        self.request_id = request_id
+        self.field_errors = field_errors
 
 
 class SendlyValidationError(SendlyError):
@@ -69,24 +102,95 @@ class SendlyConnectionError(SendlyError):
         super().__init__(0, "connection_error", message, body)
 
 
-def error_from_response(
-    status_code: int, error_code: str, message: str, body: Any = None
-) -> SendlyError:
-    """Map an HTTP status + error envelope to the appropriate error subclass."""
-    if status_code == 400:
-        return SendlyValidationError(status_code, error_code, message, body)
+def _error_class(status_code: int) -> type[SendlyError]:
+    """The exception class a status maps to. Shared by both error dialects."""
+    if status_code in (400, 422):
+        return SendlyValidationError
     if status_code == 401:
-        return SendlyAuthenticationError(status_code, error_code, message, body)
+        return SendlyAuthenticationError
     if status_code == 403:
-        return SendlyPermissionError(status_code, error_code, message, body)
+        return SendlyPermissionError
     if status_code == 404:
-        return SendlyNotFoundError(status_code, error_code, message, body)
-    if status_code == 422:
-        return SendlyValidationError(status_code, error_code, message, body)
+        return SendlyNotFoundError
     if status_code == 409:
-        return SendlyConflictError(status_code, error_code, message, body)
+        return SendlyConflictError
     if status_code == 429:
-        return SendlyRateLimitError(status_code, error_code, message, body)
+        return SendlyRateLimitError
     if status_code >= 500:
-        return SendlyServerError(status_code, error_code, message, body)
-    return SendlyError(status_code, error_code, message, body)
+        return SendlyServerError
+    return SendlyError
+
+
+def error_from_response(
+    status_code: int,
+    error_code: str,
+    message: str,
+    body: Any = None,
+    *,
+    request_id: str | None = None,
+    field_errors: list[dict[str, Any]] | None = None,
+) -> SendlyError:
+    """Map an HTTP status + error envelope to the appropriate error subclass."""
+    return _error_class(status_code)(
+        status_code,
+        error_code,
+        message,
+        body,
+        request_id=request_id,
+        field_errors=field_errors,
+    )
+
+
+def is_problem_document(body: Any, content_type: str | None = None) -> bool:
+    """Is this response body an RFC 9457 problem document?
+
+    Trusts the ``application/problem+json`` content type when present, and
+    otherwise falls back to the document shape (``type`` + ``title`` + ``code``),
+    so a proxy that rewrites the media type cannot downgrade a v1 error into the
+    generic ``http_<status>`` path. The legacy ``{success, error}`` envelope
+    carries none of those members, so it can never match.
+    """
+    if not isinstance(body, dict):
+        return False
+    if content_type and PROBLEM_CONTENT_TYPE in content_type.lower():
+        return True
+    return all(isinstance(body.get(key), str) for key in ("type", "title", "code"))
+
+
+def error_from_problem(status_code: int, problem: dict[str, Any]) -> SendlyError:
+    """Map an RFC 9457 problem document to the exception class for its status.
+
+    ``code`` supplies the machine-readable :attr:`SendlyError.error_code` and
+    ``detail`` the message, falling back to ``title`` — a problem document always
+    carries a title but only sometimes an occurrence-specific detail.
+    """
+    raw_code = problem.get("code")
+    code = raw_code if isinstance(raw_code, str) and raw_code else f"http_{status_code}"
+
+    message = ""
+    for key in ("detail", "title"):
+        value = problem.get(key)
+        if isinstance(value, str) and value:
+            message = value
+            break
+    if not message:
+        message = f"Sendly request failed with status {status_code}"
+
+    raw_request_id = problem.get("request_id")
+    request_id = raw_request_id if isinstance(raw_request_id, str) else None
+
+    raw_errors = problem.get("errors")
+    field_errors = (
+        [item for item in raw_errors if isinstance(item, dict)]
+        if isinstance(raw_errors, list)
+        else None
+    )
+
+    return error_from_response(
+        status_code,
+        code,
+        message,
+        problem,
+        request_id=request_id,
+        field_errors=field_errors,
+    )

sendly/resources/_pagination.py

@@ -0,0 +1,49 @@
+"""Auto-pagination over the ``/api/v1`` cursor envelope.
+
+Every v1 list endpoint answers with ``{data, has_more, next_cursor}``: an opaque
+forward-only cursor and no total (deliberately — counting a project's rows is a
+scan the API refuses to pay for on every page). :func:`iterate_cursor` walks that
+shape so callers can treat a multi-page listing as one stream of items.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator
+
+    from sendly.types import JSONDict, Query
+
+
+def iterate_cursor(
+    fetch: Callable[[dict[str, Any]], Any],
+    query: Query | None = None,
+) -> Iterator[JSONDict]:
+    """Yield every item across the pages ``fetch`` returns.
+
+    ``fetch`` receives the query for one page — the caller's own filters, plus
+    the ``after`` cursor from page two onward — and returns the raw cursor
+    envelope. Iteration stops when ``has_more`` is false or ``next_cursor`` is
+    ``None``, and also when a page carries no ``data`` list, so a malformed
+    response ends the walk instead of looping forever.
+
+    The caller's filters are held fixed for the whole walk on purpose: changing
+    them mid-pagination invalidates the cursor and the API answers ``422
+    validation_error`` telling you to restart from the first page.
+    """
+    params = dict(query or {})
+    while True:
+        page = fetch(params)
+        if not isinstance(page, dict):
+            return
+        items = page.get("data")
+        if not isinstance(items, list):
+            return
+        yield from items
+        if not page.get("has_more"):
+            return
+        cursor = page.get("next_cursor")
+        if not cursor:
+            return
+        params = {**params, "after": cursor}

sendly/resources/analytics.py

@@ -0,0 +1,49 @@
+"""Analytics resource (``/api/v1``)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sendly.client import Sendly
+    from sendly.types import (
+        AnalyticsTimeseries,
+        CampaignAnalytics,
+        Query,
+        TopCampaignList,
+    )
+
+
+class AnalyticsResource:
+    """Aggregate sending and engagement metrics.
+
+    Every method takes an optional ``from`` / ``to`` window (ISO 8601) and echoes
+    the resolved window back as ``window``, so a caller can tell what the API
+    actually measured when it defaulted the range. None of these are
+    cursor-paginated — they answer a bounded aggregate, not a listing — so there
+    are no iterators here.
+    """
+
+    def __init__(self, client: Sendly) -> None:
+        self._client = client
+
+    def timeseries(self, query: Query | None = None) -> AnalyticsTimeseries:
+        """Per-day sending and engagement counts over the window."""
+        response: AnalyticsTimeseries = self._client.request(
+            method="GET", path="/api/v1/analytics/timeseries", query=query
+        )
+        return response
+
+    def campaigns(self, query: Query | None = None) -> CampaignAnalytics:
+        """Campaign totals for the window: counts plus average open/click rates."""
+        response: CampaignAnalytics = self._client.request(
+            method="GET", path="/api/v1/analytics/campaigns", query=query
+        )
+        return response
+
+    def top_campaigns(self, query: Query | None = None) -> TopCampaignList:
+        """Best-performing campaigns in the window. Accepts ``limit``."""
+        response: TopCampaignList = self._client.request(
+            method="GET", path="/api/v1/analytics/top-campaigns", query=query
+        )
+        return response

sendly/resources/campaigns.py

@@ -0,0 +1,135 @@
+"""Campaigns resource (``/api/v1``)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from sendly.resources._helpers import encode_path_segment, idempotency_headers
+from sendly.resources._pagination import iterate_cursor
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from sendly.client import Sendly
+    from sendly.types import (
+        Body,
+        CampaignDeleted,
+        CampaignList,
+        CampaignRecord,
+        CampaignStats,
+        JSONDict,
+        Query,
+    )
+
+
+class CampaignsResource:
+    """Create, schedule, and run bulk email campaigns.
+
+    A campaign moves through ``DRAFT`` -> ``SENDING`` -> ``SENT``; :meth:`send`
+    starts it (optionally at a future time), and :meth:`pause` / :meth:`resume` /
+    :meth:`cancel` steer it while in flight. Responses are bare v1 resource
+    bodies — there is no ``{success, data}`` envelope to unwrap.
+    """
+
+    def __init__(self, client: Sendly) -> None:
+        self._client = client
+
+    def list(self, query: Query | None = None) -> CampaignList:
+        """List campaigns, newest first.
+
+        Accepts ``limit`` (1-100, default 20) and ``after`` (opaque cursor), and
+        answers ``{data, has_more, next_cursor}``. Keep the filters identical for
+        every page of one walk — changing them invalidates the cursor and the API
+        answers 422 ``validation_error`` telling you to restart from the first
+        page. :meth:`iter_list` does that bookkeeping for you.
+        """
+        response: CampaignList = self._client.request(
+            method="GET", path="/api/v1/campaigns", query=query
+        )
+        return response
+
+    def iter_list(self, query: Query | None = None) -> Iterator[JSONDict]:
+        """Iterate every campaign across pages, following the cursor for you."""
+        return iterate_cursor(self.list, query)
+
+    def create(self, body: Body, *, idempotency_key: str | None = None) -> CampaignRecord:
+        """Create a campaign in ``DRAFT``.
+
+        Requires ``name``, ``subject``, ``body``, ``from`` and ``audience_type``.
+        Pass ``idempotency_key`` (1-255 chars) to make a replayed create return
+        the original campaign instead of a second one.
+        """
+        response: CampaignRecord = self._client.request(
+            method="POST",
+            path="/api/v1/campaigns",
+            body=body,
+            headers=idempotency_headers(idempotency_key),
+        )
+        return response
+
+    def get(self, id: str) -> CampaignRecord:
+        """Fetch a single campaign, including its delivery ``stats``."""
+        response: CampaignRecord = self._client.request(
+            method="GET", path=f"/api/v1/campaigns/{encode_path_segment(id)}"
+        )
+        return response
+
+    def update(self, id: str, body: Body) -> CampaignRecord:
+        """Patch a draft campaign's content or audience."""
+        response: CampaignRecord = self._client.request(
+            method="PATCH", path=f"/api/v1/campaigns/{encode_path_segment(id)}", body=body
+        )
+        return response
+
+    def delete(self, id: str) -> CampaignDeleted:
+        """Delete a campaign. Returns the ``{id, deleted}`` confirmation body."""
+        response: CampaignDeleted = self._client.request(
+            method="DELETE", path=f"/api/v1/campaigns/{encode_path_segment(id)}"
+        )
+        return response
+
+    def send(
+        self, id: str, body: Body | None = None, *, idempotency_key: str | None = None
+    ) -> CampaignRecord:
+        """Send a campaign now, or schedule it.
+
+        Pass ``{"scheduled_for": "<ISO 8601>"}`` as ``body`` to queue it for a
+        future time instead of sending immediately. ``idempotency_key`` is the
+        guard that matters most on this call: a replayed send must not mail the
+        audience twice.
+        """
+        response: CampaignRecord = self._client.request(
+            method="POST",
+            path=f"/api/v1/campaigns/{encode_path_segment(id)}/send",
+            body=body,
+            headers=idempotency_headers(idempotency_key),
+        )
+        return response
+
+    def cancel(self, id: str) -> CampaignRecord:
+        """Cancel a scheduled or in-flight campaign. Already-sent mail stays sent."""
+        response: CampaignRecord = self._client.request(
+            method="POST", path=f"/api/v1/campaigns/{encode_path_segment(id)}/cancel"
+        )
+        return response
+
+    def pause(self, id: str) -> CampaignRecord:
+        """Pause an in-flight campaign, holding the remaining recipients."""
+        response: CampaignRecord = self._client.request(
+            method="POST", path=f"/api/v1/campaigns/{encode_path_segment(id)}/pause"
+        )
+        return response
+
+    def resume(self, id: str) -> CampaignRecord:
+        """Resume a paused campaign from where it stopped."""
+        response: CampaignRecord = self._client.request(
+            method="POST", path=f"/api/v1/campaigns/{encode_path_segment(id)}/resume"
+        )
+        return response
+
+    def stats(self, id: str) -> CampaignStats:
+        """Delivery and engagement counters plus derived rates for one campaign."""
+        response: CampaignStats = self._client.request(
+            method="GET", path=f"/api/v1/campaigns/{encode_path_segment(id)}/stats"
+        )
+        return response

sendly/resources/events.py

@@ -1,22 +1,43 @@
-"""Events resource."""
+"""Events resource (legacy ``/api/track`` + the ``/api/v1/events`` surface)."""
 
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from sendly.resources._pagination import iterate_cursor
+
 if TYPE_CHECKING:
+    from collections.abc import Iterator
+
     from sendly.client import Sendly
-    from sendly.types import Body, TrackEventData
+    from sendly.types import (
+        Body,
+        EventList,
+        EventNameList,
+        EventRecord,
+        EventStats,
+        JSONDict,
+        Query,
+        TrackEventData,
+    )
 
 
 class EventsResource:
-    """Record custom events for contacts."""
+    """Record custom events for contacts, and query the ones already recorded.
+
+    Two write methods, one per API surface. :meth:`track` is the original
+    ``POST /api/track`` call and is unchanged; :meth:`record` is its ``/api/v1``
+    counterpart. They do the same thing — the difference is the dialect: v1
+    returns the event body directly and reports failures as RFC 9457 problem
+    documents. New code should prefer :meth:`record`, alongside the v1 read
+    methods below.
+    """
 
     def __init__(self, client: Sendly) -> None:
         self._client = client
 
     def track(self, body: Body) -> TrackEventData:
-        """Record a custom event for a contact.
+        """Record a custom event for a contact (legacy ``/api/track``).
 
         Both full (``sk_*``) and sending-only (``pk_*``) keys are accepted.
         Reserved system event names (e.g. ``email.sent``) are rejected by the API.
@@ -24,3 +45,54 @@ class EventsResource:
         envelope = self._client.request(method="POST", path="/api/track", body=body)
         data: TrackEventData = self._client.unwrap(envelope)
         return data
+
+    def record(self, body: Body) -> EventRecord:
+        """Record a custom event for a contact (``/api/v1``).
+
+        Requires ``name``; optionally takes ``contact_id`` and a ``data`` object.
+        The v1 counterpart of :meth:`track`, returning the created event body
+        rather than a ``{success, data}`` envelope.
+
+        Takes no ``Idempotency-Key``: events are the highest-volume write on the
+        surface and append-only by nature, so the API deliberately does not
+        ledger them. If a duplicate would matter to you, dedupe on your side.
+        """
+        response: EventRecord = self._client.request(
+            method="POST", path="/api/v1/events", body=body
+        )
+        return response
+
+    def list(self, query: Query | None = None) -> EventList:
+        """List recorded events, newest first.
+
+        Accepts ``limit`` (1-100, default 20), ``after`` (opaque cursor), and
+        ``event_name`` to filter to one event. Answers
+        ``{data, has_more, next_cursor}`` — no total, deliberately. Keep the
+        filters identical across one walk: changing them invalidates the cursor
+        and the API answers 422 ``validation_error`` telling you to restart from
+        the first page.
+        """
+        response: EventList = self._client.request(method="GET", path="/api/v1/events", query=query)
+        return response
+
+    def iter_list(self, query: Query | None = None) -> Iterator[JSONDict]:
+        """Iterate every matching event across pages, following the cursor for you."""
+        return iterate_cursor(self.list, query)
+
+    def list_names(self) -> EventNameList:
+        """The distinct event names recorded on the project.
+
+        Takes no arguments — the endpoint declares no parameters, and the answer
+        is the project's whole name set. Useful for building a workflow trigger:
+        a workflow's ``event_name`` has to match a name events are actually
+        recorded under.
+        """
+        response: EventNameList = self._client.request(method="GET", path="/api/v1/events/names")
+        return response
+
+    def stats(self, query: Query | None = None) -> EventStats:
+        """Per-event counts over an optional ``from`` / ``to`` window."""
+        response: EventStats = self._client.request(
+            method="GET", path="/api/v1/events/stats", query=query
+        )
+        return response

sendly/resources/lists.py

@@ -0,0 +1,59 @@
+"""Lists resource (subscribe / unsubscribe)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from sendly.resources._helpers import encode_path_segment
+
+if TYPE_CHECKING:
+    from sendly.client import Sendly
+    from sendly.types import Body, ListSubscribeData, ListUnsubscribeData
+
+
+class ListsResource:
+    """Manage a contact's membership on a subscriber list.
+
+    Both calls accept sending-only (``pk_*``) keys so they can back a public
+    subscribe or preference form directly.
+    """
+
+    def __init__(self, client: Sendly) -> None:
+        self._client = client
+
+    def subscribe(self, id: str, body: Body) -> ListSubscribeData:
+        """Subscribe an address to a list, creating the contact if needed.
+
+        Requires ``email``. Two behaviours worth knowing before you wire this to
+        a form:
+
+        * When the list has double opt-in, the membership is created ``PENDING``
+          and the response carries a ``confirmToken``. Sendly does **not** send
+          the confirmation email — deliver ``/api/lists/confirm?token=<token>``
+          to the contact yourself.
+        * Re-subscribing an address that previously opted out fails with
+          ``409 RESUBSCRIBE_CONFIRMATION_REQUIRED`` unless the body sets
+          ``allowResubscribe: true``. Read ``previousStatus`` rather than
+          ``created`` to describe the transition back to the user.
+        """
+        envelope = self._client.request(
+            method="POST",
+            path=f"/api/lists/{encode_path_segment(id)}/subscribe",
+            body=body,
+        )
+        data: ListSubscribeData = self._client.unwrap(envelope)
+        return data
+
+    def unsubscribe(self, id: str, body: Body) -> ListUnsubscribeData:
+        """Mark an address's membership on this list ``UNSUBSCRIBED``.
+
+        Requires ``email``. Idempotent — unsubscribing an address that is not a
+        member succeeds.
+        """
+        envelope = self._client.request(
+            method="POST",
+            path=f"/api/lists/{encode_path_segment(id)}/unsubscribe",
+            body=body,
+        )
+        data: ListUnsubscribeData = self._client.unwrap(envelope)
+        return data

sendly/resources/segments.py

@@ -0,0 +1,106 @@
+"""Segments resource (``/api/v1``)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from sendly.resources._helpers import encode_path_segment
+from sendly.resources._pagination import iterate_cursor
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from sendly.client import Sendly
+    from sendly.types import (
+        Body,
+        ContactList,
+        JSONDict,
+        Query,
+        SegmentDeleted,
+        SegmentList,
+        SegmentRecord,
+    )
+
+
+class SegmentsResource:
+    """Group contacts into static lists or dynamic, condition-driven audiences.
+
+    A ``DYNAMIC`` segment's ``condition`` is evaluated by the API — its
+    ``member_count`` is computed at creation and kept current — so an invalid
+    condition fails the create with a 422 rather than silently matching nothing.
+    """
+
+    def __init__(self, client: Sendly) -> None:
+        self._client = client
+
+    def list(self, query: Query | None = None) -> SegmentList:
+        """List segments.
+
+        Accepts ``limit`` (1-100, default 20) and ``after`` (opaque cursor), and
+        answers ``{data, has_more, next_cursor}``. Hold the filters steady across
+        one walk — changing them mid-pagination invalidates the cursor and the
+        API answers 422 ``validation_error`` telling you to restart from the
+        first page.
+        """
+        response: SegmentList = self._client.request(
+            method="GET", path="/api/v1/segments", query=query
+        )
+        return response
+
+    def iter_list(self, query: Query | None = None) -> Iterator[JSONDict]:
+        """Iterate every segment across pages, following the cursor for you."""
+        return iterate_cursor(self.list, query)
+
+    def create(self, body: Body) -> SegmentRecord:
+        """Create a segment. Requires ``name``.
+
+        Takes no ``Idempotency-Key``: creating a segment neither sends anything
+        nor consumes quota, so a duplicate costs one row that a
+        :meth:`delete` undoes.
+        """
+        response: SegmentRecord = self._client.request(
+            method="POST", path="/api/v1/segments", body=body
+        )
+        return response
+
+    def get(self, id: str) -> SegmentRecord:
+        """Fetch a single segment, including its current ``member_count``."""
+        response: SegmentRecord = self._client.request(
+            method="GET", path=f"/api/v1/segments/{encode_path_segment(id)}"
+        )
+        return response
+
+    def update(self, id: str, body: Body) -> SegmentRecord:
+        """Patch a segment's name, description, condition, or membership tracking."""
+        response: SegmentRecord = self._client.request(
+            method="PATCH", path=f"/api/v1/segments/{encode_path_segment(id)}", body=body
+        )
+        return response
+
+    def delete(self, id: str) -> SegmentDeleted:
+        """Delete a segment. Returns the ``{id, deleted}`` confirmation body.
+
+        Removes the grouping, not the contacts in it.
+        """
+        response: SegmentDeleted = self._client.request(
+            method="DELETE", path=f"/api/v1/segments/{encode_path_segment(id)}"
+        )
+        return response
+
+    def list_contacts(self, id: str, query: Query | None = None) -> ContactList:
+        """List the contacts currently in a segment.
+
+        Cursor-paginated like :meth:`list` (``limit`` / ``after``). For a dynamic
+        segment this is evaluated against the live condition, so membership can
+        differ between two walks.
+        """
+        response: ContactList = self._client.request(
+            method="GET",
+            path=f"/api/v1/segments/{encode_path_segment(id)}/contacts",
+            query=query,
+        )
+        return response
+
+    def iter_list_contacts(self, id: str, query: Query | None = None) -> Iterator[JSONDict]:
+        """Iterate every contact in a segment across pages."""
+        return iterate_cursor(lambda params: self.list_contacts(id, params), query)

sendly/resources/usage.py

@@ -0,0 +1,27 @@
+"""Usage resource (``/api/v1``)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sendly.client import Sendly
+    from sendly.types import UsageSummary
+
+
+class UsageResource:
+    """The caller's plan and its current quota consumption."""
+
+    def __init__(self, client: Sendly) -> None:
+        self._client = client
+
+    def get(self) -> UsageSummary:
+        """Current ``plan`` plus ``monthly`` and ``daily`` usage against its limits.
+
+        Read this before a large send to see the headroom the API would enforce:
+        exceeding a quota answers 429 ``quota_exhausted``, which is a different
+        failure from 429 ``rate_limited`` (too fast, retry) and is not fixed by
+        backing off.
+        """
+        response: UsageSummary = self._client.request(method="GET", path="/api/v1/usage")
+        return response

sendly/resources/workflows.py

@@ -0,0 +1,139 @@
+"""Workflows resource (``/api/v1``)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from sendly.resources._helpers import encode_path_segment
+from sendly.resources._pagination import iterate_cursor
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from sendly.client import Sendly
+    from sendly.types import (
+        Body,
+        JSONDict,
+        Query,
+        WorkflowDeleted,
+        WorkflowExecutionList,
+        WorkflowExecutionRecord,
+        WorkflowList,
+        WorkflowRecord,
+        WorkflowStats,
+    )
+
+
+class WorkflowsResource:
+    """Event-triggered automations and their per-contact executions.
+
+    A workflow fires when its ``event_name`` arrives for a contact (see
+    :meth:`~sendly.resources.events.EventsResource.record`); ``allow_reentry``
+    decides whether a contact already running the workflow can start it again.
+    """
+
+    def __init__(self, client: Sendly) -> None:
+        self._client = client
+
+    def list(self, query: Query | None = None) -> WorkflowList:
+        """List workflows.
+
+        Accepts ``limit`` (1-100, default 20) and ``after`` (opaque cursor), and
+        answers ``{data, has_more, next_cursor}``. Keep the filters identical for
+        every page of one walk — changing them invalidates the cursor and the API
+        answers 422 ``validation_error`` telling you to restart from the first
+        page.
+        """
+        response: WorkflowList = self._client.request(
+            method="GET", path="/api/v1/workflows", query=query
+        )
+        return response
+
+    def iter_list(self, query: Query | None = None) -> Iterator[JSONDict]:
+        """Iterate every workflow across pages, following the cursor for you."""
+        return iterate_cursor(self.list, query)
+
+    def create(self, body: Body) -> WorkflowRecord:
+        """Create a workflow. Requires ``name`` and ``event_name``."""
+        response: WorkflowRecord = self._client.request(
+            method="POST", path="/api/v1/workflows", body=body
+        )
+        return response
+
+    def get(self, id: str) -> WorkflowRecord:
+        """Fetch a single workflow."""
+        response: WorkflowRecord = self._client.request(
+            method="GET", path=f"/api/v1/workflows/{encode_path_segment(id)}"
+        )
+        return response
+
+    def update(self, id: str, body: Body) -> WorkflowRecord:
+        """Patch a workflow — including ``enabled``, which is how you pause one."""
+        response: WorkflowRecord = self._client.request(
+            method="PATCH", path=f"/api/v1/workflows/{encode_path_segment(id)}", body=body
+        )
+        return response
+
+    def delete(self, id: str) -> WorkflowDeleted:
+        """Delete a workflow. Returns the ``{id, deleted}`` confirmation body."""
+        response: WorkflowDeleted = self._client.request(
+            method="DELETE", path=f"/api/v1/workflows/{encode_path_segment(id)}"
+        )
+        return response
+
+    def list_executions(self, id: str, query: Query | None = None) -> WorkflowExecutionList:
+        """List one workflow's executions.
+
+        Cursor-paginated (``limit`` / ``after``) and filterable by ``status``.
+        As with every v1 listing, a filter you change mid-walk invalidates the
+        cursor — restart from the first page instead.
+        """
+        response: WorkflowExecutionList = self._client.request(
+            method="GET",
+            path=f"/api/v1/workflows/{encode_path_segment(id)}/executions",
+            query=query,
+        )
+        return response
+
+    def iter_list_executions(self, id: str, query: Query | None = None) -> Iterator[JSONDict]:
+        """Iterate every execution of a workflow across pages."""
+        return iterate_cursor(lambda params: self.list_executions(id, params), query)
+
+    def start_execution(self, id: str, body: Body) -> WorkflowExecutionRecord:
+        """Start the workflow for one contact, bypassing its event trigger.
+
+        ``body`` is required and must carry ``contact_id`` — an execution always
+        belongs to a contact. It may also carry a ``context`` object the
+        workflow's steps can read.
+        """
+        response: WorkflowExecutionRecord = self._client.request(
+            method="POST",
+            path=f"/api/v1/workflows/{encode_path_segment(id)}/executions",
+            body=body,
+        )
+        return response
+
+    def cancel_execution(self, execution_id: str) -> WorkflowExecutionRecord:
+        """Cancel one in-flight execution.
+
+        Addressed by execution id alone — the route is
+        ``/api/v1/workflows/executions/{execution_id}/cancel``, not nested under
+        the workflow — so a caller holding an execution id needs nothing else.
+        """
+        response: WorkflowExecutionRecord = self._client.request(
+            method="POST",
+            path=f"/api/v1/workflows/executions/{encode_path_segment(execution_id)}/cancel",
+        )
+        return response
+
+    def stats(self, id: str, query: Query | None = None) -> WorkflowStats:
+        """Execution totals, completion rate, and attributed email/conversion counts.
+
+        Accepts ``from`` to bound the window.
+        """
+        response: WorkflowStats = self._client.request(
+            method="GET",
+            path=f"/api/v1/workflows/{encode_path_segment(id)}/stats",
+            query=query,
+        )
+        return response

sendly/types.py

@@ -73,6 +73,11 @@ SuppressionRecord = JSONDict
 SuppressionListResponse = JSONDict
 SuppressionCheckResponse = JSONDict
 
+# ---------- Lists ----------
+
+ListSubscribeData = JSONDict
+ListUnsubscribeData = JSONDict
+
 # ---------- Events ----------
 
 TrackEventData = JSONDict
@@ -82,3 +87,39 @@ TrackEventResponse = JSONDict
 
 VerifyEmailData = JSONDict
 VerifyEmailResponse = JSONDict
+
+# ---------- /api/v1 ----------
+#
+# The v1 surface returns bare resource bodies (no {success, data} envelope) and
+# a uniform list envelope: {data, has_more, next_cursor}. The ``*List`` aliases
+# below name that envelope; the iterator methods yield the items inside ``data``.
+
+CursorList = JSONDict
+
+CampaignRecord = JSONDict
+CampaignList = CursorList
+CampaignStats = JSONDict
+CampaignDeleted = JSONDict
+
+SegmentRecord = JSONDict
+SegmentList = CursorList
+SegmentDeleted = JSONDict
+ContactList = CursorList
+
+WorkflowRecord = JSONDict
+WorkflowList = CursorList
+WorkflowDeleted = JSONDict
+WorkflowStats = JSONDict
+WorkflowExecutionRecord = JSONDict
+WorkflowExecutionList = CursorList
+
+EventRecord = JSONDict
+EventList = CursorList
+EventNameList = JSONDict
+EventStats = JSONDict
+
+AnalyticsTimeseries = JSONDict
+CampaignAnalytics = JSONDict
+TopCampaignList = JSONDict
+
+UsageSummary = JSONDict

{sendly_python-0.1.0.dist-info → sendly_python-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sendly-python
-Version: 0.1.0
+Version: 0.2.0
 Summary: Official Sendly Python SDK
 Project-URL: Homepage, https://sendly.now
 Project-URL: Documentation, https://docs.sendly.now
@@ -62,6 +62,25 @@ pip install git+https://github.com/DevinoSolutions/sendly-python.git
 
 Requires Python 3.10+.
 
+## Already on Resend, SendGrid, Postmark, Mailgun, or Plunk?
+
+You don't even need this SDK to try Sendly. The API also speaks the
+transactional-send dialect of those providers — keep the vendor SDK you already
+run and change **two things**: the base URL and the API key.
+
+```python
+import resend  # your existing Resend integration
+
+resend.api_key = "sk_your_sendly_key"
+resend.api_url = "https://api.sendly.now/api/compat/resend"
+# resend.Emails.send(...) now sends through Sendly — same code, same shapes.
+```
+
+Every compat request runs through the same pipeline as the native API (domain
+verification, suppression, limits), and anything a dialect can express that
+Sendly doesn't support returns a clean error in that vendor's own error shape.
+Per-provider guides: [docs.sendly.now/migrate](https://docs.sendly.now/migrate).
+
 ## Quickstart
 
 The client reads your API key from the `SENDLY_API_KEY` environment variable:
@@ -207,6 +226,125 @@ sendly.suppression.get("bounce@example.com")
 sendly.suppression.remove("bounce@example.com")
 ```
 
+### Lists
+
+```python
+# Both calls accept sending-only (pk_*) keys, so they can back a public form.
+result = sendly.lists.subscribe("l_123", {"email": "user@example.com"})
+
+# On a double opt-in list the membership is PENDING and carries a confirmToken.
+# Sendly does NOT send the confirmation email — deliver this link yourself.
+if result["status"] == "PENDING":
+    confirm_url = f"https://api.sendly.now/api/lists/confirm?token={result['confirmToken']}"
+
+# Re-subscribing an address that opted out needs an explicit opt-in, or the call
+# fails with 409 RESUBSCRIBE_CONFIRMATION_REQUIRED.
+sendly.lists.subscribe("l_123", {"email": "user@example.com", "allowResubscribe": True})
+
+sendly.lists.unsubscribe("l_123", {"email": "user@example.com"})
+```
+
+## The v1 API
+
+`campaigns`, `segments`, `workflows`, `analytics` and `usage` — plus the v1
+methods on `events` — speak Sendly's `/api/v1` surface. Same client, same API
+key; two differences worth knowing:
+
+- **Responses are bare resource bodies.** There is no `{success, data}` envelope
+  to unwrap, so what the API documents is exactly what you get.
+- **Errors are RFC 9457 problem documents.** They raise the same exception
+  classes as the legacy surface, with two extra fields — see
+  [Error handling](#error-handling).
+
+### Campaigns
+
+```python
+campaign = sendly.campaigns.create(
+    {
+        "name": "August launch",
+        "subject": "We are live",
+        "body": "<p>Hello</p>",
+        "from": "team@you.com",
+        "audience_type": "ALL",
+    },
+    idempotency_key="august-launch",
+)
+
+# Send now, or schedule it. Key the replay — a duplicate send mails the audience twice.
+sendly.campaigns.send(campaign["id"], idempotency_key="august-launch-send")
+sendly.campaigns.send(campaign["id"], {"scheduled_for": "2026-09-01T10:00:00Z"})
+
+sendly.campaigns.pause(campaign["id"])
+sendly.campaigns.resume(campaign["id"])
+sendly.campaigns.cancel(campaign["id"])
+
+stats = sendly.campaigns.stats(campaign["id"])
+print(stats["delivered"], stats["open_rate"])
+```
+
+### Pagination
+
+Every v1 list answers `{data, has_more, next_cursor}` — an opaque forward-only
+cursor, and no total. Page it yourself with `limit` (1–100, default 20) and
+`after`:
+
+```python
+page = sendly.campaigns.list({"limit": 50})
+while page["has_more"]:
+    page = sendly.campaigns.list({"limit": 50, "after": page["next_cursor"]})
+```
+
+…or let the `iter_*` companion do it. It yields individual items and follows the
+cursor until the last page:
+
+```python
+for campaign in sendly.campaigns.iter_list({"limit": 100}):
+    print(campaign["name"], campaign["status"])
+
+for contact in sendly.segments.iter_list_contacts("seg_123"):
+    print(contact["email"])
+```
+
+Keep your filters identical for every page of one walk. Changing them
+mid-pagination invalidates the cursor and the API answers `422 validation_error`
+telling you to restart from the first page — which is exactly why `iter_*` holds
+the query fixed and only advances `after`.
+
+Available on the six cursor-paginated listings: `campaigns.iter_list`,
+`segments.iter_list`, `segments.iter_list_contacts`, `workflows.iter_list`,
+`workflows.iter_list_executions`, `events.iter_list`. The analytics endpoints and
+`events.list_names` / `events.stats` return a bounded aggregate rather than a
+cursor, so they have no iterator.
+
+### Segments, workflows, events, analytics, usage
+
+```python
+segment = sendly.segments.create({"name": "Power users", "type": "DYNAMIC",
+                                  "condition": {"field": "plan", "op": "eq", "value": "pro"}})
+sendly.segments.list_contacts(segment["id"], {"limit": 50})
+
+workflow = sendly.workflows.create({"name": "Welcome", "event_name": "signup.completed"})
+sendly.workflows.start_execution(workflow["id"], {"contact_id": "c_123"})
+# Executions are cancelled by execution id alone — not nested under the workflow.
+sendly.workflows.cancel_execution("exe_123")
+sendly.workflows.stats(workflow["id"], {"from": "2026-08-01"})
+
+# events.record is the v1 counterpart of the legacy events.track. Same effect,
+# v1 dialect. It takes no idempotency_key: events are append-only and the API
+# deliberately does not ledger them.
+sendly.events.record({"name": "signup.completed", "contact_id": "c_123", "data": {"plan": "pro"}})
+sendly.events.list({"event_name": "signup.completed", "limit": 20})
+sendly.events.list_names()
+sendly.events.stats({"from": "2026-08-01", "to": "2026-08-31"})
+
+sendly.analytics.timeseries({"from": "2026-08-01", "to": "2026-08-31"})
+sendly.analytics.campaigns()
+sendly.analytics.top_campaigns({"limit": 5})
+
+usage = sendly.usage.get()
+print(usage["plan"], usage["monthly"])
+```
+
 ## Error handling
 
 Every non-2xx response raises a `SendlyError` subclass carrying `status_code`,
@@ -244,6 +382,40 @@ Invalid input raises `SendlyValidationError`. Migrated routes report it as HTTP
 `err.body["error"]["details"]["errors"]`; legacy/malformed requests still use
 `400`. Both surface as `SendlyValidationError`.
 
+### v1 errors (RFC 9457)
+
+The `/api/v1` surface reports failures as `application/problem+json` documents.
+They raise the **same** exception classes, keyed off the same statuses, so
+existing `except` blocks keep working. Three things move:
+
+- `error_code` comes from the problem's `code` — a lowercase, machine-readable
+  value like `scope_missing`, `quota_exhausted`, or `idempotency_key_reused`.
+- `err.request_id` carries the correlation id. Quote it in support requests.
+- `err.field_errors` carries the per-field breakdown on a `validation_error`,
+  each entry `{pointer, code, message}` with an RFC 6901 JSON Pointer.
+
+```python
+from sendly import Sendly, SendlyValidationError, SendlyRateLimitError
+
+sendly = Sendly()
+try:
+    sendly.campaigns.create({"name": "Launch"})
+except SendlyValidationError as err:
+    print(err.error_code, err.message, err.request_id)
+    for field in err.field_errors or []:
+        print(f"  {field['pointer']}: {field['message']}")
+except SendlyRateLimitError as err:
+    # Two different failures share this class — check the code before retrying.
+    if err.error_code == "quota_exhausted":
+        print("Plan limit reached; backing off will not help")
+    else:
+        print("Too fast — retry with backoff")
+```
+
+The full problem document stays on `err.body`, so `type`, `title` and `instance`
+remain reachable. On the legacy surface `request_id` and `field_errors` are
+`None`.
+
 ## Verifying webhooks
 
 Every delivery is signed. Verify it against the **raw** request body — do not

sendly_python-0.2.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+sendly/__init__.py,sha256=AQ1Yu-7DFJ9LQz_-w6RSk_u25U-oITJGwRwJ1M9v-9s,2487
+sendly/client.py,sha256=GRII4hPJwBNPDPL9i84y3YwtPvRgT5CVXGkBgL1r7IY,11356
+sendly/errors.py,sha256=urF33X-d39OEiasLh6C7PlrrUmmrS3XIMvFYj20rUy8,7002
+sendly/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sendly/types.py,sha256=ggxBcjjkdgmJEPNk04tFdrLoTggOFZuj2kcqsvBPIXk,3140
+sendly/webhook_utils.py,sha256=epmK860gLknaElxfXdVD3h_9ASkjWQsyl1exUC8qBL4,4762
+sendly/resources/__init__.py,sha256=Nf7zjcFjsztXsGtrvxq3KGacX7SwDgSf3r0nAVHLvPY,73
+sendly/resources/_helpers.py,sha256=W6AlzXuqH53Vk1dIxuQm_-Vpq9gmZvLzKPRionjH9wQ,550
+sendly/resources/_pagination.py,sha256=dp0rNKruPBtCgPZT8ZPzmGGVpbFN2SCQdV4m9-qlLEA,1786
+sendly/resources/analytics.py,sha256=7w4A-w-dXZkgLi2j1dO6X88V-T9itlF0rWjdLiFAStc,1770
+sendly/resources/campaigns.py,sha256=vcpwNa51ncSuieGYUhwcMLpzB-cRrf6qZ1RXB0iVmo8,5293
+sendly/resources/contacts.py,sha256=7DwbGXvwUw8Tf5WfIUU0ZEvJs3ZBIqulkbN_Ke0-ilc,3274
+sendly/resources/domains.py,sha256=m69uHKGhmtVlzo3QAmMmMHvmpc0T3JAv5izTWxDpxhc,2368
+sendly/resources/emails.py,sha256=3LHxre7lJfa_6z1F9Rzmdh5QDwhYpwTWaAJZGVCLsY8,2390
+sendly/resources/events.py,sha256=8aFUPa1iTVqEUnhwnpcsfE7_JyirtBw7POgadk4hhMs,3926
+sendly/resources/lists.py,sha256=KXHOW_UQMEdXoat9mHJ4mJKmvrzk0AVQ3k8273GRIH4,2189
+sendly/resources/segments.py,sha256=dc4KzorLRSfkZe63J144wm6W5bjVaDA4U8ID7HyyK_U,3944
+sendly/resources/suppression.py,sha256=NNIhmkq1bC2qe1i4nSGZDCvuGBT7JddIrkXlVP1qASU,1716
+sendly/resources/templates.py,sha256=DhewoFRqxGfjo0brAtG9rI6GHTCWNv4J01TylB4luXI,2104
+sendly/resources/usage.py,sha256=kMcoAeGAnCilLyNihKBFcfFf-CVoSlpKUmTtlfDWAMA,879
+sendly/resources/verify.py,sha256=QyVNmrzZ4Nj87YWxMPt9wlovcCyZutV9eGmn49c0EEg,818
+sendly/resources/webhooks.py,sha256=rooES4-HMy7mhC9D1bzVDUpJ34cf1yZkVilkoWEIBEQ,2763
+sendly/resources/workflows.py,sha256=42j-227rFUkWjA6DYmKYxqc6Bfdpxy5IHDuDgZrUO5k,5381
+sendly_python-0.2.0.dist-info/METADATA,sha256=qP01SKUw9EeFuqAMVvnnyPTMLrgs-nwZZJlU9lbAn2w,16456
+sendly_python-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sendly_python-0.2.0.dist-info/licenses/LICENSE,sha256=TZHT_f_vV-xujWjSy7EkTybNT6iivrfGHLd-rR1Xl7c,1073
+sendly_python-0.2.0.dist-info/RECORD,,

sendly_python-0.1.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-sendly/__init__.py,sha256=EK_NplzmfmE_d_CcW7epJdKbZLVFn5zK3culailQLkA,1764
-sendly/client.py,sha256=fiiRtDeV3Wt1nLA2ERsK-rlSNg9XBzj4wNgiUA-kYY0,9467
-sendly/errors.py,sha256=7nlE2ixqRXS21zYe5qwb-rTUyv1Wx3yI9uThsf4sJoQ,3394
-sendly/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sendly/types.py,sha256=YiHQaggce5KIEr5cZMg0Ks923mDX9kNUrpWLujvf00k,2159
-sendly/webhook_utils.py,sha256=epmK860gLknaElxfXdVD3h_9ASkjWQsyl1exUC8qBL4,4762
-sendly/resources/__init__.py,sha256=Nf7zjcFjsztXsGtrvxq3KGacX7SwDgSf3r0nAVHLvPY,73
-sendly/resources/_helpers.py,sha256=W6AlzXuqH53Vk1dIxuQm_-Vpq9gmZvLzKPRionjH9wQ,550
-sendly/resources/contacts.py,sha256=7DwbGXvwUw8Tf5WfIUU0ZEvJs3ZBIqulkbN_Ke0-ilc,3274
-sendly/resources/domains.py,sha256=m69uHKGhmtVlzo3QAmMmMHvmpc0T3JAv5izTWxDpxhc,2368
-sendly/resources/emails.py,sha256=3LHxre7lJfa_6z1F9Rzmdh5QDwhYpwTWaAJZGVCLsY8,2390
-sendly/resources/events.py,sha256=hEy1HCRWfPS_Mc7xxWZtgqj9R8iYsgPRR1YdZuGuP1c,785
-sendly/resources/suppression.py,sha256=NNIhmkq1bC2qe1i4nSGZDCvuGBT7JddIrkXlVP1qASU,1716
-sendly/resources/templates.py,sha256=DhewoFRqxGfjo0brAtG9rI6GHTCWNv4J01TylB4luXI,2104
-sendly/resources/verify.py,sha256=QyVNmrzZ4Nj87YWxMPt9wlovcCyZutV9eGmn49c0EEg,818
-sendly/resources/webhooks.py,sha256=rooES4-HMy7mhC9D1bzVDUpJ34cf1yZkVilkoWEIBEQ,2763
-sendly_python-0.1.0.dist-info/METADATA,sha256=_CFNo8me4v-Duk1M_PWpiiq_FKQNcfd3ASOh4jSN-IM,9560
-sendly_python-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-sendly_python-0.1.0.dist-info/licenses/LICENSE,sha256=TZHT_f_vV-xujWjSy7EkTybNT6iivrfGHLd-rR1Xl7c,1073
-sendly_python-0.1.0.dist-info/RECORD,,