honeycomb-api 0.1.0__py3-none-any.whl

honeycomb/_generated/models/slo_history.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 ..types import UNSET, Unset
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="SLOHistory")
+
+
+
+@_attrs_define
+class SLOHistory:
+    """ 
+        Attributes:
+            timestamp (Union[Unset, int]): The starting Unix timestamp, in seconds since the epoch, for the interval.
+                Example: 1744650000.
+            compliance (Union[Unset, float]): Historical compliance of the SLO in this interval.
+                 Example: 91.44851657940663.
+            budget_remaining (Union[Unset, float]): How much error budget remains for the SLO in this interval.
+                 Example: 14.48516579406632.
+     """
+
+    timestamp: Union[Unset, int] = UNSET
+    compliance: Union[Unset, float] = UNSET
+    budget_remaining: Union[Unset, float] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        timestamp = self.timestamp
+
+        compliance = self.compliance
+
+        budget_remaining = self.budget_remaining
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+        if compliance is not UNSET:
+            field_dict["compliance"] = compliance
+        if budget_remaining is not UNSET:
+            field_dict["budget_remaining"] = budget_remaining
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        timestamp = d.pop("timestamp", UNSET)
+
+        compliance = d.pop("compliance", UNSET)
+
+        budget_remaining = d.pop("budget_remaining", UNSET)
+
+        slo_history = cls(
+            timestamp=timestamp,
+            compliance=compliance,
+            budget_remaining=budget_remaining,
+        )
+
+
+        slo_history.additional_properties = d
+        return slo_history
+
+    @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/slo_history_request.py

@@ -0,0 +1,93 @@
+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
+
+
+
+
+
+
+T = TypeVar("T", bound="SLOHistoryRequest")
+
+
+
+@_attrs_define
+class SLOHistoryRequest:
+    """ 
+        Attributes:
+            ids (list[str]): A list of SLO IDs to retrieve history for. Cannot be an empty array or more than 24 in length.
+                 Example: ['2LBq9LckbcA', 'CzcpPs7cJ4d'].
+            start_time (int): The starting Unix timestamp, in seconds since the epoch, to retrieve historical data for.
+                Cannot be more than a year in the past. Example: 1742230800.
+            end_time (int): The ending Unix timestamp, in seconds since the epoch, to retrieve historical data for. Must be
+                greater than `start_time`. Cannot be a future timestamp. Example: 1745254800.
+     """
+
+    ids: list[str]
+    start_time: int
+    end_time: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        ids = self.ids
+
+
+
+        start_time = self.start_time
+
+        end_time = self.end_time
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "ids": ids,
+            "start_time": start_time,
+            "end_time": end_time,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        ids = cast(list[str], d.pop("ids"))
+
+
+        start_time = d.pop("start_time")
+
+        end_time = d.pop("end_time")
+
+        slo_history_request = cls(
+            ids=ids,
+            start_time=start_time,
+            end_time=end_time,
+        )
+
+
+        slo_history_request.additional_properties = d
+        return slo_history_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/slo_history_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 typing import cast
+
+if TYPE_CHECKING:
+  from ..models.slo_history import SLOHistory
+
+
+
+
+
+T = TypeVar("T", bound="SLOHistoryResponse")
+
+
+
+@_attrs_define
+class SLOHistoryResponse:
+    """ A mapping from SLO IDs (e.g., "2LBq9LckbcA") to their historical data. Each SLO ID maps to an array of compliance
+    and budget intervals.
+
+        Example:
+            {'2LBq9LckbcA': [{'timestamp': 1744650000, 'compliance': 91.44851657940663, 'budget_remaining':
+                14.48516579406632}, {'timestamp': 1744653600, 'compliance': 97.98746514671242, 'budget_remaining':
+                88.13453467953423}], 'CzcpPs7cJ4d': [{'timestamp': 1744650000, 'compliance': 93.53414567784128,
+                'budget_remaining': -71.02966841186735}]}
+
+     """
+
+    additional_properties: dict[str, list['SLOHistory']] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.slo_history import SLOHistory
+        
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = []
+            for additional_property_item_data in prop:
+                additional_property_item = additional_property_item_data.to_dict()
+                field_dict[prop_name].append(additional_property_item)
+
+
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.slo_history import SLOHistory
+        d = src_dict.copy()
+        slo_history_response = cls(
+        )
+
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = []
+            _additional_property = prop_dict
+            for additional_property_item_data in (_additional_property):
+                additional_property_item = SLOHistory.from_dict(additional_property_item_data)
+
+
+
+                additional_property.append(additional_property_item)
+
+            additional_properties[prop_name] = additional_property
+
+        slo_history_response.additional_properties = additional_properties
+        return slo_history_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list['SLOHistory']:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list['SLOHistory']) -> 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/slo_panel.py

@@ -0,0 +1,114 @@
+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 Literal, cast
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.board_panel_position import BoardPanelPosition
+  from ..models.slo_panel_slo_panel import SLOPanelSloPanel
+
+
+
+
+
+T = TypeVar("T", bound="SLOPanel")
+
+
+
+@_attrs_define
+class SLOPanel:
+    """ 
+        Attributes:
+            type_ (Literal['slo']): The type of the board panel.
+            slo_panel (SLOPanelSloPanel):
+            position (Union[Unset, BoardPanelPosition]): The position of the panel within the layout. When X and Y
+                coordinates are not specified for any of the panels, the layout will be generated automatically.
+     """
+
+    type_: Literal['slo']
+    slo_panel: 'SLOPanelSloPanel'
+    position: Union[Unset, 'BoardPanelPosition'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.board_panel_position import BoardPanelPosition
+        from ..models.slo_panel_slo_panel import SLOPanelSloPanel
+        type_ = self.type_
+
+        slo_panel = self.slo_panel.to_dict()
+
+        position: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.position, Unset):
+            position = self.position.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "type": type_,
+            "slo_panel": slo_panel,
+        })
+        if position is not UNSET:
+            field_dict["position"] = position
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.board_panel_position import BoardPanelPosition
+        from ..models.slo_panel_slo_panel import SLOPanelSloPanel
+        d = src_dict.copy()
+        type_ = cast(Literal['slo'] , d.pop("type"))
+        if type_ != 'slo':
+            raise ValueError(f"type must match const 'slo', got '{type_}'")
+
+        slo_panel = SLOPanelSloPanel.from_dict(d.pop("slo_panel"))
+
+
+
+
+        _position = d.pop("position", UNSET)
+        position: Union[Unset, BoardPanelPosition]
+        if isinstance(_position,  Unset):
+            position = UNSET
+        else:
+            position = BoardPanelPosition.from_dict(_position)
+
+
+
+
+        slo_panel = cls(
+            type_=type_,
+            slo_panel=slo_panel,
+            position=position,
+        )
+
+
+        slo_panel.additional_properties = d
+        return slo_panel
+
+    @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/slo_panel_slo_panel.py

@@ -0,0 +1,75 @@
+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="SLOPanelSloPanel")
+
+
+
+@_attrs_define
+class SLOPanelSloPanel:
+    """ 
+        Attributes:
+            slo_id (Union[Unset, str]): The ID of the SLO to display on the board. The SLO must be in the same environment
+                as the board.
+                 Example: BGfyxhFto.
+     """
+
+    slo_id: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        slo_id = self.slo_id
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if slo_id is not UNSET:
+            field_dict["slo_id"] = slo_id
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        slo_id = d.pop("slo_id", UNSET)
+
+        slo_panel_slo_panel = cls(
+            slo_id=slo_id,
+        )
+
+
+        slo_panel_slo_panel.additional_properties = d
+        return slo_panel_slo_panel
+
+    @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/slo_sli.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
+
+
+
+
+
+
+
+T = TypeVar("T", bound="SLOSli")
+
+
+
+@_attrs_define
+class SLOSli:
+    """ Reference to the [Calculated Field](/api/calculated-fields/) used as the indicator of event success.
+
+        Example:
+            {'alias': 'error_sli'}
+
+        Attributes:
+            alias (str): The alias of the Calculated Field (also called Derived Column).
+     """
+
+    alias: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        alias = self.alias
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "alias": alias,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        alias = d.pop("alias")
+
+        slo_sli = cls(
+            alias=alias,
+        )
+
+
+        slo_sli.additional_properties = d
+        return slo_sli
+
+    @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/tag.py

@@ -0,0 +1,79 @@
+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="Tag")
+
+
+
+@_attrs_define
+class Tag:
+    """ 
+        Attributes:
+            key (str): A key to identify the tag, lowercase letters only.
+            value (str): A value for the tag, must begin with a lowercase letter, contain only alphanumeric characters (all
+                letters lowercase) and special characters of `/` and `-` allowed.
+     """
+
+    key: str
+    value: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        key = self.key
+
+        value = self.value
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "key": key,
+            "value": value,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        key = d.pop("key")
+
+        value = d.pop("value")
+
+        tag = cls(
+            key=key,
+            value=value,
+        )
+
+
+        tag.additional_properties = d
+        return tag
+
+    @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/team_relationship.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.team_relationship_team import TeamRelationshipTeam
+
+
+
+
+
+T = TypeVar("T", bound="TeamRelationship")
+
+
+
+@_attrs_define
+class TeamRelationship:
+    """ 
+        Attributes:
+            team (TeamRelationshipTeam):
+     """
+
+    team: 'TeamRelationshipTeam'
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.team_relationship_team import TeamRelationshipTeam
+        team = self.team.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "team": team,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.team_relationship_team import TeamRelationshipTeam
+        d = src_dict.copy()
+        team = TeamRelationshipTeam.from_dict(d.pop("team"))
+
+
+
+
+        team_relationship = cls(
+            team=team,
+        )
+
+
+        team_relationship.additional_properties = d
+        return team_relationship
+
+    @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