resources/tools/dash/app/pal/news/layout.py

   1 # Copyright (c) 2022 Cisco and/or its affiliates.
   2 # Licensed under the Apache License, Version 2.0 (the "License");
   3 # you may not use this file except in compliance with the License.
   4 # You may obtain a copy of the License at:
   5 #
   6 #     http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 # Unless required by applicable law or agreed to in writing, software
   9 # distributed under the License is distributed on an "AS IS" BASIS,
  10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 # See the License for the specific language governing permissions and
  12 # limitations under the License.
  13
  14 """Plotly Dash HTML layout override.
  15 """
  16
  17 import logging
  18 import pandas as pd
  19 import dash_bootstrap_components as dbc
  20
  21 from flask import Flask
  22 from dash import dcc
  23 from dash import html
  24 from dash import callback_context
  25 from dash import Input, Output
  26 from yaml import load, FullLoader, YAMLError
  27
  28 from ..data.data import Data
  29 from ..utils.constants import Constants as C
  30 from ..utils.utils import classify_anomalies, show_tooltip, gen_new_url
  31 from ..utils.url_processing import url_decode
  32 from ..data.data import Data
  33 from .tables import table_summary
  34
  35
  36 class Layout:
  37     """The layout of the dash app and the callbacks.
  38     """
  39
  40     def __init__(self, app: Flask, html_layout_file: str, data_spec_file: str,
  41         tooltip_file: str) -> None:
  42         """Initialization:
  43         - save the input parameters,
  44         - read and pre-process the data,
  45         - prepare data for the control panel,
  46         - read HTML layout file,
  47         - read tooltips from the tooltip file.
  48
  49         :param app: Flask application running the dash application.
  50         :param html_layout_file: Path and name of the file specifying the HTML
  51             layout of the dash application.
  52         :param data_spec_file: Path and name of the file specifying the data to
  53             be read from parquets for this application.
  54         :param tooltip_file: Path and name of the yaml file specifying the
  55             tooltips.
  56         :type app: Flask
  57         :type html_layout_file: str
  58         :type data_spec_file: str
  59         :type tooltip_file: str
  60         """
  61
  62         # Inputs
  63         self._app = app
  64         self._html_layout_file = html_layout_file
  65         self._data_spec_file = data_spec_file
  66         self._tooltip_file = tooltip_file
  67
  68         # Read the data:
  69         data_stats, data_mrr, data_ndrpdr = Data(
  70             data_spec_file=self._data_spec_file,
  71             debug=True
  72         ).read_stats(days=C.NEWS_TIME_PERIOD)
  73
  74         df_tst_info = pd.concat([data_mrr, data_ndrpdr], ignore_index=True)
  75
  76         # Prepare information for the control panel:
  77         self._jobs = sorted(list(df_tst_info["job"].unique()))
  78         d_job_info = {
  79             "job": list(),
  80             "dut": list(),
  81             "ttype": list(),
  82             "cadence": list(),
  83             "tbed": list()
  84         }
  85         for job in self._jobs:
  86             lst_job = job.split("-")
  87             d_job_info["job"].append(job)
  88             d_job_info["dut"].append(lst_job[1])
  89             d_job_info["ttype"].append(lst_job[3])
  90             d_job_info["cadence"].append(lst_job[4])
  91             d_job_info["tbed"].append("-".join(lst_job[-2:]))
  92         self.job_info = pd.DataFrame.from_dict(d_job_info)
  93
  94         # Pre-process the data:
  95
  96         def _create_test_name(test: str) -> str:
  97             lst_tst = test.split(".")
  98             suite = lst_tst[-2].replace("2n1l-", "").replace("1n1l-", "").\
  99                 replace("2n-", "")
 100             return f"{suite.split('-')[0]}-{lst_tst[-1]}"
 101
 102         def _get_rindex(array: list, itm: any) -> int:
 103             return len(array) - 1 - array[::-1].index(itm)
 104
 105         tst_info = {
 106             "job": list(),
 107             "build": list(),
 108             "start": list(),
 109             "dut_type": list(),
 110             "dut_version": list(),
 111             "hosts": list(),
 112             "failed": list(),
 113             "regressions": list(),
 114             "progressions": list()
 115         }
 116         for job in self._jobs:
 117             # Create lists of failed tests:
 118             df_job = df_tst_info.loc[(df_tst_info["job"] == job)]
 119             last_build = str(max(pd.to_numeric(df_job["build"].unique())))
 120             df_build = df_job.loc[(df_job["build"] == last_build)]
 121             tst_info["job"].append(job)
 122             tst_info["build"].append(last_build)
 123             tst_info["start"].append(data_stats.loc[
 124                 (data_stats["job"] == job) &
 125                 (data_stats["build"] == last_build)
 126             ]["start_time"].iloc[-1].strftime('%Y-%m-%d %H:%M'))
 127             tst_info["dut_type"].append(df_build["dut_type"].iloc[-1])
 128             tst_info["dut_version"].append(df_build["dut_version"].iloc[-1])
 129             tst_info["hosts"].append(df_build["hosts"].iloc[-1])
 130             failed_tests = df_build.loc[(df_build["passed"] == False)]\
 131                 ["test_id"].to_list()
 132             l_failed = list()
 133             try:
 134                 for tst in failed_tests:
 135                     l_failed.append(_create_test_name(tst))
 136             except KeyError:
 137                 l_failed = list()
 138             tst_info["failed"].append(sorted(l_failed))
 139
 140             # Create lists of regressions and progressions:
 141             l_reg = list()
 142             l_prog = list()
 143
 144             tests = df_job["test_id"].unique()
 145             for test in tests:
 146                 tst_data = df_job.loc[df_job["test_id"] == test].sort_values(
 147                     by="start_time", ignore_index=True)
 148                 x_axis = tst_data["start_time"].tolist()
 149                 if "-ndrpdr" in test:
 150                     tst_data = tst_data.dropna(
 151                         subset=["result_pdr_lower_rate_value", ]
 152                     )
 153                     if tst_data.empty:
 154                         continue
 155                     try:
 156                         anomalies, _, _ = classify_anomalies({
 157                             k: v for k, v in zip(
 158                                 x_axis,
 159                                 tst_data["result_ndr_lower_rate_value"].tolist()
 160                             )
 161                         })
 162                     except ValueError:
 163                         continue
 164                     if "progression" in anomalies:
 165                         l_prog.append((
 166                             _create_test_name(test).replace("-ndrpdr", "-ndr"),
 167                             x_axis[_get_rindex(anomalies, "progression")]
 168                         ))
 169                     if "regression" in anomalies:
 170                         l_reg.append((
 171                             _create_test_name(test).replace("-ndrpdr", "-ndr"),
 172                             x_axis[_get_rindex(anomalies, "regression")]
 173                         ))
 174                     try:
 175                         anomalies, _, _ = classify_anomalies({
 176                             k: v for k, v in zip(
 177                                 x_axis,
 178                                 tst_data["result_pdr_lower_rate_value"].tolist()
 179                             )
 180                         })
 181                     except ValueError:
 182                         continue
 183                     if "progression" in anomalies:
 184                         l_prog.append((
 185                             _create_test_name(test).replace("-ndrpdr", "-pdr"),
 186                             x_axis[_get_rindex(anomalies, "progression")]
 187                         ))
 188                     if "regression" in anomalies:
 189                         l_reg.append((
 190                             _create_test_name(test).replace("-ndrpdr", "-pdr"),
 191                             x_axis[_get_rindex(anomalies, "regression")]
 192                         ))
 193                 else:  # mrr
 194                     tst_data = tst_data.dropna(
 195                         subset=["result_receive_rate_rate_avg", ]
 196                     )
 197                     if tst_data.empty:
 198                         continue
 199                     try:
 200                         anomalies, _, _ = classify_anomalies({
 201                             k: v for k, v in zip(
 202                                 x_axis,
 203                                 tst_data["result_receive_rate_rate_avg"].\
 204                                     tolist()
 205                             )
 206                         })
 207                     except ValueError:
 208                         continue
 209                     if "progression" in anomalies:
 210                         l_prog.append((
 211                             _create_test_name(test),
 212                             x_axis[_get_rindex(anomalies, "progression")]
 213                         ))
 214                     if "regression" in anomalies:
 215                         l_reg.append((
 216                             _create_test_name(test),
 217                             x_axis[_get_rindex(anomalies, "regression")]
 218                         ))
 219
 220             tst_info["regressions"].append(
 221                 sorted(l_reg, key=lambda k: k[1], reverse=True))
 222             tst_info["progressions"].append(
 223                 sorted(l_prog, key=lambda k: k[1], reverse=True))
 224
 225         self._data = pd.DataFrame.from_dict(tst_info)
 226
 227         # Read from files:
 228         self._html_layout = str()
 229         self._tooltips = dict()
 230
 231         try:
 232             with open(self._html_layout_file, "r") as file_read:
 233                 self._html_layout = file_read.read()
 234         except IOError as err:
 235             raise RuntimeError(
 236                 f"Not possible to open the file {self._html_layout_file}\n{err}"
 237             )
 238
 239         try:
 240             with open(self._tooltip_file, "r") as file_read:
 241                 self._tooltips = load(file_read, Loader=FullLoader)
 242         except IOError as err:
 243             logging.warning(
 244                 f"Not possible to open the file {self._tooltip_file}\n{err}"
 245             )
 246         except YAMLError as err:
 247             logging.warning(
 248                 f"An error occurred while parsing the specification file "
 249                 f"{self._tooltip_file}\n{err}"
 250             )
 251
 252         self._default_period = C.NEWS_SHORT
 253         self._default_active = (False, True, False)
 254         self._default_table = \
 255             table_summary(self._data, self._jobs, self._default_period)
 256
 257         # Callbacks:
 258         if self._app is not None and hasattr(self, 'callbacks'):
 259             self.callbacks(self._app)
 260
 261     @property
 262     def html_layout(self) -> dict:
 263         return self._html_layout
 264
 265     def add_content(self):
 266         """Top level method which generated the web page.
 267
 268         It generates:
 269         - Store for user input data,
 270         - Navigation bar,
 271         - Main area with control panel and ploting area.
 272
 273         If no HTML layout is provided, an error message is displayed instead.
 274
 275         :returns: The HTML div with the whole page.
 276         :rtype: html.Div
 277         """
 278
 279         if self.html_layout:
 280             return html.Div(
 281                 id="div-main",
 282                 children=[
 283                     dcc.Location(id="url", refresh=False),
 284                     dbc.Row(
 285                         id="row-navbar",
 286                         class_name="g-0",
 287                         children=[
 288                             self._add_navbar(),
 289                         ]
 290                     ),
 291                     dbc.Row(
 292                         id="row-main",
 293                         class_name="g-0",
 294                         children=[
 295                             self._add_ctrl_col(),
 296                             self._add_plotting_col(),
 297                         ]
 298                     )
 299                 ]
 300             )
 301         else:
 302             return html.Div(
 303                 id="div-main-error",
 304                 children=[
 305                     dbc.Alert(
 306                         [
 307                             "An Error Occured",
 308                         ],
 309                         color="danger",
 310                     ),
 311                 ]
 312             )
 313
 314     def _add_navbar(self):
 315         """Add nav element with navigation panel. It is placed on the top.
 316
 317         :returns: Navigation bar.
 318         :rtype: dbc.NavbarSimple
 319         """
 320
 321         return dbc.NavbarSimple(
 322             id="navbarsimple-main",
 323             children=[
 324                 dbc.NavItem(
 325                     dbc.NavLink(
 326                         "Continuous Performance News",
 327                         disabled=True,
 328                         external_link=True,
 329                         href="#"
 330                     )
 331                 )
 332             ],
 333             brand="Dashboard",
 334             brand_href="/",
 335             brand_external_link=True,
 336             class_name="p-2",
 337             fluid=True,
 338         )
 339
 340     def _add_ctrl_col(self) -> dbc.Col:
 341         """Add column with control panel. It is placed on the left side.
 342
 343         :returns: Column with the control panel.
 344         :rtype: dbc.Col
 345         """
 346
 347         return dbc.Col(
 348             id="col-controls",
 349             children=[
 350                 self._add_ctrl_panel(),
 351             ],
 352         )
 353
 354     def _add_plotting_col(self) -> dbc.Col:
 355         """Add column with tables. It is placed on the right side.
 356
 357         :returns: Column with tables.
 358         :rtype: dbc.Col
 359         """
 360
 361         return dbc.Col(
 362             id="col-plotting-area",
 363             children=[
 364                 dcc.Loading(
 365                     children=[
 366                         dbc.Row(  # Failed tests
 367                             id="row-table",
 368                             class_name="g-0 p-2",
 369                             children=self._default_table
 370                         ),
 371                         dbc.Row(
 372                             class_name="g-0 p-2",
 373                             align="center",
 374                             justify="start",
 375                             children=[
 376                                 dbc.InputGroup(
 377                                     class_name="me-1",
 378                                     children=[
 379                                         dbc.InputGroupText(
 380                                             style=C.URL_STYLE,
 381                                             children=show_tooltip(
 382                                                 self._tooltips,
 383                                                 "help-url", "URL",
 384                                                 "input-url"
 385                                             )
 386                                         ),
 387                                         dbc.Input(
 388                                             id="input-url",
 389                                             readonly=True,
 390                                             type="url",
 391                                             style=C.URL_STYLE,
 392                                             value=""
 393                                         )
 394                                     ]
 395                                 )
 396                             ]
 397                         )
 398                     ]
 399                 )
 400             ],
 401             width=9,
 402         )
 403
 404     def _add_ctrl_panel(self) -> dbc.Row:
 405         """Add control panel.
 406
 407         :returns: Control panel.
 408         :rtype: dbc.Row
 409         """
 410         return dbc.Row(
 411             id="row-ctrl-panel",
 412             class_name="g-0",
 413             children=[
 414                 dbc.Row(
 415                     class_name="g-0 p-2",
 416                     children=[
 417                         dbc.Row(
 418                             class_name="g-0",
 419                             children=[
 420                                 dbc.Label(
 421                                     class_name="g-0",
 422                                     children=show_tooltip(self._tooltips,
 423                                         "help-summary-period", "Window")
 424                                 ),
 425                                 dbc.Row(
 426                                     dbc.ButtonGroup(
 427                                         id="bg-time-period",
 428                                         class_name="g-0",
 429                                         children=[
 430                                             dbc.Button(
 431                                                 id="period-last",
 432                                                 children="Last Run",
 433                                                 className="me-1",
 434                                                 outline=True,
 435                                                 color="info"
 436                                             ),
 437                                             dbc.Button(
 438                                                 id="period-short",
 439                                                 children=\
 440                                                     f"Last {C.NEWS_SHORT} Runs",
 441                                                 className="me-1",
 442                                                 outline=True,
 443                                                 active=True,
 444                                                 color="info"
 445                                             ),
 446                                             dbc.Button(
 447                                                 id="period-long",
 448                                                 children="All Runs",
 449                                                 className="me-1",
 450                                                 outline=True,
 451                                                 color="info"
 452                                             )
 453                                         ]
 454                                     )
 455                                 )
 456                             ]
 457                         )
 458                     ]
 459                 )
 460             ]
 461         )
 462
 463     def callbacks(self, app):
 464         """Callbacks for the whole application.
 465
 466         :param app: The application.
 467         :type app: Flask
 468         """
 469
 470         @app.callback(
 471             Output("row-table", "children"),
 472             Output("input-url", "value"),
 473             Output("period-last", "active"),
 474             Output("period-short", "active"),
 475             Output("period-long", "active"),
 476             Input("period-last", "n_clicks"),
 477             Input("period-short", "n_clicks"),
 478             Input("period-long", "n_clicks"),
 479             Input("url", "href")
 480         )
 481         def _update_application(btn_last: int, btn_short: int, btn_long: int,
 482             href: str) -> tuple:
 483             """Update the application when the event is detected.
 484
 485             :returns: New values for web page elements.
 486             :rtype: tuple
 487             """
 488
 489             _, _, _ = btn_last, btn_short, btn_long
 490
 491             periods = {
 492                 "period-last": C.NEWS_LAST,
 493                 "period-short": C.NEWS_SHORT,
 494                 "period-long": C.NEWS_LONG
 495             }
 496             actives = {
 497                 "period-last": (True, False, False),
 498                 "period-short": (False, True, False),
 499                 "period-long": (False, False, True)
 500             }
 501
 502             # Parse the url:
 503             parsed_url = url_decode(href)
 504             if parsed_url:
 505                 url_params = parsed_url["params"]
 506             else:
 507                 url_params = None
 508
 509             trigger_id = callback_context.triggered[0]["prop_id"].split(".")[0]
 510             if trigger_id == "url" and url_params:
 511                 trigger_id = url_params.get("period", list())[0]
 512
 513             period = periods.get(trigger_id, self._default_period)
 514             active = actives.get(trigger_id, self._default_active)
 515
 516             ret_val = [
 517                 table_summary(self._data, self._jobs, period),
 518                 gen_new_url(parsed_url, {"period": trigger_id})
 519             ]
 520             ret_val.extend(active)
 521             return ret_val