path: root/resources/tools/dash/app/pal/trending/layout.py

# Copyright (c) 2022 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Plotly Dash HTML layout override.
"""

import pandas as pd

from dash import dcc
from dash import html
from dash import callback_context, no_update
from dash import Input, Output, State
from dash.exceptions import PreventUpdate
from yaml import load, FullLoader, YAMLError
from datetime import datetime, timedelta

from ..data.data import Data
from .graphs import graph_trending, graph_hdrh_latency, \
    select_trending_data


class Layout:
    """
    """

    STYLE_HIDEN = {"display": "none"}
    STYLE_BLOCK = {"display": "block", "vertical-align": "top"}
    STYLE_INLINE ={
        "display": "inline-block",
        "vertical-align": "top"
    }
    NO_GRAPH = {"data": [], "layout": {}, "frames": []}

    def __init__(self, app, html_layout_file, spec_file, graph_layout_file,
        data_spec_file):
        """
        """

        # Inputs
        self._app = app
        self._html_layout_file = html_layout_file
        self._spec_file = spec_file
        self._graph_layout_file = graph_layout_file
        self._data_spec_file = data_spec_file

        # Read the data:
        data_mrr = Data(
            data_spec_file=self._data_spec_file,
            debug=True
        ).read_trending_mrr()

        data_ndrpdr = Data(
            data_spec_file=self._data_spec_file,
            debug=True
        ).read_trending_ndrpdr()

        self._data = pd.concat([data_mrr, data_ndrpdr], ignore_index=True)

        # Read from files:
        self._html_layout = ""
        self._spec_tbs = None
        self._graph_layout = None

        try:
            with open(self._html_layout_file, "r") as file_read:
                self._html_layout = file_read.read()
        except IOError as err:
            raise RuntimeError(
                f"Not possible to open the file {self._html_layout_file}\n{err}"
            )

        try:
            with open(self._spec_file, "r") as file_read:
                self._spec_tbs = load(file_read, Loader=FullLoader)
        except IOError as err:
            raise RuntimeError(
                f"Not possible to open the file {self._spec_file,}\n{err}"
            )
        except YAMLError as err:
            raise RuntimeError(
                f"An error occurred while parsing the specification file "
                f"{self._spec_file,}\n"
                f"{err}"
            )

        try:
            with open(self._graph_layout_file, "r") as file_read:
                self._graph_layout = load(file_read, Loader=FullLoader)
        except IOError as err:
            raise RuntimeError(
                f"Not possible to open the file {self._graph_layout_file}\n"
                f"{err}"
            )
        except YAMLError as err:
            raise RuntimeError(
                f"An error occurred while parsing the specification file "
                f"{self._graph_layout_file}\n"
                f"{err}"
            )

        # Callbacks:
        if self._app is not None and hasattr(self, 'callbacks'):
            self.callbacks(self._app)

    @property
    def html_layout(self):
        return self._html_layout

    @property
    def spec_tbs(self):
        return self._spec_tbs

    @property
    def data(self):
        return self._data

    @property
    def layout(self):
        return self._graph_layout

    def add_content(self):
        """
        """
        if self.html_layout and self.spec_tbs:
            return html.Div(
                id="div-main",
                children=[
                    dcc.Store(id="selected-tests"),
                    self._add_ctrl_div(),
                    self._add_plotting_div()
                ]
            )
        else:
            return html.Div(
            id="div-main-error",
            children="An Error Occured."
        )

    def _add_ctrl_div(self):
        """Add div with controls. It is placed on the left side.
        """
        return html.Div(
            id="div-controls",
            children=[
                html.Div(
                    id="div-controls-tabs",
                    children=[
                        self._add_ctrl_select(),
                        self._add_ctrl_shown()
                    ]
                )
            ],
            style={
                "display": "inline-block",
                "width": "20%"
            }
        )

    def _add_plotting_div(self):
        """Add div with plots and tables. It is placed on the right side.
        """
        return html.Div(
            id="div-plotting-area",
            children=[
                html.Table(children=[
                    html.Tr(
                        id="div-tput",
                        style=self.STYLE_HIDEN,
                        children=[
                            html.Td(children=[
                                dcc.Loading(
                                    dcc.Graph(
                                        id="graph-tput"
                                    ),
                                )
                            ], style={"width": "80%"}),
                            html.Td(children=[
                                dcc.Clipboard(
                                    target_id="tput-metadata",
                                    title="Copy",
                                    style={"display": "inline-block"}
                                ),
                                html.Nobr(" "),
                                html.Nobr(" "),
                                dcc.Markdown(
                                    children="**Throughput**",
                                    style={"display": "inline-block"}
                                ),
                                html.Pre(
                                    id="tput-metadata",
                                    children="Click on data point in the graph"
                                ),
                                html.Div(
                                    id="div-lat-metadata",
                                    style=self.STYLE_HIDEN,
                                    children=[
                                        dcc.Clipboard(
                                            target_id="lat-metadata",
                                            title="Copy",
                                            style={"display": "inline-block"}
                                        ),
                                        html.Nobr(" "),
                                        html.Nobr(" "),
                                        dcc.Markdown(
                                            children="**Latency**",
                                            style={"display": "inline-block"}
                                        ),
                                        html.Pre(
                                            id="lat-metadata",
                                            children= \
                                            "Click on data point in the graph"
                                        )
                                    ]
                                )
                            ], style={"width": "20%"}),
                        ]
                    ),
                    html.Tr(
                        id="div-latency",
                        style=self.STYLE_HIDEN,
                        children=[
                            html.Td(children=[
                                dcc.Loading(
                                    dcc.Graph(
                                        id="graph-latency"
                                    )
                                )
                            ], style={"width": "80%"}),
                            html.Td(children=[
                                dcc.Loading(
                                    dcc.Graph(
                                        id="graph-latency-hdrh",
                                        style=self.STYLE_INLINE,
                                        figure=self.NO_GRAPH
                                    )
                                )
                            ], style={"width": "20%"}),
                        ]
                    ),
                    html.Tr(
                        id="div-download",
                        style=self.STYLE_HIDEN,
                        children=[
                            html.Td(children=[
                                dcc.Loading(
                                    children=[
                                        html.Button(
                                            id="btn-download-data",
                                            children=["Download Data"]
                                        ),
                                        dcc.Download(id="download-data")
                                    ]
                                )
                            ], style={"width": "80%"}),
                            html.Td(children=[
                                html.Nobr(" ")
                            ], style={"width": "20%"}),
                        ]
                    ),
                ]),
            ],
            style={
                "vertical-align": "top",
                "display": "inline-block",
                "width": "80%"
            }
        )

    def _add_ctrl_shown(self):
        """
        """
        return html.Div(
            id="div-ctrl-shown",
            children=[
                html.H5("Selected tests"),
                html.Div(
                    id="container-selected-tests",
                    children=[
                        dcc.Checklist(
                            id="cl-selected",
                            options=[],
                            labelStyle={"display": "block"}
                        ),
                        html.Button(
                            id="btn-sel-remove",
                            children="Remove Selected",
                            disabled=False
                        ),
                        html.Button(
                            id="btn-sel-display",
                            children="Display",
                            disabled=False
                        )
                    ]
                ),
            ]
        )

    def _add_ctrl_select(self):
        """
        """
        return html.Div(
            id="div-ctrl-select",
            children=[
                html.H5("Physical Test Bed Topology, NIC and Driver"),
                dcc.Dropdown(
                    id="dd-ctrl-phy",
                    placeholder="Select a Physical Test Bed Topology...",
                    multi=False,
                    clearable=False,
                    options=[
                        {"label": k, "value": k} for k in self.spec_tbs.keys()
                    ],
                ),
                html.H5("Area"),
                dcc.Dropdown(
                    id="dd-ctrl-area",
                    placeholder="Select an Area...",
                    disabled=True,
                    multi=False,
                    clearable=False,
                ),
                html.H5("Test"),
                dcc.Dropdown(
                    id="dd-ctrl-test",
                    placeholder="Select a Test...",
                    disabled=True,
                    multi=False,
                    clearable=False,
                ),
                html.Div(
                    id="div-ctrl-core",
                    children=[
                        html.H5("Number of Cores"),
                        dcc.Checklist(
                            id="cl-ctrl-core-all",
                            options=[{"label": "All", "value": "all"}, ],
                            labelStyle={"display": "inline-block"}
                        ),
                        dcc.Checklist(
                            id="cl-ctrl-core",
                            labelStyle={"display": "inline-block"}
                        )
                    ],
                    style={"display": "none"}
                ),
                html.Div(
                    id="div-ctrl-framesize",
                    children=[
                        html.H5("Frame Size"),
                        dcc.Checklist(
                            id="cl-ctrl-framesize-all",
                            options=[{"label": "All", "value": "all"}, ],
                            labelStyle={"display": "inline-block"}
                        ),
                        dcc.Checklist(
                            id="cl-ctrl-framesize",
                            labelStyle={"display": "inline-block"}
                        )
                    ],
                    style={"display": "none"}
                ),
                html.Div(
                    id="div-ctrl-testtype",
                    children=[
                        html.H5("Test Type"),
                        dcc.Checklist(
                            id="cl-ctrl-testtype-all",
                            options=[{"label": "All", "value": "all"}, ],
                            labelStyle={"display": "inline-block"}
                        ),
                        dcc.Checklist(
                            id="cl-ctrl-testtype",
                            labelStyle={"display": "inline-block"}
                        )
                    ],
                    style={"display": "none"}
                ),
                html.Button(
                    id="btn-ctrl-add",
                    children="Add",
                    disabled=True
                ),
                html.Br(),
                dcc.DatePickerRange(
                    id="dpr-period",
                    min_date_allowed=datetime.utcnow() - timedelta(days=180),
                    max_date_allowed=datetime.utcnow(),
                    initial_visible_month=datetime.utcnow(),
                    start_date=datetime.utcnow() - timedelta(days=180),
                    end_date=datetime.utcnow(),
                    display_format="D MMMM YY"
                )
            ]
        )

    def callbacks(self, app):

        @app.callback(
            Output("dd-ctrl-area", "options"),
            Output("dd-ctrl-area", "disabled"),
            Input("dd-ctrl-phy", "value"),
        )
        def _update_dd_area(phy):
            """
            """

            if phy is None:
                raise PreventUpdate

            try:
                options = [
                    {"label": self.spec_tbs[phy][v]["label"], "value": v}
                        for v in [v for v in self.spec_tbs[phy].keys()]
                ]
                disable = False
            except KeyError:
                options = list()
                disable = True

            return options, disable

        @app.callback(
            Output("dd-ctrl-test", "options"),
            Output("dd-ctrl-test", "disabled"),
            State("dd-ctrl-phy", "value"),
            Input("dd-ctrl-area", "value"),
        )
        def _update_dd_test(phy, area):
            """
            """

            if not area:
                raise PreventUpdate

            try:
                options = [
                    {"label": v, "value": v}
                        for v in self.spec_tbs[phy][area]["test"]
                ]
                disable = False
            except KeyError:
                options = list()
                disable = True

            return options, disable

        @app.callback(
            Output("div-ctrl-core", "style"),
            Output("cl-ctrl-core", "options"),
            Output("div-ctrl-framesize", "style"),
            Output("cl-ctrl-framesize", "options"),
            Output("div-ctrl-testtype", "style"),
            Output("cl-ctrl-testtype", "options"),
            Output("btn-ctrl-add", "disabled"),
            State("dd-ctrl-phy", "value"),
            State("dd-ctrl-area", "value"),
            Input("dd-ctrl-test", "value"),
        )
        def _update_btn_add(phy, area, test):
            """
            """

            if test is None:
                raise PreventUpdate

            core_style = {"display": "none"}
            core_opts = []
            framesize_style = {"display": "none"}
            framesize_opts = []
            testtype_style = {"display": "none"}
            testtype_opts = []
            add_disabled = True
            if phy and area and test:
                core_style = {"display": "block"}
                core_opts = [
                    {"label": v, "value": v}
                        for v in self.spec_tbs[phy][area]["core"]
                ]
                framesize_style = {"display": "block"}
                framesize_opts = [
                    {"label": v, "value": v}
                        for v in self.spec_tbs[phy][area]["frame-size"]
                ]
                testtype_style = {"display": "block"}
                testtype_opts = [
                    {"label": v, "value": v}
                        for v in self.spec_tbs[phy][area]["test-type"]
                ]
                add_disabled = False

            return (
                core_style, core_opts,
                framesize_style, framesize_opts,
                testtype_style, testtype_opts,
                add_disabled
            )

        def _sync_checklists(opt, sel, all, id):
            """
            """
            options = {v["value"] for v in opt}
            input_id = callback_context.triggered[0]["prop_id"].split(".")[0]
            if input_id == id:
                all = ["all"] if set(sel) == options else list()
            else:
                sel = list(options) if all else list()
            return sel, all

        @app.callback(
            Output("cl-ctrl-core", "value"),
            Output("cl-ctrl-core-all", "value"),
            State("cl-ctrl-core", "options"),
            Input("cl-ctrl-core", "value"),
            Input("cl-ctrl-core-all", "value"),
            prevent_initial_call=True
        )
        def _sync_cl_core(opt, sel, all):
            return _sync_checklists(opt, sel, all, "cl-ctrl-core")

        @app.callback(
            Output("cl-ctrl-framesize", "value"),
            Output("cl-ctrl-framesize-all", "value"),
            State("cl-ctrl-framesize", "options"),
            Input("cl-ctrl-framesize", "value"),
            Input("cl-ctrl-framesize-all", "value"),
            prevent_initial_call=True
        )
        def _sync_cl_framesize(opt, sel, all):
            return _sync_checklists(opt, sel, all, "cl-ctrl-framesize")

        @app.callback(
            Output("cl-ctrl-testtype", "value"),
            Output("cl-ctrl-testtype-all", "value"),
            State("cl-ctrl-testtype", "options"),
            Input("cl-ctrl-testtype", "value"),
            Input("cl-ctrl-testtype-all", "value"),
            prevent_initial_call=True
        )
        def _sync_cl_testtype(opt, sel, all):
            return _sync_checklists(opt, sel, all, "cl-ctrl-testtype")

        @app.callback(
            Output("graph-tput", "figure"),
            Output("graph-latency", "figure"),
            Output("div-tput", "style"),
            Output("div-latency", "style"),
            Output("div-lat-metadata", "style"),
            Output("div-download", "style"),
            Output("selected-tests", "data"),  # Store
            Output("cl-selected", "options"),  # User selection
            Output("dd-ctrl-phy", "value"),
            Output("dd-ctrl-area", "value"),
            Output("dd-ctrl-test", "value"),
            State("selected-tests", "data"),  # Store
            State("cl-selected", "value"),
            State("dd-ctrl-phy", "value"),
            State("dd-ctrl-area", "value"),
            State("dd-ctrl-test", "value"),
            State("cl-ctrl-core", "value"),
            State("cl-ctrl-framesize", "value"),
            State("cl-ctrl-testtype", "value"),
            Input("btn-ctrl-add", "n_clicks"),
            Input("btn-sel-display", "n_clicks"),
            Input("btn-sel-remove", "n_clicks"),
            Input("dpr-period", "start_date"),
            Input("dpr-period", "end_date"),
            prevent_initial_call=True
        )
        def _process_list(store_sel, list_sel, phy, area, test, cores,
                framesizes, testtypes, btn_add, btn_display, btn_remove,
                d_start, d_end):
            """
            """

            if not (btn_add or btn_display or btn_remove or d_start or d_end):
                raise PreventUpdate

            def _list_tests():
                # Display selected tests with checkboxes:
                if store_sel:
                    return [
                        {"label": v["id"], "value": v["id"]} for v in store_sel
                    ]
                else:
                    return list()

            class RetunValue:
                def __init__(self) -> None:
                    self._output = {
                        "graph-tput-figure": no_update,
                        "graph-lat-figure": no_update,
                        "div-tput-style": no_update,
                        "div-latency-style": no_update,
                        "div-lat-metadata-style": no_update,
                        "div-download-style": no_update,
                        "selected-tests-data": no_update,
                        "cl-selected-options": no_update,
                        "dd-ctrl-phy-value": no_update,
                        "dd-ctrl-area-value": no_update,
                        "dd-ctrl-test-value": no_update,
                    }

                def value(self):
                    return tuple(self._output.values())

                def set_values(self, kwargs: dict) -> None:
                    for key, val in kwargs.items():
                        if key in self._output:
                            self._output[key] = val
                        else:
                            raise KeyError(f"The key {key} is not defined.")


            trigger_id = callback_context.triggered[0]["prop_id"].split(".")[0]

            d_start = datetime(int(d_start[0:4]), int(d_start[5:7]),
                int(d_start[8:10]))
            d_end = datetime(int(d_end[0:4]), int(d_end[5:7]), int(d_end[8:10]))

            output = RetunValue()

            if trigger_id == "btn-ctrl-add":
                # Add selected test to the list of tests in store:
                if phy and area and test and cores and framesizes and testtypes:
                    if store_sel is None:
                        store_sel = list()
                    for core in cores:
                        for framesize in framesizes:
                            for ttype in testtypes:
                                tid = (
                                    f"{phy.replace('af_xdp', 'af-xdp')}-"
                                    f"{area}-"
                                    f"{framesize.lower()}-"
                                    f"{core.lower()}-"
                                    f"{test}-"
                                    f"{ttype.lower()}"
                                )
                                if tid not in [itm["id"] for itm in store_sel]:
                                    store_sel.append({
                                        "id": tid,
                                        "phy": phy,
                                        "area": area,
                                        "test": test,
                                        "framesize": framesize.lower(),
                                        "core": core.lower(),
                                        "testtype": ttype.lower()
                                    })
                output.set_values({
                    "selected-tests-data": store_sel,
                    "cl-selected-options": _list_tests(),
                    "dd-ctrl-phy-value": None,
                    "dd-ctrl-area-value": None,
                    "dd-ctrl-test-value": None,
                })

            elif trigger_id in ("btn-sel-display", "dpr-period"):
                fig_tput, fig_lat = graph_trending(
                    self.data, store_sel, self.layout, d_start, d_end
                )
                output.set_values({
                    "graph-tput-figure": \
                        fig_tput if fig_tput else self.NO_GRAPH,
                    "graph-lat-figure": \
                        fig_lat if fig_lat else self.NO_GRAPH,
                    "div-tput-style": \
                        self.STYLE_BLOCK if fig_tput else self.STYLE_HIDEN,
                    "div-latency-style": \
                        self.STYLE_BLOCK if fig_lat else self.STYLE_HIDEN,
                    "div-lat-metadata-style": \
                        self.STYLE_BLOCK if fig_lat else self.STYLE_HIDEN,
                    "div-download-style": \
                        self.STYLE_BLOCK if fig_tput else self.STYLE_HIDEN,
                })

            elif trigger_id == "btn-sel-remove":
                if list_sel:
                    new_store_sel = list()
                    for item in store_sel:
                        if item["id"] not in list_sel:
                            new_store_sel.append(item)
                    store_sel = new_store_sel
                if store_sel:
                    fig_tput, fig_lat = graph_trending(
                        self.data, store_sel, self.layout, d_start, d_end
                    )
                    output.set_values({
                        "graph-tput-figure": \
                            fig_tput if fig_tput else self.NO_GRAPH,
                        "graph-lat-figure": \
                            fig_lat if fig_lat else self.NO_GRAPH,
                        "div-tput-style": \
                            self.STYLE_BLOCK if fig_tput else self.STYLE_HIDEN,
                        "div-latency-style": \
                            self.STYLE_BLOCK if fig_lat else self.STYLE_HIDEN,
                        "div-lat-metadata-style": \
                            self.STYLE_BLOCK if fig_lat else self.STYLE_HIDEN,
                        "div-download-style": \
                            self.STYLE_BLOCK if fig_tput else self.STYLE_HIDEN,
                        "selected-tests-data": store_sel,
                        "cl-selected-options": _list_tests()
                    })
                else:
                    output.set_values({
                        "graph-tput-figure": self.NO_GRAPH,
                        "graph-lat-figure": self.NO_GRAPH,
                        "div-tput-style": self.STYLE_HIDEN,
                        "div-latency-style": self.STYLE_HIDEN,
                        "div-lat-metadata-style": self.STYLE_HIDEN,
                        "div-download-style": self.STYLE_HIDEN,
                        "selected-tests-data": store_sel,
                        "cl-selected-options": _list_tests()
                    })

            return output.value()

        @app.callback(
            Output("tput-metadata", "children"),
            Input("graph-tput", "clickData")
        )
        def _show_tput_metadata(hover_data):
            """
            """
            if not hover_data:
                raise PreventUpdate

            return hover_data["points"][0]["text"].replace("<br>", "\n")

        @app.callback(
            Output("graph-latency-hdrh", "figure"),
            Output("graph-latency-hdrh", "style"),
            Output("lat-metadata", "children"),
            Input("graph-latency", "clickData")
        )
        def _show_latency_hdhr(hover_data):
            """
            """
            if not hover_data:
                raise PreventUpdate

            graph = no_update
            hdrh_data = hover_data["points"][0].get("customdata", None)
            if hdrh_data:
                graph = graph_hdrh_latency(hdrh_data, self.layout)

            return (
                graph,
                self.STYLE_INLINE,
                hover_data["points"][0]["text"].replace("<br>", "\n")
            )

        @app.callback(
            Output("download-data", "data"),
            State("selected-tests", "data"),
            Input("btn-download-data", "n_clicks"),
            prevent_initial_call=True
        )
        def _download_data(store_sel, n_clicks):
            """
            """

            if not n_clicks:
                raise PreventUpdate

            df = pd.DataFrame()
            for itm in store_sel:
                sel_data = select_trending_data(self.data, itm)
                if sel_data is None:
                    continue
                df = pd.concat([df, sel_data], ignore_index=True)

            return dcc.send_data_frame(df.to_csv, "trending_data.csv")