honeycomb-api 0.1.0__py3-none-any.whl

honeycomb/_generated/models/query_panel_query_panel.py

@@ -0,0 +1,143 @@
+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.query_panel_query_panel_query_style import QueryPanelQueryPanelQueryStyle
+from ..types import UNSET, Unset
+from typing import cast
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.board_query_visualization_settings import BoardQueryVisualizationSettings
+
+
+
+
+
+T = TypeVar("T", bound="QueryPanelQueryPanel")
+
+
+
+@_attrs_define
+class QueryPanelQueryPanel:
+    """ 
+        Attributes:
+            query_id (str): The ID of the Query to display on the board. The Query must be in the same environment as the
+                board.
+                 Example: abc1234e.
+            query_annotation_id (str): The ID of a Query Annotation that provides a name and description for the Query. The
+                Query Annotation must apply to the `query_id` or `query` specified.
+                 Example: e4c24a35.
+            query_style (Union[Unset, QueryPanelQueryPanelQueryStyle]): How the query should be displayed on the board.
+                Default: QueryPanelQueryPanelQueryStyle.GRAPH.
+            dataset (Union[Unset, str]): The dataset name to which the query is scoped. Empty for environment-wide queries.
+                 Example: My Dataset.
+            visualization_settings (Union[Unset, 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.
+     """
+
+    query_id: str
+    query_annotation_id: str
+    query_style: Union[Unset, QueryPanelQueryPanelQueryStyle] = QueryPanelQueryPanelQueryStyle.GRAPH
+    dataset: Union[Unset, str] = UNSET
+    visualization_settings: Union[Unset, 'BoardQueryVisualizationSettings'] = 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 import BoardQueryVisualizationSettings
+        query_id = self.query_id
+
+        query_annotation_id = self.query_annotation_id
+
+        query_style: Union[Unset, str] = UNSET
+        if not isinstance(self.query_style, Unset):
+            query_style = self.query_style.value
+
+
+        dataset = self.dataset
+
+        visualization_settings: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.visualization_settings, Unset):
+            visualization_settings = self.visualization_settings.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "query_id": query_id,
+            "query_annotation_id": query_annotation_id,
+        })
+        if query_style is not UNSET:
+            field_dict["query_style"] = query_style
+        if dataset is not UNSET:
+            field_dict["dataset"] = dataset
+        if visualization_settings is not UNSET:
+            field_dict["visualization_settings"] = visualization_settings
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.board_query_visualization_settings import BoardQueryVisualizationSettings
+        d = src_dict.copy()
+        query_id = d.pop("query_id")
+
+        query_annotation_id = d.pop("query_annotation_id")
+
+        _query_style = d.pop("query_style", UNSET)
+        query_style: Union[Unset, QueryPanelQueryPanelQueryStyle]
+        if isinstance(_query_style,  Unset):
+            query_style = UNSET
+        else:
+            query_style = QueryPanelQueryPanelQueryStyle(_query_style)
+
+
+
+
+        dataset = d.pop("dataset", UNSET)
+
+        _visualization_settings = d.pop("visualization_settings", UNSET)
+        visualization_settings: Union[Unset, BoardQueryVisualizationSettings]
+        if isinstance(_visualization_settings,  Unset):
+            visualization_settings = UNSET
+        else:
+            visualization_settings = BoardQueryVisualizationSettings.from_dict(_visualization_settings)
+
+
+
+
+        query_panel_query_panel = cls(
+            query_id=query_id,
+            query_annotation_id=query_annotation_id,
+            query_style=query_style,
+            dataset=dataset,
+            visualization_settings=visualization_settings,
+        )
+
+
+        query_panel_query_panel.additional_properties = d
+        return query_panel_query_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/query_panel_query_panel_query_style.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class QueryPanelQueryPanelQueryStyle(str, Enum):
+    COMBO = "combo"
+    GRAPH = "graph"
+    TABLE = "table"
+
+    def __str__(self) -> str:
+        return str(self.value)

honeycomb/_generated/models/query_result.py

@@ -0,0 +1,130 @@
+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.query import Query
+  from ..models.query_result_links import QueryResultLinks
+
+
+
+
+
+T = TypeVar("T", bound="QueryResult")
+
+
+
+@_attrs_define
+class QueryResult:
+    """ A Query Result is created with the Query ID.
+
+        Attributes:
+            query (Union[Unset, Query]):
+            id (Union[Unset, str]): The unique identifier (ID) of a Query Result. Example: sGUnkBHgRFN.
+            complete (Union[Unset, bool]): Indicates if the query results are available yet or not. For example, is the
+                query still being processed or complete?
+            links (Union[Unset, QueryResultLinks]): An object containing UI links to the query result and query result graph
+     """
+
+    query: Union[Unset, 'Query'] = UNSET
+    id: Union[Unset, str] = UNSET
+    complete: Union[Unset, bool] = UNSET
+    links: Union[Unset, 'QueryResultLinks'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.query import Query
+        from ..models.query_result_links import QueryResultLinks
+        query: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.query, Unset):
+            query = self.query.to_dict()
+
+        id = self.id
+
+        complete = self.complete
+
+        links: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.links, Unset):
+            links = self.links.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if query is not UNSET:
+            field_dict["query"] = query
+        if id is not UNSET:
+            field_dict["id"] = id
+        if complete is not UNSET:
+            field_dict["complete"] = complete
+        if links is not UNSET:
+            field_dict["links"] = links
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.query import Query
+        from ..models.query_result_links import QueryResultLinks
+        d = src_dict.copy()
+        _query = d.pop("query", UNSET)
+        query: Union[Unset, Query]
+        if isinstance(_query,  Unset):
+            query = UNSET
+        else:
+            query = Query.from_dict(_query)
+
+
+
+
+        id = d.pop("id", UNSET)
+
+        complete = d.pop("complete", UNSET)
+
+        _links = d.pop("links", UNSET)
+        links: Union[Unset, QueryResultLinks]
+        if isinstance(_links,  Unset):
+            links = UNSET
+        else:
+            links = QueryResultLinks.from_dict(_links)
+
+
+
+
+        query_result = cls(
+            query=query,
+            id=id,
+            complete=complete,
+            links=links,
+        )
+
+
+        query_result.additional_properties = d
+        return query_result
+
+    @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/query_result_details.py

@@ -0,0 +1,156 @@
+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.query import Query
+  from ..models.query_result_details_links import QueryResultDetailsLinks
+  from ..models.query_result_details_data import QueryResultDetailsData
+
+
+
+
+
+T = TypeVar("T", bound="QueryResultDetails")
+
+
+
+@_attrs_define
+class QueryResultDetails:
+    """ Query Results for the Query ID.
+    The response body will be a JSON object with "complete": true and the results populated once the query is complete.
+    The response body will contain caching headers to indicate that once complete, and the Query Result may be cached,
+    as it will not change.
+
+        Attributes:
+            query (Union[Unset, Query]):
+            id (Union[Unset, str]): The unique identifier (ID) of a Query Result Example: sGUnkBHgRFN.
+            complete (Union[Unset, bool]): Indicates if the query results are available yet or not. For example, is the
+                query still being processed or complete? Example: True.
+            data (Union[Unset, QueryResultDetailsData]): An object containing the query result data
+            links (Union[Unset, QueryResultDetailsLinks]): An object containing UI links to the query result and query
+                result graph
+     """
+
+    query: Union[Unset, 'Query'] = UNSET
+    id: Union[Unset, str] = UNSET
+    complete: Union[Unset, bool] = UNSET
+    data: Union[Unset, 'QueryResultDetailsData'] = UNSET
+    links: Union[Unset, 'QueryResultDetailsLinks'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.query import Query
+        from ..models.query_result_details_links import QueryResultDetailsLinks
+        from ..models.query_result_details_data import QueryResultDetailsData
+        query: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.query, Unset):
+            query = self.query.to_dict()
+
+        id = self.id
+
+        complete = self.complete
+
+        data: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.data, Unset):
+            data = self.data.to_dict()
+
+        links: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.links, Unset):
+            links = self.links.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if query is not UNSET:
+            field_dict["query"] = query
+        if id is not UNSET:
+            field_dict["id"] = id
+        if complete is not UNSET:
+            field_dict["complete"] = complete
+        if data is not UNSET:
+            field_dict["data"] = data
+        if links is not UNSET:
+            field_dict["links"] = links
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.query import Query
+        from ..models.query_result_details_links import QueryResultDetailsLinks
+        from ..models.query_result_details_data import QueryResultDetailsData
+        d = src_dict.copy()
+        _query = d.pop("query", UNSET)
+        query: Union[Unset, Query]
+        if isinstance(_query,  Unset):
+            query = UNSET
+        else:
+            query = Query.from_dict(_query)
+
+
+
+
+        id = d.pop("id", UNSET)
+
+        complete = d.pop("complete", UNSET)
+
+        _data = d.pop("data", UNSET)
+        data: Union[Unset, QueryResultDetailsData]
+        if isinstance(_data,  Unset):
+            data = UNSET
+        else:
+            data = QueryResultDetailsData.from_dict(_data)
+
+
+
+
+        _links = d.pop("links", UNSET)
+        links: Union[Unset, QueryResultDetailsLinks]
+        if isinstance(_links,  Unset):
+            links = UNSET
+        else:
+            links = QueryResultDetailsLinks.from_dict(_links)
+
+
+
+
+        query_result_details = cls(
+            query=query,
+            id=id,
+            complete=complete,
+            data=data,
+            links=links,
+        )
+
+
+        query_result_details.additional_properties = d
+        return query_result_details
+
+    @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/query_result_details_data.py

@@ -0,0 +1,188 @@
+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.query_results_series import QueryResultsSeries
+  from ..models.query_results_data import QueryResultsData
+
+
+
+
+
+T = TypeVar("T", bound="QueryResultDetailsData")
+
+
+
+@_attrs_define
+class QueryResultDetailsData:
+    """ An object containing the query result data
+
+        Attributes:
+            series (Union[Unset, list['QueryResultsSeries']]): Timeseries data from the query result (equivalent to the
+                graph data in the Honeycomb UI)
+            results (Union[Unset, list['QueryResultsData']]): Query results data (equivalent to the Overview in the
+                Honeycomb UI below the graph)
+            total_by_aggregate (Union[Unset, QueryResultsData]): Query result details
+            total_by_aggregate_series (Union[Unset, list['QueryResultsSeries']]): Timeseries data showing the total value of
+                each aggregate returned in `total_by_aggregate` across the time range. Aggregate values returned do not respect
+                any Having clauses included in a query. Only available if both `disable_total_by_aggregate` and `disable_series`
+                are set to `false`.
+            other_by_aggregate (Union[Unset, QueryResultsData]): Query result details
+     """
+
+    series: Union[Unset, list['QueryResultsSeries']] = UNSET
+    results: Union[Unset, list['QueryResultsData']] = UNSET
+    total_by_aggregate: Union[Unset, 'QueryResultsData'] = UNSET
+    total_by_aggregate_series: Union[Unset, list['QueryResultsSeries']] = UNSET
+    other_by_aggregate: Union[Unset, 'QueryResultsData'] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.query_results_series import QueryResultsSeries
+        from ..models.query_results_data import QueryResultsData
+        series: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.series, Unset):
+            series = []
+            for series_item_data in self.series:
+                series_item = series_item_data.to_dict()
+                series.append(series_item)
+
+
+
+        results: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.results, Unset):
+            results = []
+            for results_item_data in self.results:
+                results_item = results_item_data.to_dict()
+                results.append(results_item)
+
+
+
+        total_by_aggregate: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.total_by_aggregate, Unset):
+            total_by_aggregate = self.total_by_aggregate.to_dict()
+
+        total_by_aggregate_series: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.total_by_aggregate_series, Unset):
+            total_by_aggregate_series = []
+            for total_by_aggregate_series_item_data in self.total_by_aggregate_series:
+                total_by_aggregate_series_item = total_by_aggregate_series_item_data.to_dict()
+                total_by_aggregate_series.append(total_by_aggregate_series_item)
+
+
+
+        other_by_aggregate: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.other_by_aggregate, Unset):
+            other_by_aggregate = self.other_by_aggregate.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if series is not UNSET:
+            field_dict["series"] = series
+        if results is not UNSET:
+            field_dict["results"] = results
+        if total_by_aggregate is not UNSET:
+            field_dict["total_by_aggregate"] = total_by_aggregate
+        if total_by_aggregate_series is not UNSET:
+            field_dict["total_by_aggregate_series"] = total_by_aggregate_series
+        if other_by_aggregate is not UNSET:
+            field_dict["other_by_aggregate"] = other_by_aggregate
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.query_results_series import QueryResultsSeries
+        from ..models.query_results_data import QueryResultsData
+        d = src_dict.copy()
+        series = []
+        _series = d.pop("series", UNSET)
+        for series_item_data in (_series or []):
+            series_item = QueryResultsSeries.from_dict(series_item_data)
+
+
+
+            series.append(series_item)
+
+
+        results = []
+        _results = d.pop("results", UNSET)
+        for results_item_data in (_results or []):
+            results_item = QueryResultsData.from_dict(results_item_data)
+
+
+
+            results.append(results_item)
+
+
+        _total_by_aggregate = d.pop("total_by_aggregate", UNSET)
+        total_by_aggregate: Union[Unset, QueryResultsData]
+        if isinstance(_total_by_aggregate,  Unset):
+            total_by_aggregate = UNSET
+        else:
+            total_by_aggregate = QueryResultsData.from_dict(_total_by_aggregate)
+
+
+
+
+        total_by_aggregate_series = []
+        _total_by_aggregate_series = d.pop("total_by_aggregate_series", UNSET)
+        for total_by_aggregate_series_item_data in (_total_by_aggregate_series or []):
+            total_by_aggregate_series_item = QueryResultsSeries.from_dict(total_by_aggregate_series_item_data)
+
+
+
+            total_by_aggregate_series.append(total_by_aggregate_series_item)
+
+
+        _other_by_aggregate = d.pop("other_by_aggregate", UNSET)
+        other_by_aggregate: Union[Unset, QueryResultsData]
+        if isinstance(_other_by_aggregate,  Unset):
+            other_by_aggregate = UNSET
+        else:
+            other_by_aggregate = QueryResultsData.from_dict(_other_by_aggregate)
+
+
+
+
+        query_result_details_data = cls(
+            series=series,
+            results=results,
+            total_by_aggregate=total_by_aggregate,
+            total_by_aggregate_series=total_by_aggregate_series,
+            other_by_aggregate=other_by_aggregate,
+        )
+
+
+        query_result_details_data.additional_properties = d
+        return query_result_details_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