sentroy-client-sdk 1.1.5__py3-none-any.whl

sentroy/__init__.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import urllib.parse
+
+from sentroy._http import SentroyError, _HttpClient
+from sentroy.domains import DomainsResource
+from sentroy.inbox import InboxResource
+from sentroy.mailboxes import MailboxesResource
+from sentroy.send import SendResource
+from sentroy.templates import TemplatesResource
+from sentroy.types import (
+    Attachment,
+    AttachmentInfo,
+    Domain,
+    InboxListParams,
+    LocalizedString,
+    Mailbox,
+    MailboxUser,
+    MessageAddress,
+    MessageDetail,
+    MessageSummary,
+    SendParams,
+    SendResult,
+    Template,
+)
+
+
+class Sentroy:
+    """Sentroy platform client.
+
+    Example::
+
+        sentroy = Sentroy(
+            base_url="https://sentroy.com",
+            company_slug="my-company",
+            access_token="stk_abc123...",
+        )
+
+        domains = sentroy.domains.list()
+    """
+
+    domains: DomainsResource
+    mailboxes: MailboxesResource
+    templates: TemplatesResource
+    inbox: InboxResource
+    send: SendResource
+
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        company_slug: str,
+        access_token: str,
+        timeout: int = 30,
+    ) -> None:
+        base = base_url.rstrip("/")
+        api_base = f"{base}/api/companies/{urllib.parse.quote(company_slug, safe='')}"
+        http = _HttpClient(api_base, access_token, timeout)
+
+        self.domains = DomainsResource(http)
+        self.mailboxes = MailboxesResource(http)
+        self.templates = TemplatesResource(http)
+        self.inbox = InboxResource(http)
+        self.send = SendResource(http)
+
+
+__all__ = [
+    "Sentroy",
+    "SentroyError",
+    "Attachment",
+    "AttachmentInfo",
+    "Domain",
+    "InboxListParams",
+    "LocalizedString",
+    "Mailbox",
+    "MailboxUser",
+    "MessageAddress",
+    "MessageDetail",
+    "MessageSummary",
+    "SendParams",
+    "SendResult",
+    "Template",
+]

sentroy/_http.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+import urllib.request
+import urllib.parse
+import urllib.error
+from typing import Any, Optional
+
+
+class SentroyError(Exception):
+    """Raised when the Sentroy API returns an error response."""
+
+    def __init__(
+        self,
+        status_code: int,
+        body: Any,
+        message: Optional[str] = None,
+    ) -> None:
+        self.status_code = status_code
+        self.body = body
+        super().__init__(message or f"Sentroy API error ({status_code})")
+
+
+class _HttpClient:
+    """Low-level HTTP client that wraps urllib.request for Sentroy API calls."""
+
+    def __init__(self, base_url: str, token: str, timeout: int = 30) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._token = token
+        self._timeout = timeout
+
+    def _build_url(
+        self,
+        path: str,
+        query: Optional[dict[str, Any]] = None,
+    ) -> str:
+        url = f"{self._base_url}{path}"
+        if query:
+            filtered = {
+                k: str(v) for k, v in query.items() if v is not None
+            }
+            if filtered:
+                url = f"{url}?{urllib.parse.urlencode(filtered)}"
+        return url
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        query: Optional[dict[str, Any]] = None,
+        body: Optional[Any] = None,
+    ) -> Any:
+        url = self._build_url(path, query)
+
+        headers: dict[str, str] = {
+            "Authorization": f"Bearer {self._token}",
+        }
+
+        data: Optional[bytes] = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode("utf-8")
+
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers=headers,
+            method=method,
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
+                raw = resp.read().decode("utf-8")
+                envelope = json.loads(raw) if raw else {}
+                return envelope.get("data")
+        except urllib.error.HTTPError as exc:
+            raw_body = exc.read().decode("utf-8") if exc.fp else ""
+            try:
+                envelope = json.loads(raw_body)
+            except (json.JSONDecodeError, ValueError):
+                envelope = {"error": raw_body}
+            message = envelope.get("error") or f"Request failed with status {exc.code}"
+            raise SentroyError(exc.code, envelope, message) from exc
+
+    def get(self, path: str, query: Optional[dict[str, Any]] = None) -> Any:
+        return self._request("GET", path, query=query)
+
+    def post(self, path: str, body: Optional[Any] = None) -> Any:
+        return self._request("POST", path, body=body)
+
+    def put(self, path: str, body: Optional[Any] = None) -> Any:
+        return self._request("PUT", path, body=body)
+
+    def delete(self, path: str, query: Optional[dict[str, Any]] = None) -> Any:
+        return self._request("DELETE", path, query=query)

sentroy/domains.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import urllib.parse
+
+from sentroy._http import _HttpClient
+from sentroy.types import Domain
+
+
+class DomainsResource:
+    """Interact with the Domains API."""
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    def list(self) -> list[Domain]:
+        """List all verified domains for the company."""
+        data = self._http.get("/domains")
+        return [Domain.from_dict(d) for d in (data or [])]
+
+    def get(self, id: str) -> Domain:
+        """Get a single domain by ID."""
+        data = self._http.get(f"/domains/{urllib.parse.quote(id, safe='')}")
+        return Domain.from_dict(data)

sentroy/inbox.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from sentroy._http import _HttpClient
+from sentroy.types import (
+    InboxListParams,
+    Mailbox,
+    MessageDetail,
+    MessageSummary,
+)
+
+
+class InboxResource:
+    """Interact with the Inbox API."""
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    def list(self, params: Optional[InboxListParams] = None) -> list[MessageSummary]:
+        """List messages in a mailbox folder."""
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.mailbox is not None:
+                query["mailbox"] = params.mailbox
+            if params.folder is not None:
+                query["folder"] = params.folder
+            if params.page is not None:
+                query["page"] = params.page
+            if params.limit is not None:
+                query["limit"] = params.limit
+            if params.unread_only:
+                query["unreadOnly"] = "true"
+        data = self._http.get("/inbox", query or None)
+        return [MessageSummary.from_dict(d) for d in (data or [])]
+
+    def get(
+        self,
+        uid: int,
+        *,
+        mailbox: Optional[str] = None,
+        folder: Optional[str] = None,
+    ) -> MessageDetail:
+        """Get a single message detail."""
+        query: dict[str, Any] = {}
+        if mailbox is not None:
+            query["mailbox"] = mailbox
+        if folder is not None:
+            query["folder"] = folder
+        data = self._http.get(f"/inbox/{uid}", query or None)
+        return MessageDetail.from_dict(data)
+
+    def list_folders(self, mailbox: Optional[str] = None) -> list[Mailbox]:
+        """List IMAP folders (mailboxes) for a given email account."""
+        query: dict[str, Any] = {}
+        if mailbox is not None:
+            query["mailbox"] = mailbox
+        data = self._http.get("/inbox/mailboxes", query or None)
+        return [Mailbox.from_dict(d) for d in (data or [])]
+
+    def get_thread(
+        self,
+        subject: str,
+        mailbox: Optional[str] = None,
+    ) -> list[MessageDetail]:
+        """Get thread messages by subject."""
+        query: dict[str, Any] = {"subject": subject}
+        if mailbox is not None:
+            query["mailbox"] = mailbox
+        data = self._http.get("/inbox/thread", query)
+        return [MessageDetail.from_dict(d) for d in (data or [])]
+
+    def mark_as_read(
+        self,
+        uid: int,
+        *,
+        mailbox: Optional[str] = None,
+        folder: Optional[str] = None,
+    ) -> None:
+        """Mark a message as read."""
+        self._http.post(f"/inbox/{uid}/read", {
+            "mailbox": mailbox,
+            "folder": folder,
+        })
+
+    def mark_as_unread(
+        self,
+        uid: int,
+        *,
+        mailbox: Optional[str] = None,
+        folder: Optional[str] = None,
+    ) -> None:
+        """Mark a message as unread."""
+        self._http.delete(f"/inbox/{uid}/read", {
+            "mailbox": mailbox,
+            "folder": folder,
+        })
+
+    def move(
+        self,
+        uid: int,
+        to: str,
+        *,
+        from_folder: Optional[str] = None,
+        mailbox: Optional[str] = None,
+    ) -> None:
+        """Move a message to another folder."""
+        self._http.post(f"/inbox/{uid}/move", {
+            "to": to,
+            "from": from_folder,
+            "mailbox": mailbox,
+        })
+
+    def delete(
+        self,
+        uid: int,
+        *,
+        mailbox: Optional[str] = None,
+        folder: Optional[str] = None,
+    ) -> None:
+        """Delete a message."""
+        query: dict[str, Any] = {}
+        if mailbox is not None:
+            query["mailbox"] = mailbox
+        if folder is not None:
+            query["folder"] = folder
+        self._http.delete(f"/inbox/{uid}", query or None)

sentroy/mailboxes.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from sentroy._http import _HttpClient
+from sentroy.types import MailboxUser
+
+
+class MailboxesResource:
+    """Interact with the Mailboxes API."""
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    def list(self) -> list[MailboxUser]:
+        """List all mailbox accounts for the company."""
+        data = self._http.get("/mailboxes")
+        return [MailboxUser.from_dict(d) for d in (data or [])]

sentroy/send.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from sentroy._http import _HttpClient
+from sentroy.types import SendParams, SendResult
+
+
+class SendResource:
+    """Interact with the Send API."""
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    def email(self, params: SendParams) -> SendResult:
+        """Send an email."""
+        data = self._http.post("/send", params.to_dict())
+        return SendResult.from_dict(data)

sentroy/templates.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import urllib.parse
+
+from sentroy._http import _HttpClient
+from sentroy.types import Template
+
+
+class TemplatesResource:
+    """Interact with the Templates API."""
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    def list(self) -> list[Template]:
+        """List all templates."""
+        data = self._http.get("/templates")
+        return [Template.from_dict(d) for d in (data or [])]
+
+    def get(self, id: str) -> Template:
+        """Get a single template by ID."""
+        data = self._http.get(f"/templates/{urllib.parse.quote(id, safe='')}")
+        return Template.from_dict(data)

sentroy/types.py

@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Optional, Union
+
+
+# -- Domains -----------------------------------------------------------------
+
+@dataclass
+class Domain:
+    id: str
+    domain: str
+    status: str
+    spf_verified: bool
+    dkim_verified: bool
+    dmarc_verified: bool
+    created_at: str
+    updated_at: str
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> Domain:
+        return cls(
+            id=d["id"],
+            domain=d["domain"],
+            status=d["status"],
+            spf_verified=d.get("spfVerified", d.get("spf_verified", False)),
+            dkim_verified=d.get("dkimVerified", d.get("dkim_verified", False)),
+            dmarc_verified=d.get("dmarcVerified", d.get("dmarc_verified", False)),
+            created_at=d.get("createdAt", d.get("created_at", "")),
+            updated_at=d.get("updatedAt", d.get("updated_at", "")),
+        )
+
+
+# -- Mailboxes ---------------------------------------------------------------
+
+@dataclass
+class MailboxUser:
+    email: str
+    domain: str
+    username: str
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> MailboxUser:
+        return cls(
+            email=d["email"],
+            domain=d["domain"],
+            username=d["username"],
+        )
+
+
+# -- Templates ----------------------------------------------------------------
+
+LocalizedString = Union[str, dict[str, str]]
+
+
+@dataclass
+class Template:
+    id: str
+    name: LocalizedString
+    subject: LocalizedString
+    mjml_body: LocalizedString
+    html_body: Optional[LocalizedString] = None
+    variables: Optional[list[str]] = None
+    domain_id: Optional[str] = None
+    domain_name: Optional[str] = None
+    created_at: str = ""
+    updated_at: str = ""
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> Template:
+        return cls(
+            id=d["id"],
+            name=d["name"],
+            subject=d["subject"],
+            mjml_body=d.get("mjmlBody", d.get("mjml_body", "")),
+            html_body=d.get("htmlBody", d.get("html_body")),
+            variables=d.get("variables"),
+            domain_id=d.get("domainId", d.get("domain_id")),
+            domain_name=d.get("domainName", d.get("domain_name")),
+            created_at=d.get("createdAt", d.get("created_at", "")),
+            updated_at=d.get("updatedAt", d.get("updated_at", "")),
+        )
+
+
+# -- Inbox --------------------------------------------------------------------
+
+@dataclass
+class MessageAddress:
+    name: str
+    address: str
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> MessageAddress:
+        return cls(name=d.get("name", ""), address=d.get("address", ""))
+
+
+@dataclass
+class MessageSummary:
+    uid: int
+    subject: str
+    from_addr: MessageAddress
+    to: list[MessageAddress]
+    date: str
+    seen: bool
+    flagged: bool
+    size: int
+    has_attachments: bool
+    preview: str
+    message_id: Optional[str]
+    in_reply_to: Optional[str]
+    category: str
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> MessageSummary:
+        from_raw = d.get("from", d.get("from_addr", {}))
+        from_addr = MessageAddress.from_dict(from_raw) if isinstance(from_raw, dict) else MessageAddress(name="", address="")
+        return cls(
+            uid=d["uid"],
+            subject=d.get("subject", ""),
+            from_addr=from_addr,
+            to=[MessageAddress.from_dict(a) for a in d.get("to", [])],
+            date=d.get("date", ""),
+            seen=d.get("seen", False),
+            flagged=d.get("flagged", False),
+            size=d.get("size", 0),
+            has_attachments=d.get("hasAttachments", d.get("has_attachments", False)),
+            preview=d.get("preview", ""),
+            message_id=d.get("messageId", d.get("message_id")),
+            in_reply_to=d.get("inReplyTo", d.get("in_reply_to")),
+            category=d.get("category", ""),
+        )
+
+
+@dataclass
+class AttachmentInfo:
+    part_id: str
+    filename: str
+    size: int
+    content_type: str
+    content_id: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> AttachmentInfo:
+        return cls(
+            part_id=d.get("partId", d.get("part_id", "")),
+            filename=d.get("filename", ""),
+            size=d.get("size", 0),
+            content_type=d.get("contentType", d.get("content_type", "")),
+            content_id=d.get("contentId", d.get("content_id")),
+        )
+
+
+@dataclass
+class MessageDetail:
+    uid: int
+    subject: str
+    from_addr: MessageAddress
+    to: list[MessageAddress]
+    cc: list[MessageAddress]
+    reply_to: Optional[MessageAddress]
+    date: str
+    seen: bool
+    flagged: bool
+    text_body: Optional[str]
+    html_body: Optional[str]
+    attachments: list[AttachmentInfo]
+    headers: dict[str, str]
+    message_id: Optional[str]
+    in_reply_to: Optional[str]
+    references: list[str]
+    folder: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> MessageDetail:
+        from_raw = d.get("from", d.get("from_addr", {}))
+        from_addr = MessageAddress.from_dict(from_raw) if isinstance(from_raw, dict) else MessageAddress(name="", address="")
+        reply_to_raw = d.get("replyTo", d.get("reply_to"))
+        reply_to = MessageAddress.from_dict(reply_to_raw) if isinstance(reply_to_raw, dict) else None
+        return cls(
+            uid=d["uid"],
+            subject=d.get("subject", ""),
+            from_addr=from_addr,
+            to=[MessageAddress.from_dict(a) for a in d.get("to", [])],
+            cc=[MessageAddress.from_dict(a) for a in d.get("cc", [])],
+            reply_to=reply_to,
+            date=d.get("date", ""),
+            seen=d.get("seen", False),
+            flagged=d.get("flagged", False),
+            text_body=d.get("textBody", d.get("text_body")),
+            html_body=d.get("htmlBody", d.get("html_body")),
+            attachments=[AttachmentInfo.from_dict(a) for a in d.get("attachments", [])],
+            headers=d.get("headers", {}),
+            message_id=d.get("messageId", d.get("message_id")),
+            in_reply_to=d.get("inReplyTo", d.get("in_reply_to")),
+            references=d.get("references", []),
+            folder=d.get("folder"),
+        )
+
+
+@dataclass
+class Mailbox:
+    name: str
+    path: str
+    special_use: Optional[str]
+    total_messages: int
+    unread_messages: int
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> Mailbox:
+        return cls(
+            name=d.get("name", ""),
+            path=d.get("path", ""),
+            special_use=d.get("specialUse", d.get("special_use")),
+            total_messages=d.get("totalMessages", d.get("total_messages", 0)),
+            unread_messages=d.get("unreadMessages", d.get("unread_messages", 0)),
+        )
+
+
+@dataclass
+class InboxListParams:
+    mailbox: Optional[str] = None
+    folder: Optional[str] = None
+    page: Optional[int] = None
+    limit: Optional[int] = None
+    unread_only: Optional[bool] = None
+
+
+# -- Send ---------------------------------------------------------------------
+
+@dataclass
+class Attachment:
+    filename: str
+    content: str
+    content_type: Optional[str] = None
+
+
+@dataclass
+class SendParams:
+    to: Union[str, list[str]]
+    from_addr: str
+    subject: str
+    domain_id: str
+    cc: Optional[Union[str, list[str]]] = None
+    template_id: Optional[str] = None
+    lang: Optional[str] = None  # Template language code (e.g. "en", "tr")
+    html: Optional[str] = None
+    text: Optional[str] = None
+    variables: Optional[dict[str, str]] = None
+    reply_to: Optional[str] = None
+    attachments: Optional[list[Attachment]] = None
+    scheduled_at: Optional[str] = None
+    headers: Optional[dict[str, str]] = None
+    in_reply_to: Optional[str] = None
+    references: Optional[list[str]] = None
+
+    def to_dict(self) -> dict[str, Any]:
+        d: dict[str, Any] = {
+            "to": self.to,
+            "from": self.from_addr,
+            "subject": self.subject,
+            "domainId": self.domain_id,
+        }
+        if self.cc is not None:
+            d["cc"] = self.cc
+        if self.template_id is not None:
+            d["templateId"] = self.template_id
+        if self.lang is not None:
+            d["lang"] = self.lang
+        if self.html is not None:
+            d["html"] = self.html
+        if self.text is not None:
+            d["text"] = self.text
+        if self.variables is not None:
+            d["variables"] = self.variables
+        if self.reply_to is not None:
+            d["replyTo"] = self.reply_to
+        if self.attachments is not None:
+            d["attachments"] = [
+                {
+                    "filename": a.filename,
+                    "content": a.content,
+                    **({"contentType": a.content_type} if a.content_type is not None else {}),
+                }
+                for a in self.attachments
+            ]
+        if self.scheduled_at is not None:
+            d["scheduledAt"] = self.scheduled_at
+        if self.headers is not None:
+            d["headers"] = self.headers
+        if self.in_reply_to is not None:
+            d["inReplyTo"] = self.in_reply_to
+        if self.references is not None:
+            d["references"] = self.references
+        return d
+
+
+@dataclass
+class SendResult:
+    job_id: str
+    mail_log_id: str
+    status: str
+    scheduled_at: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> SendResult:
+        return cls(
+            job_id=d.get("jobId", d.get("job_id", "")),
+            mail_log_id=d.get("mailLogId", d.get("mail_log_id", "")),
+            status=d.get("status", ""),
+            scheduled_at=d.get("scheduledAt", d.get("scheduled_at")),
+        )

sentroy_client_sdk-1.1.5.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: sentroy-client-sdk
+Version: 1.1.5
+Summary: Server-side Python SDK for Sentroy platform API
+Project-URL: Homepage, https://github.com/Sentroy-Co/client-sdk
+Project-URL: Repository, https://github.com/Sentroy-Co/client-sdk
+Project-URL: Issues, https://github.com/Sentroy-Co/client-sdk/issues
+License-Expression: MIT
+Keywords: api,email,mail,sdk,sentroy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://sentroy.com/business/sentroy-logo-light.png" alt="Sentroy" width="240" />
+</p>
+
+<h3 align="center">Sentroy Client SDK for Python</h3>
+
+<p align="center">
+  Server-side SDK to interact with the Sentroy platform API.<br />
+  List domains, manage mailboxes, fetch templates, read inbox, and send emails.
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/sentroy-client-sdk/"><img src="https://img.shields.io/pypi/v/sentroy-client-sdk.svg" alt="PyPI version" /></a>
+  <a href="https://github.com/Sentroy-Co/client-sdk/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/sentroy-client-sdk.svg" alt="license" /></a>
+</p>
+
+---
+
+## Installation
+
+```bash
+pip install sentroy-client-sdk
+```
+
+## Quick Start
+
+```python
+from sentroy import Sentroy
+
+sentroy = Sentroy(
+    base_url="https://sentroy.com",
+    company_slug="my-company",
+    access_token="stk_...",
+)
+```
+
+> Access tokens can be created from **Admin > Access Tokens** in the Sentroy dashboard.
+
+## Usage
+
+### Domains
+
+```python
+# List all domains
+domains = sentroy.domains.list()
+
+# Get a single domain
+domain = sentroy.domains.get("domain-id")
+```
+
+### Mailboxes
+
+```python
+# List all mailbox accounts
+mailboxes = sentroy.mailboxes.list()
+```
+
+### Templates
+
+```python
+# List all templates
+templates = sentroy.templates.list()
+
+# Get a template by ID
+template = sentroy.templates.get("template-id")
+```
+
+Templates support multiple languages. A field like `name` or `subject` can be a plain string or a dict keyed by language code:
+
+```python
+# Example template response
+{
+    "id": "b3f1a2c4-...",
+    "name": {"en": "Welcome Email", "tr": "Hosgeldin E-postasi"},
+    "subject": {"en": "Welcome, {{name}}!", "tr": "Hosgeldin, {{name}}!"},
+    "mjmlBody": {"en": "<mjml>...</mjml>", "tr": "<mjml>...</mjml>"},
+    "variables": ["name", "company"],
+    "domainId": "a1b2c3d4-...",
+    "domainName": "example.com"
+}
+```
+
+Use the `variables` list to know which placeholders (`{{name}}`, `{{company}}`) the template expects.
+
+### Inbox
+
+```python
+from sentroy import InboxListParams
+
+# List messages
+messages = sentroy.inbox.list(InboxListParams(
+    mailbox="info@example.com",
+    folder="INBOX",
+    page=1,
+    limit=20,
+))
+
+# Get a single message
+message = sentroy.inbox.get(1234, mailbox="info@example.com")
+
+# List IMAP folders
+folders = sentroy.inbox.list_folders("info@example.com")
+
+# Get a thread by subject
+thread = sentroy.inbox.get_thread("Re: Project update", "info@example.com")
+
+# Mark as read / unread
+sentroy.inbox.mark_as_read(1234, mailbox="info@example.com")
+sentroy.inbox.mark_as_unread(1234, mailbox="info@example.com")
+
+# Move message
+sentroy.inbox.move(1234, "Trash", from_folder="INBOX", mailbox="info@example.com")
+
+# Delete message
+sentroy.inbox.delete(1234, mailbox="info@example.com")
+```
+
+### Send Email
+
+```python
+from sentroy import SendParams, Attachment
+
+# Send with a template
+result = sentroy.send.email(SendParams(
+    to="user@example.com",
+    from_addr="info@example.com",
+    subject="Welcome!",
+    domain_id="domain-id",
+    template_id="template-id",
+    variables={
+        "name": "John",
+        "company": "Acme",
+    },
+))
+
+# Send with a specific language
+result = sentroy.send.email(SendParams(
+    to="user@example.com",
+    from_addr="info@example.com",
+    subject="Hosgeldin!",
+    domain_id="domain-id",
+    template_id="template-id",
+    lang="tr",
+    variables={"name": "Ahmet"},
+))
+
+# Send with raw HTML
+result = sentroy.send.email(SendParams(
+    to=["user1@example.com", "user2@example.com"],
+    from_addr="info@example.com",
+    subject="Hello",
+    domain_id="domain-id",
+    html="<h1>Hello World</h1>",
+))
+
+# Send with attachments
+result = sentroy.send.email(SendParams(
+    to="user@example.com",
+    from_addr="info@example.com",
+    subject="Invoice",
+    domain_id="domain-id",
+    html="<p>Please find your invoice attached.</p>",
+    attachments=[
+        Attachment(
+            filename="invoice.pdf",
+            content=base64_string,
+            content_type="application/pdf",
+        ),
+    ],
+))
+```
+
+## Error Handling
+
+```python
+from sentroy import Sentroy, SentroyError
+
+try:
+    sentroy.send.email(params)
+except SentroyError as err:
+    print(err.status_code)  # 401, 403, 500, etc.
+    print(err)              # Human-readable error
+```
+
+## Configuration
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `base_url` | `str` | Yes | Sentroy instance URL (e.g. `https://sentroy.com`) |
+| `company_slug` | `str` | Yes | Your company slug |
+| `access_token` | `str` | Yes | Access token (`stk_...`) |
+| `timeout` | `int` | No | Request timeout in seconds (default: `30`) |
+
+## Requirements
+
+- Python 3.10+
+- Zero external dependencies (stdlib only)
+
+## Raw Documentation
+
+For AI agents and LLMs — plain-text version of this document:
+
+```
+https://raw.githubusercontent.com/Sentroy-Co/client-sdk/refs/heads/main/python/README.md
+```
+
+## License
+
+[MIT](LICENSE)

sentroy_client_sdk-1.1.5.dist-info/RECORD

@@ -0,0 +1,11 @@
+sentroy/__init__.py,sha256=ZGLGrc3C63h3vOSmIExtgXMrqXBClTNsmdTLdBMy1qo,1875
+sentroy/_http.py,sha256=y9gHm7-hlFAFvHoqTtf6duaVN-bMkpDNIfA3L85o7SA,3019
+sentroy/domains.py,sha256=EYWbRm-oGYeDzNgxSprlckj2YDosDBXAxxBK5Rd8Evk,662
+sentroy/inbox.py,sha256=yyYO43Z6o2SXBhy1Gc_NlAbjkWUte6PMN6BrPyH_4As,3808
+sentroy/mailboxes.py,sha256=kBYvctvvi6eRz3OViVUgbBMmkEYT8E5_zUJGR81s3d0,467
+sentroy/send.py,sha256=4oBJ053mF-_Le2Mr7Bkm7Zkqr0gdeuM2C9E3VfSykMA,446
+sentroy/templates.py,sha256=bhZpoWEByh3TeJrmd2Iy0FKqGLQjaOr6zxCpfspQfWM,659
+sentroy/types.py,sha256=GfHpZyu4lvs621ss5VQdYrPoO2i46yvtSQCOd7UsG7g,9715
+sentroy_client_sdk-1.1.5.dist-info/METADATA,sha256=FP4L9Xr7tWC3LbXG_4ttOevxIiSCiS1N7oRAWuyOIqo,5853
+sentroy_client_sdk-1.1.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sentroy_client_sdk-1.1.5.dist-info/RECORD,,

sentroy_client_sdk-1.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any