pingram-python 0.1.0__py3-none-any.whl

pingram/api_response.py

@@ -0,0 +1,21 @@
+"""API response object."""
+
+from __future__ import annotations
+from typing import Optional, Generic, Mapping, TypeVar
+from pydantic import Field, StrictInt, StrictBytes, BaseModel
+
+T = TypeVar("T")
+
+class ApiResponse(BaseModel, Generic[T]):
+    """
+    API response object
+    """
+
+    status_code: StrictInt = Field(description="HTTP status code")
+    headers: Optional[Mapping[str, str]] = Field(None, description="HTTP headers")
+    data: T = Field(description="Deserialized data given the data type")
+    raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
+
+    model_config = {
+        "arbitrary_types_allowed": True
+    }

pingram/client_wrapper.py

@@ -0,0 +1,357 @@
+# This file is auto-generated by tools/sdk-codegen/generate-python-wrapper.ts
+# DO NOT EDIT MANUALLY - changes will be overwritten
+# Edit sdks/python/templates/client_wrapper.mustache instead
+
+from __future__ import annotations
+
+from typing import Literal, Optional, TypedDict, Union
+
+
+from .api.account_api import AccountApi
+
+from .api.addresses_api import AddressesApi
+
+from .api.components_api import ComponentsApi
+
+from .api.default_api import DefaultApi
+
+from .api.domains_api import DomainsApi
+
+from .api.editor_api import EditorApi
+
+from .api.environments_api import EnvironmentsApi
+
+from .api.health_api import HealthApi
+
+from .api.insights_api import InsightsApi
+
+from .api.keys_api import KeysApi
+
+from .api.logs_api import LogsApi
+
+from .api.members_api import MembersApi
+
+from .api.sender_api import SenderApi
+
+from .api.templates_api import TemplatesApi
+
+from .api.types_api import TypesApi
+
+from .api.user_api import UserApi
+
+from .api.users_api import UsersApi
+
+from .api_client import ApiClient
+from .configuration import Configuration
+from .models.sender_post_body import SenderPostBody
+from .models.sender_post_response import SenderPostResponse
+
+PingramRegion = Literal["us", "eu", "ca"]
+
+
+class PingramConfig(TypedDict, total=False):
+    """Configuration options for the Pingram client."""
+
+    api_key: str
+    region: PingramRegion
+    base_url: Optional[str]
+
+
+_REGION_BASE_URLS: dict[PingramRegion, str] = {
+    "us": "https://api.pingram.io",
+    "eu": "https://api.eu.pingram.io",
+    "ca": "https://api.ca.pingram.io",
+}
+
+
+def get_region_base_url(region: PingramRegion = "us") -> str:
+    """Return the base URL for the given region."""
+    return _REGION_BASE_URLS[region]
+
+
+class Pingram:
+    """
+    Pingram client: high-level wrapper over the generated API client.
+
+    Use as an async context manager so the HTTP client is opened and closed correctly:
+
+        async with Pingram(api_key="pingram_sk_...") as client:
+            await client.send(sender_post_body=body)
+            user = await client.user.user_get_user(account_id="...", user_id="...")
+    """
+
+    def __init__(
+        self,
+        config_or_api_key: Optional[Union[PingramConfig, str]] = None,
+        region: PingramRegion = "us",
+        base_url: Optional[str] = None,
+        *,
+        api_key: Optional[str] = None,
+    ):
+        """
+        Initialize the Pingram client.
+
+        :param config_or_api_key: Optional. Either an API key string (e.g. pingram_sk_...) or a config dict with "api_key", optional "region", optional "base_url".
+        :param region: Region: "us", "eu", or "ca". Default "us".
+        :param base_url: Override base URL (ignores region if set).
+        :param api_key: Optional keyword. API key (e.g. pingram_sk_...) or JWT. Use this or pass as first positional arg.
+        """
+        if api_key is not None:
+            config_or_api_key = api_key
+        if config_or_api_key is None:
+            raise ValueError("api_key or config must be provided")
+        if isinstance(config_or_api_key, dict):
+            api_key_val = config_or_api_key.get("api_key") or ""
+            region = config_or_api_key.get("region", "us")
+            base_url = config_or_api_key.get("base_url") or base_url
+        else:
+            api_key_val = config_or_api_key or ""
+        if not api_key_val:
+            raise ValueError("api_key must be provided")
+
+        host = base_url if base_url else get_region_base_url(region)
+        self._configuration = Configuration(host=host, access_token=api_key_val)
+        self._api_client: Optional[ApiClient] = None
+
+        self._account: Optional[AccountApi] = None
+
+        self._addresses: Optional[AddressesApi] = None
+
+        self._components: Optional[ComponentsApi] = None
+
+        self._default_api: Optional[DefaultApi] = None
+
+        self._domains: Optional[DomainsApi] = None
+
+        self._editor: Optional[EditorApi] = None
+
+        self._environments: Optional[EnvironmentsApi] = None
+
+        self._health: Optional[HealthApi] = None
+
+        self._insights: Optional[InsightsApi] = None
+
+        self._keys: Optional[KeysApi] = None
+
+        self._logs: Optional[LogsApi] = None
+
+        self._members: Optional[MembersApi] = None
+
+        self._sender: Optional[SenderApi] = None
+
+        self._templates: Optional[TemplatesApi] = None
+
+        self._types: Optional[TypesApi] = None
+
+        self._user: Optional[UserApi] = None
+
+        self._users: Optional[UsersApi] = None
+
+
+    async def __aenter__(self) -> Pingram:
+        self._api_client = ApiClient(self._configuration)
+        await self._api_client.__aenter__()
+
+        self._account = AccountApi(self._api_client)
+
+        self._addresses = AddressesApi(self._api_client)
+
+        self._components = ComponentsApi(self._api_client)
+
+        self._default_api = DefaultApi(self._api_client)
+
+        self._domains = DomainsApi(self._api_client)
+
+        self._editor = EditorApi(self._api_client)
+
+        self._environments = EnvironmentsApi(self._api_client)
+
+        self._health = HealthApi(self._api_client)
+
+        self._insights = InsightsApi(self._api_client)
+
+        self._keys = KeysApi(self._api_client)
+
+        self._logs = LogsApi(self._api_client)
+
+        self._members = MembersApi(self._api_client)
+
+        self._sender = SenderApi(self._api_client)
+
+        self._templates = TemplatesApi(self._api_client)
+
+        self._types = TypesApi(self._api_client)
+
+        self._user = UserApi(self._api_client)
+
+        self._users = UsersApi(self._api_client)
+
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        if self._api_client is not None:
+            await self._api_client.__aexit__(exc_type, exc_val, exc_tb)
+            self._api_client = None
+
+        self._account = None
+
+        self._addresses = None
+
+        self._components = None
+
+        self._default_api = None
+
+        self._domains = None
+
+        self._editor = None
+
+        self._environments = None
+
+        self._health = None
+
+        self._insights = None
+
+        self._keys = None
+
+        self._logs = None
+
+        self._members = None
+
+        self._sender = None
+
+        self._templates = None
+
+        self._types = None
+
+        self._user = None
+
+        self._users = None
+
+
+
+    @property
+    def account(self) -> AccountApi:
+        if self._account is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._account
+
+
+    @property
+    def addresses(self) -> AddressesApi:
+        if self._addresses is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._addresses
+
+
+    @property
+    def components(self) -> ComponentsApi:
+        if self._components is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._components
+
+
+    @property
+    def default_api(self) -> DefaultApi:
+        if self._default_api is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._default_api
+
+
+    @property
+    def domains(self) -> DomainsApi:
+        if self._domains is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._domains
+
+
+    @property
+    def editor(self) -> EditorApi:
+        if self._editor is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._editor
+
+
+    @property
+    def environments(self) -> EnvironmentsApi:
+        if self._environments is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._environments
+
+
+    @property
+    def health(self) -> HealthApi:
+        if self._health is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._health
+
+
+    @property
+    def insights(self) -> InsightsApi:
+        if self._insights is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._insights
+
+
+    @property
+    def keys(self) -> KeysApi:
+        if self._keys is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._keys
+
+
+    @property
+    def logs(self) -> LogsApi:
+        if self._logs is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._logs
+
+
+    @property
+    def members(self) -> MembersApi:
+        if self._members is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._members
+
+
+    @property
+    def sender(self) -> SenderApi:
+        if self._sender is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._sender
+
+
+    @property
+    def templates(self) -> TemplatesApi:
+        if self._templates is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._templates
+
+
+    @property
+    def types(self) -> TypesApi:
+        if self._types is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._types
+
+
+    @property
+    def user(self) -> UserApi:
+        if self._user is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._user
+
+
+    @property
+    def users(self) -> UsersApi:
+        if self._users is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return self._users
+
+
+
+    async def send(self, sender_post_body: SenderPostBody) -> SenderPostResponse:
+        """Send a notification. Delegates to DefaultApi.send."""
+        if self._default_api is None:
+            raise RuntimeError("Pingram must be used as async context manager: async with Pingram(...) as client:")
+        return await self._default_api.send(sender_post_body=sender_post_body)
+