generator.views.events_view

  1"""Class to describe an Events view."""
  2
  3from __future__ import annotations
  4
  5from copy import deepcopy
  6from typing import Any, Dict, Iterator, List, Optional
  7
  8from . import lookml_utils
  9from .view import View, ViewDict
 10
 11
 12class EventsView(View):
 13    """A view for querying events data, with one row per-event."""
 14
 15    type: str = "events_view"
 16
 17    default_measures: List[Dict[str, str]] = [
 18        {
 19            "name": "event_count",
 20            "type": "count",
 21            "description": ("The number of times the event(s) occurred."),
 22        },
 23    ]
 24
 25    def __init__(self, namespace: str, name: str, tables: List[Dict[str, str]]):
 26        """Get an instance of an EventsView."""
 27        super().__init__(namespace, name, EventsView.type, tables)
 28
 29    @classmethod
 30    def from_db_views(
 31        klass,
 32        namespace: str,
 33        is_glean: bool,
 34        channels: List[Dict[str, str]],
 35        db_views: dict,
 36    ) -> Iterator[EventsView]:
 37        """Get Events Views from db views and app variants."""
 38        # We can guarantee there will always be at least one channel,
 39        # because this comes from the associated _get_glean_repos in
 40        # namespaces.py
 41        dataset = next(
 42            (channel for channel in channels if channel.get("channel") == "release"),
 43            channels[0],
 44        )["dataset"]
 45
 46        for view_id, references in db_views[dataset].items():
 47            if view_id == "events_unnested":
 48                yield EventsView(
 49                    namespace,
 50                    "events",
 51                    [
 52                        {
 53                            "events_table_view": "events_unnested_table",
 54                            "base_table": f"mozdata.{dataset}.{view_id}",
 55                        }
 56                    ],
 57                )
 58
 59    @classmethod
 60    def from_dict(klass, namespace: str, name: str, _dict: ViewDict) -> EventsView:
 61        """Get a view from a name and dict definition."""
 62        return EventsView(namespace, name, _dict["tables"])
 63
 64    def to_lookml(self, v1_name: Optional[str], dryrun) -> Dict[str, Any]:
 65        """Generate LookML for this view."""
 66        view_defn: Dict[str, Any] = {
 67            "extends": [self.tables[0]["events_table_view"]],
 68            "name": self.name,
 69        }
 70
 71        # add measures
 72        dimensions = lookml_utils._generate_dimensions(
 73            self.tables[0]["base_table"], dryrun=dryrun
 74        )
 75        view_defn["measures"] = self.get_measures(dimensions)
 76
 77        # set document_id as primary key if it exists in the underlying table
 78        # this will allow one_to_many joins
 79        event_id_dimension = self.generate_event_id_dimension(dimensions)
 80        if event_id_dimension is not None:
 81            view_defn["dimensions"] = [event_id_dimension]
 82
 83        return {
 84            "includes": [f"{self.tables[0]['events_table_view']}.view.lkml"],
 85            "views": [view_defn],
 86        }
 87
 88    def get_measures(self, dimensions) -> List[Dict[str, str]]:
 89        """Generate measures for Events Views."""
 90        measures = deepcopy(EventsView.default_measures)
 91        client_id_field = self.get_client_id(dimensions, "events")
 92        if client_id_field is not None:
 93            measures.append(
 94                {
 95                    "name": "client_count",
 96                    "type": "count_distinct",
 97                    "sql": f"${{{client_id_field}}}",
 98                    "description": (
 99                        "The number of clients that completed the event(s)."
100                    ),
101                }
102            )
103
104        return measures
105
106    def generate_event_id_dimension(
107        self, dimensions: list[dict]
108    ) -> Optional[Dict[str, str]]:
109        """Generate the event_id dimension to be used as a primary key for a one to many join."""
110        event_id = self.select_dimension("event_id", dimensions, "events")
111        if event_id:
112            return {
113                "name": "event_id",
114                "primary_key": "yes",
115            }
116        return None