X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=resources%2Ftools%2Fdash%2Fapp%2Fpal%2Futils%2Futils.py;h=9e4eeeb892ae08cdd72e0eab9c2606fdda3bed08;hb=refs%2Fchanges%2F28%2F36728%2F3;hp=63c9c1aaa44336a9ae59d3942bb96d4e29db54f5;hpb=ae1fe880286d7b0414664bce2b2c7c91c3f543f3;p=csit.git

diff --git a/resources/tools/dash/app/pal/utils/utils.py b/resources/tools/dash/app/pal/utils/utils.py
index 63c9c1aaa4..9e4eeeb892 100644
--- a/resources/tools/dash/app/pal/utils/utils.py
+++ b/resources/tools/dash/app/pal/utils/utils.py
@@ -11,12 +11,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""Function used by Dash applications.
 """
-"""
+
+import pandas as pd
+import dash_bootstrap_components as dbc
 
 from numpy import isnan
+from dash import dcc
+from datetime import datetime
 
 from ..jumpavg import classify
+from ..utils.constants import Constants as C
+from ..utils.url_processing import url_encode
 
 
 def classify_anomalies(data):
@@ -67,3 +74,271 @@ def classify_anomalies(data):
         stdevs.append(stdv)
         values_left -= 1
     return classification, avgs, stdevs
+
+
+def get_color(idx: int) -> str:
+    """Returns a color from the list defined in Constants.PLOT_COLORS defined by
+    its index.
+
+    :param idx: Index of the color.
+    :type idx: int
+    :returns: Color defined by hex code.
+    :trype: str
+    """
+    return C.PLOT_COLORS[idx % len(C.PLOT_COLORS)]
+
+
+def show_tooltip(tooltips:dict, id: str, title: str,
+        clipboard_id: str=None) -> list:
+    """Generate list of elements to display a text (e.g. a title) with a
+    tooltip and optionaly with Copy&Paste icon and the clipboard
+    functionality enabled.
+
+    :param tooltips: Dictionary with tooltips.
+    :param id: Tooltip ID.
+    :param title: A text for which the tooltip will be displayed.
+    :param clipboard_id: If defined, a Copy&Paste icon is displayed and the
+        clipboard functionality is enabled.
+    :type tooltips: dict
+    :type id: str
+    :type title: str
+    :type clipboard_id: str
+    :returns: List of elements to display a text with a tooltip and
+        optionaly with Copy&Paste icon.
+    :rtype: list
+    """
+
+    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=tooltips.get(id, str()),
+            target=id,
+            placement="auto"
+        )
+    ]
+
+
+def label(key: str) -> str:
+    """Returns a label for input elements (dropdowns, ...).
+
+    If the label is not defined, the function returns the provided key.
+
+    :param key: The key to the label defined in Constants.LABELS.
+    :type key: str
+    :returns: Label.
+    :rtype: str
+    """
+    return C.LABELS.get(key, key)
+
+
+def sync_checklists(options: list, sel: list, all: list, id: str) -> tuple:
+    """Synchronize a checklist with defined "options" with its "All" checklist.
+
+    :param options: List of options for the cheklist.
+    :param sel: List of selected options.
+    :param all: List of selected option from "All" checklist.
+    :param id: ID of a checklist to be used for synchronization.
+    :returns: Tuple of lists with otions for both checklists.
+    :rtype: tuple of lists
+    """
+    opts = {v["value"] for v in options}
+    if id =="all":
+        sel = list(opts) if all else list()
+    else:
+        all = ["all", ] if set(sel) == opts else list()
+    return sel, all
+
+
+def list_tests(selection: dict) -> list:
+    """Transform list of tests to a list of dictionaries usable by checkboxes.
+
+    :param selection: List of tests to be displayed in "Selected tests" window.
+    :type selection: list
+    :returns: List of dictionaries with "label", "value" pairs for a checkbox.
+    :rtype: list
+    """
+    if selection:
+        return [{"label": v["id"], "value": v["id"]} for v in selection]
+    else:
+        return list()
+
+
+def get_date(s_date: str) -> datetime:
+    """Transform string reprezentation of date to datetime.datetime data type.
+
+    :param s_date: String reprezentation of date.
+    :type s_date: str
+    :returns: Date as datetime.datetime.
+    :rtype: datetime.datetime
+    """
+    return datetime(int(s_date[0:4]), int(s_date[5:7]), int(s_date[8:10]))
+
+
+def gen_new_url(url_components: dict, params: dict) -> str:
+    """Generate a new URL with encoded parameters.
+
+    :param url_components: Dictionary with URL elements. It should contain
+        "scheme", "netloc" and "path".
+    :param url_components: URL parameters to be encoded to the URL.
+    :type parsed_url: dict
+    :type params: dict
+    :returns Encoded URL with parameters.
+    :rtype: str
+    """
+
+    if url_components:
+        return url_encode(
+            {
+                "scheme": url_components.get("scheme", ""),
+                "netloc": url_components.get("netloc", ""),
+                "path": url_components.get("path", ""),
+                "params": params
+            }
+        )
+    else:
+        return str()
+
+
+def get_duts(df: pd.DataFrame) -> list:
+    """Get the list of DUTs from the pre-processed information about jobs.
+
+    :param df: DataFrame with information about jobs.
+    :type df: pandas.DataFrame
+    :returns: Alphabeticaly sorted list of DUTs.
+    :rtype: list
+    """
+    return sorted(list(df["dut"].unique()))
+
+
+def get_ttypes(df: pd.DataFrame, dut: str) -> list:
+    """Get the list of test types from the pre-processed information about
+    jobs.
+
+    :param df: DataFrame with information about jobs.
+    :param dut: The DUT for which the list of test types will be populated.
+    :type df: pandas.DataFrame
+    :type dut: str
+    :returns: Alphabeticaly sorted list of test types.
+    :rtype: list
+    """
+    return sorted(list(df.loc[(df["dut"] == dut)]["ttype"].unique()))
+
+
+def get_cadences(df: pd.DataFrame, dut: str, ttype: str) -> list:
+    """Get the list of cadences from the pre-processed information about
+    jobs.
+
+    :param df: DataFrame with information about jobs.
+    :param dut: The DUT for which the list of cadences will be populated.
+    :param ttype: The test type for which the list of cadences will be
+        populated.
+    :type df: pandas.DataFrame
+    :type dut: str
+    :type ttype: str
+    :returns: Alphabeticaly sorted list of cadences.
+    :rtype: list
+    """
+    return sorted(list(df.loc[(
+        (df["dut"] == dut) &
+        (df["ttype"] == ttype)
+    )]["cadence"].unique()))
+
+
+def get_test_beds(df: pd.DataFrame, dut: str, ttype: str, cadence: str) -> list:
+    """Get the list of test beds from the pre-processed information about
+    jobs.
+
+    :param df: DataFrame with information about jobs.
+    :param dut: The DUT for which the list of test beds will be populated.
+    :param ttype: The test type for which the list of test beds will be
+        populated.
+    :param cadence: The cadence for which the list of test beds will be
+        populated.
+    :type df: pandas.DataFrame
+    :type dut: str
+    :type ttype: str
+    :type cadence: str
+    :returns: Alphabeticaly sorted list of test beds.
+    :rtype: list
+    """
+    return sorted(list(df.loc[(
+        (df["dut"] == dut) &
+        (df["ttype"] == ttype) &
+        (df["cadence"] == cadence)
+    )]["tbed"].unique()))
+
+
+def get_job(df: pd.DataFrame, dut, ttype, cadence, testbed):
+    """Get the name of a job defined by dut, ttype, cadence, test bed.
+    Input information comes from the control panel.
+
+    :param df: DataFrame with information about jobs.
+    :param dut: The DUT for which the job name will be created.
+    :param ttype: The test type for which the job name will be created.
+    :param cadence: The cadence for which the job name will be created.
+    :param testbed: The test bed for which the job name will be created.
+    :type df: pandas.DataFrame
+    :type dut: str
+    :type ttype: str
+    :type cadence: str
+    :type testbed: str
+    :returns: Job name.
+    :rtype: str
+    """
+    return df.loc[(
+        (df["dut"] == dut) &
+        (df["ttype"] == ttype) &
+        (df["cadence"] == cadence) &
+        (df["tbed"] == testbed)
+    )]["job"].item()
+
+
+def generate_options(opts: list) -> list:
+    """Return list of options for radio items in control panel. The items in
+    the list are dictionaries with keys "label" and "value".
+
+    :params opts: List of options (str) to be used for the generated list.
+    :type opts: list
+    :returns: List of options (dict).
+    :rtype: list
+    """
+    return [{"label": i, "value": i} for i in opts]
+
+
+def set_job_params(df: pd.DataFrame, job: str) -> dict:
+    """Create a dictionary with all options and values for (and from) the
+    given job.
+
+    :param df: DataFrame with information about jobs.
+    :params job: The name of job for and from which the dictionary will be
+        created.
+    :type df: pandas.DataFrame
+    :type job: str
+    :returns: Dictionary with all options and values for (and from) the
+        given job.
+    :rtype: dict
+    """
+
+    l_job = job.split("-")
+    return {
+        "job": job,
+        "dut": l_job[1],
+        "ttype": l_job[3],
+        "cadence": l_job[4],
+        "tbed": "-".join(l_job[-2:]),
+        "duts": generate_options(get_duts(df)),
+        "ttypes": generate_options(get_ttypes(df, l_job[1])),
+        "cadences": generate_options(get_cadences(df, l_job[1], l_job[3])),
+        "tbeds": generate_options(
+            get_test_beds(df, l_job[1], l_job[3], l_job[4]))
+    }