honeycomb-api 0.1.0__py3-none-any.whl

honeycomb/_generated/models/marker_object_relationships_dataset_data_type_0.py

@@ -0,0 +1,94 @@
+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.marker_object_relationships_dataset_data_type_0_type import MarkerObjectRelationshipsDatasetDataType0Type
+from ..types import UNSET, Unset
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="MarkerObjectRelationshipsDatasetDataType0")
+
+
+
+@_attrs_define
+class MarkerObjectRelationshipsDatasetDataType0:
+    """ 
+        Attributes:
+            type_ (Union[Unset, MarkerObjectRelationshipsDatasetDataType0Type]):
+            id (Union[Unset, str]): The dataset ID Example: hcxds_12345678901234567890123456.
+     """
+
+    type_: Union[Unset, MarkerObjectRelationshipsDatasetDataType0Type] = UNSET
+    id: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        type_: Union[Unset, str] = UNSET
+        if not isinstance(self.type_, Unset):
+            type_ = self.type_.value
+
+
+        id = self.id
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if id is not UNSET:
+            field_dict["id"] = id
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        _type_ = d.pop("type", UNSET)
+        type_: Union[Unset, MarkerObjectRelationshipsDatasetDataType0Type]
+        if isinstance(_type_,  Unset):
+            type_ = UNSET
+        else:
+            type_ = MarkerObjectRelationshipsDatasetDataType0Type(_type_)
+
+
+
+
+        id = d.pop("id", UNSET)
+
+        marker_object_relationships_dataset_data_type_0 = cls(
+            type_=type_,
+            id=id,
+        )
+
+
+        marker_object_relationships_dataset_data_type_0.additional_properties = d
+        return marker_object_relationships_dataset_data_type_0
+
+    @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/marker_object_relationships_dataset_data_type_0_type.py

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

honeycomb/_generated/models/marker_object_type.py

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

honeycomb/_generated/models/marker_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.marker_object import MarkerObject
+
+
+
+
+
+T = TypeVar("T", bound="MarkerResponse")
+
+
+
+@_attrs_define
+class MarkerResponse:
+    """ 
+        Attributes:
+            data (MarkerObject):
+     """
+
+    data: 'MarkerObject'
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.marker_object import MarkerObject
+        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.marker_object import MarkerObject
+        d = src_dict.copy()
+        data = MarkerObject.from_dict(d.pop("data"))
+
+
+
+
+        marker_response = cls(
+            data=data,
+        )
+
+
+        marker_response.additional_properties = d
+        return marker_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/marker_setting.py

@@ -0,0 +1,125 @@
+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, Union
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="MarkerSetting")
+
+
+
+@_attrs_define
+class MarkerSetting:
+    """ 
+        Attributes:
+            type_ (str): Groups similar Markers. For example, 'deploys'. All Markers of the same type appears with the same
+                color on the graph.
+                 Example: deploy.
+            color (str): Color to use for display of this marker type. Specified as hexadecimal RGB. For example, "#F96E11".
+                 Example: #7b1fa2.
+            id (Union[Unset, str]): The unique identifier (ID) for the Marker Setting. Example: gwAHiE5TS4j.
+            created_at (Union[Unset, str]): The ISO8601-formatted time when the Marker Setting was created. Example:
+                2022-09-15T05:39:42Z.
+            updated_at (Union[None, Unset, str]): The ISO8601-formatted time when the Marker Setting was updated. Example:
+                2022-12-15T04:25:14Z.
+     """
+
+    type_: str
+    color: str
+    id: Union[Unset, str] = UNSET
+    created_at: Union[Unset, str] = UNSET
+    updated_at: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        color = self.color
+
+        id = self.id
+
+        created_at = self.created_at
+
+        updated_at: Union[None, Unset, str]
+        if isinstance(self.updated_at, Unset):
+            updated_at = UNSET
+        else:
+            updated_at = self.updated_at
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "type": type_,
+            "color": color,
+        })
+        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
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        type_ = d.pop("type")
+
+        color = d.pop("color")
+
+        id = d.pop("id", UNSET)
+
+        created_at = d.pop("created_at", UNSET)
+
+        def _parse_updated_at(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        updated_at = _parse_updated_at(d.pop("updated_at", UNSET))
+
+
+        marker_setting = cls(
+            type_=type_,
+            color=color,
+            id=id,
+            created_at=created_at,
+            updated_at=updated_at,
+        )
+
+
+        marker_setting.additional_properties = d
+        return marker_setting
+
+    @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/marker_update_request.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.marker_update_request_data import MarkerUpdateRequestData
+
+
+
+
+
+T = TypeVar("T", bound="MarkerUpdateRequest")
+
+
+
+@_attrs_define
+class MarkerUpdateRequest:
+    """ 
+        Attributes:
+            data (MarkerUpdateRequestData):
+     """
+
+    data: 'MarkerUpdateRequestData'
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.marker_update_request_data import MarkerUpdateRequestData
+        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.marker_update_request_data import MarkerUpdateRequestData
+        d = src_dict.copy()
+        data = MarkerUpdateRequestData.from_dict(d.pop("data"))
+
+
+
+
+        marker_update_request = cls(
+            data=data,
+        )
+
+
+        marker_update_request.additional_properties = d
+        return marker_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/marker_update_request_data.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 ..models.marker_update_request_data_type import MarkerUpdateRequestDataType
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.marker_update_request_data_attributes import MarkerUpdateRequestDataAttributes
+  from ..models.marker_update_request_data_relationships import MarkerUpdateRequestDataRelationships
+
+
+
+
+
+T = TypeVar("T", bound="MarkerUpdateRequestData")
+
+
+
+@_attrs_define
+class MarkerUpdateRequestData:
+    """ 
+        Attributes:
+            type_ (MarkerUpdateRequestDataType):
+            attributes (MarkerUpdateRequestDataAttributes):
+            relationships (MarkerUpdateRequestDataRelationships):
+     """
+
+    type_: MarkerUpdateRequestDataType
+    attributes: 'MarkerUpdateRequestDataAttributes'
+    relationships: 'MarkerUpdateRequestDataRelationships'
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.marker_update_request_data_attributes import MarkerUpdateRequestDataAttributes
+        from ..models.marker_update_request_data_relationships import MarkerUpdateRequestDataRelationships
+        type_ = self.type_.value
+
+        attributes = self.attributes.to_dict()
+
+        relationships = self.relationships.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "type": type_,
+            "attributes": attributes,
+            "relationships": relationships,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.marker_update_request_data_attributes import MarkerUpdateRequestDataAttributes
+        from ..models.marker_update_request_data_relationships import MarkerUpdateRequestDataRelationships
+        d = src_dict.copy()
+        type_ = MarkerUpdateRequestDataType(d.pop("type"))
+
+
+
+
+        attributes = MarkerUpdateRequestDataAttributes.from_dict(d.pop("attributes"))
+
+
+
+
+        relationships = MarkerUpdateRequestDataRelationships.from_dict(d.pop("relationships"))
+
+
+
+
+        marker_update_request_data = cls(
+            type_=type_,
+            attributes=attributes,
+            relationships=relationships,
+        )
+
+
+        marker_update_request_data.additional_properties = d
+        return marker_update_request_data
+
+    @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/marker_update_request_data_attributes.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 Union
+
+
+
+
+
+
+T = TypeVar("T", bound="MarkerUpdateRequestDataAttributes")
+
+
+
+@_attrs_define
+class MarkerUpdateRequestDataAttributes:
+    """ 
+        Attributes:
+            start_time (Union[Unset, int]): The time the Marker should be placed. Expressed in Unix Time (seconds since
+                epoch). Example: 1471040808.
+            end_time (Union[Unset, int]): Optional end time. Must be >= start_time if provided. Expressed in Unix Time
+                (seconds since epoch). Example: 1471040908.
+            message (Union[Unset, str]): A message to describe this specific Marker. Example: backend deploy #123.
+            type_ (Union[Unset, str]): Groups similar Markers. Example: deploy.
+            url (Union[Unset, str]): A target URL for the marker. Example: https://github.com/myorg/myrepo/commit/abc123.
+     """
+
+    start_time: Union[Unset, int] = UNSET
+    end_time: Union[Unset, int] = UNSET
+    message: Union[Unset, str] = UNSET
+    type_: Union[Unset, str] = UNSET
+    url: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        start_time = self.start_time
+
+        end_time = self.end_time
+
+        message = self.message
+
+        type_ = self.type_
+
+        url = self.url
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if start_time is not UNSET:
+            field_dict["start_time"] = start_time
+        if end_time is not UNSET:
+            field_dict["end_time"] = end_time
+        if message is not UNSET:
+            field_dict["message"] = message
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if url is not UNSET:
+            field_dict["url"] = url
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        start_time = d.pop("start_time", UNSET)
+
+        end_time = d.pop("end_time", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        type_ = d.pop("type", UNSET)
+
+        url = d.pop("url", UNSET)
+
+        marker_update_request_data_attributes = cls(
+            start_time=start_time,
+            end_time=end_time,
+            message=message,
+            type_=type_,
+            url=url,
+        )
+
+
+        marker_update_request_data_attributes.additional_properties = d
+        return marker_update_request_data_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/marker_update_request_data_relationships.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 typing import cast
+
+if TYPE_CHECKING:
+  from ..models.dataset_relationship import DatasetRelationship
+  from ..models.environment_relationship import EnvironmentRelationship
+
+
+
+
+
+T = TypeVar("T", bound="MarkerUpdateRequestDataRelationships")
+
+
+
+@_attrs_define
+class MarkerUpdateRequestDataRelationships:
+    """ 
+        Attributes:
+            environment (EnvironmentRelationship): The Environment this object is associated with.
+            dataset (DatasetRelationship): The Dataset this object is associated with.
+     """
+
+    environment: 'EnvironmentRelationship'
+    dataset: 'DatasetRelationship'
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.dataset_relationship import DatasetRelationship
+        from ..models.environment_relationship import EnvironmentRelationship
+        environment = self.environment.to_dict()
+
+        dataset = self.dataset.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "environment": environment,
+            "dataset": dataset,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.dataset_relationship import DatasetRelationship
+        from ..models.environment_relationship import EnvironmentRelationship
+        d = src_dict.copy()
+        environment = EnvironmentRelationship.from_dict(d.pop("environment"))
+
+
+
+
+        dataset = DatasetRelationship.from_dict(d.pop("dataset"))
+
+
+
+
+        marker_update_request_data_relationships = cls(
+            environment=environment,
+            dataset=dataset,
+        )
+
+
+        marker_update_request_data_relationships.additional_properties = d
+        return marker_update_request_data_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/marker_update_request_data_type.py

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