pumpwood_streamlit.dashboard

  1"""Dashboard class to use as base from Pumpwood Streamlit Dashboards."""
  2import os
  3import streamlit as st
  4import extra_streamlit_components as stx
  5from abc import ABC, abstractmethod
  6from pumpwood_communication.microservices import PumpWoodMicroService
  7
  8
  9def _get_cookie_manager():
 10    """Retrieve Cookie Manager."""
 11    return stx.CookieManager()
 12
 13
 14class PumpwoodStreamlitDashboard(ABC):
 15    """Abstract Class to facilitate criation of Streamlit Dashboards."""
 16
 17    def __init__(self, microservice: PumpWoodMicroService = None):
 18        """
 19        __init__.
 20
 21        It is possible to init object with a microservice to help
 22        building dashboard.
 23
 24        If microservice=None (production deploy), `__init__` will create an
 25        unlogged microservice object using `MICROSERVICE_URL` from enviroment
 26        variable. Authentication validation function will set attribute
 27        `_auth_token` with `PumpwoodAuthorization` token that can be used
 28        to user impersonation.
 29
 30        Args:
 31            microservice:
 32                 An microservice can be passed to object for developing
 33                 and debug.
 34        """
 35        # Set auth_header to None, this will permit dev microservice to
 36        # use credencials and prod get auth header from cookie
 37        self._auth_token = None
 38        if microservice is not None:
 39            self._microservice = microservice
 40        else:
 41            MICROSERVICE_URL = os.getenv("MICROSERVICE_URL")
 42            if MICROSERVICE_URL is not None:
 43                self._microservice = PumpWoodMicroService(
 44                    name="dashboard-microservice",
 45                    server_url=MICROSERVICE_URL)
 46            else:
 47                msg = (
 48                    "'microservice' is not set as argument and " +
 49                    "'MICROSERVICE_URL' not set as enviroment variable")
 50                raise Exception(msg)
 51
 52    def validate_authentication(self) -> bool:
 53        """
 54        Validate authentication using cookie with PumpwoodAuthorization.
 55
 56        Returns:
 57            Return True if user is logged on Pumpwood and False if token
 58            set at PumpwoodAuthorization is invalid.
 59        """
 60        cookie_manager = _get_cookie_manager()
 61        cookie_auth_token = cookie_manager.get('PumpwoodAuthorization')
 62        if cookie_auth_token is not None:
 63            self._auth_token = {"Authorization": 'Token ' + cookie_auth_token}
 64
 65        is_logged = self._microservice.check_if_logged(
 66            auth_header=self._auth_token)
 67        return is_logged
 68
 69    def authentication_error_page(self) -> None:
 70        """
 71        Set the authentication error page.
 72
 73        This function is called if self.validate_login() return False.
 74
 75        Example:
 76        ```python
 77        st.title('User token is invalid, log in again to refresh token.')
 78        ```
 79        """
 80        st.title('User token is invalid, log in again to refresh token.')
 81
 82    def run(self) -> None:
 83        """
 84        Render Streamlit dashboard.
 85
 86        This function is used as an entry point for app.py Streamlit
 87        dashboard.
 88
 89        Most of the cases should not be reimplemented. It is important
 90        that if reimplemented `is_logged = self.validate_authentication()`
 91        function must be called at the beggin to assure that user is
 92        authenticated on Pumpwood.
 93
 94        Example of an app.py:
 95        ```
 96        import os
 97        from dashboard import Dashboard
 98        from pumpwood_communication.microservices import PumpWoodMicroService
 99
100        ###############################################################
101        # Read env variables to be used on local test of the dashboard.
102        # Passing a logged microservice to dashboard will disable
103        # authentication
104        # !!! DO NOT USE AUTHENTICATED MICROSERVICE IN PRODUCTION
105        # DASHBOARDS !!! #
106        MICROSERVICE_URL = os.getenv('MICROSERVICE_URL')
107        MICROSERVICE_DASHBOARD_USERNAME = os.getenv(
108            'MICROSERVICE_DASHBOARD_USERNAME')
109        MICROSERVICE_DASHBOARD_PASSWORD = os.getenv(
110            'MICROSERVICE_DASHBOARD_PASSWORD')
111
112        microservice = None
113        if MICROSERVICE_DASHBOARD_USERNAME is not None:
114            microservice = PumpWoodMicroService(
115                name="dashboard-microservice",
116                server_url=MICROSERVICE_URL,
117                username=MICROSERVICE_DASHBOARD_USERNAME,
118                password=MICROSERVICE_DASHBOARD_PASSWORD,)
119            microservice.login()
120
121        dash_obj = Dashboard(microservice=microservice)
122        dash_obj.run()
123        ```
124
125        Implemented run function:
126        ```python
127        def run(self) -> None:
128            # Set page configuration
129            self.set_page_config()
130
131            # Validate auth_header
132            is_logged = self.validate_authentication()
133            if not is_logged:
134                # Authorization error
135                self.authentication_error_page()
136            else:
137                # Render main Dashboard View
138                self.main_view()
139        ```
140        """
141        # Set page configuration
142        self.set_page_config()
143
144        # Validate auth_header
145        is_logged = self.validate_authentication()
146        if not is_logged:
147            # Authorization error
148            self.authentication_error_page()
149        else:
150            # Render main Dashboard View
151            self.main_view()
152
153    @abstractmethod
154    def set_page_config(self) -> None:
155        """
156        Set page config, must be implemented.
157
158        Exemple:
159        ```python
160        st.set_page_config(
161            page_title="US Population Dashboard",
162            page_icon="🏂",
163            layout="wide",
164            initial_sidebar_state="expanded")
165        ```
166        """
167        msg = "'set_page_config' function must be implemented"
168        raise NotImplementedError(msg)
169
170    @abstractmethod
171    def main_view(self) -> None:
172        """
173        Render main dashboard view.
174
175        Exemple:
176        ```python
177        st.set_page_config(
178            page_title="US Population Dashboard",
179            page_icon="🏂",
180            layout="wide",
181            initial_sidebar_state="expanded")
182        ```
183        """
184        msg = "'main_view' function must be implemented"
185        raise NotImplementedError(msg)