honeycomb-api 0.1.0__py3-none-any.whl

honeycomb/_generated/models/ingest_key_attributes_timestamps.py

@@ -0,0 +1,107 @@
+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 dateutil.parser import isoparse
+from typing import cast
+from typing import Union
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="IngestKeyAttributesTimestamps")
+
+
+
+@_attrs_define
+class IngestKeyAttributesTimestamps:
+    """ 
+        Attributes:
+            created (Union[Unset, datetime.datetime]): The ISO8601-formatted time when the API Key was created. Example:
+                2022-09-22T17:32:11Z.
+            updated (Union[Unset, datetime.datetime]): The ISO8601-formatted time when the API Key was updated. Example:
+                2022-10-31T15:08:11Z.
+     """
+
+    created: Union[Unset, datetime.datetime] = UNSET
+    updated: Union[Unset, datetime.datetime] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        created: Union[Unset, str] = UNSET
+        if not isinstance(self.created, Unset):
+            created = self.created.isoformat()
+
+        updated: Union[Unset, str] = UNSET
+        if not isinstance(self.updated, Unset):
+            updated = self.updated.isoformat()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if created is not UNSET:
+            field_dict["created"] = created
+        if updated is not UNSET:
+            field_dict["updated"] = updated
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        _created = d.pop("created", UNSET)
+        created: Union[Unset, datetime.datetime]
+        if isinstance(_created,  Unset):
+            created = UNSET
+        else:
+            created = isoparse(_created)
+
+
+
+
+        _updated = d.pop("updated", UNSET)
+        updated: Union[Unset, datetime.datetime]
+        if isinstance(_updated,  Unset):
+            updated = UNSET
+        else:
+            updated = isoparse(_updated)
+
+
+
+
+        ingest_key_attributes_timestamps = cls(
+            created=created,
+            updated=updated,
+        )
+
+
+        ingest_key_attributes_timestamps.additional_properties = d
+        return ingest_key_attributes_timestamps
+
+    @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/ingest_key_type.py

@@ -0,0 +1,90 @@
+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.ingest_key_type_key_type import IngestKeyTypeKeyType
+from ..types import UNSET, Unset
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="IngestKeyType")
+
+
+
+@_attrs_define
+class IngestKeyType:
+    """ 
+        Attributes:
+            key_type (IngestKeyTypeKeyType): The type of API Key Example: ingest.
+            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. The time_to_live property can only
+                be set when the key is created and cannot be changed.
+                Expressed as a RFC3339-formatted time.
+                 Example: 2025-11-19T18:01:02+00:00.
+     """
+
+    key_type: IngestKeyTypeKeyType
+    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]:
+        key_type = self.key_type.value
+
+        time_to_live = self.time_to_live
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "key_type": key_type,
+        })
+        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:
+        d = src_dict.copy()
+        key_type = IngestKeyTypeKeyType(d.pop("key_type"))
+
+
+
+
+        time_to_live = d.pop("time_to_live", UNSET)
+
+        ingest_key_type = cls(
+            key_type=key_type,
+            time_to_live=time_to_live,
+        )
+
+
+        ingest_key_type.additional_properties = d
+        return ingest_key_type
+
+    @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/ingest_key_type_key_type.py

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

honeycomb/_generated/models/jsonapi_error_source.py

@@ -0,0 +1,92 @@
+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="JSONAPIErrorSource")
+
+
+
+@_attrs_define
+class JSONAPIErrorSource:
+    """ Source of a JSON:API error
+
+        Attributes:
+            pointer (Union[Unset, str]):
+            header (Union[Unset, str]):
+            parameter (Union[Unset, str]):
+     """
+
+    pointer: Union[Unset, str] = UNSET
+    header: Union[Unset, str] = UNSET
+    parameter: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        pointer = self.pointer
+
+        header = self.header
+
+        parameter = self.parameter
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if pointer is not UNSET:
+            field_dict["pointer"] = pointer
+        if header is not UNSET:
+            field_dict["header"] = header
+        if parameter is not UNSET:
+            field_dict["parameter"] = parameter
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        pointer = d.pop("pointer", UNSET)
+
+        header = d.pop("header", UNSET)
+
+        parameter = d.pop("parameter", UNSET)
+
+        jsonapi_error_source = cls(
+            pointer=pointer,
+            header=header,
+            parameter=parameter,
+        )
+
+
+        jsonapi_error_source.additional_properties = d
+        return jsonapi_error_source
+
+    @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/kinesis_event.py

@@ -0,0 +1,111 @@
+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.kinesis_event_record import KinesisEventRecord
+
+
+
+
+
+T = TypeVar("T", bound="KinesisEvent")
+
+
+
+@_attrs_define
+class KinesisEvent:
+    """ 
+        Attributes:
+            request_id (Union[Unset, str]):
+            timestamp (Union[Unset, int]):
+            records (Union[Unset, list['KinesisEventRecord']]):
+     """
+
+    request_id: Union[Unset, str] = UNSET
+    timestamp: Union[Unset, int] = UNSET
+    records: Union[Unset, list['KinesisEventRecord']] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.kinesis_event_record import KinesisEventRecord
+        request_id = self.request_id
+
+        timestamp = self.timestamp
+
+        records: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.records, Unset):
+            records = []
+            for records_item_data in self.records:
+                records_item = records_item_data.to_dict()
+                records.append(records_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if request_id is not UNSET:
+            field_dict["requestId"] = request_id
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+        if records is not UNSET:
+            field_dict["records"] = records
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.kinesis_event_record import KinesisEventRecord
+        d = src_dict.copy()
+        request_id = d.pop("requestId", UNSET)
+
+        timestamp = d.pop("timestamp", UNSET)
+
+        records = []
+        _records = d.pop("records", UNSET)
+        for records_item_data in (_records or []):
+            records_item = KinesisEventRecord.from_dict(records_item_data)
+
+
+
+            records.append(records_item)
+
+
+        kinesis_event = cls(
+            request_id=request_id,
+            timestamp=timestamp,
+            records=records,
+        )
+
+
+        kinesis_event.additional_properties = d
+        return kinesis_event
+
+    @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/kinesis_event_record.py

@@ -0,0 +1,73 @@
+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="KinesisEventRecord")
+
+
+
+@_attrs_define
+class KinesisEventRecord:
+    """ 
+        Attributes:
+            data (Union[Unset, str]): Base64 encoded Kinesis record from AWS
+     """
+
+    data: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        data = self.data
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if data is not UNSET:
+            field_dict["data"] = data
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        data = d.pop("data", UNSET)
+
+        kinesis_event_record = cls(
+            data=data,
+        )
+
+
+        kinesis_event_record.additional_properties = d
+        return kinesis_event_record
+
+    @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/kinesis_response.py

@@ -0,0 +1,91 @@
+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="KinesisResponse")
+
+
+
+@_attrs_define
+class KinesisResponse:
+    """ 
+        Attributes:
+            request_id (Union[Unset, str]):
+            timestamp (Union[Unset, int]):
+            error_message (Union[Unset, str]):
+     """
+
+    request_id: Union[Unset, str] = UNSET
+    timestamp: Union[Unset, int] = UNSET
+    error_message: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        request_id = self.request_id
+
+        timestamp = self.timestamp
+
+        error_message = self.error_message
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if request_id is not UNSET:
+            field_dict["requestId"] = request_id
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+        if error_message is not UNSET:
+            field_dict["errorMessage"] = error_message
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        request_id = d.pop("requestId", UNSET)
+
+        timestamp = d.pop("timestamp", UNSET)
+
+        error_message = d.pop("errorMessage", UNSET)
+
+        kinesis_response = cls(
+            request_id=request_id,
+            timestamp=timestamp,
+            error_message=error_message,
+        )
+
+
+        kinesis_response.additional_properties = d
+        return kinesis_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/list_api_keys_filtertype.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class ListApiKeysFiltertype(str, Enum):
+    CONFIGURATION = "configuration"
+    INGEST = "ingest"
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/map_dependency.py

@@ -0,0 +1,118 @@
+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.map_node import MapNode
+
+
+
+
+
+T = TypeVar("T", bound="MapDependency")
+
+
+
+@_attrs_define
+class MapDependency:
+    """ A dependency relationship between two services.
+
+        Attributes:
+            parent_node (Union[Unset, MapNode]): A node in the service map (typically a service).
+            child_node (Union[Unset, MapNode]): A node in the service map (typically a service).
+            call_count (Union[Unset, int]): Number of calls between the parent and child services.
+                 Example: 142.
+     """
+
+    parent_node: Union[Unset, 'MapNode'] = UNSET
+    child_node: Union[Unset, 'MapNode'] = UNSET
+    call_count: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.map_node import MapNode
+        parent_node: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.parent_node, Unset):
+            parent_node = self.parent_node.to_dict()
+
+        child_node: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.child_node, Unset):
+            child_node = self.child_node.to_dict()
+
+        call_count = self.call_count
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if parent_node is not UNSET:
+            field_dict["parent_node"] = parent_node
+        if child_node is not UNSET:
+            field_dict["child_node"] = child_node
+        if call_count is not UNSET:
+            field_dict["call_count"] = call_count
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.map_node import MapNode
+        d = src_dict.copy()
+        _parent_node = d.pop("parent_node", UNSET)
+        parent_node: Union[Unset, MapNode]
+        if isinstance(_parent_node,  Unset):
+            parent_node = UNSET
+        else:
+            parent_node = MapNode.from_dict(_parent_node)
+
+
+
+
+        _child_node = d.pop("child_node", UNSET)
+        child_node: Union[Unset, MapNode]
+        if isinstance(_child_node,  Unset):
+            child_node = UNSET
+        else:
+            child_node = MapNode.from_dict(_child_node)
+
+
+
+
+        call_count = d.pop("call_count", UNSET)
+
+        map_dependency = cls(
+            parent_node=parent_node,
+            child_node=child_node,
+            call_count=call_count,
+        )
+
+
+        map_dependency.additional_properties = d
+        return map_dependency
+
+    @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