honeycomb-api 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,82 @@
+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.team_relationship_team_data_type import TeamRelationshipTeamDataType
+
+
+
+
+
+
+T = TypeVar("T", bound="TeamRelationshipTeamData")
+
+
+
+@_attrs_define
+class TeamRelationshipTeamData:
+    """ 
+        Attributes:
+            id (str): The ID of the Team this object is associated with Example: hxctm_12345678901234567890123456.
+            type_ (TeamRelationshipTeamDataType):
+     """
+
+    id: str
+    type_: TeamRelationshipTeamDataType
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        type_ = self.type_.value
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "id": id,
+            "type": type_,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        id = d.pop("id")
+
+        type_ = TeamRelationshipTeamDataType(d.pop("type"))
+
+
+
+
+        team_relationship_team_data = cls(
+            id=id,
+            type_=type_,
+        )
+
+
+        team_relationship_team_data.additional_properties = d
+        return team_relationship_team_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/team_relationship_team_data_type.py

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

honeycomb/_generated/models/template_variable_definition.py

@@ -0,0 +1,81 @@
+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="TemplateVariableDefinition")
+
+
+
+@_attrs_define
+class TemplateVariableDefinition:
+    """ 
+        Attributes:
+            name (str):  Example: severity.
+            default_value (Union[Unset, str]):  Example: CRITICAL.
+     """
+
+    name: str
+    default_value: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        default_value = self.default_value
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "name": name,
+        })
+        if default_value is not UNSET:
+            field_dict["default_value"] = default_value
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        name = d.pop("name")
+
+        default_value = d.pop("default_value", UNSET)
+
+        template_variable_definition = cls(
+            name=name,
+            default_value=default_value,
+        )
+
+
+        template_variable_definition.additional_properties = d
+        return template_variable_definition
+
+    @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/text_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.text_panel_text_panel import TextPanelTextPanel
+
+
+
+
+
+T = TypeVar("T", bound="TextPanel")
+
+
+
+@_attrs_define
+class TextPanel:
+    """ 
+        Attributes:
+            type_ (Literal['text']): The type of the board panel.
+            text_panel (TextPanelTextPanel):
+            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['text']
+    text_panel: 'TextPanelTextPanel'
+    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.text_panel_text_panel import TextPanelTextPanel
+        type_ = self.type_
+
+        text_panel = self.text_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_,
+            "text_panel": text_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.text_panel_text_panel import TextPanelTextPanel
+        d = src_dict.copy()
+        type_ = cast(Literal['text'] , d.pop("type"))
+        if type_ != 'text':
+            raise ValueError(f"type must match const 'text', got '{type_}'")
+
+        text_panel = TextPanelTextPanel.from_dict(d.pop("text_panel"))
+
+
+
+
+        _position = d.pop("position", UNSET)
+        position: Union[Unset, BoardPanelPosition]
+        if isinstance(_position,  Unset):
+            position = UNSET
+        else:
+            position = BoardPanelPosition.from_dict(_position)
+
+
+
+
+        text_panel = cls(
+            type_=type_,
+            text_panel=text_panel,
+            position=position,
+        )
+
+
+        text_panel.additional_properties = d
+        return text_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/text_panel_text_panel.py

@@ -0,0 +1,71 @@
+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="TextPanelTextPanel")
+
+
+
+@_attrs_define
+class TextPanelTextPanel:
+    """ 
+        Attributes:
+            content (str): The text content to display on the board panel. This field supports Markdown formatting.
+                 Example: # This is a text panel with some content.
+     """
+
+    content: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        content = self.content
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "content": content,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        content = d.pop("content")
+
+        text_panel_text_panel = cls(
+            content=content,
+        )
+
+
+        text_panel_text_panel.additional_properties = d
+        return text_panel_text_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