reloop-email 0.2.0__py3-none-any.whl

reloop_email/__init__.py

@@ -0,0 +1,12 @@
+from .errors import ReloopApiError, ReloopError, ReloopNetworkError
+from .reloop import Reloop
+
+ReloopClient = Reloop
+
+__all__ = [
+    "Reloop",
+    "ReloopClient",
+    "ReloopError",
+    "ReloopApiError",
+    "ReloopNetworkError",
+]

reloop_email/_http_client.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import httpx
+
+from .errors import ReloopApiError, ReloopNetworkError
+
+
+class HTTPClient:
+    """Internal HTTP transport for the Reloop SDK."""
+
+    def __init__(self, api_key: str, base_url: str = "https://reloop.sh") -> None:
+        if not api_key:
+            raise ValueError("Reloop SDK requires an api_key.")
+
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self._http = httpx.Client(
+            base_url=self.base_url,
+            headers={
+                "x-api-key": self.api_key,
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            },
+            timeout=30.0,
+        )
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[dict[str, Any]] = None,
+        json: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
+        try:
+            response = self._http.request(method, path, params=params, json=json)
+        except httpx.RequestError as exc:
+            raise ReloopNetworkError(f"Reloop network error: {exc}") from exc
+
+        if response.status_code >= 400:
+            body: Any = None
+            try:
+                body = response.json()
+            except ValueError:
+                body = response.text
+
+            message = response.reason_phrase
+            if isinstance(body, dict) and body.get("message"):
+                message = str(body["message"])
+
+            raise ReloopApiError(
+                f"Reloop API error ({response.status_code}): {message}",
+                status_code=response.status_code,
+                body=body,
+            )
+
+        if response.status_code == 204 or not response.content:
+            return {}
+
+        data = response.json()
+        if not isinstance(data, dict):
+            return {"data": data}
+        return data
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "HTTPClient":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

reloop_email/_parameters.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+REQUEST_KEY_MAP = {
+    "first_name": "firstName",
+    "last_name": "lastName",
+    "group_ids": "groupIds",
+    "group_id": "groupId",
+    "fallback_value": "fallbackValue",
+    "default_subscription": "defaultSubscription",
+    "channel_id": "channelId",
+    "property_name": "propertyName",
+    "property_type": "propertyType",
+    "contact_id": "contactId",
+    "rate_limit_enabled": "rateLimitEnabled",
+    "user_id": "userId",
+}
+
+
+def for_request(parameters: dict[str, Any]) -> dict[str, Any]:
+    normalized: dict[str, Any] = {}
+
+    for key, value in parameters.items():
+        if key == "unsubscribed":
+            if "status" not in parameters:
+                normalized["status"] = "unsubscribed" if value else "subscribed"
+            continue
+
+        api_key = REQUEST_KEY_MAP.get(key, _to_camel_case(key))
+        normalized[api_key] = _normalize_value(value, is_request=True)
+
+    return {key: value for key, value in normalized.items() if value is not None}
+
+
+def for_query(options: dict[str, Any]) -> dict[str, Any]:
+    return for_request(options)
+
+
+def for_snake_request(parameters: dict[str, Any]) -> dict[str, Any]:
+    """Pass parameters through without camelCase conversion (domain API)."""
+    return {key: value for key, value in parameters.items() if value is not None}
+
+
+def for_response(data: dict[str, Any]) -> dict[str, Any]:
+    normalized: dict[str, Any] = {}
+
+    for key, value in data.items():
+        normalized[_to_snake_case(key)] = _normalize_value(value, is_request=False)
+
+    return normalized
+
+
+def _normalize_value(value: Any, *, is_request: bool) -> Any:
+    if not isinstance(value, dict):
+        return value
+
+    if _is_list(value):
+        return [
+            _normalize_value(item, is_request=is_request) if isinstance(item, dict) else item
+            for item in value
+        ]
+
+    return for_request(value) if is_request else for_response(value)
+
+
+def _is_list(value: dict[str, Any]) -> bool:
+    if not value:
+        return True
+    return list(value.keys()) == list(range(len(value)))
+
+
+def _to_camel_case(key: str) -> str:
+    if key in REQUEST_KEY_MAP:
+        return REQUEST_KEY_MAP[key]
+    if "_" not in key:
+        return key
+    parts = key.split("_")
+    return parts[0] + "".join(part.capitalize() for part in parts[1:])
+
+
+def _to_snake_case(key: str) -> str:
+    if "_" in key:
+        return key
+    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", key).lower()

reloop_email/_resource.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Any, Iterator, Mapping
+
+
+class Resource(Mapping[str, Any]):
+    """StripeObject-style resource with snake_case attribute access."""
+
+    _repr_attr = "id"
+
+    def __init__(self, **attributes: Any) -> None:
+        self._values = dict(attributes)
+        for key, value in attributes.items():
+            object.__setattr__(self, key, value)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Resource:
+        return cls(**data)
+
+    def __getitem__(self, key: str) -> Any:
+        return self._values[key]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._values)
+
+    def __len__(self) -> int:
+        return len(self._values)
+
+    def __repr__(self) -> str:
+        ident = getattr(self, self._repr_attr, None)
+        class_name = self.__class__.__name__
+        if ident is not None:
+            return f"<{class_name} {self._repr_attr}={ident!r}>"
+        return f"<{class_name}>"
+
+
+class ApiKey(Resource):
+    pass
+
+
+class ApiKeyList(Resource):
+    pass
+
+
+class Contact(Resource):
+    pass
+
+
+class ContactList(Resource):
+    pass
+
+
+class ContactProperty(Resource):
+    pass
+
+
+class PropertyList(Resource):
+    pass
+
+
+class ContactGroup(Resource):
+    pass
+
+
+class GroupList(Resource):
+    pass
+
+
+class ContactChannel(Resource):
+    pass
+
+
+class ChannelList(Resource):
+    pass
+
+
+class DnsRecord(Resource):
+    pass
+
+
+class Domain(Resource):
+    pass
+
+
+class DomainList(Resource):
+    pass
+
+
+class DomainStatus(Resource):
+    pass
+
+
+class DomainNameservers(Resource):
+    pass
+
+
+class ForwardDnsResponse(Resource):
+    pass

reloop_email/_resource_factory.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Optional, TypeVar
+
+from ._parameters import for_response
+from ._resource import (
+    ApiKey,
+    ApiKeyList,
+    ChannelList,
+    Contact,
+    ContactChannel,
+    ContactGroup,
+    ContactList,
+    ContactProperty,
+    DnsRecord,
+    Domain,
+    DomainList,
+    DomainNameservers,
+    DomainStatus,
+    ForwardDnsResponse,
+    GroupList,
+    PropertyList,
+    Resource,
+)
+
+T = TypeVar("T", bound=Resource)
+
+
+def _build(resource_cls: type[T], data: dict[str, Any]) -> T:
+    return resource_cls.from_dict(for_response(data))
+
+
+def api_key(data: dict[str, Any]) -> ApiKey:
+    return _build(ApiKey, data)
+
+
+def api_key_list(data: dict[str, Any]) -> ApiKeyList:
+    normalized = for_response(data)
+    if isinstance(normalized.get("api_keys"), list):
+        normalized["api_keys"] = [api_key(item) for item in normalized["api_keys"]]
+    return ApiKeyList.from_dict(normalized)
+
+
+def contact(data: dict[str, Any]) -> Contact:
+    return _build(Contact, data)
+
+
+def contact_list(data: dict[str, Any]) -> ContactList:
+    normalized = for_response(data)
+    if isinstance(normalized.get("contacts"), list):
+        normalized["contacts"] = [contact(item) for item in normalized["contacts"]]
+    return ContactList.from_dict(normalized)
+
+
+def contact_property(data: dict[str, Any]) -> ContactProperty:
+    return _build(ContactProperty, data)
+
+
+def property_list(data: dict[str, Any]) -> PropertyList:
+    normalized = for_response(data)
+    if isinstance(normalized.get("properties"), list):
+        normalized["properties"] = [
+            contact_property(item) for item in normalized["properties"]
+        ]
+    return PropertyList.from_dict(normalized)
+
+
+def contact_group(data: dict[str, Any]) -> ContactGroup:
+    normalized = for_response(data)
+    if isinstance(normalized.get("contacts"), list):
+        normalized["contacts"] = [contact(item) for item in normalized["contacts"]]
+    return ContactGroup.from_dict(normalized)
+
+
+def group_list(data: dict[str, Any]) -> GroupList:
+    normalized = for_response(data)
+    if isinstance(normalized.get("groups"), list):
+        normalized["groups"] = [contact_group(item) for item in normalized["groups"]]
+    return GroupList.from_dict(normalized)
+
+
+def contact_channel(data: dict[str, Any]) -> ContactChannel:
+    normalized = for_response(data)
+    if isinstance(normalized.get("contact"), dict):
+        normalized["contact"] = contact(normalized["contact"])
+    return ContactChannel.from_dict(normalized)
+
+
+def channel_list(data: dict[str, Any]) -> ChannelList:
+    normalized = for_response(data)
+    if isinstance(normalized.get("channels"), list):
+        normalized["channels"] = [
+            contact_channel(item) for item in normalized["channels"]
+        ]
+    return ChannelList.from_dict(normalized)
+
+
+def dns_record(data: dict[str, Any]) -> DnsRecord:
+    return _build(DnsRecord, data)
+
+
+def domain(data: dict[str, Any]) -> Domain:
+    normalized = for_response(data)
+    if isinstance(normalized.get("dns_records"), list):
+        normalized["dns_records"] = [
+            dns_record(item) for item in normalized["dns_records"]
+        ]
+    return Domain.from_dict(normalized)
+
+
+def domain_list(data: dict[str, Any]) -> DomainList:
+    normalized = for_response(data)
+    if isinstance(normalized.get("domains"), list):
+        normalized["domains"] = [domain(item) for item in normalized["domains"]]
+    return DomainList.from_dict(normalized)
+
+
+def domain_status(data: dict[str, Any]) -> DomainStatus:
+    return _build(DomainStatus, data)
+
+
+def domain_nameservers(data: dict[str, Any]) -> DomainNameservers:
+    return _build(DomainNameservers, data)
+
+
+def forward_dns_response(data: dict[str, Any]) -> ForwardDnsResponse:
+    return _build(ForwardDnsResponse, data)

reloop_email/client.py

@@ -0,0 +1,6 @@
+from .reloop import Reloop
+
+# Backward-compatible alias used in dashboard examples.
+ReloopClient = Reloop
+
+__all__ = ["Reloop", "ReloopClient"]

reloop_email/errors.py

@@ -0,0 +1,27 @@
+from typing import Any, Optional
+
+
+class ReloopError(Exception):
+    """Base exception for all Reloop SDK errors."""
+
+
+class ReloopApiError(ReloopError):
+    """Raised when the Reloop API returns an error response."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: Optional[int] = None,
+        body: Optional[Any] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body
+
+    def __repr__(self) -> str:
+        return f"ReloopApiError(message={self.args[0]!r}, status_code={self.status_code!r})"
+
+
+class ReloopNetworkError(ReloopError):
+    """Raised when a network error occurs while communicating with Reloop."""

reloop_email/reloop.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from ._http_client import HTTPClient
+from .services.api_keys import ApiKeysService
+from .services.contacts import ContactsService
+from .services.domain import DomainService
+
+
+class Reloop:
+    """Reloop Python SDK client."""
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = "https://reloop.sh",
+    ) -> None:
+        self._http = HTTPClient(api_key, base_url)
+        self.api_keys = ApiKeysService(self._http)
+        self.contacts = ContactsService(self._http)
+        self.domain = DomainService(self._http)
+
+    @classmethod
+    def client(
+        cls,
+        api_key: str,
+        base_url: str = "https://reloop.sh",
+    ) -> "Reloop":
+        """Create a new Reloop client with the given API key."""
+        return cls(api_key, base_url=base_url)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "Reloop":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

reloop_email/services/__init__.py

@@ -0,0 +1,4 @@
+from .api_keys import ApiKeysService
+from .domain import DomainService
+
+__all__ = ["ApiKeysService", "DomainService"]

reloop_email/services/api_keys.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .._http_client import HTTPClient
+from .._parameters import for_query, for_request
+from .._resource_factory import api_key, api_key_list
+
+
+class ApiKeysService:
+    """Manage API keys."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def create(self, **parameters: Any) -> Any:
+        data = self._client.request(
+            "POST",
+            "/api/api-key/v1/",
+            json=for_request(parameters),
+        )
+        return api_key(data)
+
+    def list(self, **options: Any) -> Any:
+        data = self._client.request(
+            "GET",
+            "/api/api-key/v1/",
+            params=for_query(options) or None,
+        )
+        return api_key_list(data)
+
+    def get(self, api_key_id: str) -> Any:
+        data = self._client.request("GET", f"/api/api-key/v1/{api_key_id}")
+        return api_key(data)
+
+    def update(self, api_key_id: str, **parameters: Any) -> Any:
+        data = self._client.request(
+            "PATCH",
+            f"/api/api-key/v1/{api_key_id}",
+            json=for_request(parameters),
+        )
+        return api_key(data)
+
+    def delete(self, api_key_id: str) -> Any:
+        data = self._client.request("DELETE", f"/api/api-key/v1/{api_key_id}")
+        return api_key(data)
+
+    def rotate(self, api_key_id: str) -> Any:
+        data = self._client.request("POST", f"/api/api-key/v1/rotate/{api_key_id}")
+        return api_key(data)
+
+    def enable(self, api_key_id: str) -> Any:
+        data = self._client.request("POST", f"/api/api-key/v1/enable/{api_key_id}")
+        return api_key(data)
+
+    def disable(self, api_key_id: str) -> Any:
+        data = self._client.request("POST", f"/api/api-key/v1/disable/{api_key_id}")
+        return api_key(data)
+
+    def pause(self, api_key_id: str) -> Any:
+        """Pause an API key (alias for :meth:`disable`)."""
+        return self.disable(api_key_id)

reloop_email/services/contacts/__init__.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..._http_client import HTTPClient
+from ..._parameters import for_query, for_request
+from ..._resource_factory import (
+    contact,
+    contact_group,
+    contact_list,
+    contact_property,
+    group_list,
+    property_list,
+)
+from .channels import ContactChannelsService
+from .groups import ContactGroupsService
+
+
+class ContactsService:
+    """Manage contacts, properties, and groups."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+        self.groups = ContactGroupsService(client)
+        self.channels = ContactChannelsService(client)
+
+    def create(self, **parameters: Any) -> Any:
+        data = self._client.request(
+            "POST",
+            "/api/contacts/create",
+            json=for_request(parameters),
+        )
+        return contact(data)
+
+    def get(self, contact_id: str) -> Any:
+        data = self._client.request("GET", f"/api/contacts/retrieve/{contact_id}")
+        return contact(data)
+
+    def list(self, **options: Any) -> Any:
+        group_id = options.get("group_id") or options.get("groupId")
+
+        if group_id:
+            filtered = {
+                key: value
+                for key, value in options.items()
+                if key not in ("group_id", "groupId")
+            }
+            return self.groups.list_contacts(group_id, **filtered)
+
+        data = self._client.request(
+            "GET",
+            "/api/contacts/list",
+            params=for_query(options) or None,
+        )
+        return contact_list(data)
+
+    def update(self, contact_id: str, **parameters: Any) -> Any:
+        data = self._client.request(
+            "PATCH",
+            f"/api/contacts/{contact_id}",
+            json=for_request(parameters),
+        )
+        return contact(data)
+
+    def delete(self, contact_id: str) -> Any:
+        data = self._client.request("DELETE", f"/api/contacts/{contact_id}")
+        return contact(data)
+
+    def create_property(self, **parameters: Any) -> Any:
+        data = self._client.request(
+            "POST",
+            "/api/contacts/v1/properties/create",
+            json=for_request(parameters),
+        )
+        return contact_property(data)
+
+    def list_properties(self, **options: Any) -> Any:
+        data = self._client.request(
+            "GET",
+            "/api/contacts/v1/properties/list",
+            params=for_query(options) or None,
+        )
+        return property_list(data)
+
+    def update_property(self, property_id: str, **parameters: Any) -> Any:
+        data = self._client.request(
+            "PATCH",
+            f"/api/contacts/v1/properties/{property_id}",
+            json=for_request(parameters),
+        )
+        return contact_property(data)
+
+    def delete_property(self, property_id: str) -> Any:
+        data = self._client.request(
+            "DELETE",
+            f"/api/contacts/v1/properties/{property_id}",
+        )
+        return contact_property(data)
+
+    def create_group(self, **parameters: Any) -> Any:
+        data = self._client.request(
+            "POST",
+            "/api/contacts/v1/groups/create",
+            json=for_request(parameters),
+        )
+        return contact_group(data)
+
+    def list_groups(self, **options: Any) -> Any:
+        data = self._client.request(
+            "GET",
+            "/api/contacts/v1/groups/list",
+            params=for_query(options) or None,
+        )
+        return group_list(data)
+
+    def get_group(self, group_id: str) -> Any:
+        data = self._client.request("GET", f"/api/contacts/v1/groups/{group_id}")
+        return contact_group(data)
+
+    def update_group(self, group_id: str, **parameters: Any) -> Any:
+        data = self._client.request(
+            "PATCH",
+            f"/api/contacts/v1/groups/{group_id}",
+            json=for_request(parameters),
+        )
+        return contact_group(data)
+
+    def delete_group(self, group_id: str) -> Any:
+        data = self._client.request(
+            "DELETE",
+            f"/api/contacts/v1/groups/{group_id}",
+        )
+        return contact_group(data)

reloop_email/services/contacts/channels.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..._http_client import HTTPClient
+from ..._parameters import for_query, for_request
+from ..._resource_factory import channel_list, contact_channel
+
+
+class ContactChannelsService:
+    """Manage contact channels."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def create(self, **parameters: Any) -> Any:
+        data = self._client.request(
+            "POST",
+            "/api/contacts/v1/channels/create",
+            json=for_request(parameters),
+        )
+        return contact_channel(data)
+
+    def list(self, **options: Any) -> Any:
+        data = self._client.request(
+            "GET",
+            "/api/contacts/v1/channels/list",
+            params=for_query(options) or None,
+        )
+        return channel_list(data)
+
+    def get(self, channel_id: str) -> Any:
+        data = self._client.request("GET", f"/api/contacts/v1/channels/{channel_id}")
+        return contact_channel(data)
+
+    def update(self, channel_id: str, **parameters: Any) -> Any:
+        data = self._client.request(
+            "PATCH",
+            f"/api/contacts/v1/channels/{channel_id}",
+            json=for_request(parameters),
+        )
+        return contact_channel(data)
+
+    def delete(self, channel_id: str) -> Any:
+        data = self._client.request(
+            "DELETE",
+            f"/api/contacts/v1/channels/{channel_id}",
+        )
+        return contact_channel(data)
+
+    def add_contact(self, channel_id: str, **parameters: Any) -> Any:
+        data = self._client.request(
+            "POST",
+            f"/api/contacts/channel/{channel_id}",
+            json=for_request(parameters),
+        )
+        return contact_channel(data)
+
+    def update_subscription(self, channel_id: str, **parameters: Any) -> Any:
+        data = self._client.request(
+            "PATCH",
+            f"/api/contacts/channel/{channel_id}",
+            json=for_request(parameters),
+        )
+        return contact_channel(data)

reloop_email/services/contacts/groups.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..._http_client import HTTPClient
+from ..._parameters import for_query, for_request
+from ..._resource_factory import contact, contact_group
+
+
+class ContactGroupsService:
+    """Manage contact group membership."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def add_contact(self, group_id: str, **parameters: Any) -> Any:
+        data = self._client.request(
+            "POST",
+            f"/api/contacts/group/{group_id}",
+            json=for_request(parameters),
+        )
+        return contact(data)
+
+    def remove_contact(self, group_id: str, **parameters: Any) -> Any:
+        data = self._client.request(
+            "DELETE",
+            f"/api/contacts/group/{group_id}",
+            json=for_request(parameters),
+        )
+        return contact(data)
+
+    def list_contacts(self, group_id: str, **options: Any) -> Any:
+        data = self._client.request(
+            "GET",
+            f"/api/contacts/v1/groups/{group_id}/contacts",
+            params=for_query(options) or None,
+        )
+        return contact_group(data)

reloop_email/services/domain.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .._http_client import HTTPClient
+from .._parameters import for_query, for_snake_request
+from .._resource_factory import (
+    domain,
+    domain_list,
+    domain_nameservers,
+    domain_status,
+    forward_dns_response,
+)
+
+
+class DomainService:
+    """Manage sending and receiving domains."""
+
+    def __init__(self, client: HTTPClient) -> None:
+        self._client = client
+
+    def create(self, **parameters: Any) -> Any:
+        data = self._client.request(
+            "POST",
+            "/api/domain/v1/create",
+            json=for_snake_request(parameters),
+        )
+        return domain(data)
+
+    def list(self, **options: Any) -> Any:
+        data = self._client.request(
+            "GET",
+            "/api/domain/v1/list",
+            params=for_query(options) or None,
+        )
+        return domain_list(data)
+
+    def get(self, domain_id: str) -> Any:
+        data = self._client.request("GET", f"/api/domain/v1/{domain_id}")
+        return domain(data)
+
+    def get_nameservers(self, domain_id: str) -> Any:
+        data = self._client.request(
+            "GET",
+            f"/api/domain/v1/nameservers/{domain_id}",
+        )
+        return domain_nameservers(data)
+
+    def update(self, domain_id: str, **parameters: Any) -> Any:
+        data = self._client.request(
+            "PATCH",
+            f"/api/domain/v1/{domain_id}",
+            json=for_snake_request(parameters),
+        )
+        return domain(data)
+
+    def delete(self, domain_id: str) -> Any:
+        data = self._client.request("DELETE", f"/api/domain/v1/{domain_id}")
+        return domain(data)
+
+    def verify(self, domain_id: str) -> Any:
+        data = self._client.request("POST", f"/api/domain/v1/verify/{domain_id}")
+        return domain_status(data)
+
+    def forward_dns(self, domain_id: str, *, email: str) -> Any:
+        data = self._client.request(
+            "POST",
+            f"/api/domain/v1/verify/{domain_id}/forward-dns",
+            json={"email": email},
+        )
+        return forward_dns_response(data)

reloop_email-0.2.0.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: reloop-email
+Version: 0.2.0
+Summary: Reloop Python SDK
+Project-URL: Homepage, https://reloop.sh
+Project-URL: Repository, https://github.com/reloop-labs/reloop-python
+Author: Reloop Labs
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24.0
+Description-Content-Type: text/markdown
+
+# Reloop Python SDK
+
+The official Python SDK for [Reloop](https://reloop.sh), modeled after the Stripe Python SDK with snake_case parameters and typed resource responses.
+
+## Requirements
+
+- Python 3.9 or higher
+
+## Installation
+
+```bash
+pip install reloop-email
+```
+
+## Getting Started
+
+```python
+from reloop_email import Reloop
+
+reloop = Reloop(api_key="re_123456789")
+# or
+reloop = Reloop.client("re_123456789")
+```
+
+## API Keys
+
+```python
+reloop = Reloop(api_key="rl_123456789")
+
+reloop.api_keys.list(page=1, limit=10)
+
+reloop.api_keys.create(
+    name="Production key",
+    enabled=True,
+    rate_limit_enabled=True,
+)
+
+reloop.api_keys.get("key_123456789")
+reloop.api_keys.update("key_123456789", name="Renamed key")
+reloop.api_keys.rotate("key_123456789")
+reloop.api_keys.disable("key_123456789")
+reloop.api_keys.pause("key_123456789")
+reloop.api_keys.enable("key_123456789")
+reloop.api_keys.delete("key_123456789")
+```
+
+## Domains
+
+Add, verify, and manage sending domains. Request parameters use snake_case; responses expose snake_case attributes.
+
+```python
+reloop = Reloop(api_key="rl_123456789")
+
+created = reloop.domain.create(
+    domain="send.example.com",
+    custom_return_path="inbound",
+    click_tracking=True,
+    open_tracking=True,
+    tls="opportunistic",
+    sending_email=True,
+    receiving_email=True,
+)
+
+domains = reloop.domain.list(page=1, limit=10, status="active")
+one = reloop.domain.get("domain_123456789")
+
+reloop.domain.update(
+    "domain_123456789",
+    click_tracking=False,
+    sending_email=True,
+)
+
+reloop.domain.verify("domain_123456789")
+
+reloop.domain.forward_dns("domain_123456789", email="admin@example.com")
+
+nameservers = reloop.domain.get_nameservers("domain_123456789")
+print(nameservers.dns_provider, nameservers.nameservers)
+
+reloop.domain.delete("domain_123456789")
+```
+
+## Contacts
+
+Manage contacts, custom properties, groups, and channels. Methods accept snake_case keyword arguments and return resource objects with snake_case attributes.
+
+### Create a contact
+
+```python
+reloop = Reloop(api_key="re_123456789")
+
+contact = reloop.contacts.create(
+    email="steve.wozniak@gmail.com",
+    first_name="Steve",
+    last_name="Wozniak",
+    unsubscribed=False,
+)
+
+print(contact.email)
+print(contact.first_name)
+```
+
+### List and update contacts
+
+```python
+contacts = reloop.contacts.list(page=1, limit=10)
+print(contacts.contacts, contacts.total)
+
+reloop.contacts.update(
+    "cont_123456789",
+    first_name="Steve",
+    unsubscribed=False,
+)
+```
+
+### Groups and channels
+
+```python
+reloop.contacts.groups.add_contact(
+    "grp_123456789",
+    contact_id="cont_123456789",
+)
+
+reloop.contacts.channels.create(
+    name="Product Updates",
+    default_subscription="opt_in",
+)
+```
+
+## Error Handling
+
+```python
+from reloop_email import Reloop, ReloopApiError
+
+reloop = Reloop(api_key="re_123456789")
+
+try:
+    reloop.contacts.get("cont_invalid")
+except ReloopApiError as error:
+    print(error.status_code, error.body)
+```
+
+## Context Manager
+
+```python
+with Reloop(api_key="re_123456789") as reloop:
+    reloop.contacts.list(limit=10)
+```

reloop_email-0.2.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+reloop_email/__init__.py,sha256=tWlolF6kqj_B6zklRDp4GzPzPwLGuqkBqvQgEO56UhQ,234
+reloop_email/_http_client.py,sha256=Y5MnGVwWp3HV0sIyrg2d_-8lDu_XfA0CLqpG-o1qMuE,2115
+reloop_email/_parameters.py,sha256=KubqE0x9rejq7o7KfFY4iDiS75cWrJ6enJ2CwBHLY_I,2504
+reloop_email/_resource.py,sha256=yfOKfIZkpb0KUG72tpVyYMOJXmcHBFrh9EeeVU4mt-U,1619
+reloop_email/_resource_factory.py,sha256=vLSrejn0ukyDHUofxS5XfxJdapquC2r_qPSRxapK5V4,3812
+reloop_email/client.py,sha256=D_xa3t1CqmfM0SLFgNfWwdA9zw9fjKLEpJNiBN4YcTM,144
+reloop_email/errors.py,sha256=ajAg90kW_qw1vLeB1ct4eCJzJYjUI8ikxPQ0DWWRvrI,720
+reloop_email/reloop.py,sha256=jDPTjw0_IGb2zK0ZBAL0arw9AdeL-N1AgoInNruTmYE,1047
+reloop_email/services/__init__.py,sha256=xikGDamIqwyPBClEpPxXppdvc7VgxUDvZ-KoiNrFGJI,118
+reloop_email/services/api_keys.py,sha256=TEXIqfM72OkefRoPzB78WFJTci2A_l9375_msJg36Cs,1969
+reloop_email/services/domain.py,sha256=YimwEU-YS8wVE0E75gxPLeEqOVvfZb5MrPjJ1vqHIOg,2094
+reloop_email/services/contacts/__init__.py,sha256=pAsZ4-g5IBQeCtG89D5xbGBsTL0gplSmNPj4-WRFrek,4110
+reloop_email/services/contacts/channels.py,sha256=sNR2ZXG0VkaEZnecG6CluVAkPBbzlRu4wuQo5jFKgBQ,2030
+reloop_email/services/contacts/groups.py,sha256=g9ABqZbAaDo-qDRf_Ws81U7OyYNuXwvYwB9QzRwerZI,1150
+reloop_email-0.2.0.dist-info/METADATA,sha256=pfN0RcXvSXZcvbtfQnClF4FdwTuNNfqe_8Y-nJalfYk,3396
+reloop_email-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+reloop_email-0.2.0.dist-info/RECORD,,

reloop_email-0.2.0.dist-info/WHEEL

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