Refactor callbacks into services. Create Page class

Author: Eric Smyth

src/chime_dash/app/components/__init__.py

@@ -4,8 +4,6 @@
 have callbacks.
 
 To add or remove components, adjust the `setup`.
-If callbacks are present, also adjust `CALLBACK_INPUTS`, `CALLBACK_OUTPUTS` and
-`callback_body`.
 """
 from collections import OrderedDict
 
@@ -57,8 +55,7 @@ def get_html(self):
             children=self.components["navbar"].html + [
                 Div(
                     className="app-content",
-                    children=
-                    self.components["sidebar"].html
+                    children=self.components["sidebar"].html
                     + self.components["index"].html
                 )
             ]
@@ -67,8 +64,7 @@ def get_html(self):
     def get_html_old(self):
         """Glues individual setup components together
         """
-        return Div(children=
-                   self.components["navbar"].html
+        return Div(children=self.components["navbar"].html
                    + [Container(
                        children=Row(self.components["sidebar"].html + [Div(
                            id="page-wrapper",

src/chime_dash/app/components/base.py

@@ -4,19 +4,17 @@
 
 #! candidate for moving into utils/components
 """
-from typing import List, Dict, Any, Union
+from typing import List, Dict, Union
 
 from abc import ABC
 
-from dash import Dash
 from dash.development.base_component import ComponentMeta
 from dash_html_components import Div
 
 from penn_chime.parameters import Parameters
 from penn_chime.settings import DEFAULTS
 
 from chime_dash.app.utils.templates import read_localization_yml, read_localization_markdown
-from chime_dash.app.utils.callbacks import ChimeCallback, register_callbacks
 
 
 class Component(ABC):
@@ -32,19 +30,13 @@ class Component(ABC):
     external_stylesheets: List[str] = []
     external_scripts: List[str] = []
 
-    def __init__(
-            self,
-            language: str = "en",
-            defaults: Parameters = DEFAULTS,
-            callbacks: List[ChimeCallback] = None
-    ):
+    def __init__(self, language: str = "en", defaults: Parameters = DEFAULTS):
         """Initializes the component
         """
         self.language = language
         self.defaults = defaults
         self._content = None
         self._html = None
-        register_callbacks(callbacks)
 
     def get_html(self) -> List[ComponentMeta]:  # pylint: disable=R0201
         """Function which is called to render html elements.
@@ -97,6 +89,14 @@ def content(self) -> Union[str, Dict[str, str], None]:
         return self._content
 
 
+class Page(Component):
+    callbacks_cls = None
+
+    def __init__(self, language: str = "en", defaults: Parameters = DEFAULTS):
+        super().__init__(language, defaults)
+        self.callbacks_cls(self)
+
+
 class HTMLComponentError(Exception):
     """Custom exception for errors when rendering component html.
 

src/chime_dash/app/pages/index.py

@@ -1,96 +1,29 @@
 """pages/index
 Homepage
 """
-
 from collections import OrderedDict
 
 from dash_html_components import Main
 from dash_bootstrap_components import Container
 
-from chime_dash.app.components.base import Component
+from chime_dash.app.components.base import Page
 from chime_dash.app.components.footer import Footer
 from chime_dash.app.components.header import Header
 from chime_dash.app.components.tool_details import ToolDetails
 from chime_dash.app.components.intro import Intro
 from chime_dash.app.components.visualizations import Visualizations
+from chime_dash.app.services.callbacks import IndexCallbacks
 
-from chime_dash.app.utils import get_n_switch_values, parameters_deserializer, prepare_visualization_group
-from chime_dash.app.utils.callbacks import ChimeCallback
-
-from penn_chime.models import SimSirModel
 
-
-class Index(Component):
+class Index(Page):
     """
     """
-
-    @staticmethod
-    def toggle_tool_details(switch_value):
-        return get_n_switch_values(switch_value, 1)
-
-    @staticmethod
-    def toggle_tables(switch_value):
-        return get_n_switch_values(switch_value, 3)
+    callbacks_cls = IndexCallbacks
 
     def __init__(self, language, defaults):
         """
         """
-
-        def handle_model_change_helper(pars_json):
-            model = {}
-            pars = None
-            result = []
-            viz_kwargs = {}
-            if pars_json:
-                pars = parameters_deserializer(pars_json)
-                model = SimSirModel(pars)
-                viz_kwargs = dict(
-                    labels=pars.labels,
-                    table_mod=7,
-                    max_y_axis=pars.max_y_axis,
-                )
-            result.extend(self.components["intro"].build(model, pars))
-            result.extend(self.components["tool_details"].build(model, pars))
-            for df_key in ["admits_df", "census_df", "sim_sir_w_date_df"]:
-                df = None
-                if model:
-                    df = model.__dict__.get(df_key, None)
-                result.extend(prepare_visualization_group(df, **viz_kwargs))
-            return result
-
-        super().__init__(language, defaults, [
-            ChimeCallback(  # If user toggles show_additional_projections, show/hide the additional intro content
-                changed_elements=OrderedDict(show_tool_details="value"),
-                dom_updates=OrderedDict(more_intro_wrapper="hidden"),
-                callback_fn=Index.toggle_tool_details
-            ),
-            ChimeCallback(  # If user toggles show_tables, show/hide tables
-                changed_elements=OrderedDict(show_tables="value"),
-                dom_updates=OrderedDict(
-                    SIR_table_container="hidden",
-                    new_admissions_table_container="hidden",
-                    admitted_patients_table_container="hidden",
-                ),
-                callback_fn=Index.toggle_tables
-            ),
-            ChimeCallback(  # If the parameters or model change, update the text
-                changed_elements=OrderedDict(pars="children"),
-                dom_updates=OrderedDict(
-                    intro="children",
-                    more_intro="children",
-                    new_admissions_graph="figure",
-                    new_admissions_table="children",
-                    new_admissions_download="href",
-                    admitted_patients_graph="figure",
-                    admitted_patients_table="children",
-                    admitted_patients_download="href",
-                    SIR_graph="figure",
-                    SIR_table="children",
-                    SIR_download="href",
-                ),
-                callback_fn=handle_model_change_helper
-            )
-        ])
+        super().__init__()
         self.components = OrderedDict(
             header=Header(language, defaults),
             intro=Intro(language, defaults),
@@ -108,17 +41,14 @@ def get_html(self):
                 "marginLeft": "320px",
                 "marginTop": "56px"
             },
-            children=
-            [Container(
-                children=
-                self.components["header"].html
+            children=[Container(
+                children=self.components["header"].html
                 + self.components["intro"].html
                 + self.components["tool_details"].html
             )]
             + self.components["visualizations"].html
             + [Container(
-                children=
-                self.components["footer"].html
+                children=self.components["footer"].html
             )],
         )
 

src/chime_dash/app/pages/sidebar.py

@@ -1,33 +1,29 @@
 """components/sidebar
 Initializes the side bar containing the various inputs for the model
 
-#! _INPUTS should be considered for moving else where
+#! _SIDEBAR_ELEMENTS should be considered for moving else where
 """
-from dash_html_components import Nav, Div
-
-from typing import List, Dict, Any, Tuple
+from typing import List
 from collections import OrderedDict
 from datetime import date, datetime
 
 from dash.development.base_component import ComponentMeta
-from dash_html_components import Nav, Div, Hr
-
-from penn_chime.parameters import Parameters, Disposition
+from dash_html_components import Nav, Div
 
-from chime_dash.app.components.base import Component
-from chime_dash.app.utils import parameters_serializer
-from chime_dash.app.utils.callbacks import ChimeCallback
+from chime_dash.app.components.base import Page
+from chime_dash.app.utils import ReadOnlyDict
 from chime_dash.app.utils.templates import (
     create_switch_input,
     create_number_input,
     create_date_input,
     create_header,
 )
+from chime_dash.app.services.callbacks import SidebarCallbacks
 
 FLOAT_INPUT_MIN = 0.001
 FLOAT_INPUT_STEP = "any"
 
-_INPUTS = OrderedDict(
+_SIDEBAR_ELEMENTS = ReadOnlyDict(OrderedDict(
     ###
     hospital_parameters={"type": "header", "size": "h3"},
     population={"type": "number", "min": 1, "step": 1},
@@ -94,94 +90,37 @@
     max_y_axis_value={"type": "number", "min": 10, "step": 10, "value": None},
     show_tables={"type": "switch", "value": False},
     show_tool_details={"type": "switch", "value": False},
-)
+))
 
-# Different kind of inputs store different kind of "values"
-# This tells the callback output for which field to look
-_PROPERTY_OUTPUT_MAP = {
-    "number": "value",
-    "date": "date",
-}
 
-
-class Sidebar(Component):
+class Sidebar(Page):
     """Sidebar to the left of the screen
     contains the various inputs used to interact
     with the model.
     """
+    callbacks_cls = SidebarCallbacks
 
     # localization temp. for widget descriptions
     localization_file = "sidebar.yml"
-
-    @staticmethod
-    def get_ordered_input_keys():
-        return [key for key in _INPUTS if _INPUTS[key]["type"] not in ("header", )]
-
-    @staticmethod
-    def get_formated_values(input_values):
-        result = dict(zip(Sidebar.get_ordered_input_keys(), input_values))
-        # todo remove this hack needed because of how Checklist type used for switch input returns values
-        for key in _INPUTS:
-            if _INPUTS[key]["type"] == "switch":
-                value = False
-                if result[key] == [True]:
-                    value = True
-                result[key] = value
-            elif _INPUTS[key]["type"] == "date":
-                value = result[key]
-                result[key] = datetime.strptime(value, "%Y-%m-%d").date() if value else value
-        return result
-
-    @staticmethod
-    def update_parameters(*input_values, **kwargs) -> List[str]:
-        """Reads html form outputs and converts them to a parameter instance
-
-        Returns Parameters
-        """
-        inputs_dict = Sidebar.get_formated_values(input_values)
-        dt = inputs_dict["doubling_time"] if inputs_dict["doubling_time"] else None
-        dfh = inputs_dict["date_first_hospitalized"] if not dt else None
-        pars = Parameters(
-            population=inputs_dict["population"],
-            current_hospitalized=inputs_dict["current_hospitalized"],
-            date_first_hospitalized=dfh,
-            doubling_time=dt,
-            hospitalized=Disposition(
-                inputs_dict["hospitalized_rate"] / 100, inputs_dict["hospitalized_los"]
-            ),
-            icu=Disposition(inputs_dict["icu_rate"] / 100, inputs_dict["icu_los"]),
-            infectious_days=inputs_dict["infectious_days"],
-            market_share=inputs_dict["market_share"] / 100,
-            n_days=inputs_dict["n_days"],
-            relative_contact_rate=inputs_dict["relative_contact_rate"] / 100,
-            ventilated=Disposition(
-                inputs_dict["ventilated_rate"] / 100, inputs_dict["ventilated_los"]
-            ),
-            max_y_axis=inputs_dict.get("max_y_axis_value", None),
-        )
-        return [parameters_serializer(pars)]
-
-    def __init__(self, language, defaults):
-        changed_elements = OrderedDict(
-            (key, _PROPERTY_OUTPUT_MAP.get(_INPUTS[key]["type"], "value"))
-            for key in _INPUTS
-            if _INPUTS[key]["type"] not in ("header",)
-        )
-
-        input_change_callback = ChimeCallback(
-            changed_elements=changed_elements,
-            dom_updates=OrderedDict(pars="children"),
-            callback_fn=Sidebar.update_parameters,
-        )
-        super().__init__(language, defaults, [input_change_callback])
+    # Different kind of inputs store different kind of "values"
+    # This tells the callback output for which field to look
+    input_type_map = ReadOnlyDict(OrderedDict(
+        (key, value["type"])
+        for key, value in _SIDEBAR_ELEMENTS.items()
+        if value["type"] not in ("header",)
+    ))
+    input_value_map = ReadOnlyDict(OrderedDict(
+        (key, {"number": "value", "date": "date"}.get(value, "value"))
+        for key, value in input_type_map.items()
+    ))
 
     def get_html(self) -> List[ComponentMeta]:
         """Initializes the view
         """
         elements = [
             Div(id='pars', style={'display': 'none'})
         ]
-        for idx, data in _INPUTS.items():
+        for idx, data in _SIDEBAR_ELEMENTS.items():
             if data["type"] == "number":
                 element = create_number_input(idx, data, self.content, self.defaults)
             elif data["type"] == "switch":
@@ -216,4 +155,3 @@ def get_html(self) -> List[ComponentMeta]:
         )
 
         return [sidebar]
-