Merge pull request wildfish#10 from wildfish/feature/render-serializers

Feature/render serializers

Author: jamesoutterside

dashboards/component/base.py

@@ -7,10 +7,13 @@
 from django.template import Context
 from django.template.loader import render_to_string
 from django.urls import reverse, reverse_lazy
+from django.utils.functional import lazy
 from django.utils.module_loading import import_string
 from django.utils.safestring import mark_safe
 from django.utils.text import slugify
 
+import asset_definitions
+
 from dashboards import config
 
 from ..types import ValueData
@@ -127,6 +130,7 @@ def get_value(
                 value = self.defer(request=request, object=self.object, filters=filters)
             else:
                 value = self.defer
+
         else:
             serializable = getattr(self.value, "serialize", None)
             if serializable:
@@ -142,28 +146,96 @@ def get_value(
 
         return value
 
-    def render(
-        self, context: Context, htmx: Optional[bool] = None, call_deferred: bool = False
-    ) -> str:
-        request = context.get("request")
+    @property
+    def media(self):
+        return self.get_media()
+
+    def _get_media_from_definition(self) -> Optional[asset_definitions.Media]:
+        definition = getattr(self.__class__, "Media", None)
+        if definition:
+            return asset_definitions.Media(media=definition)
+
+        return None
+
+    def get_media(self) -> asset_definitions.Media:
+        # component level media
+        media = self._get_media_from_definition() or asset_definitions.Media()
+        # serializers may have media, if so use that instead of component media
+        if callable(self.value) and hasattr(self.value, "get_media"):
+            media = self.value().get_media()
+        elif callable(self.defer) and hasattr(self.defer, "get_media"):
+            media = self.defer().get_media()
+
+        return media
+
+    def get_filters(self, request: HttpRequest) -> Dict[str, Any]:
         if request:
             filters = (
                 request.GET.dict() if request.method == "GET" else request.POST.dict()
             )
         else:
             filters = {}
 
-        context = {
+        return filters
+
+    def render_value(self, context: Context, call_deferred: bool = False) -> str:
+        # if value is deferred and we are not ready to call it, return loading template
+        if self.is_deferred and not call_deferred:
+            return render_to_string(self.defer_loading_template_name)
+
+        request = context.get("request")
+        filters = self.get_filters(request)
+
+        if self.is_deferred and self.defer and call_deferred:
+            render = getattr(self.defer, "render", None)
+        else:
+            render = getattr(self.value, "render", None)
+
+        if callable(render):
+            lazy_render = lazy(render)
+            rendered_value = lazy_render(
+                template_id=self.template_id,
+                request=request,
+                filters=filters,
+                object=self.object,
+                css_classes=self.css_classes,
+                is_deferred=self.is_deferred,
+                defer_url=self.get_absolute_url(),
+            )
+            return rendered_value
+
+        value = self.get_value(
+            request=request, call_deferred=call_deferred, filters=filters
+        )
+
+        template_context = {
             "request": request,
             "component": self,
-            "rendered_value": self.get_value(
-                request=request, call_deferred=call_deferred, filters=filters
-            ),
+            "rendered_value": value,
+        }
+        return render_to_string(self.template_name, template_context)
+
+    def render(
+        self, context: Context, htmx: Optional[bool] = None, call_deferred: bool = False
+    ) -> str:
+        template_context = {
+            "template_id": self.template_id,
+            "object": self.object,
+            "media": self.media,
+            "cta": self.cta,
+            "is_deferred": self.is_deferred,
             "htmx": self.is_deferred if htmx is None else htmx,
+            "defer_url": self.get_absolute_url(),
+            "trigger_on": self.htmx_trigger_on(),
+            "poll_rate": self.htmx_poll_rate(),
+            "defer_loading_template_name": self.defer_loading_template_name,
+            "rendered_value": self.render_value(
+                context=context, call_deferred=call_deferred
+            ),
         }
 
         return mark_safe(
-            render_to_string("dashboards/components/component.html", context)
+            render_to_string("dashboards/components/component.html", template_context)
         )
 
     def get_absolute_url(self):
@@ -192,6 +264,7 @@ def get_absolute_url(self):
 
         return url
 
+    @property
     def template_id(self):
         return slugify(self.get_absolute_url())
 

dashboards/component/chart/serializers.py

@@ -1,46 +1,73 @@
 import json
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Type
 
 from django.core.exceptions import ImproperlyConfigured
+from django.db.models import Model
+from django.template.loader import render_to_string
 
+import asset_definitions
 import pandas as pd
 import plotly.graph_objs as go
 
 from dashboards.meta import ClassWithMeta
 
 
-class ChartSerializer(ClassWithMeta):
-    meta_layout_attrs = ["title", "width", "height"]
-    layout: Optional[Dict[str, Any]] = None
+class ModelDataMixin:
+    """
+    gets data from a django model and converts to a pandas dataframe
+    """
 
     class Meta:
         fields: Optional[List[str]] = None
-        model: Optional[str] = None
-        queryset: Optional[str] = None
-        title: Optional[str] = None
-        width: Optional[int] = None
-        height: Optional[int] = None
+        model: Optional[Model] = None
 
-    @classmethod
-    def preprocess_meta(cls, current_class_meta):
-        title = getattr(current_class_meta, "title", None)
+    _meta: Type["ModelDataMixin.Meta"]
 
-        if title and not hasattr(current_class_meta, "name"):
-            current_class_meta.name = title
+    def get_fields(self) -> Optional[List[str]]:
+        # TODO: for some reason mypy complains about this one line
+        return self._meta.fields  # type: ignore
 
-        if title and not hasattr(current_class_meta, "verbose_name"):
-            current_class_meta.verbose_name = title
+    def convert_to_df(self, data: Any, columns: Optional[List] = None) -> pd.DataFrame:
+        return pd.DataFrame(data, columns=columns)
 
-        return current_class_meta
+    def get_data(self, *args, **kwargs) -> pd.DataFrame:
+        fields = self.get_fields()
+        queryset = self.get_queryset(*args, **kwargs)
+        if fields:
+            queryset = queryset.values(*fields)
 
-    @classmethod
-    def postprocess_meta(cls, current_class_meta, resolved_meta_class):
-        if not hasattr(resolved_meta_class, "title"):
-            resolved_meta_class.title = resolved_meta_class.verbose_name
+        try:
+            df = self.convert_to_df(queryset.iterator(), fields)
+        except KeyError:
+            return pd.DataFrame()
+        return df
 
-        return resolved_meta_class
+    def get_queryset(self, *args, **kwargs):
+        if self._meta.model is not None:
+            queryset = self._meta.model._default_manager.all()
+        else:
+            raise ImproperlyConfigured(
+                "%(self)s is missing a QuerySet. Define "
+                "%(self)s.model or override "
+                "%(self)s.get_queryset()." % {"self": self.__class__.__name__}
+            )
+
+        return queryset
 
-    def empty_chart(self):
+
+class PlotlyChartSerializerMixin:
+    template_name: str = "dashboards/components/chart/plotly.html"
+    meta_layout_attrs = ["title", "width", "height"]
+    layout: Optional[Dict[str, Any]] = None
+
+    _meta: Type[Any]
+
+    class Meta:
+        displayModeBar: Optional[bool] = True
+        staticPlot: Optional[bool] = False
+        responsive: Optional[bool] = True
+
+    def empty_chart(self) -> str:
         return json.dumps(
             {
                 "layout": {
@@ -59,6 +86,27 @@ def empty_chart(self):
             }
         )
 
+    def apply_layout(self, fig: go.Figure, dark=False) -> go.Figure:
+        layout = self.layout or {}
+
+        for attr in self.meta_layout_attrs:
+            layout.setdefault(attr, getattr(self._meta, attr))
+
+        if dark:
+            fig = fig.update_layout(
+                template="plotly_dark",
+                plot_bgcolor="rgba(0,0,0,0.05)",
+                paper_bgcolor="rgba(0,0,0,0.05)",
+            )
+
+        return fig.update_layout(**layout)
+
+    def get_data(self, *args, **kwargs) -> pd.DataFrame:
+        raise NotImplementedError
+
+    def to_fig(self, data: Any) -> go.Figure:
+        raise NotImplementedError
+
     @classmethod
     def serialize(cls, **kwargs) -> str:
         self = cls()
@@ -69,58 +117,77 @@ def serialize(cls, **kwargs) -> str:
             return self.empty_chart()
 
         fig = self.to_fig(df)
-
         fig = self.apply_layout(
             fig, dark=request and request.COOKIES.get("appearanceMode") == "dark"
         )
 
         return fig.to_json()
 
-    def get_fields(self) -> Optional[List[str]]:
-        # TODO: for some reason mypy complains about this one line
-        return self._meta.fields  # type: ignore
+    @classmethod
+    def render(cls, template_id, **kwargs) -> str:
+        self = cls()
+        value = cls.serialize(**kwargs)
+        context = {
+            "template_id": template_id,
+            "value": value,
+            "displayModeBar": self._meta.displayModeBar,
+            "staticPlot": self._meta.staticPlot,
+            "responsive": self._meta.responsive,
+        }
+        return render_to_string(cls.template_name, context)
 
-    def apply_layout(self, fig: go.Figure, dark=False):
-        layout = self.layout or {}
 
-        for attr in self.meta_layout_attrs:
-            layout.setdefault(attr, getattr(self._meta, attr))
+class BaseChartSerializer(ClassWithMeta, asset_definitions.MediaDefiningClass):
+    _meta: Type[Any]
 
-        if dark:
-            fig = fig.update_layout(
-                template="plotly_dark",
-                plot_bgcolor="rgba(0,0,0,0.05)",
-                paper_bgcolor="rgba(0,0,0,0.05)",
-            )
+    class Meta:
+        title: Optional[str] = None
+        width: Optional[int] = None
+        height: Optional[int] = None
 
-        return fig.update_layout(**layout)
+    @classmethod
+    def preprocess_meta(cls, current_class_meta):
+        title = getattr(current_class_meta, "title", None)
 
-    def convert_to_df(self, data: Any, columns: Optional[List] = None) -> pd.DataFrame:
-        return pd.DataFrame(data, columns=columns)
+        if title and not hasattr(current_class_meta, "name"):
+            current_class_meta.name = title
 
-    def get_data(self, *args, **kwargs) -> pd.DataFrame:
-        fields = self.get_fields()
-        queryset = self.get_queryset(*args, **kwargs)
-        if fields:
-            queryset = queryset.values(*fields)
+        if title and not hasattr(current_class_meta, "verbose_name"):
+            current_class_meta.verbose_name = title
 
-        try:
-            df = self.convert_to_df(queryset.iterator(), fields)
-        except KeyError:
-            return pd.DataFrame()
-        return df
+        return current_class_meta
 
-    def get_queryset(self, *args, **kwargs):
-        if self._meta.model is not None:
-            queryset = self._meta.model._default_manager.all()
-        else:
-            raise ImproperlyConfigured(
-                "%(self)s is missing a QuerySet. Define "
-                "%(self)s.model or override "
-                "%(self)s.get_queryset()." % {"self": self.__class__.__name__}
-            )
+    @classmethod
+    def postprocess_meta(cls, current_class_meta, resolved_meta_class):
+        if not hasattr(resolved_meta_class, "title"):
+            resolved_meta_class.title = resolved_meta_class.verbose_name
 
-        return queryset
+        return resolved_meta_class
 
-    def to_fig(self, data: Any) -> go.Figure:
+    @classmethod
+    def serialize(cls, **kwargs) -> str:
         raise NotImplementedError
+
+
+class PlotlyChartSerializer(PlotlyChartSerializerMixin, BaseChartSerializer):
+    """
+    Serializer to convert data into a plotly js format
+    """
+
+    class Meta(PlotlyChartSerializerMixin.Meta, BaseChartSerializer.Meta):
+        pass
+
+    class Media:
+        js = ("dashboards/vendor/js/plotly.min.js",)
+
+
+class ChartSerializer(ModelDataMixin, PlotlyChartSerializer):
+    """
+    Default chart serializer to read data from a django model
+    and serialize it to something plotly js can render
+    """
+
+    class Meta(ModelDataMixin.Meta, PlotlyChartSerializer.Meta):
+        pass
+
+    _meta: Type["ChartSerializer.Meta"]

dashboards/component/gauge/gauge.py

@@ -18,3 +18,6 @@ class Gauge(Component):
     title: str = ""
     value: Optional[GaugeValue] = None
     template_name: str = "dashboards/components/gauge/gauge.html"
+
+    class Media:
+        js = ("dashboards/vendor/js/gauge.min.js",)