Upload Data_Import.py

Data_Import.py

@@ -8,11 +8,10 @@ st.set_page_config(
     initial_sidebar_state="collapsed",
 )
 
+import pickle
 import numpy as np
 import pandas as pd
 from utilities import set_header, load_local_css, load_authenticator
-import pickle
-
 
 load_local_css("styles.css")
 set_header()
@@ -116,60 +115,6 @@ def files_to_dataframes(uploaded_files):
 
 
 # Function to adjust dataframe granularity
-# def adjust_dataframe_granularity(df, current_granularity, target_granularity):
-#     # Set index
-#     df.set_index("date", inplace=True)
-
-#     # Define aggregation rules for resampling
-#     aggregation_rules = {
-#         col: "sum" if pd.api.types.is_numeric_dtype(df[col]) else "first"
-#         for col in df.columns
-#     }
-
-#     resampled_df = df
-#     if current_granularity == "daily" and target_granularity == "weekly":
-#         resampled_df = df.resample("W-MON").agg(aggregation_rules)
-
-#     elif current_granularity == "daily" and target_granularity == "monthly":
-#         resampled_df = df.resample("MS").agg(aggregation_rules)
-
-#     elif current_granularity == "daily" and target_granularity == "daily":
-#         resampled_df = df.resample("D").agg(aggregation_rules)
-
-#     elif current_granularity in ["weekly", "monthly"] and target_granularity == "daily":
-#         # For higher to lower granularity, distribute numeric and replicate non-numeric values equally across the new period
-#         expanded_data = []
-#         for _, row in df.iterrows():
-#             if current_granularity == "weekly":
-#                 period_range = pd.date_range(start=row.name, periods=7)
-#             elif current_granularity == "monthly":
-#                 period_range = pd.date_range(
-#                     start=row.name, periods=row.name.days_in_month
-#                 )
-
-#             for date in period_range:
-#                 new_row = {}
-#                 for col in df.columns:
-#                     if pd.api.types.is_numeric_dtype(df[col]):
-#                         if current_granularity == "weekly":
-#                             new_row[col] = row[col] / 7
-#                         elif current_granularity == "monthly":
-#                             new_row[col] = row[col] / row.name.days_in_month
-#                     else:
-#                         new_row[col] = row[col]
-#                 expanded_data.append((date, new_row))
-
-#         resampled_df = pd.DataFrame(
-#             [data for _, data in expanded_data],
-#             index=[date for date, _ in expanded_data],
-#         )
-
-#     # Reset index
-#     resampled_df = resampled_df.reset_index().rename(columns={"index": "date"})
-
-#     return resampled_df
-
-
 def adjust_dataframe_granularity(df, current_granularity, target_granularity):
     # Set index
     df.set_index("date", inplace=True)
@@ -229,39 +174,47 @@ def adjust_dataframe_granularity(df, current_granularity, target_granularity):
     return resampled_df
 
 
-# Function to clean and extract unique values of DMA and Panel
+# Function to clean and extract unique values of Panel_1 and Panel_2
 st.cache_resource(show_spinner=False)
 
 
 def clean_and_extract_unique_values(files_dict, selections):
-    all_dma_values = set()
-    all_panel_values = set()
+    all_panel1_values = set()
+    all_panel2_values = set()
 
     for file_name, file_data in files_dict.items():
         df = file_data["df"]
 
-        # 'DMA' and 'Panel' selections
-        selected_dma = selections[file_name].get("DMA")
-        selected_panel = selections[file_name].get("Panel")
+        # 'Panel_1' and 'Panel_2' selections
+        selected_panel1 = selections[file_name].get("Panel_1")
+        selected_panel2 = selections[file_name].get("Panel_2")
 
-        # Clean and standardize DMA column if it exists and is selected
-        if selected_dma and selected_dma != "N/A" and selected_dma in df.columns:
-            df[selected_dma] = (
-                df[selected_dma].str.lower().str.strip().str.replace("_", " ")
+        # Clean and standardize Panel_1 column if it exists and is selected
+        if (
+            selected_panel1
+            and selected_panel1 != "N/A"
+            and selected_panel1 in df.columns
+        ):
+            df[selected_panel1] = (
+                df[selected_panel1].str.lower().str.strip().str.replace("_", " ")
             )
-            all_dma_values.update(df[selected_dma].dropna().unique())
+            all_panel1_values.update(df[selected_panel1].dropna().unique())
 
-        # Clean and standardize Panel column if it exists and is selected
-        if selected_panel and selected_panel != "N/A" and selected_panel in df.columns:
-            df[selected_panel] = (
-                df[selected_panel].str.lower().str.strip().str.replace("_", " ")
+        # Clean and standardize Panel_2 column if it exists and is selected
+        if (
+            selected_panel2
+            and selected_panel2 != "N/A"
+            and selected_panel2 in df.columns
+        ):
+            df[selected_panel2] = (
+                df[selected_panel2].str.lower().str.strip().str.replace("_", " ")
             )
-            all_panel_values.update(df[selected_panel].dropna().unique())
+            all_panel2_values.update(df[selected_panel2].dropna().unique())
 
         # Update the processed DataFrame back in the dictionary
         files_dict[file_name]["df"] = df
 
-    return all_dma_values, all_panel_values
+    return all_panel1_values, all_panel2_values
 
 
 # Function to format values for display
@@ -302,19 +255,21 @@ def apply_granularity_to_all(files_dict, granularity_selection, selections):
     for file_name, file_data in files_dict.items():
         df = file_data["df"].copy()
 
-        # Handling when DMA or Panel might be 'N/A'
-        selected_dma = selections[file_name].get("DMA")
-        selected_panel = selections[file_name].get("Panel")
+        # Handling when Panel_1 or Panel_2 might be 'N/A'
+        selected_panel1 = selections[file_name].get("Panel_1")
+        selected_panel2 = selections[file_name].get("Panel_2")
 
         # Correcting the segment selection logic & handling 'N/A'
-        if selected_dma != "N/A" and selected_panel != "N/A":
-            unique_combinations = df[[selected_dma, selected_panel]].drop_duplicates()
-        elif selected_dma != "N/A":
-            unique_combinations = df[[selected_dma]].drop_duplicates()
-            selected_panel = None  # Ensure Panel is ignored if N/A
-        elif selected_panel != "N/A":
-            unique_combinations = df[[selected_panel]].drop_duplicates()
-            selected_dma = None  # Ensure DMA is ignored if N/A
+        if selected_panel1 != "N/A" and selected_panel2 != "N/A":
+            unique_combinations = df[
+                [selected_panel1, selected_panel2]
+            ].drop_duplicates()
+        elif selected_panel1 != "N/A":
+            unique_combinations = df[[selected_panel1]].drop_duplicates()
+            selected_panel2 = None  # Ensure Panel_2 is ignored if N/A
+        elif selected_panel2 != "N/A":
+            unique_combinations = df[[selected_panel2]].drop_duplicates()
+            selected_panel1 = None  # Ensure Panel_1 is ignored if N/A
         else:
             # If both are 'N/A', process the entire dataframe as is
             df = adjust_dataframe_granularity(
@@ -325,15 +280,15 @@ def apply_granularity_to_all(files_dict, granularity_selection, selections):
 
         transformed_segments = []
         for _, combo in unique_combinations.iterrows():
-            if selected_dma and selected_panel:
+            if selected_panel1 and selected_panel2:
                 segment = df[
-                    (df[selected_dma] == combo[selected_dma])
-                    & (df[selected_panel] == combo[selected_panel])
+                    (df[selected_panel1] == combo[selected_panel1])
+                    & (df[selected_panel2] == combo[selected_panel2])
                 ]
-            elif selected_dma:
-                segment = df[df[selected_dma] == combo[selected_dma]]
-            elif selected_panel:
-                segment = df[df[selected_panel] == combo[selected_panel]]
+            elif selected_panel1:
+                segment = df[df[selected_panel1] == combo[selected_panel1]]
+            elif selected_panel2:
+                segment = df[df[selected_panel2] == combo[selected_panel2]]
 
             # Adjust granularity of the segment
             transformed_segment = adjust_dataframe_granularity(
@@ -353,7 +308,7 @@ st.cache_resource(show_spinner=False)
 
 
 def create_main_dataframe(
-    files_dict, all_dma_values, all_panel_values, granularity_selection
+    files_dict, all_panel1_values, all_panel2_values, granularity_selection
 ):
     # Determine the global start and end dates across all DataFrames
     global_start = min(df["df"]["date"].min() for df in files_dict.values())
@@ -369,18 +324,18 @@ def create_main_dataframe(
     else:  # Default to daily if not weekly or monthly
         date_range = pd.date_range(start=global_start, end=global_end, freq="D")
 
-    # Collect all unique DMA and Panel values, excluding 'N/A'
-    all_dmas = all_dma_values
-    all_panels = all_panel_values
+    # Collect all unique Panel_1 and Panel_2 values, excluding 'N/A'
+    all_panel1s = all_panel1_values
+    all_panel2s = all_panel2_values
 
-    # Dynamically build the list of dimensions (Panel, DMA) to include in the main DataFrame based on availability
+    # Dynamically build the list of dimensions (Panel_1, Panel_2) to include in the main DataFrame based on availability
     dimensions, merge_keys = [], []
-    if all_panels:
-        dimensions.append(all_panels)
-        merge_keys.append("Panel")
-    if all_dmas:
-        dimensions.append(all_dmas)
-        merge_keys.append("DMA")
+    if all_panel1s:
+        dimensions.append(all_panel1s)
+        merge_keys.append("Panel_1")
+    if all_panel2s:
+        dimensions.append(all_panel2s)
+        merge_keys.append("Panel_2")
 
     dimensions.append(date_range)  # Date range is always included
     merge_keys.append("date")  # Date range is always included
@@ -402,28 +357,28 @@ def merge_into_main_df(main_df, files_dict, selections):
     for file_name, file_data in files_dict.items():
         df = file_data["df"].copy()
 
-        # Rename selected DMA and Panel columns if not 'N/A'
-        selected_dma = selections[file_name].get("DMA", "N/A")
-        selected_panel = selections[file_name].get("Panel", "N/A")
-        if selected_dma != "N/A":
-            df.rename(columns={selected_dma: "DMA"}, inplace=True)
-        if selected_panel != "N/A":
-            df.rename(columns={selected_panel: "Panel"}, inplace=True)
+        # Rename selected Panel_1 and Panel_2 columns if not 'N/A'
+        selected_panel1 = selections[file_name].get("Panel_1", "N/A")
+        selected_panel2 = selections[file_name].get("Panel_2", "N/A")
+        if selected_panel1 != "N/A":
+            df.rename(columns={selected_panel1: "Panel_1"}, inplace=True)
+        if selected_panel2 != "N/A":
+            df.rename(columns={selected_panel2: "Panel_2"}, inplace=True)
 
-        # Merge current DataFrame into main_df based on 'date', and where applicable, 'Panel' and 'DMA'
+        # Merge current DataFrame into main_df based on 'date', and where applicable, 'Panel_1' and 'Panel_2'
         merge_keys = ["date"]
-        if "Panel" in df.columns:
-            merge_keys.append("Panel")
-        if "DMA" in df.columns:
-            merge_keys.append("DMA")
+        if "Panel_1" in df.columns:
+            merge_keys.append("Panel_1")
+        if "Panel_2" in df.columns:
+            merge_keys.append("Panel_2")
         main_df = pd.merge(main_df, df, on=merge_keys, how="left")
 
     # After all merges, sort by 'date' and reset index for cleanliness
     sort_by = ["date"]
-    if "Panel" in main_df.columns:
-        sort_by.append("Panel")
-    if "DMA" in main_df.columns:
-        sort_by.append("DMA")
+    if "Panel_1" in main_df.columns:
+        sort_by.append("Panel_1")
+    if "Panel_2" in main_df.columns:
+        sort_by.append("Panel_2")
     main_df.sort_values(by=sort_by, inplace=True)
     main_df.reset_index(drop=True, inplace=True)
 
@@ -478,16 +433,16 @@ def prepare_missing_stats_df(df):
     missing_stats = []
     for column in df.columns:
         if (
-            column == "date" or column == "DMA" or column == "Panel"
-        ):  # Skip Date, DMA and Panel column
+            column == "date" or column == "Panel_2" or column == "Panel_1"
+        ):  # Skip Date, Panel_1 and Panel_2 column
             continue
 
         missing = df[column].isnull().sum()
         pct_missing = round((missing / len(df)) * 100, 2)
 
         # Dynamically assign category based on column name
-        # category = categorize_column(column)
-        category = "Media"
+        category = categorize_column(column)
+        # category = "Media"  # Keep default bin as Media
 
         missing_stats.append(
             {
@@ -527,12 +482,21 @@ def add_api_dataframe_to_dict(main_df, files_dict):
 # Function to reads an API into a DataFrame, parsing specified columns as datetime
 @st.cache_resource(show_spinner=False)
 def read_API_data():
-    return pd.read_excel(r"upf_data_converted.xlsx", parse_dates=["Date"])
+    return pd.read_excel("upf_data_converted.xlsx", parse_dates=["Date"])
 
 
-# Function to set the 'DMA_Panel_Selected' session state variable to False
-def set_DMA_Panel_Selected_false():
-    st.session_state["DMA_Panel_Selected"] = False
+# Function to set the 'Panel_1_Panel_2_Selected' session state variable to False
+def set_Panel_1_Panel_2_Selected_false():
+    st.session_state["Panel_1_Panel_2_Selected"] = False
+
+
+# Function to serialize and save the objects into a pickle file
+@st.cache_resource(show_spinner=False)
+def save_to_pickle(file_path, final_df, bin_dict):
+    # Open the file in write-binary mode and dump the objects
+    with open(file_path, "wb") as f:
+        pickle.dump({"final_df": final_df, "bin_dict": bin_dict}, f)
+        # Data is now saved to file
 
 
 # Initialize 'final_df' in session state
@@ -543,9 +507,9 @@ if "final_df" not in st.session_state:
 if "bin_dict" not in st.session_state:
     st.session_state["bin_dict"] = {}
 
-# Initialize 'DMA_Panel_Selected' in session state
-if "DMA_Panel_Selected" not in st.session_state:
-    st.session_state["DMA_Panel_Selected"] = False
+# Initialize 'Panel_1_Panel_2_Selected' in session state
+if "Panel_1_Panel_2_Selected" not in st.session_state:
+    st.session_state["Panel_1_Panel_2_Selected"] = False
 
 # Page Title
 st.write("")  # Top padding
@@ -553,7 +517,7 @@ st.title("Data Import")
 
 
 #########################################################################################################################################################
-# Create a dictionary to hold all DataFrames and collect user input to specify "DMA" and "Panel" columns for each file
+# Create a dictionary to hold all DataFrames and collect user input to specify "Panel_2" and "Panel_1" columns for each file
 #########################################################################################################################################################
 
 
@@ -568,25 +532,25 @@ uploaded_files = st.file_uploader(
     "Upload additional data",
     type=["xlsx"],
     accept_multiple_files=True,
-    on_change=set_DMA_Panel_Selected_false,
+    on_change=set_Panel_1_Panel_2_Selected_false,
 )
 
 # Custom HTML for upload instructions
 recommendation_html = f"""
 <div style="text-align: justify;">
-<strong>Recommendation:</strong> For optimal processing, please ensure that all uploaded datasets including DMA, Panel, media, internal, and exogenous data adhere to the following guidelines: Each dataset must include a <code>Date</code> column formatted as <code>DD-MM-YYYY</code>, be free of missing values.
+<strong>Recommendation:</strong> For optimal processing, please ensure that all uploaded datasets including panel, media, internal, and exogenous data adhere to the following guidelines: Each dataset must include a <code>Date</code> column formatted as <code>DD-MM-YYYY</code>, be free of missing values.
 </div>
 """
 st.markdown(recommendation_html, unsafe_allow_html=True)
 
-# Choose Date Granularity
-st.markdown("#### Choose Date Granularity")
+# Choose Desired Granularity
+st.markdown("#### Choose Desired Granularity")
 # Granularity Selection
 granularity_selection = st.selectbox(
     "Choose Date Granularity",
     ["Daily", "Weekly", "Monthly"],
     label_visibility="collapsed",
-    on_change=set_DMA_Panel_Selected_false,
+    on_change=set_Panel_1_Panel_2_Selected_false,
 )
 granularity_selection = str(granularity_selection).lower()
 
@@ -606,10 +570,10 @@ if not files_dict:
     st.stop()  # Halts further execution until file is uploaded
 
 
-# Select DMA and Panel columns
-st.markdown("#### Select DMA and Panel columns")
+# Select Panel_1 and Panel_2 columns
+st.markdown("#### Select Panel columns")
 selections = {}
-with st.expander("Select DMA and Panel columns", expanded=False):
+with st.expander("Select Panel columns", expanded=False):
     count = 0  # Initialize counter to manage the visibility of labels and keys
     for file_name, file_data in files_dict.items():
         # Determine visibility of the label based on the count
@@ -621,22 +585,22 @@ with st.expander("Select DMA and Panel columns", expanded=False):
         # Extract non-numeric columns
         non_numeric_cols = file_data["non_numeric"]
 
-        # Prepare DMA and Panel values for dropdown, adding "N/A" as an option
-        dma_values = non_numeric_cols + ["N/A"]
-        panel_values = non_numeric_cols + ["N/A"]
+        # Prepare Panel_1 and Panel_2 values for dropdown, adding "N/A" as an option
+        panel1_values = non_numeric_cols + ["N/A"]
+        panel2_values = non_numeric_cols + ["N/A"]
 
         # Skip if only one option is available
-        if len(dma_values) == 1 and len(panel_values) == 1:
-            selected_dma, selected_panel = "N/A", "N/A"
-            # Update the selections for DMA and Panel for the current file
+        if len(panel1_values) == 1 and len(panel2_values) == 1:
+            selected_panel1, selected_panel2 = "N/A", "N/A"
+            # Update the selections for Panel_1 and Panel_2 for the current file
             selections[file_name] = {
-                "DMA": selected_dma,
-                "Panel": selected_panel,
+                "Panel_1": selected_panel1,
+                "Panel_2": selected_panel2,
             }
             continue
 
-        # Create layout columns for File Name, DMA, and Panel selections
-        file_name_col, DMA_col, Panel_col = st.columns([2, 4, 4])
+        # Create layout columns for File Name, Panel_2, and Panel_1 selections
+        file_name_col, Panel_1_col, Panel_2_col = st.columns([2, 4, 4])
 
         with file_name_col:
             # Display "File Name" label only for the first file
@@ -646,45 +610,45 @@ with st.expander("Select DMA and Panel columns", expanded=False):
                 st.write("")
             st.write(file_name)  # Display the file name
 
-        with DMA_col:
-            # Display a selectbox for DMA values
-            selected_dma = st.selectbox(
-                "Select DMA",
-                dma_values,
-                on_change=set_DMA_Panel_Selected_false,
+        with Panel_1_col:
+            # Display a selectbox for Panel_1 values
+            selected_panel1 = st.selectbox(
+                "Select Panel Level 1",
+                panel2_values,
+                on_change=set_Panel_1_Panel_2_Selected_false,
                 label_visibility=label_visibility,  # Control visibility of the label
-                key=f"DMA_selectbox{count}",  # Ensure unique key for each selectbox
+                key=f"Panel_1_selectbox{count}",  # Ensure unique key for each selectbox
             )
 
-        with Panel_col:
-            # Display a selectbox for Panel values
-            selected_panel = st.selectbox(
-                "Select Panel",
-                panel_values,
-                on_change=set_DMA_Panel_Selected_false,
+        with Panel_2_col:
+            # Display a selectbox for Panel_2 values
+            selected_panel2 = st.selectbox(
+                "Select Panel Level 2",
+                panel1_values,
+                on_change=set_Panel_1_Panel_2_Selected_false,
                 label_visibility=label_visibility,  # Control visibility of the label
-                key=f"Panel_selectbox{count}",  # Ensure unique key for each selectbox
+                key=f"Panel_2_selectbox{count}",  # Ensure unique key for each selectbox
             )
 
-        # Skip processing if the same column is selected for both Panel and DMA due to potential data integrity issues
-        if selected_panel == selected_dma and not (
-            selected_panel == "N/A" and selected_dma == "N/A"
+        # Skip processing if the same column is selected for both Panel_1 and Panel_2 due to potential data integrity issues
+        if selected_panel2 == selected_panel1 and not (
+            selected_panel2 == "N/A" and selected_panel1 == "N/A"
         ):
             st.warning(
-                f"File: {file_name} → The same column cannot serve as both Panel and DMA. Please adjust your selections.",
+                f"File: {file_name} → The same column cannot serve as both Panel_1 and Panel_2. Please adjust your selections.",
             )
-            selected_dma, selected_panel = "N/A", "N/A"
+            selected_panel1, selected_panel2 = "N/A", "N/A"
             st.stop()
 
-        # Update the selections for DMA and Panel for the current file
+        # Update the selections for Panel_1 and Panel_2 for the current file
         selections[file_name] = {
-            "DMA": selected_dma,
-            "Panel": selected_panel,
+            "Panel_1": selected_panel1,
+            "Panel_2": selected_panel2,
         }
 
         count += 1  # Increment the counter after processing each file
 
-    # Accept DMA and Panel selection
+    # Accept Panel_1 and Panel_2 selection
     if st.button("Accept and Process", use_container_width=True):
 
         # Normalize all data to a daily granularity. This initial standardization simplifies subsequent conversions to other levels of granularity
@@ -697,38 +661,38 @@ with st.expander("Select DMA and Panel columns", expanded=False):
             )
 
         st.session_state["files_dict"] = files_dict
-        st.session_state["DMA_Panel_Selected"] = True
+        st.session_state["Panel_1_Panel_2_Selected"] = True
 
 
 #########################################################################################################################################################
-# Display unique DMA and Panel values
+# Display unique Panel_1 and Panel_2 values
 #########################################################################################################################################################
 
 
-# Halts further execution until DMA and Panel columns are selected
-if "files_dict" in st.session_state and st.session_state["DMA_Panel_Selected"]:
+# Halts further execution until Panel_1 and Panel_2 columns are selected
+if "files_dict" in st.session_state and st.session_state["Panel_1_Panel_2_Selected"]:
     files_dict = st.session_state["files_dict"]
 else:
     st.stop()
 
-# Set to store unique values of DMA and Panel
-with st.spinner("Fetching DMA and Panel values..."):
-    all_dma_values, all_panel_values = clean_and_extract_unique_values(
+# Set to store unique values of Panel_1 and Panel_2
+with st.spinner("Fetching Panel values..."):
+    all_panel1_values, all_panel2_values = clean_and_extract_unique_values(
         files_dict, selections
     )
 
-    # List of DMA and Panel columns unique values
-    list_of_all_dma_values = list(all_dma_values)
-    list_of_all_panel_values = list(all_panel_values)
+    # List of Panel_1 and Panel_2 columns unique values
+    list_of_all_panel1_values = list(all_panel1_values)
+    list_of_all_panel2_values = list(all_panel2_values)
 
-    # Format DMA and Panel values for display
-    formatted_dma_values = format_values_for_display(list_of_all_dma_values)
-    formatted_panel_values = format_values_for_display(list_of_all_panel_values)
+    # Format Panel_1 and Panel_2 values for display
+    formatted_panel1_values = format_values_for_display(list_of_all_panel1_values)
+    formatted_panel2_values = format_values_for_display(list_of_all_panel2_values)
 
-# Unique DMA and Panel values
-st.markdown("#### Unique DMA and Panel values")
-# Display DMA and Panel values
-with st.expander("Unique DMA and Panel values"):
+# Unique Panel_1 and Panel_2 values
+st.markdown("#### Unique Panel values")
+# Display Panel_1 and Panel_2 values
+with st.expander("Unique Panel values"):
     st.write("")
     st.markdown(
         f"""
@@ -738,20 +702,20 @@ with st.expander("Unique DMA and Panel values"):
     }}
     </style>
     <div class="justify-text">
-    <strong>Panel Values:</strong> {formatted_panel_values}<br>
-    <strong>DMA Values:</strong> {formatted_dma_values}
+    <strong>Panel Level 1 Values:</strong> {formatted_panel1_values}<br>
+    <strong>Panel Level 2 Values:</strong> {formatted_panel2_values}
     </div>
     """,
         unsafe_allow_html=True,
     )
 
-    # Display total DMA and Panel
+    # Display total Panel_1 and Panel_2
     st.write("")
     st.markdown(
         f"""
     <div style="text-align: justify;">
-        <strong>Number of DMAs detected:</strong> {len(list_of_all_dma_values)}<br>
-        <strong>Number of Panels detected:</strong> {len(list_of_all_panel_values)}
+        <strong>Number of Level 1 Panels detected:</strong> {len(list_of_all_panel1_values)}<br>
+        <strong>Number of Level 2 Panels detected:</strong> {len(list_of_all_panel2_values)}
     </div>
     """,
         unsafe_allow_html=True,
@@ -766,12 +730,12 @@ with st.expander("Unique DMA and Panel values"):
 
 # Merge all DataFrames selected
 main_df = create_main_dataframe(
-    files_dict, all_dma_values, all_panel_values, granularity_selection
+    files_dict, all_panel1_values, all_panel2_values, granularity_selection
 )
 merged_df = merge_into_main_df(main_df, files_dict, selections)
 
 # # Display the merged DataFrame
-# st.markdown("#### Merged DataFrame based on selected DMA and Panel")
+# st.markdown("#### Merged DataFrame based on selected Panel_1 and Panel_2")
 # st.dataframe(merged_df)
 
 
@@ -804,7 +768,7 @@ edited_stats_df = st.data_editor(
                 "Media",
                 "Exogenous",
                 "Internal",
-                "Response_Metric"
+                "Response Metrics",
             ],
             required=True,
             default="Media",
@@ -851,13 +815,12 @@ for i, row in edited_stats_df.iterrows():
         # If it exists, append the current column to the list of variables under this category
         category_dict[category].append(column)
 
-# Add Date, DMA and Panel in category dictionary
+# Add Date, Panel_1 and Panel_12 in category dictionary
 category_dict.update({"Date": ["date"]})
-if "DMA" in final_df.columns:
-    category_dict["DMA"] = ["DMA"]
-
-if "Panel" in final_df.columns:
-    category_dict["Panel"] = ["Panel"]
+if "Panel_1" in final_df.columns:
+    category_dict["Panel Level 1"] = ["Panel_1"]
+if "Panel_2" in final_df.columns:
+    category_dict["Panel Level 2"] = ["Panel_2"]
 
 # Display the dictionary
 st.markdown("#### Variable Category")
@@ -879,13 +842,10 @@ for category, variables in category_dict.items():
 # Store final dataframe and bin dictionary into session state
 st.session_state["final_df"], st.session_state["bin_dict"] = final_df, category_dict
 
-if st.button('Save Changes'):
-    
-    with open("Pickle_files/main_df", 'wb') as f:
-        pickle.dump(st.session_state["final_df"], f)
-    with open("Pickle_files/category_dict",'wb') as c:
-        pickle.dump(st.session_state["bin_dict"],c)
-    st.success('Changes Saved!')
-
-
-
+# Save the DataFrame and dictionary from the session state to the pickle file
+st.write("")
+if st.button("Accept and Save", use_container_width=True):
+    save_to_pickle(
+        "data_import.pkl", st.session_state["final_df"], st.session_state["bin_dict"]
+    )
+    st.toast("💾 Saved Successfully!")