epostix 1.0.0__tar.gz

epostix-1.0.0/.codegen.json

@@ -0,0 +1,31 @@
+{
+  "generator": "epostix-codegen",
+  "spec": {
+    "raw_sha256": "bb71a54ab7ec8025ecc7f833f8a9c260ee0a9040fcfb39608c5cde1ba952c6f2",
+    "contract_sha256": "8f5de3df7a3ac063c6f0110ffc007cea51db26cb9f2826b0d72e6e27d235b4f3"
+  },
+  "ir_sha256": "182bab5a6f40f8c424518090112332f014d04098e0969687b0f3321738d93b07",
+  "files": {
+    "epostix/_generated/models.py": "ad1cb5fed77e365c193fe31f9d17bb7b84dab9700a3824b6f5955251be01a0fe",
+    "epostix/models.py": "2f647a6f861262349357aa6bab61e9403af76c9fde9d6e68f5c5c9e25ae4fab2",
+    "epostix/_generated/codecs.py": "94d7e413d040b0592efe1cd3baf97698d0bec68ac5307dc135f0da4e09a19ad0",
+    "epostix/_generated/operations.py": "547b7896baea9dafd21f6ce4e7794f07e7e0cb8e93833a168f463245356ea963",
+    "epostix/_generated/resources/analytics.py": "3bb7c5464b1f8dbc83eaa408db8b2da660599545a9b0b88cc6e327ef44e910e1",
+    "epostix/_generated/resources/api_keys.py": "514a460940e59e8bc91af1554e08c9cc9c827b40630e5014c302969f3183dfba",
+    "epostix/_generated/resources/attachments.py": "e87758a7f2957a7093f173d6d701a692e7915117ed029fd2276a7bd7815f7ae8",
+    "epostix/_generated/resources/broadcasts.py": "e756cfb53034d502cc767f167ee5c872816231ba86a4901ac992a8bc408b4534",
+    "epostix/_generated/resources/contacts.py": "757ed6ca3e5140954b675d324c8d4f8c1ca9d592205cae2b62ab1ab5af22b9e2",
+    "epostix/_generated/resources/domains.py": "eb961f7a3c46c9ac6f0a2a81ec38163ddb24816344083aa1cb6697fed33011bf",
+    "epostix/_generated/resources/emails.py": "1a9dfe9c838d6eb31dc5f505b14c9a4f5fbdba128a4c476688cd597944dea330",
+    "epostix/_generated/resources/events.py": "0fc1e45b2c6ed11e846d9e6413cd4184e7852a2299b1460717e62536c9738a14",
+    "epostix/_generated/resources/inbound.py": "75e8a5b18195051d60cea5fd972c48a5580921c7b3511d2c90e25f048df09b83",
+    "epostix/_generated/resources/suppressions.py": "38d60c29befe9259ad5bb160f6959e2140ac696b31d6e58b1d132372c9672dc7",
+    "epostix/_generated/resources/tags.py": "9fd18587e35a1b09949808210bb91812c859b9e28e7f7cc5794adadcec29ca4d",
+    "epostix/_generated/resources/templates.py": "47d6e3be9377ae9f42dcacdcc414895588d9b2c502a99be2cf878fed5efa72d0",
+    "epostix/_generated/resources/templates_versions.py": "a9ccd5054204147eb35cb0fb107fd038cdc2658afc80ce725efe0ca3ed6dcca1",
+    "epostix/_generated/resources/webhooks.py": "4a44e89fceaf0e7687c214815b3939d532be835c955a92001945b259081b9d28",
+    "epostix/_generated/resources/webhooks_logs.py": "bd09bf857b311d080cdf09533a85b098512d09681c3401f96c89ff9b285f8d84",
+    "epostix/_generated/resources/__init__.py": "8242f142db2e5367c72f73f140e25b5c2eff97ac7af2c54c97d594c2232d68f4",
+    "epostix/_generated/__init__.py": "64747d64d6dc44e816b417cd4dd4f9d50643c3ef1f2931d6dc1fa2d6396e87ef"
+  }
+}

epostix-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,105 @@
+name: ci
+
+on:
+  pull_request:
+  push:
+    branches: ["**"]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  contract:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: the vendored spec must match the codegen manifest
+        run: |
+          expected=$(python3 -c "import json;print(json.load(open('.codegen.json'))['spec']['raw_sha256'])")
+          actual=$(sha256sum openapi/developer-v1.yaml | cut -d' ' -f1)
+          if [ "$expected" != "$actual" ]; then
+            echo "the vendored spec does not match .codegen.json"
+            exit 1
+          fi
+      - name: generated files must not be hand-edited
+        run: |
+          python3 - <<'PY'
+          import hashlib, json, sys
+          manifest = json.load(open('.codegen.json'))
+          failures = 0
+          for path, expected in manifest['files'].items():
+              try:
+                  actual = hashlib.sha256(open(path, 'rb').read()).hexdigest()
+              except FileNotFoundError:
+                  print(f'missing generated file: {path}')
+                  failures += 1
+                  continue
+              if actual != expected:
+                  print(f'generated file was edited by hand: {path}')
+                  failures += 1
+          if failures:
+              sys.exit(1)
+          print(f"contract ok: {len(manifest['files'])} generated files")
+          PY
+
+  test:
+    needs: contract
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python }}
+      - run: pip install httpx pytest pytest-asyncio mypy
+      - run: python -m pytest -q
+      - run: python -m mypy --strict epostix
+
+  prerelease:
+    needs: contract
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.15"
+          allow-prereleases: true
+      - run: pip install httpx pytest pytest-asyncio
+      - run: python -m pytest -q
+
+  package:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - run: pip install build
+      - run: python -m build
+      - name: install the built wheel into a clean environment
+        run: |
+          python -m venv /tmp/smoke
+          /tmp/smoke/bin/pip install --quiet dist/*.whl
+          /tmp/smoke/bin/python -c "
+          import epostix
+          client = epostix.Epostix(api_key='tix_test_smoke')
+          assert callable(client.emails.send_email)
+          assert callable(client.templates.versions.list_template_versions)
+          assert callable(client.attachments.upload_attachment)
+          from epostix.webhooks import EpostixWebhookVerifier
+          assert EpostixWebhookVerifier is not None
+          print('install smoke ok')
+          "
+      - uses: actions/upload-artifact@v4
+        with:
+          name: distributions
+          path: dist/

epostix-1.0.0/.github/workflows/release.yml

@@ -0,0 +1,85 @@
+name: release
+
+on:
+  release:
+    types: [created]
+
+permissions:
+  contents: read
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ github.event.release.tag_name }}
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - run: pip install httpx pytest pytest-asyncio mypy
+      - run: python -m pytest -q
+      - run: python -m mypy --strict epostix
+      - name: the tag must match the project version
+        run: |
+          version=$(python3 -c "import tomllib;print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          tag="${{ github.event.release.tag_name }}"
+          if [ "v$version" != "$tag" ]; then
+            echo "pyproject.toml is $version but the tag is $tag"
+            exit 1
+          fi
+      - name: the tag must be a signed annotated tag
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          tag="${{ github.event.release.tag_name }}"
+          ref=$(gh api "repos/${{ github.repository }}/git/ref/tags/$tag")
+          kind=$(echo "$ref" | jq -r .object.type)
+          sha=$(echo "$ref" | jq -r .object.sha)
+
+          if [ "$kind" != "tag" ]; then
+            echo "$tag is a lightweight tag; a release must use a signed annotated tag"
+            exit 1
+          fi
+
+          object=$(gh api "repos/${{ github.repository }}/git/tags/$sha")
+          verified=$(echo "$object" | jq -r .verification.verified)
+          reason=$(echo "$object" | jq -r .verification.reason)
+
+          if [ "$verified" != "true" ]; then
+            echo "$tag is not a verified signed tag: $reason"
+            exit 1
+          fi
+
+          echo "$tag is signed and verified by GitHub ($reason)"
+
+  build:
+    needs: verify
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ github.event.release.tag_name }}
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - run: pip install build
+      - run: python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: distributions
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v5
+        with:
+          name: distributions
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

epostix-1.0.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+dist/
+build/

epostix-1.0.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.5
+Name: epostix
+Version: 1.0.0
+Summary: Epostix Developer API client
+Requires-Python: >=3.11
+Requires-Dist: httpx<1,>=0.27

epostix-1.0.0/conftest.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Iterator, Sequence, cast
+
+import httpx
+import pytest
+
+from epostix import AsyncEpostix, Epostix
+from epostix._codec import Codec
+from epostix._generated import codecs
+from epostix._retry import DISABLED_RETRY_POLICY, RetryPolicy
+
+FIXTURES = Path(__file__).parent / "tests" / "fixtures"
+
+BASE_URL = "https://api.epostix.test/v1"
+API_KEY = "tix_test_abcdef"
+
+def load_fixture(name: str) -> Any:
+    return json.loads((FIXTURES / f"{name}.json").read_text())
+
+
+def screaming(name: str) -> str:
+    name = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+    name = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", name)
+
+    return name.upper()
+
+
+def codec_for(type_name: str) -> Codec:
+    codec = getattr(codecs, "CODEC_" + screaming(type_name), None)
+
+    if codec is None:
+        raise AssertionError(f"no codec for fixture type {type_name}")
+
+    return cast(Codec, codec)
+
+
+@dataclass
+class Reply:
+    status: int = 200
+    body: Any = None
+    text: str | None = None
+    headers: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class Recorder:
+    replies: list[Reply]
+    requests: list[httpx.Request] = field(default_factory=list)
+
+    def __call__(self, request: httpx.Request) -> httpx.Response:
+        index = min(len(self.requests), len(self.replies) - 1)
+        self.requests.append(request)
+        reply = self.replies[index]
+
+        if reply.text is not None:
+            return httpx.Response(reply.status, text=reply.text, headers=reply.headers)
+
+        return httpx.Response(reply.status, json=reply.body, headers=reply.headers)
+
+    @property
+    def count(self) -> int:
+        return len(self.requests)
+
+    def query_of(self, index: int) -> dict[str, list[str]]:
+        params = self.requests[index].url.params
+
+        return {key: params.get_list(key) for key in params.keys()}
+
+
+@dataclass
+class Clients:
+    _closers: list[Callable[[], None]] = field(default_factory=list)
+
+    def sync(
+        self,
+        recorder: Recorder,
+        *,
+        retry_policy: RetryPolicy = DISABLED_RETRY_POLICY,
+        automatic_idempotency_keys: bool = True,
+    ) -> Epostix:
+        http = httpx.Client(transport=httpx.MockTransport(recorder))
+        self._closers.append(http.close)
+
+        return Epostix(
+            API_KEY,
+            base_url=BASE_URL,
+            http_client=http,
+            retry_policy=retry_policy,
+            automatic_idempotency_keys=automatic_idempotency_keys,
+        )
+
+    def asynchronous(
+        self,
+        recorder: Recorder,
+        *,
+        retry_policy: RetryPolicy = DISABLED_RETRY_POLICY,
+        automatic_idempotency_keys: bool = True,
+    ) -> AsyncEpostix:
+        http = httpx.AsyncClient(transport=httpx.MockTransport(recorder))
+
+        return AsyncEpostix(
+            API_KEY,
+            base_url=BASE_URL,
+            http_client=http,
+            retry_policy=retry_policy,
+            automatic_idempotency_keys=automatic_idempotency_keys,
+        )
+
+    def close(self) -> None:
+        for closer in self._closers:
+            closer()
+
+
+@pytest.fixture
+def clients() -> Iterator[Clients]:
+    built = Clients()
+    yield built
+    built.close()
+
+
+def replies(*items: Reply) -> list[Reply]:
+    return list(items)
+
+
+def pages(bodies: Sequence[Any]) -> list[Reply]:
+    return [Reply(status=200, body=body) for body in bodies]

epostix-1.0.0/epostix/__init__.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from . import attachments as attachments
+from . import batch as batch
+from . import models as models
+from . import overrides as overrides
+from . import webhooks as webhooks
+from ._client import (
+    DEDUPLICATION_SCOPE as DEDUPLICATION_SCOPE,
+)
+from ._client import (
+    PRODUCTION_BASE_URL as PRODUCTION_BASE_URL,
+)
+from ._client import (
+    SANDBOX_DOMAIN as SANDBOX_DOMAIN,
+)
+from ._client import (
+    STAGING_BASE_URL as STAGING_BASE_URL,
+)
+from ._client import (
+    AsyncEpostix as AsyncEpostix,
+)
+from ._client import (
+    Epostix as Epostix,
+)
+from ._client import (
+    KeyEnvironment as KeyEnvironment,
+)
+from ._client import (
+    key_environment_of as key_environment_of,
+)
+from ._codec import (
+    EpostixDecodeError as EpostixDecodeError,
+)
+from ._codec import (
+    is_known_enum_value as is_known_enum_value,
+)
+from ._errors import (
+    EpostixAccountSuspendedError as EpostixAccountSuspendedError,
+)
+from ._errors import (
+    EpostixAPIError as EpostixAPIError,
+)
+from ._errors import (
+    EpostixAuthenticationError as EpostixAuthenticationError,
+)
+from ._errors import (
+    EpostixConfigurationError as EpostixConfigurationError,
+)
+from ._errors import (
+    EpostixConflictError as EpostixConflictError,
+)
+from ._errors import (
+    EpostixContentError as EpostixContentError,
+)
+from ._errors import (
+    EpostixError as EpostixError,
+)
+from ._errors import (
+    EpostixErrorType as EpostixErrorType,
+)
+from ._errors import (
+    EpostixIdempotencyConflictError as EpostixIdempotencyConflictError,
+)
+from ._errors import (
+    EpostixIdempotencyInProgressError as EpostixIdempotencyInProgressError,
+)
+from ._errors import (
+    EpostixInvalidRequestError as EpostixInvalidRequestError,
+)
+from ._errors import (
+    EpostixNotFoundError as EpostixNotFoundError,
+)
+from ._errors import (
+    EpostixOutcomeUnknownError as EpostixOutcomeUnknownError,
+)
+from ._errors import (
+    EpostixPaginationError as EpostixPaginationError,
+)
+from ._errors import (
+    EpostixPermissionError as EpostixPermissionError,
+)
+from ._errors import (
+    EpostixQuotaExceededError as EpostixQuotaExceededError,
+)
+from ._errors import (
+    EpostixRateLimitError as EpostixRateLimitError,
+)
+from ._errors import (
+    EpostixServerError as EpostixServerError,
+)
+from ._errors import (
+    EpostixTimeoutError as EpostixTimeoutError,
+)
+from ._errors import (
+    EpostixTransportError as EpostixTransportError,
+)
+from ._errors import (
+    EpostixValidationError as EpostixValidationError,
+)
+from ._errors import (
+    EpostixWebhookVerificationError as EpostixWebhookVerificationError,
+)
+from ._errors import (
+    FieldError as FieldError,
+)
+from ._errors import (
+    PaginationFailureReason as PaginationFailureReason,
+)
+from ._errors import (
+    QuotaPeriod as QuotaPeriod,
+)
+from ._errors import (
+    TimeoutPhase as TimeoutPhase,
+)
+from ._errors import (
+    WebhookFailureReason as WebhookFailureReason,
+)
+from ._mailbox import (
+    Mailbox as Mailbox,
+)
+from ._mailbox import (
+    addr as addr,
+)
+from ._mailbox import (
+    named as named,
+)
+from ._model import (
+    Model as Model,
+)
+from ._model import (
+    response_metadata_of as response_metadata_of,
+)
+from ._model import (
+    unknown_fields_of as unknown_fields_of,
+)
+from ._pagination import (
+    AsyncPaginator as AsyncPaginator,
+)
+from ._pagination import (
+    Collection as Collection,
+)
+from ._pagination import (
+    Page as Page,
+)
+from ._pagination import (
+    Paginator as Paginator,
+)
+from ._response import (
+    AttemptRecord as AttemptRecord,
+)
+from ._response import (
+    RateLimitSnapshot as RateLimitSnapshot,
+)
+from ._response import (
+    ResponseMetadata as ResponseMetadata,
+)
+from ._response import (
+    RetriesExhaustedReason as RetriesExhaustedReason,
+)
+from ._retry import (
+    BATCH_RETRY_POLICY as BATCH_RETRY_POLICY,
+)
+from ._retry import (
+    DEFAULT_RETRY_POLICY as DEFAULT_RETRY_POLICY,
+)
+from ._retry import (
+    DISABLED_RETRY_POLICY as DISABLED_RETRY_POLICY,
+)
+from ._retry import (
+    UPLOAD_RETRY_POLICY as UPLOAD_RETRY_POLICY,
+)
+from ._retry import (
+    MutationRetryMode as MutationRetryMode,
+)
+from ._retry import (
+    RetryClass as RetryClass,
+)
+from ._retry import (
+    RetryPolicy as RetryPolicy,
+)
+from ._transport import (
+    IDEMPOTENCY_KEY_MAXIMUM_LENGTH as IDEMPOTENCY_KEY_MAXIMUM_LENGTH,
+)
+from ._transport import (
+    IDEMPOTENCY_RETENTION_HOURS as IDEMPOTENCY_RETENTION_HOURS,
+)
+from ._transport import (
+    OperationSpec as OperationSpec,
+)
+from ._transport import (
+    RequestOptions as RequestOptions,
+)
+from .attachments import (
+    ATTACHMENT_DECODED_LIMIT_BYTES as ATTACHMENT_DECODED_LIMIT_BYTES,
+)
+from .attachments import (
+    REQUEST_BODY_LIMIT_BYTES as REQUEST_BODY_LIMIT_BYTES,
+)
+from .attachments import (
+    EpostixAttachmentTooLargeError as EpostixAttachmentTooLargeError,
+)
+from .attachments import (
+    EpostixRequestTooLargeError as EpostixRequestTooLargeError,
+)
+from ._types import (
+    NOT_GIVEN as NOT_GIVEN,
+)
+from ._types import (
+    JsonValue as JsonValue,
+)
+from ._types import (
+    NotGiven as NotGiven,
+)
+
+from .overrides import (
+    AsyncRawContent as AsyncRawContent,
+)
+from .overrides import (
+    RawContent as RawContent,
+)
+
+__version__ = "1.0.0"