generator.explores.operational_monitoring_explore

  1"""Operational Monitoring Explore type."""
  2
  3from __future__ import annotations
  4
  5from pathlib import Path
  6from typing import Any, Dict, Iterator, List, Optional
  7
  8from ..views import View
  9from . import Explore
 10
 11
 12class OperationalMonitoringExplore(Explore):
 13    """An Operational Monitoring Explore."""
 14
 15    type: str = "operational_monitoring_explore"
 16
 17    def __init__(
 18        self,
 19        name: str,
 20        views: Dict[str, str],
 21        views_path: Optional[Path] = None,
 22        defn: Optional[Dict[str, Any]] = None,
 23    ):
 24        """Initialize OperationalMonitoringExplore."""
 25        super().__init__(name, views, views_path)
 26        if defn is not None:
 27            self.branches = ", ".join(defn["branches"])
 28            self.xaxis = defn.get("xaxis")
 29            self.dimensions = defn.get("dimensions", {})
 30            self.summaries = defn.get("summaries", [])
 31
 32    @staticmethod
 33    def from_views(views: List[View]) -> Iterator[Explore]:
 34        """Generate an Operational Monitoring explore for this namespace."""
 35        for view in views:
 36            if view.view_type == "operational_monitoring_view":
 37                yield OperationalMonitoringExplore(
 38                    "operational_monitoring",
 39                    {"base_view": view.name},
 40                )
 41
 42    @staticmethod
 43    def from_dict(
 44        name: str, defn: dict, views_path: Path
 45    ) -> OperationalMonitoringExplore:
 46        """Get an instance of this explore from a dictionary definition."""
 47        return OperationalMonitoringExplore(name, defn["views"], views_path, defn)
 48
 49    def _to_lookml(
 50        self,
 51        v1_name: Optional[str],
 52    ) -> List[Dict[str, Any]]:
 53        base_view_name = self.views["base_view"]
 54
 55        filters = [
 56            {f"{base_view_name}.branch": self.branches},
 57        ]
 58        for dimension, info in self.dimensions.items():
 59            if "default" in info:
 60                filters.append({f"{base_view_name}.{dimension}": info["default"]})
 61
 62        explore_lookml = {
 63            "name": self.views["base_view"],
 64            "always_filter": {
 65                "filters": [
 66                    {"branch": self.branches},
 67                ]
 68            },
 69            "hidden": "yes",
 70        }
 71
 72        if datagroup := self.get_datagroup():
 73            explore_lookml["persist_with"] = datagroup
 74
 75        defn: List[Dict[str, Any]] = [explore_lookml]
 76
 77        return defn
 78
 79
 80class OperationalMonitoringAlertingExplore(Explore):
 81    """An Operational Monitoring Alerting Explore."""
 82
 83    type: str = "operational_monitoring_alerting_explore"
 84
 85    def __init__(
 86        self,
 87        name: str,
 88        views: Dict[str, str],
 89        views_path: Optional[Path] = None,
 90        defn: Optional[Dict[str, Any]] = None,
 91    ):
 92        """Initialize OperationalMonitoringExplore."""
 93        super().__init__(name, views, views_path)
 94
 95    @staticmethod
 96    def from_views(views: List[View]) -> Iterator[Explore]:
 97        """Generate an Operational Monitoring explore for this namespace."""
 98        for view in views:
 99            if view.view_type in {
100                "operational_monitoring_alerting_view",
101            }:
102                yield OperationalMonitoringAlertingExplore(
103                    "operational_monitoring",
104                    {"base_view": view.name},
105                )
106
107    @staticmethod
108    def from_dict(
109        name: str, defn: dict, views_path: Path
110    ) -> OperationalMonitoringAlertingExplore:
111        """Get an instance of this explore from a dictionary definition."""
112        return OperationalMonitoringAlertingExplore(
113            name, defn["views"], views_path, defn
114        )
115
116    def _to_lookml(
117        self,
118        v1_name: Optional[str],
119    ) -> List[Dict[str, Any]]:
120        explore_lookml = {"name": self.views["base_view"], "hidden": "yes"}
121
122        if datagroup := self.get_datagroup():
123            explore_lookml["persist_with"] = datagroup
124
125        defn: List[Dict[str, Any]] = [explore_lookml]
126
127        return defn