thrustlab 0.1.0__py3-none-any.whl

thrustlab/__init__.py

@@ -0,0 +1,23 @@
+"""ThrustLab — official Python SDK for the ThrustLab API.
+
+See https://thrustlab.com/docs/sdk/python for usage.
+"""
+
+from thrustlab._version import __version__
+from thrustlab.client import Client
+from thrustlab.exceptions import (
+    APIError, APIServerError, AuthenticationError, ConfigurationError,
+    ConflictError, ForbiddenError, NetworkError, NotFoundError, RateLimitError,
+    SignatureVerificationError, ThrustlabError, ValidationError,
+)
+from thrustlab.webhooks import Event, Webhook
+
+__all__ = [
+    "__version__",
+    "Client",
+    "APIError", "APIServerError", "AuthenticationError", "ConfigurationError",
+    "ConflictError", "ForbiddenError", "NetworkError", "NotFoundError",
+    "RateLimitError", "SignatureVerificationError", "ThrustlabError",
+    "ValidationError",
+    "Event", "Webhook",
+]

thrustlab/_async_polling.py

@@ -0,0 +1,47 @@
+"""Polling helpers for async resources (simulations, sweeps).
+
+The terminal states are: 'succeeded' | 'failed' | 'cancelled'.
+'timed_out' is an SDK-side sentinel set when wait() exceeds its timeout budget
+— it is never returned by the server.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Callable
+
+TERMINAL_STATES = {"succeeded", "failed", "cancelled"}
+
+
+def poll_until_terminal(
+    fetch: Callable[[], dict[str, Any]],
+    *,
+    timeout: float = 600.0,
+    poll_interval: float = 2.0,
+) -> dict[str, Any]:
+    """Poll ``fetch`` until the returned object reaches a terminal state.
+
+    Args:
+        fetch: Zero-argument callable that returns the latest resource dict.
+        timeout: Maximum seconds to wait. If exceeded, returns the last dict
+                 with ``status`` set to ``"timed_out"``.
+        poll_interval: Seconds between polls (``time.sleep``).
+
+    Returns:
+        The resource dict when status is in ``TERMINAL_STATES``, or a copy
+        with ``status="timed_out"`` if the deadline was exceeded.
+    """
+    deadline = time.monotonic() + timeout
+    attempt = 0
+    while True:
+        obj = fetch()
+        status = obj.get("status")
+        if status in TERMINAL_STATES:
+            return obj
+        if time.monotonic() >= deadline:
+            obj = dict(obj)
+            obj["status"] = "timed_out"
+            return obj
+        sleep_for = min(poll_interval * (2 ** attempt), 30.0)
+        time.sleep(sleep_for)
+        attempt += 1

thrustlab/_http.py

@@ -0,0 +1,166 @@
+"""Internal HTTP transport for the ThrustLab SDK.
+
+Wraps httpx.Client with auth, idempotency-key generation, retries with
+exponential backoff + jitter, and error-envelope → exception mapping.
+"""
+
+from __future__ import annotations
+
+import logging
+import platform
+import random
+import time
+import uuid
+from typing import Any, Optional
+
+import httpx
+
+from thrustlab._version import __version__
+from thrustlab.exceptions import (
+    APIError, NetworkError, RateLimitError, from_response_status,
+)
+
+
+logger = logging.getLogger("thrustlab")
+
+
+def _user_agent() -> str:
+    return (
+        f"thrustlab-python/{__version__} "
+        f"(Python/{platform.python_version()}; {platform.system()})"
+    )
+
+
+_RETRYABLE_STATUSES = {429, 500, 502, 503, 504}
+_MUTATING_METHODS = {"POST", "PUT", "PATCH", "DELETE"}
+
+
+class Transport:
+    """HTTP transport for the SDK Client.
+
+    Responsibilities:
+      - inject Authorization + User-Agent on every request
+      - auto-generate Idempotency-Key on every mutating request unless caller passes one
+      - retry on 429 + 5xx + connection errors with exponential backoff + jitter
+      - map error responses to the right APIError subclass
+      - parse JSON responses
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+        client: Optional[httpx.Client] = None,
+    ) -> None:
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._client = client or httpx.Client(timeout=timeout)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Any:
+        url = self._base_url + path
+        headers = {
+            "Authorization": f"Bearer {self._api_key}",
+            "User-Agent": _user_agent(),
+            "Accept": "application/json",
+        }
+        if json is not None:
+            headers["Content-Type"] = "application/json"
+        if method.upper() in _MUTATING_METHODS:
+            headers["Idempotency-Key"] = idempotency_key or str(uuid.uuid4())
+
+        last_exc: Optional[Exception] = None
+        for attempt in range(self._max_retries + 1):
+            try:
+                resp = self._client.request(method, url, params=params, json=json, headers=headers)
+            except httpx.HTTPError as exc:
+                net_err = NetworkError(f"network error: {exc}")
+                net_err.__cause__ = exc
+                last_exc = net_err
+                if attempt < self._max_retries:
+                    self._sleep(attempt, retry_after=None)
+                    continue
+                raise last_exc
+            else:
+                if resp.status_code in _RETRYABLE_STATUSES and attempt < self._max_retries:
+                    retry_after = _parse_retry_after(resp)
+                    self._sleep(attempt, retry_after=retry_after)
+                    continue
+                return self._handle_response(resp)
+
+        # Unreachable in practice (loop returns or raises), but pacifies type checker.
+        if last_exc is not None:
+            raise last_exc
+        raise NetworkError("unreachable: exhausted retries with no exception")
+
+    def _sleep(self, attempt: int, retry_after: Optional[float]) -> None:
+        if retry_after is not None:
+            delay = retry_after
+        else:
+            base = 0.5 * (2 ** attempt)
+            jitter = random.uniform(0, 0.5)
+            delay = base + jitter
+        logger.debug("thrustlab: retrying after %.2fs (attempt %d)", delay, attempt + 1)
+        time.sleep(delay)
+
+    def _handle_response(self, resp: httpx.Response) -> Any:
+        if 200 <= resp.status_code < 300:
+            if resp.status_code == 204 or not resp.content:
+                return None
+            return resp.json()
+
+        # Error path. Parse envelope: { "error": { "type": ..., "code": ..., "message": ..., "param": ... } }.
+        request_id = resp.headers.get("X-Request-ID")
+        body: dict[str, Any] = {}
+        try:
+            body = resp.json()
+        except ValueError:
+            pass
+        env = body.get("error", {}) if isinstance(body, dict) else {}
+
+        kwargs = dict(
+            code=env.get("code"),
+            type=env.get("type"),
+            request_id=request_id,
+            http_status=resp.status_code,
+            param=env.get("param"),
+        )
+        message = env.get("message") or f"HTTP {resp.status_code}"
+
+        cls = from_response_status(resp.status_code)
+        if cls is RateLimitError:
+            return self._raise_rate_limit(message, kwargs, resp)
+        raise cls(message, **kwargs)
+
+    def _raise_rate_limit(self, message: str, kwargs: dict[str, Any], resp: httpx.Response) -> None:
+        retry_after = _parse_retry_after(resp)
+        raise RateLimitError(message, retry_after=retry_after, **kwargs)
+
+
+def _parse_retry_after(resp: httpx.Response) -> Optional[float]:
+    raw = resp.headers.get("Retry-After")
+    if not raw:
+        return None
+    try:
+        return float(raw)
+    except (TypeError, ValueError):
+        pass
+    try:
+        from email.utils import parsedate_to_datetime
+        dt = parsedate_to_datetime(raw)
+        if dt is not None:
+            delta = dt.timestamp() - time.time()
+            return max(0.0, delta)
+    except (TypeError, ValueError):
+        pass
+    return None

thrustlab/_models/__init__.py

@@ -0,0 +1,211 @@
+"""Contains all the data models used in inputs/outputs"""
+
+from thrustlab._models.api_key import ApiKey
+from thrustlab._models.api_key_create import ApiKeyCreate
+from thrustlab._models.api_key_with_secret import ApiKeyWithSecret
+from thrustlab._models.billing_portal_session_resource import BillingPortalSessionResource
+from thrustlab._models.checkout_session_resource import CheckoutSessionResource
+from thrustlab._models.component_brand import ComponentBrand
+from thrustlab._models.component_brands_response import ComponentBrandsResponse
+from thrustlab._models.component_create_body import ComponentCreateBody
+from thrustlab._models.component_create_body_spec_json import ComponentCreateBodySpecJson
+from thrustlab._models.component_list_response import ComponentListResponse
+from thrustlab._models.component_patch import ComponentPatch
+from thrustlab._models.component_patch_spec_json_type_0 import ComponentPatchSpecJsonType0
+from thrustlab._models.component_resource import ComponentResource
+from thrustlab._models.component_resource_spec_json import ComponentResourceSpecJson
+from thrustlab._models.create_webhook_endpoint_v1_webhook_endpoints_post_response_create_webhook_endpoint_v1_webhook_endpoints_post import (
+    CreateWebhookEndpointV1WebhookEndpointsPostResponseCreateWebhookEndpointV1WebhookEndpointsPost,
+)
+from thrustlab._models.credit_balance_resource import CreditBalanceResource
+from thrustlab._models.credit_bucket_breakdown import CreditBucketBreakdown
+from thrustlab._models.credit_bucket_breakdown_type import CreditBucketBreakdownType
+from thrustlab._models.credit_usage_event_resource import CreditUsageEventResource
+from thrustlab._models.credit_usage_event_resource_credit_type import CreditUsageEventResourceCreditType
+from thrustlab._models.credit_usage_event_resource_type import CreditUsageEventResourceType
+from thrustlab._models.credit_usage_list_response import CreditUsageListResponse
+from thrustlab._models.credit_usage_related_resource import CreditUsageRelatedResource
+from thrustlab._models.credit_usage_related_resource_object import CreditUsageRelatedResourceObject
+from thrustlab._models.fire_test_event_v1_webhook_endpoints_public_id_test_post_response_fire_test_event_v1_webhook_endpoints_public_id_test_post import (
+    FireTestEventV1WebhookEndpointsPublicIdTestPostResponseFireTestEventV1WebhookEndpointsPublicIdTestPost,
+)
+from thrustlab._models.get_delivery_v1_webhook_endpoints_public_id_deliveries_delivery_public_id_get_response_get_delivery_v1_webhook_endpoints_public_id_deliveries_delivery_public_id_get import (
+    GetDeliveryV1WebhookEndpointsPublicIdDeliveriesDeliveryPublicIdGetResponseGetDeliveryV1WebhookEndpointsPublicIdDeliveriesDeliveryPublicIdGet,
+)
+from thrustlab._models.get_event_v1_events_event_id_get_response_get_event_v1_events_event_id_get import (
+    GetEventV1EventsEventIdGetResponseGetEventV1EventsEventIdGet,
+)
+from thrustlab._models.get_webhook_endpoint_v1_webhook_endpoints_public_id_get_response_get_webhook_endpoint_v1_webhook_endpoints_public_id_get import (
+    GetWebhookEndpointV1WebhookEndpointsPublicIdGetResponseGetWebhookEndpointV1WebhookEndpointsPublicIdGet,
+)
+from thrustlab._models.http_validation_error import HTTPValidationError
+from thrustlab._models.list_deliveries_v1_webhook_endpoints_public_id_deliveries_get_response_list_deliveries_v1_webhook_endpoints_public_id_deliveries_get import (
+    ListDeliveriesV1WebhookEndpointsPublicIdDeliveriesGetResponseListDeliveriesV1WebhookEndpointsPublicIdDeliveriesGet,
+)
+from thrustlab._models.list_events_v1_events_get_response_list_events_v1_events_get import (
+    ListEventsV1EventsGetResponseListEventsV1EventsGet,
+)
+from thrustlab._models.list_response_api_key import ListResponseApiKey
+from thrustlab._models.list_webhook_endpoints_v1_webhook_endpoints_get_response_list_webhook_endpoints_v1_webhook_endpoints_get import (
+    ListWebhookEndpointsV1WebhookEndpointsGetResponseListWebhookEndpointsV1WebhookEndpointsGet,
+)
+from thrustlab._models.patch_webhook_endpoint_v1_webhook_endpoints_public_id_patch_response_patch_webhook_endpoint_v1_webhook_endpoints_public_id_patch import (
+    PatchWebhookEndpointV1WebhookEndpointsPublicIdPatchResponsePatchWebhookEndpointV1WebhookEndpointsPublicIdPatch,
+)
+from thrustlab._models.portal_session_in import PortalSessionIn
+from thrustlab._models.project_create_body import ProjectCreateBody
+from thrustlab._models.project_list_response import ProjectListResponse
+from thrustlab._models.project_patch import ProjectPatch
+from thrustlab._models.project_resource import ProjectResource
+from thrustlab._models.retry_delivery_v1_webhook_endpoints_public_id_deliveries_delivery_public_id_retry_post_response_retry_delivery_v1_webhook_endpoints_public_id_deliveries_delivery_public_id_retry_post import (
+    RetryDeliveryV1WebhookEndpointsPublicIdDeliveriesDeliveryPublicIdRetryPostResponseRetryDeliveryV1WebhookEndpointsPublicIdDeliveriesDeliveryPublicIdRetryPost,
+)
+from thrustlab._models.rotate_webhook_secret_v1_webhook_endpoints_public_id_rotate_secret_post_response_rotate_webhook_secret_v1_webhook_endpoints_public_id_rotate_secret_post import (
+    RotateWebhookSecretV1WebhookEndpointsPublicIdRotateSecretPostResponseRotateWebhookSecretV1WebhookEndpointsPublicIdRotateSecretPost,
+)
+from thrustlab._models.rotor_group_in import RotorGroupIn
+from thrustlab._models.rotor_group_resource import RotorGroupResource
+from thrustlab._models.simulation_cancel_body import SimulationCancelBody
+from thrustlab._models.simulation_create_body import SimulationCreateBody
+from thrustlab._models.simulation_inputs import SimulationInputs
+from thrustlab._models.simulation_list_response import SimulationListResponse
+from thrustlab._models.simulation_patch import SimulationPatch
+from thrustlab._models.simulation_patch_plot_config_json_type_0_item import SimulationPatchPlotConfigJsonType0Item
+from thrustlab._models.simulation_resource import SimulationResource
+from thrustlab._models.simulation_resource_error_type_0 import SimulationResourceErrorType0
+from thrustlab._models.simulation_resource_plot_config_json_type_0_item import SimulationResourcePlotConfigJsonType0Item
+from thrustlab._models.simulation_resource_result_type_0 import SimulationResourceResultType0
+from thrustlab._models.starred_component_create_body import StarredComponentCreateBody
+from thrustlab._models.starred_component_list_response import StarredComponentListResponse
+from thrustlab._models.starred_component_resource import StarredComponentResource
+from thrustlab._models.submission_create_body import SubmissionCreateBody
+from thrustlab._models.submission_create_body_data_json import SubmissionCreateBodyDataJson
+from thrustlab._models.submission_list_response import SubmissionListResponse
+from thrustlab._models.submission_patch import SubmissionPatch
+from thrustlab._models.submission_patch_data_json_type_0 import SubmissionPatchDataJsonType0
+from thrustlab._models.submission_resource import SubmissionResource
+from thrustlab._models.submission_resource_data_json import SubmissionResourceDataJson
+from thrustlab._models.subscription_create import SubscriptionCreate
+from thrustlab._models.subscription_resource import SubscriptionResource
+from thrustlab._models.subscription_resource_status import SubscriptionResourceStatus
+from thrustlab._models.subscription_resource_tier import SubscriptionResourceTier
+from thrustlab._models.sweep_cancel_body import SweepCancelBody
+from thrustlab._models.sweep_config_in import SweepConfigIn
+from thrustlab._models.sweep_create_body import SweepCreateBody
+from thrustlab._models.sweep_inputs import SweepInputs
+from thrustlab._models.sweep_list_response import SweepListResponse
+from thrustlab._models.sweep_param_range_in import SweepParamRangeIn
+from thrustlab._models.sweep_param_range_in_mode import SweepParamRangeInMode
+from thrustlab._models.sweep_patch import SweepPatch
+from thrustlab._models.sweep_patch_plot_config_json_type_0_item import SweepPatchPlotConfigJsonType0Item
+from thrustlab._models.sweep_point_list_response import SweepPointListResponse
+from thrustlab._models.sweep_point_resource import SweepPointResource
+from thrustlab._models.sweep_point_resource_inputs import SweepPointResourceInputs
+from thrustlab._models.sweep_point_resource_rotors_type_0 import SweepPointResourceRotorsType0
+from thrustlab._models.sweep_resource import SweepResource
+from thrustlab._models.sweep_resource_error_type_0 import SweepResourceErrorType0
+from thrustlab._models.sweep_resource_plot_config_json_type_0_item import SweepResourcePlotConfigJsonType0Item
+from thrustlab._models.sweep_resource_summary_type_0 import SweepResourceSummaryType0
+from thrustlab._models.sweep_resource_sweep_config_type_0 import SweepResourceSweepConfigType0
+from thrustlab._models.sweep_rotor_group_in import SweepRotorGroupIn
+from thrustlab._models.user_patch import UserPatch
+from thrustlab._models.user_resource import UserResource
+from thrustlab._models.v1_health_v1_health_get_response_v1_health_v1_health_get import V1HealthV1HealthGetResponseV1HealthV1HealthGet
+from thrustlab._models.validation_error import ValidationError
+from thrustlab._models.webhook_endpoint_create import WebhookEndpointCreate
+from thrustlab._models.webhook_endpoint_patch import WebhookEndpointPatch
+
+__all__ = (
+    "ApiKey",
+    "ApiKeyCreate",
+    "ApiKeyWithSecret",
+    "BillingPortalSessionResource",
+    "CheckoutSessionResource",
+    "ComponentBrand",
+    "ComponentBrandsResponse",
+    "ComponentCreateBody",
+    "ComponentCreateBodySpecJson",
+    "ComponentListResponse",
+    "ComponentPatch",
+    "ComponentPatchSpecJsonType0",
+    "ComponentResource",
+    "ComponentResourceSpecJson",
+    "CreateWebhookEndpointV1WebhookEndpointsPostResponseCreateWebhookEndpointV1WebhookEndpointsPost",
+    "CreditBalanceResource",
+    "CreditBucketBreakdown",
+    "CreditBucketBreakdownType",
+    "CreditUsageEventResource",
+    "CreditUsageEventResourceCreditType",
+    "CreditUsageEventResourceType",
+    "CreditUsageListResponse",
+    "CreditUsageRelatedResource",
+    "CreditUsageRelatedResourceObject",
+    "FireTestEventV1WebhookEndpointsPublicIdTestPostResponseFireTestEventV1WebhookEndpointsPublicIdTestPost",
+    "GetDeliveryV1WebhookEndpointsPublicIdDeliveriesDeliveryPublicIdGetResponseGetDeliveryV1WebhookEndpointsPublicIdDeliveriesDeliveryPublicIdGet",
+    "GetEventV1EventsEventIdGetResponseGetEventV1EventsEventIdGet",
+    "GetWebhookEndpointV1WebhookEndpointsPublicIdGetResponseGetWebhookEndpointV1WebhookEndpointsPublicIdGet",
+    "HTTPValidationError",
+    "ListDeliveriesV1WebhookEndpointsPublicIdDeliveriesGetResponseListDeliveriesV1WebhookEndpointsPublicIdDeliveriesGet",
+    "ListEventsV1EventsGetResponseListEventsV1EventsGet",
+    "ListResponseApiKey",
+    "ListWebhookEndpointsV1WebhookEndpointsGetResponseListWebhookEndpointsV1WebhookEndpointsGet",
+    "PatchWebhookEndpointV1WebhookEndpointsPublicIdPatchResponsePatchWebhookEndpointV1WebhookEndpointsPublicIdPatch",
+    "PortalSessionIn",
+    "ProjectCreateBody",
+    "ProjectListResponse",
+    "ProjectPatch",
+    "ProjectResource",
+    "RetryDeliveryV1WebhookEndpointsPublicIdDeliveriesDeliveryPublicIdRetryPostResponseRetryDeliveryV1WebhookEndpointsPublicIdDeliveriesDeliveryPublicIdRetryPost",
+    "RotateWebhookSecretV1WebhookEndpointsPublicIdRotateSecretPostResponseRotateWebhookSecretV1WebhookEndpointsPublicIdRotateSecretPost",
+    "RotorGroupIn",
+    "RotorGroupResource",
+    "SimulationCancelBody",
+    "SimulationCreateBody",
+    "SimulationInputs",
+    "SimulationListResponse",
+    "SimulationPatch",
+    "SimulationPatchPlotConfigJsonType0Item",
+    "SimulationResource",
+    "SimulationResourceErrorType0",
+    "SimulationResourcePlotConfigJsonType0Item",
+    "SimulationResourceResultType0",
+    "StarredComponentCreateBody",
+    "StarredComponentListResponse",
+    "StarredComponentResource",
+    "SubmissionCreateBody",
+    "SubmissionCreateBodyDataJson",
+    "SubmissionListResponse",
+    "SubmissionPatch",
+    "SubmissionPatchDataJsonType0",
+    "SubmissionResource",
+    "SubmissionResourceDataJson",
+    "SubscriptionCreate",
+    "SubscriptionResource",
+    "SubscriptionResourceStatus",
+    "SubscriptionResourceTier",
+    "SweepCancelBody",
+    "SweepConfigIn",
+    "SweepCreateBody",
+    "SweepInputs",
+    "SweepListResponse",
+    "SweepParamRangeIn",
+    "SweepParamRangeInMode",
+    "SweepPatch",
+    "SweepPatchPlotConfigJsonType0Item",
+    "SweepPointListResponse",
+    "SweepPointResource",
+    "SweepPointResourceInputs",
+    "SweepPointResourceRotorsType0",
+    "SweepResource",
+    "SweepResourceErrorType0",
+    "SweepResourcePlotConfigJsonType0Item",
+    "SweepResourceSummaryType0",
+    "SweepResourceSweepConfigType0",
+    "SweepRotorGroupIn",
+    "UserPatch",
+    "UserResource",
+    "V1HealthV1HealthGetResponseV1HealthV1HealthGet",
+    "ValidationError",
+    "WebhookEndpointCreate",
+    "WebhookEndpointPatch",
+)

thrustlab/_models/api_key.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from thrustlab._models.types import UNSET, Unset
+
+T = TypeVar("T", bound="ApiKey")
+
+
+@_attrs_define
+class ApiKey:
+    """API key resource as returned by LIST and GET.
+
+    NEVER includes the raw ``key`` field — that field only appears in the
+    POST response body via :class:`ApiKeyWithSecret` below.
+
+        Attributes:
+            created_at (datetime.datetime):
+            id (str):
+            key_prefix (str):
+            key_suffix (str):
+            last_used_at (datetime.datetime | None | Unset):
+            name (None | str | Unset):
+            object_ (Literal['api_key'] | Unset):  Default: 'api_key'.
+            revoked_at (datetime.datetime | None | Unset):
+    """
+
+    created_at: datetime.datetime
+    id: str
+    key_prefix: str
+    key_suffix: str
+    last_used_at: datetime.datetime | None | Unset = UNSET
+    name: None | str | Unset = UNSET
+    object_: Literal["api_key"] | Unset = "api_key"
+    revoked_at: datetime.datetime | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        id = self.id
+
+        key_prefix = self.key_prefix
+
+        key_suffix = self.key_suffix
+
+        last_used_at: None | str | Unset
+        if isinstance(self.last_used_at, Unset):
+            last_used_at = UNSET
+        elif isinstance(self.last_used_at, datetime.datetime):
+            last_used_at = self.last_used_at.isoformat()
+        else:
+            last_used_at = self.last_used_at
+
+        name: None | str | Unset
+        if isinstance(self.name, Unset):
+            name = UNSET
+        else:
+            name = self.name
+
+        object_ = self.object_
+
+        revoked_at: None | str | Unset
+        if isinstance(self.revoked_at, Unset):
+            revoked_at = UNSET
+        elif isinstance(self.revoked_at, datetime.datetime):
+            revoked_at = self.revoked_at.isoformat()
+        else:
+            revoked_at = self.revoked_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "created_at": created_at,
+                "id": id,
+                "key_prefix": key_prefix,
+                "key_suffix": key_suffix,
+            }
+        )
+        if last_used_at is not UNSET:
+            field_dict["last_used_at"] = last_used_at
+        if name is not UNSET:
+            field_dict["name"] = name
+        if object_ is not UNSET:
+            field_dict["object"] = object_
+        if revoked_at is not UNSET:
+            field_dict["revoked_at"] = revoked_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        created_at = isoparse(d.pop("created_at"))
+
+        id = d.pop("id")
+
+        key_prefix = d.pop("key_prefix")
+
+        key_suffix = d.pop("key_suffix")
+
+        def _parse_last_used_at(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_used_at_type_0 = isoparse(data)
+
+                return last_used_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        last_used_at = _parse_last_used_at(d.pop("last_used_at", UNSET))
+
+        def _parse_name(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        name = _parse_name(d.pop("name", UNSET))
+
+        object_ = cast(Literal["api_key"] | Unset, d.pop("object", UNSET))
+        if object_ != "api_key" and not isinstance(object_, Unset):
+            raise ValueError(f"object must match const 'api_key', got '{object_}'")
+
+        def _parse_revoked_at(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                revoked_at_type_0 = isoparse(data)
+
+                return revoked_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        revoked_at = _parse_revoked_at(d.pop("revoked_at", UNSET))
+
+        api_key = cls(
+            created_at=created_at,
+            id=id,
+            key_prefix=key_prefix,
+            key_suffix=key_suffix,
+            last_used_at=last_used_at,
+            name=name,
+            object_=object_,
+            revoked_at=revoked_at,
+        )
+
+        api_key.additional_properties = d
+        return api_key
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties