X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=resources%2Ftools%2Fdash%2Fapp%2Fpal%2Fnews%2Flayout.py;h=73fabdf88446fe0da4eaaaa4709f5e778bc0b350;hb=refs%2Fchanges%2F62%2F36762%2F2;hp=c34575b75a84e6f7387aa8757c032eb6738c1ece;hpb=6f2d3a207bd2ccad8001bfca328b7be5da8e29d0;p=csit.git diff --git a/resources/tools/dash/app/pal/news/layout.py b/resources/tools/dash/app/pal/news/layout.py index c34575b75a..73fabdf884 100644 --- a/resources/tools/dash/app/pal/news/layout.py +++ b/resources/tools/dash/app/pal/news/layout.py @@ -27,24 +27,39 @@ from yaml import load, FullLoader, YAMLError from copy import deepcopy from ..data.data import Data -from .tables import table_failed +from ..utils.constants import Constants as C +from ..utils.utils import classify_anomalies, show_tooltip, gen_new_url, \ + get_ttypes, get_cadences, get_test_beds, get_job, generate_options, \ + set_job_params +from ..utils.url_processing import url_decode +from ..data.data import Data +from .tables import table_news class Layout: + """The layout of the dash app and the callbacks. """ - """ - - DEFAULT_JOB = "csit-vpp-perf-mrr-daily-master-2n-icx" - URL_STYLE = { - "background-color": "#d2ebf5", - "border-color": "#bce1f1", - "color": "#135d7c" - } - - def __init__(self, app: Flask, html_layout_file: str, - data_spec_file: str, tooltip_file: str) -> None: - """ + def __init__(self, app: Flask, html_layout_file: str, data_spec_file: str, + tooltip_file: str) -> None: + """Initialization: + - save the input parameters, + - read and pre-process the data, + - prepare data for the control panel, + - read HTML layout file, + - read tooltips from the tooltip file. + + :param app: Flask application running the dash application. + :param html_layout_file: Path and name of the file specifying the HTML + layout of the dash application. + :param data_spec_file: Path and name of the file specifying the data to + be read from parquets for this application. + :param tooltip_file: Path and name of the yaml file specifying the + tooltips. + :type app: Flask + :type html_layout_file: str + :type data_spec_file: str + :type tooltip_file: str """ # Inputs @@ -57,12 +72,13 @@ class Layout: data_stats, data_mrr, data_ndrpdr = Data( data_spec_file=self._data_spec_file, debug=True - ).read_stats(days=10) # To be sure + ).read_stats(days=C.NEWS_TIME_PERIOD) df_tst_info = pd.concat([data_mrr, data_ndrpdr], ignore_index=True) + # Prepare information for the control panel: jobs = sorted(list(df_tst_info["job"].unique())) - job_info = { + d_job_info = { "job": list(), "dut": list(), "ttype": list(), @@ -71,14 +87,25 @@ class Layout: } for job in jobs: lst_job = job.split("-") - job_info["job"].append(job) - job_info["dut"].append(lst_job[1]) - job_info["ttype"].append(lst_job[3]) - job_info["cadence"].append(lst_job[4]) - job_info["tbed"].append("-".join(lst_job[-2:])) - self.df_job_info = pd.DataFrame.from_dict(job_info) + d_job_info["job"].append(job) + d_job_info["dut"].append(lst_job[1]) + d_job_info["ttype"].append(lst_job[3]) + d_job_info["cadence"].append(lst_job[4]) + d_job_info["tbed"].append("-".join(lst_job[-2:])) + self.job_info = pd.DataFrame.from_dict(d_job_info) - self._default = self._set_job_params(self.DEFAULT_JOB) + self._default = set_job_params(self.job_info, C.NEWS_DEFAULT_JOB) + + # Pre-process the data: + + def _create_test_name(test: str) -> str: + lst_tst = test.split(".") + suite = lst_tst[-2].replace("2n1l-", "").replace("1n1l-", "").\ + replace("2n-", "") + return f"{suite.split('-')[0]}-{lst_tst[-1]}" + + def _get_rindex(array: list, itm: any) -> int: + return len(array) - 1 - array[::-1].index(itm) tst_info = { "job": list(), @@ -87,9 +114,12 @@ class Layout: "dut_type": list(), "dut_version": list(), "hosts": list(), - "lst_failed": list() + "failed": list(), + "regressions": list(), + "progressions": list() } for job in jobs: + # Create lists of failed tests: df_job = df_tst_info.loc[(df_tst_info["job"] == job)] last_build = max(df_job["build"].unique()) df_build = df_job.loc[(df_job["build"] == last_build)] @@ -107,18 +137,100 @@ class Layout: l_failed = list() try: for tst in failed_tests: - lst_tst = tst.split(".") - suite = lst_tst[-2].replace("2n1l-", "").\ - replace("1n1l-", "").replace("2n-", "") - l_failed.append(f"{suite.split('-')[0]}-{lst_tst[-1]}") + l_failed.append(_create_test_name(tst)) except KeyError: l_failed = list() - tst_info["lst_failed"].append(sorted(l_failed)) + tst_info["failed"].append(sorted(l_failed)) + + # Create lists of regressions and progressions: + l_reg = list() + l_prog = list() + + tests = df_job["test_id"].unique() + for test in tests: + tst_data = df_job.loc[df_job["test_id"] == test].sort_values( + by="start_time", ignore_index=True) + x_axis = tst_data["start_time"].tolist() + if "-ndrpdr" in test: + tst_data = tst_data.dropna( + subset=["result_pdr_lower_rate_value", ] + ) + if tst_data.empty: + continue + try: + anomalies, _, _ = classify_anomalies({ + k: v for k, v in zip( + x_axis, + tst_data["result_ndr_lower_rate_value"].tolist() + ) + }) + except ValueError: + continue + if "progression" in anomalies: + l_prog.append(( + _create_test_name(test).replace("-ndrpdr", "-ndr"), + x_axis[_get_rindex(anomalies, "progression")] + )) + if "regression" in anomalies: + l_reg.append(( + _create_test_name(test).replace("-ndrpdr", "-ndr"), + x_axis[_get_rindex(anomalies, "regression")] + )) + try: + anomalies, _, _ = classify_anomalies({ + k: v for k, v in zip( + x_axis, + tst_data["result_pdr_lower_rate_value"].tolist() + ) + }) + except ValueError: + continue + if "progression" in anomalies: + l_prog.append(( + _create_test_name(test).replace("-ndrpdr", "-pdr"), + x_axis[_get_rindex(anomalies, "progression")] + )) + if "regression" in anomalies: + l_reg.append(( + _create_test_name(test).replace("-ndrpdr", "-pdr"), + x_axis[_get_rindex(anomalies, "regression")] + )) + else: # mrr + tst_data = tst_data.dropna( + subset=["result_receive_rate_rate_avg", ] + ) + if tst_data.empty: + continue + try: + anomalies, _, _ = classify_anomalies({ + k: v for k, v in zip( + x_axis, + tst_data["result_receive_rate_rate_avg"].\ + tolist() + ) + }) + except ValueError: + continue + if "progression" in anomalies: + l_prog.append(( + _create_test_name(test), + x_axis[_get_rindex(anomalies, "progression")] + )) + if "regression" in anomalies: + l_reg.append(( + _create_test_name(test), + x_axis[_get_rindex(anomalies, "regression")] + )) + + tst_info["regressions"].append( + sorted(l_reg, key=lambda k: k[1], reverse=True)) + tst_info["progressions"].append( + sorted(l_prog, key=lambda k: k[1], reverse=True)) self._data = pd.DataFrame.from_dict(tst_info) # Read from files: - self._html_layout = "" + self._html_layout = str() self._tooltips = dict() try: @@ -142,7 +254,7 @@ class Layout: f"{self._tooltip_file}\n{err}" ) - self._default_tab_failed = table_failed(self.data, self._default["job"]) + self._default_tab_failed = table_news(self.data, self._default["job"]) # Callbacks: if self._app is not None and hasattr(self, 'callbacks'): @@ -157,99 +269,29 @@ class Layout: return self._data @property - def default(self) -> any: + def default(self) -> dict: return self._default - def _get_duts(self) -> list: - """ - """ - return sorted(list(self.df_job_info["dut"].unique())) - - def _get_ttypes(self, dut: str) -> list: - """ - """ - return sorted(list(self.df_job_info.loc[( - self.df_job_info["dut"] == dut - )]["ttype"].unique())) - - def _get_cadences(self, dut: str, ttype: str) -> list: - """ - """ - return sorted(list(self.df_job_info.loc[( - (self.df_job_info["dut"] == dut) & - (self.df_job_info["ttype"] == ttype) - )]["cadence"].unique())) - - def _get_test_beds(self, dut: str, ttype: str, cadence: str) -> list: - """ - """ - return sorted(list(self.df_job_info.loc[( - (self.df_job_info["dut"] == dut) & - (self.df_job_info["ttype"] == ttype) & - (self.df_job_info["cadence"] == cadence) - )]["tbed"].unique())) + def add_content(self): + """Top level method which generated the web page. - def _get_job(self, dut, ttype, cadence, testbed): - """Get the name of a job defined by dut, ttype, cadence, testbed. + It generates: + - Store for user input data, + - Navigation bar, + - Main area with control panel and ploting area. - Input information comes from control panel. - """ - return self.df_job_info.loc[( - (self.df_job_info["dut"] == dut) & - (self.df_job_info["ttype"] == ttype) & - (self.df_job_info["cadence"] == cadence) & - (self.df_job_info["tbed"] == testbed) - )]["job"].item() - - def _set_job_params(self, job: str) -> dict: - """ - """ - lst_job = job.split("-") - return { - "job": job, - "dut": lst_job[1], - "ttype": lst_job[3], - "cadence": lst_job[4], - "tbed": "-".join(lst_job[-2:]), - "duts": self._generate_options(self._get_duts()), - "ttypes": self._generate_options(self._get_ttypes(lst_job[1])), - "cadences": self._generate_options(self._get_cadences( - lst_job[1], lst_job[3])), - "tbeds": self._generate_options(self._get_test_beds( - lst_job[1], lst_job[3], lst_job[4])) - } + If no HTML layout is provided, an error message is displayed instead. - def _show_tooltip(self, id: str, title: str, - clipboard_id: str=None) -> list: + :returns: The HTML div with the whole page. + :rtype: html.Div """ - """ - return [ - dcc.Clipboard(target_id=clipboard_id, title="Copy URL") \ - if clipboard_id else str(), - f"{title} ", - dbc.Badge( - id=id, - children="?", - pill=True, - color="white", - text_color="info", - class_name="border ms-1", - ), - dbc.Tooltip( - children=self._tooltips.get(id, str()), - target=id, - placement="auto" - ) - ] - def add_content(self): - """ - """ if self.html_layout: return html.Div( id="div-main", children=[ dcc.Store(id="control-panel"), + dcc.Location(id="url", refresh=False), dbc.Row( id="row-navbar", class_name="g-0", @@ -282,7 +324,11 @@ class Layout: def _add_navbar(self): """Add nav element with navigation panel. It is placed on the top. + + :returns: Navigation bar. + :rtype: dbc.NavbarSimple """ + return dbc.NavbarSimple( id="navbarsimple-main", children=[ @@ -303,8 +349,12 @@ class Layout: ) def _add_ctrl_col(self) -> dbc.Col: - """Add column with controls. It is placed on the left side. + """Add column with control panel. It is placed on the left side. + + :returns: Column with the control panel. + :rtype: dbc.Col """ + return dbc.Col( id="col-controls", children=[ @@ -313,8 +363,12 @@ class Layout: ) def _add_plotting_col(self) -> dbc.Col: - """Add column with plots and tables. It is placed on the right side. + """Add column with tables. It is placed on the right side. + + :returns: Column with tables. + :rtype: dbc.Col """ + return dbc.Col( id="col-plotting-area", children=[ @@ -322,13 +376,43 @@ class Layout: id="row-table-failed", class_name="g-0 p-2", children=self._default_tab_failed + ), + dbc.Row( + class_name="g-0 p-2", + align="center", + justify="start", + children=[ + dbc.InputGroup( + class_name="me-1", + children=[ + dbc.InputGroupText( + style=C.URL_STYLE, + children=show_tooltip( + self._tooltips, + "help-url", "URL", + "input-url" + ) + ), + dbc.Input( + id="input-url", + readonly=True, + type="url", + style=C.URL_STYLE, + value="" + ) + ] + ) + ] ) ], width=9, ) def _add_ctrl_panel(self) -> dbc.Row: - """ + """Add control panel. + + :returns: Control panel. + :rtype: dbc.Row """ return dbc.Row( id="row-ctrl-panel", @@ -342,7 +426,7 @@ class Layout: children=[ dbc.Label( class_name="p-0", - children=self._show_tooltip( + children=show_tooltip(self._tooltips, "help-dut", "Device under Test") ), dbc.Row( @@ -360,7 +444,7 @@ class Layout: children=[ dbc.Label( class_name="p-0", - children=self._show_tooltip( + children=show_tooltip(self._tooltips, "help-ttype", "Test Type"), ), dbc.RadioItems( @@ -376,7 +460,7 @@ class Layout: children=[ dbc.Label( class_name="p-0", - children=self._show_tooltip( + children=show_tooltip(self._tooltips, "help-cadence", "Cadence"), ), dbc.RadioItems( @@ -392,7 +476,7 @@ class Layout: children=[ dbc.Label( class_name="p-0", - children=self._show_tooltip( + children=show_tooltip(self._tooltips, "help-tbed", "Test Bed"), ), dbc.Select( @@ -414,12 +498,25 @@ class Layout: ] ) ] - ), + ) ] ) class ControlPanel: + """A class representing the control panel. + """ + def __init__(self, panel: dict, default: dict) -> None: + """Initialisation of the control pannel by default values. If + particular values are provided (parameter "panel") they are set + afterwards. + + :param panel: Custom values to be set to the control panel. + :param default: Default values to be set to the control panel. + :type panel: dict + :type defaults: dict + """ + self._defaults = { "ri-ttypes-options": default["ttypes"], "ri-cadences-options": default["cadences"], @@ -436,6 +533,13 @@ class Layout: self._panel[key] = panel[key] def set(self, kwargs: dict) -> None: + """Set the values of the Control panel. + + :param kwargs: key - value pairs to be set. + :type kwargs: dict + :raises KeyError: If the key in kwargs is not present in the Control + panel. + """ for key, val in kwargs.items(): if key in self._panel: self._panel[key] = val @@ -451,20 +555,36 @@ class Layout: return self._panel def get(self, key: str) -> any: + """Returns the value of a key from the Control panel. + + :param key: The key which value should be returned. + :type key: str + :returns: The value of the key. + :rtype: any + :raises KeyError: If the key in kwargs is not present in the Control + panel. + """ return self._panel[key] def values(self) -> list: - return list(self._panel.values()) + """Returns the values from the Control panel as a list. - @staticmethod - def _generate_options(opts: list) -> list: - return [{"label": i, "value": i} for i in opts] + :returns: The values from the Control panel. + :rtype: list + """ + return list(self._panel.values()) def callbacks(self, app): + """Callbacks for the whole application. + + :param app: The application. + :type app: Flask + """ @app.callback( Output("control-panel", "data"), # Store Output("row-table-failed", "children"), + Output("input-url", "value"), Output("ri-ttypes", "options"), Output("ri-cadences", "options"), Output("dd-tbeds", "options"), @@ -478,23 +598,47 @@ class Layout: Input("ri-ttypes", "value"), Input("ri-cadences", "value"), Input("dd-tbeds", "value"), + Input("url", "href") ) - def _update_ctrl_panel(cp_data: dict, dut:str, ttype: str, cadence:str, - tbed: str) -> tuple: - """ + def _update_application(cp_data: dict, dut: str, ttype: str, + cadence:str, tbed: str, href: str) -> tuple: + """Update the application when the event is detected. + + :param cp_data: Current status of the control panel stored in + browser. + :param dut: Input - DUT name. + :param ttype: Input - Test type. + :param cadence: Input - The cadence of the job. + :param tbed: Input - The test bed. + :param href: Input - The URL provided by the browser. + :type cp_data: dict + :type dut: str + :type ttype: str + :type cadence: str + :type tbed: str + :type href: str + :returns: New values for web page elements. + :rtype: tuple """ ctrl_panel = self.ControlPanel(cp_data, self.default) + # Parse the url: + parsed_url = url_decode(href) + if parsed_url: + url_params = parsed_url["params"] + else: + url_params = None + trigger_id = callback_context.triggered[0]["prop_id"].split(".")[0] if trigger_id == "ri-duts": - ttype_opts = self._generate_options(self._get_ttypes(dut)) + ttype_opts = generate_options(get_ttypes(self.job_info, dut)) ttype_val = ttype_opts[0]["value"] - cad_opts = self._generate_options( - self._get_cadences(dut, ttype_val)) + cad_opts = generate_options( + get_cadences(self.job_info, dut, ttype_val)) cad_val = cad_opts[0]["value"] - tbed_opts = self._generate_options( - self._get_test_beds(dut, ttype_val, cad_val)) + tbed_opts = generate_options(get_test_beds( + self.job_info, dut, ttype_val, cad_val)) tbed_val = tbed_opts[0]["value"] ctrl_panel.set({ "ri-duts-value": dut, @@ -506,11 +650,11 @@ class Layout: "dd-tbeds-value": tbed_val }) elif trigger_id == "ri-ttypes": - cad_opts = self._generate_options( - self._get_cadences(ctrl_panel.get("ri-duts-value"), ttype)) + cad_opts = generate_options(get_cadences( + self.job_info, ctrl_panel.get("ri-duts-value"), ttype)) cad_val = cad_opts[0]["value"] - tbed_opts = self._generate_options( - self._get_test_beds(ctrl_panel.get("ri-duts-value"), + tbed_opts = generate_options(get_test_beds( + self.job_info, ctrl_panel.get("ri-duts-value"), ttype, cad_val)) tbed_val = tbed_opts[0]["value"] ctrl_panel.set({ @@ -521,8 +665,8 @@ class Layout: "dd-tbeds-value": tbed_val }) elif trigger_id == "ri-cadences": - tbed_opts = self._generate_options( - self._get_test_beds(ctrl_panel.get("ri-duts-value"), + tbed_opts = generate_options(get_test_beds( + self.job_info, ctrl_panel.get("ri-duts-value"), ctrl_panel.get("ri-ttypes-value"), cadence)) tbed_val = tbed_opts[0]["value"] ctrl_panel.set({ @@ -534,19 +678,30 @@ class Layout: ctrl_panel.set({ "dd-tbeds-value": tbed }) + elif trigger_id == "url": + # TODO: Add verification + if url_params: + new_job = url_params.get("job", list())[0] + if new_job: + job_params = set_job_params(self.job_info, new_job) + ctrl_panel = self.ControlPanel(None, job_params) + else: + ctrl_panel = self.ControlPanel(cp_data, self.default) - job = self._get_job( + job = get_job( + self.job_info, ctrl_panel.get("ri-duts-value"), ctrl_panel.get("ri-ttypes-value"), ctrl_panel.get("ri-cadences-value"), ctrl_panel.get("dd-tbeds-value") ) ctrl_panel.set({"al-job-children": job}) - tab_failed = table_failed(self.data, job) + tab_failed = table_news(self.data, job) ret_val = [ ctrl_panel.panel, - tab_failed + tab_failed, + gen_new_url(parsed_url, {"job": job}) ] ret_val.extend(ctrl_panel.values()) return ret_val