sendly-python 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

sendly/__init__.py

@@ -50,6 +50,7 @@ from sendly.resources.validation import ValidationResource
 from sendly.resources.verify import VerifyResource
 from sendly.resources.webhooks import WebhooksResource
 from sendly.resources.workflows import WorkflowsResource
+from sendly.types import SendlyFile
 from sendly.webhook_utils import DEFAULT_TOLERANCE_MS, construct_event, verify_signature
 
 __version__ = SDK_VERSION
@@ -74,6 +75,7 @@ __all__ = [
     "SendlyConflictError",
     "SendlyConnectionError",
     "SendlyError",
+    "SendlyFile",
     "SendlyNotFoundError",
     "SendlyPermissionError",
     "SendlyRateLimitError",

sendly/client.py

@@ -53,6 +53,7 @@ from sendly.resources.validation import ValidationResource
 from sendly.resources.verify import VerifyResource
 from sendly.resources.webhooks import WebhooksResource
 from sendly.resources.workflows import WorkflowsResource
+from sendly.types import SendlyFile
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -63,7 +64,7 @@ if TYPE_CHECKING:
 __all__ = ["DEFAULT_BASE_URL", "SDK_VERSION", "Sendly"]
 
 #: Package version. Kept in sync with ``pyproject.toml``.
-SDK_VERSION = "1.1.0"
+SDK_VERSION = "1.3.0"
 
 #: Default production API base. Override via ``base_url`` for staging/self-hosted.
 DEFAULT_BASE_URL = "https://api.sendly.now"
@@ -174,30 +175,7 @@ class Sendly:
         success body, or ``None`` for 204 / ``no_content``. Errors are raised as
         :class:`SendlyError` subclasses based on status.
         """
-        url = self._build_url(path, query)
-        request_headers: dict[str, str] = {
-            "Authorization": f"Bearer {self._api_key}",
-            "Accept": "application/json",
-            "User-Agent": USER_AGENT,
-            **self._default_headers,
-            **(dict(headers) if headers else {}),
-        }
-
-        content: str | None = None
-        if body is not None:
-            request_headers["Content-Type"] = "application/json"
-            content = json.dumps(body)
-
-        try:
-            response = self._client.request(
-                method,
-                url,
-                content=content,
-                headers=request_headers,
-                timeout=self._timeout,
-            )
-        except httpx.HTTPError as exc:
-            raise SendlyConnectionError(f"Sendly request failed: {exc}", exc) from exc
+        response = self._send(method=method, path=path, body=body, query=query, headers=headers)
 
         # 204 No Content or caller-forced no-content (DELETE endpoints, which
         # now respond 200 with an id body the SDK intentionally discards).
@@ -229,6 +207,67 @@ class Sendly:
 
         return parsed
 
+    def request_bytes(
+        self,
+        *,
+        method: str,
+        path: str,
+        query: Query | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> SendlyFile:
+        """Like :meth:`request`, for an operation whose success body is a file.
+
+        Returns the raw bytes with the response's own ``Content-Type`` and
+        ``Content-Disposition``. A failure is still a JSON error document and is
+        raised as the same :class:`SendlyError` subclasses. Reading the body as
+        text, as :meth:`request` does, would mangle any file that is not UTF-8.
+        """
+        response = self._send(
+            method=method, path=path, query=query, headers={"Accept": "*/*", **(headers or {})}
+        )
+        if not response.is_success:
+            self._raise_for_error(response)
+        return SendlyFile(
+            data=response.content,
+            content_type=response.headers.get("content-type"),
+            content_disposition=response.headers.get("content-disposition"),
+        )
+
+    def _send(
+        self,
+        *,
+        method: str,
+        path: str,
+        body: Body | None = None,
+        query: Query | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> httpx.Response:
+        """Issue the request; errors and parsing are the caller's."""
+        url = self._build_url(path, query)
+        request_headers: dict[str, str] = {
+            "Authorization": f"Bearer {self._api_key}",
+            "Accept": "application/json",
+            "User-Agent": USER_AGENT,
+            **self._default_headers,
+            **(dict(headers) if headers else {}),
+        }
+
+        content: str | None = None
+        if body is not None:
+            request_headers["Content-Type"] = "application/json"
+            content = json.dumps(body)
+
+        try:
+            return self._client.request(
+                method,
+                url,
+                content=content,
+                headers=request_headers,
+                timeout=self._timeout,
+            )
+        except httpx.HTTPError as exc:
+            raise SendlyConnectionError(f"Sendly request failed: {exc}", exc) from exc
+
     def unwrap(self, envelope: Any) -> Any:
         """Return the ``data`` field of a ``{success, data}`` envelope, else the
         value unchanged. Centralizing this keeps resource code clean.

sendly/resources/domains.py

@@ -16,6 +16,8 @@ if TYPE_CHECKING:
         DomainDeletedV1,
         DomainListResponse,
         DomainListV1,
+        DomainLogoReadinessV1,
+        DomainLogoV1,
         DomainRecord,
         DomainSetupSession,
         DomainV1,
@@ -208,3 +210,59 @@ class DomainsResource:
             method="DELETE", path=f"/api/v1/domains/{encode_path_segment(id)}"
         )
         return response
+
+    def get_logo_v1(self, id: str) -> DomainLogoV1:
+        """The logo this identity serves to inboxes (BIMI), the
+        ``default._bimi`` TXT record that makes them fetch it (``bimi_record``),
+        and a fresh DNS reading of whether they will show it today.
+
+        The URL never changes, so the record is published once. Until a logo is
+        uploaded it serves a default (the domain's initial), and it serves
+        nothing until the identity verifies. Providers decide whether to show a
+        logo; Gmail also needs a VMC or CMC certificate, which Sendly neither
+        issues nor checks. :meth:`get_logo_readiness_v1` is the full checklist.
+        """
+        response: DomainLogoV1 = self._client.request(
+            method="GET", path=f"/api/v1/domains/{encode_path_segment(id)}/logo"
+        )
+        return response
+
+    def upload_logo_v1(self, id: str, body: Body) -> DomainLogoV1:
+        """Replace the logo with an SVG: ``{"svg": "<svg ...>"}``.
+
+        It is rebuilt into SVG Tiny PS, the profile BIMI requires: square, shapes
+        rather than ``<text>``, nothing referenced outside itself, at most 32 KB
+        once rebuilt. A file that cannot be rebuilt answers 422
+        ``validation_error`` with a ``detail`` naming what to change, and the
+        previous logo stays in place.
+        """
+        response: DomainLogoV1 = self._client.request(
+            method="PUT", path=f"/api/v1/domains/{encode_path_segment(id)}/logo", body=body
+        )
+        return response
+
+    def delete_logo_v1(self, id: str) -> DomainLogoV1:
+        """Remove the uploaded logo, so the URL serves the default again.
+
+        Returns the logo now served; removing one that was never uploaded is not
+        an error. The DNS record does not change.
+        """
+        response: DomainLogoV1 = self._client.request(
+            method="DELETE", path=f"/api/v1/domains/{encode_path_segment(id)}/logo"
+        )
+        return response
+
+    def get_logo_readiness_v1(self, id: str) -> DomainLogoReadinessV1:
+        """How ready the identity is to show its logo as the inbox avatar.
+
+        Each step (DMARC at enforcement on the host and its organizational
+        domain, the BIMI record, the logo file, the mark certificate) comes back
+        ``met``, ``missing``, ``unknown`` or ``not_applicable`` with a
+        plain-English ``reason``, plus one checklist per inbox (Gmail, Yahoo,
+        Apple Mail, Fastmail). For the certificate only "the URL answers with a
+        PEM file" is checked; its chain is not validated.
+        """
+        response: DomainLogoReadinessV1 = self._client.request(
+            method="GET", path=f"/api/v1/domains/{encode_path_segment(id)}/logo/readiness"
+        )
+        return response

sendly/resources/mailboxes.py

@@ -7,8 +7,21 @@ from typing import TYPE_CHECKING
 from sendly.resources._helpers import encode_path_segment
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
+
     from sendly.client import Sendly
-    from sendly.types import AppPasswordList, Body, JSONDict, MailboxDetail, MailboxList
+    from sendly.types import (
+        AppPasswordList,
+        Body,
+        JSONDict,
+        MailboxConversation,
+        MailboxConversationPage,
+        MailboxDetail,
+        MailboxList,
+        MailboxMessageList,
+        Query,
+        SendlyFile,
+    )
 
 
 class MailboxesResource:
@@ -42,8 +55,8 @@ class MailboxesResource:
         project's whole allowance, and they are still returned here: a project
         with a run of failed provisions can therefore list more than 10.
 
-        This lists the mailboxes themselves, never their contents: received
-        messages are not part of the public API.
+        This lists the mailboxes themselves, never their contents: the mail is
+        :meth:`list_conversations`, under a scope of its own.
         """
         envelope = self._client.request(method="GET", path="/api/mailboxes")
         records: MailboxList = self._client.unwrap(envelope)
@@ -131,3 +144,103 @@ class MailboxesResource:
         )
         draft: JSONDict = self._client.unwrap(envelope)
         return draft
+
+    # The mail itself. The methods below read and answer correspondence from
+    # people outside your project, so they need ``mailbox-conversations:read``
+    # (and ``mailbox-conversations:reply`` to answer). Both scopes are opt-in
+    # only: a key holds one only if it was ticked by name when it was created,
+    # and neither the legacy full-access key nor the "Full access" preset has
+    # it. An existing key gets 403 until you mint one that does.
+
+    def list_conversations(self, id: str, query: Query | None = None) -> MailboxConversationPage:
+        """One page of a mailbox's threads, newest activity first.
+
+        ``query`` takes ``view`` (``inbox``, the default, or ``spam``),
+        ``status`` (``open``, ``snoozed``, ``closed`` or ``all``), ``q`` (a
+        substring of the subject or the correspondent's address), ``cursor``
+        and ``limit`` (at most 50). Returns ``{items, nextCursor}``: pass
+        ``nextCursor`` back as ``cursor`` until it is ``None``, or use
+        :meth:`iter_list_conversations`. A mailbox in another project answers 404.
+        """
+        envelope = self._client.request(
+            method="GET",
+            path=f"/api/mailboxes/{encode_path_segment(id)}/conversations",
+            query=query,
+        )
+        page: MailboxConversationPage = self._client.unwrap(envelope)
+        return page
+
+    def iter_list_conversations(
+        self, id: str, query: Query | None = None
+    ) -> Iterator[MailboxConversation]:
+        """Every thread in a mailbox across pages, one conversation at a time.
+
+        Stops when ``nextCursor`` is ``None`` or repeats the cursor it was given,
+        so a stuck page ends the walk instead of looping.
+        """
+        params = dict(query or {})
+        while True:
+            page = self.list_conversations(id, params)
+            yield from page.get("items") or []
+            cursor = page.get("nextCursor")
+            if not cursor or cursor == params.get("cursor"):
+                return
+            params["cursor"] = cursor
+
+    def get_conversation(self, id: str, conversation_id: str) -> MailboxMessageList:
+        """Every message in one thread, oldest first, inbound and outbound.
+
+        Not paginated, and reading marks nothing as read. Bodies were written by
+        whoever sent them: treat ``htmlBody`` as hostile HTML. A conversation
+        that is not in this mailbox returns an empty list; a mailbox outside the
+        key's project answers 404.
+        """
+        envelope = self._client.request(
+            method="GET",
+            path=(
+                f"/api/mailboxes/{encode_path_segment(id)}"
+                f"/conversations/{encode_path_segment(conversation_id)}"
+            ),
+        )
+        messages: MailboxMessageList = self._client.unwrap(envelope)
+        return messages
+
+    def reply_to_conversation(self, id: str, conversation_id: str, body: Body) -> JSONDict:
+        """SENDS a reply, from the mailbox's own address, in the same thread,
+        to the person who last wrote in.
+
+        You name neither the recipient nor the sender: this only ever answers
+        someone who wrote first, which is why it has its own scope and is not
+        :meth:`send_message`. Pass plain text in ``body`` or a structured
+        ``document``; Sendly renders the HTML and a matching text part.
+
+        Refusals worth handling by name: 422 ``UNPROCESSABLE`` (no inbound
+        message to answer, or the mailbox is not provisioned), 422
+        ``SEND_REFUSED`` (the recipient is suppressed or the project may not
+        send), 429 ``SENDING_LIMIT_REACHED``.
+        """
+        envelope = self._client.request(
+            method="POST",
+            path=(
+                f"/api/mailboxes/{encode_path_segment(id)}"
+                f"/conversations/{encode_path_segment(conversation_id)}/reply"
+            ),
+            body=body,
+        )
+        submitted: JSONDict = self._client.unwrap(envelope)
+        return submitted
+
+    def download_attachment(self, id: str, attachment_id: str) -> SendlyFile:
+        """The bytes of one attachment, the ``url`` a message lists.
+
+        The file and its ``content_type`` were chosen by the sender: treat both
+        as untrusted, and never serve the bytes back to a browser under your own
+        origin without a fixed type.
+        """
+        return self._client.request_bytes(
+            method="GET",
+            path=(
+                f"/api/mailboxes/{encode_path_segment(id)}"
+                f"/attachments/{encode_path_segment(attachment_id)}"
+            ),
+        )

sendly/types.py

@@ -15,6 +15,7 @@ same across both SDKs.
 from __future__ import annotations
 
 from collections.abc import Mapping
+from dataclasses import dataclass
 from typing import Any
 
 # ---------- Generic JSON ----------
@@ -38,12 +39,16 @@ Pagination = JSONDict
 SendEmailData = JSONDict
 SendEmailResponse = JSONDict
 BatchSendResponse = JSONDict
+#: An email row. Beyond the delivery fields it carries, ``str | None`` and ``None``
+#: until the event happens, ``bounceType``, ``bounceSubType``, ``bounceStatusCode``,
+#: ``bounceDiagnosticCode`` and ``complaintFeedbackType``.
 EmailRecord = JSONDict
 EmailListResponse = JSONDict
 
 #: One transition in a message's delivery history -- the append-only record
 #: behind ``status``. ``status`` says where the message is now; these say how it
-#: got there.
+#: got there. A bounce transition also carries ``bounceType``, ``bounceSubType``,
+#: ``bounceStatusCode`` and ``bounceDiagnosticCode`` (each ``str | None``).
 EmailEvent = JSONDict
 #: An email together with its delivery history, oldest first.
 EmailWithEvents = JSONDict
@@ -84,6 +89,26 @@ AppPasswordRecord = JSONDict
 #: types here sidesteps the shadowing and keeps the annotations readable.
 MailboxList = list[JSONDict]
 AppPasswordList = list[JSONDict]
+#: One page of a mailbox's threads: ``{items, nextCursor}``.
+MailboxConversationPage = JSONDict
+#: One thread in a mailbox: correspondent, subject, status, last activity.
+MailboxConversation = JSONDict
+#: A thread's messages, oldest first. Bodies are the sender's and untrusted.
+MailboxMessageList = list[JSONDict]
+
+
+@dataclass(frozen=True)
+class SendlyFile:
+    """A file the API answered with, as :meth:`Sendly.request_bytes` returns it."""
+
+    #: The body, byte for byte.
+    data: bytes
+    #: As the server declared it. For a mailbox attachment that is the SENDER's
+    #: claim: do not trust it.
+    content_type: str | None
+    #: ``attachment; filename="..."`` or ``inline; ...``, verbatim.
+    content_disposition: str | None
+
 
 # ---------- Projects (v1) ----------
 
@@ -193,6 +218,10 @@ TemplateDeletedV1 = JSONDict
 DomainV1 = JSONDict
 DomainListV1 = CursorList
 DomainDeletedV1 = JSONDict
+#: The logo an identity serves to inboxes, its BIMI record, and a DNS readiness reading.
+DomainLogoV1 = JSONDict
+#: The per-step, per-inbox checklist for showing the logo as the inbox avatar.
+DomainLogoReadinessV1 = JSONDict
 
 # ---------- Webhooks (v1) ----------
 

{sendly_python-1.1.0.dist-info → sendly_python-1.3.0.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: sendly-python
-Version: 1.1.0
-Summary: Official Sendly Python SDK
+Version: 1.3.0
+Summary: Official Python SDK for Sendly (sendly.now), the email API and platform for developers by Devino Solutions: transactional email, contacts, templates and webhooks.
 Project-URL: Homepage, https://sendly.now
 Project-URL: Documentation, https://docs.sendly.now
 Project-URL: Repository, https://github.com/DevinoSolutions/sendly-python
 Author-email: Devino Solutions <dev@devino.ca>
 License: MIT
 License-File: LICENSE
-Keywords: api,email,sdk,sendly,transactional-email,webhooks
+Keywords: api,email,email-api,sdk,sendly,sendly.now,transactional-email,webhooks
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -32,6 +32,18 @@ Description-Content-Type: text/markdown
 
 # Sendly Python SDK
 
+**Sendly is an email platform for developers: one REST API for transactional email, marketing
+campaigns and visual automation workflows, built on AWS SES, with contacts, segments, templates,
+webhooks and an event stream behind the same account.** It offers a free tier and metered
+pay-as-you-go sending. Sendly is made by Devino Solutions.
+
+What Sendly is not: not a multi-channel messaging suite (email is the only channel; no SMS, push or
+in-app messages), not a marketing suite (no landing pages, forms, ads or CRM), and not related to
+other products or companies that use the word "Sendly". The PyPI package `sendly` is not ours;
+this SDK is published as `sendly-python`.
+
+Canonical site: https://sendly.now · Docs: https://docs.sendly.now · API: https://api.sendly.now
+
 Official Python SDK for the [Sendly](https://sendly.now) REST API —
 transactional email, contacts, lists, topics, events, domains, templates,
 snippets, email verification, address validation, deliverability reporting,
@@ -265,6 +277,13 @@ receipt = sendly.emails.send({"from": "a@you.com", "to": "b@them.com", "subject"
 sendly.emails.send_legacy({"from": "a@you.com", "to": ["b@them.com", "c@them.com"],
                            "subject": "Hi", "body": "<p>Hi</p>"})
 
+# Your own one-click unsubscribe (https only). Sendly writes the RFC 8058
+# List-Unsubscribe headers, so the mail client shows its unsubscribe button; the
+# endpoint gets a cookie-less POST and must unsubscribe the reader on it alone.
+sendly.emails.send({"from": "notify@you.com", "to": "b@them.com", "subject": "New reply",
+                    "body": "<p>Someone replied.</p>",
+                    "listUnsubscribe": "https://you.com/unsubscribe?token=abc123"})
+
 # Batch send (up to 100)
 sendly.emails.batch({"emails": [{"from": "a@you.com", "to": "b@them.com", "subject": "Hi", "body": "<p>Hi</p>"}]})
 
@@ -292,6 +311,26 @@ for event in email["events"]:
 somebody opened, read `openedAt` / `opens` on the rows — engagement is not a
 status.
 
+A bounced or complained message says why. Each key below is `str | None` and is
+`None` until the event happens (or when the receiving server did not say):
+
+```python
+email = sendly.emails.get("em_123")["data"]
+if email["status"] == "BOUNCED":
+    # `bounceType` is "Permanent" or "Undetermined" here (a "Transient" bounce is
+    # retried and never sets BOUNCED); the rest are the receiving server's own words.
+    # Show them to a person, do not parse them.
+    print(email["bounceType"], email["bounceSubType"],
+          email["bounceStatusCode"], email["bounceDiagnosticCode"])
+if email["complainedAt"] is not None:
+    print(email["complaintFeedbackType"])  # e.g. "abuse"
+```
+
+Each entry of `email["events"]` carries the same four `bounce*` keys for the
+transition that recorded them. The `email.bounced` webhook body adds
+`bounceSubType`, `bounceStatusCode` and `bounceDiagnosticCode`, and
+`email.complained` adds `complaintFeedbackType`.
+
 ### Contacts
 
 ```python
@@ -464,6 +503,28 @@ neither is a spelling of the other. `verify_v1` verifies nothing itself:
 verification happens in the domain's DNS when its owner publishes the DKIM
 records SES minted at creation, and this call asks SES what it currently sees.
 
+#### The sender logo (BIMI)
+
+Each identity serves a logo that BIMI-capable inboxes show beside its mail, once
+its DNS is ready:
+
+```python
+logo = sendly.domains.get_logo_v1("d_123")
+print(logo["bimi_record"])  # publish this TXT record once; the URL never changes
+
+sendly.domains.upload_logo_v1("d_123", {"svg": svg_source})  # square, shapes not <text>
+for item in sendly.domains.get_logo_readiness_v1("d_123")["items"]:
+    print(item["key"], item["status"], item["reason"])
+```
+
+The upload is rebuilt into SVG Tiny PS, the profile BIMI requires. A file that
+cannot be rebuilt (text not converted to outlines, a raster image, a canvas that
+is not square, over 32 KB once cleaned) is a 422 `validation_error` naming what to
+change, and the previous logo stays. `delete_logo_v1` goes back to the default
+(the domain's initial). Providers still decide whether to show a logo, and Gmail
+and Apple Mail need a VMC or CMC certificate, which Sendly neither issues nor
+validates.
+
 ### Mailboxes
 
 Receiving mailboxes on the project's verified domains. The reads are reads; the
@@ -484,8 +545,8 @@ for pw in sendly.mailboxes.list_app_passwords("mb_123"):
     print(pw["name"], pw["lastFour"], pw["lastUsedAt"])
 ```
 
-This lists the mailboxes themselves, never their contents — received messages
-are not part of the public API. The mailbox **password** is never returned by
+`list` and `get` describe the mailboxes themselves, never their contents (the
+mail is below, under a scope of its own). The mailbox **password** is never returned by
 any of these reads; mailbox credentials are app passwords, created from the
 dashboard and shown once. `list_app_passwords` returns only the passwords that
 are still active — a revoked one drops out, so this is not an audit history.
@@ -541,6 +602,29 @@ treated strictly as data describing what to write, never as instructions to the
 model. Capped at 120 requests an hour per project; 502 means the model was
 unreachable.
 
+#### The mail itself: read, reply, download
+
+These read correspondence from people outside your project, so they need
+`mailbox-conversations:read`, and answering needs `mailbox-conversations:reply`.
+Both scopes are **opt-in only**: a key holds one only if it was ticked by name
+when the key was created, and neither the legacy full-access key nor the "Full
+access" preset carries it. An existing key gets 403 until you mint one that does.
+
+```python
+for thread in sendly.mailboxes.iter_list_conversations("mb_123", {"status": "open"}):
+    messages = sendly.mailboxes.get_conversation("mb_123", thread["id"])  # oldest first
+
+sendly.mailboxes.reply_to_conversation("mb_123", thread_id, {"body": "Sorted, thanks."})
+
+file = sendly.mailboxes.download_attachment("mb_123", attachment_id)
+# file.data is bytes; file.content_type is the SENDER's claim.
+```
+
+A reply names neither the recipient nor the sender: it answers whoever last wrote
+in, from the mailbox's own address, in the same thread. Message bodies and
+attachments were written by the sender, so treat `htmlBody`, the bytes and their
+content type as untrusted. Reading marks nothing as read.
+
 ### Templates and snippets
 
 ```python

{sendly_python-1.1.0.dist-info → sendly_python-1.3.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-sendly/__init__.py,sha256=64KKJ8Iha5nWhKFjV82adsgYD-kN-w7dsKkPV5DB-eM,3089
-sendly/client.py,sha256=nEnHn0WVAqvXp0U4G6baUnA1x6ujE4M8JQMhU5bi2kw,12077
+sendly/__init__.py,sha256=KNGjrzKPY88Qo8J4LCWxa4Ae0Dwk1JIREQ9IFF2R8bY,3143
+sendly/client.py,sha256=TqB84R4C3pXBinW3kg3WozKNucIGVS9t1xotgrdav9Q,13536
 sendly/errors.py,sha256=urF33X-d39OEiasLh6C7PlrrUmmrS3XIMvFYj20rUy8,7002
 sendly/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sendly/types.py,sha256=ug4nOQcQtCDcNkuUmlDtft586d1gsLUR242T8mioXLI,6629
+sendly/types.py,sha256=2cbZqteyutTuIxllK9Sq79_D6XjObzRSHRenRuCZ3hw,7997
 sendly/webhook_utils.py,sha256=epmK860gLknaElxfXdVD3h_9ASkjWQsyl1exUC8qBL4,4762
 sendly/resources/__init__.py,sha256=Nf7zjcFjsztXsGtrvxq3KGacX7SwDgSf3r0nAVHLvPY,73
 sendly/resources/_helpers.py,sha256=W6AlzXuqH53Vk1dIxuQm_-Vpq9gmZvLzKPRionjH9wQ,550
@@ -11,11 +11,11 @@ sendly/resources/analytics.py,sha256=7w4A-w-dXZkgLi2j1dO6X88V-T9itlF0rWjdLiFAStc
 sendly/resources/campaigns.py,sha256=r9XQcw9z1aCAkQic56vajh-Rscbc8jA0YjV4kIBalW4,7382
 sendly/resources/contacts.py,sha256=JTmj5jAu46i6suz16U3cubr1P4sM0lkpHo8AcK5JDcM,7624
 sendly/resources/deliverability.py,sha256=e69_THrIZMN7BP6i8IvTcSbeX7t3FoFZwhj3BpgW-ZE,4877
-sendly/resources/domains.py,sha256=oTLXLG6yY5GeNltuEOR0qZVMUl1YYd8Nmzt-xeO33As,9140
+sendly/resources/domains.py,sha256=ZRH0KmtaELJkbNTg-P-T5lJAHAgxbQe1LiMd9pqxfZM,11946
 sendly/resources/emails.py,sha256=ukaXSBRV3kDXism4ndfIYIluoubChH4VdH65q0A9hvI,5227
 sendly/resources/events.py,sha256=hvJpX7Q2HmUkO1mxnzFBYhoP5NfWDz2TUb2OJ1bCaQ8,4071
 sendly/resources/lists.py,sha256=rwBLIk9Q5w_TPlDtCZ4a8yne1JQnZ0U4qa1mMq-1tGs,6044
-sendly/resources/mailboxes.py,sha256=Jnr5g3gmyFUm9TJnX3lbyDL1wyOofqJHl3Q46ilRn2c,6095
+sendly/resources/mailboxes.py,sha256=QZmwd1sADTLjoPgvb8t4t4sQeoYjGPo5aE0Tnv80Wj4,10903
 sendly/resources/projects.py,sha256=g694LMqh7cI2qCD1nZ6QQEfOvT42A8EBltbEJawc2P8,1096
 sendly/resources/segments.py,sha256=dc4KzorLRSfkZe63J144wm6W5bjVaDA4U8ID7HyyK_U,3944
 sendly/resources/snippets.py,sha256=BjuMWSprTAtzF6nrqd04iC9lRc68Lf3kKMZWeNrUyMA,2645
@@ -27,7 +27,7 @@ sendly/resources/validation.py,sha256=sS0gAs5Kph-QK73YZ7dkZCUP2ZPiDtyO1DLlQuZAle
 sendly/resources/verify.py,sha256=QyVNmrzZ4Nj87YWxMPt9wlovcCyZutV9eGmn49c0EEg,818
 sendly/resources/webhooks.py,sha256=w0ZwueAGKTP6Du3b6jMr24C9nv_a_vnDExYYy3N1pfA,8036
 sendly/resources/workflows.py,sha256=wZUpL57lrKmgcdjNaLS89lyEG2D1Ov2EKfXSlcQFn74,9768
-sendly_python-1.1.0.dist-info/METADATA,sha256=Yfup-6i5MQfru2u4CA6E6MxTJ_U09vXWIKeRSGO_9z4,56285
-sendly_python-1.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-sendly_python-1.1.0.dist-info/licenses/LICENSE,sha256=TZHT_f_vV-xujWjSy7EkTybNT6iivrfGHLd-rR1Xl7c,1073
-sendly_python-1.1.0.dist-info/RECORD,,
+sendly_python-1.3.0.dist-info/METADATA,sha256=lgummrFC5rHDlamNCa0jscQR9JokeLdnNifo9tQj4lg,60764
+sendly_python-1.3.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sendly_python-1.3.0.dist-info/licenses/LICENSE,sha256=TZHT_f_vV-xujWjSy7EkTybNT6iivrfGHLd-rR1Xl7c,1073
+sendly_python-1.3.0.dist-info/RECORD,,