honeycomb-api 0.1.0__py3-none-any.whl

honeycomb/_generated/models/marker_object.py

@@ -0,0 +1,136 @@
+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_type import MarkerObjectType
+from ..types import UNSET, Unset
+from typing import cast
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.marker_object_relationships import MarkerObjectRelationships
+  from ..models.marker_object_attributes import MarkerObjectAttributes
+  from ..models.marker_object_links import MarkerObjectLinks
+
+
+
+
+
+T = TypeVar("T", bound="MarkerObject")
+
+
+
+@_attrs_define
+class MarkerObject:
+    """ 
+        Attributes:
+            id (str): The unique identifier of the Marker Example: d1c84ec0.
+            type_ (MarkerObjectType):
+            attributes (MarkerObjectAttributes):
+            links (MarkerObjectLinks):
+            relationships (Union[Unset, MarkerObjectRelationships]):
+     """
+
+    id: str
+    type_: MarkerObjectType
+    attributes: 'MarkerObjectAttributes'
+    links: 'MarkerObjectLinks'
+    relationships: Union[Unset, 'MarkerObjectRelationships'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.marker_object_relationships import MarkerObjectRelationships
+        from ..models.marker_object_attributes import MarkerObjectAttributes
+        from ..models.marker_object_links import MarkerObjectLinks
+        id = self.id
+
+        type_ = self.type_.value
+
+        attributes = self.attributes.to_dict()
+
+        links = self.links.to_dict()
+
+        relationships: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.relationships, Unset):
+            relationships = self.relationships.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "id": id,
+            "type": type_,
+            "attributes": attributes,
+            "links": links,
+        })
+        if relationships is not UNSET:
+            field_dict["relationships"] = relationships
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.marker_object_relationships import MarkerObjectRelationships
+        from ..models.marker_object_attributes import MarkerObjectAttributes
+        from ..models.marker_object_links import MarkerObjectLinks
+        d = src_dict.copy()
+        id = d.pop("id")
+
+        type_ = MarkerObjectType(d.pop("type"))
+
+
+
+
+        attributes = MarkerObjectAttributes.from_dict(d.pop("attributes"))
+
+
+
+
+        links = MarkerObjectLinks.from_dict(d.pop("links"))
+
+
+
+
+        _relationships = d.pop("relationships", UNSET)
+        relationships: Union[Unset, MarkerObjectRelationships]
+        if isinstance(_relationships,  Unset):
+            relationships = UNSET
+        else:
+            relationships = MarkerObjectRelationships.from_dict(_relationships)
+
+
+
+
+        marker_object = cls(
+            id=id,
+            type_=type_,
+            attributes=attributes,
+            links=links,
+            relationships=relationships,
+        )
+
+
+        marker_object.additional_properties = d
+        return marker_object
+
+    @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_attributes.py

@@ -0,0 +1,146 @@
+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.marker_object_attributes_timestamps import MarkerObjectAttributesTimestamps
+
+
+
+
+
+T = TypeVar("T", bound="MarkerObjectAttributes")
+
+
+
+@_attrs_define
+class MarkerObjectAttributes:
+    """ 
+        Attributes:
+            start_time (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, allows a Marker to represent a time range. 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. All Markers of the same type appear with the same color on
+                the graph. Example: deploy.
+            url (Union[Unset, str]): A target URL for the marker. Clicking the marker text will navigate to this URL.
+                Example: https://github.com/myorg/myrepo/commit/abc123.
+            color (Union[Unset, str]): Color assigned to this marker type via Marker Settings. Specified as hexadecimal RGB.
+                Example: #F96E11.
+            timestamps (Union[Unset, MarkerObjectAttributesTimestamps]):
+     """
+
+    start_time: int
+    end_time: Union[Unset, int] = UNSET
+    message: Union[Unset, str] = UNSET
+    type_: Union[Unset, str] = UNSET
+    url: Union[Unset, str] = UNSET
+    color: Union[Unset, str] = UNSET
+    timestamps: Union[Unset, 'MarkerObjectAttributesTimestamps'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.marker_object_attributes_timestamps import MarkerObjectAttributesTimestamps
+        start_time = self.start_time
+
+        end_time = self.end_time
+
+        message = self.message
+
+        type_ = self.type_
+
+        url = self.url
+
+        color = self.color
+
+        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({
+            "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
+        if color is not UNSET:
+            field_dict["color"] = color
+        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.marker_object_attributes_timestamps import MarkerObjectAttributesTimestamps
+        d = src_dict.copy()
+        start_time = d.pop("start_time")
+
+        end_time = d.pop("end_time", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        type_ = d.pop("type", UNSET)
+
+        url = d.pop("url", UNSET)
+
+        color = d.pop("color", UNSET)
+
+        _timestamps = d.pop("timestamps", UNSET)
+        timestamps: Union[Unset, MarkerObjectAttributesTimestamps]
+        if isinstance(_timestamps,  Unset):
+            timestamps = UNSET
+        else:
+            timestamps = MarkerObjectAttributesTimestamps.from_dict(_timestamps)
+
+
+
+
+        marker_object_attributes = cls(
+            start_time=start_time,
+            end_time=end_time,
+            message=message,
+            type_=type_,
+            url=url,
+            color=color,
+            timestamps=timestamps,
+        )
+
+
+        marker_object_attributes.additional_properties = d
+        return marker_object_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_object_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="MarkerObjectAttributesTimestamps")
+
+
+
+@_attrs_define
+class MarkerObjectAttributesTimestamps:
+    """ 
+        Attributes:
+            created (Union[Unset, datetime.datetime]): The ISO8601-formatted time when the Marker was created. Example:
+                2022-09-22T17:32:11Z.
+            updated (Union[Unset, datetime.datetime]): The ISO8601-formatted time when the Marker 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)
+
+
+
+
+        marker_object_attributes_timestamps = cls(
+            created=created,
+            updated=updated,
+        )
+
+
+        marker_object_attributes_timestamps.additional_properties = d
+        return marker_object_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/marker_object_links.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="MarkerObjectLinks")
+
+
+
+@_attrs_define
+class MarkerObjectLinks:
+    """ 
+        Attributes:
+            self_ (Union[Unset, str]): The URL of this resource Example: /2/teams/my-
+                team/environments/hcxen_12345678901234567890123456/markers/d1c84ec0.
+     """
+
+    self_: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        self_ = self.self_
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if self_ is not UNSET:
+            field_dict["self"] = self_
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        self_ = d.pop("self", UNSET)
+
+        marker_object_links = cls(
+            self_=self_,
+        )
+
+
+        marker_object_links.additional_properties = d
+        return marker_object_links
+
+    @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.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.marker_object_relationships_dataset import MarkerObjectRelationshipsDataset
+  from ..models.environment_relationship import EnvironmentRelationship
+
+
+
+
+
+T = TypeVar("T", bound="MarkerObjectRelationships")
+
+
+
+@_attrs_define
+class MarkerObjectRelationships:
+    """ 
+        Attributes:
+            environment (Union[Unset, EnvironmentRelationship]): The Environment this object is associated with.
+            dataset (Union[Unset, MarkerObjectRelationshipsDataset]): Optional dataset relationship. If null, this is an
+                environment-wide marker.
+     """
+
+    environment: Union[Unset, 'EnvironmentRelationship'] = UNSET
+    dataset: Union[Unset, 'MarkerObjectRelationshipsDataset'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.marker_object_relationships_dataset import MarkerObjectRelationshipsDataset
+        from ..models.environment_relationship import EnvironmentRelationship
+        environment: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.environment, Unset):
+            environment = self.environment.to_dict()
+
+        dataset: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.dataset, Unset):
+            dataset = self.dataset.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if environment is not UNSET:
+            field_dict["environment"] = environment
+        if dataset is not UNSET:
+            field_dict["dataset"] = dataset
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.marker_object_relationships_dataset import MarkerObjectRelationshipsDataset
+        from ..models.environment_relationship import EnvironmentRelationship
+        d = src_dict.copy()
+        _environment = d.pop("environment", UNSET)
+        environment: Union[Unset, EnvironmentRelationship]
+        if isinstance(_environment,  Unset):
+            environment = UNSET
+        else:
+            environment = EnvironmentRelationship.from_dict(_environment)
+
+
+
+
+        _dataset = d.pop("dataset", UNSET)
+        dataset: Union[Unset, MarkerObjectRelationshipsDataset]
+        if isinstance(_dataset,  Unset):
+            dataset = UNSET
+        else:
+            dataset = MarkerObjectRelationshipsDataset.from_dict(_dataset)
+
+
+
+
+        marker_object_relationships = cls(
+            environment=environment,
+            dataset=dataset,
+        )
+
+
+        marker_object_relationships.additional_properties = d
+        return marker_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/marker_object_relationships_dataset.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 ..types import UNSET, Unset
+from typing import cast
+from typing import cast, Union
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.marker_object_relationships_dataset_data_type_0 import MarkerObjectRelationshipsDatasetDataType0
+
+
+
+
+
+T = TypeVar("T", bound="MarkerObjectRelationshipsDataset")
+
+
+
+@_attrs_define
+class MarkerObjectRelationshipsDataset:
+    """ Optional dataset relationship. If null, this is an environment-wide marker.
+
+        Attributes:
+            data (Union['MarkerObjectRelationshipsDatasetDataType0', None, Unset]):
+     """
+
+    data: Union['MarkerObjectRelationshipsDatasetDataType0', None, Unset] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.marker_object_relationships_dataset_data_type_0 import MarkerObjectRelationshipsDatasetDataType0
+        data: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.data, Unset):
+            data = UNSET
+        elif isinstance(self.data, MarkerObjectRelationshipsDatasetDataType0):
+            data = self.data.to_dict()
+        else:
+            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:
+        from ..models.marker_object_relationships_dataset_data_type_0 import MarkerObjectRelationshipsDatasetDataType0
+        d = src_dict.copy()
+        def _parse_data(data: object) -> Union['MarkerObjectRelationshipsDatasetDataType0', None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                data_type_0 = MarkerObjectRelationshipsDatasetDataType0.from_dict(data)
+
+
+
+                return data_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union['MarkerObjectRelationshipsDatasetDataType0', None, Unset], data)
+
+        data = _parse_data(d.pop("data", UNSET))
+
+
+        marker_object_relationships_dataset = cls(
+            data=data,
+        )
+
+
+        marker_object_relationships_dataset.additional_properties = d
+        return marker_object_relationships_dataset
+
+    @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