honeycomb-api 0.1.0__py3-none-any.whl

honeycomb/_generated/models/base_trigger_evaluation_schedule_window.py

@@ -0,0 +1,103 @@
+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.base_trigger_evaluation_schedule_window_days_of_week_item import BaseTriggerEvaluationScheduleWindowDaysOfWeekItem
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="BaseTriggerEvaluationScheduleWindow")
+
+
+
+@_attrs_define
+class BaseTriggerEvaluationScheduleWindow:
+    """ Window start/end times and days of the week are calculated in UTC. If the end time is the same as or earlier than
+    the start time, the end time is treated as being in the following day.
+
+        Attributes:
+            days_of_week (list[BaseTriggerEvaluationScheduleWindowDaysOfWeekItem]):
+            start_time (str): A UTC time in HH:mm format (13:00) Example: 840.
+            end_time (str): A UTC time in HH:mm format (13:00) Example: 1260.
+     """
+
+    days_of_week: list[BaseTriggerEvaluationScheduleWindowDaysOfWeekItem]
+    start_time: str
+    end_time: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        days_of_week = []
+        for days_of_week_item_data in self.days_of_week:
+            days_of_week_item = days_of_week_item_data.value
+            days_of_week.append(days_of_week_item)
+
+
+
+        start_time = self.start_time
+
+        end_time = self.end_time
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "days_of_week": days_of_week,
+            "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()
+        days_of_week = []
+        _days_of_week = d.pop("days_of_week")
+        for days_of_week_item_data in (_days_of_week):
+            days_of_week_item = BaseTriggerEvaluationScheduleWindowDaysOfWeekItem(days_of_week_item_data)
+
+
+
+            days_of_week.append(days_of_week_item)
+
+
+        start_time = d.pop("start_time")
+
+        end_time = d.pop("end_time")
+
+        base_trigger_evaluation_schedule_window = cls(
+            days_of_week=days_of_week,
+            start_time=start_time,
+            end_time=end_time,
+        )
+
+
+        base_trigger_evaluation_schedule_window.additional_properties = d
+        return base_trigger_evaluation_schedule_window
+
+    @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/base_trigger_evaluation_schedule_window_days_of_week_item.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+class BaseTriggerEvaluationScheduleWindowDaysOfWeekItem(str, Enum):
+    FRIDAY = "friday"
+    MONDAY = "monday"
+    SATURDAY = "saturday"
+    SUNDAY = "sunday"
+    THURSDAY = "thursday"
+    TUESDAY = "tuesday"
+    WEDNESDAY = "wednesday"
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/base_trigger_threshold.py

@@ -0,0 +1,95 @@
+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.base_trigger_threshold_op import BaseTriggerThresholdOp
+from ..types import UNSET, Unset
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="BaseTriggerThreshold")
+
+
+
+@_attrs_define
+class BaseTriggerThreshold:
+    """ The threshold over which the trigger will fire, specified as both an operator and a value.
+
+        Attributes:
+            op (BaseTriggerThresholdOp):
+            value (float):
+            exceeded_limit (Union[Unset, int]): The number of times the threshold must be met before an alert is sent.
+                 Default: 1.
+     """
+
+    op: BaseTriggerThresholdOp
+    value: float
+    exceeded_limit: Union[Unset, int] = 1
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        op = self.op.value
+
+        value = self.value
+
+        exceeded_limit = self.exceeded_limit
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "op": op,
+            "value": value,
+        })
+        if exceeded_limit is not UNSET:
+            field_dict["exceeded_limit"] = exceeded_limit
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        op = BaseTriggerThresholdOp(d.pop("op"))
+
+
+
+
+        value = d.pop("value")
+
+        exceeded_limit = d.pop("exceeded_limit", UNSET)
+
+        base_trigger_threshold = cls(
+            op=op,
+            value=value,
+            exceeded_limit=exceeded_limit,
+        )
+
+
+        base_trigger_threshold.additional_properties = d
+        return base_trigger_threshold
+
+    @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/base_trigger_threshold_op.py

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

honeycomb/_generated/models/batch_event.py

@@ -0,0 +1,110 @@
+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.event import Event
+
+
+
+
+
+T = TypeVar("T", bound="BatchEvent")
+
+
+
+@_attrs_define
+class BatchEvent:
+    """ 
+        Attributes:
+            data (Union[Unset, Event]):
+            time (Union[Unset, str]): Should be in RFC3339 high precision format (for example, YYYY-MM-DDTHH:MM:SS.mmmZ).
+                May be a Unix epoch (seconds since 1970) with second or greater precision (for example, 1452759330927).
+                Optional. If not set, defaults to the time that the API receives the event.
+            samplerate (Union[Unset, int]): An integer representing the denominator in the fraction 1/n when client-side
+                sampling has been applied. Optional. If not set, defaults to `1`, meaning "not sampled". Refer to
+                [Sampling](https://docs.honeycomb.io/manage-data-volume/sample/sampled-data-in-honeycomb/) for more detail.
+     """
+
+    data: Union[Unset, 'Event'] = UNSET
+    time: Union[Unset, str] = UNSET
+    samplerate: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.event import Event
+        data: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.data, Unset):
+            data = self.data.to_dict()
+
+        time = self.time
+
+        samplerate = self.samplerate
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if data is not UNSET:
+            field_dict["data"] = data
+        if time is not UNSET:
+            field_dict["time"] = time
+        if samplerate is not UNSET:
+            field_dict["samplerate"] = samplerate
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.event import Event
+        d = src_dict.copy()
+        _data = d.pop("data", UNSET)
+        data: Union[Unset, Event]
+        if isinstance(_data,  Unset):
+            data = UNSET
+        else:
+            data = Event.from_dict(_data)
+
+
+
+
+        time = d.pop("time", UNSET)
+
+        samplerate = d.pop("samplerate", UNSET)
+
+        batch_event = cls(
+            data=data,
+            time=time,
+            samplerate=samplerate,
+        )
+
+
+        batch_event.additional_properties = d
+        return batch_event
+
+    @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/board.py

@@ -0,0 +1,276 @@
+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.board_layout_generation import BoardLayoutGeneration
+from ..models.board_type import BoardType
+from ..types import UNSET, Unset
+from typing import cast
+from typing import cast, Union
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.preset_filter import PresetFilter
+  from ..models.tag import Tag
+  from ..models.text_panel import TextPanel
+  from ..models.slo_panel import SLOPanel
+  from ..models.query_panel import QueryPanel
+  from ..models.board_links import BoardLinks
+
+
+
+
+
+T = TypeVar("T", bound="Board")
+
+
+
+@_attrs_define
+class Board:
+    """ 
+        Attributes:
+            name (str): The name of the Board. Example: My Board.
+            type_ (BoardType): The type of the board. Only flexible boards are supported.
+            description (Union[Unset, str]): A description of the Board. Example: A board created via the API.
+            links (Union[Unset, BoardLinks]):
+            id (Union[Unset, str]): Unique identifier (ID), returned in response bodies. Example: 2NeeaE9bBLd.
+            panels (Union[Unset, list[Union['QueryPanel', 'SLOPanel', 'TextPanel']]]):
+            layout_generation (Union[Unset, BoardLayoutGeneration]): The layout generation mode for the board. When set to
+                "auto", the board will be automatically laid out based on the panels. When set to "manual", the board will be
+                laid out manually by the user.
+                 Default: BoardLayoutGeneration.MANUAL.
+            tags (Union[Unset, list['Tag']]): A list of key-value pairs to help identify the Trigger. Example: [{'key':
+                'team', 'value': 'blue'}].
+            preset_filters (Union[Unset, list['PresetFilter']]): A list of preset filters to apply to the board. For
+                backwards compatibility, if no preset filters are provided, the existing preset filters will be preserved. If an
+                empty array is provided, all preset filters will be deleted. Example: [{'column': 'app.Service', 'alias':
+                'Service'}].
+     """
+
+    name: str
+    type_: BoardType
+    description: Union[Unset, str] = UNSET
+    links: Union[Unset, 'BoardLinks'] = UNSET
+    id: Union[Unset, str] = UNSET
+    panels: Union[Unset, list[Union['QueryPanel', 'SLOPanel', 'TextPanel']]] = UNSET
+    layout_generation: Union[Unset, BoardLayoutGeneration] = BoardLayoutGeneration.MANUAL
+    tags: Union[Unset, list['Tag']] = UNSET
+    preset_filters: Union[Unset, list['PresetFilter']] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.preset_filter import PresetFilter
+        from ..models.tag import Tag
+        from ..models.text_panel import TextPanel
+        from ..models.slo_panel import SLOPanel
+        from ..models.query_panel import QueryPanel
+        from ..models.board_links import BoardLinks
+        name = self.name
+
+        type_ = self.type_.value
+
+        description = self.description
+
+        links: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.links, Unset):
+            links = self.links.to_dict()
+
+        id = self.id
+
+        panels: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.panels, Unset):
+            panels = []
+            for panels_item_data in self.panels:
+                panels_item: dict[str, Any]
+                if isinstance(panels_item_data, QueryPanel):
+                    panels_item = panels_item_data.to_dict()
+                elif isinstance(panels_item_data, SLOPanel):
+                    panels_item = panels_item_data.to_dict()
+                else:
+                    panels_item = panels_item_data.to_dict()
+
+                panels.append(panels_item)
+
+
+
+        layout_generation: Union[Unset, str] = UNSET
+        if not isinstance(self.layout_generation, Unset):
+            layout_generation = self.layout_generation.value
+
+
+        tags: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.tags, Unset):
+            tags = []
+            for tags_item_data in self.tags:
+                tags_item = tags_item_data.to_dict()
+                tags.append(tags_item)
+
+
+
+        preset_filters: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.preset_filters, Unset):
+            preset_filters = []
+            for preset_filters_item_data in self.preset_filters:
+                preset_filters_item = preset_filters_item_data.to_dict()
+                preset_filters.append(preset_filters_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "name": name,
+            "type": type_,
+        })
+        if description is not UNSET:
+            field_dict["description"] = description
+        if links is not UNSET:
+            field_dict["links"] = links
+        if id is not UNSET:
+            field_dict["id"] = id
+        if panels is not UNSET:
+            field_dict["panels"] = panels
+        if layout_generation is not UNSET:
+            field_dict["layout_generation"] = layout_generation
+        if tags is not UNSET:
+            field_dict["tags"] = tags
+        if preset_filters is not UNSET:
+            field_dict["preset_filters"] = preset_filters
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.preset_filter import PresetFilter
+        from ..models.tag import Tag
+        from ..models.text_panel import TextPanel
+        from ..models.slo_panel import SLOPanel
+        from ..models.query_panel import QueryPanel
+        from ..models.board_links import BoardLinks
+        d = src_dict.copy()
+        name = d.pop("name")
+
+        type_ = BoardType(d.pop("type"))
+
+
+
+
+        description = d.pop("description", UNSET)
+
+        _links = d.pop("links", UNSET)
+        links: Union[Unset, BoardLinks]
+        if isinstance(_links,  Unset):
+            links = UNSET
+        else:
+            links = BoardLinks.from_dict(_links)
+
+
+
+
+        id = d.pop("id", UNSET)
+
+        panels = []
+        _panels = d.pop("panels", UNSET)
+        for panels_item_data in (_panels or []):
+            def _parse_panels_item(data: object) -> Union['QueryPanel', 'SLOPanel', 'TextPanel']:
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_board_panel_type_0 = QueryPanel.from_dict(data)
+
+
+
+                    return componentsschemas_board_panel_type_0
+                except: # noqa: E722
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_board_panel_type_1 = SLOPanel.from_dict(data)
+
+
+
+                    return componentsschemas_board_panel_type_1
+                except: # noqa: E722
+                    pass
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_board_panel_type_2 = TextPanel.from_dict(data)
+
+
+
+                return componentsschemas_board_panel_type_2
+
+            panels_item = _parse_panels_item(panels_item_data)
+
+            panels.append(panels_item)
+
+
+        _layout_generation = d.pop("layout_generation", UNSET)
+        layout_generation: Union[Unset, BoardLayoutGeneration]
+        if isinstance(_layout_generation,  Unset):
+            layout_generation = UNSET
+        else:
+            layout_generation = BoardLayoutGeneration(_layout_generation)
+
+
+
+
+        tags = []
+        _tags = d.pop("tags", UNSET)
+        for tags_item_data in (_tags or []):
+            tags_item = Tag.from_dict(tags_item_data)
+
+
+
+            tags.append(tags_item)
+
+
+        preset_filters = []
+        _preset_filters = d.pop("preset_filters", UNSET)
+        for preset_filters_item_data in (_preset_filters or []):
+            preset_filters_item = PresetFilter.from_dict(preset_filters_item_data)
+
+
+
+            preset_filters.append(preset_filters_item)
+
+
+        board = cls(
+            name=name,
+            type_=type_,
+            description=description,
+            links=links,
+            id=id,
+            panels=panels,
+            layout_generation=layout_generation,
+            tags=tags,
+            preset_filters=preset_filters,
+        )
+
+
+        board.additional_properties = d
+        return board
+
+    @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/board_layout_generation.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class BoardLayoutGeneration(str, Enum):
+    AUTO = "auto"
+    MANUAL = "manual"
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/board_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="BoardLinks")
+
+
+
+@_attrs_define
+class BoardLinks:
+    """ 
+        Attributes:
+            board_url (Union[Unset, str]):  Example:
+                https://ui.honeycomb.io/myteam/environments/myenvironment/board/2NeeaE9bBLd.
+     """
+
+    board_url: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        board_url = self.board_url
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if board_url is not UNSET:
+            field_dict["board_url"] = board_url
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        board_url = d.pop("board_url", UNSET)
+
+        board_links = cls(
+            board_url=board_url,
+        )
+
+
+        board_links.additional_properties = d
+        return board_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