Add snapshot comparison, operations queue, geographic map visualization, and KPI correlation analysis features with delta tracking, alert pack export, and interactive map-based drill-down navigation

panel_app/kpi_health_check_panel.py

@@ -1,4 +1,5 @@
 import io
+import json
 import os
 import sys
 import time
@@ -67,7 +68,12 @@ 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_ops_queue_df: pd.DataFrame | None = None
 current_export_bytes: bytes | None = None
+current_alert_pack_bytes: bytes | None = None
+
+current_snapshot: dict | None = None
+current_delta_df: pd.DataFrame | None = None
 
 complaint_sites: set[int] = set()
 
@@ -98,6 +104,7 @@ def _set_widget_value(widget, value) -> None:
             return
     except Exception:  # noqa: BLE001
         pass
+
     _updating_drilldown = True
     try:
         widget.value = value
@@ -167,6 +174,7 @@ def _drilldown_cache_key(site_code: int, rat: str, kpi: str) -> tuple:
         # New cache keys
         str(kpi_group_select.value),
         str(kpi_group_mode.value),
+        str(corr_window_select.value),
     )
 
 
@@ -297,7 +305,7 @@ def _handle_double_click(table_key: str, table: pn.widgets.Tabulator, event) ->
                 pass
             return
 
-        if table_key == "multirat":
+        if table_key in {"multirat", "ops"}:
             site_code = data.get("site_code")
             best_rat = rat_select.value
             try:
@@ -437,6 +445,30 @@ complaint_top_anomalies_table = pn.widgets.Tabulator(
     height=260, sizing_mode="stretch_width", layout="fit_data_table"
 )
 
+ops_queue_table = pn.widgets.Tabulator(
+    height=520, sizing_mode="stretch_width", layout="fit_data_table"
+)
+
+snapshot_file = pn.widgets.FileInput(name="Load snapshot (JSON)", accept=".json")
+snapshot_download = pn.widgets.FileDownload(
+    label="Save snapshot",
+    filename="KPI_Health_Check_Snapshot.json",
+    button_type="primary",
+)
+snapshot_rules_table = pn.widgets.Tabulator(
+    height=220, sizing_mode="stretch_width", layout="fit_data_table"
+)
+snapshot_multirat_table = pn.widgets.Tabulator(
+    height=260, sizing_mode="stretch_width", layout="fit_data_table"
+)
+snapshot_top_table = pn.widgets.Tabulator(
+    height=260, sizing_mode="stretch_width", layout="fit_data_table"
+)
+
+delta_table = pn.widgets.Tabulator(
+    height=320, sizing_mode="stretch_width", layout="fit_data_table"
+)
+
 site_select = pn.widgets.AutocompleteInput(
     name="Select a site (Type to search)",
     options={},
@@ -453,6 +485,12 @@ kpi_compare_norm = pn.widgets.Select(
     name="Normalization", options=["None", "Min-Max", "Z-score"], value="None"
 )
 
+corr_window_select = pn.widgets.Select(
+    name="Correlation window",
+    options=["Full (filtered range)", "Recent", "Baseline"],
+    value="Full (filtered range)",
+)
+
 kpi_group_select = pn.widgets.Select(
     name="KPI Group", options=["All (selected KPIs)"], value="All (selected KPIs)"
 )
@@ -543,17 +581,399 @@ _set_tabulator_pagination(multirat_summary_table, page_size=50)
 _set_tabulator_pagination(top_anomalies_table, page_size=50)
 _set_tabulator_pagination(complaint_multirat_summary_table, page_size=50)
 _set_tabulator_pagination(complaint_top_anomalies_table, page_size=50)
+_set_tabulator_pagination(ops_queue_table, page_size=50)
+_set_tabulator_pagination(snapshot_rules_table, page_size=50)
+_set_tabulator_pagination(snapshot_multirat_table, page_size=50)
+_set_tabulator_pagination(snapshot_top_table, page_size=50)
+_set_tabulator_pagination(delta_table, page_size=50)
 _set_tabulator_pagination(site_kpi_table, page_size=50)
 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)
 
+map_pane = pn.pane.Plotly(sizing_mode="stretch_both", config=PLOTLY_CONFIG)
+map_message = pn.pane.Alert("", alert_type="info", visible=False)
+
+corr_plot_pane = pn.pane.Plotly(sizing_mode="stretch_both", config=PLOTLY_CONFIG)
+corr_message = pn.pane.Alert("", alert_type="info", visible=False)
+
+
+def _coords_by_site() -> pd.DataFrame:
+    rows = []
+    for _, df in (current_daily_by_rat or {}).items():
+        if not isinstance(df, pd.DataFrame) or df.empty:
+            continue
+        cols = [
+            c for c in ["site_code", "Latitude", "Longitude", "City"] if c in df.columns
+        ]
+        if "site_code" not in cols:
+            continue
+        tmp = df[cols].copy()
+        tmp["site_code"] = pd.to_numeric(tmp["site_code"], errors="coerce")
+        tmp = tmp.dropna(subset=["site_code"]).copy()
+        tmp["site_code"] = tmp["site_code"].astype(int)
+        tmp = tmp.drop_duplicates(subset=["site_code"]).copy()
+        rows.append(tmp)
+    if not rows:
+        return pd.DataFrame(columns=["site_code", "Latitude", "Longitude", "City"])
+    out = pd.concat(rows, ignore_index=True)
+    out = out.drop_duplicates(subset=["site_code"]).copy()
+    return out
+
+
+def _map_df() -> pd.DataFrame:
+    base = (
+        current_multirat_df
+        if isinstance(current_multirat_df, pd.DataFrame)
+        else pd.DataFrame()
+    )
+    if base is None or base.empty:
+        base = (
+            current_multirat_raw
+            if isinstance(current_multirat_raw, pd.DataFrame)
+            else pd.DataFrame()
+        )
+    if base is None or base.empty or "site_code" not in base.columns:
+        return pd.DataFrame()
+
+    base = base.copy()
+    base["site_code"] = pd.to_numeric(base["site_code"], errors="coerce")
+    base = base.dropna(subset=["site_code"]).copy()
+    base["site_code"] = base["site_code"].astype(int)
+
+    coords = _coords_by_site()
+    if coords is None or coords.empty:
+        return pd.DataFrame()
+
+    out = pd.merge(base, coords, on="site_code", how="left", suffixes=("", "_coord"))
+    if "City" not in out.columns and "City_coord" in out.columns:
+        out["City"] = out["City_coord"]
+    if "City" in out.columns and "City_coord" in out.columns:
+        out["City"] = out["City"].where(out["City"].notna(), out["City_coord"])
+    return out
+
+
+def _build_map_fig(df_map: pd.DataFrame) -> go.Figure | None:
+    if df_map is None or df_map.empty:
+        return None
+    if "Latitude" not in df_map.columns or "Longitude" not in df_map.columns:
+        return None
+
+    tmp = df_map.copy()
+    tmp["Latitude"] = pd.to_numeric(tmp["Latitude"], errors="coerce")
+    tmp["Longitude"] = pd.to_numeric(tmp["Longitude"], errors="coerce")
+    tmp = tmp.dropna(subset=["Latitude", "Longitude"]).copy()
+    if tmp.empty:
+        return None
+
+    score_col = (
+        "criticality_score_weighted"
+        if "criticality_score_weighted" in tmp.columns
+        else "criticality_score"
+    )
+    if score_col not in tmp.columns:
+        score_col = None
+
+    if score_col is not None:
+        tmp["_score"] = (
+            pd.to_numeric(tmp[score_col], errors="coerce").fillna(0).astype(float)
+        )
+    else:
+        tmp["_score"] = 0.0
+
+    size = (tmp["_score"].clip(lower=0) + 1.0).pow(0.5) * 6.0
+    tmp["_size"] = size.clip(lower=6, upper=28)
+
+    hover_cols = [
+        c
+        for c in [
+            "site_code",
+            "City",
+            score_col,
+            "impacted_rats",
+            "persistent_kpis_total",
+            "degraded_kpis_total",
+        ]
+        if c and c in tmp.columns
+    ]
+    fig = px.scatter_mapbox(
+        tmp,
+        lat="Latitude",
+        lon="Longitude",
+        color="_score" if score_col is not None else None,
+        size="_size",
+        size_max=28,
+        zoom=4,
+        hover_data=hover_cols,
+        custom_data=["site_code"],
+    )
+    fig.update_layout(
+        mapbox_style="open-street-map",
+        margin=dict(l=10, r=10, t=10, b=10),
+        height=700,
+    )
+    if score_col is not None:
+        fig.update_layout(coloraxis_colorbar=dict(title="Score"))
+    return fig
+
+
+def _refresh_map_view(event=None) -> None:
+    df_map = _map_df()
+
+    if df_map is None or df_map.empty:
+        map_pane.object = None
+        map_message.alert_type = "info"
+        map_message.object = "Run health check to display the map (needs Multi-RAT results + coordinates)."
+        map_message.visible = True
+        return
+
+    fig = _build_map_fig(df_map)
+    if fig is None:
+        map_pane.object = None
+        map_message.alert_type = "warning"
+        map_message.object = (
+            "No geo coordinates available (Latitude/Longitude) for current sites."
+        )
+        map_message.visible = True
+        return
+
+    map_message.visible = False
+    map_pane.object = fig
+
+
+def _on_map_click(event) -> None:
+    try:
+        cd = event.new
+        if not isinstance(cd, dict):
+            return
+        pts = cd.get("points", [])
+        if not pts:
+            return
+        p0 = pts[0]
+        custom = p0.get("customdata", None)
+        if not custom:
+            return
+        site_code = custom[0] if isinstance(custom, (list, tuple)) else custom
+        site_code_int = _coerce_int(site_code)
+        if site_code_int is None:
+            return
+
+        best_rat = rat_select.value
+        try:
+            row = None
+            if (
+                isinstance(current_multirat_raw, pd.DataFrame)
+                and not current_multirat_raw.empty
+            ):
+                sel = current_multirat_raw[
+                    current_multirat_raw["site_code"] == int(site_code_int)
+                ]
+                row = sel.iloc[0].to_dict() if not sel.empty else None
+            if row:
+                best_score = -1
+                for r in list(rat_select.options or []):
+                    p = pd.to_numeric(row.get(f"persistent_{r}", 0), errors="coerce")
+                    d = pd.to_numeric(row.get(f"degraded_{r}", 0), errors="coerce")
+                    p = int(p) if pd.notna(p) else 0
+                    d = int(d) if pd.notna(d) else 0
+                    score = p * 2 + d
+                    if score > best_score:
+                        best_score = score
+                        best_rat = r
+        except Exception:  # noqa: BLE001
+            best_rat = rat_select.value
+
+        _apply_drilldown_selection(site_code=site_code_int, rat=best_rat)
+        try:
+            status_pane.alert_type = "primary"
+            status_pane.object = f"Drill-down: site {int(site_code_int)} | {best_rat}"
+        except Exception:  # noqa: BLE001
+            pass
+    except Exception:  # noqa: BLE001
+        return
+
+
+def _compute_delta_df() -> pd.DataFrame:
+    if not isinstance(current_snapshot, dict) or not current_snapshot:
+        return pd.DataFrame()
+
+    snap_rows = current_snapshot.get("multirat_df", [])
+    if not isinstance(snap_rows, list) or not snap_rows:
+        return pd.DataFrame()
+
+    snap = pd.DataFrame(snap_rows)
+    if snap.empty or "site_code" not in snap.columns:
+        return pd.DataFrame()
+
+    cur = (
+        current_multirat_raw
+        if isinstance(current_multirat_raw, pd.DataFrame)
+        else pd.DataFrame()
+    )
+    if cur.empty or "site_code" not in cur.columns:
+        return pd.DataFrame()
+
+    snap["site_code"] = pd.to_numeric(snap["site_code"], errors="coerce")
+    cur["site_code"] = pd.to_numeric(cur["site_code"], errors="coerce")
+
+    snap = snap.dropna(subset=["site_code"]).copy()
+    cur = cur.dropna(subset=["site_code"]).copy()
+
+    snap["site_code"] = snap["site_code"].astype(int)
+    cur["site_code"] = cur["site_code"].astype(int)
+
+    left = snap.set_index("site_code")
+    right = cur.set_index("site_code")
+
+    score_col = (
+        "criticality_score_weighted"
+        if "criticality_score_weighted" in right.columns
+        else "criticality_score"
+    )
+    if score_col not in right.columns:
+        score_col = (
+            "criticality_score" if "criticality_score" in right.columns else None
+        )
+
+    key_cols = [
+        "City",
+        "is_complaint_site",
+        "impacted_rats",
+        "persistent_kpis_total",
+        "degraded_kpis_total",
+        "resolved_kpis_total",
+        "criticality_score",
+        "criticality_score_weighted",
+        "traffic_gb_total",
+    ]
+
+    all_sites = sorted(set(left.index.tolist()) | set(right.index.tolist()))
+    rows = []
+    for sc in all_sites:
+        srow = left.loc[sc] if sc in left.index else None
+        crow = right.loc[sc] if sc in right.index else None
+
+        def _get(row, col):
+            try:
+                if row is None:
+                    return None
+                if isinstance(row, pd.DataFrame):
+                    row = row.iloc[0]
+                return row.get(col, None)
+            except Exception:  # noqa: BLE001
+                return None
+
+        snap_score = _get(srow, score_col) if score_col else None
+        cur_score = _get(crow, score_col) if score_col else None
+        try:
+            snap_score_f = (
+                float(snap_score)
+                if snap_score is not None and pd.notna(snap_score)
+                else 0.0
+            )
+        except Exception:  # noqa: BLE001
+            snap_score_f = 0.0
+        try:
+            cur_score_f = (
+                float(cur_score)
+                if cur_score is not None and pd.notna(cur_score)
+                else 0.0
+            )
+        except Exception:  # noqa: BLE001
+            cur_score_f = 0.0
+
+        if sc not in left.index:
+            change_type = "NEW"
+        elif sc not in right.index:
+            change_type = "MISSING"
+        else:
+            if cur_score_f > snap_score_f:
+                change_type = "SEVERITY_UP"
+            elif cur_score_f < snap_score_f:
+                change_type = "SEVERITY_DOWN"
+            else:
+                change_type = "UNCHANGED"
+
+        row_out = {
+            "site_code": int(sc),
+            "change_type": change_type,
+            "score_snapshot": int(round(snap_score_f)),
+            "score_current": int(round(cur_score_f)),
+            "score_delta": int(round(cur_score_f - snap_score_f)),
+        }
+
+        for c in key_cols:
+            row_out[f"snapshot_{c}"] = _get(srow, c)
+            row_out[f"current_{c}"] = _get(crow, c)
+
+        rows.append(row_out)
+
+    out = pd.DataFrame(rows)
+    if out.empty:
+        return out
+
+    try:
+        q = (city_filter.value or "").strip()
+        if q:
+            city_series = out.get("current_City")
+            if city_series is None:
+                city_series = out.get("snapshot_City")
+            if city_series is not None:
+                out = out[
+                    city_series.astype(str).str.contains(q, case=False, na=False)
+                ].copy()
+    except Exception:  # noqa: BLE001
+        pass
+
+    try:
+        mc = int(min_criticality.value)
+        if mc > 0 and "score_current" in out.columns:
+            out = out[
+                pd.to_numeric(out["score_current"], errors="coerce").fillna(0) >= mc
+            ]
+    except Exception:  # noqa: BLE001
+        pass
+
+    order = {
+        "SEVERITY_UP": 0,
+        "NEW": 1,
+        "SEVERITY_DOWN": 2,
+        "UNCHANGED": 3,
+        "MISSING": 4,
+    }
+    try:
+        out["_order"] = out["change_type"].map(order).fillna(99).astype(int)
+        out = out.sort_values(
+            by=["_order", "score_delta"], ascending=[True, False]
+        ).drop(columns=["_order"], errors="ignore")
+    except Exception:  # noqa: BLE001
+        out = out.sort_values(
+            by=["change_type", "score_delta"], ascending=[True, False]
+        )
+    return out
+
+
+def _refresh_delta_view(event=None) -> None:
+    global current_delta_df
+    try:
+        current_delta_df = _compute_delta_df()
+    except Exception:  # noqa: BLE001
+        current_delta_df = pd.DataFrame()
+    delta_table.value = current_delta_df
+
+
 export_button = pn.widgets.FileDownload(
     label="Download KPI Health Check report",
     filename="KPI_Health_Check_Report.xlsx",
     button_type="primary",
 )
 
+alert_pack_button = pn.widgets.FileDownload(
+    label="Download Alert Pack",
+    filename="KPI_Alert_Pack.xlsx",
+    button_type="primary",
+)
+
 
 def _filtered_daily(df: pd.DataFrame) -> pd.DataFrame:
     if df is None or df.empty:
@@ -830,6 +1250,8 @@ def _update_site_view(event=None) -> None:
         trend_plot_pane.object = None
         heatmap_plot_pane.object = None
         hist_plot_pane.object = None
+        corr_plot_pane.object = None
+        corr_message.visible = False
         return
 
     daily = current_daily_by_rat.get(rat)
@@ -837,6 +1259,8 @@ def _update_site_view(event=None) -> None:
         trend_plot_pane.object = None
         heatmap_plot_pane.object = None
         hist_plot_pane.object = None
+        corr_plot_pane.object = None
+        corr_message.visible = False
         return
 
     d = _filtered_daily(daily)
@@ -849,6 +1273,8 @@ def _update_site_view(event=None) -> None:
         trend_plot_pane.object = None
         heatmap_plot_pane.object = None
         hist_plot_pane.object = None
+        corr_plot_pane.object = None
+        corr_message.visible = False
         return
 
     try:
@@ -877,6 +1303,8 @@ def _update_site_view(event=None) -> None:
         trend_plot_pane.object = None
         heatmap_plot_pane.object = None
         hist_plot_pane.object = None
+        corr_plot_pane.object = None
+        corr_message.visible = False
         _refresh_validation_state()
         return
 
@@ -885,6 +1313,8 @@ def _update_site_view(event=None) -> None:
         trend_plot_pane.object = None
         heatmap_plot_pane.object = None
         hist_plot_pane.object = None
+        corr_plot_pane.object = None
+        corr_message.visible = False
         return
 
     code = code_int
@@ -915,6 +1345,8 @@ def _update_site_view(event=None) -> None:
             trend_plot_pane.object = None
             heatmap_plot_pane.object = None
             hist_plot_pane.object = None
+            corr_plot_pane.object = None
+            corr_message.visible = False
             return
         new_kpi = candidate_kpis[0]
         _set_widget_value(kpi_select, new_kpi)
@@ -924,12 +1356,27 @@ def _update_site_view(event=None) -> None:
         trend_plot_pane.object = None
         heatmap_plot_pane.object = None
         hist_plot_pane.object = None
+        corr_plot_pane.object = None
+        corr_message.visible = False
         return
 
     cache_key = _drilldown_cache_key(int(code_int), str(rat), str(kpi))
     cached = _drilldown_cache_get(cache_key)
     if cached is not None:
-        trend_plot_pane.object, heatmap_plot_pane.object, hist_plot_pane.object = cached
+        try:
+            (
+                trend_plot_pane.object,
+                heatmap_plot_pane.object,
+                hist_plot_pane.object,
+                corr_plot_pane.object,
+                corr_message.object,
+                corr_message.alert_type,
+                corr_message.visible,
+            ) = cached
+        except Exception:  # noqa: BLE001
+            trend_plot_pane.object, heatmap_plot_pane.object, hist_plot_pane.object = (
+                cached
+            )
         return
 
     kpis_to_plot = []
@@ -1008,6 +1455,47 @@ def _update_site_view(event=None) -> None:
     )
     hist_plot_pane.object = _build_baseline_recent_hist(d, int(code_int), str(kpi))
 
+    try:
+        corr_kpis = [str(x) for x in (kpi_compare_select.value or []) if str(x)]
+        if len(corr_kpis) < 2:
+            corr_kpis = [str(x) for x in (kpis_to_plot or []) if str(x)]
+        corr_kpis = [c for c in corr_kpis if c in d.columns]
+        corr_kpis = corr_kpis[:20]
+
+        df_corr = d
+        try:
+            windows = _compute_site_windows(d)
+            if windows is not None:
+                baseline_start, baseline_end, recent_start, recent_end = windows
+                w = str(corr_window_select.value or "")
+                if w.startswith("Recent"):
+                    df_corr = d[
+                        (d["date_only"] >= recent_start)
+                        & (d["date_only"] <= recent_end)
+                    ].copy()
+                elif w.startswith("Baseline"):
+                    df_corr = d[
+                        (d["date_only"] >= baseline_start)
+                        & (d["date_only"] <= baseline_end)
+                    ].copy()
+        except Exception:  # noqa: BLE001
+            df_corr = d
+
+        corr_fig = _build_corr_heatmap(df_corr, int(code_int), corr_kpis)
+        if corr_fig is None:
+            corr_plot_pane.object = None
+            corr_message.alert_type = "info"
+            corr_message.object = "Correlation needs at least 2 KPIs with enough samples for the selected site."
+            corr_message.visible = True
+        else:
+            corr_message.visible = False
+            corr_plot_pane.object = corr_fig
+    except Exception:  # noqa: BLE001
+        corr_plot_pane.object = None
+        corr_message.alert_type = "warning"
+        corr_message.object = "Unable to compute correlation."
+        corr_message.visible = True
+
     try:
         drilldown_export_button.filename = (
             f"KPI_Drilldown_{rat}_site_{int(code_int)}.xlsx"
@@ -1017,7 +1505,15 @@ def _update_site_view(event=None) -> None:
 
     _drilldown_cache_set(
         cache_key,
-        (trend_plot_pane.object, heatmap_plot_pane.object, hist_plot_pane.object),
+        (
+            trend_plot_pane.object,
+            heatmap_plot_pane.object,
+            hist_plot_pane.object,
+            corr_plot_pane.object,
+            corr_message.object,
+            corr_message.alert_type,
+            corr_message.visible,
+        ),
     )
 
 
@@ -1344,6 +1840,72 @@ def _build_baseline_recent_hist(
     return fig
 
 
+def _build_corr_heatmap(
+    daily_filtered: pd.DataFrame,
+    site_code: int,
+    kpis: list[str],
+) -> go.Figure | None:
+    if daily_filtered is None or daily_filtered.empty:
+        return None
+    if not kpis:
+        return None
+    if "site_code" not in daily_filtered.columns:
+        return None
+
+    df_site = daily_filtered[daily_filtered["site_code"] == int(site_code)].copy()
+    if df_site.empty:
+        return None
+
+    cols = [str(c) for c in kpis if str(c) in df_site.columns]
+    cols = [
+        c
+        for c in cols
+        if c not in {"site_code", "date_only", "Longitude", "Latitude", "City", "RAT"}
+    ]
+    cols = list(dict.fromkeys(cols))
+    if len(cols) < 2:
+        return None
+
+    x = df_site[cols].copy()
+    for c in cols:
+        x[c] = pd.to_numeric(x[c], errors="coerce")
+    x = x.dropna(how="all")
+    if x.empty or x.shape[0] < 5:
+        return None
+
+    x = x.dropna(axis=1, how="all")
+    if x.shape[1] < 2:
+        return None
+
+    corr = x.corr(method="pearson")
+    if corr is None or corr.empty:
+        return None
+
+    labels = [str(c) for c in corr.columns.tolist()]
+    z = corr.values
+    fig = go.Figure(
+        data=[
+            go.Heatmap(
+                z=z,
+                x=labels,
+                y=labels,
+                zmin=-1,
+                zmax=1,
+                colorscale="RdBu",
+                reversescale=True,
+                hovertemplate="%{y} vs %{x}<br>corr=%{z:.3f}<extra></extra>",
+            )
+        ]
+    )
+    fig.update_layout(
+        template="plotly_white",
+        title=f"Correlation heatmap (Pearson) - Site {int(site_code)}",
+        height=520,
+        margin=dict(l=60, r=20, t=60, b=60),
+    )
+    return fig
+
+
 def _compute_site_traffic_gb(daily_by_rat: dict[str, pd.DataFrame]) -> pd.DataFrame:
     MB_PER_GB = 1024.0
     rows = []
@@ -1425,7 +1987,8 @@ 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
+    global current_multirat_df, current_top_anomalies_df, current_ops_queue_df
+    global current_export_bytes, current_alert_pack_bytes
 
     if _applying_profile or _loading_datasets:
         return
@@ -1455,6 +2018,70 @@ def _refresh_filtered_results(event=None) -> None:
         current_multirat_df = pd.DataFrame()
         multirat_summary_table.value = current_multirat_df
 
+    if current_multirat_raw is not None and not current_multirat_raw.empty:
+        oq = _apply_city_filter(current_multirat_raw)
+
+        oq_score_col = (
+            "criticality_score_weighted"
+            if "criticality_score_weighted" in oq.columns
+            else "criticality_score"
+        )
+        if oq_score_col in oq.columns:
+            oq = oq[
+                pd.to_numeric(oq[oq_score_col], errors="coerce").fillna(0)
+                >= int(min_criticality.value)
+            ]
+
+        oq = oq.copy()
+        try:
+            oq["priority_score"] = (
+                pd.to_numeric(oq[oq_score_col], errors="coerce")
+                .fillna(0)
+                .round(0)
+                .astype(int)
+                if oq_score_col in oq.columns
+                else 0
+            )
+        except Exception:  # noqa: BLE001
+            oq["priority_score"] = 0
+
+        cols = []
+        for c in [
+            "priority_score",
+            "site_code",
+            "City",
+            "is_complaint_site",
+            "impacted_rats",
+            "persistent_kpis_total",
+            "degraded_kpis_total",
+            "resolved_kpis_total",
+            "criticality_score",
+            "criticality_score_weighted",
+            "traffic_gb_total",
+            "traffic_gb_2G",
+            "traffic_gb_3G",
+            "traffic_gb_LTE",
+        ]:
+            if c in oq.columns and c not in cols:
+                cols.append(c)
+
+        for prefix in ["persistent", "degraded", "resolved"]:
+            for r in ["2G", "3G", "LTE"]:
+                c = f"{prefix}_{r}"
+                if c in oq.columns and c not in cols:
+                    cols.append(c)
+        if cols:
+            oq = oq[cols].copy()
+
+        if not oq.empty and "priority_score" in oq.columns:
+            oq = oq.sort_values(by=["priority_score"], ascending=False)
+
+        current_ops_queue_df = oq
+        ops_queue_table.value = current_ops_queue_df
+    else:
+        current_ops_queue_df = pd.DataFrame()
+        ops_queue_table.value = current_ops_queue_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 (
@@ -1531,6 +2158,12 @@ def _refresh_filtered_results(event=None) -> None:
         complaint_top_anomalies_table.value = pd.DataFrame()
 
     current_export_bytes = None
+    current_alert_pack_bytes = None
+
+    try:
+        _refresh_map_view()
+    except Exception:  # noqa: BLE001
+        pass
 
 
 def _refresh_presets(event=None) -> None:
@@ -1766,7 +2399,7 @@ def _delete_profile(event=None) -> None:
 
 
 def _apply_preset(event=None) -> None:
-    global current_export_bytes
+    global current_export_bytes, current_alert_pack_bytes
     try:
         if not preset_select.value:
             return
@@ -1830,7 +2463,7 @@ def _save_current_rules_as_preset(event=None) -> None:
 
 
 def _delete_selected_preset(event=None) -> None:
-    global current_export_bytes
+    global current_export_bytes, current_alert_pack_bytes
     try:
         name = str(preset_select.value or "").strip()
         if not name:
@@ -1840,6 +2473,7 @@ def _delete_selected_preset(event=None) -> None:
         status_pane.alert_type = "success"
         status_pane.object = f"Preset deleted: {name}"
         current_export_bytes = None
+        current_alert_pack_bytes = None
 
         _invalidate_drilldown_cache(data_changed=True, rules_changed=True)
     except Exception as exc:  # noqa: BLE001
@@ -1857,6 +2491,9 @@ 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_multirat_raw, current_top_anomalies_df, current_top_anomalies_raw
+        global current_ops_queue_df
+        global current_alert_pack_bytes
+        global current_snapshot, current_delta_df
 
         current_daily_by_rat = {}
         current_rules_df = None
@@ -1866,7 +2503,11 @@ def load_datasets(event=None) -> None:
         current_multirat_raw = None
         current_top_anomalies_df = None
         current_top_anomalies_raw = None
+        current_ops_queue_df = None
         current_export_bytes = None
+        current_alert_pack_bytes = None
+        current_snapshot = None
+        current_delta_df = None
 
         _invalidate_drilldown_cache(
             data_changed=True, rules_changed=True, healthcheck_changed=True
@@ -1877,10 +2518,16 @@ def load_datasets(event=None) -> None:
         top_anomalies_table.value = pd.DataFrame()
         complaint_multirat_summary_table.value = pd.DataFrame()
         complaint_top_anomalies_table.value = pd.DataFrame()
+        ops_queue_table.value = pd.DataFrame()
+        delta_table.value = pd.DataFrame()
+        map_pane.object = None
+        map_message.visible = False
         site_kpi_table.value = pd.DataFrame()
         trend_plot_pane.object = None
         heatmap_plot_pane.object = None
         hist_plot_pane.object = None
+        corr_plot_pane.object = None
+        corr_message.visible = False
 
         inputs = {"2G": file_2g, "3G": file_3g, "LTE": file_lte}
         rows = []
@@ -1995,6 +2642,8 @@ def run_health_check(event=None) -> None:
         global current_status_df, current_summary_df, current_export_bytes
         global current_multirat_df, current_multirat_raw
         global current_top_anomalies_df, current_top_anomalies_raw
+        global current_alert_pack_bytes
+        global current_snapshot, current_delta_df
 
         rules_df = (
             rules_table.value
@@ -2109,6 +2758,13 @@ def run_health_check(event=None) -> None:
         _apply_complaint_flags()
 
         current_export_bytes = None
+        current_alert_pack_bytes = None
+
+        try:
+            current_delta_df = _compute_delta_df()
+        except Exception:  # noqa: BLE001
+            current_delta_df = pd.DataFrame()
+        delta_table.value = current_delta_df
 
         _invalidate_drilldown_cache(healthcheck_changed=True)
 
@@ -2154,6 +2810,12 @@ def _build_export_bytes() -> bytes:
             if isinstance(complaint_top_anomalies_table.value, pd.DataFrame)
             else None
         ),
+        (
+            current_ops_queue_df
+            if isinstance(current_ops_queue_df, pd.DataFrame)
+            else None
+        ),
+        (current_delta_df if isinstance(current_delta_df, pd.DataFrame) else None),
     )
 
 
@@ -2167,6 +2829,157 @@ def _export_callback() -> io.BytesIO:
     return io.BytesIO(current_export_bytes or b"")
 
 
+def _build_alert_pack_bytes() -> bytes:
+    params = {
+        "baseline_days": baseline_days.value,
+        "recent_days": recent_days.value,
+        "rel_threshold_pct": rel_threshold_pct.value,
+        "min_consecutive_days": min_consecutive_days.value,
+        "min_criticality": min_criticality.value,
+        "min_anomaly_score": min_anomaly_score.value,
+        "city_filter": str(city_filter.value or ""),
+        "only_complaint_sites": bool(only_complaint_sites.value),
+        "top_rat_filter": ",".join(list(top_rat_filter.value or [])),
+        "top_status_filter": ",".join(list(top_status_filter.value or [])),
+    }
+    params_df = pd.DataFrame(
+        {"key": list(params.keys()), "value": [params[k] for k in params.keys()]}
+    )
+
+    return write_dfs_to_excel(
+        [
+            params_df,
+            (
+                current_ops_queue_df
+                if isinstance(current_ops_queue_df, pd.DataFrame)
+                else pd.DataFrame()
+            ),
+            (
+                current_top_anomalies_df
+                if isinstance(current_top_anomalies_df, pd.DataFrame)
+                else pd.DataFrame()
+            ),
+            (
+                current_summary_df
+                if isinstance(current_summary_df, pd.DataFrame)
+                else pd.DataFrame()
+            ),
+        ],
+        ["Run_Params", "Ops_Queue", "Top_Anomalies", "Site_Summary"],
+        index=False,
+    )
+
+
+def _alert_pack_callback() -> io.BytesIO:
+    global current_alert_pack_bytes
+    if current_alert_pack_bytes is None:
+        try:
+            current_alert_pack_bytes = _build_alert_pack_bytes()
+        except Exception:  # noqa: BLE001
+            current_alert_pack_bytes = b""
+    return io.BytesIO(current_alert_pack_bytes or b"")
+
+
+def _build_snapshot_obj() -> dict:
+    cfg = _current_profile_config()
+
+    rules_df = (
+        rules_table.value
+        if isinstance(rules_table.value, pd.DataFrame)
+        else pd.DataFrame()
+    )
+    multirat_df = (
+        current_multirat_raw
+        if isinstance(current_multirat_raw, pd.DataFrame)
+        else pd.DataFrame()
+    )
+    top_df = (
+        current_top_anomalies_raw
+        if isinstance(current_top_anomalies_raw, pd.DataFrame)
+        else pd.DataFrame()
+    )
+
+    return {
+        "snapshot_version": 1,
+        "created_at": pd.Timestamp.utcnow().isoformat() + "Z",
+        "profile_config": cfg,
+        "rules_df": rules_df.to_dict(orient="records"),
+        "multirat_df": multirat_df.to_dict(orient="records"),
+        "top_anomalies_df": top_df.to_dict(orient="records"),
+    }
+
+
+def _snapshot_download_callback() -> io.BytesIO:
+    b = b""
+    try:
+        obj = _build_snapshot_obj()
+        b = json.dumps(obj, ensure_ascii=False, indent=2).encode("utf-8")
+    except Exception:  # noqa: BLE001
+        b = b""
+    return io.BytesIO(b)
+
+
+def _snapshot_from_bytes(content: bytes) -> dict:
+    try:
+        txt = content.decode("utf-8", errors="ignore")
+        obj = json.loads(txt)
+        return obj if isinstance(obj, dict) else {}
+    except Exception:  # noqa: BLE001
+        return {}
+
+
+def _apply_snapshot_to_ui(obj: dict) -> None:
+    global current_snapshot, current_delta_df, current_export_bytes, current_alert_pack_bytes
+    current_snapshot = obj if isinstance(obj, dict) else {}
+
+    cfg = (
+        current_snapshot.get("profile_config", {})
+        if isinstance(current_snapshot.get("profile_config", {}), dict)
+        else {}
+    )
+    _apply_profile_config(cfg)
+
+    try:
+        r = current_snapshot.get("rules_df", [])
+        snapshot_rules_table.value = pd.DataFrame(r)
+    except Exception:  # noqa: BLE001
+        snapshot_rules_table.value = pd.DataFrame()
+
+    try:
+        m = current_snapshot.get("multirat_df", [])
+        snapshot_multirat_table.value = pd.DataFrame(m)
+    except Exception:  # noqa: BLE001
+        snapshot_multirat_table.value = pd.DataFrame()
+
+    try:
+        t = current_snapshot.get("top_anomalies_df", [])
+        snapshot_top_table.value = pd.DataFrame(t)
+    except Exception:  # noqa: BLE001
+        snapshot_top_table.value = pd.DataFrame()
+
+    try:
+        current_delta_df = _compute_delta_df()
+        delta_table.value = current_delta_df
+    except Exception:  # noqa: BLE001
+        current_delta_df = pd.DataFrame()
+        delta_table.value = current_delta_df
+
+    current_export_bytes = None
+    current_alert_pack_bytes = None
+
+
+def _on_snapshot_upload(event=None) -> None:
+    if not snapshot_file.value:
+        return
+    obj = _snapshot_from_bytes(snapshot_file.value)
+    _apply_snapshot_to_ui(obj)
+    try:
+        status_pane.alert_type = "success"
+        status_pane.object = "Snapshot loaded."
+    except Exception:  # noqa: BLE001
+        pass
+
+
 load_button.on_click(load_datasets)
 run_button.on_click(run_health_check)
 
@@ -2180,11 +2993,21 @@ profile_apply_button.on_click(_apply_profile)
 profile_save_button.on_click(_save_profile)
 profile_delete_button.on_click(_delete_profile)
 
+snapshot_file.param.watch(_on_snapshot_upload, "value")
+snapshot_download.callback = _snapshot_download_callback
+
+map_pane.param.watch(_on_map_click, "click_data")
+
 _refresh_presets()
 _refresh_profiles()
 _refresh_complaint_sites()
 _refresh_validation_state()
 
+try:
+    _refresh_map_view()
+except Exception:  # noqa: BLE001
+    pass
+
 
 def _on_rat_change(event=None) -> None:
     if _applying_profile or _loading_datasets or _updating_drilldown:
@@ -2217,6 +3040,7 @@ site_select.param.watch(_on_drilldown_change, "value")
 kpi_select.param.watch(_on_drilldown_change, "value")
 kpi_compare_select.param.watch(_on_drilldown_change, "value")
 kpi_compare_norm.param.watch(_on_drilldown_change, "value")
+corr_window_select.param.watch(_on_drilldown_change, "value")
 
 analysis_range.param.watch(_on_drilldown_params_change, "value")
 baseline_days.param.watch(_on_drilldown_params_change, "value")
@@ -2226,10 +3050,11 @@ min_consecutive_days.param.watch(_on_drilldown_params_change, "value")
 
 
 def _on_rules_table_change(event=None) -> None:
-    global current_export_bytes
+    global current_export_bytes, current_alert_pack_bytes
     if _applying_profile or _loading_datasets:
         return
     current_export_bytes = None
+    current_alert_pack_bytes = None
     _invalidate_drilldown_cache(rules_changed=True)
 
 
@@ -2263,6 +3088,11 @@ try:
 except Exception:  # noqa: BLE001
     pass
 
+try:
+    ops_queue_table.on_click(lambda e: _handle_double_click("ops", ops_queue_table, e))
+except Exception:  # noqa: BLE001
+    pass
+
 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")
@@ -2270,9 +3100,13 @@ only_complaint_sites.param.watch(_refresh_filtered_results, "value")
 top_rat_filter.param.watch(_refresh_filtered_results, "value")
 top_status_filter.param.watch(_refresh_filtered_results, "value")
 
+min_criticality.param.watch(_refresh_delta_view, "value")
+city_filter.param.watch(_refresh_delta_view, "value")
+
 complaint_sites_file.param.watch(_refresh_complaint_sites, "value")
 
 export_button.callback = _export_callback
+alert_pack_button.callback = _alert_pack_callback
 
 
 def _build_drilldown_export_bytes() -> bytes:
@@ -2462,6 +3296,7 @@ sidebar = pn.Column(
     run_button,
     "---",
     export_button,
+    alert_pack_button,
 )
 
 _tab_overview = pn.Column(
@@ -2487,6 +3322,37 @@ _tab_complaint = pn.Column(
     sizing_mode="stretch_width",
 )
 
+_tab_ops_queue = pn.Column(
+    pn.pane.Markdown("## Ops Queue"),
+    ops_queue_table,
+    sizing_mode="stretch_width",
+)
+
+_tab_snapshot = pn.Column(
+    pn.pane.Markdown("## Snapshot"),
+    pn.Row(snapshot_download, snapshot_file),
+    pn.pane.Markdown("### Snapshot KPI rules"),
+    snapshot_rules_table,
+    pn.pane.Markdown("### Snapshot Multi-RAT"),
+    snapshot_multirat_table,
+    pn.pane.Markdown("### Snapshot Top anomalies"),
+    snapshot_top_table,
+    sizing_mode="stretch_width",
+)
+
+_tab_delta = pn.Column(
+    pn.pane.Markdown("## Delta"),
+    delta_table,
+    sizing_mode="stretch_width",
+)
+
+_tab_map = pn.Column(
+    pn.pane.Markdown("## Map"),
+    map_message,
+    pn.Column(map_pane, sizing_mode="stretch_both", min_height=700),
+    sizing_mode="stretch_both",
+)
+
 _tab_drilldown = pn.Column(
     pn.pane.Markdown("## Drill-down"),
     pn.Row(site_select, rat_select),
@@ -2496,12 +3362,20 @@ _tab_drilldown = pn.Column(
     pn.Column(trend_plot_pane, sizing_mode="stretch_both", min_height=500),
     pn.Column(heatmap_plot_pane, sizing_mode="stretch_both", min_height=400),
     pn.Column(hist_plot_pane, sizing_mode="stretch_both", min_height=400),
+    pn.pane.Markdown("## Correlation"),
+    pn.Row(corr_window_select),
+    corr_message,
+    pn.Column(corr_plot_pane, sizing_mode="stretch_both", min_height=520),
     sizing_mode="stretch_both",
 )
 
 _tabs_main = pn.Tabs(
     ("Overview", _tab_overview),
+    ("Ops Queue", _tab_ops_queue),
     ("Complaint sites only", _tab_complaint),
+    ("Snapshot", _tab_snapshot),
+    ("Delta", _tab_delta),
+    ("Map", _tab_map),
     ("Drill-down", _tab_drilldown),
     dynamic=True,
     sizing_mode="stretch_both",

panel_app/panel_portal.py

@@ -9,10 +9,8 @@ if ROOT_DIR not in sys.path:
 
 pn.extension("plotly", "tabulator")
 
-import kpi_health_check_panel
-
 # Import pages (kept as modules, not nested templates)
-import trafic_analysis_panel
+from panel_app import kpi_health_check_panel, trafic_analysis_panel
 
 PAGES = {
     "📊 Global Traffic Analysis": {

process_kpi/kpi_health_check/export.py

@@ -12,6 +12,8 @@ def build_export_bytes(
     top_anomalies_df: pd.DataFrame | None = None,
     complaint_multirat_df: pd.DataFrame | None = None,
     complaint_top_anomalies_df: pd.DataFrame | None = None,
+    ops_queue_df: pd.DataFrame | None = None,
+    delta_df: pd.DataFrame | None = None,
 ) -> bytes:
     dfs = [
         datasets_df if isinstance(datasets_df, pd.DataFrame) else pd.DataFrame(),
@@ -38,6 +40,8 @@ def build_export_bytes(
             if isinstance(complaint_top_anomalies_df, pd.DataFrame)
             else pd.DataFrame()
         ),
+        ops_queue_df if isinstance(ops_queue_df, pd.DataFrame) else pd.DataFrame(),
+        delta_df if isinstance(delta_df, pd.DataFrame) else pd.DataFrame(),
     ]
     sheet_names = [
         "Datasets",
@@ -48,5 +52,7 @@ def build_export_bytes(
         "Top_Anomalies",
         "Complaint_MultiRAT",
         "Complaint_Top_Anomalies",
+        "Ops_Queue",
+        "Delta",
     ]
     return write_dfs_to_excel(dfs, sheet_names, index=False)