honeycomb-api 0.1.0__py3-none-any.whl

honeycomb/_generated/models/board_panel_position.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 Union
+
+
+
+
+
+
+T = TypeVar("T", bound="BoardPanelPosition")
+
+
+
+@_attrs_define
+class 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.
+
+        Attributes:
+            x_coordinate (Union[Unset, int]): The x-axis origin point for placing the panel within the layout.
+            y_coordinate (Union[Unset, int]): The y-axis origin point for placing the panel within the layout.
+            height (Union[Unset, int]): The height of the panel. When not specified or set to 0, the height of the panel is
+                calculated dynamically based on the panel type.
+            width (Union[Unset, int]): The width of the panel. When not specified or set to 0, the width of the panel is
+                calculated dynamically based on the panel type.
+     """
+
+    x_coordinate: Union[Unset, int] = UNSET
+    y_coordinate: Union[Unset, int] = UNSET
+    height: Union[Unset, int] = UNSET
+    width: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        x_coordinate = self.x_coordinate
+
+        y_coordinate = self.y_coordinate
+
+        height = self.height
+
+        width = self.width
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if x_coordinate is not UNSET:
+            field_dict["x_coordinate"] = x_coordinate
+        if y_coordinate is not UNSET:
+            field_dict["y_coordinate"] = y_coordinate
+        if height is not UNSET:
+            field_dict["height"] = height
+        if width is not UNSET:
+            field_dict["width"] = width
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        x_coordinate = d.pop("x_coordinate", UNSET)
+
+        y_coordinate = d.pop("y_coordinate", UNSET)
+
+        height = d.pop("height", UNSET)
+
+        width = d.pop("width", UNSET)
+
+        board_panel_position = cls(
+            x_coordinate=x_coordinate,
+            y_coordinate=y_coordinate,
+            height=height,
+            width=width,
+        )
+
+
+        board_panel_position.additional_properties = d
+        return board_panel_position
+
+    @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_query_visualization_settings.py

@@ -0,0 +1,141 @@
+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.board_query_visualization_settings_charts_item import BoardQueryVisualizationSettingsChartsItem
+
+
+
+
+
+T = TypeVar("T", bound="BoardQueryVisualizationSettings")
+
+
+
+@_attrs_define
+class BoardQueryVisualizationSettings:
+    """ A map of values to control the display settings for the Query on the Board. Unspecified boolean values are assumed
+    to be `false`. Unspecified integers are assumed to be `0`, unspecified arrays are assumed to be null and unspecified
+    strings are assumed to be empty. This is incompatible with the `graph_settings` field.
+
+        Attributes:
+            hide_compare (Union[Unset, bool]):  Default: False.
+            hide_hovers (Union[Unset, bool]):  Default: False.
+            hide_markers (Union[Unset, bool]):  Default: False.
+            utc_xaxis (Union[Unset, bool]):  Default: False.
+            overlaid_charts (Union[Unset, bool]):  Default: False.
+            charts (Union[Unset, list['BoardQueryVisualizationSettingsChartsItem']]):
+     """
+
+    hide_compare: Union[Unset, bool] = False
+    hide_hovers: Union[Unset, bool] = False
+    hide_markers: Union[Unset, bool] = False
+    utc_xaxis: Union[Unset, bool] = False
+    overlaid_charts: Union[Unset, bool] = False
+    charts: Union[Unset, list['BoardQueryVisualizationSettingsChartsItem']] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.board_query_visualization_settings_charts_item import BoardQueryVisualizationSettingsChartsItem
+        hide_compare = self.hide_compare
+
+        hide_hovers = self.hide_hovers
+
+        hide_markers = self.hide_markers
+
+        utc_xaxis = self.utc_xaxis
+
+        overlaid_charts = self.overlaid_charts
+
+        charts: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.charts, Unset):
+            charts = []
+            for charts_item_data in self.charts:
+                charts_item = charts_item_data.to_dict()
+                charts.append(charts_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if hide_compare is not UNSET:
+            field_dict["hide_compare"] = hide_compare
+        if hide_hovers is not UNSET:
+            field_dict["hide_hovers"] = hide_hovers
+        if hide_markers is not UNSET:
+            field_dict["hide_markers"] = hide_markers
+        if utc_xaxis is not UNSET:
+            field_dict["utc_xaxis"] = utc_xaxis
+        if overlaid_charts is not UNSET:
+            field_dict["overlaid_charts"] = overlaid_charts
+        if charts is not UNSET:
+            field_dict["charts"] = charts
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.board_query_visualization_settings_charts_item import BoardQueryVisualizationSettingsChartsItem
+        d = src_dict.copy()
+        hide_compare = d.pop("hide_compare", UNSET)
+
+        hide_hovers = d.pop("hide_hovers", UNSET)
+
+        hide_markers = d.pop("hide_markers", UNSET)
+
+        utc_xaxis = d.pop("utc_xaxis", UNSET)
+
+        overlaid_charts = d.pop("overlaid_charts", UNSET)
+
+        charts = []
+        _charts = d.pop("charts", UNSET)
+        for charts_item_data in (_charts or []):
+            charts_item = BoardQueryVisualizationSettingsChartsItem.from_dict(charts_item_data)
+
+
+
+            charts.append(charts_item)
+
+
+        board_query_visualization_settings = cls(
+            hide_compare=hide_compare,
+            hide_hovers=hide_hovers,
+            hide_markers=hide_markers,
+            utc_xaxis=utc_xaxis,
+            overlaid_charts=overlaid_charts,
+            charts=charts,
+        )
+
+
+        board_query_visualization_settings.additional_properties = d
+        return board_query_visualization_settings
+
+    @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_query_visualization_settings_charts_item.py

@@ -0,0 +1,113 @@
+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_query_visualization_settings_charts_item_chart_type import BoardQueryVisualizationSettingsChartsItemChartType
+from ..types import UNSET, Unset
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="BoardQueryVisualizationSettingsChartsItem")
+
+
+
+@_attrs_define
+class BoardQueryVisualizationSettingsChartsItem:
+    """ 
+        Attributes:
+            chart_index (Union[Unset, int]):  Default: 0.
+            chart_type (Union[Unset, BoardQueryVisualizationSettingsChartsItemChartType]):  Default:
+                BoardQueryVisualizationSettingsChartsItemChartType.DEFAULT.
+            log_scale (Union[Unset, bool]):  Default: False.
+            omit_missing_values (Union[Unset, bool]):  Default: False.
+     """
+
+    chart_index: Union[Unset, int] = 0
+    chart_type: Union[Unset, BoardQueryVisualizationSettingsChartsItemChartType] = BoardQueryVisualizationSettingsChartsItemChartType.DEFAULT
+    log_scale: Union[Unset, bool] = False
+    omit_missing_values: Union[Unset, bool] = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        chart_index = self.chart_index
+
+        chart_type: Union[Unset, str] = UNSET
+        if not isinstance(self.chart_type, Unset):
+            chart_type = self.chart_type.value
+
+
+        log_scale = self.log_scale
+
+        omit_missing_values = self.omit_missing_values
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if chart_index is not UNSET:
+            field_dict["chart_index"] = chart_index
+        if chart_type is not UNSET:
+            field_dict["chart_type"] = chart_type
+        if log_scale is not UNSET:
+            field_dict["log_scale"] = log_scale
+        if omit_missing_values is not UNSET:
+            field_dict["omit_missing_values"] = omit_missing_values
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        chart_index = d.pop("chart_index", UNSET)
+
+        _chart_type = d.pop("chart_type", UNSET)
+        chart_type: Union[Unset, BoardQueryVisualizationSettingsChartsItemChartType]
+        if isinstance(_chart_type,  Unset):
+            chart_type = UNSET
+        else:
+            chart_type = BoardQueryVisualizationSettingsChartsItemChartType(_chart_type)
+
+
+
+
+        log_scale = d.pop("log_scale", UNSET)
+
+        omit_missing_values = d.pop("omit_missing_values", UNSET)
+
+        board_query_visualization_settings_charts_item = cls(
+            chart_index=chart_index,
+            chart_type=chart_type,
+            log_scale=log_scale,
+            omit_missing_values=omit_missing_values,
+        )
+
+
+        board_query_visualization_settings_charts_item.additional_properties = d
+        return board_query_visualization_settings_charts_item
+
+    @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_query_visualization_settings_charts_item_chart_type.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+class BoardQueryVisualizationSettingsChartsItemChartType(str, Enum):
+    CBAR = "cbar"
+    CPIE = "cpie"
+    DEFAULT = "default"
+    LINE = "line"
+    STACKED = "stacked"
+    STAT = "stat"
+    TSBAR = "tsbar"
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/board_type.py

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

honeycomb/_generated/models/board_view_filter.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 ..models.board_view_filter_operation import BoardViewFilterOperation
+from ..types import UNSET, Unset
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="BoardViewFilter")
+
+
+
+@_attrs_define
+class BoardViewFilter:
+    """ 
+        Attributes:
+            column (str): The column name to filter on. Example: status.
+            operation (BoardViewFilterOperation): The filter operation. Example: =.
+            value (Union[Unset, Any]): The value to filter by. Example: error.
+     """
+
+    column: str
+    operation: BoardViewFilterOperation
+    value: Union[Unset, Any] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        column = self.column
+
+        operation = self.operation.value
+
+        value = self.value
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "column": column,
+            "operation": operation,
+        })
+        if value is not UNSET:
+            field_dict["value"] = value
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        column = d.pop("column")
+
+        operation = BoardViewFilterOperation(d.pop("operation"))
+
+
+
+
+        value = d.pop("value", UNSET)
+
+        board_view_filter = cls(
+            column=column,
+            operation=operation,
+            value=value,
+        )
+
+
+        board_view_filter.additional_properties = d
+        return board_view_filter
+
+    @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_view_filter_operation.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+class BoardViewFilterOperation(str, Enum):
+    CONTAINS = "contains"
+    DOES_NOT_CONTAIN = "does-not-contain"
+    DOES_NOT_END_WITH = "does-not-end-with"
+    DOES_NOT_EXIST = "does-not-exist"
+    DOES_NOT_START_WITH = "does-not-start-with"
+    ENDS_WITH = "ends-with"
+    EXISTS = "exists"
+    IN = "in"
+    NOT_IN = "not-in"
+    STARTS_WITH = "starts-with"
+    VALUE_0 = "="
+    VALUE_1 = "!="
+    VALUE_2 = ">"
+    VALUE_3 = ">="
+    VALUE_4 = "<"
+    VALUE_5 = "<="
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/board_view_response.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.board_view_filter import BoardViewFilter
+
+
+
+
+
+T = TypeVar("T", bound="BoardViewResponse")
+
+
+
+@_attrs_define
+class BoardViewResponse:
+    """ 
+        Attributes:
+            id (Union[Unset, str]): Unique identifier for the board view. Example: eC_abc123.
+            name (Union[Unset, str]): The name of the view. Example: My View.
+            filters (Union[Unset, list['BoardViewFilter']]):
+     """
+
+    id: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    filters: Union[Unset, list['BoardViewFilter']] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.board_view_filter import BoardViewFilter
+        id = self.id
+
+        name = self.name
+
+        filters: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.filters, Unset):
+            filters = []
+            for filters_item_data in self.filters:
+                filters_item = filters_item_data.to_dict()
+                filters.append(filters_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if id is not UNSET:
+            field_dict["id"] = id
+        if name is not UNSET:
+            field_dict["name"] = name
+        if filters is not UNSET:
+            field_dict["filters"] = filters
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.board_view_filter import BoardViewFilter
+        d = src_dict.copy()
+        id = d.pop("id", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        filters = []
+        _filters = d.pop("filters", UNSET)
+        for filters_item_data in (_filters or []):
+            filters_item = BoardViewFilter.from_dict(filters_item_data)
+
+
+
+            filters.append(filters_item)
+
+
+        board_view_response = cls(
+            id=id,
+            name=name,
+            filters=filters,
+        )
+
+
+        board_view_response.additional_properties = d
+        return board_view_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