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        defn: List[Dict[str, Any]] = [
 63            {
 64                "name": self.views["base_view"],
 65                "always_filter": {
 66                    "filters": [
 67                        {"branch": self.branches},
 68                    ]
 69                },
 70                "hidden": "yes",
 71            },
 72        ]
 73
 74        return defn
 75
 76
 77class OperationalMonitoringAlertingExplore(Explore):
 78    """An Operational Monitoring Alerting Explore."""
 79
 80    type: str = "operational_monitoring_alerting_explore"
 81
 82    def __init__(
 83        self,
 84        name: str,
 85        views: Dict[str, str],
 86        views_path: Optional[Path] = None,
 87        defn: Optional[Dict[str, Any]] = None,
 88    ):
 89        """Initialize OperationalMonitoringExplore."""
 90        super().__init__(name, views, views_path)
 91
 92    @staticmethod
 93    def from_views(views: List[View]) -> Iterator[Explore]:
 94        """Generate an Operational Monitoring explore for this namespace."""
 95        for view in views:
 96            if view.view_type in {
 97                "operational_monitoring_alerting_view",
 98            }:
 99                yield OperationalMonitoringAlertingExplore(
100                    "operational_monitoring",
101                    {"base_view": view.name},
102                )
103
104    @staticmethod
105    def from_dict(
106        name: str, defn: dict, views_path: Path
107    ) -> OperationalMonitoringAlertingExplore:
108        """Get an instance of this explore from a dictionary definition."""
109        return OperationalMonitoringAlertingExplore(
110            name, defn["views"], views_path, defn
111        )
112
113    def _to_lookml(
114        self,
115        v1_name: Optional[str],
116    ) -> List[Dict[str, Any]]:
117        defn: List[Dict[str, Any]] = [
118            {"name": self.views["base_view"], "hidden": "yes"},
119        ]
120
121        return defn