adding CIQ verification app

app.py

@@ -121,6 +121,7 @@ if check_password():
             st.Page("apps/ciq_2g_generator.py", title="🧾 CIQ 2G Generator"),
             st.Page("apps/ciq_3g_generator.py", title="🧾 CIQ 3G Generator"),
             st.Page("apps/ciq_4g_generator.py", title="🧾 CIQ 4G Generator"),
+            st.Page("apps/ciq_verification.py", title="🔍 CIQ Verification"),
             st.Page("apps/core_dump_page.py", title="📠Parse dump core"),
             st.Page("apps/gps_converter.py", title="🧭GPS Converter"),
             st.Page("apps/distance.py", title="🛰Distance Calculator"),

apps/ciq_verification.py

@@ -0,0 +1,229 @@
+"""
+CIQ Verification App
+
+Streamlit interface to verify CIQ parameters against dump database.
+Supports 2G, 3G, and LTE verification with optional file uploads.
+"""
+
+import pandas as pd
+import streamlit as st
+
+from queries.verify_ciq import (
+    generate_verification_report,
+    process_dump_gsm,
+    process_dump_lte,
+    process_dump_wcdma,
+    read_ciq_file,
+    verify_2g,
+    verify_3g,
+    verify_lte,
+)
+
+st.title("🔍 CIQ Verification")
+st.markdown(
+    """
+Vérifiez que les paramètres CIQ correspondent aux valeurs du dump OML.
+- **Dump** : Obligatoire (format .xlsb)
+- **CIQ** : Au moins un fichier CIQ (2G, 3G ou LTE) est requis
+"""
+)
+
+# File uploaders
+st.subheader("📁 Fichiers d'entrée")
+
+dump_file = st.file_uploader(
+    "Upload Dump (xlsb)", type=["xlsb"], key="verify_dump", help="Fichier dump obligatoire"
+)
+
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    ciq_2g_file = st.file_uploader(
+        "CIQ 2G (optionnel)", type=["xlsx", "xls"], key="verify_ciq_2g"
+    )
+
+with col2:
+    ciq_3g_file = st.file_uploader(
+        "CIQ 3G (optionnel)", type=["xlsx", "xls"], key="verify_ciq_3g"
+    )
+
+with col3:
+    ciq_lte_file = st.file_uploader(
+        "CIQ LTE (optionnel)", type=["xlsx", "xls"], key="verify_ciq_lte"
+    )
+
+# Validation
+if dump_file is None:
+    st.info("⬆️ Veuillez uploader le fichier dump (xlsb).")
+    st.stop()
+
+if ciq_2g_file is None and ciq_3g_file is None and ciq_lte_file is None:
+    st.warning("⚠️ Au moins un fichier CIQ (2G, 3G ou LTE) est requis.")
+    st.stop()
+
+# Verify button
+if st.button("🔎 Vérifier", type="primary"):
+    try:
+        results_2g = None
+        results_3g = None
+        results_lte = None
+
+        with st.spinner("Traitement en cours..."):
+            # Process 2G if provided
+            if ciq_2g_file is not None:
+                st.text("📶 Traitement 2G...")
+                dump_gsm = process_dump_gsm(dump_file)
+                dump_file.seek(0)  # Reset file pointer
+                ciq_2g_df = read_ciq_file(ciq_2g_file)
+                results_2g = verify_2g(ciq_2g_df, dump_gsm)
+
+            # Process 3G if provided
+            if ciq_3g_file is not None:
+                st.text("📶 Traitement 3G...")
+                dump_wcdma = process_dump_wcdma(dump_file)
+                dump_file.seek(0)  # Reset file pointer
+                ciq_3g_df = read_ciq_file(ciq_3g_file)
+                results_3g = verify_3g(ciq_3g_df, dump_wcdma)
+
+            # Process LTE if provided
+            if ciq_lte_file is not None:
+                st.text("📶 Traitement LTE...")
+                dump_lte = process_dump_lte(dump_file)
+                dump_file.seek(0)  # Reset file pointer
+                ciq_lte_df = read_ciq_file(ciq_lte_file)
+                results_lte = verify_lte(ciq_lte_df, dump_lte)
+
+            # Generate report
+            sheets, excel_bytes = generate_verification_report(
+                results_2g=results_2g,
+                results_3g=results_3g,
+                results_lte=results_lte,
+            )
+
+            st.session_state["verify_results_2g"] = results_2g
+            st.session_state["verify_results_3g"] = results_3g
+            st.session_state["verify_results_lte"] = results_lte
+            st.session_state["verify_sheets"] = sheets
+            st.session_state["verify_excel_bytes"] = excel_bytes
+
+        st.success("✅ Vérification terminée!")
+
+    except Exception as e:
+        st.error(f"❌ Erreur: {e}")
+        import traceback
+        st.code(traceback.format_exc())
+
+# Display results
+results_2g = st.session_state.get("verify_results_2g")
+results_3g = st.session_state.get("verify_results_3g")
+results_lte = st.session_state.get("verify_results_lte")
+sheets = st.session_state.get("verify_sheets")
+excel_bytes = st.session_state.get("verify_excel_bytes")
+
+
+def display_stats(stats: dict, tech: str):
+    """Display verification statistics."""
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.metric("Total Cells", stats["total_cells"])
+    with col2:
+        st.metric("✅ OK", stats["ok_count"])
+    with col3:
+        st.metric("⚠️ Mismatch", stats["mismatch_count"])
+    with col4:
+        st.metric("❓ Not Found", stats["not_found_count"])
+
+
+def style_results(df: pd.DataFrame) -> pd.DataFrame:
+    """Apply styling to highlight mismatches."""
+    def highlight_status(val):
+        if val == "OK":
+            return "background-color: #d4edda; color: #155724;"
+        elif val == "MISMATCH":
+            return "background-color: #f8d7da; color: #721c24;"
+        elif val == "NOT_FOUND":
+            return "background-color: #fff3cd; color: #856404;"
+        return ""
+
+    def highlight_match(val):
+        if val is True:
+            return "background-color: #d4edda;"
+        elif val is False:
+            return "background-color: #f8d7da;"
+        return ""
+
+    # Get status column name
+    status_col = "Status"
+
+    # Apply styling (using map instead of deprecated applymap)
+    styled = df.style.map(
+        highlight_status, subset=[status_col]
+    )
+
+    # Highlight match columns
+    match_cols = [c for c in df.columns if c.endswith("_Match")]
+    if match_cols:
+        styled = styled.map(highlight_match, subset=match_cols)
+
+    return styled
+
+
+if sheets:
+    st.divider()
+    st.subheader("📊 Résultats de la vérification")
+
+    tabs = []
+    tab_names = []
+
+    if results_2g:
+        tab_names.append("2G")
+    if results_3g:
+        tab_names.append("3G")
+    if results_lte:
+        tab_names.append("LTE")
+
+    if tab_names:
+        tabs = st.tabs(tab_names)
+        tab_idx = 0
+
+        if results_2g:
+            with tabs[tab_idx]:
+                st.markdown("### 📶 Vérification 2G")
+                display_stats(results_2g[1], "2G")
+                st.dataframe(
+                    style_results(results_2g[0]),
+                    use_container_width=True,
+                    hide_index=True,
+                )
+            tab_idx += 1
+
+        if results_3g:
+            with tabs[tab_idx]:
+                st.markdown("### 📶 Vérification 3G")
+                display_stats(results_3g[1], "3G")
+                st.dataframe(
+                    style_results(results_3g[0]),
+                    use_container_width=True,
+                    hide_index=True,
+                )
+            tab_idx += 1
+
+        if results_lte:
+            with tabs[tab_idx]:
+                st.markdown("### 📶 Vérification LTE")
+                display_stats(results_lte[1], "LTE")
+                st.dataframe(
+                    style_results(results_lte[0]),
+                    use_container_width=True,
+                    hide_index=True,
+                )
+
+if excel_bytes:
+    st.divider()
+    st.download_button(
+        label="📥 Télécharger le rapport de vérification (Excel)",
+        data=excel_bytes,
+        file_name="CIQ_Verification_Report.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        type="primary",
+    )

queries/verify_ciq.py

@@ -0,0 +1,514 @@
+"""
+CIQ Verification Module
+
+Compares CIQ parameters (2G/3G/LTE) against dump database values.
+Identifies discrepancies between configured and actual network parameters.
+"""
+
+from io import BytesIO
+from typing import Optional, Tuple
+
+import pandas as pd
+
+
+# Column mappings: CIQ column name -> Dump column name
+CIQ_2G_MAPPING = {
+    "NOM_CELLULE": "name",
+    "LAC": "locationAreaIdLAC",
+    "CI": "cellId",
+}
+
+CIQ_3G_MAPPING = {
+    "NOM_CELLULE": "name",
+    "CELLID": "CId",
+    "SAC": "SAC",
+    "LAC": "LAC",
+    "PSCRAMBCODE": "PriScrCode",
+}
+
+CIQ_LTE_MAPPING = {
+    "CellName": "cellName",
+    "TAC": "tac",
+    "Physical cell ID": "phyCellId",
+    "Root sequence index": "rootSeqIndex",
+}
+
+
+def normalize_cell_name(name: str) -> str:
+    """
+    Normalize cell name by removing _NA suffix if present.
+    Handles both CIQ and dump cell names for comparison.
+
+    Args:
+        name: Cell name to normalize
+
+    Returns:
+        Normalized cell name without _NA suffix
+    """
+    if pd.isna(name):
+        return ""
+    name_str = str(name).strip()
+    if name_str.endswith("_NA"):
+        return name_str[:-3]
+    return name_str
+
+
+def process_dump_gsm(dump_file) -> pd.DataFrame:
+    """
+    Process GSM data from dump file for verification.
+
+    Args:
+        dump_file: Uploaded dump file (xlsb format)
+
+    Returns:
+        DataFrame with GSM cells and parameters
+    """
+    dfs = pd.read_excel(
+        dump_file,
+        sheet_name=["BTS"],
+        engine="calamine",
+        skiprows=[0],
+    )
+
+    df_bts = dfs["BTS"]
+    df_bts.columns = df_bts.columns.str.replace(r"[ ]", "", regex=True)
+
+    # Select only needed columns for verification
+    columns_needed = ["name", "locationAreaIdLAC", "cellId"]
+    df_gsm = df_bts[columns_needed].copy()
+
+    # Normalize cell names
+    df_gsm["name_normalized"] = df_gsm["name"].apply(normalize_cell_name)
+
+    return df_gsm
+
+
+def process_dump_wcdma(dump_file) -> pd.DataFrame:
+    """
+    Process WCDMA data from dump file for verification.
+
+    Args:
+        dump_file: Uploaded dump file (xlsb format)
+
+    Returns:
+        DataFrame with WCDMA cells and parameters
+    """
+    dfs = pd.read_excel(
+        dump_file,
+        sheet_name=["WCEL"],
+        engine="calamine",
+        skiprows=[0],
+    )
+
+    df_wcel = dfs["WCEL"]
+    df_wcel.columns = df_wcel.columns.str.replace(r"[ ]", "", regex=True)
+
+    # Select only needed columns for verification
+    columns_needed = ["name", "CId", "SAC", "LAC", "PriScrCode"]
+    df_wcdma = df_wcel[columns_needed].copy()
+
+    # Normalize cell names
+    df_wcdma["name_normalized"] = df_wcdma["name"].apply(normalize_cell_name)
+
+    return df_wcdma
+
+
+def process_dump_lte(dump_file) -> pd.DataFrame:
+    """
+    Process LTE data from dump file for verification.
+    Uses the existing process_lte module to correctly merge FDD/TDD data.
+    rootSeqIndex is in LNCEL_FDD/LNCEL_TDD, not LNCEL.
+
+    Args:
+        dump_file: Uploaded dump file (xlsb format)
+
+    Returns:
+        DataFrame with LTE cells and parameters
+    """
+    from queries.process_lte import process_lte_data
+
+    # Use existing function which correctly handles FDD/TDD merge
+    lte_dfs = process_lte_data(dump_file)
+    df_fdd = lte_dfs[0]  # FDD cells with rootSeqIndex
+    df_tdd = lte_dfs[1]  # TDD cells with rootSeqIndex
+
+    # Combine FDD and TDD
+    df_lte = pd.concat([df_fdd, df_tdd], ignore_index=True)
+
+    # Select only needed columns for verification
+    # Use cellName or final_name depending on what's available
+    if "cellName" in df_lte.columns:
+        name_col = "cellName"
+    elif "final_name" in df_lte.columns:
+        name_col = "final_name"
+    else:
+        name_col = "name"
+
+    columns_mapping = {
+        name_col: "cellName",
+        "tac": "tac",
+        "phyCellId": "phyCellId",
+        "rootSeqIndex": "rootSeqIndex",
+    }
+
+    # Check each column exists and build result
+    result_data = {}
+    for target_col, source_col in [("cellName", name_col), ("tac", "tac"), 
+                                    ("phyCellId", "phyCellId"), ("rootSeqIndex", "rootSeqIndex")]:
+        if source_col in df_lte.columns:
+            result_data[target_col] = df_lte[source_col]
+        else:
+            result_data[target_col] = None
+
+    df_result = pd.DataFrame(result_data)
+
+    # Normalize cell names
+    df_result["name_normalized"] = df_result["cellName"].apply(normalize_cell_name)
+
+    return df_result
+
+
+def read_ciq_file(ciq_file) -> pd.DataFrame:
+    """
+    Read CIQ Excel file and return as DataFrame.
+
+    Args:
+        ciq_file: Uploaded CIQ Excel file
+
+    Returns:
+        DataFrame with CIQ data
+    """
+    df = pd.read_excel(ciq_file, engine="calamine")
+    return df
+
+
+def verify_2g(
+    ciq_df: pd.DataFrame, dump_df: pd.DataFrame
+) -> Tuple[pd.DataFrame, dict]:
+    """
+    Verify 2G CIQ parameters against dump.
+
+    Args:
+        ciq_df: CIQ 2G DataFrame
+        dump_df: Dump GSM DataFrame
+
+    Returns:
+        Tuple of (comparison DataFrame, summary stats)
+    """
+    # Normalize CIQ cell names
+    ciq_df = ciq_df.copy()
+    ciq_df["name_normalized"] = ciq_df["NOM_CELLULE"].apply(normalize_cell_name)
+
+    # Merge on normalized cell name
+    merged = ciq_df.merge(
+        dump_df,
+        on="name_normalized",
+        how="left",
+        suffixes=("_ciq", "_dump"),
+    )
+
+    # Compare parameters
+    results = []
+    for _, row in merged.iterrows():
+        cell_name = row["NOM_CELLULE"]
+        found_in_dump = not pd.isna(row.get("name"))
+
+        if not found_in_dump:
+            results.append(
+                {
+                    "NOM_CELLULE": cell_name,
+                    "Status": "NOT_FOUND",
+                    "LAC_CIQ": row.get("LAC"),
+                    "LAC_DUMP": None,
+                    "LAC_Match": False,
+                    "CI_CIQ": row.get("CI"),
+                    "CI_DUMP": None,
+                    "CI_Match": False,
+                }
+            )
+        else:
+            lac_match = _compare_values(row.get("LAC"), row.get("locationAreaIdLAC"))
+            ci_match = _compare_values(row.get("CI"), row.get("cellId"))
+            status = "OK" if (lac_match and ci_match) else "MISMATCH"
+
+            results.append(
+                {
+                    "NOM_CELLULE": cell_name,
+                    "Status": status,
+                    "LAC_CIQ": row.get("LAC"),
+                    "LAC_DUMP": row.get("locationAreaIdLAC"),
+                    "LAC_Match": lac_match,
+                    "CI_CIQ": row.get("CI"),
+                    "CI_DUMP": row.get("cellId"),
+                    "CI_Match": ci_match,
+                }
+            )
+
+    result_df = pd.DataFrame(results)
+
+    # Summary stats
+    stats = {
+        "total_cells": len(result_df),
+        "ok_count": len(result_df[result_df["Status"] == "OK"]),
+        "mismatch_count": len(result_df[result_df["Status"] == "MISMATCH"]),
+        "not_found_count": len(result_df[result_df["Status"] == "NOT_FOUND"]),
+    }
+
+    return result_df, stats
+
+
+def verify_3g(
+    ciq_df: pd.DataFrame, dump_df: pd.DataFrame
+) -> Tuple[pd.DataFrame, dict]:
+    """
+    Verify 3G CIQ parameters against dump.
+
+    Args:
+        ciq_df: CIQ 3G DataFrame
+        dump_df: Dump WCDMA DataFrame
+
+    Returns:
+        Tuple of (comparison DataFrame, summary stats)
+    """
+    # Normalize CIQ cell names
+    ciq_df = ciq_df.copy()
+    ciq_df["name_normalized"] = ciq_df["NOM_CELLULE"].apply(normalize_cell_name)
+
+    # Merge on normalized cell name
+    merged = ciq_df.merge(
+        dump_df,
+        on="name_normalized",
+        how="left",
+        suffixes=("_ciq", "_dump"),
+    )
+
+    # Compare parameters
+    results = []
+    for _, row in merged.iterrows():
+        cell_name = row["NOM_CELLULE"]
+        found_in_dump = not pd.isna(row.get("name"))
+
+        if not found_in_dump:
+            results.append(
+                {
+                    "NOM_CELLULE": cell_name,
+                    "Status": "NOT_FOUND",
+                    "CELLID_CIQ": row.get("CELLID"),
+                    "CELLID_DUMP": None,
+                    "CELLID_Match": False,
+                    "SAC_CIQ": row.get("SAC"),
+                    "SAC_DUMP": None,
+                    "SAC_Match": False,
+                    "LAC_CIQ": row.get("LAC"),
+                    "LAC_DUMP": None,
+                    "LAC_Match": False,
+                    "PSC_CIQ": row.get("PSCRAMBCODE"),
+                    "PSC_DUMP": None,
+                    "PSC_Match": False,
+                }
+            )
+        else:
+            cellid_match = _compare_values(row.get("CELLID"), row.get("CId"))
+            sac_match = _compare_values(row.get("SAC_ciq", row.get("SAC")), row.get("SAC_dump", row.get("SAC")))
+            lac_match = _compare_values(row.get("LAC_ciq", row.get("LAC")), row.get("LAC_dump"))
+            psc_match = _compare_values(row.get("PSCRAMBCODE"), row.get("PriScrCode"))
+
+            # Handle potential column name conflicts from merge
+            sac_ciq = row.get("SAC_ciq") if "SAC_ciq" in row.index else row.get("SAC")
+            sac_dump = row.get("SAC_dump") if "SAC_dump" in row.index else None
+            lac_ciq = row.get("LAC_ciq") if "LAC_ciq" in row.index else row.get("LAC")
+            lac_dump = row.get("LAC_dump") if "LAC_dump" in row.index else None
+
+            sac_match = _compare_values(sac_ciq, sac_dump)
+            lac_match = _compare_values(lac_ciq, lac_dump)
+
+            status = (
+                "OK"
+                if (cellid_match and sac_match and lac_match and psc_match)
+                else "MISMATCH"
+            )
+
+            results.append(
+                {
+                    "NOM_CELLULE": cell_name,
+                    "Status": status,
+                    "CELLID_CIQ": row.get("CELLID"),
+                    "CELLID_DUMP": row.get("CId"),
+                    "CELLID_Match": cellid_match,
+                    "SAC_CIQ": sac_ciq,
+                    "SAC_DUMP": sac_dump,
+                    "SAC_Match": sac_match,
+                    "LAC_CIQ": lac_ciq,
+                    "LAC_DUMP": lac_dump,
+                    "LAC_Match": lac_match,
+                    "PSC_CIQ": row.get("PSCRAMBCODE"),
+                    "PSC_DUMP": row.get("PriScrCode"),
+                    "PSC_Match": psc_match,
+                }
+            )
+
+    result_df = pd.DataFrame(results)
+
+    # Summary stats
+    stats = {
+        "total_cells": len(result_df),
+        "ok_count": len(result_df[result_df["Status"] == "OK"]),
+        "mismatch_count": len(result_df[result_df["Status"] == "MISMATCH"]),
+        "not_found_count": len(result_df[result_df["Status"] == "NOT_FOUND"]),
+    }
+
+    return result_df, stats
+
+
+def verify_lte(
+    ciq_df: pd.DataFrame, dump_df: pd.DataFrame
+) -> Tuple[pd.DataFrame, dict]:
+    """
+    Verify LTE CIQ parameters against dump.
+
+    Args:
+        ciq_df: CIQ LTE DataFrame
+        dump_df: Dump LTE DataFrame
+
+    Returns:
+        Tuple of (comparison DataFrame, summary stats)
+    """
+    # Normalize CIQ cell names
+    ciq_df = ciq_df.copy()
+    ciq_df["name_normalized"] = ciq_df["CellName"].apply(normalize_cell_name)
+
+    # Merge on normalized cell name
+    merged = ciq_df.merge(
+        dump_df,
+        on="name_normalized",
+        how="left",
+        suffixes=("_ciq", "_dump"),
+    )
+
+    # Compare parameters
+    results = []
+    for _, row in merged.iterrows():
+        cell_name = row["CellName"]
+        found_in_dump = not pd.isna(row.get("cellName"))
+
+        if not found_in_dump:
+            results.append(
+                {
+                    "CellName": cell_name,
+                    "Status": "NOT_FOUND",
+                    "TAC_CIQ": row.get("TAC"),
+                    "TAC_DUMP": None,
+                    "TAC_Match": False,
+                    "PCI_CIQ": row.get("Physical cell ID"),
+                    "PCI_DUMP": None,
+                    "PCI_Match": False,
+                    "RSI_CIQ": row.get("Root sequence index"),
+                    "RSI_DUMP": None,
+                    "RSI_Match": False,
+                }
+            )
+        else:
+            # Handle potential column name conflicts from merge
+            tac_ciq = row.get("TAC_ciq") if "TAC_ciq" in row.index else row.get("TAC")
+            tac_dump = row.get("tac_dump") if "tac_dump" in row.index else row.get("tac")
+
+            tac_match = _compare_values(tac_ciq, tac_dump)
+            pci_match = _compare_values(row.get("Physical cell ID"), row.get("phyCellId"))
+            rsi_match = _compare_values(
+                row.get("Root sequence index"), row.get("rootSeqIndex")
+            )
+
+            status = "OK" if (tac_match and pci_match and rsi_match) else "MISMATCH"
+
+            results.append(
+                {
+                    "CellName": cell_name,
+                    "Status": status,
+                    "TAC_CIQ": tac_ciq,
+                    "TAC_DUMP": tac_dump,
+                    "TAC_Match": tac_match,
+                    "PCI_CIQ": row.get("Physical cell ID"),
+                    "PCI_DUMP": row.get("phyCellId"),
+                    "PCI_Match": pci_match,
+                    "RSI_CIQ": row.get("Root sequence index"),
+                    "RSI_DUMP": row.get("rootSeqIndex"),
+                    "RSI_Match": rsi_match,
+                }
+            )
+
+    result_df = pd.DataFrame(results)
+
+    # Summary stats
+    stats = {
+        "total_cells": len(result_df),
+        "ok_count": len(result_df[result_df["Status"] == "OK"]),
+        "mismatch_count": len(result_df[result_df["Status"] == "MISMATCH"]),
+        "not_found_count": len(result_df[result_df["Status"] == "NOT_FOUND"]),
+    }
+
+    return result_df, stats
+
+
+def _compare_values(val1, val2) -> bool:
+    """
+    Compare two values for equality, handling NaN and type differences.
+
+    Args:
+        val1: First value
+        val2: Second value
+
+    Returns:
+        True if values are equal, False otherwise
+    """
+    # Handle NaN cases
+    if pd.isna(val1) and pd.isna(val2):
+        return True
+    if pd.isna(val1) or pd.isna(val2):
+        return False
+
+    # Convert to comparable types
+    try:
+        # Try numeric comparison first
+        num1 = float(val1)
+        num2 = float(val2)
+        return num1 == num2
+    except (ValueError, TypeError):
+        # Fall back to string comparison
+        return str(val1).strip() == str(val2).strip()
+
+
+def generate_verification_report(
+    results_2g: Optional[Tuple[pd.DataFrame, dict]] = None,
+    results_3g: Optional[Tuple[pd.DataFrame, dict]] = None,
+    results_lte: Optional[Tuple[pd.DataFrame, dict]] = None,
+) -> Tuple[dict, bytes]:
+    """
+    Generate verification report as Excel file.
+
+    Args:
+        results_2g: Tuple of (DataFrame, stats) for 2G verification
+        results_3g: Tuple of (DataFrame, stats) for 3G verification
+        results_lte: Tuple of (DataFrame, stats) for LTE verification
+
+    Returns:
+        Tuple of (sheets dict, Excel bytes)
+    """
+    sheets = {}
+
+    if results_2g is not None:
+        sheets["2G_Verification"] = results_2g[0]
+
+    if results_3g is not None:
+        sheets["3G_Verification"] = results_3g[0]
+
+    if results_lte is not None:
+        sheets["LTE_Verification"] = results_lte[0]
+
+    # Create Excel file
+    output = BytesIO()
+    with pd.ExcelWriter(output, engine="openpyxl") as writer:
+        for sheet_name, df in sheets.items():
+            df.to_excel(writer, sheet_name=sheet_name, index=False)
+
+    output.seek(0)
+    return sheets, output.getvalue()