honeycomb-api 0.1.0__py3-none-any.whl

honeycomb/_generated/models/filter_op.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+class FilterOp(str, Enum):
+    CONTAINS = "contains"
+    DOES_NOT_CONTAIN = "does-not-contain"
+    DOES_NOT_END_WITH = "does-not-end-with"
+    DOES_NOT_EXIST = "does-not-exist"
+    DOES_NOT_START_WITH = "does-not-start-with"
+    ENDS_WITH = "ends-with"
+    EXISTS = "exists"
+    IN = "in"
+    NOT_IN = "not-in"
+    STARTS_WITH = "starts-with"
+    VALUE_0 = "="
+    VALUE_1 = "!="
+    VALUE_2 = ">"
+    VALUE_3 = ">="
+    VALUE_4 = "<"
+    VALUE_5 = "<="
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/get_map_dependencies_response.py

@@ -0,0 +1,169 @@
+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.get_map_dependencies_response_status import GetMapDependenciesResponseStatus
+from ..types import UNSET, Unset
+from typing import cast
+from typing import cast, Union
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.pagination_links import PaginationLinks
+  from ..models.map_dependency import MapDependency
+
+
+
+
+
+T = TypeVar("T", bound="GetMapDependenciesResponse")
+
+
+
+@_attrs_define
+class GetMapDependenciesResponse:
+    """ Response containing map dependencies data.
+
+        Attributes:
+            request_id (Union[Unset, str]): Unique identifier for the Map Dependency Request.
+                 Example: abc123.
+            status (Union[Unset, GetMapDependenciesResponseStatus]): Status of the Map Dependency Request.
+                 Example: ready.
+            dependencies (Union[None, Unset, list['MapDependency']]): Array of service dependencies. Null when status is
+                "pending" or "error".
+            links (Union[Unset, PaginationLinks]): Links to iterate through the pages of results.
+     """
+
+    request_id: Union[Unset, str] = UNSET
+    status: Union[Unset, GetMapDependenciesResponseStatus] = UNSET
+    dependencies: Union[None, Unset, list['MapDependency']] = UNSET
+    links: Union[Unset, 'PaginationLinks'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.pagination_links import PaginationLinks
+        from ..models.map_dependency import MapDependency
+        request_id = self.request_id
+
+        status: Union[Unset, str] = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
+
+
+        dependencies: Union[None, Unset, list[dict[str, Any]]]
+        if isinstance(self.dependencies, Unset):
+            dependencies = UNSET
+        elif isinstance(self.dependencies, list):
+            dependencies = []
+            for dependencies_type_0_item_data in self.dependencies:
+                dependencies_type_0_item = dependencies_type_0_item_data.to_dict()
+                dependencies.append(dependencies_type_0_item)
+
+
+        else:
+            dependencies = self.dependencies
+
+        links: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.links, Unset):
+            links = self.links.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if request_id is not UNSET:
+            field_dict["request_id"] = request_id
+        if status is not UNSET:
+            field_dict["status"] = status
+        if dependencies is not UNSET:
+            field_dict["dependencies"] = dependencies
+        if links is not UNSET:
+            field_dict["links"] = links
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.pagination_links import PaginationLinks
+        from ..models.map_dependency import MapDependency
+        d = src_dict.copy()
+        request_id = d.pop("request_id", UNSET)
+
+        _status = d.pop("status", UNSET)
+        status: Union[Unset, GetMapDependenciesResponseStatus]
+        if isinstance(_status,  Unset):
+            status = UNSET
+        else:
+            status = GetMapDependenciesResponseStatus(_status)
+
+
+
+
+        def _parse_dependencies(data: object) -> Union[None, Unset, list['MapDependency']]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                dependencies_type_0 = []
+                _dependencies_type_0 = data
+                for dependencies_type_0_item_data in (_dependencies_type_0):
+                    dependencies_type_0_item = MapDependency.from_dict(dependencies_type_0_item_data)
+
+
+
+                    dependencies_type_0.append(dependencies_type_0_item)
+
+                return dependencies_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[None, Unset, list['MapDependency']], data)
+
+        dependencies = _parse_dependencies(d.pop("dependencies", UNSET))
+
+
+        _links = d.pop("links", UNSET)
+        links: Union[Unset, PaginationLinks]
+        if isinstance(_links,  Unset):
+            links = UNSET
+        else:
+            links = PaginationLinks.from_dict(_links)
+
+
+
+
+        get_map_dependencies_response = cls(
+            request_id=request_id,
+            status=status,
+            dependencies=dependencies,
+            links=links,
+        )
+
+
+        get_map_dependencies_response.additional_properties = d
+        return get_map_dependencies_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/get_map_dependencies_response_status.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class GetMapDependenciesResponseStatus(str, Enum):
+    ERROR = "error"
+    PENDING = "pending"
+    READY = "ready"
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/having_calculate_op.py

@@ -0,0 +1,29 @@
+from enum import Enum
+
+class HavingCalculateOp(str, Enum):
+    AVG = "AVG"
+    CONCURRENCY = "CONCURRENCY"
+    COUNT = "COUNT"
+    COUNT_DISTINCT = "COUNT_DISTINCT"
+    MAX = "MAX"
+    MIN = "MIN"
+    P001 = "P001"
+    P01 = "P01"
+    P05 = "P05"
+    P10 = "P10"
+    P20 = "P20"
+    P25 = "P25"
+    P50 = "P50"
+    P75 = "P75"
+    P80 = "P80"
+    P90 = "P90"
+    P95 = "P95"
+    P99 = "P99"
+    P999 = "P999"
+    RATE_AVG = "RATE_AVG"
+    RATE_MAX = "RATE_MAX"
+    RATE_SUM = "RATE_SUM"
+    SUM = "SUM"
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/having_op.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class HavingOp(str, Enum):
+    VALUE_0 = "="
+    VALUE_1 = "!="
+    VALUE_2 = ">"
+    VALUE_3 = ">="
+    VALUE_4 = "<"
+    VALUE_5 = "<="
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/included_resource.py

@@ -0,0 +1,106 @@
+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.included_resource_attributes import IncludedResourceAttributes
+
+
+
+
+
+T = TypeVar("T", bound="IncludedResource")
+
+
+
+@_attrs_define
+class IncludedResource:
+    """ 
+        Attributes:
+            id (Union[Unset, str]): The unique identifier of the resource Example: hcxen_01hznmeqrcq8rz533xrvtc6mk0.
+            type_ (Union[Unset, str]):  Example: environments.
+            attributes (Union[Unset, IncludedResourceAttributes]):  Example: {'name': 'Production', 'slug': 'production'}.
+     """
+
+    id: Union[Unset, str] = UNSET
+    type_: Union[Unset, str] = UNSET
+    attributes: Union[Unset, 'IncludedResourceAttributes'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.included_resource_attributes import IncludedResourceAttributes
+        id = self.id
+
+        type_ = self.type_
+
+        attributes: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.attributes, Unset):
+            attributes = self.attributes.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 type_ is not UNSET:
+            field_dict["type"] = type_
+        if attributes is not UNSET:
+            field_dict["attributes"] = attributes
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.included_resource_attributes import IncludedResourceAttributes
+        d = src_dict.copy()
+        id = d.pop("id", UNSET)
+
+        type_ = d.pop("type", UNSET)
+
+        _attributes = d.pop("attributes", UNSET)
+        attributes: Union[Unset, IncludedResourceAttributes]
+        if isinstance(_attributes,  Unset):
+            attributes = UNSET
+        else:
+            attributes = IncludedResourceAttributes.from_dict(_attributes)
+
+
+
+
+        included_resource = cls(
+            id=id,
+            type_=type_,
+            attributes=attributes,
+        )
+
+
+        included_resource.additional_properties = d
+        return included_resource
+
+    @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/included_resource_attributes.py

@@ -0,0 +1,62 @@
+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
+
+
+
+
+
+
+
+T = TypeVar("T", bound="IncludedResourceAttributes")
+
+
+
+@_attrs_define
+class IncludedResourceAttributes:
+    """ 
+        Example:
+            {'name': 'Production', 'slug': 'production'}
+
+     """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        included_resource_attributes = cls(
+        )
+
+
+        included_resource_attributes.additional_properties = d
+        return included_resource_attributes
+
+    @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_attributes.py

@@ -0,0 +1,153 @@
+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 cast
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.ingest_key_attributes_permissions import IngestKeyAttributesPermissions
+  from ..models.ingest_key_attributes_timestamps import IngestKeyAttributesTimestamps
+
+
+
+
+
+T = TypeVar("T", bound="IngestKeyAttributes")
+
+
+
+@_attrs_define
+class IngestKeyAttributes:
+    """ 
+        Attributes:
+            key_type (IngestKeyTypeKeyType): The type of API Key Example: ingest.
+            name (str): A human-readable name for the API Key Example: us-west-2 collectors key.
+            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.
+            disabled (Union[Unset, bool]): Whether the API Key is disabled Default: False.
+            permissions (Union[Unset, IngestKeyAttributesPermissions]): The permissions granted to this Ingest API Key
+            timestamps (Union[Unset, IngestKeyAttributesTimestamps]):
+     """
+
+    key_type: IngestKeyTypeKeyType
+    name: str
+    time_to_live: Union[Unset, str] = UNSET
+    disabled: Union[Unset, bool] = False
+    permissions: Union[Unset, 'IngestKeyAttributesPermissions'] = UNSET
+    timestamps: Union[Unset, 'IngestKeyAttributesTimestamps'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.ingest_key_attributes_permissions import IngestKeyAttributesPermissions
+        from ..models.ingest_key_attributes_timestamps import IngestKeyAttributesTimestamps
+        key_type = self.key_type.value
+
+        name = self.name
+
+        time_to_live = self.time_to_live
+
+        disabled = self.disabled
+
+        permissions: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.permissions, Unset):
+            permissions = self.permissions.to_dict()
+
+        timestamps: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.timestamps, Unset):
+            timestamps = self.timestamps.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "key_type": key_type,
+            "name": name,
+        })
+        if time_to_live is not UNSET:
+            field_dict["time_to_live"] = time_to_live
+        if disabled is not UNSET:
+            field_dict["disabled"] = disabled
+        if permissions is not UNSET:
+            field_dict["permissions"] = permissions
+        if timestamps is not UNSET:
+            field_dict["timestamps"] = timestamps
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.ingest_key_attributes_permissions import IngestKeyAttributesPermissions
+        from ..models.ingest_key_attributes_timestamps import IngestKeyAttributesTimestamps
+        d = src_dict.copy()
+        key_type = IngestKeyTypeKeyType(d.pop("key_type"))
+
+
+
+
+        name = d.pop("name")
+
+        time_to_live = d.pop("time_to_live", UNSET)
+
+        disabled = d.pop("disabled", UNSET)
+
+        _permissions = d.pop("permissions", UNSET)
+        permissions: Union[Unset, IngestKeyAttributesPermissions]
+        if isinstance(_permissions,  Unset):
+            permissions = UNSET
+        else:
+            permissions = IngestKeyAttributesPermissions.from_dict(_permissions)
+
+
+
+
+        _timestamps = d.pop("timestamps", UNSET)
+        timestamps: Union[Unset, IngestKeyAttributesTimestamps]
+        if isinstance(_timestamps,  Unset):
+            timestamps = UNSET
+        else:
+            timestamps = IngestKeyAttributesTimestamps.from_dict(_timestamps)
+
+
+
+
+        ingest_key_attributes = cls(
+            key_type=key_type,
+            name=name,
+            time_to_live=time_to_live,
+            disabled=disabled,
+            permissions=permissions,
+            timestamps=timestamps,
+        )
+
+
+        ingest_key_attributes.additional_properties = d
+        return ingest_key_attributes
+
+    @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_attributes_key_type.py

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

honeycomb/_generated/models/ingest_key_attributes_permissions.py

@@ -0,0 +1,74 @@
+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="IngestKeyAttributesPermissions")
+
+
+
+@_attrs_define
+class IngestKeyAttributesPermissions:
+    """ The permissions granted to this Ingest API Key
+
+        Attributes:
+            create_datasets (Union[Unset, bool]): Whether this API Key can create new Datasets Default: False.
+     """
+
+    create_datasets: Union[Unset, bool] = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        create_datasets = self.create_datasets
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if create_datasets is not UNSET:
+            field_dict["create_datasets"] = create_datasets
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        create_datasets = d.pop("create_datasets", UNSET)
+
+        ingest_key_attributes_permissions = cls(
+            create_datasets=create_datasets,
+        )
+
+
+        ingest_key_attributes_permissions.additional_properties = d
+        return ingest_key_attributes_permissions
+
+    @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