honeycomb-api 0.1.0__py3-none-any.whl

honeycomb/_generated/models/api_key_object_relationships.py

@@ -0,0 +1,150 @@
+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 cast, Union
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.user_relationship import UserRelationship
+  from ..models.environment_relationship import EnvironmentRelationship
+
+
+
+
+
+T = TypeVar("T", bound="ApiKeyObjectRelationships")
+
+
+
+@_attrs_define
+class ApiKeyObjectRelationships:
+    """ 
+        Attributes:
+            environment (EnvironmentRelationship): The Environment this object is associated with.
+            creator (Union['UserRelationship', None, Unset]): The User who initially created this resource.
+            editor (Union['UserRelationship', None, Unset]): The User who last edited this resource.
+     """
+
+    environment: 'EnvironmentRelationship'
+    creator: Union['UserRelationship', None, Unset] = UNSET
+    editor: Union['UserRelationship', None, Unset] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.user_relationship import UserRelationship
+        from ..models.environment_relationship import EnvironmentRelationship
+        environment = self.environment.to_dict()
+
+        creator: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.creator, Unset):
+            creator = UNSET
+        elif isinstance(self.creator, UserRelationship):
+            creator = self.creator.to_dict()
+        else:
+            creator = self.creator
+
+        editor: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.editor, Unset):
+            editor = UNSET
+        elif isinstance(self.editor, UserRelationship):
+            editor = self.editor.to_dict()
+        else:
+            editor = self.editor
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "environment": environment,
+        })
+        if creator is not UNSET:
+            field_dict["creator"] = creator
+        if editor is not UNSET:
+            field_dict["editor"] = editor
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.user_relationship import UserRelationship
+        from ..models.environment_relationship import EnvironmentRelationship
+        d = src_dict.copy()
+        environment = EnvironmentRelationship.from_dict(d.pop("environment"))
+
+
+
+
+        def _parse_creator(data: object) -> Union['UserRelationship', None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_creator_relationship_type_0 = UserRelationship.from_dict(data)
+
+
+
+                return componentsschemas_creator_relationship_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union['UserRelationship', None, Unset], data)
+
+        creator = _parse_creator(d.pop("creator", UNSET))
+
+
+        def _parse_editor(data: object) -> Union['UserRelationship', None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_editor_relationship_type_0 = UserRelationship.from_dict(data)
+
+
+
+                return componentsschemas_editor_relationship_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union['UserRelationship', None, Unset], data)
+
+        editor = _parse_editor(d.pop("editor", UNSET))
+
+
+        api_key_object_relationships = cls(
+            environment=environment,
+            creator=creator,
+            editor=editor,
+        )
+
+
+        api_key_object_relationships.additional_properties = d
+        return api_key_object_relationships
+
+    @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/api_key_object_type.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class ApiKeyObjectType(str, Enum):
+    API_KEYS = "api-keys"
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/api_key_response.py

@@ -0,0 +1,78 @@
+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 typing import cast
+
+if TYPE_CHECKING:
+  from ..models.api_key_object import ApiKeyObject
+
+
+
+
+
+T = TypeVar("T", bound="ApiKeyResponse")
+
+
+
+@_attrs_define
+class ApiKeyResponse:
+    """ 
+        Attributes:
+            data (ApiKeyObject):
+     """
+
+    data: 'ApiKeyObject'
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.api_key_object import ApiKeyObject
+        data = self.data.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "data": data,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.api_key_object import ApiKeyObject
+        d = src_dict.copy()
+        data = ApiKeyObject.from_dict(d.pop("data"))
+
+
+
+
+        api_key_response = cls(
+            data=data,
+        )
+
+
+        api_key_response.additional_properties = d
+        return api_key_response
+
+    @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/api_key_update_request.py

@@ -0,0 +1,104 @@
+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 typing import cast
+from typing import cast, Union
+
+if TYPE_CHECKING:
+  from ..models.ingest_key import IngestKey
+  from ..models.configuration_key import ConfigurationKey
+
+
+
+
+
+T = TypeVar("T", bound="ApiKeyUpdateRequest")
+
+
+
+@_attrs_define
+class ApiKeyUpdateRequest:
+    """ 
+        Attributes:
+            data (Union['ConfigurationKey', 'IngestKey']):
+     """
+
+    data: Union['ConfigurationKey', 'IngestKey']
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.ingest_key import IngestKey
+        from ..models.configuration_key import ConfigurationKey
+        data: dict[str, Any]
+        if isinstance(self.data, IngestKey):
+            data = self.data.to_dict()
+        else:
+            data = self.data.to_dict()
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "data": data,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.ingest_key import IngestKey
+        from ..models.configuration_key import ConfigurationKey
+        d = src_dict.copy()
+        def _parse_data(data: object) -> Union['ConfigurationKey', 'IngestKey']:
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                data_type_0 = IngestKey.from_dict(data)
+
+
+
+                return data_type_0
+            except: # noqa: E722
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            data_type_1 = ConfigurationKey.from_dict(data)
+
+
+
+            return data_type_1
+
+        data = _parse_data(d.pop("data"))
+
+
+        api_key_update_request = cls(
+            data=data,
+        )
+
+
+        api_key_update_request.additional_properties = d
+        return api_key_update_request
+
+    @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/auth.py

@@ -0,0 +1,140 @@
+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.auth_type import AuthType
+from ..types import UNSET, Unset
+from typing import cast
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.auth_api_key_access import AuthApiKeyAccess
+  from ..models.auth_environment import AuthEnvironment
+  from ..models.auth_team import AuthTeam
+
+
+
+
+
+T = TypeVar("T", bound="Auth")
+
+
+
+@_attrs_define
+class Auth:
+    """ 
+        Attributes:
+            id (str): Unique identifier (ID) of the API Key.
+            type_ (AuthType): The type of API Key.
+            api_key_access (AuthApiKeyAccess):
+            environment (AuthEnvironment):
+            team (AuthTeam):
+            time_to_live (Union[Unset, str]): An optional property of an ingest key that determines the time at which the
+                key becomes unauthorized.
+                When the time_to_live passes, the key will no longer be usable. Expressed as a RFC3339-formatted time.
+                 Example: 2025-11-19T18:01:02+00:00.
+     """
+
+    id: str
+    type_: AuthType
+    api_key_access: 'AuthApiKeyAccess'
+    environment: 'AuthEnvironment'
+    team: 'AuthTeam'
+    time_to_live: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.auth_api_key_access import AuthApiKeyAccess
+        from ..models.auth_environment import AuthEnvironment
+        from ..models.auth_team import AuthTeam
+        id = self.id
+
+        type_ = self.type_.value
+
+        api_key_access = self.api_key_access.to_dict()
+
+        environment = self.environment.to_dict()
+
+        team = self.team.to_dict()
+
+        time_to_live = self.time_to_live
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "id": id,
+            "type": type_,
+            "api_key_access": api_key_access,
+            "environment": environment,
+            "team": team,
+        })
+        if time_to_live is not UNSET:
+            field_dict["time_to_live"] = time_to_live
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.auth_api_key_access import AuthApiKeyAccess
+        from ..models.auth_environment import AuthEnvironment
+        from ..models.auth_team import AuthTeam
+        d = src_dict.copy()
+        id = d.pop("id")
+
+        type_ = AuthType(d.pop("type"))
+
+
+
+
+        api_key_access = AuthApiKeyAccess.from_dict(d.pop("api_key_access"))
+
+
+
+
+        environment = AuthEnvironment.from_dict(d.pop("environment"))
+
+
+
+
+        team = AuthTeam.from_dict(d.pop("team"))
+
+
+
+
+        time_to_live = d.pop("time_to_live", UNSET)
+
+        auth = cls(
+            id=id,
+            type_=type_,
+            api_key_access=api_key_access,
+            environment=environment,
+            team=team,
+            time_to_live=time_to_live,
+        )
+
+
+        auth.additional_properties = d
+        return auth
+
+    @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/auth_api_key_access.py

@@ -0,0 +1,154 @@
+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="AuthApiKeyAccess")
+
+
+
+@_attrs_define
+class AuthApiKeyAccess:
+    """ 
+        Attributes:
+            events (Union[Unset, bool]):  Default: False.
+            markers (Union[Unset, bool]):  Default: False.
+            triggers (Union[Unset, bool]):  Default: False.
+            boards (Union[Unset, bool]):  Default: False.
+            queries (Union[Unset, bool]):  Default: False.
+            columns (Union[Unset, bool]):  Default: False.
+            create_datasets (Union[Unset, bool]):  Default: False.
+            slos (Union[Unset, bool]):  Default: False.
+            recipients (Union[Unset, bool]):  Default: False.
+            private_boards (Union[Unset, bool]):  Default: False.
+     """
+
+    events: Union[Unset, bool] = False
+    markers: Union[Unset, bool] = False
+    triggers: Union[Unset, bool] = False
+    boards: Union[Unset, bool] = False
+    queries: Union[Unset, bool] = False
+    columns: Union[Unset, bool] = False
+    create_datasets: Union[Unset, bool] = False
+    slos: Union[Unset, bool] = False
+    recipients: Union[Unset, bool] = False
+    private_boards: Union[Unset, bool] = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        events = self.events
+
+        markers = self.markers
+
+        triggers = self.triggers
+
+        boards = self.boards
+
+        queries = self.queries
+
+        columns = self.columns
+
+        create_datasets = self.create_datasets
+
+        slos = self.slos
+
+        recipients = self.recipients
+
+        private_boards = self.private_boards
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if events is not UNSET:
+            field_dict["events"] = events
+        if markers is not UNSET:
+            field_dict["markers"] = markers
+        if triggers is not UNSET:
+            field_dict["triggers"] = triggers
+        if boards is not UNSET:
+            field_dict["boards"] = boards
+        if queries is not UNSET:
+            field_dict["queries"] = queries
+        if columns is not UNSET:
+            field_dict["columns"] = columns
+        if create_datasets is not UNSET:
+            field_dict["createDatasets"] = create_datasets
+        if slos is not UNSET:
+            field_dict["slos"] = slos
+        if recipients is not UNSET:
+            field_dict["recipients"] = recipients
+        if private_boards is not UNSET:
+            field_dict["privateBoards"] = private_boards
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        events = d.pop("events", UNSET)
+
+        markers = d.pop("markers", UNSET)
+
+        triggers = d.pop("triggers", UNSET)
+
+        boards = d.pop("boards", UNSET)
+
+        queries = d.pop("queries", UNSET)
+
+        columns = d.pop("columns", UNSET)
+
+        create_datasets = d.pop("createDatasets", UNSET)
+
+        slos = d.pop("slos", UNSET)
+
+        recipients = d.pop("recipients", UNSET)
+
+        private_boards = d.pop("privateBoards", UNSET)
+
+        auth_api_key_access = cls(
+            events=events,
+            markers=markers,
+            triggers=triggers,
+            boards=boards,
+            queries=queries,
+            columns=columns,
+            create_datasets=create_datasets,
+            slos=slos,
+            recipients=recipients,
+            private_boards=private_boards,
+        )
+
+
+        auth_api_key_access.additional_properties = d
+        return auth_api_key_access
+
+    @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