Add comprehensive site-level KPI analysis with heatmaps, distribution histograms, traffic-based filtering, and preset management functionality

documentations/kpi_health_check_plan.md

@@ -205,16 +205,16 @@ Objectif: **app modulaire**, pas un fichier monolithique.
 - [DONE] RESOLVED (dégradé puis OK)
 - [DONE] Support ZIP multi-CSV
 - [N/A] Support “cell-level” vs “site-level” (switch) (KPI confirmés par site)
-- [TODO] Score de criticité (pondérer par trafic, population, criticité client)
+- [DONE] Score de criticité (pondération trafic OK avec conversion 2G MB -> GB; pas de données population/criticité client)
 - [DONE] Table “Top anomalies” multi-RAT (cross-RAT)
-- [TODO] Visualisations avancées (heatmap par jour, histogrammes, etc.)
+- [DONE] Visualisations avancées (heatmap par jour, histogrammes, etc.)
 
 ### V3 (industrialisation)
 
-- [TODO] Presets de règles par opérateur
+- [DONE] Presets de règles (JSON local) + sauvegarde/chargement dans l'UI
 - [TODO] Gestion profils / sauvegarde de configuration
-- [TODO] Import automatique de “liste des sites plaintes"
-- [TODO] Génération PDF (optionnel) et pack de preuves
+- [TODO] Import automatique de “liste des sites plaintes”
+- [N/A] Génération PDF (optionnel) et pack de preuves
 
 ## 8) Points ouverts à confirmer
 

panel_app/kpi_health_check_panel.py

@@ -1,17 +1,23 @@
 import io
 import os
 import sys
-from datetime import date
+from datetime import date, timedelta
 
+import numpy as np
 import pandas as pd
 import panel as pn
 import plotly.express as px
+import plotly.graph_objects as go
 
 ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 if ROOT_DIR not in sys.path:
     sys.path.insert(0, ROOT_DIR)
 
-from process_kpi.kpi_health_check.engine import evaluate_health_check
+from process_kpi.kpi_health_check.engine import (
+    evaluate_health_check,
+    is_bad,
+    window_bounds,
+)
 from process_kpi.kpi_health_check.export import build_export_bytes
 from process_kpi.kpi_health_check.io import read_bytes_to_df
 from process_kpi.kpi_health_check.multi_rat import compute_multirat_views
@@ -20,6 +26,12 @@ from process_kpi.kpi_health_check.normalization import (
     infer_date_col,
     infer_id_col,
 )
+from process_kpi.kpi_health_check.presets import (
+    delete_preset,
+    list_presets,
+    load_preset,
+    save_preset,
+)
 from process_kpi.kpi_health_check.rules import infer_kpi_direction, infer_kpi_sla
 
 pn.extension("plotly", "tabulator")
@@ -39,7 +51,9 @@ current_rules_df: pd.DataFrame | None = None
 current_status_df: pd.DataFrame | None = None
 current_summary_df: pd.DataFrame | None = None
 current_multirat_df: pd.DataFrame | None = None
+current_multirat_raw: pd.DataFrame | None = None
 current_top_anomalies_df: pd.DataFrame | None = None
+current_top_anomalies_raw: pd.DataFrame | None = None
 current_export_bytes: bytes | None = None
 
 file_2g = pn.widgets.FileInput(name="2G KPI report", accept=".csv,.zip")
@@ -56,6 +70,25 @@ min_consecutive_days = pn.widgets.IntInput(
     name="Min consecutive bad days (persistent)", value=3
 )
 
+min_criticality = pn.widgets.IntInput(name="Min criticality score", value=0)
+min_anomaly_score = pn.widgets.IntInput(name="Min anomaly score", value=0)
+city_filter = pn.widgets.TextInput(name="City contains (optional)", value="")
+top_rat_filter = pn.widgets.CheckBoxGroup(
+    name="Top anomalies RAT", options=["2G", "3G", "LTE"], value=["2G", "3G", "LTE"]
+)
+top_status_filter = pn.widgets.CheckBoxGroup(
+    name="Top anomalies status",
+    options=["DEGRADED", "PERSISTENT_DEGRADED"],
+    value=["DEGRADED", "PERSISTENT_DEGRADED"],
+)
+
+preset_select = pn.widgets.Select(name="Rules preset", options=[], value=None)
+preset_name_input = pn.widgets.TextInput(name="Save preset as", value="")
+preset_refresh_button = pn.widgets.Button(name="Refresh presets", button_type="default")
+preset_apply_button = pn.widgets.Button(name="Apply preset", button_type="primary")
+preset_save_button = pn.widgets.Button(name="Save current rules", button_type="primary")
+preset_delete_button = pn.widgets.Button(name="Delete preset", button_type="danger")
+
 load_button = pn.widgets.Button(
     name="Load datasets & build rules", button_type="primary"
 )
@@ -111,6 +144,8 @@ site_kpi_table = pn.widgets.Tabulator(
     height=260, sizing_mode="stretch_width", layout="fit_data_table"
 )
 trend_plot_pane = pn.pane.Plotly(sizing_mode="stretch_both", config=PLOTLY_CONFIG)
+heatmap_plot_pane = pn.pane.Plotly(sizing_mode="stretch_both", config=PLOTLY_CONFIG)
+hist_plot_pane = pn.pane.Plotly(sizing_mode="stretch_both", config=PLOTLY_CONFIG)
 
 export_button = pn.widgets.FileDownload(
     label="Download KPI Health Check report",
@@ -190,6 +225,8 @@ def _update_site_view(event=None) -> None:
     if current_status_df is None or current_status_df.empty:
         site_kpi_table.value = pd.DataFrame()
         trend_plot_pane.object = None
+        heatmap_plot_pane.object = None
+        hist_plot_pane.object = None
         return
 
     code = site_select.value
@@ -199,6 +236,8 @@ def _update_site_view(event=None) -> None:
     if code is None or rat is None:
         site_kpi_table.value = pd.DataFrame()
         trend_plot_pane.object = None
+        heatmap_plot_pane.object = None
+        hist_plot_pane.object = None
         return
 
     site_df = current_status_df[
@@ -210,12 +249,16 @@ def _update_site_view(event=None) -> None:
     daily = current_daily_by_rat.get(rat)
     if daily is None or daily.empty or not kpi or kpi not in daily.columns:
         trend_plot_pane.object = None
+        heatmap_plot_pane.object = None
+        hist_plot_pane.object = None
         return
 
     d = _filtered_daily(daily)
     s = d[d["site_code"] == int(code)].copy().sort_values("date_only")
     if s.empty:
         trend_plot_pane.object = None
+        heatmap_plot_pane.object = None
+        hist_plot_pane.object = None
         return
 
     title = f"{rat} - {kpi} - site {int(code)}"
@@ -223,6 +266,440 @@ def _update_site_view(event=None) -> None:
     fig.update_layout(template="plotly_white", title=title)
     trend_plot_pane.object = fig
 
+    rules_df = (
+        rules_table.value
+        if isinstance(rules_table.value, pd.DataFrame)
+        else pd.DataFrame()
+    )
+    kpis_for_heatmap = []
+    if (
+        isinstance(site_df, pd.DataFrame)
+        and not site_df.empty
+        and "KPI" in site_df.columns
+    ):
+        sev = {
+            "PERSISTENT_DEGRADED": 3,
+            "DEGRADED": 2,
+            "RESOLVED": 1,
+            "OK": 0,
+            "NO_DATA": -1,
+        }
+        tmp = site_df.copy()
+        if "status" in tmp.columns:
+            tmp["_sev"] = tmp["status"].map(sev).fillna(0).astype(int)
+            tmp = tmp.sort_values(by=["_sev", "KPI"], ascending=[False, True])
+        kpis_for_heatmap = tmp["KPI"].astype(str).tolist()[:30]
+
+    heatmap_plot_pane.object = _build_site_heatmap(
+        d, rules_df, int(code), rat, kpis_for_heatmap
+    )
+    hist_plot_pane.object = _build_baseline_recent_hist(d, int(code), str(kpi))
+
+
+def _apply_city_filter(df: pd.DataFrame) -> pd.DataFrame:
+    if df is None or df.empty:
+        return pd.DataFrame()
+    q = (city_filter.value or "").strip()
+    if not q or "City" not in df.columns:
+        return df
+    return df[df["City"].astype(str).str.contains(q, case=False, na=False)].copy()
+
+
+def _infer_rule_row(rules_df: pd.DataFrame, rat: str, kpi: str) -> dict:
+    if rules_df is None or rules_df.empty:
+        return {}
+    s = rules_df[(rules_df["RAT"] == rat) & (rules_df["KPI"] == kpi)]
+    if s.empty:
+        return {}
+    return dict(s.iloc[0].to_dict())
+
+
+def _compute_site_windows(
+    daily_filtered: pd.DataFrame,
+) -> tuple[date, date, date, date] | None:
+    if daily_filtered is None or daily_filtered.empty:
+        return None
+    end_date = max(daily_filtered["date_only"])
+    recent_start, recent_end = window_bounds(end_date, int(recent_days.value))
+    baseline_end = recent_start - timedelta(days=1)
+    baseline_start = baseline_end - timedelta(days=int(baseline_days.value) - 1)
+    return baseline_start, baseline_end, recent_start, recent_end
+
+
+def _build_site_heatmap(
+    daily_filtered: pd.DataFrame,
+    rules_df: pd.DataFrame,
+    site_code: int,
+    rat: str,
+    kpis: list[str],
+) -> go.Figure | None:
+    if daily_filtered is None or daily_filtered.empty:
+        return None
+    windows = _compute_site_windows(daily_filtered)
+    if windows is None:
+        return None
+    baseline_start, baseline_end, recent_start, recent_end = windows
+
+    site_daily = daily_filtered[daily_filtered["site_code"] == int(site_code)].copy()
+    if site_daily.empty:
+        return None
+    site_daily = site_daily.sort_values("date_only")
+
+    dates = []
+    cur = recent_start
+    while cur <= recent_end:
+        dates.append(cur)
+        cur = cur + timedelta(days=1)
+
+    z = []
+    hover = []
+    y_labels = []
+    for kpi in kpis:
+        if kpi not in site_daily.columns:
+            continue
+        rule = _infer_rule_row(rules_df, rat, kpi)
+        direction = str(rule.get("direction", "higher_is_better"))
+        sla_raw = rule.get("sla", None)
+        try:
+            sla_val = float(sla_raw) if pd.notna(sla_raw) else None
+        except Exception:  # noqa: BLE001
+            sla_val = None
+
+        s = site_daily[["date_only", kpi]].dropna(subset=[kpi])
+        baseline_mask = (s["date_only"] >= baseline_start) & (
+            s["date_only"] <= baseline_end
+        )
+        baseline = s.loc[baseline_mask, kpi].median() if baseline_mask.any() else np.nan
+        baseline_val = float(baseline) if pd.notna(baseline) else None
+
+        row_z = []
+        row_h = []
+        for d in dates:
+            v_series = site_daily.loc[site_daily["date_only"] == d, kpi]
+            v = v_series.iloc[0] if not v_series.empty else np.nan
+            if v is None or (isinstance(v, float) and np.isnan(v)):
+                row_z.append(None)
+                row_h.append(f"{kpi}<br>{d}: NO_DATA")
+                continue
+            bad = is_bad(
+                float(v) if pd.notna(v) else None,
+                baseline_val,
+                direction,
+                float(rel_threshold_pct.value),
+                sla_val,
+            )
+            row_z.append(1 if bad else 0)
+            row_h.append(
+                f"{kpi}<br>{d}: {float(v):.3f}<br>baseline: {baseline_val if baseline_val is not None else 'NA'}<br>sla: {sla_val if sla_val is not None else 'NA'}"
+            )
+
+        z.append(row_z)
+        hover.append(row_h)
+        y_labels.append(kpi)
+
+    if not z:
+        return None
+
+    fig = go.Figure(
+        data=[
+            go.Heatmap(
+                z=z,
+                x=[str(d) for d in dates],
+                y=y_labels,
+                colorscale=[[0.0, "#2ca02c"], [1.0, "#d62728"]],
+                zmin=0,
+                zmax=1,
+                showscale=False,
+                hovertext=hover,
+                hovertemplate="%{hovertext}<extra></extra>",
+            )
+        ]
+    )
+    fig.update_layout(
+        template="plotly_white",
+        title=f"{rat} - Site {int(site_code)} - Recent window heatmap",
+        xaxis_title="date",
+        yaxis_title="KPI",
+        height=420,
+        margin=dict(l=40, r=20, t=60, b=40),
+    )
+    return fig
+
+
+def _build_baseline_recent_hist(
+    daily_filtered: pd.DataFrame,
+    site_code: int,
+    kpi: str,
+) -> go.Figure | None:
+    if (
+        daily_filtered is None
+        or daily_filtered.empty
+        or not kpi
+        or kpi not in daily_filtered.columns
+    ):
+        return None
+
+    windows = _compute_site_windows(daily_filtered)
+    if windows is None:
+        return None
+    baseline_start, baseline_end, recent_start, recent_end = windows
+
+    site_daily = daily_filtered[daily_filtered["site_code"] == int(site_code)].copy()
+    if site_daily.empty:
+        return None
+
+    s = site_daily[["date_only", kpi]].dropna(subset=[kpi])
+    baseline_mask = (s["date_only"] >= baseline_start) & (
+        s["date_only"] <= baseline_end
+    )
+    recent_mask = (s["date_only"] >= recent_start) & (s["date_only"] <= recent_end)
+
+    baseline_vals = (
+        pd.to_numeric(s.loc[baseline_mask, kpi], errors="coerce").dropna().astype(float)
+    )
+    recent_vals = (
+        pd.to_numeric(s.loc[recent_mask, kpi], errors="coerce").dropna().astype(float)
+    )
+    if baseline_vals.empty and recent_vals.empty:
+        return None
+
+    dfh = pd.concat(
+        [
+            pd.DataFrame({"window": "baseline", "value": baseline_vals}),
+            pd.DataFrame({"window": "recent", "value": recent_vals}),
+        ],
+        ignore_index=True,
+    )
+    fig = px.histogram(
+        dfh,
+        x="value",
+        color="window",
+        barmode="overlay",
+        opacity=0.6,
+    )
+    fig.update_layout(
+        template="plotly_white",
+        title=f"{kpi} distribution (baseline vs recent)",
+        xaxis_title=kpi,
+        yaxis_title="count",
+        height=420,
+        margin=dict(l=40, r=20, t=60, b=40),
+    )
+    return fig
+
+
+def _compute_site_traffic_gb(daily_by_rat: dict[str, pd.DataFrame]) -> pd.DataFrame:
+    MB_PER_GB = 1024.0
+    rows = []
+
+    for rat, daily in daily_by_rat.items():
+        if daily is None or daily.empty:
+            continue
+        d = _filtered_daily(daily)
+        if d.empty or "site_code" not in d.columns:
+            continue
+
+        cols: list[str] = []
+        if rat == "2G":
+            for c in d.columns:
+                key = str(c).lower().replace(" ", "_")
+                if "traffic_ps" in key:
+                    cols.append(c)
+        elif rat == "3G":
+            if "Total_Data_Traffic" in d.columns:
+                cols.append("Total_Data_Traffic")
+        elif rat == "LTE":
+            for c in d.columns:
+                key = str(c).lower().replace(" ", "_")
+                if "traffic_volume" in key and "gbytes" in key:
+                    cols.append(c)
+
+        cols = [c for c in cols if c in d.columns]
+        if not cols:
+            continue
+
+        traffic = pd.to_numeric(
+            d[cols].sum(axis=1, skipna=True), errors="coerce"
+        ).fillna(0)
+        if rat == "2G":
+            traffic = traffic / MB_PER_GB
+
+        tmp = pd.DataFrame(
+            {
+                "site_code": d["site_code"].astype(int),
+                "RAT": rat,
+                "traffic_gb": traffic.astype(float),
+            }
+        )
+        tmp = tmp.groupby(["site_code", "RAT"], as_index=False)["traffic_gb"].sum()
+        rows.append(tmp)
+
+    if not rows:
+        return pd.DataFrame(columns=["site_code", "traffic_gb_total"])
+
+    all_rows = pd.concat(rows, ignore_index=True)
+    pivot = (
+        all_rows.pivot_table(
+            index="site_code",
+            columns="RAT",
+            values="traffic_gb",
+            aggfunc="sum",
+            fill_value=0,
+        )
+        .reset_index()
+        .copy()
+    )
+
+    traffic_cols = []
+    for rat in ["2G", "3G", "LTE"]:
+        if rat in pivot.columns:
+            pivot = pivot.rename(columns={rat: f"traffic_gb_{rat}"})
+            traffic_cols.append(f"traffic_gb_{rat}")
+
+    if traffic_cols:
+        pivot["traffic_gb_total"] = (
+            pd.to_numeric(pivot[traffic_cols].sum(axis=1), errors="coerce")
+            .fillna(0)
+            .astype(float)
+        )
+    else:
+        pivot["traffic_gb_total"] = 0.0
+
+    return pivot
+
+
+def _refresh_filtered_results(event=None) -> None:
+    global current_multirat_df, current_top_anomalies_df, current_export_bytes
+
+    if current_multirat_raw is not None and not current_multirat_raw.empty:
+        m = _apply_city_filter(current_multirat_raw)
+        score_col = (
+            "criticality_score_weighted"
+            if "criticality_score_weighted" in m.columns
+            else "criticality_score"
+        )
+        if score_col in m.columns:
+            m = m[
+                pd.to_numeric(m[score_col], errors="coerce").fillna(0)
+                >= int(min_criticality.value)
+            ]
+            m = m.sort_values(by=[score_col], ascending=False)
+        current_multirat_df = m
+        multirat_summary_table.value = current_multirat_df
+    else:
+        current_multirat_df = pd.DataFrame()
+        multirat_summary_table.value = current_multirat_df
+
+    if current_top_anomalies_raw is not None and not current_top_anomalies_raw.empty:
+        t = _apply_city_filter(current_top_anomalies_raw)
+        if top_rat_filter.value:
+            t = t[t["RAT"].isin(list(top_rat_filter.value))]
+        if top_status_filter.value and "status" in t.columns:
+            t = t[t["status"].isin(list(top_status_filter.value))]
+        score_col = (
+            "anomaly_score_weighted"
+            if "anomaly_score_weighted" in t.columns
+            else "anomaly_score"
+        )
+        if score_col in t.columns:
+            t = t[
+                pd.to_numeric(t[score_col], errors="coerce").fillna(0)
+                >= int(min_anomaly_score.value)
+            ]
+            t = t.sort_values(by=[score_col], ascending=False)
+        current_top_anomalies_df = t
+        top_anomalies_table.value = current_top_anomalies_df
+    else:
+        current_top_anomalies_df = pd.DataFrame()
+        top_anomalies_table.value = current_top_anomalies_df
+
+    current_export_bytes = None
+
+
+def _refresh_presets(event=None) -> None:
+    names = list_presets()
+    preset_select.options = [""] + names
+    if preset_select.value not in preset_select.options:
+        preset_select.value = ""
+
+
+def _apply_preset(event=None) -> None:
+    global current_export_bytes
+    try:
+        if not preset_select.value:
+            return
+        preset_df = load_preset(str(preset_select.value))
+        if preset_df is None or preset_df.empty:
+            return
+    except Exception as exc:  # noqa: BLE001
+        status_pane.alert_type = "danger"
+        status_pane.object = f"Error loading preset: {exc}"
+        return
+
+    cur = (
+        rules_table.value
+        if isinstance(rules_table.value, pd.DataFrame)
+        else pd.DataFrame()
+    )
+    if cur is None or cur.empty:
+        rules_table.value = preset_df
+        return
+
+    key = ["RAT", "KPI"]
+    upd_cols = [c for c in ["direction", "sla"] if c in preset_df.columns]
+    preset_df2 = preset_df[key + upd_cols].copy()
+
+    merged = pd.merge(cur, preset_df2, on=key, how="left", suffixes=("", "_preset"))
+    for c in upd_cols:
+        pc = f"{c}_preset"
+        if pc in merged.columns:
+            merged[c] = merged[pc].where(merged[pc].notna(), merged[c])
+            merged = merged.drop(columns=[pc])
+
+    rules_table.value = merged
+    status_pane.alert_type = "success"
+    status_pane.object = f"Preset applied: {preset_select.value}"
+    current_export_bytes = None
+
+
+def _save_current_rules_as_preset(event=None) -> None:
+    try:
+        name = (preset_name_input.value or "").strip()
+        if not name:
+            name = str(preset_select.value or "").strip()
+        if not name:
+            raise ValueError("Please provide a preset name")
+        cur = (
+            rules_table.value
+            if isinstance(rules_table.value, pd.DataFrame)
+            else pd.DataFrame()
+        )
+        save_preset(name, cur)
+        preset_name_input.value = ""
+        _refresh_presets()
+        preset_select.value = name
+        status_pane.alert_type = "success"
+        status_pane.object = f"Preset saved: {name}"
+    except Exception as exc:  # noqa: BLE001
+        status_pane.alert_type = "danger"
+        status_pane.object = f"Error saving preset: {exc}"
+
+
+def _delete_selected_preset(event=None) -> None:
+    global current_export_bytes
+    try:
+        name = str(preset_select.value or "").strip()
+        if not name:
+            return
+        delete_preset(name)
+        _refresh_presets()
+        status_pane.alert_type = "success"
+        status_pane.object = f"Preset deleted: {name}"
+        current_export_bytes = None
+    except Exception as exc:  # noqa: BLE001
+        status_pane.alert_type = "danger"
+        status_pane.object = f"Error deleting preset: {exc}"
+
 
 def load_datasets(event=None) -> None:
     try:
@@ -231,14 +708,16 @@ def load_datasets(event=None) -> None:
 
         global current_daily_by_rat, current_rules_df
         global current_status_df, current_summary_df, current_export_bytes
-        global current_multirat_df, current_top_anomalies_df
+        global current_multirat_df, current_multirat_raw, current_top_anomalies_df, current_top_anomalies_raw
 
         current_daily_by_rat = {}
         current_rules_df = None
         current_status_df = None
         current_summary_df = None
         current_multirat_df = None
+        current_multirat_raw = None
         current_top_anomalies_df = None
+        current_top_anomalies_raw = None
         current_export_bytes = None
 
         site_summary_table.value = pd.DataFrame()
@@ -246,6 +725,8 @@ def load_datasets(event=None) -> None:
         top_anomalies_table.value = pd.DataFrame()
         site_kpi_table.value = pd.DataFrame()
         trend_plot_pane.object = None
+        heatmap_plot_pane.object = None
+        hist_plot_pane.object = None
 
         inputs = {"2G": file_2g, "3G": file_3g, "LTE": file_lte}
         rows = []
@@ -329,7 +810,8 @@ def run_health_check(event=None) -> None:
         status_pane.object = "Running health check..."
 
         global current_status_df, current_summary_df, current_export_bytes
-        global current_multirat_df, current_top_anomalies_df
+        global current_multirat_df, current_multirat_raw
+        global current_top_anomalies_df, current_top_anomalies_raw
 
         rules_df = (
             rules_table.value
@@ -366,11 +848,64 @@ def run_health_check(event=None) -> None:
         )
         site_summary_table.value = current_summary_df
 
-        current_multirat_df, current_top_anomalies_df = compute_multirat_views(
+        current_multirat_raw, current_top_anomalies_raw = compute_multirat_views(
             current_status_df
         )
-        multirat_summary_table.value = current_multirat_df
-        top_anomalies_table.value = current_top_anomalies_df
+
+        traffic_df = _compute_site_traffic_gb(current_daily_by_rat)
+        if traffic_df is not None and not traffic_df.empty:
+            if current_multirat_raw is not None and not current_multirat_raw.empty:
+                current_multirat_raw = pd.merge(
+                    current_multirat_raw, traffic_df, on="site_code", how="left"
+                )
+                w = 1.0 + np.log1p(
+                    pd.to_numeric(
+                        current_multirat_raw["traffic_gb_total"], errors="coerce"
+                    )
+                    .fillna(0)
+                    .astype(float)
+                )
+                current_multirat_raw["criticality_score_weighted"] = (
+                    (
+                        pd.to_numeric(
+                            current_multirat_raw["criticality_score"], errors="coerce"
+                        )
+                        .fillna(0)
+                        .astype(float)
+                        * w
+                    )
+                    .round(0)
+                    .astype(int)
+                )
+
+            if (
+                current_top_anomalies_raw is not None
+                and not current_top_anomalies_raw.empty
+            ):
+                current_top_anomalies_raw = pd.merge(
+                    current_top_anomalies_raw, traffic_df, on="site_code", how="left"
+                )
+                w = 1.0 + np.log1p(
+                    pd.to_numeric(
+                        current_top_anomalies_raw["traffic_gb_total"], errors="coerce"
+                    )
+                    .fillna(0)
+                    .astype(float)
+                )
+                current_top_anomalies_raw["anomaly_score_weighted"] = (
+                    (
+                        pd.to_numeric(
+                            current_top_anomalies_raw["anomaly_score"], errors="coerce"
+                        )
+                        .fillna(0)
+                        .astype(float)
+                        * w
+                    )
+                    .round(0)
+                    .astype(int)
+                )
+
+        _refresh_filtered_results()
 
         current_export_bytes = _build_export_bytes()
 
@@ -408,19 +943,35 @@ def _build_export_bytes() -> bytes:
 
 
 def _export_callback() -> io.BytesIO:
-    data = current_export_bytes or b""
-    if not data:
-        return io.BytesIO()
-    return io.BytesIO(data)
+    global current_export_bytes
+    if current_export_bytes is None:
+        try:
+            current_export_bytes = _build_export_bytes()
+        except Exception:  # noqa: BLE001
+            current_export_bytes = b""
+    return io.BytesIO(current_export_bytes or b"")
 
 
 load_button.on_click(load_datasets)
 run_button.on_click(run_health_check)
 
+preset_refresh_button.on_click(_refresh_presets)
+preset_apply_button.on_click(_apply_preset)
+preset_save_button.on_click(_save_current_rules_as_preset)
+preset_delete_button.on_click(_delete_selected_preset)
+
+_refresh_presets()
+
 rat_select.param.watch(lambda e: (_update_kpi_options(), _update_site_view()), "value")
 site_select.param.watch(_update_site_view, "value")
 kpi_select.param.watch(_update_site_view, "value")
 
+min_criticality.param.watch(_refresh_filtered_results, "value")
+min_anomaly_score.param.watch(_refresh_filtered_results, "value")
+city_filter.param.watch(_refresh_filtered_results, "value")
+top_rat_filter.param.watch(_refresh_filtered_results, "value")
+top_status_filter.param.watch(_refresh_filtered_results, "value")
+
 export_button.callback = _export_callback
 
 
@@ -436,6 +987,19 @@ sidebar = pn.Column(
     rel_threshold_pct,
     min_consecutive_days,
     "---",
+    pn.pane.Markdown("### Filters"),
+    min_criticality,
+    min_anomaly_score,
+    city_filter,
+    top_rat_filter,
+    top_status_filter,
+    "---",
+    pn.pane.Markdown("### Rule presets"),
+    preset_select,
+    pn.Row(preset_refresh_button, preset_apply_button),
+    preset_name_input,
+    pn.Row(preset_save_button, preset_delete_button),
+    "---",
     load_button,
     run_button,
     "---",
@@ -461,6 +1025,10 @@ main = pn.Column(
         pn.Column(site_kpi_table, sizing_mode="stretch_width"),
         pn.Column(trend_plot_pane, sizing_mode="stretch_both"),
     ),
+    pn.Row(
+        pn.Column(heatmap_plot_pane, sizing_mode="stretch_both"),
+        pn.Column(hist_plot_pane, sizing_mode="stretch_both"),
+    ),
 )
 
 

process_kpi/kpi_health_check/multi_rat.py

@@ -87,9 +87,31 @@ def compute_multirat_views(
 
     metric_cols = [c for c in out.columns if c != "City"]
     out[metric_cols] = out[metric_cols].fillna(0)
+
+    resolved_total = (
+        out["resolved_kpis_total"].astype(float)
+        if "resolved_kpis_total" in out.columns
+        else 0.0
+    )
+    out["criticality_score"] = (
+        (
+            out["persistent_kpis_total"].astype(float) * 5.0
+            + out["degraded_kpis_total"].astype(float) * 2.0
+            + out["impacted_rats"].astype(float) * 1.0
+            + resolved_total * 0.5
+        )
+        .round(0)
+        .astype(int)
+    )
+
     out = out.sort_values(
-        by=["persistent_kpis_total", "degraded_kpis_total", "impacted_rats"],
-        ascending=[False, False, False],
+        by=[
+            "criticality_score",
+            "persistent_kpis_total",
+            "degraded_kpis_total",
+            "impacted_rats",
+        ],
+        ascending=[False, False, False, False],
     )
 
     top = df[df["is_degraded"]].copy()
@@ -100,14 +122,30 @@ def compute_multirat_views(
         if col not in top.columns:
             top[col] = pd.NA
 
+    top["anomaly_score"] = (
+        (
+            top["severity"].astype(float) * 100.0
+            + pd.to_numeric(top["max_streak_recent"], errors="coerce")
+            .fillna(0)
+            .astype(float)
+            * 10.0
+            + pd.to_numeric(top["bad_days_recent"], errors="coerce")
+            .fillna(0)
+            .astype(float)
+        )
+        .round(0)
+        .astype(int)
+    )
+
     top = top.sort_values(
-        by=["severity", "max_streak_recent", "bad_days_recent"],
-        ascending=[False, False, False],
+        by=["anomaly_score", "severity", "max_streak_recent", "bad_days_recent"],
+        ascending=[False, False, False, False],
     )
 
     top_cols = [
         c
         for c in [
+            "anomaly_score",
             "severity",
             "RAT",
             "site_code",

process_kpi/kpi_health_check/presets.py

@@ -0,0 +1,79 @@
+import json
+import os
+from datetime import datetime
+
+import pandas as pd
+
+
+def presets_dir() -> str:
+    root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    return os.path.join(root, "data", "kpi_health_check_presets")
+
+
+def _safe_name(name: str) -> str:
+    s = (name or "").strip()
+    s = s.replace("..", "")
+    s = s.replace("/", "_").replace("\\", "_")
+    s = "_".join([p for p in s.split() if p])
+    return s
+
+
+def list_presets() -> list[str]:
+    d = presets_dir()
+    if not os.path.isdir(d):
+        return []
+    out = []
+    for fn in os.listdir(d):
+        if fn.lower().endswith(".json"):
+            out.append(os.path.splitext(fn)[0])
+    return sorted(set(out))
+
+
+def load_preset(name: str) -> pd.DataFrame:
+    d = presets_dir()
+    safe = _safe_name(name)
+    path = os.path.join(d, f"{safe}.json")
+    with open(path, "r", encoding="utf-8") as f:
+        obj = json.load(f)
+    rows = obj.get("rules", []) if isinstance(obj, dict) else []
+    df = pd.DataFrame(rows)
+    if not df.empty:
+        df["RAT"] = df["RAT"].astype(str)
+        df["KPI"] = df["KPI"].astype(str)
+    return df
+
+
+def save_preset(name: str, rules_df: pd.DataFrame) -> str:
+    safe = _safe_name(name)
+    if not safe:
+        raise ValueError("Preset name is empty")
+
+    d = presets_dir()
+    os.makedirs(d, exist_ok=True)
+    path = os.path.join(d, f"{safe}.json")
+
+    df = rules_df.copy() if isinstance(rules_df, pd.DataFrame) else pd.DataFrame()
+    if df.empty:
+        raise ValueError("Rules dataframe is empty")
+
+    keep = [c for c in ["RAT", "KPI", "direction", "sla"] if c in df.columns]
+    df = df[keep].copy()
+
+    obj = {
+        "name": safe,
+        "saved_at": datetime.utcnow().isoformat() + "Z",
+        "rules": df.to_dict(orient="records"),
+    }
+
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(obj, f, ensure_ascii=False, indent=2)
+
+    return path
+
+
+def delete_preset(name: str) -> None:
+    d = presets_dir()
+    safe = _safe_name(name)
+    path = os.path.join(d, f"{safe}.json")
+    if os.path.isfile(path):
+        os.remove(path)