Add Analitic dashboards for each database (Count of NE)

README.md

@@ -43,6 +43,7 @@ You can access the hosted version of the app at [https://davmelchi-db-query.hf.s
 - [x] Add TRX database
 - [x] Add  MRBTS with code
 - [x] Check TCH from MAL sheet
-- [ ] Add dashboards for each database (Count of NE)
+- [x] Add Analitic dashboards for each database (Count of NE)
+- [ ] Improve Dashboard
 - [ ] Add the ability to select columns
 - [ ] Error handling

apps/database_page.py

@@ -3,7 +3,8 @@ from datetime import datetime
 
 import streamlit as st
 
-from queries.process_all_db import process_all_tech_db
+from apps.dump_analysis import dump_analysis_space
+from queries.process_all_db import process_all_tech_db, process_all_tech_db_with_stats
 from queries.process_gsm import process_gsm_data_to_excel
 from queries.process_lte import process_lte_data_to_excel
 
@@ -13,8 +14,8 @@ from queries.process_neighbors import process_neighbors_data_to_excel
 
 # from queries.process_trx import process_trx_with_bts_name_data_to_excel
 from queries.process_wcdma import process_wcdma_data_to_excel
-from utils.check_sheet_exist import Technology, execute_checks_sheets_exist
-from utils.utils_vars import UtilsVars
+from utils.check_sheet_exist import DumpType, Technology, execute_checks_sheets_exist
+from utils.utils_vars import GsmAnalysisData, UtilsVars, WcdmaAnalysisData
 
 st.title("Database processing")
 
@@ -77,6 +78,17 @@ def execute_process_all_tech_db(uploaded_file):
         download_button("All")
 
 
+def execute_process_all_tech_db_with_stats(uploaded_file):
+    if uploaded_file is not None:
+        start_time = time.time()
+        process_all_tech_db_with_stats(uploaded_file)
+        execution_time = time.time() - start_time
+        st.write(
+            f"All databases are generated. Execution time: {execution_time:.2f} seconds"
+        )
+        download_button("All")
+
+
 col1, col2, col3, col4 = st.columns(4)
 col5, col6, col7, col8 = st.columns(4)
 if uploaded_file is not None:
@@ -112,6 +124,7 @@ if uploaded_file is not None:
             and Technology.mrbts == True
             and Technology.mal == True
         ):
+            DumpType.full_dump = True
             with col1:
                 st.button(
                     "Generate All DBs",
@@ -170,3 +183,12 @@ if uploaded_file is not None:
                 )
     except Exception as e:
         st.error(f"Error: {e}")
+
+
+######################## ANALYTICS AND STATS ####################################
+
+if uploaded_file is not None:
+    if DumpType.full_dump == True:
+        if st.button("Generate All DBs and Show Stats"):
+            execute_process_all_tech_db_with_stats(uploaded_file)
+            dump_analysis_space()

apps/dump_analysis.py

@@ -0,0 +1,311 @@
+import streamlit as st
+
+from utils.utils_vars import (
+    GsmAnalysisData,
+    LteFddAnalysisData,
+    LteTddAnalysisData,
+    WcdmaAnalysisData,
+)
+
+":red[**L2300 Parameters:**]"
+
+
+def dump_analysis_space():
+
+    st.title("ANALYTICS DATA")
+
+    ####################### GSM ANALYTICS DATA #######################################
+    st.subheader(":blue[GSM ANALYTICS DATA]")
+
+    (
+        number_of_bsc_col,
+        number_of_cell_col,
+        number_of_site_col,
+        number_of_empty_bts_name_col,
+        number_of_empty_bcf_name_col,
+        number_of_cell_with_empty_bcch_col,
+    ) = st.columns((1, 1, 1, 1, 1, 1))
+
+    with number_of_bsc_col:
+        st.metric("Number of BSC", GsmAnalysisData.total_number_of_bsc)
+    with number_of_cell_col:
+        st.metric("Number of Cell", GsmAnalysisData.total_number_of_cell)
+    with number_of_site_col:
+        st.metric("Number of Site", GsmAnalysisData.number_of_site)
+    with number_of_empty_bts_name_col:
+        st.metric("Empty BTS name", GsmAnalysisData.number_of_bts_name_empty)
+    with number_of_empty_bcf_name_col:
+        st.metric("Empty BCF name", GsmAnalysisData.number_of_bcf_name_empty)
+    with number_of_cell_with_empty_bcch_col:
+        st.metric("Empty BCCH", GsmAnalysisData.number_of_bcch_empty)
+
+    st.markdown("***")
+    st.markdown(":blue[**Number of TRX per BSC**]")
+    number_of_trx_per_bsc_data_col, number_of_trx_per_bsc_plot_col = st.columns(2)
+    with number_of_trx_per_bsc_data_col:
+        st.write(GsmAnalysisData.number_of_trx_per_bsc)
+    with number_of_trx_per_bsc_plot_col:
+        st.bar_chart(GsmAnalysisData.number_of_trx_per_bsc)
+
+    st.markdown("***")
+    st.markdown(":blue[**Number of Site per BSC**]")
+    number_of_site_per_bsc_data_col, number_of_site_per_bsc_plot_col = st.columns(2)
+    with number_of_site_per_bsc_data_col:
+        st.write(GsmAnalysisData.number_of_site_per_bsc)
+    with number_of_site_per_bsc_plot_col:
+        st.bar_chart(GsmAnalysisData.number_of_site_per_bsc)
+
+    st.markdown("***")
+    st.markdown(":blue[**Number of Cell per BSC**]")
+    number_of_cell_per_bsc_data_col, number_of_cell_per_bsc_plot_col = st.columns(2)
+    with number_of_cell_per_bsc_data_col:
+        st.write(GsmAnalysisData.number_of_cell_per_bsc)
+    with number_of_cell_per_bsc_plot_col:
+        st.bar_chart(GsmAnalysisData.number_of_cell_per_bsc)
+
+    st.markdown("***")
+    st.markdown(":blue[**BTS AdminState Distribution**]")
+    bts_administate_distribution_data_col, bts_administate_distribution_plot_col = (
+        st.columns(2)
+    )
+    with bts_administate_distribution_data_col:
+        st.write(GsmAnalysisData.bts_administate_distribution)
+    with bts_administate_distribution_plot_col:
+        st.bar_chart(GsmAnalysisData.bts_administate_distribution)
+
+    st.markdown("***")
+    st.markdown(":blue[**Number of Cell per LAC**]")
+    number_of_cell_per_lac_data_col, number_of_cell_per_lac_plot_col = st.columns(2)
+    with number_of_cell_per_lac_data_col:
+        st.write(GsmAnalysisData.number_of_cell_per_lac)
+    with number_of_cell_per_lac_plot_col:
+        st.bar_chart(GsmAnalysisData.number_of_cell_per_lac)
+
+    st.markdown("***")
+    st.markdown(":blue[**TRX AdminState Distribution**]")
+    trx_administate_distribution_data_col, trx_administate_distribution_plot_col = (
+        st.columns(2)
+    )
+    with trx_administate_distribution_data_col:
+        st.write(GsmAnalysisData.trx_administate_distribution)
+    with trx_administate_distribution_plot_col:
+        st.bar_chart(GsmAnalysisData.trx_administate_distribution)
+
+    ####################### WCDMA ANALYTICS DATA #######################################
+    st.subheader(":green[WCDMA ANALYTICS DATA]")
+
+    (
+        number_of_rnc_col,
+        number_of_cell_col,
+        number_of_site_col,
+        empty_wbts_name_col,
+        empty_wcel_name_col,
+    ) = st.columns(5)
+
+    with number_of_rnc_col:
+        st.metric("Number of RNC", WcdmaAnalysisData.total_number_of_rnc)
+    with number_of_cell_col:
+        st.metric("Number of Cell", WcdmaAnalysisData.total_number_of_wcel)
+    with number_of_site_col:
+        st.metric("Number of Site", WcdmaAnalysisData.number_of_site)
+    with empty_wbts_name_col:
+        st.metric("Empty WBTS name", WcdmaAnalysisData.number_of_empty_wbts_name)
+    with empty_wcel_name_col:
+        st.metric("Empty WCEL name", WcdmaAnalysisData.number_of_empty_wcel_name)
+
+    st.markdown("***")
+
+    st.markdown(":green[**Number of Cell per RNC**]")
+    number_of_cell_per_rnc_data_col, number_of_cell_per_rnc_plot_col = st.columns(2)
+    with number_of_cell_per_rnc_data_col:
+        st.write(WcdmaAnalysisData.number_of_cell_per_rnc)
+    with number_of_cell_per_rnc_plot_col:
+        st.bar_chart(WcdmaAnalysisData.number_of_cell_per_rnc)
+
+    st.markdown("***")
+
+    st.markdown(":green[**Number of Site per RNC**]")
+    number_of_site_per_rnc_data_col, number_of_site_per_rnc_plot_col = st.columns(2)
+    with number_of_site_per_rnc_data_col:
+        st.write(WcdmaAnalysisData.number_of_site_per_rnc)
+    with number_of_site_per_rnc_plot_col:
+        st.bar_chart(WcdmaAnalysisData.number_of_site_per_rnc)
+
+    st.markdown("***")
+
+    st.markdown(":green[**Number of Cell per LAC**]")
+    number_of_cell_per_lac_data_col, number_of_cell_per_lac_plot_col = st.columns(2)
+    with number_of_cell_per_lac_data_col:
+        st.write(WcdmaAnalysisData.number_of_cell_per_lac)
+    with number_of_cell_per_lac_plot_col:
+        st.bar_chart(WcdmaAnalysisData.number_of_cell_per_lac)
+
+    st.markdown("***")
+    st.markdown(":green[**WCEL AdminState Distribution**]")
+    wcel_administate_distribution_data_col, wcel_administate_distribution_plot_col = (
+        st.columns(2)
+    )
+    with wcel_administate_distribution_data_col:
+        st.write(WcdmaAnalysisData.wcel_administate_distribution)
+    with wcel_administate_distribution_plot_col:
+        st.bar_chart(WcdmaAnalysisData.wcel_administate_distribution)
+
+    ####################### LTE FDD ANALYTICS DATA #######################################
+    st.subheader(":red[LTE FDD ANALYTICS DATA]")
+
+    (
+        fdd_total_number_of_lncel_col,
+        fdd_total_number_of_site_col,
+        fdd_number_of_empty_lncel_name_col,
+        fdd_number_of_empty_lncel_cellname_col,
+        fdd_number_of_empty_lnbts_name_col,
+    ) = st.columns(5)
+
+    with fdd_total_number_of_lncel_col:
+        st.metric("Nbr of Lncel", LteFddAnalysisData.total_number_of_lncel)
+    with fdd_total_number_of_site_col:
+        st.metric("Nbr of Site", LteFddAnalysisData.total_number_of_site)
+    with fdd_number_of_empty_lncel_name_col:
+        st.metric("Empty name", LteFddAnalysisData.number_of_empty_lncel_name)
+    with fdd_number_of_empty_lncel_cellname_col:
+        st.metric("Empty Cellname", LteFddAnalysisData.number_of_empty_lncel_cellname)
+    with fdd_number_of_empty_lnbts_name_col:
+        st.metric("Empty LNBTS name", LteFddAnalysisData.number_of_empty_lnbts_name)
+
+    st.markdown("***")
+
+    st.markdown(":red[**Number of Cell per Band**]")
+    fdd_number_of_cell_per_band_data_col, fdd_number_of_cell_per_band_plot_col = (
+        st.columns(2)
+    )
+
+    with fdd_number_of_cell_per_band_data_col:
+        st.write(LteFddAnalysisData.number_of_cell_per_band)
+    with fdd_number_of_cell_per_band_plot_col:
+        st.bar_chart(LteFddAnalysisData.number_of_cell_per_band)
+
+    st.markdown("***")
+
+    st.markdown(":red[**PhyCellId Distribution**]")
+    fdd_phycellid_distribution_data_col, fdd_phycellid_distribution_plot_col = (
+        st.columns(2)
+    )
+    with fdd_phycellid_distribution_data_col:
+        st.write(LteFddAnalysisData.phycellid_distribution)
+    with fdd_phycellid_distribution_plot_col:
+        st.bar_chart(LteFddAnalysisData.phycellid_distribution)
+
+    st.markdown("***")
+
+    st.markdown(":red[**Root Sequence Index Distribution**]")
+    (
+        fdd_rootsequenceindex_distribution_data_col,
+        fdd_rootsequenceindex_distribution_plot_col,
+    ) = st.columns(2)
+    with fdd_rootsequenceindex_distribution_data_col:
+        st.write(LteFddAnalysisData.rootsequenceindex_distribution)
+    with fdd_rootsequenceindex_distribution_plot_col:
+        st.bar_chart(LteFddAnalysisData.rootsequenceindex_distribution)
+
+    st.markdown("***")
+
+    st.markdown(":red[**LNCel Administate Distribution**]")
+    (
+        fdd_lncel_administate_distribution_data_col,
+        fdd_lncel_administate_distribution_plot_col,
+    ) = st.columns(2)
+    with fdd_lncel_administate_distribution_data_col:
+        st.write(LteFddAnalysisData.lncel_administate_distribution)
+    with fdd_lncel_administate_distribution_plot_col:
+        st.bar_chart(LteFddAnalysisData.lncel_administate_distribution)
+
+    st.markdown("***")
+
+    st.markdown(":red[**Number of Cell per TAC**]")
+    fdd_number_of_cell_per_tac_data_col, fdd_number_of_cell_per_tac_plot_col = (
+        st.columns(2)
+    )
+    with fdd_number_of_cell_per_tac_data_col:
+        st.write(LteFddAnalysisData.number_of_cell_per_tac)
+    with fdd_number_of_cell_per_tac_plot_col:
+        st.bar_chart(LteFddAnalysisData.number_of_cell_per_tac)
+
+    ####################### LTE TDD ANALYTICS DATA #######################################
+    st.subheader(":orange[LTE TDD ANALYTICS DATA]")
+
+    (
+        tdd_total_number_of_lncel_col,
+        tdd_total_number_of_site_col,
+        tdd_number_of_empty_lncel_name_col,
+        tdd_number_of_empty_lncel_cellname_col,
+        tdd_number_of_empty_lnbts_name_col,
+    ) = st.columns(5)
+
+    with tdd_total_number_of_lncel_col:
+        st.metric("Nbr of Lncel", LteTddAnalysisData.total_number_of_lncel)
+    with tdd_total_number_of_site_col:
+        st.metric("Nbr of Site", LteTddAnalysisData.total_number_of_site)
+    with tdd_number_of_empty_lncel_name_col:
+        st.metric("Empty name", LteTddAnalysisData.number_of_empty_lncel_name)
+    with tdd_number_of_empty_lncel_cellname_col:
+        st.metric("Empty Cellname", LteTddAnalysisData.number_of_empty_lncel_cellname)
+    with tdd_number_of_empty_lnbts_name_col:
+        st.metric("Empty LNBTS name", LteTddAnalysisData.number_of_empty_lnbts_name)
+
+    st.markdown("***")
+
+    st.markdown(":orange[**Number of Cell per Band**]")
+    tdd_number_of_cell_per_band_data_col, tdd_number_of_cell_per_band_plot_col = (
+        st.columns(2)
+    )
+
+    with tdd_number_of_cell_per_band_data_col:
+        st.write(LteTddAnalysisData.number_of_cell_per_band)
+    with tdd_number_of_cell_per_band_plot_col:
+        st.bar_chart(LteTddAnalysisData.number_of_cell_per_band)
+
+    st.markdown("***")
+
+    st.markdown(":orange[**PhyCellId Distribution**]")
+    tdd_phycellid_distribution_data_col, tdd_phycellid_distribution_plot_col = (
+        st.columns(2)
+    )
+    with tdd_phycellid_distribution_data_col:
+        st.write(LteTddAnalysisData.phycellid_distribution)
+    with tdd_phycellid_distribution_plot_col:
+        st.bar_chart(LteTddAnalysisData.phycellid_distribution)
+
+    st.markdown("***")
+
+    st.markdown(":orange[**Root Sequence Index Distribution**]")
+    (
+        tdd_rootsequenceindex_distribution_data_col,
+        tdd_rootsequenceindex_distribution_plot_col,
+    ) = st.columns(2)
+    with tdd_rootsequenceindex_distribution_data_col:
+        st.write(LteTddAnalysisData.rootsequenceindex_distribution)
+    with tdd_rootsequenceindex_distribution_plot_col:
+        st.bar_chart(LteTddAnalysisData.rootsequenceindex_distribution)
+
+    st.markdown("***")
+
+    st.markdown(":orange[**LNCel Administate Distribution**]")
+    (
+        tdd_lncel_administate_distribution_data_col,
+        tdd_lncel_administate_distribution_plot_col,
+    ) = st.columns(2)
+    with tdd_lncel_administate_distribution_data_col:
+        st.write(LteTddAnalysisData.lncel_administate_distribution)
+    with tdd_lncel_administate_distribution_plot_col:
+        st.bar_chart(LteTddAnalysisData.lncel_administate_distribution)
+
+    st.markdown("***")
+
+    st.markdown(":orange[**Number of Cell per TAC**]")
+    tdd_number_of_cell_per_tac_data_col, tdd_number_of_cell_per_tac_plot_col = (
+        st.columns(2)
+    )
+    with tdd_number_of_cell_per_tac_data_col:
+        st.write(LteTddAnalysisData.number_of_cell_per_tac)
+    with tdd_number_of_cell_per_tac_plot_col:
+        st.bar_chart(LteTddAnalysisData.number_of_cell_per_tac)

queries/process_all_db.py

@@ -1,18 +1,34 @@
-from queries.process_gsm import combined_gsm_database
-from queries.process_lte import process_lte_data
+from queries.process_gsm import combined_gsm_database, gsm_analaysis
+from queries.process_lte import lte_fdd_analaysis, lte_tdd_analaysis, process_lte_data
 from queries.process_mrbts import process_mrbts_data
-from queries.process_wcdma import process_wcdma_data
+from queries.process_wcdma import process_wcdma_data, wcdma_analaysis
 from utils.convert_to_excel import convert_dfs
 from utils.utils_vars import UtilsVars
 
 
-def process_all_tech_db(filepath: str):
+def all_dbs(filepath: str):
     UtilsVars.all_db_dfs.clear()
-    combined_gsm_database(filepath)  # for gsm,mal,trx
+    combined_gsm_database(filepath)
     process_wcdma_data(filepath)
-    process_lte_data(filepath),  # for LTE_FDD, LTE_TDD
+    process_lte_data(filepath),
     process_mrbts_data(filepath)
 
+
+def process_all_tech_db(filepath: str):
+    all_dbs(filepath)
+
+    UtilsVars.final_all_database = convert_dfs(
+        UtilsVars.all_db_dfs,
+        ["GSM", "MAL", "TRX", "WCDMA", "LTE_FDD", "LTE_TDD", "MRBTS"],
+    )
+
+
+def process_all_tech_db_with_stats(filepath: str):
+    all_dbs(filepath)
+    gsm_analaysis(filepath)
+    wcdma_analaysis(filepath)
+    lte_fdd_analaysis(filepath)
+    lte_tdd_analaysis(filepath)
     UtilsVars.final_all_database = convert_dfs(
         UtilsVars.all_db_dfs,
         ["GSM", "MAL", "TRX", "WCDMA", "LTE_FDD", "LTE_TDD", "MRBTS"],

queries/process_gsm.py

@@ -4,7 +4,7 @@ from queries.process_mal import process_mal_data, process_mal_with_bts_name
 from queries.process_trx import process_trx_data, process_trx_with_bts_name
 from utils.config_band import config_band
 from utils.convert_to_excel import convert_dfs, save_dataframe
-from utils.utils_vars import UtilsVars
+from utils.utils_vars import GsmAnalysisData, UtilsVars
 
 BTS_COLUMNS = [
     "ID_BCF",
@@ -82,7 +82,10 @@ def process_gsm_data(file_path: str):
     # Process BTS data
     df_bts = dfs["BTS"]
     df_bts.columns = df_bts.columns.str.replace(r"[ ]", "", regex=True)
-    df_bts["code"] = df_bts["name"].str.split("_").str[0].astype(int)
+    df_bts["code"] = df_bts["name"].str.split("_").str[0]
+    df_bts["code"] = (
+        pd.to_numeric(df_bts["code"], errors="coerce").fillna(0).astype(int)
+    )
     df_bts["Region"] = df_bts["name"].str.split("_").str[1]
     df_bts["ID_BTS"] = df_bts[["BSC", "BCF", "BTS"]].astype(str).apply("_".join, axis=1)
     df_bts["ID_MAL"] = (
@@ -178,3 +181,31 @@ def process_gsm_data_to_excel(file_path: str):
     """
     gsm_dfs = combined_gsm_database(file_path)
     UtilsVars.final_gsm_database = convert_dfs(gsm_dfs, ["GSM", "MAL", "TRX"])
+
+
+#############################GSM ANALYSIS#################################
+
+
+def gsm_analaysis(file_path: str):
+    gsm_df = process_gsm_data(file_path)
+    trx_df = process_trx_with_bts_name(file_path)
+
+    # df to count number of site per bsc
+    df_site_per_bsc = gsm_df[["BSC", "code"]]
+    df_site_per_bsc = df_site_per_bsc.drop_duplicates(subset=["code"], keep="first")
+
+    GsmAnalysisData.total_number_of_bsc = len(gsm_df["BSC"].unique())
+    GsmAnalysisData.total_number_of_cell = len(gsm_df["ID_BTS"].unique())
+    GsmAnalysisData.number_of_site = len(gsm_df["site_name"].unique())
+    GsmAnalysisData.number_of_cell_per_bsc = gsm_df["BSC"].value_counts()
+    GsmAnalysisData.number_of_site_per_bsc = df_site_per_bsc["BSC"].value_counts()
+    GsmAnalysisData.number_of_bts_name_empty = gsm_df["name"].isna().sum()
+    GsmAnalysisData.number_of_bcf_name_empty = gsm_df["site_name"].isna().sum()
+    GsmAnalysisData.number_of_bcch_empty = gsm_df["BCCH"].isna().sum()
+    GsmAnalysisData.bts_administate_distribution = gsm_df["adminState"].value_counts()
+    GsmAnalysisData.trx_administate_distribution = trx_df["adminState"].value_counts()
+    GsmAnalysisData.number_of_trx_per_bsc = trx_df["BSC"].value_counts()
+    #     .rename(columns={"index": "BSC2", "BSC": "count2"})
+    # )
+
+    GsmAnalysisData.number_of_cell_per_lac = gsm_df["locationAreaIdLAC"].value_counts()

queries/process_lte.py

@@ -3,7 +3,7 @@ import pandas as pd
 
 from utils.config_band import config_band
 from utils.convert_to_excel import convert_dfs, save_dataframe
-from utils.utils_vars import UtilsVars, get_band
+from utils.utils_vars import LteFddAnalysisData, LteTddAnalysisData, UtilsVars, get_band
 
 LNCEL_COLUMNS = [
     "ID_LNBTS",
@@ -215,4 +215,42 @@ def process_lte_data_to_excel(file_path: str):
     UtilsVars.final_lte_database = convert_dfs(lte_dfs, ["LTE_FDD", "LTE_TDD"])
 
 
-# process_lte_data(r"data2\20240805_5810_05082024_Dump.xml.gz.xlsb")
+#############################LTE ANALYSIS#################################
+
+
+def lte_fdd_analaysis(file_path: str):
+    df_fdd = process_lte_data(file_path)[0]
+
+    LteFddAnalysisData.total_number_of_lncel = len(df_fdd["ID_LNCEL"].unique())
+    LteFddAnalysisData.total_number_of_site = len(df_fdd["code"].unique())
+    LteFddAnalysisData.number_of_empty_lncel_name = df_fdd["name"].isna().sum()
+    LteFddAnalysisData.number_of_empty_lncel_cellname = df_fdd["cellName"].isna().sum()
+    LteFddAnalysisData.number_of_empty_lnbts_name = df_fdd["lnbts_name"].isna().sum()
+    LteFddAnalysisData.number_of_cell_per_band = df_fdd["band"].value_counts()
+    LteFddAnalysisData.phycellid_distribution = df_fdd["phyCellId"].value_counts()
+    LteFddAnalysisData.rootsequenceindex_distribution = df_fdd[
+        "rootSeqIndex"
+    ].value_counts()
+    LteFddAnalysisData.lncel_administate_distribution = df_fdd[
+        "administrativeState"
+    ].value_counts()
+    LteFddAnalysisData.number_of_cell_per_tac = df_fdd["tac"].value_counts()
+
+
+def lte_tdd_analaysis(file_path: str):
+    df_tdd = process_lte_data(file_path)[1]
+
+    LteTddAnalysisData.total_number_of_lncel = len(df_tdd["ID_LNCEL"].unique())
+    LteTddAnalysisData.total_number_of_site = len(df_tdd["code"].unique())
+    LteTddAnalysisData.number_of_empty_lncel_name = df_tdd["name"].isna().sum()
+    LteTddAnalysisData.number_of_empty_lncel_cellname = df_tdd["cellName"].isna().sum()
+    LteTddAnalysisData.number_of_empty_lnbts_name = df_tdd["lnbts_name"].isna().sum()
+    LteTddAnalysisData.number_of_cell_per_band = df_tdd["band"].value_counts()
+    LteTddAnalysisData.phycellid_distribution = df_tdd["phyCellId"].value_counts()
+    LteTddAnalysisData.rootsequenceindex_distribution = df_tdd[
+        "rootSeqIndex"
+    ].value_counts()
+    LteTddAnalysisData.lncel_administate_distribution = df_tdd[
+        "administrativeState"
+    ].value_counts()
+    LteTddAnalysisData.number_of_cell_per_tac = df_tdd["tac"].value_counts()

queries/process_small_bts.py

@@ -10,7 +10,10 @@ def process_small_bts_data(file_path: str):
     )
     df_bts = dfs["BTS"]
     df_bts.columns = df_bts.columns.str.replace(r"[ ]", "", regex=True)
-    df_bts["code"] = df_bts["name"].str.split("_").str[0].astype(int)
+    df_bts["code"] = df_bts["name"].str.split("_").str[0]
+    df_bts["code"] = (
+        pd.to_numeric(df_bts["code"], errors="coerce").fillna(0).astype(int)
+    )
     df_bts["ID_BTS"] = df_bts[["BSC", "BCF", "BTS"]].astype(str).apply("_".join, axis=1)
     df_bts["ID_MAL"] = df_bts[["BSC", "BTS"]].astype(str).apply("_".join, axis=1)
     df_bts = df_bts[["ID_BTS", "ID_MAL", "code", "name"]]

queries/process_wcdma.py

@@ -3,7 +3,7 @@ import pandas as pd
 from utils.config_band import config_band
 from utils.convert_to_excel import convert_dfs, save_dataframe
 from utils.extract_code import extract_code_from_mrbts
-from utils.utils_vars import UtilsVars
+from utils.utils_vars import UtilsVars, WcdmaAnalysisData
 
 WCEL_COLUMNS = [
     "ID_WBTS",
@@ -84,7 +84,10 @@ def process_wcdma_data(file_path: str):
     # Process BTS data
     df_wcel = dfs["WCEL"]
     df_wcel.columns = df_wcel.columns.str.replace(r"[ ]", "", regex=True)
-    df_wcel["code"] = df_wcel["name"].str.split("_").str[0].astype(int)
+    df_wcel["code"] = df_wcel["name"].str.split("_").str[0]
+    df_wcel["code"] = (
+        pd.to_numeric(df_wcel["code"], errors="coerce").fillna(0).astype(int)
+    )
     df_wcel["Region"] = df_wcel["name"].str.split("_").str[1]
     df_wcel["ID_WCEL"] = (
         df_wcel[["RNC", "WBTS", "WCEL"]].astype(str).apply("_".join, axis=1)
@@ -155,3 +158,32 @@ def process_wcdma_data_to_excel(file_path: str):
     """
     wcdma_dfs = process_wcdma_data(file_path)
     UtilsVars.final_wcdma_database = convert_dfs([wcdma_dfs], ["WCDMA"])
+
+
+############################ANALYTICSS AND STATISTICS############################
+
+
+def wcdma_analaysis(filepath: str):
+    """
+    Process WCDMA data from the specified file path and convert it to Excel format
+
+    Args:
+        filepath (str): The path to the file.
+    """
+    wcdma_df = process_wcdma_data(filepath)
+
+    # df to count number of site per rnc
+    df_site_per_rnc = wcdma_df[["RNC", "code"]]
+    df_site_per_rnc = df_site_per_rnc.drop_duplicates(subset=["code"], keep="first")
+
+    WcdmaAnalysisData.total_number_of_rnc = wcdma_df["RNC"].nunique()
+    WcdmaAnalysisData.total_number_of_wcel = wcdma_df["ID_WCEL"].nunique()
+    WcdmaAnalysisData.number_of_site = len(wcdma_df["site_name"].unique())
+    WcdmaAnalysisData.number_of_site_per_rnc = df_site_per_rnc["RNC"].value_counts()
+    WcdmaAnalysisData.number_of_cell_per_rnc = wcdma_df["RNC"].value_counts()
+    WcdmaAnalysisData.number_of_empty_wbts_name = wcdma_df["site_name"].isnull().sum()
+    WcdmaAnalysisData.number_of_empty_wcel_name = wcdma_df["name"].isnull().sum()
+    WcdmaAnalysisData.wcel_administate_distribution = wcdma_df[
+        "AdminCellState"
+    ].value_counts()
+    WcdmaAnalysisData.number_of_cell_per_lac = wcdma_df["LAC"].value_counts()

utils/check_sheet_exist.py

@@ -1,6 +1,10 @@
 import pandas as pd
 
 
+class DumpType:
+    full_dump = False
+
+
 class Technology:
     gsm = False
     wcdma = False

utils/utils_vars.py

@@ -76,3 +76,59 @@ def get_band(text):
         elif "L800" in text:
             return "L800"
     return np.nan  # or return None
+
+
+##############################STATISTICS############################
+
+
+class GsmAnalysisData:
+    total_number_of_bsc = 0
+    total_number_of_cell = 0
+    number_of_site = 0
+    number_of_cell_per_bsc = pd.DataFrame()
+    number_of_site_per_bsc = pd.DataFrame()
+    number_of_bts_name_empty = 0
+    number_of_bcf_name_empty = 0
+    number_of_bcch_empty = 0
+    bts_administate_distribution = pd.DataFrame()
+    trx_administate_distribution = pd.DataFrame()
+    number_of_trx_per_bsc = pd.DataFrame()
+    number_of_cell_per_lac = pd.DataFrame()
+
+
+class WcdmaAnalysisData:
+    total_number_of_rnc = 0
+    total_number_of_wcel = 0
+    number_of_site = 0
+    number_of_site_per_rnc = 0
+    number_of_cell_per_rnc = pd.DataFrame()
+    number_of_empty_wbts_name = 0
+    number_of_empty_wcel_name = 0
+    wcel_administate_distribution = pd.DataFrame()
+    number_of_cell_per_lac = pd.DataFrame()
+
+
+class LteFddAnalysisData:
+    total_number_of_lncel = 0
+    total_number_of_site = 0
+    number_of_empty_lncel_name = 0
+    number_of_empty_lncel_cellname = 0
+    number_of_empty_lnbts_name = 0
+    number_of_cell_per_band = pd.DataFrame()
+    phycellid_distribution = pd.DataFrame()
+    rootsequenceindex_distribution = pd.DataFrame()
+    lncel_administate_distribution = pd.DataFrame()
+    number_of_cell_per_tac = pd.DataFrame()
+
+
+class LteTddAnalysisData:
+    total_number_of_lncel = 0
+    total_number_of_site = 0
+    number_of_empty_lncel_name = 0
+    number_of_empty_lncel_cellname = 0
+    number_of_empty_lnbts_name = 0
+    number_of_cell_per_band = pd.DataFrame()
+    phycellid_distribution = pd.DataFrame()
+    rootsequenceindex_distribution = pd.DataFrame()
+    lncel_administate_distribution = pd.DataFrame()
+    number_of_cell_per_tac = pd.DataFrame()