Add comprehensive profile management system for KPI health check panel with full state persistence including analysis parameters, filters, presets, and drill-down selections

panel_app/kpi_health_check_panel.py

@@ -32,6 +32,12 @@ from process_kpi.kpi_health_check.presets import (
     load_preset,
     save_preset,
 )
+from process_kpi.kpi_health_check.profiles import (
+    delete_profile,
+    list_profiles,
+    load_profile,
+    save_profile,
+)
 from process_kpi.kpi_health_check.rules import infer_kpi_direction, infer_kpi_sla
 
 pn.extension("plotly", "tabulator")
@@ -56,6 +62,45 @@ current_top_anomalies_df: pd.DataFrame | None = None
 current_top_anomalies_raw: pd.DataFrame | None = None
 current_export_bytes: bytes | None = None
 
+_applying_profile: bool = False
+_loading_datasets: bool = False
+_updating_drilldown: bool = False
+
+_drilldown_update_pending: bool = False
+
+
+def _set_widget_value(widget, value) -> None:
+    global _updating_drilldown
+    try:
+        if getattr(widget, "value", None) == value:
+            return
+    except Exception:  # noqa: BLE001
+        pass
+    _updating_drilldown = True
+    try:
+        widget.value = value
+    finally:
+        _updating_drilldown = False
+
+
+def _schedule_drilldown_update(fn) -> None:
+    global _drilldown_update_pending
+    if _drilldown_update_pending:
+        return
+    _drilldown_update_pending = True
+
+    def _wrapped() -> None:
+        global _drilldown_update_pending
+        _drilldown_update_pending = False
+        fn()
+
+    doc = pn.state.curdoc
+    if doc is not None:
+        doc.add_next_tick_callback(_wrapped)
+    else:
+        _wrapped()
+
+
 file_2g = pn.widgets.FileInput(name="2G KPI report", accept=".csv,.zip")
 file_3g = pn.widgets.FileInput(name="3G KPI report", accept=".csv,.zip")
 file_lte = pn.widgets.FileInput(name="LTE KPI report", accept=".csv,.zip")
@@ -89,6 +134,15 @@ preset_apply_button = pn.widgets.Button(name="Apply preset", button_type="primar
 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")
 
+profile_select = pn.widgets.Select(name="Profile", options=[], value=None)
+profile_name_input = pn.widgets.TextInput(name="Save profile as", value="")
+profile_refresh_button = pn.widgets.Button(
+    name="Refresh profiles", button_type="default"
+)
+profile_apply_button = pn.widgets.Button(name="Apply profile", button_type="primary")
+profile_save_button = pn.widgets.Button(name="Save profile", button_type="primary")
+profile_delete_button = pn.widgets.Button(name="Delete profile", button_type="danger")
+
 load_button = pn.widgets.Button(
     name="Load datasets & build rules", button_type="primary"
 )
@@ -170,6 +224,7 @@ def _filtered_daily(df: pd.DataFrame) -> pd.DataFrame:
 
 
 def _update_site_options() -> None:
+    global _updating_drilldown
     all_sites = []
     for df in current_daily_by_rat.values():
         if df is None or df.empty:
@@ -197,12 +252,20 @@ def _update_site_options() -> None:
         )
         opts[str(label)] = int(row["site_code"])
 
-    site_select.options = opts
-    if opts and site_select.value not in opts.values():
-        site_select.value = next(iter(opts.values()))
+    _updating_drilldown = True
+    try:
+        site_select.options = opts
+        if opts and site_select.value not in opts.values():
+            site_select.value = next(iter(opts.values()))
+    finally:
+        _updating_drilldown = False
 
 
 def _update_kpi_options() -> None:
+    if _applying_profile or _loading_datasets:
+        return
+
+    global _updating_drilldown
     rat = rat_select.value
     df = current_daily_by_rat.get(rat)
     if df is None or df.empty:
@@ -216,12 +279,18 @@ def _update_kpi_options() -> None:
         if c not in {"site_code", "date_only", "Longitude", "Latitude", "City", "RAT"}
     ]
     kpis = sorted([str(c) for c in kpis])
-    kpi_select.options = kpis
-    if kpis and kpi_select.value not in kpis:
-        kpi_select.value = kpis[0]
+    _updating_drilldown = True
+    try:
+        kpi_select.options = kpis
+        if kpis and kpi_select.value not in kpis:
+            kpi_select.value = kpis[0]
+    finally:
+        _updating_drilldown = False
 
 
 def _update_site_view(event=None) -> None:
+    if _applying_profile or _loading_datasets or _updating_drilldown:
+        return
     code = site_select.value
     rat = rat_select.value
     kpi = kpi_select.value
@@ -271,9 +340,28 @@ def _update_site_view(event=None) -> None:
         )
     except Exception:  # noqa: BLE001
         available_sites = set()
-    if available_sites and int(code) not in available_sites:
-        site_select.value = next(iter(sorted(available_sites)))
-        return
+    if available_sites:
+        try:
+            code_int = int(code)
+        except Exception:  # noqa: BLE001
+            code_int = None
+        if code_int is None or code_int not in available_sites:
+            new_code = next(iter(sorted(available_sites)))
+            _set_widget_value(site_select, new_code)
+            code = new_code
+
+    status_df = (
+        current_status_df
+        if isinstance(current_status_df, pd.DataFrame)
+        else pd.DataFrame()
+    )
+    if status_df is None or status_df.empty:
+        site_df = pd.DataFrame()
+    else:
+        site_df = status_df[
+            (status_df["site_code"] == int(code)) & (status_df["RAT"] == rat)
+        ].copy()
+    site_kpi_table.value = site_df
 
     if not kpi or kpi not in d.columns:
         candidate_kpis = [
@@ -283,12 +371,14 @@ def _update_site_view(event=None) -> None:
             not in {"site_code", "date_only", "Longitude", "Latitude", "City", "RAT"}
         ]
         candidate_kpis = sorted([str(c) for c in candidate_kpis])
-        if candidate_kpis:
-            kpi_select.value = candidate_kpis[0]
-        trend_plot_pane.object = None
-        heatmap_plot_pane.object = None
-        hist_plot_pane.object = None
-        return
+        if not candidate_kpis:
+            trend_plot_pane.object = None
+            heatmap_plot_pane.object = None
+            hist_plot_pane.object = None
+            return
+        new_kpi = candidate_kpis[0]
+        _set_widget_value(kpi_select, new_kpi)
+        kpi = new_kpi
     s = d[d["site_code"] == int(code)].copy().sort_values("date_only")
     if s.empty:
         trend_plot_pane.object = None
@@ -615,6 +705,9 @@ def _compute_site_traffic_gb(daily_by_rat: dict[str, pd.DataFrame]) -> pd.DataFr
 def _refresh_filtered_results(event=None) -> None:
     global current_multirat_df, current_top_anomalies_df, current_export_bytes
 
+    if _applying_profile or _loading_datasets:
+        return
+
     if current_multirat_raw is not None and not current_multirat_raw.empty:
         m = _apply_city_filter(current_multirat_raw)
         score_col = (
@@ -667,6 +760,204 @@ def _refresh_presets(event=None) -> None:
         preset_select.value = ""
 
 
+def _refresh_profiles(event=None) -> None:
+    names = list_profiles()
+    profile_select.options = [""] + names
+    if profile_select.value not in profile_select.options:
+        profile_select.value = ""
+
+
+def _current_profile_config() -> dict:
+    cfg: dict = {}
+
+    cfg["analysis_range"] = (
+        [
+            (
+                str(analysis_range.value[0])
+                if analysis_range.value and analysis_range.value[0]
+                else None
+            ),
+            (
+                str(analysis_range.value[1])
+                if analysis_range.value and analysis_range.value[1]
+                else None
+            ),
+        ]
+        if analysis_range.value
+        else [None, None]
+    )
+
+    cfg["baseline_days"] = int(baseline_days.value)
+    cfg["recent_days"] = int(recent_days.value)
+    cfg["rel_threshold_pct"] = float(rel_threshold_pct.value)
+    cfg["min_consecutive_days"] = int(min_consecutive_days.value)
+
+    cfg["min_criticality"] = int(min_criticality.value)
+    cfg["min_anomaly_score"] = int(min_anomaly_score.value)
+    cfg["city_filter"] = str(city_filter.value or "")
+    cfg["top_rat_filter"] = list(top_rat_filter.value) if top_rat_filter.value else []
+    cfg["top_status_filter"] = (
+        list(top_status_filter.value) if top_status_filter.value else []
+    )
+
+    cfg["preset_selected"] = str(preset_select.value or "")
+
+    cfg["drilldown"] = {
+        "site_code": int(site_select.value) if site_select.value is not None else None,
+        "rat": str(rat_select.value or ""),
+        "kpi": str(kpi_select.value or ""),
+    }
+    return cfg
+
+
+def _apply_profile_config(cfg: dict) -> None:
+    global _applying_profile
+    if cfg is None or not isinstance(cfg, dict):
+        return
+
+    _applying_profile = True
+
+    try:
+        try:
+            ar = cfg.get("analysis_range", [None, None])
+            if isinstance(ar, (list, tuple)) and len(ar) == 2 and ar[0] and ar[1]:
+                analysis_range.value = (
+                    pd.to_datetime(ar[0]).date(),
+                    pd.to_datetime(ar[1]).date(),
+                )
+            else:
+                analysis_range.value = None
+        except Exception:  # noqa: BLE001
+            pass
+
+        for w, key, cast in [
+            (baseline_days, "baseline_days", int),
+            (recent_days, "recent_days", int),
+            (rel_threshold_pct, "rel_threshold_pct", float),
+            (min_consecutive_days, "min_consecutive_days", int),
+            (min_criticality, "min_criticality", int),
+            (min_anomaly_score, "min_anomaly_score", int),
+        ]:
+            try:
+                if key in cfg and cfg[key] is not None:
+                    w.value = cast(cfg[key])
+            except Exception:  # noqa: BLE001
+                pass
+
+        try:
+            city_filter.value = str(cfg.get("city_filter", "") or "")
+        except Exception:  # noqa: BLE001
+            pass
+
+        try:
+            tr = cfg.get("top_rat_filter", [])
+            if isinstance(tr, list):
+                top_rat_filter.value = [x for x in tr if x in top_rat_filter.options]
+        except Exception:  # noqa: BLE001
+            pass
+
+        try:
+            ts = cfg.get("top_status_filter", [])
+            if isinstance(ts, list):
+                top_status_filter.value = [
+                    x for x in ts if x in top_status_filter.options
+                ]
+        except Exception:  # noqa: BLE001
+            pass
+
+        try:
+            preset_name = str(cfg.get("preset_selected", "") or "").strip()
+            if preset_name:
+                _refresh_presets()
+                if preset_name in preset_select.options:
+                    preset_select.value = preset_name
+                    try:
+                        _apply_preset()
+                    except Exception:  # noqa: BLE001
+                        pass
+        except Exception:  # noqa: BLE001
+            pass
+
+        drill = (
+            cfg.get("drilldown", {})
+            if isinstance(cfg.get("drilldown", {}), dict)
+            else {}
+        )
+        try:
+            rat = str(drill.get("rat", "") or "")
+            if rat and rat in list(rat_select.options):
+                rat_select.value = rat
+        except Exception:  # noqa: BLE001
+            pass
+        try:
+            sc = drill.get("site_code", None)
+            if sc is not None:
+                site_select.value = int(sc)
+        except Exception:  # noqa: BLE001
+            pass
+        try:
+            kpi = str(drill.get("kpi", "") or "")
+            if kpi:
+                kpi_select.value = kpi
+        except Exception:  # noqa: BLE001
+            pass
+    finally:
+        _applying_profile = False
+
+    _refresh_filtered_results()
+    _update_kpi_options()
+    _update_site_view()
+
+
+def _apply_profile(event=None) -> None:
+    try:
+        if not profile_select.value:
+            return
+        cfg = load_profile(str(profile_select.value))
+        _apply_profile_config(cfg)
+        status_pane.alert_type = "success"
+        status_pane.object = f"Profile applied: {profile_select.value}"
+    except Exception as exc:  # noqa: BLE001
+        status_pane.alert_type = "danger"
+        status_pane.object = f"Error applying profile: {exc}"
+
+
+def _save_profile(event=None) -> None:
+    try:
+        name = (profile_name_input.value or "").strip()
+        if not name:
+            name = str(profile_select.value or "").strip()
+        if not name:
+            raise ValueError("Please provide a profile name")
+
+        cfg = _current_profile_config()
+        save_profile(name, cfg)
+
+        profile_name_input.value = ""
+        _refresh_profiles()
+        profile_select.value = name
+
+        status_pane.alert_type = "success"
+        status_pane.object = f"Profile saved: {name}"
+    except Exception as exc:  # noqa: BLE001
+        status_pane.alert_type = "danger"
+        status_pane.object = f"Error saving profile: {exc}"
+
+
+def _delete_profile(event=None) -> None:
+    try:
+        name = str(profile_select.value or "").strip()
+        if not name:
+            return
+        delete_profile(name)
+        _refresh_profiles()
+        status_pane.alert_type = "success"
+        status_pane.object = f"Profile deleted: {name}"
+    except Exception as exc:  # noqa: BLE001
+        status_pane.alert_type = "danger"
+        status_pane.object = f"Error deleting profile: {exc}"
+
+
 def _apply_preset(event=None) -> None:
     global current_export_bytes
     try:
@@ -746,6 +1037,8 @@ def _delete_selected_preset(event=None) -> None:
 
 
 def load_datasets(event=None) -> None:
+    global _loading_datasets
+    _loading_datasets = True
     try:
         status_pane.alert_type = "primary"
         status_pane.object = "Loading datasets..."
@@ -841,9 +1134,6 @@ def load_datasets(event=None) -> None:
         current_rules_df = rules_df
         rules_table.value = rules_df
 
-        _update_site_options()
-        _update_kpi_options()
-
         status_pane.alert_type = "success"
         status_pane.object = (
             "Datasets loaded. Edit KPI rules if needed, then run health check."
@@ -853,6 +1143,15 @@ def load_datasets(event=None) -> None:
         status_pane.alert_type = "danger"
         status_pane.object = f"Error: {exc}"
 
+    finally:
+        _loading_datasets = False
+        try:
+            _update_site_options()
+            _update_kpi_options()
+            _update_site_view()
+        except Exception:  # noqa: BLE001
+            pass
+
 
 def run_health_check(event=None) -> None:
     try:
@@ -1010,11 +1309,30 @@ 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)
 
+profile_refresh_button.on_click(_refresh_profiles)
+profile_apply_button.on_click(_apply_profile)
+profile_save_button.on_click(_save_profile)
+profile_delete_button.on_click(_delete_profile)
+
 _refresh_presets()
+_refresh_profiles()
 
-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")
+
+def _on_rat_change(event=None) -> None:
+    if _applying_profile or _loading_datasets or _updating_drilldown:
+        return
+    _schedule_drilldown_update(lambda: (_update_kpi_options(), _update_site_view()))
+
+
+def _on_drilldown_change(event=None) -> None:
+    if _applying_profile or _loading_datasets or _updating_drilldown:
+        return
+    _schedule_drilldown_update(_update_site_view)
+
+
+rat_select.param.watch(_on_rat_change, "value")
+site_select.param.watch(_on_drilldown_change, "value")
+kpi_select.param.watch(_on_drilldown_change, "value")
 
 min_criticality.param.watch(_refresh_filtered_results, "value")
 min_anomaly_score.param.watch(_refresh_filtered_results, "value")
@@ -1050,6 +1368,12 @@ sidebar = pn.Column(
     preset_name_input,
     pn.Row(preset_save_button, preset_delete_button),
     "---",
+    pn.pane.Markdown("### Profiles"),
+    profile_select,
+    pn.Row(profile_refresh_button, profile_apply_button),
+    profile_name_input,
+    pn.Row(profile_save_button, profile_delete_button),
+    "---",
     load_button,
     run_button,
     "---",

process_kpi/kpi_health_check/profiles.py

@@ -0,0 +1,71 @@
+import json
+import os
+from datetime import datetime
+
+
+def profiles_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_profiles")
+
+
+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_profiles() -> list[str]:
+    d = profiles_dir()
+    if not os.path.isdir(d):
+        return []
+    out: list[str] = []
+    for fn in os.listdir(d):
+        if fn.lower().endswith(".json"):
+            out.append(os.path.splitext(fn)[0])
+    return sorted(set(out))
+
+
+def load_profile(name: str) -> dict:
+    d = profiles_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)
+    if isinstance(obj, dict) and "config" in obj and isinstance(obj["config"], dict):
+        return obj["config"]
+    if isinstance(obj, dict):
+        return obj
+    return {}
+
+
+def save_profile(name: str, config: dict) -> str:
+    safe = _safe_name(name)
+    if not safe:
+        raise ValueError("Profile name is empty")
+    if config is None or not isinstance(config, dict) or not config:
+        raise ValueError("Profile config is empty")
+
+    d = profiles_dir()
+    os.makedirs(d, exist_ok=True)
+    path = os.path.join(d, f"{safe}.json")
+
+    obj = {
+        "name": safe,
+        "saved_at": datetime.utcnow().isoformat() + "Z",
+        "config": config,
+    }
+
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(obj, f, ensure_ascii=False, indent=2)
+
+    return path
+
+
+def delete_profile(name: str) -> None:
+    d = profiles_dir()
+    safe = _safe_name(name)
+    path = os.path.join(d, f"{safe}.json")
+    if os.path.isfile(path):
+        os.remove(path)