honeycomb-api 0.1.0__py3-none-any.whl

honeycomb/_generated/models/validation_error_type_detail_item_code.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class ValidationErrorTypeDetailItemCode(str, Enum):
+    ALREADY_EXISTS = "already_exists"
+    INCORRECT_TYPE = "incorrect_type"
+    INVALID = "invalid"
+    MISSING = "missing"
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/webhook_header.py

@@ -0,0 +1,81 @@
+from typing import Any, TypeVar, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="WebhookHeader")
+
+
+
+@_attrs_define
+class WebhookHeader:
+    """ 
+        Attributes:
+            header (str):
+            value (Union[Unset, str]):
+     """
+
+    header: str
+    value: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        header = self.header
+
+        value = self.value
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "header": header,
+        })
+        if value is not UNSET:
+            field_dict["value"] = value
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        header = d.pop("header")
+
+        value = d.pop("value", UNSET)
+
+        webhook_header = cls(
+            header=header,
+            value=value,
+        )
+
+
+        webhook_header.additional_properties = d
+        return webhook_header
+
+    @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

honeycomb/_generated/models/webhook_recipient.py

@@ -0,0 +1,160 @@
+from typing import Any, TypeVar, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.webhook_recipient_type import WebhookRecipientType
+from ..types import UNSET, Unset
+from dateutil.parser import isoparse
+from typing import cast
+from typing import Union
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.webhook_recipient_details import WebhookRecipientDetails
+
+
+
+
+
+T = TypeVar("T", bound="WebhookRecipient")
+
+
+
+@_attrs_define
+class WebhookRecipient:
+    """ 
+        Attributes:
+            id (Union[Unset, str]):  Example: yUheCUmgZ8p.
+            created_at (Union[Unset, datetime.datetime]): ISO8601 formatted time the Recipient was created. Example:
+                2022-07-26T22:38:04Z.
+            updated_at (Union[Unset, datetime.datetime]): ISO8601 formatted time the Recipient was updated. Example:
+                2022-07-26T22:38:04Z.
+            type_ (Union[Unset, WebhookRecipientType]): One of the supported Recipient Types
+            details (Union[Unset, WebhookRecipientDetails]): Specific schema for the Webhook Recipient Type
+     """
+
+    id: Union[Unset, str] = UNSET
+    created_at: Union[Unset, datetime.datetime] = UNSET
+    updated_at: Union[Unset, datetime.datetime] = UNSET
+    type_: Union[Unset, WebhookRecipientType] = UNSET
+    details: Union[Unset, 'WebhookRecipientDetails'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.webhook_recipient_details import WebhookRecipientDetails
+        id = self.id
+
+        created_at: Union[Unset, str] = UNSET
+        if not isinstance(self.created_at, Unset):
+            created_at = self.created_at.isoformat()
+
+        updated_at: Union[Unset, str] = UNSET
+        if not isinstance(self.updated_at, Unset):
+            updated_at = self.updated_at.isoformat()
+
+        type_: Union[Unset, str] = UNSET
+        if not isinstance(self.type_, Unset):
+            type_ = self.type_.value
+
+
+        details: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.details, Unset):
+            details = self.details.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if id is not UNSET:
+            field_dict["id"] = id
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+        if updated_at is not UNSET:
+            field_dict["updated_at"] = updated_at
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if details is not UNSET:
+            field_dict["details"] = details
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.webhook_recipient_details import WebhookRecipientDetails
+        d = src_dict.copy()
+        id = d.pop("id", UNSET)
+
+        _created_at = d.pop("created_at", UNSET)
+        created_at: Union[Unset, datetime.datetime]
+        if isinstance(_created_at,  Unset):
+            created_at = UNSET
+        else:
+            created_at = isoparse(_created_at)
+
+
+
+
+        _updated_at = d.pop("updated_at", UNSET)
+        updated_at: Union[Unset, datetime.datetime]
+        if isinstance(_updated_at,  Unset):
+            updated_at = UNSET
+        else:
+            updated_at = isoparse(_updated_at)
+
+
+
+
+        _type_ = d.pop("type", UNSET)
+        type_: Union[Unset, WebhookRecipientType]
+        if isinstance(_type_,  Unset):
+            type_ = UNSET
+        else:
+            type_ = WebhookRecipientType(_type_)
+
+
+
+
+        _details = d.pop("details", UNSET)
+        details: Union[Unset, WebhookRecipientDetails]
+        if isinstance(_details,  Unset):
+            details = UNSET
+        else:
+            details = WebhookRecipientDetails.from_dict(_details)
+
+
+
+
+        webhook_recipient = cls(
+            id=id,
+            created_at=created_at,
+            updated_at=updated_at,
+            type_=type_,
+            details=details,
+        )
+
+
+        webhook_recipient.additional_properties = d
+        return webhook_recipient
+
+    @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

honeycomb/_generated/models/webhook_recipient_details.py

@@ -0,0 +1,142 @@
+from typing import Any, TypeVar, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.webhook_header import WebhookHeader
+  from ..models.webhook_recipient_details_webhook_payloads import WebhookRecipientDetailsWebhookPayloads
+
+
+
+
+
+T = TypeVar("T", bound="WebhookRecipientDetails")
+
+
+
+@_attrs_define
+class WebhookRecipientDetails:
+    """ Specific schema for the Webhook Recipient Type
+
+        Attributes:
+            webhook_name (str): A name for this Integration. Example: Example webhook.
+            webhook_url (str): Webhook URL. Example: https://webhook.example.com.
+            webhook_headers (Union[Unset, list['WebhookHeader']]): Custom headers for this webhook Example: [{'header':
+                'Authorization', 'value': 'Bearer xyz123'}].
+            webhook_secret (Union[Unset, str]): Webhook secret. Example: secret.
+            webhook_payloads (Union[Unset, WebhookRecipientDetailsWebhookPayloads]): Specify a custom webhook payload.
+     """
+
+    webhook_name: str
+    webhook_url: str
+    webhook_headers: Union[Unset, list['WebhookHeader']] = UNSET
+    webhook_secret: Union[Unset, str] = UNSET
+    webhook_payloads: Union[Unset, 'WebhookRecipientDetailsWebhookPayloads'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.webhook_header import WebhookHeader
+        from ..models.webhook_recipient_details_webhook_payloads import WebhookRecipientDetailsWebhookPayloads
+        webhook_name = self.webhook_name
+
+        webhook_url = self.webhook_url
+
+        webhook_headers: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.webhook_headers, Unset):
+            webhook_headers = []
+            for webhook_headers_item_data in self.webhook_headers:
+                webhook_headers_item = webhook_headers_item_data.to_dict()
+                webhook_headers.append(webhook_headers_item)
+
+
+
+        webhook_secret = self.webhook_secret
+
+        webhook_payloads: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.webhook_payloads, Unset):
+            webhook_payloads = self.webhook_payloads.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "webhook_name": webhook_name,
+            "webhook_url": webhook_url,
+        })
+        if webhook_headers is not UNSET:
+            field_dict["webhook_headers"] = webhook_headers
+        if webhook_secret is not UNSET:
+            field_dict["webhook_secret"] = webhook_secret
+        if webhook_payloads is not UNSET:
+            field_dict["webhook_payloads"] = webhook_payloads
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.webhook_header import WebhookHeader
+        from ..models.webhook_recipient_details_webhook_payloads import WebhookRecipientDetailsWebhookPayloads
+        d = src_dict.copy()
+        webhook_name = d.pop("webhook_name")
+
+        webhook_url = d.pop("webhook_url")
+
+        webhook_headers = []
+        _webhook_headers = d.pop("webhook_headers", UNSET)
+        for webhook_headers_item_data in (_webhook_headers or []):
+            webhook_headers_item = WebhookHeader.from_dict(webhook_headers_item_data)
+
+
+
+            webhook_headers.append(webhook_headers_item)
+
+
+        webhook_secret = d.pop("webhook_secret", UNSET)
+
+        _webhook_payloads = d.pop("webhook_payloads", UNSET)
+        webhook_payloads: Union[Unset, WebhookRecipientDetailsWebhookPayloads]
+        if isinstance(_webhook_payloads,  Unset):
+            webhook_payloads = UNSET
+        else:
+            webhook_payloads = WebhookRecipientDetailsWebhookPayloads.from_dict(_webhook_payloads)
+
+
+
+
+        webhook_recipient_details = cls(
+            webhook_name=webhook_name,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            webhook_secret=webhook_secret,
+            webhook_payloads=webhook_payloads,
+        )
+
+
+        webhook_recipient_details.additional_properties = d
+        return webhook_recipient_details
+
+    @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

honeycomb/_generated/models/webhook_recipient_details_webhook_payloads.py

@@ -0,0 +1,117 @@
+from typing import Any, TypeVar, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.template_variable_definition import TemplateVariableDefinition
+  from ..models.webhook_recipient_details_webhook_payloads_payload_templates import WebhookRecipientDetailsWebhookPayloadsPayloadTemplates
+
+
+
+
+
+T = TypeVar("T", bound="WebhookRecipientDetailsWebhookPayloads")
+
+
+
+@_attrs_define
+class WebhookRecipientDetailsWebhookPayloads:
+    """ Specify a custom webhook payload.
+
+        Attributes:
+            template_variables (Union[Unset, list['TemplateVariableDefinition']]): Custom variable definitions for this
+                webhook Example: [{'name': 'severity', 'default_value': 'CRITICAL'}].
+            payload_templates (Union[Unset, WebhookRecipientDetailsWebhookPayloadsPayloadTemplates]):
+     """
+
+    template_variables: Union[Unset, list['TemplateVariableDefinition']] = UNSET
+    payload_templates: Union[Unset, 'WebhookRecipientDetailsWebhookPayloadsPayloadTemplates'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.template_variable_definition import TemplateVariableDefinition
+        from ..models.webhook_recipient_details_webhook_payloads_payload_templates import WebhookRecipientDetailsWebhookPayloadsPayloadTemplates
+        template_variables: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.template_variables, Unset):
+            template_variables = []
+            for template_variables_item_data in self.template_variables:
+                template_variables_item = template_variables_item_data.to_dict()
+                template_variables.append(template_variables_item)
+
+
+
+        payload_templates: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.payload_templates, Unset):
+            payload_templates = self.payload_templates.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if template_variables is not UNSET:
+            field_dict["template_variables"] = template_variables
+        if payload_templates is not UNSET:
+            field_dict["payload_templates"] = payload_templates
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.template_variable_definition import TemplateVariableDefinition
+        from ..models.webhook_recipient_details_webhook_payloads_payload_templates import WebhookRecipientDetailsWebhookPayloadsPayloadTemplates
+        d = src_dict.copy()
+        template_variables = []
+        _template_variables = d.pop("template_variables", UNSET)
+        for template_variables_item_data in (_template_variables or []):
+            template_variables_item = TemplateVariableDefinition.from_dict(template_variables_item_data)
+
+
+
+            template_variables.append(template_variables_item)
+
+
+        _payload_templates = d.pop("payload_templates", UNSET)
+        payload_templates: Union[Unset, WebhookRecipientDetailsWebhookPayloadsPayloadTemplates]
+        if isinstance(_payload_templates,  Unset):
+            payload_templates = UNSET
+        else:
+            payload_templates = WebhookRecipientDetailsWebhookPayloadsPayloadTemplates.from_dict(_payload_templates)
+
+
+
+
+        webhook_recipient_details_webhook_payloads = cls(
+            template_variables=template_variables,
+            payload_templates=payload_templates,
+        )
+
+
+        webhook_recipient_details_webhook_payloads.additional_properties = d
+        return webhook_recipient_details_webhook_payloads
+
+    @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

honeycomb/_generated/models/webhook_recipient_details_webhook_payloads_payload_templates.py

@@ -0,0 +1,126 @@
+from typing import Any, TypeVar, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.payload_template import PayloadTemplate
+
+
+
+
+
+T = TypeVar("T", bound="WebhookRecipientDetailsWebhookPayloadsPayloadTemplates")
+
+
+
+@_attrs_define
+class WebhookRecipientDetailsWebhookPayloadsPayloadTemplates:
+    """ 
+        Attributes:
+            trigger (Union[Unset, PayloadTemplate]):
+            budget_rate (Union[Unset, PayloadTemplate]):
+            exhaustion_time (Union[Unset, PayloadTemplate]):
+     """
+
+    trigger: Union[Unset, 'PayloadTemplate'] = UNSET
+    budget_rate: Union[Unset, 'PayloadTemplate'] = UNSET
+    exhaustion_time: Union[Unset, 'PayloadTemplate'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.payload_template import PayloadTemplate
+        trigger: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.trigger, Unset):
+            trigger = self.trigger.to_dict()
+
+        budget_rate: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.budget_rate, Unset):
+            budget_rate = self.budget_rate.to_dict()
+
+        exhaustion_time: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.exhaustion_time, Unset):
+            exhaustion_time = self.exhaustion_time.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if trigger is not UNSET:
+            field_dict["trigger"] = trigger
+        if budget_rate is not UNSET:
+            field_dict["budget_rate"] = budget_rate
+        if exhaustion_time is not UNSET:
+            field_dict["exhaustion_time"] = exhaustion_time
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.payload_template import PayloadTemplate
+        d = src_dict.copy()
+        _trigger = d.pop("trigger", UNSET)
+        trigger: Union[Unset, PayloadTemplate]
+        if isinstance(_trigger,  Unset):
+            trigger = UNSET
+        else:
+            trigger = PayloadTemplate.from_dict(_trigger)
+
+
+
+
+        _budget_rate = d.pop("budget_rate", UNSET)
+        budget_rate: Union[Unset, PayloadTemplate]
+        if isinstance(_budget_rate,  Unset):
+            budget_rate = UNSET
+        else:
+            budget_rate = PayloadTemplate.from_dict(_budget_rate)
+
+
+
+
+        _exhaustion_time = d.pop("exhaustion_time", UNSET)
+        exhaustion_time: Union[Unset, PayloadTemplate]
+        if isinstance(_exhaustion_time,  Unset):
+            exhaustion_time = UNSET
+        else:
+            exhaustion_time = PayloadTemplate.from_dict(_exhaustion_time)
+
+
+
+
+        webhook_recipient_details_webhook_payloads_payload_templates = cls(
+            trigger=trigger,
+            budget_rate=budget_rate,
+            exhaustion_time=exhaustion_time,
+        )
+
+
+        webhook_recipient_details_webhook_payloads_payload_templates.additional_properties = d
+        return webhook_recipient_details_webhook_payloads_payload_templates
+
+    @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

honeycomb/_generated/models/webhook_recipient_type.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class WebhookRecipientType(str, Enum):
+    WEBHOOK = "webhook"
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

honeycomb/_generated/types.py

@@ -0,0 +1,46 @@
+""" Contains some shared types for properties """
+
+from collections.abc import MutableMapping
+from http import HTTPStatus
+from typing import BinaryIO, Generic, Optional, TypeVar, Literal
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+FileJsonType = tuple[Optional[str], BinaryIO, Optional[str]]
+
+
+@define
+class File:
+    """ Contains information for file uploads """
+
+    payload: BinaryIO
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+
+    def to_tuple(self) -> FileJsonType:
+        """ Return a tuple representation that httpx will accept for multipart/form-data """
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """ A response from an endpoint """
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: Optional[T]
+
+
+__all__ = ["UNSET", "File", "FileJsonType", "Response", "Unset"]